refdatakit 0.1.0__py3-none-any.whl

refdatakit/validator.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import unicodedata
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Literal, NotRequired, TypedDict, cast
+
+from jsonschema import Draft202012Validator, FormatChecker
+from jsonschema.exceptions import SchemaError
+
+from .canonical_json import canonical_json
+
+
+class DatasetValidationError(ValueError):
+    pass
+
+
+class DatasetSource(TypedDict):
+    source_url: str
+    license: str
+    attribution: str
+    fields: list[str]
+    data_as_of: NotRequired[str]
+
+
+class DatasetEntry(TypedDict):
+    path: str
+    source_url: str
+    license: str
+    attribution: str
+    sha256: str
+    data_as_of: NotRequired[str]
+    additional_sources: NotRequired[list[DatasetSource]]
+
+
+class DatasetVocabularies(TypedDict):
+    entity_tags: list[str]
+
+
+class DatasetManifest(TypedDict):
+    datasets: list[DatasetEntry]
+    vocabularies: DatasetVocabularies
+
+
+@dataclass(frozen=True)
+class DatasetDefinition:
+    domain: Literal["country", "subdivision", "city", "entity"]
+    schema: str
+    country_code: str | None = None
+
+
+@dataclass(frozen=True)
+class DatasetRecords:
+    definition: DatasetDefinition
+    entry: DatasetEntry
+    records: list[object]
+
+
+DATASET_PATH_PATTERNS: tuple[
+    tuple[re.Pattern[str], Literal["country", "subdivision", "city", "entity"], str],
+    ...,
+] = (
+    (
+        re.compile(r"datasets/countries/data\.json"),
+        "country",
+        "schemas/country.schema.json",
+    ),
+    (
+        re.compile(r"datasets/subdivisions/by-country/([A-Z]{2})\.json"),
+        "subdivision",
+        "schemas/subdivision.schema.json",
+    ),
+    (
+        re.compile(r"datasets/cities/by-country/([A-Z]{2})\.json"),
+        "city",
+        "schemas/city.schema.json",
+    ),
+    (
+        re.compile(r"datasets/institutions/by-country/([A-Z]{2})\.json"),
+        "entity",
+        "schemas/entity.schema.json",
+    ),
+)
+
+
+IDENTITY_FIELDS: dict[str, str] = {
+    "country": "code",
+    "subdivision": "code",
+    "city": "id",
+    "entity": "id",
+}
+
+
+def _repository_file(root: Path, relative_path: str) -> Path:
+    path = PurePosixPath(relative_path)
+    if path.is_absolute() or ".." in path.parts or "\\" in relative_path:
+        raise DatasetValidationError(f"Expected a repository-relative path: {relative_path}")
+
+    try:
+        resolved_path = (root / Path(*path.parts)).resolve(strict=True)
+    except FileNotFoundError as error:
+        raise DatasetValidationError(f"Missing repository file: {relative_path}") from error
+    try:
+        resolved_path.relative_to(root)
+    except ValueError as error:
+        raise DatasetValidationError(f"Path resolves outside the repository: {relative_path}") from error
+    return resolved_path
+
+
+def _read_json(path: Path) -> object:
+    try:
+        return json.loads(path.read_bytes())
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise DatasetValidationError(f"Invalid JSON in {path}: {error}") from error
+
+
+def _validate_instance(validator: Draft202012Validator, instance: object, description: str) -> None:
+    errors = sorted(
+        validator.iter_errors(instance),
+        key=lambda error: tuple(str(part) for part in error.absolute_path),
+    )
+    if errors:
+        details = "; ".join(
+            f"/{'/'.join(str(part) for part in error.absolute_path)} {error.message}"
+            for error in errors
+        )
+        raise DatasetValidationError(f"{description} is invalid: {details}")
+
+
+def _schema_validator(schema: object, description: str) -> Draft202012Validator:
+    try:
+        Draft202012Validator.check_schema(schema)
+    except SchemaError as error:
+        raise DatasetValidationError(
+            f"{description} is not a valid JSON Schema: {error.message}"
+        ) from error
+    return Draft202012Validator(schema, format_checker=FormatChecker())
+
+
+def _schema_with_entity_tags(schema: object, entity_tags: list[str]) -> object:
+    if (
+        not isinstance(schema, dict)
+        or not isinstance(schema.get("$defs"), dict)
+        or not isinstance(schema["$defs"].get("tag"), dict)
+    ):
+        raise DatasetValidationError("schemas/entity.schema.json must define $defs.tag")
+
+    return {
+        **schema,
+        "$defs": {
+            **schema["$defs"],
+            "tag": {
+                **schema["$defs"]["tag"],
+                "enum": entity_tags,
+            },
+        },
+    }
+
+
+def _required_string(record: object, field: str, description: str) -> str:
+    if not isinstance(record, dict) or not isinstance(record.get(field), str):
+        raise DatasetValidationError(f"{description} must have a string {field}")
+    return cast(str, record[field])
+
+
+def _optional_string(record: object, field: str, description: str) -> str | None:
+    if not isinstance(record, dict):
+        raise DatasetValidationError(f"{description} must be an object")
+
+    value = record.get(field)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise DatasetValidationError(f"{description} {field} must be a string")
+    return value
+
+
+def _official_non_english_languages(record: object, description: str) -> set[str]:
+    if not isinstance(record, dict) or not isinstance(record.get("official_languages"), list):
+        raise DatasetValidationError(f"{description} must have an official_languages array")
+
+    languages: set[str] = set()
+    for language in record["official_languages"]:
+        if not isinstance(language, str):
+            raise DatasetValidationError(f"{description} official_languages must contain strings")
+        code = language.split("-", maxsplit=1)[0].lower()
+        if not re.fullmatch(r"[a-z]{2,3}", code):
+            raise DatasetValidationError(
+                f"{description} official language {language} has an invalid code"
+            )
+        if code != "en":
+            languages.add(code)
+    return languages
+
+
+def _validate_entity_language_names(
+    record: object,
+    official_languages: set[str],
+    description: str,
+) -> None:
+    if (
+        not isinstance(record, dict)
+        or not isinstance(record.get("names"), dict)
+        or not isinstance(record["names"].get("languages"), dict)
+    ):
+        raise DatasetValidationError(f"{description} names.languages must be an object")
+
+    name_languages = {language for language in official_languages if len(language) == 2}
+    actual_languages = set(record["names"]["languages"])
+    unexpected = sorted(actual_languages - name_languages)
+    if unexpected:
+        raise DatasetValidationError(
+            f"{description} names.languages contains non-official languages: {', '.join(unexpected)}"
+        )
+
+    aliases = record.get("localized_aliases", [])
+    if not isinstance(aliases, list):
+        raise DatasetValidationError(f"{description} localized_aliases must be an array")
+    for index, alias in enumerate(aliases):
+        language = _required_string(
+            alias,
+            "language",
+            f"{description} localized_aliases[{index}]",
+        ).split("-", maxsplit=1)[0].lower()
+        if language != "en" and language not in official_languages:
+            raise DatasetValidationError(
+                f"{description} localized_aliases[{index}] language {language} is not official"
+            )
+
+
+def _definition_for_path(path: str) -> DatasetDefinition:
+    for pattern, domain, schema in DATASET_PATH_PATTERNS:
+        match = pattern.fullmatch(path)
+        if match:
+            country_code = match.group(1) if domain != "country" else None
+            return DatasetDefinition(domain=domain, schema=schema, country_code=country_code)
+    raise DatasetValidationError(f"Unsupported dataset path: {path}")
+
+
+def _list_dataset_files(root: Path) -> list[str]:
+    datasets_directory = _repository_file(root, "datasets")
+    files = []
+    for path in datasets_directory.rglob("*.json"):
+        relative_path = path.relative_to(root).as_posix()
+        if relative_path != "datasets/manifest.json":
+            files.append(relative_path)
+    return sorted(files)
+
+
+def _validate_record_partition(
+    record: object,
+    definition: DatasetDefinition,
+    description: str,
+) -> None:
+    if definition.country_code is None:
+        return
+    if _required_string(record, "country_code", description) != definition.country_code:
+        raise DatasetValidationError(
+            f"{description} country_code does not match {definition.country_code}"
+        )
+
+
+def _english_sort_key(
+    record: object,
+    definition: DatasetDefinition,
+    description: str,
+) -> tuple[str, str]:
+    if definition.domain == "entity":
+        if not isinstance(record, dict) or not isinstance(record.get("names"), dict):
+            raise DatasetValidationError(f"{description} must have an object names")
+        english_name = _required_string(record["names"], "en", f"{description} names")
+    else:
+        english_name = _required_string(record, "name", description)
+    identity = _required_string(record, IDENTITY_FIELDS[definition.domain], description)
+    return (unicodedata.normalize("NFC", english_name).lower(), identity)
+
+
+def _english_sort_warning(dataset: DatasetRecords) -> str | None:
+    previous: tuple[str, str] | None = None
+    for index, record in enumerate(dataset.records):
+        description = f"{dataset.entry['path']}[{index}]"
+        english_name, identity = _english_sort_key(record, dataset.definition, description)
+        current = (english_name, identity)
+        if previous is not None and previous > current:
+            return f"{dataset.entry['path']} is not sorted by English name at record {index}"
+        previous = current
+    return None
+
+
+def _validate_cross_dataset_references(datasets: list[DatasetRecords]) -> None:
+    countries: set[str] = set()
+    country_languages: dict[str, set[str]] = {}
+    subdivisions: dict[str, set[str]] = {}
+    cities: dict[str, set[str]] = {}
+    record_identities: set[tuple[str, str, str]] = set()
+
+    for dataset in datasets:
+        for index, record in enumerate(dataset.records):
+            description = f"{dataset.entry['path']}[{index}]"
+            domain = dataset.definition.domain
+            identity_field = IDENTITY_FIELDS[domain]
+            identity = _required_string(record, identity_field, description)
+            country_code = (
+                ""
+                if domain == "country"
+                else _required_string(record, "country_code", description)
+            )
+            scoped_identity = (domain, country_code, identity)
+            if scoped_identity in record_identities:
+                raise DatasetValidationError(
+                    f"{description} duplicates {identity_field} {identity}"
+                )
+            record_identities.add(scoped_identity)
+
+            if domain == "country":
+                countries.add(identity)
+                country_languages[identity] = _official_non_english_languages(record, description)
+            elif domain == "subdivision":
+                subdivisions.setdefault(country_code, set()).add(identity)
+            elif domain == "city":
+                cities.setdefault(country_code, set()).add(identity)
+
+    for dataset in datasets:
+        for index, record in enumerate(dataset.records):
+            description = f"{dataset.entry['path']}[{index}]"
+            domain = dataset.definition.domain
+            if domain == "country":
+                continue
+
+            country_code = _required_string(record, "country_code", description)
+            if country_code not in countries:
+                raise DatasetValidationError(
+                    f"{description} references unknown country {country_code}"
+                )
+
+            subdivision_code = _optional_string(record, "subdivision_code", description)
+            if (
+                subdivision_code is not None
+                and subdivision_code not in subdivisions.get(country_code, set())
+            ):
+                raise DatasetValidationError(
+                    f"{description} references unknown subdivision {subdivision_code}"
+                )
+
+            if domain == "subdivision":
+                code = _required_string(record, "code", description)
+                parent_code = _optional_string(record, "parent_code", description)
+                if parent_code == code:
+                    raise DatasetValidationError(f"{description} cannot be its own parent")
+                if (
+                    parent_code is not None
+                    and parent_code not in subdivisions.get(country_code, set())
+                ):
+                    raise DatasetValidationError(
+                        f"{description} references unknown parent subdivision {parent_code}"
+                    )
+
+            if domain == "entity":
+                city_id = _optional_string(record, "city_id", description)
+                if city_id is not None and city_id not in cities.get(country_code, set()):
+                    raise DatasetValidationError(f"{description} references unknown city {city_id}")
+                _validate_entity_language_names(
+                    record,
+                    country_languages.get(country_code, set()),
+                    description,
+                )
+
+
+def sort_repository(root_directory: Path) -> None:
+    root = root_directory.resolve(strict=True)
+    manifest_path = _repository_file(root, "datasets/manifest.json")
+    manifest_schema_path = _repository_file(root, "schemas/manifest.schema.json")
+    manifest_value = _read_json(manifest_path)
+    manifest_validator = _schema_validator(
+        _read_json(manifest_schema_path),
+        "schemas/manifest.schema.json",
+    )
+    _validate_instance(manifest_validator, manifest_value, "datasets/manifest.json")
+    manifest = cast(DatasetManifest, manifest_value)
+
+    dataset_paths: set[str] = set()
+    datasets: list[DatasetRecords] = []
+    for entry in manifest["datasets"]:
+        if entry["path"] in dataset_paths:
+            raise DatasetValidationError(f"Duplicate dataset path: {entry['path']}")
+        dataset_paths.add(entry["path"])
+
+        definition = _definition_for_path(entry["path"])
+        data_path = _repository_file(root, entry["path"])
+        schema_path = _repository_file(root, definition.schema)
+        records_value = _read_json(data_path)
+        if not isinstance(records_value, list):
+            raise DatasetValidationError(f"{entry['path']} must contain a JSON array")
+
+        schema = _read_json(schema_path)
+        if definition.domain == "entity":
+            schema = _schema_with_entity_tags(schema, manifest["vocabularies"]["entity_tags"])
+        record_validator = _schema_validator(schema, definition.schema)
+        for index, record in enumerate(records_value):
+            description = f"{entry['path']}[{index}]"
+            _validate_instance(record_validator, record, description)
+            _validate_record_partition(record, definition, description)
+        datasets.append(DatasetRecords(definition, entry, records_value))
+
+    existing_files = _list_dataset_files(root)
+    missing_manifest_entries = sorted(set(existing_files) - dataset_paths)
+    missing_dataset_files = sorted(dataset_paths - set(existing_files))
+    if missing_manifest_entries:
+        raise DatasetValidationError(
+            f"Dataset files missing from manifest: {', '.join(missing_manifest_entries)}"
+        )
+    if missing_dataset_files:
+        raise DatasetValidationError(
+            f"Manifest paths do not exist as dataset files: {', '.join(missing_dataset_files)}"
+        )
+
+    _validate_cross_dataset_references(datasets)
+    for dataset in datasets:
+        dataset.records.sort(key=lambda record: _english_sort_key(
+            record,
+            dataset.definition,
+            dataset.entry["path"],
+        ))
+        contents = canonical_json(dataset.records)
+        data_path = _repository_file(root, dataset.entry["path"])
+        data_path.write_bytes(contents)
+        dataset.entry["sha256"] = hashlib.sha256(contents).hexdigest()
+
+    manifest_path.write_bytes(canonical_json(manifest))
+    validate_repository(root)
+
+
+def validate_repository(root_directory: Path) -> list[str]:
+    root = root_directory.resolve(strict=True)
+    manifest_path = _repository_file(root, "datasets/manifest.json")
+    manifest_schema_path = _repository_file(root, "schemas/manifest.schema.json")
+    manifest_contents = manifest_path.read_bytes()
+    manifest_value = _read_json(manifest_path)
+    try:
+        is_canonical_manifest = canonical_json(manifest_value) == manifest_contents
+    except (TypeError, ValueError) as error:
+        raise DatasetValidationError(f"Manifest cannot be serialized canonically: {error}") from error
+    if not is_canonical_manifest:
+        raise DatasetValidationError("datasets/manifest.json is not canonically serialized")
+
+    manifest_schema = _read_json(manifest_schema_path)
+    manifest_validator = _schema_validator(manifest_schema, "schemas/manifest.schema.json")
+    _validate_instance(manifest_validator, manifest_value, "datasets/manifest.json")
+    manifest = cast(DatasetManifest, manifest_value)
+
+    dataset_paths: set[str] = set()
+    validated_datasets: list[DatasetRecords] = []
+    for entry in manifest["datasets"]:
+        if entry["path"] in dataset_paths:
+            raise DatasetValidationError(f"Duplicate dataset path: {entry['path']}")
+        dataset_paths.add(entry["path"])
+
+        definition = _definition_for_path(entry["path"])
+        data_path = _repository_file(root, entry["path"])
+        schema_path = _repository_file(root, definition.schema)
+        data_bytes = data_path.read_bytes()
+        records_value = _read_json(data_path)
+        try:
+            is_canonical_dataset = canonical_json(records_value) == data_bytes
+        except (TypeError, ValueError) as error:
+            raise DatasetValidationError(
+                f"{entry['path']} cannot be serialized canonically: {error}"
+            ) from error
+        if not is_canonical_dataset:
+            raise DatasetValidationError(f"{entry['path']} is not canonically serialized")
+
+        checksum = hashlib.sha256(data_bytes).hexdigest()
+        if checksum != entry["sha256"]:
+            raise DatasetValidationError(f"Checksum mismatch for {entry['path']}")
+
+        if not isinstance(records_value, list):
+            raise DatasetValidationError(f"{entry['path']} must contain a JSON array")
+
+        schema = _read_json(schema_path)
+        if definition.domain == "entity":
+            schema = _schema_with_entity_tags(schema, manifest["vocabularies"]["entity_tags"])
+        record_validator = _schema_validator(schema, definition.schema)
+        for index, record in enumerate(records_value):
+            description = f"{entry['path']}[{index}]"
+            _validate_instance(record_validator, record, description)
+            _validate_record_partition(record, definition, description)
+        validated_datasets.append(
+            DatasetRecords(definition=definition, entry=entry, records=records_value)
+        )
+
+    existing_files = _list_dataset_files(root)
+    missing_manifest_entries = sorted(set(existing_files) - dataset_paths)
+    missing_dataset_files = sorted(dataset_paths - set(existing_files))
+    if missing_manifest_entries:
+        raise DatasetValidationError(
+            f"Dataset files missing from manifest: {', '.join(missing_manifest_entries)}"
+        )
+    if missing_dataset_files:
+        raise DatasetValidationError(
+            f"Manifest paths do not exist as dataset files: {', '.join(missing_dataset_files)}"
+        )
+
+    warnings = [
+        warning
+        for dataset in validated_datasets
+        if (warning := _english_sort_warning(dataset)) is not None
+    ]
+    _validate_cross_dataset_references(validated_datasets)
+    return warnings

refdatakit-0.1.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: refdatakit
+Version: 0.1.0
+Summary: Source-aware reference data and validation tools
+Author: RefDataKit contributors
+License: MIT
+Project-URL: Homepage, https://github.com/rezwan4029/refdatakit#readme
+Project-URL: Documentation, https://github.com/rezwan4029/refdatakit/blob/main/packages/python/README.md
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema<5,>=4.23
+Requires-Dist: rfc8785<0.2,>=0.1.4
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: ruff>=0.11; extra == "dev"
+Dynamic: license-file
+
+# refdatakit
+
+Source-aware regional reference data and validation tools for Python.
+
+Documentation: [Python package guide](https://github.com/rezwan4029/refdatakit/blob/main/packages/python/README.md) · [Project overview](https://github.com/rezwan4029/refdatakit#readme) · [JavaScript/TypeScript package guide](https://github.com/rezwan4029/refdatakit/blob/main/packages/js/README.md).
+
+Install from PyPI with `pip install refdatakit`. The package includes the versioned JSON datasets. Data access is local and makes no network requests.
+
+```python
+from refdatakit import CountryCode, get_cities, get_country, get_institutions
+
+country = get_country(CountryCode.BD)
+cities = get_cities(CountryCode.BD)
+institutions = get_institutions(CountryCode.BD)
+```
+
+Available accessors are `get_countries()`, `get_country(code)`, `get_cities(code)`, `get_subdivisions(code)`, and `get_institutions(code)`. Country arguments require a generated `CountryCode` enum member; passing a raw string raises `TypeError`. They return dictionaries/lists matching the shared JSON schemas. Source provenance and dataset licenses are recorded in the bundled manifest; dataset terms may differ from the MIT-licensed SDK code.
+
+The `refdatakit validate` and `refdatakit sort` commands are repository maintenance tools. The Python package exposes `validate_repository(path)` and `sort_repository(path)` for contributor workflows.

refdatakit-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+refdatakit/__init__.py,sha256=kI5GZQxnqpm99Ce3rs7AcIGZdyBEmDIcgUJM7xMF0P4,408
+refdatakit/canonical_json.py,sha256=5fi1CnHUrto798yF64ARRo8FP483Oi2JPbbj2GOfL_E,1284
+refdatakit/cli.py,sha256=gg3NkXLMsy6CdRML_Lb7MOhaQqcmQ6pKo407LG4pvYU,1316
+refdatakit/country_codes.py,sha256=__9WxOkOVRhlEfKtV6SEU0bWag0w6ztarji0Yl58lF8,199
+refdatakit/data.py,sha256=1IpmuxjcDiQ5vU3ZEnaZHs9jbEHUkzVSrTA8IXCcB7w,1687
+refdatakit/validator.py,sha256=acFDprPICW8NjzidhHmMLKpjuwo2rrC9ZIFISn3EQjE,19882
+refdatakit/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+refdatakit/data/datasets/manifest.json,sha256=CMb1uQ-cELzNzmSYfxxK5m_IV1NvaRdo_vwCFydiVL4,12146
+refdatakit/data/datasets/cities/by-country/BD.json,sha256=jR2o7_5myELufMG_Q4_0P8_6sVNivN7FQ5ajIoYJlmw,9579
+refdatakit/data/datasets/cities/by-country/BT.json,sha256=aJeoLrKKhL24p5F38KFFcRUV6-8zj_7xdBcK0yOxads,137
+refdatakit/data/datasets/cities/by-country/LK.json,sha256=SEuFX7mhNHh9nd5QobXaWo-Iat7p6skVFlLRVSlOgKM,1035
+refdatakit/data/datasets/cities/by-country/MV.json,sha256=UPA3CFrP0NVk3qXEu9ofp0QxVzXJjVpwsBNiqAELO3I,298
+refdatakit/data/datasets/cities/by-country/NP.json,sha256=970Kcea0vrAa0GRHCFBdGmc8rfpqYlwefRUplYjdtZA,820
+refdatakit/data/datasets/cities/by-country/SG.json,sha256=LlScLCZx-y0Hc9q12aldXEx8eoAfU00KHWBD5N3dK7M,268
+refdatakit/data/datasets/countries/data.json,sha256=L1z9LrnGBFR-cWl13Qp0kCCTX0lg7uVB9MnB30TPkU4,898
+refdatakit/data/datasets/institutions/by-country/BD.json,sha256=i0IhTm2RxyUoI0Jy-SDAGhmS9tB6f-Tqj-Hj2cgsJYU,91614
+refdatakit/data/datasets/institutions/by-country/BT.json,sha256=I9GP2H0SKpa3VuADOCftMfncvTXrB7cfqO3kSDq2SmQ,1940
+refdatakit/data/datasets/institutions/by-country/LK.json,sha256=IdJlHOkkXQbAlG3xLMyvQ_A6-ioaweTygL1JZRZgKNo,6024
+refdatakit/data/datasets/institutions/by-country/MV.json,sha256=jsf6FK5I90pgb2ICfSzwMk3LogcwPb6-4mpKIbrnKnA,1854
+refdatakit/data/datasets/institutions/by-country/NP.json,sha256=qNQBLYGiAyH2ljyyT1J-xHYcd9_8kiR0r6cjRmtr8D4,3851
+refdatakit/data/datasets/institutions/by-country/SG.json,sha256=yQI_KbunUli1H8G51KKXn7Gx-_RjgybN5zrdGhJvqHw,6014
+refdatakit/data/datasets/subdivisions/by-country/BD.json,sha256=nm3TZ2gE4ZQcz7kOJGLB6oBv6hruLsik4PEO1ad5yzg,1315
+refdatakit/data/schemas/city.schema.json,sha256=lU2Gd0Q5amw2N5UoF_1r57bWTUkboOvEeePAIK-EABA,1880
+refdatakit/data/schemas/country.schema.json,sha256=MAumIg--QmDw2vzBgf4LvwZmTQXbrdS3F8EgldjMG2I,2507
+refdatakit/data/schemas/entity.schema.json,sha256=z4XqIkBAn3uwog03dTY92OUpkSTLoAJkgu9rVDTV-bs,3968
+refdatakit/data/schemas/manifest.schema.json,sha256=3eQHV6AVX9s2kJ_xyafkjiwBUvtoiVsKthg4m6a64q8,2524
+refdatakit/data/schemas/subdivision.schema.json,sha256=kkFwOjr4nF3nt9bJ2_bLiCpBw0IVafqsUfKS9zATb0Y,1500
+refdatakit-0.1.0.dist-info/licenses/LICENSE,sha256=AceJ6-88pwOg59nr84IL_4dpAhVEDS6z6WFs-desMSc,1080
+refdatakit-0.1.0.dist-info/METADATA,sha256=zWDItqvNs1IABJvzUy0GiHxEJxQpGEIH6Jx6KJQbHe8,2120
+refdatakit-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+refdatakit-0.1.0.dist-info/entry_points.txt,sha256=A-SRkK17ZyVgzJeSzamHVEvyk39GMtS6O68cRC-KyVk,51
+refdatakit-0.1.0.dist-info/top_level.txt,sha256=VBQQ0UDfxMi-_R31XZhviStJjkPoQ1mEGEJDEKI2M2k,11
+refdatakit-0.1.0.dist-info/RECORD,,

refdatakit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

refdatakit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+refdatakit = refdatakit.cli:main

refdatakit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RefDataKit contributors
+
+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.

refdatakit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+refdatakit