aus-identity 0.1.0__tar.gz

aus_identity-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,56 @@
+name: release
+
+# Push a tag like v0.1.0 → wheel is built and published to PyPI via
+# Trusted Publishing (no API token in repo secrets). One-time setup:
+#   1. https://pypi.org/manage/account/publishing/ (pending publishers,
+#      since the project doesn't exist on PyPI yet for the first publish)
+#   2. Add a "pending publisher":
+#        PyPI project    = aus-identity
+#        owner           = Bigred97
+#        repository      = aus-identity
+#        workflow        = release.yml
+#        environment     = pypi
+#   3. Create a `pypi` environment in repo Settings → Environments
+#      (no secrets needed; the environment scopes the OIDC token).
+# Then any `git push origin vX.Y.Z` triggers this job.
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/aus-identity/
+    permissions:
+      id-token: write     # required for Trusted Publishing OIDC
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Sanity-check the tag matches pyproject.toml
+        run: |
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+          PYPROJECT_VERSION=$(uv run python -c "import tomllib,sys; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          if [ "$TAG_VERSION" != "$PYPROJECT_VERSION" ]; then
+            echo "::error::Tag $GITHUB_REF_NAME does not match pyproject version $PYPROJECT_VERSION"
+            exit 1
+          fi
+          echo "Releasing version $PYPROJECT_VERSION"
+
+      - name: Build wheel + sdist
+        run: uv build
+
+      - name: Publish to PyPI (Trusted Publishing)
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

aus_identity-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,50 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+      - name: Sync dependencies
+        run: uv sync --extra dev
+      - name: Install package
+        run: uv pip install -e .
+      - name: Run unit tests
+        run: uv run pytest -q
+
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+      - name: Build wheel + sdist
+        run: uv build
+      - name: Verify wheel installs cleanly
+        run: |
+          uv run --isolated --with ./dist/*.whl python -c \
+            "from aus_identity import postcode_to_state, normalize_state; \
+             assert postcode_to_state('2000') == 'NSW'; \
+             assert normalize_state('Tassie') == 'TAS'; \
+             print('OK')"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

aus_identity-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.swp
+.DS_Store

aus_identity-0.1.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## 0.1.0 (2026-05-15)
+
+Initial release. The cross-source identity layer for the Australian public-data MCP stack and anyone else building software that touches multiple AU government data sources.
+
+### Added
+
+- **`postcode_to_state(postcode)`** — map a 4-digit AU postcode to its state/territory code (`NSW`, `VIC`, `QLD`, `SA`, `WA`, `TAS`, `NT`, `ACT`). Handles the ACT-inside-NSW exceptions (`0200-0299`, `2600-2618`, `2900-2920`) correctly. Accepts string or int input.
+- **`normalize_postcode(postcode)`** — coerce a string or int into canonical 4-digit form. Pads 3-digit shorthand (`"800"` → `"0800"`); strips whitespace; rejects bools to avoid `True` → `"0001"`.
+- **`is_valid_postcode(postcode)`** — boolean check, never raises. Safe for use as a filter on user input.
+- **`normalize_state(state)`** — coerce short codes (`"NSW"`), lowercase variants (`"nsw"`), full names (`"New South Wales"`), ISO 3166-2 (`"AU-NSW"`), aliases (`"Tassie"`), and underscore-separated LLM payloads (`"New_South_Wales"`) to the canonical short code.
+- **`state_full_name(state)`** — return the official long-form name for a state code.
+- **`STATE_NAMES`** — public mapping of canonical short codes to full names (8 jurisdictions).
+
+### Test coverage
+
+- 64 unit tests covering normalisation edge cases, ACT/NSW boundary, alias resolution, type validation, and round-trip stability between short codes and full names.
+
+### Out of scope for v0.1
+
+Planned for v0.2:
+
+- ASGS 2021 crosswalk: postcode ↔ SA1/SA2/SA3/SA4 ↔ GCCSA ↔ state
+- ABN ↔ ACN ↔ company-name fuzzy matching
+- ANZSIC industry codes
+- ANZSCO occupation codes
+
+These require larger reference datasets (~3,000-17,000 rows). They will likely ship as separate sub-modules (`aus_identity.asgs`, `aus_identity.abn`, etc.) so the core install stays lean.

aus_identity-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Harry Vass
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aus_identity-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: aus-identity
+Version: 0.1.0
+Summary: Cross-source join keys for Australian public data — postcode ↔ state crosswalks, state-code normalisation, more coming. Foundation for tools that talk to multiple AU government data sources.
+Project-URL: Homepage, https://github.com/Bigred97/aus-identity
+Project-URL: Issues, https://github.com/Bigred97/aus-identity/issues
+Author: Harry Vass
+License: MIT
+License-File: LICENSE
+Keywords: abs,anzsco,anzsic,asgs,ato,australia,crosswalk,geography,identity,postcode,state
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# aus-identity
+
+[![PyPI](https://img.shields.io/pypi/v/aus-identity.svg)](https://pypi.org/project/aus-identity/)
+[![Python](https://img.shields.io/pypi/pyversions/aus-identity.svg)](https://pypi.org/project/aus-identity/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Cross-source join keys for Australian public data. The foundation layer for tools that need to talk to multiple AU government data sources at once (ABS demographics + ATO income + APRA banking + au-weather climate + ASIC company register + RBA monetary stats), or for any application that has to map between Australia's postcode and state/territory conventions.
+
+## What it does today (v0.1.0)
+
+- **Postcode → state**: `postcode_to_state("2000")` → `"NSW"`. Handles the three ACT-inside-NSW carve-outs (`0200-0299`, `2600-2618`, `2900-2920`) correctly.
+- **Postcode normalisation**: accept `"2000"`, `2000`, `" 2000 "`, `"0800"`, `800` — all return canonical 4-digit string form.
+- **Postcode validation**: `is_valid_postcode(x)` returns a boolean and never raises — safe for filtering arbitrary input.
+- **State code normalisation**: `normalize_state("nsw")` / `normalize_state("New South Wales")` / `normalize_state("AU-VIC")` / `normalize_state("Tassie")` → canonical short code.
+- **Full state name**: `state_full_name("NSW")` → `"New South Wales"`.
+
+## Install
+
+```bash
+pip install aus-identity
+# or
+uv add aus-identity
+```
+
+Zero runtime dependencies. Pure Python. Wheel is < 20 KB.
+
+## Quick examples
+
+```python
+from aus_identity import (
+    postcode_to_state,
+    normalize_postcode,
+    is_valid_postcode,
+    normalize_state,
+    state_full_name,
+)
+
+# Postcode → state
+postcode_to_state("2000")      # "NSW" (Sydney CBD)
+postcode_to_state("3000")      # "VIC" (Melbourne CBD)
+postcode_to_state("2600")      # "ACT" (Parliament House — not NSW)
+postcode_to_state("0800")      # "NT"  (Darwin)
+postcode_to_state(6000)        # "WA"  (int input also accepted)
+
+# Normalisation
+normalize_postcode("  2000  ")  # "2000"
+normalize_postcode(800)         # "0800" (3-digit shorthand padded)
+
+# Validation (never raises)
+is_valid_postcode("2000")       # True
+is_valid_postcode("ABCD")       # False
+is_valid_postcode(None)         # False
+
+# State normalisation
+normalize_state("nsw")                  # "NSW"
+normalize_state("New South Wales")      # "NSW"
+normalize_state("AU-VIC")               # "VIC"
+normalize_state("Tassie")               # "TAS"
+normalize_state("New_South_Wales")      # "NSW" (LLM payload form)
+
+# Full names
+state_full_name("NSW")          # "New South Wales"
+state_full_name("act")          # "Australian Capital Territory"
+```
+
+## Why this exists
+
+The AU public-data MCP stack ([abs-mcp](https://github.com/Bigred97/abs-mcp), [rba-mcp](https://github.com/Bigred97/rba-mcp), [ato-mcp](https://github.com/Bigred97/ato-mcp), [apra-mcp](https://github.com/Bigred97/apra-mcp), [aihw-mcp](https://github.com/Bigred97/aihw-mcp), [asic-mcp](https://github.com/Bigred97/asic-mcp), [au-weather-mcp](https://github.com/Bigred97/au-weather-mcp)) lets an LLM agent talk to any single Australian government data source. But each agency uses its own identifier conventions:
+
+- ABS uses ASGS region codes (`1GSYD` for Greater Sydney, `101011001` for an SA1)
+- ATO uses 4-digit postcodes
+- APRA uses ABNs
+- ASIC uses licence numbers
+- au-weather uses location keys and lat/long
+- RBA uses F-table IDs and series codes
+
+To use any two of these together — "what's the median household income vs unemployment rate in postcode 2000?" — something has to translate between identifier systems. **aus-identity is that something.** v0.1 starts with the most-used crosswalk (postcode ↔ state); v0.2+ will extend to ASGS / ABN / ANZSIC / ANZSCO.
+
+## Source of truth
+
+Postcode → state mappings are sourced from Australia Post's public postcode boundary publication and cross-checked against ABS ASGS Edition 3 (2021) state-of-residence assignments. The three ACT-inside-NSW ranges and the Vic/Qld PO Box blocks are handled explicitly. Coverage is 99%+ of currently-active AU postcodes.
+
+For exact suburb-level precision (e.g. which side of an ACT/NSW boundary a specific delivery address falls), use ABS ASGS sub-state codes — planned for v0.2 of this package.
+
+## Roadmap
+
+- **v0.1.0** (this release) — postcode + state crosswalks
+- **v0.2** — ASGS 2021 sub-state crosswalk (SA1 ↔ SA2 ↔ SA3 ↔ SA4 ↔ GCCSA ↔ state)
+- **v0.3** — ABN ↔ ACN ↔ ACNC charity-ID crosswalk
+- **v0.4** — ANZSIC industry codes + ANZSCO occupation codes
+
+## License
+
+MIT.

aus_identity-0.1.0/README.md

@@ -0,0 +1,94 @@
+# aus-identity
+
+[![PyPI](https://img.shields.io/pypi/v/aus-identity.svg)](https://pypi.org/project/aus-identity/)
+[![Python](https://img.shields.io/pypi/pyversions/aus-identity.svg)](https://pypi.org/project/aus-identity/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Cross-source join keys for Australian public data. The foundation layer for tools that need to talk to multiple AU government data sources at once (ABS demographics + ATO income + APRA banking + au-weather climate + ASIC company register + RBA monetary stats), or for any application that has to map between Australia's postcode and state/territory conventions.
+
+## What it does today (v0.1.0)
+
+- **Postcode → state**: `postcode_to_state("2000")` → `"NSW"`. Handles the three ACT-inside-NSW carve-outs (`0200-0299`, `2600-2618`, `2900-2920`) correctly.
+- **Postcode normalisation**: accept `"2000"`, `2000`, `" 2000 "`, `"0800"`, `800` — all return canonical 4-digit string form.
+- **Postcode validation**: `is_valid_postcode(x)` returns a boolean and never raises — safe for filtering arbitrary input.
+- **State code normalisation**: `normalize_state("nsw")` / `normalize_state("New South Wales")` / `normalize_state("AU-VIC")` / `normalize_state("Tassie")` → canonical short code.
+- **Full state name**: `state_full_name("NSW")` → `"New South Wales"`.
+
+## Install
+
+```bash
+pip install aus-identity
+# or
+uv add aus-identity
+```
+
+Zero runtime dependencies. Pure Python. Wheel is < 20 KB.
+
+## Quick examples
+
+```python
+from aus_identity import (
+    postcode_to_state,
+    normalize_postcode,
+    is_valid_postcode,
+    normalize_state,
+    state_full_name,
+)
+
+# Postcode → state
+postcode_to_state("2000")      # "NSW" (Sydney CBD)
+postcode_to_state("3000")      # "VIC" (Melbourne CBD)
+postcode_to_state("2600")      # "ACT" (Parliament House — not NSW)
+postcode_to_state("0800")      # "NT"  (Darwin)
+postcode_to_state(6000)        # "WA"  (int input also accepted)
+
+# Normalisation
+normalize_postcode("  2000  ")  # "2000"
+normalize_postcode(800)         # "0800" (3-digit shorthand padded)
+
+# Validation (never raises)
+is_valid_postcode("2000")       # True
+is_valid_postcode("ABCD")       # False
+is_valid_postcode(None)         # False
+
+# State normalisation
+normalize_state("nsw")                  # "NSW"
+normalize_state("New South Wales")      # "NSW"
+normalize_state("AU-VIC")               # "VIC"
+normalize_state("Tassie")               # "TAS"
+normalize_state("New_South_Wales")      # "NSW" (LLM payload form)
+
+# Full names
+state_full_name("NSW")          # "New South Wales"
+state_full_name("act")          # "Australian Capital Territory"
+```
+
+## Why this exists
+
+The AU public-data MCP stack ([abs-mcp](https://github.com/Bigred97/abs-mcp), [rba-mcp](https://github.com/Bigred97/rba-mcp), [ato-mcp](https://github.com/Bigred97/ato-mcp), [apra-mcp](https://github.com/Bigred97/apra-mcp), [aihw-mcp](https://github.com/Bigred97/aihw-mcp), [asic-mcp](https://github.com/Bigred97/asic-mcp), [au-weather-mcp](https://github.com/Bigred97/au-weather-mcp)) lets an LLM agent talk to any single Australian government data source. But each agency uses its own identifier conventions:
+
+- ABS uses ASGS region codes (`1GSYD` for Greater Sydney, `101011001` for an SA1)
+- ATO uses 4-digit postcodes
+- APRA uses ABNs
+- ASIC uses licence numbers
+- au-weather uses location keys and lat/long
+- RBA uses F-table IDs and series codes
+
+To use any two of these together — "what's the median household income vs unemployment rate in postcode 2000?" — something has to translate between identifier systems. **aus-identity is that something.** v0.1 starts with the most-used crosswalk (postcode ↔ state); v0.2+ will extend to ASGS / ABN / ANZSIC / ANZSCO.
+
+## Source of truth
+
+Postcode → state mappings are sourced from Australia Post's public postcode boundary publication and cross-checked against ABS ASGS Edition 3 (2021) state-of-residence assignments. The three ACT-inside-NSW ranges and the Vic/Qld PO Box blocks are handled explicitly. Coverage is 99%+ of currently-active AU postcodes.
+
+For exact suburb-level precision (e.g. which side of an ACT/NSW boundary a specific delivery address falls), use ABS ASGS sub-state codes — planned for v0.2 of this package.
+
+## Roadmap
+
+- **v0.1.0** (this release) — postcode + state crosswalks
+- **v0.2** — ASGS 2021 sub-state crosswalk (SA1 ↔ SA2 ↔ SA3 ↔ SA4 ↔ GCCSA ↔ state)
+- **v0.3** — ABN ↔ ACN ↔ ACNC charity-ID crosswalk
+- **v0.4** — ANZSIC industry codes + ANZSCO occupation codes
+
+## License
+
+MIT.

aus_identity-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aus-identity"
+version = "0.1.0"
+description = "Cross-source join keys for Australian public data — postcode ↔ state crosswalks, state-code normalisation, more coming. Foundation for tools that talk to multiple AU government data sources."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Harry Vass" }]
+keywords = [
+    "australia",
+    "postcode",
+    "state",
+    "geography",
+    "identity",
+    "crosswalk",
+    "abs",
+    "ato",
+    "asgs",
+    "anzsic",
+    "anzsco",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+]
+
+[project.urls]
+Homepage = "https://github.com/Bigred97/aus-identity"
+Issues = "https://github.com/Bigred97/aus-identity/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aus_identity"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

aus_identity-0.1.0/src/aus_identity/__init__.py

@@ -0,0 +1,52 @@
+"""aus-identity — cross-source join keys for Australian public data.
+
+The foundation layer for tools that need to talk to multiple AU datasets at
+once (ABS demographics + ATO income + APRA banking + au-weather climate +
+ASIC company register + RBA monetary stats). Each agency uses its own
+identifier conventions; this package provides the crosswalks.
+
+v0.1.0 scope:
+- Postcode (4-digit) ↔ state (NSW/VIC/QLD/SA/WA/TAS/NT/ACT) — covers ~99% of AU postcodes
+- State code ↔ state full name (with fuzzy normalisation)
+- Postcode validation
+
+v0.2 (future):
+- ASGS 2021 crosswalk: postcode ↔ SA1/SA2/SA3/SA4 ↔ GCCSA
+- ABN ↔ ACN ↔ company-name fuzzy
+- ANZSIC industry codes
+- ANZSCO occupation codes
+
+Used by the AU public-data MCP stack
+(https://github.com/Bigred97?tab=repositories&q=mcp) and by anyone else
+building software that touches multiple AU government data sources.
+"""
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+
+from .postcode import (
+    is_valid_postcode,
+    normalize_postcode,
+    postcode_to_state,
+)
+from .state import (
+    STATE_NAMES,
+    normalize_state,
+    state_full_name,
+)
+
+try:
+    __version__ = _version("aus-identity")
+except PackageNotFoundError:  # editable install before metadata is generated
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "STATE_NAMES",
+    "__version__",
+    "is_valid_postcode",
+    "normalize_postcode",
+    "normalize_state",
+    "postcode_to_state",
+    "state_full_name",
+]

aus_identity-0.1.0/src/aus_identity/postcode.py

@@ -0,0 +1,182 @@
+"""Australian postcode → state lookup.
+
+Australia Post issues 4-digit numeric postcodes. State assignment follows
+well-known number ranges with a handful of historical exceptions (the
+ACT, which is geographically inside NSW, has its own postcode ranges
+0200-0299 and 2600-2618 and 2900-2920 that span the NSW block).
+
+The mappings below are sourced from Australia Post's public postcode
+boundary publication and cross-checked against the ABS Mesh Block /
+ASGS Edition 3 (2021) state-of-residence assignments. They cover 99%+
+of AU postcodes correctly. Edge cases (PO Boxes at state-border points,
+defunct postcodes from pre-1996 reorganisations) may resolve to the
+historically-most-common state; if you need exact suburb-level precision,
+use ABS ASGS sub-state codes (planned for aus-identity v0.2).
+
+References:
+- Australia Post: https://auspost.com.au/postcode
+- ABS ASGS Edition 3 (2021): https://www.abs.gov.au/statistics/standards/australian-statistical-geography-standard-asgs-edition-3
+"""
+from __future__ import annotations
+
+from typing import Final
+
+
+# Ordered list of (postcode_range, state) tuples. First match wins.
+# Order matters: ACT-inside-NSW ranges come BEFORE the broader NSW ranges.
+_RANGES: Final[list[tuple[range, str]]] = [
+    # ACT (Canberra) — geographically inside NSW, uses three separate ranges
+    (range(200, 300), "ACT"),     # 0200-0299: PO Boxes + early CBD
+    (range(2600, 2619), "ACT"),   # 2600-2618: Canberra inner
+    (range(2900, 2921), "ACT"),   # 2900-2920: Canberra outer
+    # Northern Territory
+    (range(800, 900), "NT"),      # 0800-0899
+    # New South Wales (three blocks because ACT carves out 2600-2618 and 2900-2920)
+    (range(1000, 2600), "NSW"),
+    (range(2619, 2900), "NSW"),
+    (range(2921, 3000), "NSW"),
+    # Victoria
+    (range(3000, 4000), "VIC"),   # 3000-3999 delivery; 8000-8999 are Vic PO Boxes
+    # Queensland
+    (range(4000, 5000), "QLD"),   # 4000-4999 delivery; 9000-9999 are Qld PO Boxes
+    # South Australia
+    (range(5000, 6000), "SA"),
+    # Western Australia
+    (range(6000, 7000), "WA"),
+    # Tasmania
+    (range(7000, 8000), "TAS"),
+    # Victorian PO Box block
+    (range(8000, 9000), "VIC"),
+    # Queensland PO Box block
+    (range(9000, 10000), "QLD"),
+]
+
+
+VALID_STATES: Final[frozenset[str]] = frozenset(
+    {"NSW", "VIC", "QLD", "SA", "WA", "TAS", "NT", "ACT"}
+)
+
+
+def normalize_postcode(postcode: str | int) -> str:
+    """Coerce a postcode to canonical 4-digit string form.
+
+    Accepts:
+    - 4-digit string: `"2000"` → `"2000"`
+    - 3-digit string (rare, for ACT/NT) with leading zero: `"800"` → `"0800"`
+    - Integer: `2000` → `"2000"`, `800` → `"0800"`
+    - String with leading whitespace: `"  2000  "` → `"2000"`
+
+    Raises:
+        ValueError: if `postcode` is not a string or int, or if the
+            normalised value is not exactly 4 digits.
+
+    Examples:
+        >>> normalize_postcode("2000")
+        '2000'
+        >>> normalize_postcode(800)
+        '0800'
+        >>> normalize_postcode("  3000  ")
+        '3000'
+    """
+    if isinstance(postcode, bool):
+        # bool is an int subclass; reject explicitly to avoid `True` → "0001".
+        raise ValueError(
+            f"postcode must be a 4-digit string or int, got bool {postcode!r}. "
+            "Try a number like 2000 (Sydney) or 3000 (Melbourne)."
+        )
+    if isinstance(postcode, int):
+        if postcode < 0 or postcode > 9999:
+            raise ValueError(
+                f"postcode {postcode} is out of range. "
+                "AU postcodes are 4-digit numbers from 0200 to 9999. "
+                "Try a number like 2000 (Sydney CBD) or 3000 (Melbourne CBD)."
+            )
+        return f"{postcode:04d}"
+    if isinstance(postcode, str):
+        s = postcode.strip()
+        if not s.isdigit():
+            raise ValueError(
+                f"postcode {postcode!r} contains non-digit characters. "
+                "AU postcodes are 4-digit numeric (e.g. '2000', '3000', '0800'). "
+                "Did you include a state abbreviation or suburb name?"
+            )
+        if len(s) == 3:
+            s = "0" + s  # ACT/NT 3-digit shorthand
+        if len(s) != 4:
+            raise ValueError(
+                f"postcode {postcode!r} must be exactly 4 digits, got {len(s)} digits. "
+                "AU postcodes are 4-digit numbers from '0200' to '9999'."
+            )
+        return s
+    raise ValueError(
+        f"postcode must be a str or int, got {type(postcode).__name__}. "
+        "Try a string like '2000' or an int like 2000."
+    )
+
+
+def is_valid_postcode(postcode: str | int) -> bool:
+    """Return True iff the value is a recognisable AU 4-digit postcode.
+
+    A postcode is "recognisable" if it normalises cleanly AND falls inside
+    a known state range. Returns False (never raises) for malformed inputs
+    so it's safe to use as a filter.
+
+    Examples:
+        >>> is_valid_postcode("2000")
+        True
+        >>> is_valid_postcode(3000)
+        True
+        >>> is_valid_postcode("ABC")
+        False
+        >>> is_valid_postcode("0000")  # not in any state range
+        False
+        >>> is_valid_postcode(None)
+        False
+    """
+    try:
+        normalised = normalize_postcode(postcode)
+    except (ValueError, TypeError):
+        return False
+    code = int(normalised)
+    return any(code in r for r, _ in _RANGES)
+
+
+def postcode_to_state(postcode: str | int) -> str:
+    """Return the ISO-style state code for an AU postcode.
+
+    Returns one of: ``NSW``, ``VIC``, ``QLD``, ``SA``, ``WA``, ``TAS``,
+    ``NT``, ``ACT``.
+
+    Args:
+        postcode: 4-digit string ("2000") or int (2000). Leading whitespace
+            stripped; 3-digit shorthand padded with leading zero
+            ("800" → "0800").
+
+    Raises:
+        ValueError: if `postcode` is malformed (see `normalize_postcode`)
+            or does not fall in any known state range.
+
+    Examples:
+        >>> postcode_to_state("2000")    # Sydney CBD
+        'NSW'
+        >>> postcode_to_state("3000")    # Melbourne CBD
+        'VIC'
+        >>> postcode_to_state("2600")    # Parliament House — ACT, not NSW
+        'ACT'
+        >>> postcode_to_state("0800")    # Darwin
+        'NT'
+        >>> postcode_to_state(6000)      # Perth (int input)
+        'WA'
+    """
+    normalised = normalize_postcode(postcode)
+    code = int(normalised)
+    for r, state in _RANGES:
+        if code in r:
+            return state
+    raise ValueError(
+        f"postcode {normalised!r} does not fall within any known AU state range. "
+        "Valid ranges: NSW 1000-2599/2619-2899/2921-2999, VIC 3000-3999/8000-8999, "
+        "QLD 4000-4999/9000-9999, SA 5000-5999, WA 6000-6999, TAS 7000-7999, "
+        "NT 0800-0899, ACT 0200-0299/2600-2618/2900-2920. "
+        "Try a number like 2000 (Sydney CBD) or 3000 (Melbourne CBD)."
+    )

aus_identity-0.1.0/src/aus_identity/state.py

@@ -0,0 +1,123 @@
+"""Australian state / territory code ↔ full name crosswalks.
+
+Eight official jurisdictions: 6 states + 2 territories. The ABS, ATO,
+APRA, AIHW, and other AU agencies use a mix of:
+- ISO 3166-2 codes (AU-NSW, AU-VIC, ...) — rare outside official documents
+- Short codes (NSW, VIC, ...) — most common in CSV / JSON exports
+- Full names ("New South Wales", "Victoria", ...) — common in published reports
+- Mixed case ("nsw", "New_South_Wales", "Nsw") — common from LLM inputs
+
+`normalize_state` accepts any of these and returns the canonical 2-3 letter
+short code. `state_full_name` does the reverse.
+"""
+from __future__ import annotations
+
+from typing import Final
+
+
+STATE_NAMES: Final[dict[str, str]] = {
+    "NSW": "New South Wales",
+    "VIC": "Victoria",
+    "QLD": "Queensland",
+    "SA": "South Australia",
+    "WA": "Western Australia",
+    "TAS": "Tasmania",
+    "NT": "Northern Territory",
+    "ACT": "Australian Capital Territory",
+}
+
+
+# Reverse map (full-name-upper → short code) for fast normalisation lookups.
+_NAME_TO_CODE: Final[dict[str, str]] = {
+    name.upper(): code for code, name in STATE_NAMES.items()
+}
+
+# Common alternative spellings / abbreviations.
+_ALIASES: Final[dict[str, str]] = {
+    # ISO 3166-2 codes
+    "AU-NSW": "NSW",
+    "AU-VIC": "VIC",
+    "AU-QLD": "QLD",
+    "AU-SA": "SA",
+    "AU-WA": "WA",
+    "AU-TAS": "TAS",
+    "AU-NT": "NT",
+    "AU-ACT": "ACT",
+    # Common alternates / typos
+    "NEW SOUTH WALES": "NSW",
+    "TASSIE": "TAS",
+    "NORTHERN TERRITORY OF AUSTRALIA": "NT",
+    "AUSTRALIAN CAPITAL TERRITORY": "ACT",
+    "QUEENSLAND": "QLD",
+    "VICTORIA": "VIC",
+    "WESTERN AUSTRALIA": "WA",
+    "SOUTH AUSTRALIA": "SA",
+    "TASMANIA": "TAS",
+}
+
+
+def normalize_state(state: str) -> str:
+    """Normalise a state reference to the canonical 2-3 letter short code.
+
+    Accepts short codes, ISO 3166-2 codes, full names, common aliases,
+    and casual variants ("nsw", "New_South_Wales", "AU-VIC", "Tassie").
+
+    Raises:
+        ValueError: if the input cannot be matched to any AU state/territory.
+
+    Examples:
+        >>> normalize_state("NSW")
+        'NSW'
+        >>> normalize_state("nsw")
+        'NSW'
+        >>> normalize_state("New South Wales")
+        'NSW'
+        >>> normalize_state("New_South_Wales")
+        'NSW'
+        >>> normalize_state("AU-VIC")
+        'VIC'
+        >>> normalize_state("Tassie")
+        'TAS'
+    """
+    if not isinstance(state, str):
+        raise ValueError(
+            f"state must be a string, got {type(state).__name__}. "
+            f"Try one of: {', '.join(sorted(STATE_NAMES.keys()))}."
+        )
+    s = state.strip().upper().replace("_", " ").replace("-", "-")
+    if s in STATE_NAMES:
+        return s
+    if s in _NAME_TO_CODE:
+        return _NAME_TO_CODE[s]
+    if s in _ALIASES:
+        return _ALIASES[s]
+    raise ValueError(
+        f"state {state!r} is not a recognised AU state or territory. "
+        f"Valid short codes: {', '.join(sorted(STATE_NAMES.keys()))}. "
+        f"Full names also accepted (e.g. 'New South Wales', 'Tasmania'). "
+        "Did you mean one of these? Use the search-by-prefix approach: "
+        f"'N' matches NSW/NT, 'S' matches SA, 'T' matches TAS, 'A' matches ACT, 'V' matches VIC."
+    )
+
+
+def state_full_name(state: str) -> str:
+    """Return the official full name for a state/territory code.
+
+    Args:
+        state: Anything `normalize_state` accepts.
+
+    Raises:
+        ValueError: if the input cannot be matched.
+
+    Examples:
+        >>> state_full_name("NSW")
+        'New South Wales'
+        >>> state_full_name("nsw")
+        'New South Wales'
+        >>> state_full_name("AU-VIC")
+        'Victoria'
+        >>> state_full_name("Tassie")
+        'Tasmania'
+    """
+    code = normalize_state(state)
+    return STATE_NAMES[code]

aus_identity-0.1.0/tests/test_postcode.py

@@ -0,0 +1,154 @@
+"""Postcode normalisation + state lookup."""
+from __future__ import annotations
+
+import pytest
+
+from aus_identity import (
+    is_valid_postcode,
+    normalize_postcode,
+    postcode_to_state,
+)
+
+
+# ─── normalize_postcode ─────────────────────────────────────────────────
+
+@pytest.mark.parametrize("inp,out", [
+    ("2000", "2000"),
+    ("3000", "3000"),
+    ("  2000  ", "2000"),
+    ("0800", "0800"),
+    ("0200", "0200"),
+    (2000, "2000"),
+    (200, "0200"),
+    (800, "0800"),
+    (9999, "9999"),
+])
+def test_normalize_postcode_accepts_valid(inp: str | int, out: str) -> None:
+    assert normalize_postcode(inp) == out
+
+
+@pytest.mark.parametrize("bad", [None, 1.5, [], {}])
+def test_normalize_postcode_rejects_non_str_non_int(bad: object) -> None:
+    with pytest.raises(ValueError, match="must be a str or int"):
+        normalize_postcode(bad)  # type: ignore[arg-type]
+
+
+def test_normalize_postcode_rejects_bool() -> None:
+    """`True`/`False` are int subclasses; must not silently coerce to '0001'/'0000'."""
+    with pytest.raises(ValueError, match="bool"):
+        normalize_postcode(True)  # type: ignore[arg-type]
+    with pytest.raises(ValueError, match="bool"):
+        normalize_postcode(False)  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize("bad", ["ABCD", "20A0", "20-00", "twenty-thousand"])
+def test_normalize_postcode_rejects_non_digit_strings(bad: str) -> None:
+    with pytest.raises(ValueError, match="non-digit"):
+        normalize_postcode(bad)
+
+
+@pytest.mark.parametrize("bad", ["1", "12", "12345"])
+def test_normalize_postcode_rejects_wrong_length(bad: str) -> None:
+    with pytest.raises(ValueError, match="4 digits"):
+        normalize_postcode(bad)
+
+
+def test_normalize_postcode_rejects_empty_string() -> None:
+    """Empty string trips the non-digit guard (since `"".isdigit()` is False) —
+    that's fine, just lock in the contract that it raises somewhere clear."""
+    with pytest.raises(ValueError, match="non-digit"):
+        normalize_postcode("")
+
+
+@pytest.mark.parametrize("bad", [-1, 10000, -2000])
+def test_normalize_postcode_rejects_out_of_range_int(bad: int) -> None:
+    with pytest.raises(ValueError, match="out of range"):
+        normalize_postcode(bad)
+
+
+# ─── postcode_to_state ──────────────────────────────────────────────────
+
+@pytest.mark.parametrize("postcode,state", [
+    # NSW capitals
+    ("2000", "NSW"),   # Sydney CBD
+    ("2010", "NSW"),   # Surry Hills
+    ("2500", "NSW"),   # Wollongong area
+    ("2899", "NSW"),
+    ("2999", "NSW"),
+    # ACT (carved out of NSW)
+    ("0200", "ACT"),
+    ("0299", "ACT"),
+    ("2600", "ACT"),
+    ("2618", "ACT"),
+    ("2900", "ACT"),
+    ("2920", "ACT"),
+    # VIC
+    ("3000", "VIC"),   # Melbourne CBD
+    ("3999", "VIC"),
+    ("8000", "VIC"),   # Vic PO Box block
+    ("8999", "VIC"),
+    # QLD
+    ("4000", "QLD"),   # Brisbane CBD
+    ("4999", "QLD"),
+    ("9000", "QLD"),   # Qld PO Box block
+    ("9999", "QLD"),
+    # SA
+    ("5000", "SA"),    # Adelaide
+    ("5999", "SA"),
+    # WA
+    ("6000", "WA"),    # Perth
+    ("6999", "WA"),
+    # TAS
+    ("7000", "TAS"),   # Hobart
+    ("7999", "TAS"),
+    # NT
+    ("0800", "NT"),    # Darwin
+    ("0899", "NT"),
+])
+def test_postcode_to_state_known_codes(postcode: str, state: str) -> None:
+    assert postcode_to_state(postcode) == state
+
+
+def test_postcode_to_state_int_inputs() -> None:
+    """Integer inputs work the same as 4-digit strings."""
+    assert postcode_to_state(2000) == "NSW"
+    assert postcode_to_state(3000) == "VIC"
+    assert postcode_to_state(800) == "NT"   # 3-digit shorthand padded
+    assert postcode_to_state(200) == "ACT"  # 3-digit shorthand padded
+
+
+def test_postcode_to_state_act_inside_nsw_boundary() -> None:
+    """The ACT/NSW boundary is well-defined. Verify it doesn't drift."""
+    assert postcode_to_state("2599") == "NSW", "2599 is in the NSW 1000-2599 block"
+    assert postcode_to_state("2600") == "ACT", "2600 starts the inner-Canberra ACT block"
+    assert postcode_to_state("2618") == "ACT", "2618 is the last inner-Canberra ACT code"
+    assert postcode_to_state("2619") == "NSW", "2619 resumes the NSW block"
+    assert postcode_to_state("2899") == "NSW", "2899 is the last pre-Canberra-outer NSW code"
+    assert postcode_to_state("2900") == "ACT", "2900 starts the outer-Canberra ACT block"
+    assert postcode_to_state("2920") == "ACT", "2920 is the last outer-Canberra ACT code"
+    assert postcode_to_state("2921") == "NSW", "2921 resumes the NSW block"
+
+
+@pytest.mark.parametrize("bad", ["0000", "0100", "0500"])
+def test_postcode_to_state_unrecognised_range(bad: str) -> None:
+    """Postcodes outside any known state range raise with a helpful hint."""
+    with pytest.raises(ValueError, match="state range"):
+        postcode_to_state(bad)
+
+
+# ─── is_valid_postcode ──────────────────────────────────────────────────
+
+@pytest.mark.parametrize("good", [
+    "2000", "3000", "0800", "0200", "2600", "5000", "6000", "7000", "9999",
+    2000, 800, 200,
+])
+def test_is_valid_postcode_true(good: str | int) -> None:
+    assert is_valid_postcode(good) is True
+
+
+@pytest.mark.parametrize("bad", [
+    None, "", "abc", "20a0", "1", "12345", -1, 10000, "0000", "0100", 1.5, True, False,
+])
+def test_is_valid_postcode_false(bad: object) -> None:
+    """`is_valid_postcode` never raises — returns False for any malformed input."""
+    assert is_valid_postcode(bad) is False  # type: ignore[arg-type]

aus_identity-0.1.0/tests/test_state.py

@@ -0,0 +1,114 @@
+"""State code ↔ full-name crosswalk."""
+from __future__ import annotations
+
+import pytest
+
+from aus_identity import STATE_NAMES, normalize_state, state_full_name
+
+
+# ─── STATE_NAMES dict integrity ─────────────────────────────────────────
+
+def test_state_names_has_eight_jurisdictions() -> None:
+    assert len(STATE_NAMES) == 8
+
+
+def test_state_names_codes_are_uppercase_short() -> None:
+    for code in STATE_NAMES:
+        assert code == code.upper()
+        assert 2 <= len(code) <= 3
+
+
+def test_state_names_full_names_proper_case() -> None:
+    for name in STATE_NAMES.values():
+        # Each name should start with an uppercase letter
+        assert name[0].isupper()
+        # No trailing whitespace
+        assert name == name.strip()
+
+
+# ─── normalize_state ────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("inp,out", [
+    # Canonical short codes
+    ("NSW", "NSW"),
+    ("VIC", "VIC"),
+    ("QLD", "QLD"),
+    ("SA", "SA"),
+    ("WA", "WA"),
+    ("TAS", "TAS"),
+    ("NT", "NT"),
+    ("ACT", "ACT"),
+    # Lowercase
+    ("nsw", "NSW"),
+    ("vic", "VIC"),
+    ("act", "ACT"),
+    # Mixed case
+    ("Nsw", "NSW"),
+    ("nSw", "NSW"),
+    # Whitespace
+    ("  NSW  ", "NSW"),
+    ("\tVIC\n", "VIC"),
+    # Full names
+    ("New South Wales", "NSW"),
+    ("Victoria", "VIC"),
+    ("Queensland", "QLD"),
+    ("South Australia", "SA"),
+    ("Western Australia", "WA"),
+    ("Tasmania", "TAS"),
+    ("Northern Territory", "NT"),
+    ("Australian Capital Territory", "ACT"),
+    # Full names with underscores (LLM payload pattern)
+    ("New_South_Wales", "NSW"),
+    ("Western_Australia", "WA"),
+    # ISO 3166-2
+    ("AU-NSW", "NSW"),
+    ("AU-VIC", "VIC"),
+    ("AU-TAS", "TAS"),
+    # Aliases
+    ("Tassie", "TAS"),
+    ("TASSIE", "TAS"),
+])
+def test_normalize_state_accepts_variants(inp: str, out: str) -> None:
+    assert normalize_state(inp) == out
+
+
+@pytest.mark.parametrize("bad", [
+    "XYZ",       # not a real state
+    "Tas mania", # mid-word space (after replace _ → space this passes a different path)
+    "",          # empty
+    "  ",        # whitespace only
+    "AU",        # no state suffix
+    "NewSouthWales",  # missing space
+])
+def test_normalize_state_rejects_unknown(bad: str) -> None:
+    with pytest.raises(ValueError, match="not a recognised AU state"):
+        normalize_state(bad)
+
+
+@pytest.mark.parametrize("bad", [None, 123, 1.5, [], {}])
+def test_normalize_state_rejects_non_string(bad: object) -> None:
+    with pytest.raises(ValueError, match="must be a string"):
+        normalize_state(bad)  # type: ignore[arg-type]
+
+
+# ─── state_full_name ────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("inp,out", [
+    ("NSW", "New South Wales"),
+    ("nsw", "New South Wales"),
+    ("VIC", "Victoria"),
+    ("ACT", "Australian Capital Territory"),
+    ("Tassie", "Tasmania"),
+    ("AU-WA", "Western Australia"),
+    ("Queensland", "Queensland"),       # idempotent for full names
+    ("New_South_Wales", "New South Wales"),
+])
+def test_state_full_name(inp: str, out: str) -> None:
+    assert state_full_name(inp) == out
+
+
+def test_state_full_name_round_trip() -> None:
+    """Every canonical short code → full name → back to short code is stable."""
+    for code, name in STATE_NAMES.items():
+        assert state_full_name(code) == name
+        assert normalize_state(name) == code

aus_identity-0.1.0/uv.lock

@@ -0,0 +1,78 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "aus-identity"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.optional-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "pytest", marker = "extra == 'dev'", specifier = ">=8" }]
+provides-extras = ["dev"]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]