sdmxlib 0.32.2__tar.gz → 0.34.0__tar.gz

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/PKG-INFO

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

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sdmxlib"
-version = "0.32.2"
+version = "0.34.0"
 description = "SDMX structural metadata library for Python"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/__init__.py

@@ -101,17 +101,17 @@ from sdmxlib.model import (
     TimeDimension,
     UnresolvedRef,
     ValueMap,
+    AmbiguousHierarchyError,
     artefact_urn,
     code,
-    default_hierarchy,
     node,
-    validate_binding,
 )
 from sdmxlib.model.hierarchy_query import HierarchyNodeQuery
 
 __all__ = [
     "Agency",
     "AgencyScheme",
+    "AmbiguousHierarchyError",
     "Annotation",
     "Annotations",
     "AnyRef",
@@ -217,7 +217,6 @@ __all__ = [
     "ValueMap",
     "artefact_urn",
     "code",
-    "default_hierarchy",
     "dim",
     "from_dict",
     "item",
@@ -230,6 +229,5 @@ __all__ = [
     "to_json",
     "to_xml",
     "validate",
-    "validate_binding",
     "validate_references",
 ]

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/api/federated.py

@@ -37,6 +37,7 @@ import httpx
 from sdmxlib.api.policy import FailurePolicy, RegistryUnavailable
 
 if TYPE_CHECKING:
+    from sdmxlib.model.binding import DataflowBinding, DriftIssue
     from sdmxlib.model.registry import RegistryReader
     from sdmxlib.model.urn import SdmxUrn
 
@@ -146,6 +147,19 @@ class FederatedRegistry:
         source = self._route(urn)
         return source is not None and urn in source
 
+    # ── Graph queries ────────────────────────────────────────────────────
+
+    def validate_binding(self, binding: "DataflowBinding") -> "list[DriftIssue]":
+        """Check ``binding`` against this federated registry for structural drift.
+
+        Routes the bound Dataflow lookup through the configured sources;
+        only the routed source is touched. Returns a list of
+        `DriftIssue` — empty if no drift is detected.
+        """
+        from sdmxlib.model.binding import _validate_binding  # noqa: PLC0415
+
+        return _validate_binding(binding, self)
+
     # ── Failure handling ─────────────────────────────────────────────────
 
     def _on_failure[T](self, source: "RegistryReader", exc: Exception) -> "T | None":

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/api/registry.py

@@ -21,6 +21,7 @@ from sdmxlib.model.urn import SdmxUrn
 
 if TYPE_CHECKING:
     from sdmxlib.local.registry import Registry
+    from sdmxlib.model.binding import DataflowBinding, DriftIssue
 
 SDMX_GLOBAL_REGISTRY = "https://registry.sdmx.org/sdmx/v2"
 
@@ -744,6 +745,18 @@ class RestRegistry:
         structure: DataStructure = flow.structure()
         return scan_csv(source, structure, dataflow=Ref.to(flow))
 
+    # ── Graph queries ─────────────────────────────────────────────────────────
+
+    def validate_binding(self, binding: "DataflowBinding") -> "list[DriftIssue]":
+        """Check ``binding`` against this registry for structural drift.
+
+        Performs at most one HTTP fetch (the bound Dataflow). Returns a
+        list of `DriftIssue` — empty if no drift is detected.
+        """
+        from sdmxlib.model.binding import _validate_binding  # noqa: PLC0415
+
+        return _validate_binding(binding, self)
+
 
 # ── FmrRegistry ───────────────────────────────────────────────────────────────
 

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/local/registry.py

@@ -33,7 +33,7 @@ stashes the URI; the DuckDB connection is opened by ``open()`` /
 import threading
 from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Self
+from typing import TYPE_CHECKING, Any, Self
 
 import attrs
 import duckdb
@@ -52,6 +52,11 @@ from sdmxlib.storage.schema import (
     schema_exists,
 )
 
+if TYPE_CHECKING:
+    from sdmxlib.model.binding import DataflowBinding, DriftIssue
+    from sdmxlib.model.dataflow import Dataflow
+    from sdmxlib.model.hierarchy import Hierarchy
+
 # Map item-level artefact class -> (parent scheme type name, items attribute name)
 _ITEM_TO_SCHEME: dict[str, tuple[str, str]] = {
     "Concept": ("ConceptScheme", "concepts"),
@@ -490,6 +495,40 @@ class Registry:
         memo.promote()
         return results  # type: ignore[return-value]
 
+    # ── Graph queries ──────────────────────────────────────────────────
+
+    def applicable_hierarchies(
+        self,
+        dataflow: "Dataflow",
+        dim_id: str,
+    ) -> "list[Ref[Hierarchy]]":
+        """All Hierarchies applicable to ``dim_id`` on ``dataflow``.
+
+        See `InMemoryRegistry.applicable_hierarchies` for semantics.
+        """
+        from sdmxlib.model.hierarchy import _applicable_hierarchies  # noqa: PLC0415
+
+        return _applicable_hierarchies(self, dataflow, dim_id)
+
+    def unique_hierarchy(
+        self,
+        dataflow: "Dataflow",
+        dim_id: str,
+    ) -> "Ref[Hierarchy] | None":
+        """The single applicable Hierarchy, ``None`` if none, raises on >1.
+
+        See `InMemoryRegistry.unique_hierarchy` for semantics.
+        """
+        from sdmxlib.model.hierarchy import _unique_hierarchy  # noqa: PLC0415
+
+        return _unique_hierarchy(self, dataflow, dim_id)
+
+    def validate_binding(self, binding: "DataflowBinding") -> "list[DriftIssue]":
+        """Check ``binding`` against this registry for structural drift."""
+        from sdmxlib.model.binding import _validate_binding  # noqa: PLC0415
+
+        return _validate_binding(binding, self)
+
     # ── Ref resolution ─────────────────────────────────────────────────
 
     def _resolve_refs(  # noqa: C901

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/model/__init__.py

@@ -1,7 +1,7 @@
 """sdmxlib.model — domain model, stdlib only."""
 
 from sdmxlib.model.annotations import Annotation, Annotations
-from sdmxlib.model.binding import DataflowBinding, DriftIssue, validate_binding
+from sdmxlib.model.binding import DataflowBinding, DriftIssue
 from sdmxlib.model.convert import from_dict, to_dict
 from sdmxlib.model.validation import ReferenceIssue, ValidationIssue, validate, validate_references
 from sdmxlib.model.base import MaintainableArtefact
@@ -48,11 +48,11 @@ from sdmxlib.model.concept import Concept, ConceptScheme
 from sdmxlib.model.dataflow import Dataflow
 from sdmxlib.model.dataset import Dataset
 from sdmxlib.model.hierarchy import (
+    AmbiguousHierarchyError,
     Hierarchy,
     HierarchicalCode,
     HierarchyAssociation,
     Level,
-    default_hierarchy,
 )
 from sdmxlib.model.datastructure import (
     AttachmentLevel,
@@ -84,6 +84,7 @@ from sdmxlib.model.urn import SdmxUrn
 __all__ = [
     "Agency",
     "AgencyScheme",
+    "AmbiguousHierarchyError",
     "Annotation",
     "Annotations",
     "AnyRef",
@@ -171,12 +172,10 @@ __all__ = [
     "ValueMap",
     "artefact_urn",
     "code",
-    "default_hierarchy",
     "from_dict",
     "item",
     "node",
     "to_dict",
     "validate",
-    "validate_binding",
     "validate_references",
 ]

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/model/binding.py

@@ -46,7 +46,6 @@ from sdmxlib.model.urn import SdmxUrn
 
 if TYPE_CHECKING:
     from sdmxlib.model.datastructure import DataStructure
-    from sdmxlib.model.registry import RegistryReader
 
 
 def _require_aware(value: datetime) -> datetime:
@@ -253,23 +252,14 @@ class DriftIssue:
     description: str
 
 
-def validate_binding(binding: DataflowBinding, registry: "RegistryReader") -> list[DriftIssue]:
-    """Check a binding against a structural registry for drift.
+def _validate_binding(binding: DataflowBinding, registry: object) -> list[DriftIssue]:
+    """Internal helper: check a binding against a registry for structural drift.
 
-    v1 reports three drift kinds (see `DriftIssue`). Detailed
-    codelist content diffs (added codes / removed codes / renamed
-    labels) are intentionally deferred — the v1 ``structural_version``
-    pin is enough to surface the case operationally.
-
-    Args:
-        binding: The `DataflowBinding` to validate.
-        registry: The structural source. Typically a
-            `FederatedRegistry` or a
-            `Registry`.
-
-    Returns:
-        A list of `DriftIssue` — empty if the pinned structural
-        state matches the current registry view.
+    Called by the public `validate_binding` method on registries
+    (e.g. `InMemoryRegistry.validate_binding`). ``registry`` is
+    duck-typed on ``get(urn) -> artefact | None`` — typed as ``object``
+    rather than the `RegistryReader` Protocol so the overloaded
+    ``RestRegistry.get`` and similar registries satisfy it.
     """
     binding_urn = str(
         DataflowBinding.urn(
@@ -280,7 +270,7 @@ def validate_binding(binding: DataflowBinding, registry: "RegistryReader") -> li
     )
     issues: list[DriftIssue] = []
 
-    flow = registry.get(binding.dataflow.urn)
+    flow = registry.get(binding.dataflow.urn)  # type: ignore[attr-defined]
     if flow is None:
         issues.append(
             DriftIssue(

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/model/code_query.py

@@ -31,6 +31,7 @@ from sdmxlib._duckdb import scalar
 from sdmxlib.model.annotations import Annotation, Annotations
 from sdmxlib.model.codelist import Code
 from sdmxlib.model.istring import InternationalString
+from sdmxlib.sql import CompileContext
 
 if TYPE_CHECKING:
     import duckdb
@@ -109,7 +110,56 @@ class _AnnotationTextField(_FieldExpr):
 
 
 class Predicate:
-    """Marker base for predicates the query compiler understands."""
+    """Base for predicates the code-query compiler understands.
+
+    Conforms to the cross-library `sdmxlib.sql.Predicate`
+    Protocol via `Predicate.to_sql`: a downstream library that
+    composes its own predicates with sdmxlib's (e.g. ``pinaxlib``'s
+    catalog query builder) shares one `CompileContext`
+    across both, so joins dedup and aliases stay unique within a
+    single compilation pass.
+
+    Public hook:
+
+        pred = sl.code.descendants_of("CA", hierarchy=h)
+        ctx = sl.CompileContext(row_alias="c")
+        clause, params = pred.to_sql(ctx)
+        # ctx.join_sqls / ctx.join_params carry any accumulated LATERAL
+        # JOINs (only emitted by annotation predicates today).
+
+    The emitted SQL references columns on the relation aliased as
+    ``ctx.row_alias``. The caller must have a ``sdmx.code``-shaped row
+    source under that alias, with these columns:
+
+    - ``code_id`` (TEXT) — code identifier
+    - ``parent_id`` (TEXT) — intrinsic parent code id, or NULL
+    - ``depth`` (SMALLINT) — depth in intrinsic parent chain (root = 0)
+    - ``name`` (MAP(VARCHAR, VARCHAR)) — localised label
+    - ``code_urn`` (TEXT) — full URN of the code
+    - ``codelist_urn`` (TEXT) — URN of the owning codelist
+    - ``ancestor_ids`` (TEXT[]) — flat ancestor chain (intrinsic parent)
+
+    Hierarchy-aware predicates (``descendants_of(..., hierarchy=h)``,
+    ``hierarchy(h).level(...)``) additionally reference
+    ``sdmx.hierarchy_node`` — that table must also be visible on the
+    consumer's connection. Schema names are looked up via
+    ``ctx.schema('sdmx')`` so consumers can remap if needed.
+    """
+
+    def to_sql(self, ctx: CompileContext) -> tuple[str, list[object]]:
+        """Compile this predicate to a SQL WHERE-fragment + params.
+
+        Side-effect: appends to ``ctx.join_sqls`` / ``ctx.join_params``
+        if the predicate needs a LATERAL JOIN (annotation predicates).
+        Shared aliases are deduped through ``ctx.join_aliases``.
+        """
+        return _emit_predicate(
+            self,
+            row_alias=ctx.row_alias,
+            join_sqls=ctx.join_sqls,
+            join_params=ctx.join_params,
+            annotation_join_aliases=ctx.join_aliases,
+        )
 
 
 @attrs.frozen
@@ -434,8 +484,9 @@ class _CodeAccessor:
         Accepts a URN string, a `Hierarchy` artefact, or a `Ref[Hierarchy]`.
         The same code can sit in multiple Hierarchies with different parent
         graphs — this picks the one you name. Pairs with
-        `Dataflow.default_hierarchy(dim_id)` for the "use whatever the
-        dataflow declared" case.
+        `InMemoryRegistry.unique_hierarchy(dataflow, dim_id)` (or
+        `applicable_hierarchies`) for the "use whatever the dataflow
+        declared" case.
         """
         urn: str | None = None
         if hierarchy is not None:
@@ -694,25 +745,18 @@ def _compile(
     omit_order: bool = False,
 ) -> tuple[str, list[object]]:
     """Translate the predicate tree to a single ``sdmx.code`` query."""
-    join_sqls: list[str] = []
-    join_params: list[object] = []
+    ctx = CompileContext(row_alias="c")
     where_sqls: list[str] = ["c.codelist_urn = ?"]
     where_params: list[object] = [query.codelist_urn]
-    annotation_join_aliases: dict[str, str] = {}
 
     for pred in query.predicates:
-        clause, params = _emit_predicate(
-            pred,
-            join_sqls=join_sqls,
-            join_params=join_params,
-            annotation_join_aliases=annotation_join_aliases,
-        )
+        clause, params = pred.to_sql(ctx)
         where_sqls.append(clause)
         where_params.extend(params)
 
     sql_parts = [f"SELECT {select_clause} FROM sdmx.code c"]
-    if join_sqls:
-        sql_parts.append(" ".join(join_sqls))
+    if ctx.join_sqls:
+        sql_parts.append(" ".join(ctx.join_sqls))
     sql_parts.append("WHERE " + " AND ".join(where_sqls))
 
     if not omit_order:
@@ -725,7 +769,7 @@ def _compile(
         sql_parts.append(f"LIMIT {int(query.limit_n)}")
 
     sql = " ".join(sql_parts)
-    return sql, [*join_params, *where_params, *order_params]
+    return sql, [*ctx.join_params, *where_params, *order_params]
 
 
 def _build_order_by(sort_keys: tuple[_SortKey, ...]) -> tuple[list[str], list[object]]:

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/model/hierarchy.py

@@ -23,7 +23,30 @@ from sdmxlib.model.urn import SdmxUrn
 
 if TYPE_CHECKING:
     from sdmxlib.model.dataflow import Dataflow
-    from sdmxlib.model.in_memory_registry import InMemoryRegistry
+
+
+class AmbiguousHierarchyError(ValueError):
+    """Raised when `unique_hierarchy` finds more than one applicable Hierarchy.
+
+    Carries the list of conflicting `HierarchyAssociation` URNs. The
+    caller asserted "at most one Hierarchy applies" (via the
+    `unique_hierarchy` accessor); the IM permits many, so this signals
+    that the caller's assumption doesn't hold for this registry.
+
+    Use `applicable_hierarchies` instead when the IM-canonical many-case
+    is the intended question.
+    """
+
+    def __init__(self, dim_urn: str, dataflow_urn: str, ha_urns: list[str]) -> None:
+        self.dim_urn = dim_urn
+        self.dataflow_urn = dataflow_urn
+        self.ha_urns = ha_urns
+        joined = ", ".join(ha_urns)
+        super().__init__(
+            f"Multiple HierarchyAssociations bind {dim_urn} for dataflow "
+            f"{dataflow_urn}: {joined}. Use applicable_hierarchies() to "
+            "enumerate them.",
+        )
 
 
 @define
@@ -399,34 +422,27 @@ class HierarchyAssociation(MaintainableArtefact):
     context_object: AnyRef | None = None
 
 
-def default_hierarchy(
-    registry: "InMemoryRegistry",
+def _partition_associations(
+    registry: object,
     dataflow: "Dataflow",
     dim_id: str,
-) -> Ref[Hierarchy] | None:
-    """Resolve the declared default Hierarchy for a Dataflow's dimension.
-
-    Scans `HierarchyAssociation` artefacts in ``registry`` for those
-    whose ``linked_object`` is the named dimension on ``dataflow``'s DSD.
-    Dataflow-scoped associations (``context_object`` equals this
-    dataflow's URN) win over unscoped ones; an association whose
-    ``context_object`` names a *different* dataflow is ignored.
-
-    Returns the linked Hierarchy ref, or ``None`` if no association
-    applies. Returning ``None`` is the cue to fall back to the
-    codelist's intrinsic ``parent`` chain — see
-    `code._CodeAccessor.descendants_of` for the predicate that consumes
-    this value.
-
-    Raises:
-        ValueError: if multiple associations match at the same scope
-            (both dataflow-scoped or both unscoped). The SDMX spec
-            doesn't order them, so the caller must disambiguate.
+) -> tuple[str, str, list["HierarchyAssociation"], list["HierarchyAssociation"]]:
+    """Internal helper: enumerate HAs binding (dim_id, dataflow), split by scope.
+
+    Returns (dim_urn_str, dataflow_urn_str, scoped_HAs, unscoped_HAs) where
+    ``scoped`` are HAs with ``context_object`` equal to ``dataflow``'s URN
+    and ``unscoped`` have ``context_object=None``. HAs naming a different
+    dataflow context are omitted.
+
+    ``registry`` only needs a ``get_all(HierarchyAssociation) -> list``
+    method. The duck-typed ``object`` annotation keeps this helper
+    backend-agnostic; ``InMemoryRegistry`` and ``local.Registry`` both
+    satisfy it.
     """
     from sdmxlib.model.datastructure import Dimension  # noqa: PLC0415
 
     if dataflow.structure is None:
-        return None
+        return ("", "", [], [])
     dsd_urn = dataflow.structure.urn
     dim_urn = SdmxUrn.make(
         Dimension,
@@ -442,21 +458,54 @@ def default_hierarchy(
 
     scoped: list[HierarchyAssociation] = []
     unscoped: list[HierarchyAssociation] = []
-    for ha in registry.get_all(HierarchyAssociation):
+    for ha in registry.get_all(HierarchyAssociation):  # type: ignore[attr-defined]
         if ha.linked_object is None or str(ha.linked_object.urn) != dim_urn_str:
             continue
         if ha.context_object is None:
             unscoped.append(ha)
         elif str(ha.context_object.urn) == df_urn_str:
             scoped.append(ha)
-        # else: bound to a different dataflow context, ignore
+    return (dim_urn_str, df_urn_str, scoped, unscoped)
 
+
+def _applicable_hierarchies(
+    registry: object,
+    dataflow: "Dataflow",
+    dim_id: str,
+) -> list[Ref[Hierarchy]]:
+    """Implementation of the `applicable_hierarchies` registry method.
+
+    See `InMemoryRegistry.applicable_hierarchies` for semantics.
+    """
+    _dim, _df, scoped, unscoped = _partition_associations(registry, dataflow, dim_id)
+    scoped.sort(key=lambda ha: str(artefact_urn(ha)))
+    unscoped.sort(key=lambda ha: str(artefact_urn(ha)))
+    return [ha.linked_hierarchy for ha in (*scoped, *unscoped) if ha.linked_hierarchy is not None]
+
+
+def _unique_hierarchy(
+    registry: object,
+    dataflow: "Dataflow",
+    dim_id: str,
+) -> Ref[Hierarchy] | None:
+    """Implementation of the `unique_hierarchy` registry method.
+
+    See `InMemoryRegistry.unique_hierarchy` for semantics.
+    """
+    dim_urn_str, df_urn_str, scoped, unscoped = _partition_associations(
+        registry,
+        dataflow,
+        dim_id,
+    )
     chosen = scoped or unscoped
     if not chosen:
         return None
     if len(chosen) > 1:
-        kind = "dataflow-scoped" if scoped else "unscoped"
-        urns = ", ".join(str(artefact_urn(ha)) for ha in chosen)
-        msg = f"Multiple {kind} HierarchyAssociations bind {dim_urn_str} for dataflow {df_urn_str}: {urns}"
-        raise ValueError(msg)
+        urns = [str(artefact_urn(ha)) for ha in chosen]
+        urns.sort()
+        raise AmbiguousHierarchyError(
+            dim_urn=dim_urn_str,
+            dataflow_urn=df_urn_str,
+            ha_urns=urns,
+        )
     return chosen[0].linked_hierarchy

{sdmxlib-0.32.2 → sdmxlib-0.34.0}/src/sdmxlib/model/in_memory_registry.py

@@ -20,7 +20,7 @@ Example:
 """
 
 from collections.abc import Iterable
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import attrs
 
@@ -28,6 +28,11 @@ from sdmxlib.model.collections import ItemList
 from sdmxlib.model.ref import AnyRef, HasUrn, Ref
 from sdmxlib.model.urn import SdmxUrn
 
+if TYPE_CHECKING:
+    from sdmxlib.model.binding import DataflowBinding, DriftIssue
+    from sdmxlib.model.dataflow import Dataflow
+    from sdmxlib.model.hierarchy import Hierarchy
+
 
 class InMemoryRegistry:
     """In-memory SDMX artefact store with URN identity and Ref interning.
@@ -117,6 +122,54 @@ class InMemoryRegistry:
             return str(urn) in self._store
         return False
 
+    # ── Graph queries ────────────────────────────────────────────────────
+
+    def applicable_hierarchies(
+        self,
+        dataflow: "Dataflow",
+        dim_id: str,
+    ) -> "list[Ref[Hierarchy]]":
+        """All Hierarchies whose HierarchyAssociations bind ``dim_id`` on ``dataflow``.
+
+        Returns dataflow-scoped HAs first (sorted lex by HA URN), then
+        unscoped HAs (also lex-sorted). HAs whose ``context_object``
+        names a different dataflow are skipped.
+
+        Per the SDMX 3.x IM the relation is many-to-many — this is the
+        canonical enumeration surface. Use `unique_hierarchy` when the
+        caller asserts at most one applies.
+        """
+        from sdmxlib.model.hierarchy import _applicable_hierarchies  # noqa: PLC0415
+
+        return _applicable_hierarchies(self, dataflow, dim_id)
+
+    def unique_hierarchy(
+        self,
+        dataflow: "Dataflow",
+        dim_id: str,
+    ) -> "Ref[Hierarchy] | None":
+        """The single Hierarchy applicable to ``dim_id`` on ``dataflow``, when exactly one applies.
+
+        Returns ``None`` if no HierarchyAssociation binds the dimension.
+        Returns the single applicable Hierarchy's `Ref` if exactly one
+        applies (dataflow-scoped wins over unscoped at the same dim).
+        Raises `AmbiguousHierarchyError` if more than one HA applies at
+        the chosen scope — call `applicable_hierarchies` to enumerate.
+        """
+        from sdmxlib.model.hierarchy import _unique_hierarchy  # noqa: PLC0415
+
+        return _unique_hierarchy(self, dataflow, dim_id)
+
+    def validate_binding(self, binding: "DataflowBinding") -> "list[DriftIssue]":
+        """Check ``binding`` against this registry for structural drift.
+
+        Reports a `DriftIssue` per detected mismatch — empty list
+        means the pinned structural state matches the current registry.
+        """
+        from sdmxlib.model.binding import _validate_binding  # noqa: PLC0415
+
+        return _validate_binding(binding, self)
+
     def __len__(self) -> int:
         """Number of artefacts stored."""
         return len(self._store)