sdmxlib 0.8.0__py3-none-any.whl

sdmxlib/storage/writers.py

@@ -0,0 +1,503 @@
+"""Write SDMX domain objects to DuckDB normalized tables.
+
+Flattens domain objects into the normalized schema defined by
+``storage.schema``. Language-specific columns are populated based
+on the configured language list stored in ``_meta``.
+
+Example::
+
+    from sdmxlib.storage import schema, writers
+
+    conn = duckdb.connect("store.duckdb")
+    schema.create_tables(conn, languages=["en", "fr"])
+    writers.put_codelist(conn, codelist)
+"""
+
+import json
+from typing import Any
+
+import duckdb
+
+from sdmxlib.model.annotations import Annotations
+from sdmxlib.model.codelist import Codelist
+from sdmxlib.model.concept import ConceptScheme
+from sdmxlib.model.convert import to_dict
+from sdmxlib.model.dataflow import Dataflow
+from sdmxlib.model.datastructure import DataStructure
+from sdmxlib.model.hierarchy import Hierarchy
+from sdmxlib.model.istring import InternationalString
+from sdmxlib.model.ref import HasUrn, Ref
+from sdmxlib.model.registry import _artefact_urn
+from sdmxlib.storage.schema import get_languages
+
+# Map Python class → type_name string for artefact_type column
+_CLASS_TO_NAME: dict[type, str] = {
+    Codelist: "Codelist",
+    ConceptScheme: "ConceptScheme",
+    DataStructure: "DataStructure",
+    Dataflow: "Dataflow",
+    Hierarchy: "Hierarchy",
+}
+
+# Try to import optional types that may or may not be used
+try:
+    from sdmxlib.model.category import Categorisation, CategoryScheme
+    from sdmxlib.model.constraint import ContentConstraint
+    from sdmxlib.model.mapping import StructureSet
+    from sdmxlib.model.organisation import AgencyScheme, DataProviderScheme
+    from sdmxlib.model.provision import ProvisionAgreement
+
+    _CLASS_TO_NAME.update(
+        {
+            ContentConstraint: "ContentConstraint",
+            CategoryScheme: "CategoryScheme",
+            Categorisation: "Categorisation",
+            ProvisionAgreement: "ProvisionAgreement",
+            AgencyScheme: "AgencyScheme",
+            DataProviderScheme: "DataProviderScheme",
+            StructureSet: "StructureSet",
+        }
+    )
+except ImportError:
+    pass
+
+
+# ── Helpers ─────────────────────────────────────────────────────────────
+
+
+def _istring_lang_values(
+    s: InternationalString | None,
+    languages: list[str],
+) -> list[str | None]:
+    """Extract values for each configured language from an InternationalString."""
+    if not s:
+        return [None] * len(languages)
+    return [s.get(lang) if lang in s else None for lang in languages]
+
+
+def _annotations_json(annotations: Annotations | None) -> str | None:
+    if not annotations:
+        return None
+    result = []
+    for a in annotations:
+        d: dict[str, Any] = {}
+        if a.id is not None:
+            d["id"] = a.id
+        if a.title is not None:
+            d["title"] = a.title
+        if a.type is not None:
+            d["type"] = a.type
+        if a.url is not None:
+            d["url"] = a.url
+        if a.text:
+            d["text"] = {lang: a.text[lang] for lang in a.text}
+        result.append(d)
+    return json.dumps(result)
+
+
+def _lang_cols(prefix: str, languages: list[str]) -> list[str]:
+    """Build column names like ['name_en', 'name_fr'] for a prefix."""
+    return [f"{prefix}_{lang}" for lang in languages]
+
+
+def _execute_insert(
+    conn: duckdb.DuckDBPyConnection,
+    table: str,
+    cols: list[str],
+    vals: list[Any],
+) -> None:
+    """Execute a parameterised INSERT.
+
+    Column names come from our own schema definitions (language config),
+    never from user input — SQL injection is not a concern here.
+    """
+    placeholders = ", ".join(["?"] * len(vals))
+    col_str = ", ".join(cols)
+    conn.execute(
+        f"""
+        INSERT INTO {table} ({col_str})
+        VALUES ({placeholders})
+        """,  # noqa: S608
+        vals,
+    )
+
+
+def _execute_upsert(
+    conn: duckdb.DuckDBPyConnection,
+    table: str,
+    cols: list[str],
+    vals: list[Any],
+) -> None:
+    """INSERT OR REPLACE for tables with a single unique/PK constraint."""
+    placeholders = ", ".join(["?"] * len(vals))
+    col_str = ", ".join(cols)
+    conn.execute(
+        f"""
+        INSERT OR REPLACE INTO {table} ({col_str})
+        VALUES ({placeholders})
+        """,  # noqa: S608
+        vals,
+    )
+
+
+# ── Artefact table helpers ──────────────────────────────────────────────
+
+
+def _put_artefact_row(
+    conn: duckdb.DuckDBPyConnection,
+    urn: str,
+    artefact_type: str,
+    artefact: Any,
+    doc: str,
+    languages: list[str],
+) -> None:
+    """Insert or replace a row in the artefacts table."""
+    name_vals = _istring_lang_values(getattr(artefact, "name", None), languages)
+    desc_vals = _istring_lang_values(getattr(artefact, "description", None), languages)
+    is_final = getattr(artefact, "is_final", False)
+
+    cols = ["urn", "artefact_type", "agency", "id", "version", "is_final"]
+    vals: list[Any] = [urn, artefact_type, artefact.agency_id, artefact.id, artefact.version, is_final]
+
+    cols.extend(_lang_cols("name", languages))
+    vals.extend(name_vals)
+
+    cols.extend(_lang_cols("description", languages))
+    vals.extend(desc_vals)
+
+    cols.append("_document")
+    vals.append(doc)
+
+    # artefacts has PK + UNIQUE constraint; DELETE+INSERT to avoid
+    # DuckDB's "multiple unique constraints" binder error.
+    conn.execute(
+        """
+        DELETE FROM artefacts WHERE urn = $urn
+    """,
+        {"urn": urn},
+    )
+    _execute_insert(conn, "artefacts", cols, vals)
+
+
+# ── Public writers ──────────────────────────────────────────────────────
+
+
+def put_codelist(conn: duckdb.DuckDBPyConnection, cl: Codelist) -> None:
+    """Write a Codelist to artefacts + codelists + codes tables."""
+    languages = get_languages(conn)
+    urn = str(_artefact_urn(cl))
+
+    d = to_dict(cl)
+    d.pop("codes", None)
+    doc = json.dumps(d)
+
+    # artefacts row
+    _put_artefact_row(conn, urn, "Codelist", cl, doc, languages)
+
+    # codelists row
+    cl_cols = ["urn", "agency", "id", "version"]
+    cl_vals: list[Any] = [urn, cl.agency_id, cl.id, cl.version]
+    cl_cols.extend(_lang_cols("name", languages))
+    cl_vals.extend(_istring_lang_values(cl.name, languages))
+    cl_cols.append("is_partial")
+    cl_vals.append(False)
+    _execute_upsert(conn, "codelists", cl_cols, cl_vals)
+
+    # codes rows — delete old, insert new
+    conn.execute(
+        """
+        DELETE FROM codes WHERE codelist_urn = $urn
+    """,
+        {"urn": urn},
+    )
+    for position, code in enumerate(cl.codes):
+        code_cols = ["codelist_urn", "code_id", "parent_code_id", "position"]
+        code_vals: list[Any] = [urn, code.id, code.parent_id, position]
+        code_cols.extend(_lang_cols("label", languages))
+        code_vals.extend(_istring_lang_values(code.name, languages))
+        code_cols.extend(_lang_cols("description", languages))
+        code_vals.extend(_istring_lang_values(code.description, languages))
+        code_cols.append("_annotations")
+        code_vals.append(_annotations_json(code.annotations))
+        _execute_insert(conn, "codes", code_cols, code_vals)
+
+
+def put_data_structure(conn: duckdb.DuckDBPyConnection, dsd: DataStructure) -> None:
+    """Write a DataStructure to artefacts + data_structures + dsd_components."""
+    languages = get_languages(conn)
+    urn = str(_artefact_urn(dsd))
+    doc = json.dumps(to_dict(dsd))
+
+    _put_artefact_row(conn, urn, "DataStructure", dsd, doc, languages)
+
+    # data_structures row
+    ds_cols = ["urn", "agency", "id", "version"]
+    ds_vals: list[Any] = [urn, dsd.agency_id, dsd.id, dsd.version]
+    ds_cols.extend(_lang_cols("name", languages))
+    ds_vals.extend(_istring_lang_values(dsd.name, languages))
+    _execute_upsert(conn, "data_structures", ds_cols, ds_vals)
+
+    # dsd_components — delete old, insert new
+    conn.execute(
+        """
+        DELETE FROM dsd_components WHERE dsd_urn = $urn
+    """,
+        {"urn": urn},
+    )
+
+    components: list[tuple[str, Any]] = [("Dimension", dim) for dim in dsd.dimensions]
+    if dsd.time_dimension is not None:
+        components.append(("TimeDimension", dsd.time_dimension))
+    components.extend(("Attribute", attr) for attr in dsd.attributes)
+    components.extend(("Measure", m) for m in dsd.measures)
+
+    for position, (comp_type, comp) in enumerate(components):
+        concept_ref = getattr(comp, "concept", None)
+        concept_id = None
+        concept_urn_str = None
+        concept_name: InternationalString | None = None
+        if isinstance(concept_ref, Ref):
+            c_urn = concept_ref.urn
+            concept_urn_str = str(c_urn)
+            concept_id = getattr(c_urn, "item_id", None) or getattr(c_urn, "id", None)
+            if concept_ref.resolved:
+                concept_name = concept_ref().name
+
+        rep = getattr(comp, "representation", None)
+        codelist_urn = str(rep.urn) if isinstance(rep, Ref) else None
+
+        attachment = getattr(comp, "attachment", None)
+        attachment_str = attachment.value if attachment is not None else None
+
+        comp_cols = ["dsd_urn", "component_id", "component_type", "position", "concept_id", "concept_urn"]
+        comp_vals: list[Any] = [urn, comp.id, comp_type, position, concept_id, concept_urn_str]
+        comp_cols.extend(_lang_cols("concept_name", languages))
+        comp_vals.extend(_istring_lang_values(concept_name, languages))
+        comp_cols.extend(["codelist_urn", "attachment_level"])
+        comp_vals.extend([codelist_urn, attachment_str])
+        _execute_insert(conn, "dsd_components", comp_cols, comp_vals)
+
+
+def put_dataflow(conn: duckdb.DuckDBPyConnection, flow: Dataflow) -> None:
+    """Write a Dataflow to artefacts + dataflows tables."""
+    languages = get_languages(conn)
+    urn = str(_artefact_urn(flow))
+    doc = json.dumps(to_dict(flow))
+
+    _put_artefact_row(conn, urn, "Dataflow", flow, doc, languages)
+
+    dsd_urn = str(flow.structure.urn) if flow.structure is not None else None
+    df_cols = ["urn", "agency", "id", "version"]
+    df_vals: list[Any] = [urn, flow.agency_id, flow.id, flow.version]
+    df_cols.extend(_lang_cols("name", languages))
+    df_vals.extend(_istring_lang_values(flow.name, languages))
+    df_cols.extend(_lang_cols("description", languages))
+    df_vals.extend(_istring_lang_values(flow.description, languages))
+    df_cols.append("dsd_urn")
+    df_vals.append(dsd_urn)
+    _execute_upsert(conn, "dataflows", df_cols, df_vals)
+
+
+def put_concept_scheme(conn: duckdb.DuckDBPyConnection, cs: ConceptScheme) -> None:
+    """Write a ConceptScheme to artefacts + concept_schemes + concepts tables."""
+    languages = get_languages(conn)
+    urn = str(_artefact_urn(cs))
+    doc = json.dumps(to_dict(cs))
+
+    _put_artefact_row(conn, urn, "ConceptScheme", cs, doc, languages)
+
+    # concept_schemes row
+    cs_cols = ["urn", "agency", "id", "version"]
+    cs_vals: list[Any] = [urn, cs.agency_id, cs.id, cs.version]
+    cs_cols.extend(_lang_cols("name", languages))
+    cs_vals.extend(_istring_lang_values(cs.name, languages))
+    _execute_upsert(conn, "concept_schemes", cs_cols, cs_vals)
+
+    # concepts — delete old, insert new
+    conn.execute(
+        """
+        DELETE FROM concepts WHERE scheme_urn = $urn
+    """,
+        {"urn": urn},
+    )
+    for concept in cs.concepts:
+        c_cols = ["scheme_urn", "concept_id"]
+        c_vals: list[Any] = [urn, concept.id]
+        c_cols.extend(_lang_cols("name", languages))
+        c_vals.extend(_istring_lang_values(concept.name, languages))
+        c_cols.extend(_lang_cols("description", languages))
+        c_vals.extend(_istring_lang_values(concept.description, languages))
+        _execute_insert(conn, "concepts", c_cols, c_vals)
+
+
+def put_hierarchy(conn: duckdb.DuckDBPyConnection, h: Hierarchy) -> None:
+    """Write a Hierarchy to artefacts + hierarchy_nodes tables."""
+    languages = get_languages(conn)
+    urn = str(_artefact_urn(h))
+
+    d = to_dict(h)
+    d.pop("tree", None)
+    doc = json.dumps(d)
+
+    _put_artefact_row(conn, urn, "Hierarchy", h, doc, languages)
+
+    conn.execute(
+        """
+        DELETE FROM hierarchy_nodes WHERE hierarchy_urn = $urn
+    """,
+        {"urn": urn},
+    )
+
+    rows: list[list[Any]] = []
+    _flatten_hierarchy_nodes(urn, to_dict(h).get("tree", []), None, rows, languages)
+
+    n_cols = ["hierarchy_urn", "node_id", "parent_node_id", "code_urn"]
+    n_cols.extend(_lang_cols("name", languages))
+    n_cols.extend(_lang_cols("description", languages))
+    n_cols.extend(["_annotations", "valid_from", "valid_to"])
+    for row in rows:
+        _execute_insert(conn, "hierarchy_nodes", n_cols, row)
+
+
+def _flatten_hierarchy_nodes(
+    urn: str,
+    nodes: list[dict[str, Any]],
+    parent_id: str | None,
+    rows: list[list[Any]],
+    languages: list[str],
+) -> None:
+    """Recursively flatten hierarchy tree into flat rows."""
+    for node in nodes:
+        code_urn = node.get("code")
+        name_dict = node.get("name")
+        desc_dict = node.get("description")
+
+        name_vals = [name_dict.get(lang) if name_dict else None for lang in languages]
+        desc_vals = [desc_dict.get(lang) if desc_dict else None for lang in languages]
+        anns_json = json.dumps(node["annotations"]) if node.get("annotations") else None
+
+        row: list[Any] = [urn, node["id"], parent_id, code_urn]
+        row.extend(name_vals)
+        row.extend(desc_vals)
+        row.extend([anns_json, node.get("valid_from"), node.get("valid_to")])
+        rows.append(row)
+
+        children = node.get("children", [])
+        if children:
+            _flatten_hierarchy_nodes(urn, children, node["id"], rows, languages)
+
+
+def put_artefact(conn: duckdb.DuckDBPyConnection, artefact: Any) -> None:
+    """Write any supported artefact, dispatching to the appropriate writer.
+
+    For Codelists, DataStructures, Dataflows, ConceptSchemes, and
+    Hierarchies, writes to both the artefacts table and the relevant
+    normalized tables. For all other types, writes only to the artefacts
+    table with a JSON document.
+    """
+    if not isinstance(artefact, HasUrn):
+        msg = (
+            f"{type(artefact).__name__} does not satisfy HasUrn — "
+            "it needs sdmx_package, sdmx_class, agency_id, id, version"
+        )
+        raise TypeError(msg)
+
+    if isinstance(artefact, Codelist):
+        put_codelist(conn, artefact)
+    elif isinstance(artefact, DataStructure):
+        put_data_structure(conn, artefact)
+    elif isinstance(artefact, Dataflow):
+        put_dataflow(conn, artefact)
+    elif isinstance(artefact, ConceptScheme):
+        put_concept_scheme(conn, artefact)
+    elif isinstance(artefact, Hierarchy):
+        put_hierarchy(conn, artefact)
+    else:
+        _put_blob(conn, artefact)
+
+
+def _put_blob(conn: duckdb.DuckDBPyConnection, artefact: Any) -> None:
+    """Fallback: write artefact as JSON blob only (no normalized tables)."""
+    languages = get_languages(conn)
+    urn = str(_artefact_urn(artefact))
+    type_name = _CLASS_TO_NAME.get(type(artefact))
+    if type_name is None:
+        msg = f"Unsupported artefact type: {type(artefact).__name__}"
+        raise TypeError(msg)
+    doc = json.dumps(to_dict(artefact))
+    _put_artefact_row(conn, urn, type_name, artefact, doc, languages)
+
+
+def drop_artefact(conn: duckdb.DuckDBPyConnection, urn: str) -> bool:
+    """Delete an artefact and its child rows (manual cascade).
+
+    Returns True if the artefact existed and was deleted.
+    """
+    params = {"urn": urn}
+    conn.execute(
+        """
+        DELETE FROM codes WHERE codelist_urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM codelists WHERE urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM dsd_components WHERE dsd_urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM data_structures WHERE urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM dataflows WHERE urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM concepts WHERE scheme_urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM concept_schemes WHERE urn = $urn
+    """,
+        params,
+    )
+    conn.execute(
+        """
+        DELETE FROM hierarchy_nodes WHERE hierarchy_urn = $urn
+    """,
+        params,
+    )
+
+    result = conn.execute(
+        """
+        DELETE FROM artefacts WHERE urn = $urn RETURNING urn
+    """,
+        params,
+    ).fetchone()
+    return result is not None
+
+
+def ingest_registry(conn: duckdb.DuckDBPyConnection, registry: Any) -> None:
+    """Bulk-import all artefacts from a Registry into DuckDB storage.
+
+    Iterates over the registry's internal store and writes each artefact
+    using :func:`put_artefact`.
+    """
+    store: dict[str, Any] = getattr(registry, "_store", {})
+    for artefact in store.values():
+        put_artefact(conn, artefact)

sdmxlib-0.8.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.3
+Name: sdmxlib
+Version: 0.8.0
+Summary: SDMX structural metadata library for Python
+Keywords: sdmx,statistics,metadata,datastructure
+Author: gabrielgellner
+Author-email: gabrielgellner <gabrielgellner@gmail.com>
+License: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Dist: attrs>=26.1.0
+Requires-Dist: duckdb>=1.0.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: polars>=1.39.3
+Requires-Python: >=3.12
+Project-URL: Homepage, https://gitlab.com/gabrielgellner/sdmxlib
+Project-URL: Repository, https://gitlab.com/gabrielgellner/sdmxlib
+Project-URL: Documentation, https://gabrielgellner.gitlab.io/sdmxlib
+Project-URL: Changelog, https://gitlab.com/gabrielgellner/sdmxlib/-/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# sdmxlib
+
+> **Note:** This library has been written extensively with AI assistance
+> (Claude Code). Users who are not comfortable with AI-generated code should
+> take that into account before adopting it.
+
+SDMX structural metadata library for Python. Fetch and navigate Data Structure
+Definitions, Codelists, Dataflows, and related artefacts from any SDMX REST
+endpoint — with plain attribute access, no XML or URN chasing required.
+
+## Quick start
+
+```python
+import sdmxlib as sl
+
+with sl.RestRegistry(sl.Provider.BIS) as reg:
+    dsd = reg.get(sl.DataStructure, agency="BIS", id="WS_CBPOL").resolve()
+
+    for dim in dsd.dimensions:
+        if dim.is_enumerated:
+            cl = dim.representation()
+            print(f"{dim.id}: {cl.id} ({len(cl.codes)} codes)")
+```
+
+```
+FREQ: CL_FREQ (7 codes)
+REF_AREA: CL_BIS_IF_REF_AREA (44 codes)
+INSTR_ASSET: CL_INSTR_ASSET (12 codes)
+BORROWER_CTY: CL_BIS_IF_REF_AREA (44 codes)
+```
+
+## Installation
+
+```bash
+uv add "sdmxlib @ git+https://gitlab.com/gabrielgellner/sdmxlib.git"
+```
+
+## What it does
+
+- Connects to any SDMX 2.1 or 3.0 REST endpoint; built-in shortcuts for ECB,
+  BIS, ESTAT, IMF, OECD, and the SDMX Global Registry via `sl.Provider`
+- Three resolution modes: `browse()` for catalogue scanning, `fetch()` for
+  unresolved artefacts, `resolve()` for the full reference graph (with optional
+  constraint-trimming via `partial=True/False`)
+- Returns fully resolved domain objects with plain attribute access — no XML,
+  no URN chasing
+- Filter collections with lambdas or the `item()` expression API
+- Build SDMX artefacts locally and serialise to SDMX-ML or SDMX-JSON
+- `LocalRegistry` -- a DuckDB-backed persistent store for offline access
+  with lazy codelist loading, automatic Ref resolution, and direct SQL
+  code maps; supports shared connections and configurable language columns
+- Integrates with [Polars](https://pola.rs) for schema generation and data
+  validation
+- Fully typed — IDE completion and static analysis work throughout
+
+## Documentation
+
+See the [docs](https://gabrielgellner.gitlab.io/sdmxlib/) for the full cookbook,
+including:
+
+- Connecting to registries and choosing a resolution mode
+- Persisting artefacts in a local DuckDB store with `LocalRegistry`
+- Fetching observation data with `sl.dim()` filters and pivoting to wide format
+- Inspecting DSDs and building code maps for ETL pipelines
+- Generating Polars schemas from SDMX Data Structure Definitions
+- Browsing data catalogs and filtering dataflows
+- Working with constraints, hierarchies, and serialisation
+
+## Development
+
+```bash
+just check           # lint + typecheck
+just test            # unit tests
+just test-integration  # live endpoint tests (requires network)
+just ci              # full pre-commit gate
+```

sdmxlib-0.8.0.dist-info/RECORD

@@ -0,0 +1,58 @@
+sdmxlib/__init__.py,sha256=kywSlc7M0H-YIDn7H7re2iebQs5KKtzMN_Az0qgGLDg,3125
+sdmxlib/api/__init__.py,sha256=yNPFuM9w5OEAuXqWzpV9ZxKPOrfg75iF7AwMnTF3wtE,301
+sdmxlib/api/client.py,sha256=hKWcG3Vy5JWjYxNowrI8wiLkAq-naqSJ-w-7kcUd8Lo,8761
+sdmxlib/api/filters.py,sha256=0oH_hFJwGpOQxjnVsbxI3GO-IbxGuIxdR_JlBXFccpo,1966
+sdmxlib/api/providers.py,sha256=8Jxf2WOOIMLl91iwRrOOXmW3VQe34cx7uA4e4FkT9qk,2201
+sdmxlib/api/query.py,sha256=GqjBhYA7iESV97DJnxMOT1DVTAuccxYz3hobFDCco9k,15801
+sdmxlib/api/registry.py,sha256=hAs_0x5plGZ1GfNiMICbrQlb6XRKeOijRAHAtdcOFVQ,25619
+sdmxlib/api/session.py,sha256=8dipduGvKAx19Fd5W4U67_79c_l6V0RL67inUFRmfd0,5288
+sdmxlib/formats/__init__.py,sha256=acm1AHbZwKXbgFD13Ien6yK_X-vuaxRXzT9W6oJ5JCw,5772
+sdmxlib/formats/sdmx_csv/__init__.py,sha256=0_N-eOgYfNrkfakZ1NUwgfxV0EbKZhAmhBy3O8iX9ck,114
+sdmxlib/formats/sdmx_csv/reader.py,sha256=SjMgqc0CYjXprzcJwKkGOOO06aBs8myPFRiMyFyc5jw,4856
+sdmxlib/formats/sdmx_json/__init__.py,sha256=7RrczMcD9X1PRRll5CvYef79PZ88v0JYeLZ_gkusED0,68
+sdmxlib/formats/sdmx_json/reader.py,sha256=5XhRNvYUC91FrTJNJlTQNEfOUqNWfIM2WH07on36xmU,35657
+sdmxlib/formats/sdmx_json/writer.py,sha256=t2cIvMCN1nBsLsxNfVzw73YX17BFxLJkpjKICdRxmoE,25327
+sdmxlib/formats/sdmx_ml21/__init__.py,sha256=sjCtD5QNb6VZrAoq3Tu0yc9lvuXBLrnisk78lFnwUT0,104
+sdmxlib/formats/sdmx_ml21/namespaces.py,sha256=IjlTboUJxrUrSYxUE8fkvQTsHwJsmmwkcOEQEDaGfTE,512
+sdmxlib/formats/sdmx_ml21/reader.py,sha256=REf51p9UxKeZDkjENPkS2bZkP6EpsiQUm3tKKosdVQ0,44203
+sdmxlib/formats/sdmx_ml21/writer.py,sha256=VzDNP4P2jTo1kIZablfcrIefscbgvoZT_MF1GmU3ikw,27998
+sdmxlib/formats/sdmx_ml30/__init__.py,sha256=qngL-lSQued5Qmy-Sfr3X-CRq8tjHAFSCu5oqU7tDMg,33
+sdmxlib/formats/sdmx_ml30/namespaces.py,sha256=orsdl9Il2AiU-tIe6xjoB2nMJyDCsF5WTghqUhHeSII,512
+sdmxlib/formats/sdmx_ml30/reader.py,sha256=FkBh2tNoCSv25Qm_jyTYIocMBBomsTfQu7AUDcFy8FI,43886
+sdmxlib/formats/sdmx_ml30/writer.py,sha256=7e6twXGErIP-ttnWsRkeaD3KyiJqxkZNwb9a50j-RZA,28759
+sdmxlib/local/__init__.py,sha256=ChpMTPfDW1umZRmG5zkc4i3_ahZlDgTBv32WtH9QvsM,233
+sdmxlib/local/_registry.py,sha256=OkYptstdlMEnvjZQAxj2YZg9NreepNS0cCPkcHvGSI8,14280
+sdmxlib/model/__init__.py,sha256=orY-ju8-l8A4h3c_ZF89j_w7PLToPiMDCExU1Z4qUos,3137
+sdmxlib/model/annotations.py,sha256=AqChfYEeZ5ZTgArSi6E9vlGG6U7hHumiRDAqLFoV2aE,3697
+sdmxlib/model/base.py,sha256=ieXvUbilBHnlfczh7OSIBGPWgR9rWN4OiXaGHXLUvmc,1956
+sdmxlib/model/category.py,sha256=KzbJ6QFoXjjtirTZlHYkwbA7yawrpsf_eKdoJpN7GgQ,3649
+sdmxlib/model/codelist.py,sha256=fwTknAnLQCF0WHxwdbdsh5pOkLF7TU1kmMGjXjmTtfI,3488
+sdmxlib/model/collections.py,sha256=TX-vLZ7coJd1HtIxVD7Z6BXXID-K0YV9EwVBuX9BwwM,15486
+sdmxlib/model/concept.py,sha256=BbYRZXPaGrYWUV8iTK0b8ZBQwktaSqzwr1oIqiWs1yE,4606
+sdmxlib/model/constraint.py,sha256=pwL5D05bV2eAIsZ9GivaDAyQtghh4Ws6NaFHMQtaZsI,2920
+sdmxlib/model/convert.py,sha256=5SkonvpiVxeALNHocyWj8k7o7UB3JZ5PAWij6CMqbcc,9436
+sdmxlib/model/dataflow.py,sha256=z_zHg7XCgosK04u5rLUop057A--UqkuWliQXxdnVcYo,1780
+sdmxlib/model/dataset.py,sha256=LLH1oOh92mTWkK9MtxzN8704sMqGosKXPJISFyHjCqQ,14753
+sdmxlib/model/datastructure.py,sha256=X0f7OpsmWc0YeNBljMV9hJDLbksttCLP9mFwOfQMVro,15549
+sdmxlib/model/expr.py,sha256=0a88sKBRUC_sUvvKL066kkX2PFVXXrmJYN24qs3sjps,4299
+sdmxlib/model/hierarchy.py,sha256=qMCYCfanURzAELlfI3dCl16adL-GHi2yP-xTgM1trpY,4165
+sdmxlib/model/istring.py,sha256=9956ucw2730ByddDBTj4SKM0ynvI13nXAJnisvkx8YM,2748
+sdmxlib/model/mapping.py,sha256=yyBDvZy1DSji5PfmC1XamUHF7G3YFm16GK_ZTgduuiY,4335
+sdmxlib/model/message.py,sha256=lwRKRLWwZrgzEelD9-9qpwVG_PVaJwKwzR-tPUaT9vc,3199
+sdmxlib/model/organisation.py,sha256=TCC_YmtGFy3UYr_FZ83b8tuwFcQpvbakKJnjc-0RxL8,6047
+sdmxlib/model/provision.py,sha256=FxMoNFYoVlfuqrUtqm_DXeR8Ey4itEhowh1mDsqMAGc,1653
+sdmxlib/model/ref.py,sha256=zdG6j5z-TyBvKxPxe6HkQ5337b0OkuAjEz-T3PW93XQ,6978
+sdmxlib/model/registry.py,sha256=hQ7dL3BWquYiimidjwddknZiEzHX6dAcnTDrKCy8z4o,7492
+sdmxlib/model/representation.py,sha256=W_5R0_WZjnXy5_7Uc5e0Y4YQGfw-M4Kx9uDQcAV6g_0,3018
+sdmxlib/model/urn.py,sha256=h16i_xSjZKxYwDbBcwGKS9Do-zg5fl5Zc5dRzRevbVM,4621
+sdmxlib/model/validation.py,sha256=KlaC03RNbMLpz56P8PxBci9ndKQVwe-PdhRi5K4Q98c,12991
+sdmxlib/polars.py,sha256=lWO6gwYiS73UKVeofMDWadHCsgd6I_0Vqwsl4xWb-UU,14769
+sdmxlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdmxlib/storage/__init__.py,sha256=1TT_oYx3EjtlxBMrJPIHjaJWbTz-X-wSTLEkg6UHLMQ,771
+sdmxlib/storage/lazy.py,sha256=TouG-6UgQ1_z6SSnUr7hbNOaps96MUBcT7ZNG6gJhgA,10637
+sdmxlib/storage/readers.py,sha256=9WfybYgvYV1rTNS1PHkZj0Fd5J0W7vgjbEfvb05d2Xw,10052
+sdmxlib/storage/schema.py,sha256=f65jf2eSaP4Lr5PVGtt7wzk4YWP_Hx844IOI2MWvkZY,9496
+sdmxlib/storage/writers.py,sha256=STbXpol4OtYEifqXF6AtFNCEHpABDLlPWrAOue_da-Q,17182
+sdmxlib-0.8.0.dist-info/WHEEL,sha256=s_zqWxHFEH8b58BCtf46hFCqPaISurdB9R1XJ8za6XI,80
+sdmxlib-0.8.0.dist-info/METADATA,sha256=Y0Je7YwuyR9fbp_TGn618D1shjAvknU0rMG0VMttI1E,3824
+sdmxlib-0.8.0.dist-info/RECORD,,

sdmxlib-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.6
+Root-Is-Purelib: true
+Tag: py3-none-any