Convert USPCA certified ammo list to spreadsheets.

ammo-page2file.py

#! /usr/bin/env -S uv run --verbose --script --managed-python --python=3.13
"""
USPSA Ammunition List Scraper

This script downloads the USPSA Certified Ammunition webpage, parses ammunition
entries including manufacturer, caliber, velocity, and bullet weight, and saves
them as CSV files. It also separates data into per-caliber files, including
Major-classified and PCC ammunition.

Debugging prints are included to help validate parsed content.
"""

# from stdlib
import re

# /// script
# requires-python = ">=3.10"
# dependencies = [
#   "beautifulsoup4==4.13.*",
#   "cloudscraper25==2.6.*",
#   "pandas==2.2.*",
# ]
# [tool.flake8]
# max-line-length = 127
# ///
# packages `uv run` will auto-install
from bs4 import BeautifulSoup as bs
import cloudscraper25
import pandas as pd


def main() -> None:
    """
    Entry point: download the USPSA ammunition page and extract ammo data.
    """

    url = 'https://uspsa.org/ammunition'
    output_file = 'uspsa_ammo_list.csv'
    scrape_uspsa_ammo_list(url, output_file)


def scrape_uspsa_ammo_list(url: str, output_file: str) -> None:
    """
    Fetches the USPSA ammunition page, parses ammo cards, and writes CSVs.

    Args:
        url: The URL to scrape.
        output_file: Path to save the combined CSV file.

    Debug output will show each parsed row.
    """

    scraper = cloudscraper25.create_scraper()  # debug=True)
    resp = scraper.get(url)
    resp.raise_for_status()  # Raise an error if the request fails

    soup = bs(resp.content, 'html.parser')

    ammo_cards = soup.find_all('div', class_='card')
    rows: list[list[str]] = []
    for card in ammo_cards:
        # print(card)

        # Each card contains multiple ammo entries (li elements)
        for li in card.select('ul.list-group li'):
            # print(li)
            manufacturer = li.get('data-make', '').strip()

            # Extract ammo name and SKU
            name_div = li.find('div', style='font-weight:bold;')
            if name_div is None:
                print(f"WARN: Missing ammo name in li: {li}")
                continue

            name_text = name_div.get_text(strip=True)
            match = re.match(r'^(.*?)\s*\(SKU\s+(.*?)\)$', name_text)
            ammo_name, sku = match.groups() if match else (name_text, '')

            # Default values
            caliber_text = velocity = weight = ''

            # Extract data from the row of divs
            for div in li.select('div.row div.col-md-3'):
                # print(f"div:|{div}|")

                text = div.get_text(strip=True)
                key, _, val = text.partition('-')
                key, val = key.strip(), val.strip()

                match key:
                    case 'Caliber':
                        caliber_text = val
                    case 'Velocity':
                        velocity = val.split()[0]
                    case 'Bullet Weight':
                        weight = val.split()[0]

            # Normalize caliber for CSV file naming
            caliber = normalize_caliber(caliber_text, ammo_name)

            print(manufacturer, ammo_name, caliber_text)
            rows.append([manufacturer, ammo_name, sku, caliber_text, caliber, velocity, weight])

    # Create a DataFrame
    header_list = ['Manufacturer', 'Ammo Name', 'SKU', 'Caliber Text', 'Caliber', 'Velocity', 'Weight']
    df = pd.DataFrame(rows, columns=header_list)

    # Save full list as the default CSV
    df.to_csv(output_file, index=False)
    print(f"Scraped data saved to {output_file}")

    # Create separate CSVs for each normalized caliber
    for caliber, group_df in df.groupby('Caliber'):
        # Skip empty or unknown calibers
        if not caliber:
            print(f"WARN: Missing caliber in {group_df}")
            continue
        out_file = f"ammo_caliber_{caliber}.csv"
        group_df.drop(columns=['Caliber']).to_csv(out_file, index=False)
        print(f"Saved {len(group_df)} rows to {out_file}")


def normalize_caliber(caliber: str, ammo_name: str) -> str:
    """
    Classify the caliber into one of: 9mm, .38, .40, .45, PCC, or their Major variants.

    Args:
        caliber: Caliber text from the webpage.
        ammo_name: Full ammo name for additional clues (like "Major" or "PCC").

    Returns:
        Normalized classification string.
    """

    c = caliber.lower().replace(' ', '').replace('_', '').replace('-', '')
    a = ammo_name.lower()

    if 'pcc' in a:
        return 'PCC'

    if 'major' in a or 'major' in c:
        if '9mm' in c:
            return '9mm_Maj'
        elif '38' in c:
            return '.38_Maj'
        elif '40' in c:
            return '.40_Maj'
        elif '45' in c:
            return '.45_Maj'
        else:
            return 'unk_Maj'

    if c.startswith('9mm') or '9mm' in c:
        return '9mm'
    elif c.startswith('.38') or '38' in c:
        return '.38'
    elif c.startswith('.40') or '40' in c:
        return '.40'
    elif c.startswith('.45') or '45' in c:
        return '.45'
    else:
        return 'unknown'


if __name__ == '__main__':
    main()

ammo_caliber_.38.csv

ammo_caliber_.38_Maj.csv

ammo_caliber_.40.csv

ammo_caliber_.40_Maj.csv

ammo_caliber_.45.csv

ammo_caliber_.45_Maj.csv

ammo_caliber_9mm.csv

ammo_caliber_9mm_Maj.csv

ammo_caliber_PCC.csv

uspsa_ammo_list.csv