slide2vec 7.1.2__tar.gz → 7.1.4__tar.gz

{slide2vec-7.1.2 → slide2vec-7.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 7.1.2
+Version: 7.1.4
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0

{slide2vec-7.1.2 → slide2vec-7.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "7.1.2"
+version = "7.1.4"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -218,7 +218,7 @@ testpaths = [
     "tests",
 ]
 markers = [
-    "heavy: real-weight foundation-model inference on CPU; minutes per test. Included in the PR suite and available separately through the manual heavy workflow (.github/workflows/nightly-heavy.yaml).",
+    "heavy: real-weight foundation-model inference on CPU; minutes per test. Excluded from the PR suite except the PRISM consistency test; run all of them through the manual heavy workflow (.github/workflows/nightly-heavy.yaml).",
     "gpu_integration: real one-GPU versus multi-GPU parity; requires at least two visible CUDA devices. Run explicitly with `CUDA_VISIBLE_DEVICES=0,1 python -m pytest -m gpu_integration --no-cov`.",
 ]
 
@@ -240,7 +240,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "7.1.2"
+current_version = "7.1.4"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false
 tag = false

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/__init__.py

@@ -36,7 +36,7 @@ from slide2vec.encoders import (
 )
 
 
-__version__ = "7.1.2"
+__version__ = "7.1.4"
 
 __all__ = [
     "Model",

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/api.py

@@ -708,6 +708,45 @@ class Model:
             encoded_pixels=encoded_pixels,
         )
 
+    def dense_identity_differences(
+        self,
+        recorded: Mapping[str, Any],
+        *,
+        dense: "DenseOptions | DenseImageOptions",
+        execution: ExecutionOptions | None = None,
+    ) -> dict[str, tuple[Any, Any]]:
+        """Compare a dense sidecar's ``compatibility`` block with the current request.
+
+        The dense counterpart of :meth:`pooled_identity_differences`. Pass the
+        ``dense`` options and ``execution`` of :meth:`embed_regions_dense` (a
+        :class:`DenseOptions`) or :meth:`embed_images_dense` (a
+        :class:`DenseImageOptions`). Returns ``{field: (recorded, current)}`` for every
+        request-wide field that the record holds with a different value or does not
+        hold. A field the record does not hold is reported as
+        :data:`slide2vec.MISSING_FIELD`. Per-sample fields (the sample, its path and its
+        read plan) are not compared. An empty result means the record proves the
+        current request-wide identity. The caller owns the policy for a difference.
+
+        An invalid request raises as it does in the embed methods. ``execution``
+        defaults to the model's recommended precision and needs no output directory.
+        Comparing the ``transform`` loads weights, on an isolated CPU model. This method
+        does not change this model's input contract or loaded backend, encode pixels,
+        or write files.
+        """
+        from slide2vec.runtime.feature_identity import dense_identity_differences
+
+        if not isinstance(dense, (DenseOptions, DenseImageOptions)):
+            raise TypeError(
+                "Model.dense_identity_differences(dense=...) expects DenseOptions "
+                f"or DenseImageOptions, got {type(dense).__name__}"
+            )
+        return dense_identity_differences(
+            self,
+            dict(recorded),
+            dense=dense,
+            execution=_coerce_execution_options(execution, model=self),
+        )
+
     def prepare_dense_encoder(
         self,
         *,
@@ -1085,6 +1124,11 @@ class Model:
         non-timm backbone, say) fails before any backend is loaded and before resume
         inspects or invalidates an existing artifact.
         """
+        if self.level != "tile":
+            raise ValueError(
+                "Dense extraction requires a tile-level foundation encoder; model "
+                f"{self.name!r} is registered at level {self.level!r}."
+            )
         contract = EncoderInputContract.declared_dense(
             self.name,
             target_size_px=dense.target_size,

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/encoders/__init__.py

@@ -16,6 +16,7 @@ from slide2vec.encoders.base import (
     resolve_recommended_dynamic_img_size,
     resolve_requested_output_variant,
 )
+from slide2vec.encoders.code import encoder_code
 from slide2vec.encoders.registry import (
     EncoderCapabilities,
     EncoderProviderDiagnostic,
@@ -42,6 +43,7 @@ __all__ = [
     "reshape_tokens_to_grid",
     "resolve_recommended_dynamic_img_size",
     "resolve_requested_output_variant",
+    "encoder_code",
     "encoder_registry",
     "list_encoder_provider_diagnostics",
     "normalize_patch_size",

slide2vec-7.1.4/slide2vec/encoders/code.py

@@ -0,0 +1,102 @@
+"""The code a registered encoder runs, as the feature identity records it."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import functools
+import hashlib
+from importlib import metadata as importlib_metadata
+import inspect
+import json
+from pathlib import Path
+import re
+import sys
+from typing import Any
+
+from slide2vec.encoders.registry import encoder_registry
+
+
+def encoder_code(name: str) -> dict[str, Any]:
+    """Return the code block of the registered encoder *name*.
+
+    ``object`` is the encoder class's ``module.qualname``. ``fingerprint`` is the
+    version of the non-editable installed distribution, other than slide2vec, whose
+    ``RECORD`` lists the file that defines the class; otherwise the SHA-256 of that
+    file, hashed on every call; ``None`` when there is no file (a class defined in a
+    notebook cell). ``source`` is the registry's ``source``. Reads the registry entry
+    only: the encoder is not instantiated and no weights are loaded.
+    """
+    encoder_cls = encoder_registry.require(name)
+    return {
+        "object": f"{encoder_cls.__module__}.{encoder_cls.__qualname__}",
+        "fingerprint": _fingerprint(encoder_cls),
+        "source": encoder_registry.info(name)["source"],
+    }
+
+
+def _fingerprint(encoder_cls: type) -> str | None:
+    path = _source_file(encoder_cls)
+    if path is None:
+        return None
+    distribution = _installed_distribution(encoder_cls.__module__, path)
+    return _sha256(path) if distribution is None else distribution.version
+
+
+def _installed_distribution(module: str, path: Path) -> importlib_metadata.Distribution | None:
+    """The non-editable installed distribution, other than slide2vec, whose ``RECORD``
+    lists *path*, or ``None``.
+
+    slide2vec is left out so that a built-in encoder's identity changes only when a
+    release changes its file. The distributions of a namespace package share its
+    top-level name and its install directory, so the top-level name only narrows the
+    candidates.
+    """
+    top = module.split(".", 1)[0]
+    for name in _packages_distributions(tuple(sys.path)).get(top, ()):
+        if re.sub(r"[-_.]+", "-", name).lower() == "slide2vec":
+            continue
+        try:
+            distribution = importlib_metadata.distribution(name)
+        except importlib_metadata.PackageNotFoundError:
+            continue
+        if distribution.read_text("RECORD") is None or _is_editable(distribution):
+            continue
+        try:
+            relative = path.relative_to(Path(distribution.locate_file("")).resolve())
+        except ValueError:
+            continue
+        if relative.as_posix() in {file.as_posix() for file in distribution.files or ()}:
+            return distribution
+    return None
+
+
+def _is_editable(distribution) -> bool:
+    """Whether *distribution* is an editable install, as its ``direct_url.json`` records."""
+    try:
+        payload = json.loads(distribution.read_text("direct_url.json") or "{}")
+    except json.JSONDecodeError:
+        return False
+    return isinstance(payload, dict) and bool((payload.get("dir_info") or {}).get("editable"))
+
+
+@functools.lru_cache(maxsize=1)
+def _packages_distributions(path: tuple[str, ...]) -> Mapping[str, list[str]]:
+    """Top-level package -> distributions on the import *path*, scanned once per path."""
+    return importlib_metadata.packages_distributions()
+
+
+def _source_file(encoder_cls: type) -> Path | None:
+    """The file that defines *encoder_cls*, or ``None`` (a notebook cell)."""
+    try:
+        path = Path(inspect.getsourcefile(encoder_cls) or inspect.getfile(encoder_cls))
+    except (TypeError, OSError):
+        return None
+    return path.resolve() if path.is_file() else None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/inference.py

@@ -725,8 +725,8 @@ def aggregate_tiles(
                 execution=execution,
             )
             latents = None
-        # Aggregation encodes no tile: the tile geometry and transform are the ones
-        # recorded with the tile artifact.
+        # Aggregation encodes no tile: the tile geometry, transform and tile encoder code
+        # are the ones recorded with the tile artifact.
         tile_identity = metadata.get("compatibility") or {}
         compatibility = {
             **feature_identity.pooled_feature_identity(model, execution=execution),
@@ -736,6 +736,11 @@ def aggregate_tiles(
                 if field in tile_identity
             },
         }
+        # A slide run's tile sidecar records the tile encoder's code under `tile_encoder_code`.
+        compatibility.pop("tile_encoder_code", None)
+        tile_code = tile_identity.get("tile_encoder_code") or tile_identity.get("encoder_code")
+        if tile_code is not None:
+            compatibility["tile_encoder_code"] = tile_code
         slide_artifact = embedding.write_slide_embedding_artifact(
             artifact.sample_id,
             slide_embedding,

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/runtime/dense_image_recipe.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import math
+from dataclasses import dataclass, fields
 from pathlib import Path
 from typing import Any
 
-from slide2vec.encoders.registry import resolve_encoder_output
+from slide2vec.encoders.code import encoder_code
+from slide2vec.encoders.registry import resolve_encoder_output, resolve_preprocessing_defaults
+from slide2vec.encoders.validation import validate_encoder_config
 from slide2vec.runtime.model_settings import output_dtype_name, resolve_output_precision
 
 
@@ -67,6 +70,8 @@ class DenseImageRecipe:
     """Request-wide extraction facts combined with one parent-resolved image read plan."""
 
     encoder_name: str
+    #: The encoder's code block (:func:`slide2vec.encoders.encoder_code`).
+    encoder_code: dict[str, Any]
     output_variant: str
     reader_regime: str
     spacing_source: str
@@ -99,6 +104,7 @@ class DenseImageRecipe:
     def to_dict(self) -> dict[str, Any]:
         payload = {
             "encoder_name": self.encoder_name,
+            "encoder_code": self.encoder_code,
             "output_variant": self.output_variant,
             "reader_regime": self.reader_regime,
             "spacing_source": self.spacing_source,
@@ -130,6 +136,20 @@ class DenseImageRecipe:
             payload["transform"] = self.transform
         return payload
 
+    def request_identity(self) -> dict[str, Any]:
+        """The request-wide fields of :meth:`for_image`: the recipe without per-image fields.
+
+        The per-image fields are the read plan's, which :meth:`for_image` replaces, and
+        the read sizes.
+        """
+        from slide2vec.runtime.dense_image_reading import DenseImageReadPlan
+
+        per_image = {field.name for field in fields(DenseImageReadPlan)} | {
+            "read_tile_size_px",
+            "requested_tile_size_px",
+        }
+        return {key: value for key, value in self.to_dict().items() if key not in per_image}
+
     def for_image(self, spec, read_plan=None) -> dict[str, Any]:
         """Add the normalized source identity to this request-wide recipe."""
         if read_plan is None:
@@ -142,6 +162,7 @@ class DenseImageRecipe:
             )
         recipe = self.to_dict()
         encoder_name = recipe.pop("encoder_name")
+        code = recipe.pop("encoder_code")
         output_variant = recipe.pop("output_variant")
         for field in read_plan.to_dict():
             recipe.pop(field, None)
@@ -149,6 +170,7 @@ class DenseImageRecipe:
             "sample_id": str(spec.sample_id),
             "image_path": str(Path(spec.image_path).expanduser().resolve()),
             "encoder_name": encoder_name,
+            "encoder_code": code,
             "output_variant": output_variant,
             **read_plan.to_dict(),
             **recipe,
@@ -158,6 +180,7 @@ class DenseImageRecipe:
     def from_dict(cls, payload: dict[str, Any]) -> "DenseImageRecipe":
         return cls(
             encoder_name=str(payload["encoder_name"]),
+            encoder_code=dict(payload["encoder_code"]),
             output_variant=str(payload["output_variant"]),
             reader_regime=str(payload["reader_regime"]),
             spacing_source=str(payload["spacing_source"]),
@@ -218,6 +241,38 @@ class DenseImageRecipe:
         )
 
 
+def resolve_dense_image_spacing(model, dense) -> tuple[float, str]:
+    """Resolve and validate the run spacing of *dense*: ``(spacing_um, spacing_source)``.
+
+    An omitted spacing resolves the encoder's single registry default.
+    """
+    spacing_source = "explicit"
+    if dense.spacing_um is None:
+        try:
+            spacing_um = float(
+                resolve_preprocessing_defaults(model.name)["spacing_um"]
+            )
+        except (KeyError, ValueError) as exc:
+            raise ValueError(
+                "DenseImageOptions.spacing_um must be explicit when encoder "
+                f"{model.name!r} has no single resolvable model default: {exc}"
+            ) from exc
+        spacing_source = "model_default"
+    else:
+        spacing_um = float(dense.spacing_um)
+    if not math.isfinite(spacing_um) or spacing_um <= 0:
+        raise ValueError(
+            "DenseImageOptions.spacing_um must be a positive, finite value or None."
+        )
+    validate_encoder_config(
+        model.name,
+        requested_spacing_um=spacing_um,
+        allow_non_recommended=bool(model.allow_non_recommended_settings),
+        require_known_spacing=True,
+    )
+    return spacing_um, spacing_source
+
+
 def resolve_dense_image_recipe(
     *,
     model,
@@ -270,6 +325,7 @@ def resolve_dense_image_recipe(
     )
     return DenseImageRecipe(
         encoder_name=str(model.name),
+        encoder_code=encoder_code(model.name),
         output_variant=str(output["output_variant"]),
         reader_regime=str(reader_regime),
         spacing_source=(

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/runtime/dense_image_stage.py

@@ -29,7 +29,6 @@ from __future__ import annotations
 
 import json
 import logging
-import math
 from dataclasses import replace
 from pathlib import Path
 from subprocess import Popen
@@ -37,8 +36,6 @@ from typing import Callable, Sequence
 
 from slide2vec.api import DenseImageOptions, ImageSpec
 from slide2vec.artifacts import DenseImageArtifact
-from slide2vec.encoders.registry import resolve_preprocessing_defaults
-from slide2vec.encoders.validation import validate_encoder_config
 from slide2vec.progress import emit_progress
 from slide2vec.runtime.dense_image_shard import (
     dense_image_artifact_from_disk,
@@ -48,6 +45,7 @@ from slide2vec.runtime.dense_image_shard import (
 from slide2vec.runtime.dense_image_recipe import (
     DenseImageRecipe,
     resolve_dense_image_recipe,
+    resolve_dense_image_spacing,
 )
 from slide2vec.runtime.dense_image_reading import DenseImageReadPlan, resolve_spacing_read_plan
 from slide2vec.runtime.dense_stage import resolve_output_torch_dtype
@@ -115,31 +113,8 @@ def embed_images_dense(
         artifact_location="dense_image_embeddings/<sample_id>",
     )
     reader_regime, probed_auto_backends = validate_dense_image_reader_regime(specs)
-    spacing_source = "explicit"
-    if dense.spacing_um is None:
-        try:
-            spacing_um = float(
-                resolve_preprocessing_defaults(model.name)["spacing_um"]
-            )
-        except (KeyError, ValueError) as exc:
-            raise ValueError(
-                "DenseImageOptions.spacing_um must be explicit when encoder "
-                f"{model.name!r} has no single resolvable model default: {exc}"
-            ) from exc
-        spacing_source = "model_default"
-        dense = replace(dense, spacing_um=spacing_um)
-    else:
-        spacing_um = float(dense.spacing_um)
-    if spacing_um is not None and (not math.isfinite(spacing_um) or spacing_um <= 0):
-        raise ValueError(
-            "DenseImageOptions.spacing_um must be a positive, finite value or None."
-        )
-    validate_encoder_config(
-        model.name,
-        requested_spacing_um=spacing_um,
-        allow_non_recommended=bool(model.allow_non_recommended_settings),
-        require_known_spacing=True,
-    )
+    spacing_um, spacing_source = resolve_dense_image_spacing(model, dense)
+    dense = replace(dense, spacing_um=spacing_um)
     # Declare the effective encoder input before anything is decoded, sharded or launched: an
     # image geometry this encoder cannot accept must fail here, not on the first forward pass
     # of a torchrun rank. Idempotent, so every rank re-declares for itself (dense_image_worker).

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec/runtime/feature_identity.py

@@ -11,6 +11,7 @@ from PIL import Image
 from transformers.image_processing_utils import BaseImageProcessor
 
 from slide2vec.encoders.base import ProcessorTransform
+from slide2vec.encoders.code import encoder_code
 from slide2vec.encoders.registry import encoder_registry
 from slide2vec.runtime.model_settings import output_dtype_name, resolve_output_precision
 from slide2vec.runtime.preprocessing import iter_transform_steps
@@ -35,6 +36,7 @@ def pooled_feature_identity(
     if model.level != "tile" and model.name in encoder_registry:
         info = encoder_registry.info(model.name)
         identity["tile_encoder"] = info["tile_encoder"]
+        identity["tile_encoder_code"] = encoder_code(info["tile_encoder"])
         identity["tile_encoder_output_variant"] = info["tile_encoder_output_variant"]
         if info.get("aggregation_revision") is not None:
             identity["aggregation_revision"] = info["aggregation_revision"]
@@ -74,15 +76,16 @@ def dense_feature_identity(model, *, dense, execution) -> dict[str, Any]:
 
 
 def _encoder_identity(model, execution) -> dict[str, Any]:
-    """The fields every path records: the encoder, its output variant, the precision."""
+    """The fields every path records: the encoder, its code, its output variant, the precision."""
     from slide2vec.runtime.process_list import resolved_process_list_output_variant
 
-    return {
-        "encoder_name": model.name,
-        "output_variant": resolved_process_list_output_variant(model),
-        # An unset inference precision runs without autocast, which is fp32.
-        "precision": execution.precision or "fp32",
-    }
+    identity: dict[str, Any] = {"encoder_name": model.name}
+    if model.name in encoder_registry:
+        identity["encoder_code"] = encoder_code(model.name)
+    identity["output_variant"] = resolved_process_list_output_variant(model)
+    # An unset inference precision runs without autocast, which is fp32.
+    identity["precision"] = execution.precision or "fp32"
+    return identity
 
 
 def deferred_transform_record(
@@ -222,6 +225,69 @@ def pooled_identity_differences(
     )
 
 
+def dense_identity_differences(
+    model,
+    recorded: dict[str, Any],
+    *,
+    dense,
+    execution,
+) -> dict[str, tuple[Any, Any]]:
+    """Compare a recorded dense identity with the request-wide identity of the current request.
+
+    A :class:`~slide2vec.api.DenseImageOptions` request is compared with the image recipe,
+    any other with the region identity. The request is validated as the embed methods
+    validate it, on an isolated CPU copy of *model* that declares the dense encoder-input
+    contract, so *model* keeps its contract and backend. The transform is that copy's
+    ``get_normalization_transform()``, as the shards record it.
+    """
+    from slide2vec.api import DenseImageOptions, Model
+
+    source = Model.from_preset(
+        model.name,
+        device="cpu",
+        output_variant=model._output_variant,
+        allow_non_recommended_settings=model.allow_non_recommended_settings,
+    )
+    if isinstance(dense, DenseImageOptions):
+        from slide2vec.runtime.dense_image_recipe import (
+            resolve_dense_image_recipe,
+            resolve_dense_image_spacing,
+        )
+
+        resolve_dense_image_spacing(source, dense)  # validates; the spacing is per-sample
+        contract = source._declare_dense_encoder_input(dense, emit_run_info=False)
+        requested = resolve_dense_image_recipe(
+            model=source, contract=contract, dense=dense, execution=execution
+        ).request_identity()
+    else:
+        from slide2vec.encoders.registry import resolve_patch_size
+        from slide2vec.runtime.dense_regions import (
+            compute_dense_geometry,
+            validate_dense_request_settings,
+        )
+
+        plan = source._declare_dense_encoder_input(dense, emit_run_info=False).plan
+        # The region shards validate the same settings when they encode.
+        validate_dense_request_settings(
+            compute_dense_geometry(
+                target_size=plan.target_size_px,
+                patch_size=resolve_patch_size(plan.tile_encoder_name),
+            ),
+            pad_mode=dense.pad_mode,
+            window_size=dense.window_size,
+            overlap=dense.overlap,
+            feature_kind=dense.feature_kind,
+            attention_blocks=dense.attention_blocks,
+            attention_include_registers=dense.attention_include_registers,
+        )
+        requested = dense_feature_identity(source, dense=dense, execution=execution)
+
+    def resolve_transform() -> dict[str, Any]:
+        return transform_record(source._load_backend().model.get_normalization_transform())
+
+    return differing_fields(recorded, requested, resolve_transform=resolve_transform)
+
+
 class PooledResumeCheck:
     """Compare the completed pooled artifacts of one resume with the run's feature identity.
 
@@ -253,11 +319,16 @@ class PooledResumeCheck:
                 for field, values in differing.items()
                 for leaf, old, new in _leaf_differences(field, *values)
             )
+            # A caller can request a recorded value, but not recorded code.
+            remedies = (
+                "Re-run into a new output_dir or delete the stale artifacts."
+                if differing.keys() & {"encoder_code", "tile_encoder_code"}
+                else "Re-run into a new output_dir, delete the stale artifacts, or request "
+                "the recorded values."
+            )
             raise ValueError(
                 f"Cannot resume '{sample_id}': the existing {kind} embeddings at {path} "
-                f"were computed with a different feature identity: {details}. Re-run into "
-                "a new output_dir, delete the stale artifacts, or request the recorded "
-                "values."
+                f"were computed with a different feature identity: {details}. {remedies}"
             )
         return not missing
 

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 7.1.2
+Version: 7.1.4
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0

{slide2vec-7.1.2 → slide2vec-7.1.4}/slide2vec.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ slide2vec/distributed/pipeline_worker.py
 slide2vec/distributed/worker_entry.py
 slide2vec/encoders/__init__.py
 slide2vec/encoders/base.py
+slide2vec/encoders/code.py
 slide2vec/encoders/registry.py
 slide2vec/encoders/validation.py
 slide2vec/encoders/models/__init__.py
@@ -122,6 +123,7 @@ tests/test_cufile_compat_mode.py
 tests/test_dense_encode_kit.py
 tests/test_dense_encoder_input.py
 tests/test_dense_extraction.py
+tests/test_dense_identity_api.py
 tests/test_dense_image_reading.py
 tests/test_dense_image_resume.py
 tests/test_dense_image_shard.py
@@ -136,6 +138,7 @@ tests/test_dinov2_natimage.py
 tests/test_dinov3_natimage.py
 tests/test_drop_in_encoders.py
 tests/test_encoder_capabilities.py
+tests/test_encoder_code.py
 tests/test_encoder_input_contract.py
 tests/test_encoder_plugins.py
 tests/test_encoder_preprocessing.py