sdmxlib 0.62.2__tar.gz → 0.64.0__tar.gz

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sdmxlib
-Version: 0.62.2
+Version: 0.64.0
 Summary: SDMX structural metadata library for Python
 Keywords: sdmx,statistics,metadata,datastructure
 Author: gabrielgellner

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sdmxlib"
-version = "0.62.2"
+version = "0.64.0"
 description = "SDMX structural metadata library for Python"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -140,7 +140,7 @@ mutate_only_covered_lines = false
 
 [dependency-groups]
 dev = [
-    "basedpyright>=1.39.9,<1.40",
+    "basedpyright==1.39.9",
     "catppuccin[pygments]>=2.5.0",
     "types-lxml>=2025.3.30",
     "mkdocs-material>=9.7.6",

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sdmxlib"
-version = "0.62.2"
+version = "0.64.0"
 description = "SDMX structural metadata library for Python"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -220,7 +220,16 @@ dev = [
   # ruff on `select = ["ALL"]` that is not hypothetical: ruff 0.16.0
   # stabilised 12 preview rules and would have turned CI red with no commit
   # of ours in between. Bump these deliberately, in their own MR.
-  "basedpyright>=1.39.9,<1.40",
+  #
+  # basedpyright is pinned *exactly*, because the bound above was not enough:
+  # 1.39.10 is a patch release built on pyright 1.1.412, which stopped solving
+  # a generic class passed as a `Callable[[], R]` factory from the declared
+  # type — `x: Box[int] = make(Box)` is an error there and fine on 1.1.411.
+  # Every `field(factory=ItemList, ...)` in the model is that shape, so a fresh
+  # environment failed `just check` with 44 errors and no commit of ours in
+  # between. Still broken on pyright 1.1.414 / basedpyright 1.40.2. The pin
+  # goes with basedpyright itself in the pyrefly-only migration.
+  "basedpyright==1.39.9",
   "catppuccin[pygments]>=2.5.0",
   "types-lxml>=2025.3.30",
   "mkdocs-material>=9.7.6",

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/src/sdmxlib/__init__.py

@@ -11,6 +11,7 @@ from sdmxlib.api.client import ResponseTooLargeError
 from sdmxlib.api.registry import BearerToken, FmrRegistry, RestRegistry
 from sdmxlib.data_store import DataStore, WriteSource
 from sdmxlib.model.datastructure import ComponentRole
+from sdmxlib.model.ref import short_urn as short_urn
 from sdmxlib.model.ref import SupportsUrn
 from sdmxlib.model.rest_api import ApiVersion
 from sdmxlib.model.rollup import AncestorMap

{sdmxlib-0.62.2/src/sdmxlib/storage → sdmxlib-0.64.0/src/sdmxlib}/_time.py

@@ -35,12 +35,19 @@ breaking.
 from __future__ import annotations
 
 from datetime import UTC
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, overload
 
 if TYPE_CHECKING:
     from datetime import datetime
 
 
+# Overloaded so a value known to be present stays `datetime` on the way out —
+# a query literal (#415) is never None, and widening it to `datetime | None`
+# would push a pointless check onto every caller.
+@overload
+def to_storage(value: datetime) -> datetime: ...
+@overload
+def to_storage(value: None) -> None: ...
 def to_storage(value: datetime | None) -> datetime | None:
     """A datetime as this schema stores it: UTC, with `tzinfo` stripped.
 
@@ -60,6 +67,10 @@ def to_storage(value: datetime | None) -> datetime | None:
     return value.astimezone(UTC).replace(tzinfo=None)
 
 
+@overload
+def from_storage(value: datetime) -> datetime: ...
+@overload
+def from_storage(value: None) -> None: ...
 def from_storage(value: datetime | None) -> datetime | None:
     """A stored datetime as the model sees it: the same instant, tagged UTC.
 

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/src/sdmxlib/api/_freshness.py

@@ -56,7 +56,7 @@ class Freshness:
     "has the pointer moved?", which validators answer without one.
     """
 
-    #: When the response was received. Naive UTC, per `storage._time`'s
+    #: When the response was received. Naive UTC, per `sdmxlib._time`'s
     #: convention, so comparisons cannot shift with a reader's zone.
     stored_at: datetime
     #: `ETag`, for `If-None-Match`. The cheapest revalidation there is.

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/src/sdmxlib/api/client.py

@@ -223,7 +223,7 @@ def _raise_for_status(response: httpx.Response, *, url: str) -> None:
 def _now() -> datetime:
     """Now, as naive UTC.
 
-    `storage._time`'s convention, so a stored instant means the same thing to
+    `sdmxlib._time`'s convention, so a stored instant means the same thing to
     every reader regardless of their machine's zone.
     """
     return datetime.now(UTC).replace(tzinfo=None)

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/src/sdmxlib/api/federated.py

@@ -32,7 +32,7 @@ Example:
 
 import functools
 import inspect
-from typing import TYPE_CHECKING, Any, overload
+from typing import TYPE_CHECKING, overload
 
 import httpx
 
@@ -124,7 +124,7 @@ class FederatedRegistry:
     @overload
     def get[T](
         self,
-        target: "SdmxUrn[object] | Ref[Any]",
+        target: "SdmxUrn[object] | Ref[object]",
         /,
         *,
         expect: "type[T]",
@@ -144,7 +144,7 @@ class FederatedRegistry:
 
     def get[T](
         self,
-        target: "SdmxUrn[object] | Ref[Any]",
+        target: "SdmxUrn[object] | Ref[object]",
         /,
         *,
         expect: "type[T] | None" = None,

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/src/sdmxlib/api/registry.py

@@ -4,7 +4,7 @@ import tempfile
 import threading
 from collections.abc import Callable, Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Self, Unpack, cast, overload
+from typing import TYPE_CHECKING, Self, Unpack, cast, overload
 
 import attrs
 from attrs import frozen
@@ -779,7 +779,7 @@ class RestRegistry:
     @overload
     def get[T](
         self,
-        target: "SdmxUrn[object] | Ref[Any]",
+        target: "SdmxUrn[object] | Ref[object]",
         /,
         *,
         expect: "type[T]",
@@ -799,7 +799,7 @@ class RestRegistry:
 
     def get[T](
         self,
-        target: "SdmxUrn[object] | Ref[Any]",
+        target: "SdmxUrn[object] | Ref[object]",
         /,
         *,
         expect: "type[T] | None" = None,

sdmxlib-0.64.0/src/sdmxlib/formats/sdmx_csv/reader.py

@@ -0,0 +1,321 @@
+"""SDMX-CSV data reader.
+
+Parses SDMX-CSV messages into `Dataset` objects.
+
+SDMX-CSV format::
+
+    DATAFLOW,FREQ,REF_AREA,INDICATOR,TIME_PERIOD,OBS_VALUE,OBS_STATUS
+    ESTAT:STS_INPR_M(1.0),M,AT,INDPRO,2024-01,98.5,A
+
+The ``DATAFLOW`` column identifies the dataflow but is not a DSD component.
+It is extracted and then dropped; the remaining columns are parsed using the
+DSD schema.
+"""
+
+import csv
+import io
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Final
+
+import polars as pl
+
+import sdmxlib.polars as slpl
+from sdmxlib.model.dataflow import Dataflow
+from sdmxlib.model.dataset import Dataset
+from sdmxlib.model.datastructure import DataStructure
+from sdmxlib.model.provision import ProvisionAgreement
+from sdmxlib.model.ref import Ref, short_urn
+from sdmxlib.model.urn import SdmxUrn
+
+if TYPE_CHECKING:
+    from sdmxlib.model.registry import SupportsGet
+    from sdmxlib.polars import CodedAs
+
+_DATAFLOW_COL = "DATAFLOW"
+_KEY_COL = "KEY"
+# SDMX-CSV 2.0.0 envelope columns — not DSD components, dropped on read.
+_STRUCTURE_COL = "STRUCTURE"
+_STRUCTURE_ID_COL = "STRUCTURE_ID"
+_ACTION_COL = "ACTION"
+_DATAFLOW_RE = re.compile(r"^([^:]+):([^(]+)\(([^)]+)\)$")
+
+
+def parse_dataflow_id(dataflow_id: str) -> tuple[str, str, str]:
+    """Parse an SDMX-CSV DATAFLOW value into ``(agency, id, version)``.
+
+    Example:
+        parse_dataflow_id("ESTAT:STS_INPR_M(1.0)")  # ("ESTAT", "STS_INPR_M", "1.0")
+    """
+    m = _DATAFLOW_RE.match(dataflow_id)
+    if m is None:
+        msg = f"Cannot parse DATAFLOW value {dataflow_id!r} — expected 'AGENCY:ID(VERSION)'"
+        raise ValueError(msg)
+    return m.group(1), m.group(2), m.group(3)
+
+
+#: The values SDMX-CSV 2.0's ``STRUCTURE`` column may carry.
+#:
+#: Verbatim from the field guide: "The first column contains: ``dataflow``,
+#: ``datastructure`` or ``dataprovision``". Worth stating because two of our own
+#: docstrings said ``provisionagreement`` — which is the RFC 5988 *link
+#: relation* SDMX-JSON uses, a different vocabulary — and a caller following
+#: them wrote a non-conformant file. sdmx1's CSV reader enumerates the same
+#: three (#409).
+STRUCTURE_KINDS: Final[tuple[str, ...]] = ("dataflow", "datastructure", "dataprovision")
+
+
+def _peek_dataflow_id(source: "str | Path | bytes") -> str | None:
+    """Extract the DATAFLOW value from the first data row without reading the whole file."""
+    if isinstance(source, (str, Path)):
+        with Path(source).open(newline="", encoding="utf-8") as f:
+            head = f.read(4096)
+    else:
+        head = source[:4096].decode("utf-8", errors="replace")
+
+    reader = csv.reader(io.StringIO(head))
+    try:
+        header = next(reader)
+    except StopIteration:
+        return None
+    df_idx: int | None = None
+    for col in (_DATAFLOW_COL, _STRUCTURE_ID_COL):
+        if col in header:
+            df_idx = header.index(col)
+            break
+    if df_idx is None:
+        return None
+    try:
+        first_row = next(reader)
+    except StopIteration:
+        return None
+    return first_row[df_idx] if df_idx < len(first_row) else None
+
+
+def _peek_structure(source: "str | Path | bytes") -> "tuple[str | None, str | None]":
+    """``(STRUCTURE, STRUCTURE_ID)`` from the first data row, without reading on.
+
+    The kind matters: an SDMX-CSV file may name a dataflow, a data structure or
+    a provision agreement, and resolving all three is the difference between
+    honouring the column and assuming what it says (#409). SDMX-CSV 1.0 has no
+    ``STRUCTURE`` column at all — its ``DATAFLOW`` implies the kind — so the
+    first element is None there and the caller treats it as a dataflow.
+    """
+    if isinstance(source, (str, Path)):
+        with Path(source).open(newline="", encoding="utf-8") as f:
+            head = f.read(4096)
+    else:
+        head = source[:4096].decode("utf-8", errors="replace")
+    reader = csv.reader(io.StringIO(head))
+    try:
+        header = next(reader)
+        first_row = next(reader)
+    except StopIteration:
+        return None, None
+
+    def value(column: str) -> str | None:
+        if column not in header:
+            return None
+        index = header.index(column)
+        return first_row[index] if index < len(first_row) else None
+
+    kind = value(_STRUCTURE_COL)
+    identifier = value(_STRUCTURE_ID_COL) or value(_DATAFLOW_COL)
+    return kind, identifier
+
+
+def _dataflow_ref(dataflow_str: str) -> "Ref[Dataflow]":
+    """Build an unresolved Ref[Dataflow] from an SDMX-CSV DATAFLOW column value."""
+    agency, id_, version = parse_dataflow_id(dataflow_str)
+    urn = SdmxUrn.make(
+        Dataflow,
+        package="datastructure",
+        artefact_class="Dataflow",
+        agency=agency,
+        id=id_,
+        version=version,
+    )
+    return Ref[Dataflow].unresolved(urn)
+
+
+def _resolve_structure(
+    source: "str | Path | bytes",
+    registry: "SupportsGet",
+) -> "tuple[DataStructure, Ref[Dataflow] | None]":
+    """The `DataStructure` this file names, looked up in *registry*.
+
+    Every SDMX-CSV 2.0 row names its own structure, and this reader has always
+    parsed that column and then thrown it away — `scan_csv` required the DSD as
+    a positional argument, so the file's answer was only available after you had
+    supplied it. #409 is that asymmetry.
+
+    All three kinds are honoured rather than assuming `dataflow`, which is what
+    "only `dataflow` appears to be considered" described. A provision agreement
+    resolves through its dataflow, which is the same second hop a dataflow makes
+    to its structure.
+
+    Raises:
+        ValueError: If the file names no structure (no ``STRUCTURE_ID`` and no
+            ``DATAFLOW`` column), if its ``STRUCTURE`` value is not one of
+            `STRUCTURE_KINDS`, if the registry cannot resolve what it names, or
+            if what it resolves to has no structure to read. Four distinct
+            messages, because a caller's next move differs for each.
+        TypeError: If the URN resolves to something that is not a dataflow,
+            provision agreement or data structure at all.
+    """
+    kind, identifier = _peek_structure(source)
+    if identifier is None:
+        msg = (
+            "this file names no structure: no STRUCTURE_ID column (SDMX-CSV 2.0) "
+            "and no DATAFLOW column (1.0). Pass structure=<DataStructure> instead"
+        )
+        raise ValueError(msg)
+    if kind is not None and kind not in STRUCTURE_KINDS:
+        msg = f"unknown STRUCTURE value {kind!r} — SDMX-CSV allows {', '.join(STRUCTURE_KINDS)}"
+        raise ValueError(msg)
+
+    agency, id_, version = parse_dataflow_id(identifier)
+    artefact_class = {"datastructure": DataStructure, "dataprovision": ProvisionAgreement}.get(
+        kind or "dataflow", Dataflow
+    )
+    urn = artefact_class.urn_for(agency=agency, id=id_, version=version)
+    found: object = registry.get(urn)
+    if found is None:
+        msg = f"{kind or 'dataflow'} {identifier} is not in this registry — add it, or pass structure=<DataStructure>"
+        raise ValueError(msg)
+
+    flow_ref: Ref[Dataflow] | None = None
+    if isinstance(found, ProvisionAgreement):
+        if found.dataflow is None:
+            msg = f"provision agreement {identifier} has no dataflow, so its structure cannot be reached"
+            raise ValueError(msg)
+        flow_ref = found.dataflow
+        found = found.dataflow()
+    if isinstance(found, Dataflow):
+        flow_ref = flow_ref or _dataflow_ref(identifier)
+        if found.structure is None:
+            msg = f"dataflow {identifier} has no structure — it cannot say how to read this file"
+            raise ValueError(msg)
+        found = found.structure()
+    if not isinstance(found, DataStructure):
+        # A `TypeError`, per ruff's TRY004 and correctly: the registry answered
+        # with the wrong *kind* of thing, which is a different fault from the
+        # file naming something absent.
+        msg = f"{identifier} resolved to {type(found).__name__}, which is not a DataStructure"
+        raise TypeError(msg)
+    return found, flow_ref
+
+
+def scan_csv(
+    source: "str | Path | bytes",
+    structure: "DataStructure | Dataflow | None" = None,
+    *,
+    registry: "SupportsGet | None" = None,
+    infer_schema_length: "int | None" = 0,
+    dataflow: "Ref[Dataflow] | None" = None,
+    coded_as: "CodedAs" = "enum",
+) -> Dataset:
+    """Parse an SDMX-CSV message into a `Dataset`.
+
+    File paths are scanned lazily via ``pl.scan_csv``; bytes (e.g. from an
+    HTTP response) are read eagerly and wrapped in a ``LazyFrame``. Either
+    way the returned ``Dataset.data`` is always a ``pl.LazyFrame``.
+
+    Args:
+        source: File path or raw bytes from an SDMX-CSV response.
+        structure: Fully resolved `DataStructure`, or the `Dataflow` that names
+                   one — the flow is unwrapped for you, as sdmx1's reader does.
+                   Codelists should be resolved for ``pl.Enum`` typing.
+                   Omit it and pass ``registry`` to use the file's own
+                   ``STRUCTURE_ID`` instead (#409).
+        registry: Any `Registry` to resolve the file's ``STRUCTURE_ID``
+                  against, when ``structure`` is omitted. All three
+                  ``STRUCTURE`` kinds are honoured — ``dataflow``,
+                  ``datastructure`` and ``dataprovision``.
+        infer_schema_length: Passed to Polars. ``0`` (default) means
+                             schema is fully DSD-driven with no row sampling,
+                             which is required for true streaming on paths.
+        dataflow: Optional resolved `Dataflow` ref.
+                  When ``None`` and a ``DATAFLOW`` column is present, an
+                  unresolved ref is built from the column value.
+        coded_as: How coded columns are typed — see `sdmxlib.polars.schema`.
+                  ``"enum"`` (default) fails fast on a value outside its
+                  codelist; ``"string"`` lets it through so
+                  `Dataset.validate` can report every one (#408).
+
+    Returns:
+        A `Dataset` with a lazy ``data`` frame.
+
+    Example:
+        import sdmxlib.polars as slpl
+
+        ds = slpl.scan_csv("data.csv", dsd)
+        df = ds.collect(with_labels=True, lang="en")
+
+        # The file says which structure it needs; the registry has it:
+        ds = slpl.scan_csv("data.csv", registry=reg)
+
+        # Or hand over the flow and skip the `.structure()` unwrap:
+        ds = slpl.scan_csv("data.csv", message.dataflows["DF"])
+
+        # A report rather than a raise, for a file you do not trust yet:
+        report = slpl.scan_csv("suspect.csv", dsd, coded_as="string").validate()
+    """
+    resolved_ref: Ref[Dataflow] | None = None
+    if isinstance(structure, Dataflow):
+        # sdmx1's CSV reader takes either, and for the same reason: a caller
+        # holding the flow has already done the lookup, and making them add
+        # `.structure()` is the hand-written join #409 is about.
+        if structure.structure is None:
+            msg = f"dataflow {short_urn(structure)} has no structure — it cannot say how to read this file"
+            raise ValueError(msg)
+        resolved_ref = _dataflow_ref(short_urn(structure))
+        structure = structure.structure()
+    elif structure is None:
+        if registry is None:
+            msg = (
+                "scan_csv needs structure=<DataStructure | Dataflow>, or "
+                "registry=<Registry> to resolve the file's own STRUCTURE_ID"
+            )
+            raise ValueError(msg)
+        structure, resolved_ref = _resolve_structure(source, registry)
+
+    # Only a `dataflow` file gets a `Dataset.dataflow`. This used to build one
+    # from `STRUCTURE_ID` whatever the `STRUCTURE` column said, so a
+    # `datastructure` file came back claiming a dataflow whose id was really a
+    # DSD's. Reading the kind (#409) is what makes the distinction available.
+    kind, identifier = _peek_structure(source)
+    dataflow_ref = dataflow or resolved_ref
+    if dataflow_ref is None and identifier is not None and kind in (None, "dataflow"):
+        dataflow_ref = _dataflow_ref(identifier)
+
+    schema_overrides = slpl.schema(structure, coded_as=coded_as)
+
+    if isinstance(source, (str, Path)):
+        lf = pl.scan_csv(
+            source,
+            schema_overrides=schema_overrides,
+            infer_schema_length=infer_schema_length,
+        )
+    else:
+        lf = pl.read_csv(
+            io.BytesIO(source),
+            schema_overrides=schema_overrides,
+            infer_schema_length=infer_schema_length,
+        ).lazy()
+
+    # Drop metadata columns that are not DSD components. Covers both
+    # SDMX-CSV 1.0 (DATAFLOW, KEY) and 2.0 (STRUCTURE, STRUCTURE_ID, ACTION).
+    col_names = lf.collect_schema().names()
+    envelope_cols = (
+        _DATAFLOW_COL,
+        _KEY_COL,
+        _STRUCTURE_COL,
+        _STRUCTURE_ID_COL,
+        _ACTION_COL,
+    )
+    to_drop = [c for c in envelope_cols if c in col_names]
+    if to_drop:
+        lf = lf.drop(to_drop)
+
+    return Dataset(structure=structure, data=lf, dataflow=dataflow_ref)

{sdmxlib-0.62.2 → sdmxlib-0.64.0}/src/sdmxlib/formats/sdmx_csv/writer.py

@@ -47,6 +47,21 @@ from typing import TYPE_CHECKING, cast
 
 import polars as pl
 
+from sdmxlib.formats.sdmx_csv.reader import STRUCTURE_KINDS
+from sdmxlib.model.dataflow import Dataflow
+from sdmxlib.model.datastructure import DataStructure
+from sdmxlib.model.provision import ProvisionAgreement
+from sdmxlib.model.ref import short_urn
+
+#: Artefact class -> the ``STRUCTURE`` value SDMX-CSV gives it, for the form of
+#: `write_sdmx_csv` that takes the artefact instead of a pre-formatted string.
+_KIND_OF: dict[type, str] = {
+    Dataflow: "dataflow",
+    DataStructure: "datastructure",
+    ProvisionAgreement: "dataprovision",
+}
+
+
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator
 
@@ -59,7 +74,7 @@ def write_sdmx_csv(
     batches: Iterable[pa.RecordBatch],
     dsd: DataStructure,
     *,
-    structure_id: str,
+    structure_id: str | Dataflow | DataStructure | ProvisionAgreement,
     structure: str = "dataflow",
     action: str = "I",
 ) -> Iterator[bytes]:
@@ -73,11 +88,18 @@ def write_sdmx_csv(
             Determines column order in the output: dimensions, then
             measures, then attributes, each in the order the structure
             declares them.
-        structure_id: The ``AGENCY:ID(VERSION)`` identifier emitted in
-            the ``STRUCTURE_ID`` column on every row.
-        structure: Value emitted in the ``STRUCTURE`` column. SDMX-CSV
-            allows ``"dataflow"``, ``"datastructure"``, or
-            ``"provisionagreement"``. Defaults to ``"dataflow"``.
+        structure_id: The ``AGENCY:ID(VERSION)`` identifier emitted in the
+            ``STRUCTURE_ID`` column on every row — or the artefact itself, in
+            which case both this and ``structure`` are read off it. Passing the
+            artefact is the point of #409: every caller was formatting the short
+            URN by hand while `parse_dataflow_id` owned reading it.
+        structure: Value emitted in the ``STRUCTURE`` column. SDMX-CSV allows
+            ``"dataflow"``, ``"datastructure"`` or ``"dataprovision"``, and the
+            field guide's wording is exactly those three. This said
+            ``"provisionagreement"`` until #409 — that is SDMX-JSON's RFC 5988
+            link relation, a different vocabulary, and a caller who followed it
+            wrote a file no conformant reader accepts. Ignored when
+            ``structure_id`` is an artefact.
         action: Value emitted in the ``ACTION`` column. One of ``I``
             (Insert), ``R`` (Replace), ``A`` (Append), ``D`` (Delete).
             Defaults to ``"I"``.
@@ -89,7 +111,14 @@ def write_sdmx_csv(
 
     Raises:
         KeyError: If a batch is missing a component the structure declares.
+        ValueError: If ``structure`` is not one of SDMX-CSV's three kinds.
     """
+    if not isinstance(structure_id, str):
+        structure = _KIND_OF.get(type(structure_id), "dataflow")
+        structure_id = short_urn(structure_id)
+    if structure not in STRUCTURE_KINDS:
+        msg = f"STRUCTURE must be one of {', '.join(STRUCTURE_KINDS)}, not {structure!r}"
+        raise ValueError(msg)
     # Component ids, in SDMX order, from the structure. This read the
     # *binding's* physical column names until an observation query began
     # projecting by component id — after which it raised a `KeyError` naming