slide2vec 7.1.2__tar.gz → 7.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 7.1.2
+Version: 7.1.3
 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.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "7.1.2"
+version = "7.1.3"
 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.3"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false
 tag = false

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

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

{slide2vec-7.1.2 → slide2vec-7.1.3}/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.3/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.3}/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.3}/slide2vec/runtime/dense_image_recipe.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
+from slide2vec.encoders.code import encoder_code
 from slide2vec.encoders.registry import resolve_encoder_output
 from slide2vec.runtime.model_settings import output_dtype_name, resolve_output_precision
 
@@ -67,6 +68,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 +102,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,
@@ -142,6 +146,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 +154,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 +164,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"]),
@@ -270,6 +277,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.3}/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(
@@ -253,11 +256,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.3}/slide2vec.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 7.1.2
+Version: 7.1.3
 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.3}/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
@@ -136,6 +137,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

{slide2vec-7.1.2 → slide2vec-7.1.3}/tests/test_dense_image_resume.py

@@ -9,6 +9,7 @@ import pytest
 
 from slide2vec.api import DenseImageOptions, ExecutionOptions, ImageSpec, Model
 from slide2vec.artifacts import dense_image_paths
+from slide2vec.encoders import encoder_code
 from slide2vec.runtime.dense_image_stage import partition_dense_images_by_resume
 from slide2vec.runtime.dense_image_recipe import resolve_dense_image_recipe
 from slide2vec.runtime.dense_image_reading import DenseImageReadPlan
@@ -80,6 +81,7 @@ def test_dense_image_recipe_contains_the_complete_canonical_identity(tmp_path):
     )
     assert first.to_dict() == {
         "encoder_name": "virchow2",
+        "encoder_code": encoder_code("virchow2"),
         "output_variant": "cls",
         "reader_regime": "raster",
         "spacing_source": "explicit",
@@ -444,6 +446,7 @@ def test_every_recorded_compatibility_field_participates_in_resume(tmp_path):
         "sample_id",
         "image_path",
         "encoder_name",
+        "encoder_code",
         "output_variant",
         "reader_regime",
         "spacing_source",
@@ -493,6 +496,8 @@ def test_every_recorded_compatibility_field_participates_in_resume(tmp_path):
             recorded[field] = f"{value}-different"
         elif isinstance(value, list):
             recorded[field] = [value[0] + 1, *value[1:]]
+        elif isinstance(value, dict):
+            recorded[field] = {**value, "fingerprint": "different"}
         else:
             recorded[field] = value + 1
         out_dir = tmp_path / field

{slide2vec-7.1.2 → slide2vec-7.1.3}/tests/test_dense_image_shard.py

@@ -97,6 +97,7 @@ def _recipe(
     geometry = compute_dense_geometry(target_size=target_size, patch_size=(16, 16))
     return DenseImageRecipe(
         encoder_name="fake-encoder",
+        encoder_code={"object": "tests.FakeEncoder", "fingerprint": None, "source": ""},
         output_variant="default",
         reader_regime="raster",
         spacing_source="explicit",
@@ -317,6 +318,7 @@ def test_run_dense_image_shard_sidecar_records_extraction_geometry(tmp_path):
             "sample_id": "a",
             "image_path": str(Path(specs[0].image_path).resolve()),
             "encoder_name": "fake-encoder",
+            "encoder_code": {"object": "tests.FakeEncoder", "fingerprint": None, "source": ""},
             "output_variant": "default",
             "reader_regime": "raster",
             "spacing_source": "explicit",

{slide2vec-7.1.2 → slide2vec-7.1.3}/tests/test_dense_stage.py

@@ -385,6 +385,22 @@ def test_dense_region_sidecar_records_the_feature_identity(fake_backend, stub_re
     assert compatibility["read_level"] == 0  # the read plan is still recorded alongside
 
 
+def test_dense_region_sidecar_records_the_code_of_a_registered_encoder(
+    fake_backend, stub_read_plan, tmp_path
+):
+    from slide2vec.encoders import encoder_code
+
+    [artifact] = dense_stage.embed_regions_dense(
+        _FakeModel(_encoder(), name="virchow2"),
+        [_regions(coords=((0, 0),))],
+        dense=_dense(),
+        execution=ExecutionOptions(output_dir=tmp_path, num_gpus=1, precision="fp32"),
+    )
+
+    compatibility = json.loads(artifact.metadata_path.read_text())["compatibility"]
+    assert compatibility["encoder_code"] == encoder_code("virchow2")
+
+
 def test_embed_regions_dense_resume_recomputes_regions_from_a_different_encoder(
     fake_backend, stub_read_plan, tmp_path
 ):

slide2vec-7.1.3/tests/test_encoder_code.py

@@ -0,0 +1,241 @@
+"""The encoder code block the feature identity records under ``encoder_code``.
+
+Ways it can go wrong, each covered below:
+
+* computing the block instantiates the encoder or loads its weights;
+* an edit to the file that defines the encoder leaves the block, or the comparison of
+  a recorded identity, unchanged;
+* an installed encoder records its file's digest instead of its distribution's version,
+  or a namespace package shared by several distributions is attributed by its
+  top-level name instead of by the ``RECORD`` that lists the file;
+* an editable install, or a file slide2vec itself installed, records a version that
+  does not change with the file;
+* a class with no file (a notebook cell) raises instead of recording no fingerprint.
+
+The installed-plugin path (a real ``pip install``) is covered in ``test_encoder_plugins.py``.
+"""
+
+import hashlib
+import importlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+import types
+
+from PIL import Image
+import pytest
+
+from slide2vec import ExecutionOptions, ImageSpec, Model
+from slide2vec.artifacts import load_metadata
+from slide2vec.encoders import encoder_code
+
+ENCODER_MODULE = '''
+from slide2vec import TorchTileEncoder, register_encoder
+
+
+@register_encoder(
+    "{name}",
+    encode_dim=8,
+    input_size=32,
+    supports_variable_input_size=False,
+    supported_spacing_um=0.5,
+    precision="fp32",
+    source="/models/{name}.pt",
+)
+class CustomEncoder(TorchTileEncoder):
+    def __init__(self, *, output_variant=None):
+        raise AssertionError("encoder_code must not instantiate the encoder")
+'''
+
+
+WORKING_ENCODER_MODULE = '''
+import torch
+
+from slide2vec import TorchTileEncoder, register_encoder
+
+
+@register_encoder(
+    "{name}",
+    encode_dim=3,
+    input_size=32,
+    supports_variable_input_size=False,
+    supported_spacing_um=0.5,
+    precision="fp32",
+    source="/models/{name}.pt",
+)
+class CustomEncoder(TorchTileEncoder):
+    def __init__(self, *, output_variant=None):
+        model = torch.nn.Sequential(torch.nn.AdaptiveAvgPool2d(1), torch.nn.Flatten())
+        super().__init__(
+            model, encode_dim=3, input_size=32, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5),
+            output_variant=output_variant,
+        )
+'''
+
+
+def _import_module_file(path: Path, module_name: str, monkeypatch) -> None:
+    """Import *path* as *module_name*, as a script importing its encoder module does."""
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    module = importlib.util.module_from_spec(spec)
+    monkeypatch.setitem(sys.modules, module_name, module)
+    spec.loader.exec_module(module)
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def test_encoder_code_of_a_module_file_encoder_names_its_class_file_digest_and_source(
+    tmp_path, monkeypatch, isolated_encoder_registry
+):
+    path = tmp_path / "custom_encoders.py"
+    path.write_text(ENCODER_MODULE.format(name="custom-code"), encoding="utf-8")
+    _import_module_file(path, "custom_encoders", monkeypatch)
+
+    assert encoder_code("custom-code") == {
+        "object": "custom_encoders.CustomEncoder",
+        "fingerprint": _sha256(path),
+        "source": "/models/custom-code.pt",
+    }
+
+
+def test_an_edit_to_a_module_file_encoder_is_a_feature_identity_difference(
+    tmp_path, monkeypatch, isolated_encoder_registry
+):
+    path = tmp_path / "edited_encoders.py"
+    path.write_text(WORKING_ENCODER_MODULE.format(name="edited-code"), encoding="utf-8")
+    _import_module_file(path, "edited_encoders", monkeypatch)
+    image_path = tmp_path / "image.png"
+    Image.new("RGB", (48, 48), color=(255, 255, 255)).save(image_path)
+    model = Model.from_preset("edited-code", device="cpu")
+    execution = ExecutionOptions(
+        output_dir=tmp_path / "out", precision="fp32", num_gpus=1, num_workers_per_gpu=0
+    )
+    (artifact,) = model.embed_images(
+        [ImageSpec(sample_id="image", image_path=image_path)], execution=execution
+    )
+    recorded = load_metadata(artifact.metadata_path)["compatibility"]
+    recorded_code = {
+        "object": "edited_encoders.CustomEncoder",
+        "fingerprint": _sha256(path),
+        "source": "/models/edited-code.pt",
+    }
+
+    assert recorded["encoder_code"] == recorded_code
+    assert model.pooled_identity_differences(
+        recorded, preprocessing=None, execution=execution
+    ) == {}
+
+    path.write_text(path.read_text(encoding="utf-8") + "\n# An edit.\n", encoding="utf-8")
+
+    assert model.pooled_identity_differences(
+        recorded, preprocessing=None, execution=execution
+    ) == {"encoder_code": (recorded_code, {**recorded_code, "fingerprint": _sha256(path)})}
+
+
+#: A namespace package (no ``__init__.py``) that two installed distributions share, as
+#: ``protobuf`` and ``googleapis-common-protos`` share ``google``.
+NAMESPACE = "slide2vec_test_namespace"
+
+
+def _install(site: Path, distribution: str, version: str, module: str, *, direct_url=None):
+    """Install ``<NAMESPACE>/<module>.py`` into *site* as *distribution*, listed in its RECORD."""
+    package = site / NAMESPACE
+    package.mkdir(parents=True, exist_ok=True)
+    (package / f"{module}.py").write_text(
+        ENCODER_MODULE.format(name=f"installed-{module}"), encoding="utf-8"
+    )
+    info = site / f"{distribution.replace('-', '_')}-{version}.dist-info"
+    info.mkdir()
+    (info / "METADATA").write_text(
+        f"Metadata-Version: 2.1\nName: {distribution}\nVersion: {version}\n", encoding="utf-8"
+    )
+    (info / "RECORD").write_text(
+        f"{NAMESPACE}/{module}.py,,\n{info.name}/METADATA,,\n{info.name}/RECORD,,\n",
+        encoding="utf-8",
+    )
+    if direct_url is not None:
+        (info / "direct_url.json").write_text(json.dumps(direct_url), encoding="utf-8")
+
+
+@pytest.fixture
+def site(tmp_path, monkeypatch, isolated_encoder_registry):
+    """An extra site directory on ``sys.path``; its namespace modules are unloaded after."""
+    site = tmp_path / "site-packages"
+    site.mkdir()
+    monkeypatch.syspath_prepend(str(site))
+    yield site
+    for name in [name for name in sys.modules if name.split(".", 1)[0] == NAMESPACE]:
+        sys.modules.pop(name)
+
+
+def _import_installed(module: str) -> None:
+    importlib.import_module(f"{NAMESPACE}.{module}")
+
+
+def test_encoder_code_of_an_installed_encoder_is_the_version_of_the_distribution_listing_it(site):
+    """Distributions of a namespace package share its top-level name: their RECORD decides."""
+    _install(site, "slide2vec-test-alpha", "1.0", "alpha")
+    _install(site, "slide2vec-test-beta", "2.0", "beta")
+    (site / NAMESPACE / "gamma.py").write_text(
+        ENCODER_MODULE.format(name="installed-gamma"), encoding="utf-8"
+    )
+    for module in ("alpha", "beta", "gamma"):
+        _import_installed(module)
+
+    assert {
+        module: encoder_code(f"installed-{module}")["fingerprint"]
+        for module in ("alpha", "beta", "gamma")
+    } == {
+        "alpha": "1.0",
+        "beta": "2.0",
+        # A file no distribution lists is not installed code: its digest pins it.
+        "gamma": _sha256(site / NAMESPACE / "gamma.py"),
+    }
+
+
+def test_encoder_code_of_an_editable_install_is_the_digest_of_its_file(site):
+    """An editable install runs the work tree: its version does not change with an edit."""
+    _install(
+        site, "slide2vec-test-editable", "3.0", "delta",
+        direct_url={"url": site.as_uri(), "dir_info": {"editable": True}},
+    )
+    _import_installed("delta")
+
+    assert encoder_code("installed-delta")["fingerprint"] == _sha256(site / NAMESPACE / "delta.py")
+
+
+def test_encoder_code_of_a_file_slide2vec_installed_is_its_digest(site):
+    """A built-in's identity changes when a release changes its file, not on every release."""
+    _install(site, "slide2vec", "99.0", "epsilon")
+    _import_installed("epsilon")
+
+    assert encoder_code("installed-epsilon")["fingerprint"] == _sha256(
+        site / NAMESPACE / "epsilon.py"
+    )
+
+
+def test_encoder_code_of_a_built_in_encoder_is_the_digest_of_its_file():
+    import slide2vec.encoders.models.virchow as virchow
+
+    assert encoder_code("virchow2") == {
+        "object": "slide2vec.encoders.models.virchow.Virchow2",
+        "fingerprint": _sha256(Path(virchow.__file__)),
+        "source": "paige-ai/Virchow2",
+    }
+
+
+def test_encoder_code_of_an_encoder_with_no_file_records_no_fingerprint(
+    monkeypatch, isolated_encoder_registry
+):
+    """A class defined in a notebook cell lives in a module that has no file."""
+    module = types.ModuleType("notebook_cell")
+    monkeypatch.setitem(sys.modules, "notebook_cell", module)
+    exec(compile(ENCODER_MODULE.format(name="cell-code"), "<cell>", "exec"), module.__dict__)
+
+    assert encoder_code("cell-code") == {
+        "object": "notebook_cell.CustomEncoder",
+        "fingerprint": None,
+        "source": "/models/cell-code.pt",
+    }

{slide2vec-7.1.2 → slide2vec-7.1.3}/tests/test_encoder_plugins.py

@@ -155,7 +155,7 @@ from threading import Barrier
 
 import slide2vec
 from slide2vec import Model, list_models
-from slide2vec.encoders import encoder_registry
+from slide2vec.encoders import encoder_code, encoder_registry
 from slide2vec.runtime.serialization import serialize_model
 
 discovered = Path(os.environ["PLUGIN_DISCOVERED_SENTINEL"])
@@ -201,6 +201,14 @@ assert encoder_registry.info("private-beta") == {
     "source": "private-org/private-beta",
 }
 
+# The installed distribution pins its encoders' code, without constructing them.
+assert encoder_code("private-alpha") == {
+    "object": "private_encoder_plugin.register_presets.<locals>.PrivateAlpha",
+    "fingerprint": "1.0.0",
+    "source": "/models/private-alpha.pt",
+}
+assert not constructed.exists()
+
 model = Model.from_preset("private-alpha", device="cpu")
 assert model.name == "private-alpha"
 assert model.level == "tile"