How to Export AAA Data to PBS Format: A Complete Guide to Azeroth Auction Assassin

To export Azeroth Auction Assassin (AAA) data to Point Blank Sniper (PBS) format, click the "Convert AAA to PBS" button in the Item tab, which triggers convert_to_pbs() to transform your items_list dictionary into PBS-compatible strings and copies the result to your clipboard.

The ff14-advanced-market-search/azerothauctionassassin repository provides a built-in conversion utility that bridges AAA's JSON-based item storage with Point Blank Sniper's specific import format. This guide explains how to export AAA data to PBS format using both the graphical interface and programmatic methods, referencing the actual implementation in AzerothAuctionAssassin.py.

Understanding the AAA to PBS Export Workflow

The conversion system relies on three core components working sequentially. First, the UI stores your desired items in self.items_list, a dictionary mapping item IDs to price thresholds. When you initiate the export, the convert_to_pbs() slot retrieves this data and passes it to convert_aaa_json_to_pbs(), which constructs properly formatted PBS strings using item name lookups from StaticData/item_names.json.

The PBS format requires a specific structure: Snipe^ItemName;;0;0;0;0;0;0;0;price;;#;;. The converter automatically populates the item name and price fields while maintaining the zero-padding required by Point Blank Sniper's import specification.

Step-by-Step Guide to Export AAA Data to PBS Format

Using the GUI Button

The most common method for exporting AAA data to PBS format uses the built-in conversion button:

1. Launch the application and navigate to the Item tab.
2. Ensure your items are loaded (either via Import Item Data or by manually editing desired_items.json).
3. Click the Convert AAA to PBS button, which triggers the convert_to_pbs() method.

# Button implementation in AzerothAuctionAssassin.py (lines 24-30)

self.convert_to_pbs_button = QPushButton("Convert AAA to PBS")
self.convert_to_pbs_button.setToolTip("Convert your AAA JSON list to PBS format.")
self.convert_to_pbs_button.clicked.connect(self.convert_to_pbs)  # Slot connection

Upon successful conversion, a QMessageBox confirms the operation, and the PBS-formatted string resides in your system clipboard, ready for pasting into Point Blank Sniper.

Programmatic Conversion via Python

For batch processing or automation, you can export AAA data to PBS format programmatically without manual GUI interaction:

import json
from PyQt5.QtWidgets import QApplication
from AzerothAuctionAssassin import AzerothAuctionAssassin

# Load AAA JSON file (same structure as desired_items.json)

with open("my_aaa_items.json", "r") as f:
    aaa_data = json.load(f)  # Format: {"12345": 12.34, "67890": 56.78}

# Initialize UI (required for statistics lookup)

app = QApplication([])
window = AzerothAuctionAssassin()
window.show()

# Populate internal dictionary manually

window.items_list = aaa_data

# Convert to PBS format

pbs_string = window.convert_aaa_json_to_pbs(window.items_list)

print("PBS output ready for clipboard:")
print(pbs_string)

# Example output: Snipe^Mystic Sword;;0;0;0;0;0;0;0;1200;;#;;

This approach bypasses the import dialog while maintaining full access to the conversion logic and item name resolution via item_statistics.

Direct Helper Method Access

If you need only the conversion routine without UI overhead, instantiate the class and call convert_aaa_json_to_pbs() directly:

from AzerothAuctionAssassin import AzerothAuctionAssassin

# Create instance

assistant = AzerothAuctionAssassin()

# Load item statistics for name resolution

assistant.item_statistics = assistant.load_item_statistics()

# Example AAA data

aaa_items = {"12345": 1500, "67890": 3000}

# Generate PBS string

pbs_output = assistant.convert_aaa_json_to_pbs(aaa_items)

print(pbs_output)

Note that load_item_statistics() populates the internal lookup table from StaticData/item_names.json, which is essential for resolving numeric item IDs to human-readable names required by the PBS format.

Technical Implementation Details

The conversion logic in AzerothAuctionAssassin.py (lines 2438–2462) handles the transformation through several precise steps:

def convert_aaa_json_to_pbs(self, json_data):
    pbs_entries = []
    
    for item_id, price in json_data.items():
        # Resolve item name from statistics

        if item_id in self.item_statistics:
            item_name = self.item_statistics[item_id]
            
            # Construct PBS entry: Snipe^Name;;0;0;0;0;0;0;0;price;;#;;

            pbs_entry = f"Snipe^{item_name};;0;0;0;0;0;0;0;{price};;#;;"
            pbs_entries.append(pbs_entry)
    
    # Join all entries into single PBS payload

    return "".join(pbs_entries)

The method skips entries without matching names in item_statistics, ensuring that only valid, name-resolvable items appear in the final PBS output. The convert_to_pbs() wrapper (lines 2423–2435) then copies this string to the clipboard using QApplication.clipboard().setText(), completing the export workflow.

Summary

• Primary Method: Click Convert AAA to PBS in the Item tab to instantly convert your items_list to PBS format and copy it to the clipboard.
• Data Structure: The converter reads self.items_list (a dictionary of item_id: price pairs) and resolves names via StaticData/item_names.json.
• Output Format: PBS entries follow the pattern Snipe^ItemName;;0;0;0;0;0;0;0;price;;#;;, concatenated into a single import string.
• Automation: Use convert_aaa_json_to_pbs() programmatically for batch processing without GUI interaction.

Frequently Asked Questions

What is the PBS format used for in Azeroth Auction Assassin?

The PBS (Point Blank Sniper) format is a specific text format required by the Point Blank Sniper addon for World of Warcraft. When you export AAA data to PBS format, you generate a string that the addon can parse to configure its sniping behavior, allowing you to import your Azeroth Auction Assassin price thresholds directly into the in-game tool.

Can I convert AAA data to PBS format without opening the GUI?

Yes, you can export AAA data to PBS format programmatically by instantiating the AzerothAuctionAssassin class and calling convert_aaa_json_to_pbs() directly. You must first populate self.item_statistics by calling load_item_statistics() or manually loading StaticData/item_names.json, as the converter requires item name resolution to generate valid PBS strings.

Why are some items missing from my PBS export?

Items missing from the PBS output typically lack entries in the item_statistics dictionary, which is populated from StaticData/item_names.json. The convert_aaa_json_to_pbs() method explicitly skips any item_id that cannot be resolved to a human-readable name, ensuring that only valid, name-resolvable items appear in the final Point Blank Sniper import string.

How do I batch process multiple AAA JSON files into PBS format?

To batch export AAA data to PBS format, write a Python script that iterates over your JSON files, instantiates AzerothAuctionAssassin once to load the statistics cache, and calls convert_aaa_json_to_pbs() for each file's contents. Write the returned PBS strings to separate text files or combine them depending on your Point Blank Sniper import requirements. This approach avoids the overhead of launching the GUI for each conversion.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}