loom-kernel 2.1.2__tar.gz → 2.1.3__tar.gz

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/.github/workflows/ci-pr.yml

@@ -91,6 +91,41 @@ jobs:
           if-no-files-found: error
           retention-days: 1
 
+  model-python-314:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5
+        with:
+          python-version: "3.14"
+
+      - name: Install uv
+        run: |
+          pip install --only-binary :all: "uv==0.10.2"
+
+      - name: Run the model tests with coverage
+        shell: bash
+        env:
+          COVERAGE_FILE: .coverage.model
+        run: |
+          set -euo pipefail
+          uv run --frozen --python 3.14 --no-default-groups --extra testing \
+            --with "pytest-cov==7.1.0" pytest tests/unit/core/model --cov --cov-report=
+
+      - name: Store model coverage
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        with:
+          name: test-results-model
+          path: .coverage.model
+          include-hidden-files: true
+          if-no-files-found: error
+          retention-days: 1
+
   # Serial: each xdist worker starts its own JVM, which under coverage cancels
   # the parallelism out.
   tests-spark:
@@ -141,7 +176,7 @@ jobs:
   # The gate: cheap checks plus the merged results, so a failure in either lane
   # still blocks here.
   validate:
-    needs: [tests-fast, tests-spark]
+    needs: [tests-fast, tests-spark, model-python-314]
     runs-on: ubuntu-latest
     env:
       SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
@@ -186,7 +221,12 @@ jobs:
         with:
           name: test-results-spark
 
-      - name: Combine the results of both lanes
+      - name: Download model coverage
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
+        with:
+          name: test-results-model
+
+      - name: Combine the results of every lane
         shell: bash
         run: |
           set -euo pipefail
@@ -194,7 +234,7 @@ jobs:
             --junit junit-fast.xml --junit junit-slow.xml --junit junit-spark.xml \
             --junit-output junit.xml
           uv run --frozen --with "pytest-cov==7.1.0" coverage combine \
-            .coverage.fast .coverage.slow .coverage.spark
+            .coverage.fast .coverage.slow .coverage.spark .coverage.model
           uv run --frozen --with "pytest-cov==7.1.0" coverage json -o coverage.json
           uv run --frozen --with "pytest-cov==7.1.0" coverage xml -o coverage.xml
 

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## 🐛 Fixes
 
+### core
+
+- **core:** a model with a relation or projection field imports again on
+  Python 3.12.4 and later when its module uses
+  `from __future__ import annotations`. It failed with
+  `TypeError: ForwardRef._evaluate() missing 1 required keyword-only argument: 'recursive_guard'`,
+  because the string annotation went through a private `typing` API whose
+  signature changed; it is now evaluated with `typing.get_type_hints`.
+- **core:** a model keeps its fields on Python 3.14. Class annotations are lazy
+  there, so the model metaclass found no `__annotations__` in the class body and
+  replaced them with an empty mapping: the struct had no fields and
+  `compile_model` failed with `could not assemble any primary key columns`. The
+  metaclass now evaluates them with `annotationlib` when the class is created,
+  so an undefined name still fails at import; the model class carries the
+  evaluated `__annotations__` and no `__annotate__` function.
+
+## ♻️ Refactor
+
+### etl
+
+- **etl:** the reader registry is gone. Nothing registered a per-kind
+  reader: the Mongo, ClickHouse and DynamoDB readers are built from
+  configuration and injected into the Polars reader, so the registry wrapped
+  one reader and forwarded to it. `PolarsProvider.create_backends` now
+  returns that reader directly, as the Spark provider already did. The
+  executor's own `StreamingSourceReader` check consequently inspects the
+  reader instead of the wrapper, which satisfied the protocol whatever it
+  wrapped, and a step that asks for a streaming read its reader cannot serve
+  is now refused by that check, naming the reader.
+- **etl:** the writer registry names the `TargetWriter` protocol instead of
+  `Any`. That surfaced `ClickHouseTargetWriter.write` declaring a narrower
+  spec type than the protocol it is dispatched through; it now accepts the
+  protocol's type and refuses a spec of another kind with a `TypeError`,
+  which the registry's dispatch by kind already made unreachable.
+
+# 🚀 Release 2.1.2 ([#238](https://github.com/the-reacher-data/loom-py/pull/238))
+
+## 🐛 Fixes
+
 ### prefect
 
 - **prefect:** a correlation id renders its datetime's UTC instant instead of
@@ -15,6 +54,12 @@
   `20260602T220000`), so do not upgrade across a run you intend to resume
   from its manifest.
 
+# 🚀 Release 2.1.1 ([#236](https://github.com/the-reacher-data/loom-py/pull/236))
+
+## 🐛 Fixes
+
+### prefect
+
 - **prefect:** `backfill_flow` resumes from a `start_from` submitted as a
   string. A flow's run parameters are not validated against its signature
   (`validate_parameters=False`), so `start_from` reached the chunk algebra

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 2.1.2
+Version: 2.1.3
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Typing :: Typed

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/src/loom/core/model/base.py

@@ -10,6 +10,9 @@ from loom.core.model.projection import Projection
 from loom.core.model.relation import Relation
 from loom.core.model.struct import LoomStruct
 
+if sys.version_info >= (3, 14):
+    import annotationlib
+
 if TYPE_CHECKING:
 
     class _StructMeta(type):
@@ -20,12 +23,25 @@ else:
 
 def _resolve_annotation(annotation: Any, namespace: dict[str, Any]) -> Any:
     """Resolve a stringified annotation to its actual type."""
-    if isinstance(annotation, str):
-        eval_ns: dict[str, Any] = {}
-        eval_ns.update(namespace)
-        eval_ns.setdefault("typing", typing)
-        return typing.ForwardRef(annotation)._evaluate(eval_ns, eval_ns, frozenset[str]())
-    return annotation
+    if not isinstance(annotation, str):
+        return annotation
+    holder = type("_AnnotationHolder", (), {"__annotations__": {"annotation": annotation}})
+    eval_ns = {"typing": typing, **namespace}
+    hints = typing.get_type_hints(holder, globalns=eval_ns, localns=eval_ns, include_extras=True)
+    return hints["annotation"]
+
+
+def _take_class_body_annotations(namespace: dict[str, Any]) -> dict[str, Any]:
+    if "__annotations__" in namespace:
+        annotations: dict[str, Any] = namespace["__annotations__"]
+        return annotations
+    if sys.version_info >= (3, 14):
+        annotate = annotationlib.get_annotate_from_class_namespace(namespace)
+        if annotate is not None:
+            namespace.pop("__annotate__", None)
+            namespace.pop("__annotate_func__", None)
+            return annotationlib.call_annotate_function(annotate, annotationlib.Format.VALUE)
+    return {}
 
 
 def _build_eval_namespace(namespace: dict[str, Any]) -> dict[str, Any]:
@@ -86,7 +102,7 @@ class LoomStructMeta(_StructMeta):
         columns: dict[str, ColumnFieldSpec] = {}
         relations: dict[str, Relation] = {}
         projections: dict[str, Projection] = {}
-        annotations: dict[str, Any] = namespace.get("__annotations__", {})
+        annotations = _take_class_body_annotations(namespace)
 
         eval_ns = _build_eval_namespace(namespace)
 

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/src/loom/etl/backends/polars/provider.py

@@ -6,7 +6,7 @@ from typing import Any, cast
 
 from loom.etl.backends.polars._reader import PolarsSourceReader
 from loom.etl.backends.polars._writer import PolarsTargetWriter
-from loom.etl.io._registry import ReaderRegistry, WriterRegistry
+from loom.etl.io._registry import WriterRegistry
 from loom.etl.io.sources._clickhouse import ClickHouseSourceReader
 from loom.etl.io.sources._dynamodb import DynamoDbSourceReader
 from loom.etl.io.sources._mongo import MongoSourceReader
@@ -48,7 +48,6 @@ class PolarsProvider(BackendProvider):
             clickhouse_reader=clickhouse_reader,
             dynamodb_reader=dynamodb_reader,
         )
-        reader = ReaderRegistry(polars_reader)
         polars_writer = PolarsTargetWriter(
             locator,
             missing_table_policy=config.missing_table_policy,
@@ -63,7 +62,7 @@ class PolarsProvider(BackendProvider):
             )
         else:
             writer = polars_writer
-        return (reader, writer)
+        return (polars_reader, writer)
 
     def create_lineage_writer(
         self,

loom_kernel-2.1.3/src/loom/etl/io/_registry.py

@@ -0,0 +1,54 @@
+"""Dispatch registry that routes a target spec to the writer registered for its kind."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from loom.etl.declarative.target import TargetSpec
+from loom.etl.runtime.contracts import TargetWriter
+
+if TYPE_CHECKING:
+    from loom.etl.lineage._records import WriteContext
+
+
+class WriterRegistry:
+    """Dispatch a write to the writer registered for the spec's kind, or to the base writer.
+
+    Args:
+        base: Writer every spec whose kind is not in *extra* is written through.
+        extra: Writers by ``spec.kind``.
+    """
+
+    def __init__(
+        self,
+        base: TargetWriter,
+        *,
+        extra: Mapping[str, TargetWriter] | None = None,
+    ) -> None:
+        self._base = base
+        self._extra: Mapping[str, TargetWriter] = extra or {}
+
+    def write(
+        self,
+        frame: Any,
+        spec: TargetSpec,
+        params: Any,
+        /,
+        *,
+        streaming: bool = False,
+        write_ctx: WriteContext | None = None,
+    ) -> None:
+        """Write *frame* into *spec* through its kind's writer, or through the base writer.
+
+        Args:
+            frame: Frame returned by the step's ``execute()``.
+            spec: Compiled target specification.
+            params: Concrete params for current run.
+            streaming: Hint for lazy backends to use streaming materialization.
+            write_ctx: Execution context for audit-column injection.
+        """
+        kind = getattr(spec, "kind", None)
+        handler = self._extra.get(kind) if kind is not None else None
+        writer = handler if handler is not None else self._base
+        writer.write(frame, spec, params, streaming=streaming, write_ctx=write_ctx)

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/src/loom/etl/io/targets/_clickhouse.py

@@ -15,6 +15,7 @@ except ImportError:
     _clickhouse_connect = None
 
 from loom.core.logger import get_logger
+from loom.etl.declarative.target import TargetSpec
 from loom.etl.declarative.target._client import ClientSpec
 
 _log = get_logger(__name__)
@@ -108,7 +109,7 @@ class ClickHouseTargetWriter:
     def write(
         self,
         frame: Any,
-        spec: ClickHouseTableSpec,
+        spec: ClickHouseTableSpec | TargetSpec,
         params: Any,
         /,
         *,
@@ -137,6 +138,12 @@ class ClickHouseTargetWriter:
                 "ClientStep execution is routed by ETLExecutor before write() is called. "
                 "This is an internal error — ClientSpec should never reach write()."
             )
+        if not isinstance(spec, ClickHouseTableSpec):
+            raise TypeError(
+                f"ClickHouseTargetWriter.write() does not handle {type(spec).__qualname__}. "
+                "The writer registry dispatches a spec to this writer by its 'clickhouse' "
+                "kind, so this is an internal error."
+            )
         _ = write_ctx
         engine: Literal["streaming", "auto"] = "streaming" if streaming else "auto"
         df: pl.DataFrame = (

loom_kernel-2.1.3/tests/unit/core/model/test_annotation_resolution.py

@@ -0,0 +1,59 @@
+import msgspec
+import pytest
+from msgspec import UnsetType
+
+from loom.core.model import BaseModel, Cardinality, ColumnField, ProjectionField, RelationField
+
+
+def _field_types(model: type[msgspec.Struct]) -> dict[str, object]:
+    return {field.name: field.type for field in msgspec.structs.fields(model)}
+
+
+def test_annotations_become_fields_and_relations_are_widened() -> None:
+    class Page(msgspec.Struct):
+        number: int
+
+    class Chapter(BaseModel):
+        __tablename__ = "annotation_resolution_chapters"
+        id: int = ColumnField(primary_key=True, autoincrement=True)
+        pages: list[Page] = RelationField(
+            foreign_key="chapter_id",
+            cardinality=Cardinality.ONE_TO_MANY,
+        )
+        page_count: int = ProjectionField(loader=None, default=0)
+
+    assert _field_types(Chapter) == {
+        "id": int,
+        "pages": list[Page] | UnsetType,
+        "page_count": int | UnsetType,
+    }
+    assert getattr(Chapter, "__annotate__", None) is None
+
+
+def test_subclass_without_annotations_keeps_inherited_fields() -> None:
+    class Shelf(BaseModel):
+        __tablename__ = "annotation_resolution_shelves"
+        id: int = ColumnField(primary_key=True, autoincrement=True)
+
+    class ArchivedShelf(Shelf):
+        pass
+
+    assert _field_types(ArchivedShelf) == _field_types(Shelf)
+
+
+@pytest.mark.parametrize("header", ["", "from __future__ import annotations\n"])
+def test_an_undefined_annotation_name_fails_at_class_creation(header: str) -> None:
+    source = (
+        f"{header}"
+        "class Broken(BaseModel):\n"
+        "    loans: list[Missing] = RelationField(\n"
+        "        foreign_key='broken_id', cardinality=ONE_TO_MANY\n"
+        "    )\n"
+    )
+    namespace = {
+        "BaseModel": BaseModel,
+        "RelationField": RelationField,
+        "ONE_TO_MANY": Cardinality.ONE_TO_MANY,
+    }
+    with pytest.raises(NameError, match="Missing"):
+        exec(source, namespace)

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/tests/unit/core/model/test_model.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+from typing import Annotated
+
 import msgspec
 import pytest
+from msgspec import UnsetType
 
 from loom.core.model import (
     BaseModel,
@@ -38,6 +41,12 @@ class _Product(BaseModel):
         depends_on=("reviews:product_id",),
         default=0,
     )
+    rating: Annotated[int, "stars"] = ProjectionField(loader=None, default=0)
+
+
+def test_annotated_projection_keeps_its_metadata() -> None:
+    types = {field.name: field.type for field in msgspec.structs.fields(_Product)}
+    assert types["rating"] == Annotated[int, "stars"] | UnsetType
 
 
 class TestModelIntrospection:

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/tests/unit/etl/backends/test_polars/test_provider_optional_mongo.py

@@ -38,7 +38,7 @@ def test_provider_imports_with_pymongo_hidden(tmp_path: Path) -> None:
     )
 
     assert result.returncode == 0, result.stderr
-    assert result.stdout.split() == ["ReaderRegistry", "PolarsTargetWriter"]
+    assert result.stdout.split() == ["PolarsSourceReader", "PolarsTargetWriter"]
 
 
 def test_mongo_source_without_pymongo_names_the_extra(

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/tests/unit/etl/io/targets/test_clickhouse_writer.py

@@ -104,3 +104,16 @@ class TestMissingDependency:
             pytest.raises(ImportError, match="clickhouse-connect"),
         ):
             ClickHouseTargetWriter(_URL)
+
+
+class _DeltaSpec:
+    kind = "delta"
+
+
+class TestSpecGuards:
+    def test_a_spec_of_another_kind_is_refused(self) -> None:
+        writer, client = _make_writer()
+
+        with pytest.raises(TypeError, match="does not handle _DeltaSpec"):
+            writer.write(pl.DataFrame({"a": [1]}), _DeltaSpec(), _PARAMS)  # type: ignore[arg-type]
+        client.insert_df.assert_not_called()

loom_kernel-2.1.3/tests/unit/etl/io/test_writer_registry.py

@@ -0,0 +1,70 @@
+"""Tests for WriterRegistry dispatch logic."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from loom.etl.io._registry import WriterRegistry
+
+
+class _FakeSpec:
+    """A minimal spec object with a configurable kind."""
+
+    def __init__(self, kind: str) -> None:
+        self.kind = kind
+
+
+_PARAMS = object()
+
+
+class TestWriterRegistryDispatch:
+    def test_writes_through_the_writer_registered_for_the_kind(self) -> None:
+        clickhouse_writer = MagicMock()
+        base_writer = MagicMock()
+        registry = WriterRegistry(base_writer, extra={"clickhouse": clickhouse_writer})
+        frame = object()
+        spec = _FakeSpec(kind="clickhouse")
+
+        registry.write(frame, spec, _PARAMS)
+
+        clickhouse_writer.write.assert_called_once_with(
+            frame, spec, _PARAMS, streaming=False, write_ctx=None
+        )
+        base_writer.write.assert_not_called()
+
+    def test_falls_back_to_the_base_writer_for_an_unregistered_kind(self) -> None:
+        base_writer = MagicMock()
+        registry = WriterRegistry(base_writer, extra={"clickhouse": MagicMock()})
+        frame = object()
+        spec = _FakeSpec(kind="delta")
+
+        registry.write(frame, spec, _PARAMS)
+
+        base_writer.write.assert_called_once_with(
+            frame, spec, _PARAMS, streaming=False, write_ctx=None
+        )
+
+    def test_falls_back_to_the_base_writer_for_a_spec_without_a_kind(self) -> None:
+        base_writer = MagicMock()
+
+        class _KindlessSpec:
+            pass
+
+        registry = WriterRegistry(base_writer, extra={"clickhouse": MagicMock()})
+        frame = object()
+        spec = _KindlessSpec()
+
+        registry.write(frame, spec, _PARAMS)
+
+        base_writer.write.assert_called_once_with(
+            frame, spec, _PARAMS, streaming=False, write_ctx=None
+        )
+
+    def test_forwards_the_streaming_flag(self) -> None:
+        clickhouse_writer = MagicMock()
+        registry = WriterRegistry(MagicMock(), extra={"clickhouse": clickhouse_writer})
+
+        registry.write(object(), _FakeSpec(kind="clickhouse"), _PARAMS, streaming=True)
+
+        _, call_kwargs = clickhouse_writer.write.call_args
+        assert call_kwargs["streaming"] is True

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/tests/unit/etl/storage/test_backend_factory.py

@@ -57,13 +57,11 @@ class _DummyTargetWriter:
 
 def test_make_backends_polars_path_defaults_returns_polars_types(tmp_path: Path) -> None:
     from loom.etl.backends.polars import PolarsSourceReader, PolarsTargetWriter
-    from loom.etl.io._registry import ReaderRegistry
 
     config = StorageConfig(defaults=_path_defaults(str(tmp_path / "test-lake")))
     reader, writer = make_backends(config)
 
-    assert isinstance(reader, ReaderRegistry)
-    assert isinstance(reader._base, PolarsSourceReader)
+    assert isinstance(reader, PolarsSourceReader)
     assert isinstance(writer, PolarsTargetWriter)
 
 
@@ -88,7 +86,6 @@ def test_make_backends_prefers_spark_when_session_is_provided() -> None:
 
 def test_make_backends_polars_catalog_route_builds_backends() -> None:
     from loom.etl.backends.polars import PolarsSourceReader, PolarsTargetWriter
-    from loom.etl.io._registry import ReaderRegistry
 
     config = StorageConfig(
         catalogs={
@@ -98,8 +95,7 @@ def test_make_backends_polars_catalog_route_builds_backends() -> None:
     )
     reader, writer = make_backends(config)
 
-    assert isinstance(reader, ReaderRegistry)
-    assert isinstance(reader._base, PolarsSourceReader)
+    assert isinstance(reader, PolarsSourceReader)
     assert isinstance(writer, PolarsTargetWriter)
 
 
@@ -120,11 +116,8 @@ def test_make_backends_polars_mixed_routes_builds_backends(tmp_path: Path) -> No
         ),
     )
 
-    from loom.etl.io._registry import ReaderRegistry
-
     reader, writer = make_backends(config)
-    assert isinstance(reader, ReaderRegistry)
-    assert isinstance(reader._base, PolarsSourceReader)
+    assert isinstance(reader, PolarsSourceReader)
     assert isinstance(writer, PolarsTargetWriter)
 
 

{loom_kernel-2.1.2 → loom_kernel-2.1.3}/tests/unit/etl/test_runner.py

@@ -312,7 +312,6 @@ class TestRunnerFromConfig:
         has_checkpoint_store: bool,
     ) -> None:
         from loom.etl.backends.polars import PolarsSourceReader, PolarsTargetWriter
-        from loom.etl.io._registry import ReaderRegistry
 
         config = StorageConfig(
             defaults=StorageDefaults(table_path=TablePathConfig(uri=str(tmp_path))),
@@ -320,8 +319,7 @@ class TestRunnerFromConfig:
         )
         runner = ETLRunner.from_config(config)
 
-        assert isinstance(runner._executor._reader, ReaderRegistry)
-        assert isinstance(runner._executor._reader._base, PolarsSourceReader)
+        assert isinstance(runner._executor._reader, PolarsSourceReader)
         assert isinstance(runner._executor._writer, PolarsTargetWriter)
         assert (runner._checkpoint_store is not None) is has_checkpoint_store
 
@@ -357,11 +355,9 @@ class TestRunnerFromConfig:
 class TestRunnerFromDict:
     def test_from_dict_polars_path_builds_polars_backends(self, tmp_path: Path) -> None:
         from loom.etl.backends.polars import PolarsSourceReader
-        from loom.etl.io._registry import ReaderRegistry
 
         runner = ETLRunner.from_dict({"defaults": {"table_path": {"uri": str(tmp_path)}}})
-        assert isinstance(runner._executor._reader, ReaderRegistry)
-        assert isinstance(runner._executor._reader._base, PolarsSourceReader)
+        assert isinstance(runner._executor._reader, PolarsSourceReader)
 
     @pytest.mark.parametrize(
         "storage,error,match",

loom_kernel-2.1.2/src/loom/etl/io/_registry.py

@@ -1,96 +0,0 @@
-"""Dispatch registries that route specs to per-kind readers and writers."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from loom.etl.runtime.contracts import StreamingSourceReader
-
-
-class ConfigurationError(Exception):
-    """Raised when a required connector dependency is absent at construction."""
-
-
-class ReaderRegistry:
-    def __init__(
-        self,
-        base: Any | None,
-        *,
-        extra: dict[str, Any] | None = None,
-    ) -> None:
-        self._base = base
-        self._extra: dict[str, Any] = extra or {}
-
-    def read(self, spec: Any, params: Any, /) -> Any:
-        handler = self._resolve_handler(spec)
-        return handler.read(spec, params)
-
-    def read_streaming(self, spec: Any, params: Any, /) -> Any:
-        """Dispatch a streaming read to the per-kind handler or base reader.
-
-        Args:
-            spec: Source specification with a ``.kind`` attribute.
-            params: Concrete params for current run.
-
-        Returns:
-            Backend frame produced by the matching reader's
-            ``read_streaming``.
-
-        Raises:
-            ConfigurationError: When no reader is registered for this kind.
-            TypeError: When the matching reader does not implement
-                :class:`StreamingSourceReader`.
-        """
-        handler = self._resolve_handler(spec)
-        if not isinstance(handler, StreamingSourceReader):
-            raise TypeError(
-                f"Reader for spec kind {spec.kind!r} "
-                f"({type(handler).__qualname__}) does not implement "
-                "StreamingSourceReader; cannot honor streaming=True."
-            )
-        return handler.read_streaming(spec, params)
-
-    def _resolve_handler(self, spec: Any) -> Any:
-        handler = self._extra.get(spec.kind)
-        if handler is not None:
-            return handler
-        if self._base is not None:
-            return self._base
-        raise ConfigurationError(
-            f"No reader registered for spec kind {spec.kind!r} and no base reader."
-        )
-
-
-class WriterRegistry:
-    """Dispatch write() calls to a per-kind writer or fall back to the base writer.
-
-    The ``extra`` dict maps ``spec.kind`` strings to writer instances.  Specs
-    whose kind is not in ``extra`` are forwarded to ``base``.
-    """
-
-    def __init__(
-        self,
-        base: Any,
-        *,
-        extra: dict[str, Any] | None = None,
-    ) -> None:
-        self._base = base
-        self._extra: dict[str, Any] = extra or {}
-
-    def write(
-        self,
-        frame: Any,
-        spec: Any,
-        params: Any,
-        /,
-        *,
-        streaming: bool = False,
-        write_ctx: Any = None,
-    ) -> None:
-        """Dispatch write to the matching extra handler or fall back to base."""
-        kind = getattr(spec, "kind", None)
-        handler = self._extra.get(kind) if kind is not None else None
-        if handler is not None:
-            handler.write(frame, spec, params, streaming=streaming, write_ctx=write_ctx)
-            return
-        self._base.write(frame, spec, params, streaming=streaming, write_ctx=write_ctx)