slide2vec 7.1.4__tar.gz → 7.1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 7.1.4
+Version: 7.1.5
 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.4 → slide2vec-7.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "7.1.4"
+version = "7.1.5"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -240,7 +240,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "7.1.4"
+current_version = "7.1.5"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false
 tag = false

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

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

slide2vec-7.1.5/slide2vec/encoders/models/mettle_1_5.py

@@ -0,0 +1,129 @@
+"""Mettle-1.5 tile encoder.
+
+Mettle-1.5 (slideflow labs; ``slideflow-labs/mettle-1.5``) is a later scanner and
+stain robustness fine-tune of H-optimus-0. It shares ``mettle``'s backbone,
+``MettleRefineHead``, H-optimus mean/std and feature views, so this module reuses
+:mod:`.mettle`. Weights are openly downloadable (not gated). The model card states
+no license; slide2vec only wraps user-downloaded weights and does not redistribute
+them.
+
+The given recipe resizes directly to 224x224, as upstream's
+``preprocessor_config.json`` does. ``mettle`` resizes the shortest side and
+center-crops instead. The two agree on square tiles.
+
+slide2vec strictly loads ``model.safetensors`` at a pinned revision, as for
+``mettle``; no remote code runs.
+
+Output variants (upstream ``feature_view``):
+
+* ``cls`` (1536, default): the headed CLS token. The card and upstream
+  ``config.json`` default to it; the card makes no benchmark claims for this
+  checkpoint.
+* ``cls_patch_mean`` (3072; upstream ``cls_mean``): the headed CLS token
+  concatenated with the *unheaded* mean of the spatial patch tokens (CLS and the
+  4 register tokens excluded).
+
+``mettle`` defaults to ``cls_patch_mean``, so a config moved from ``mettle`` to
+``mettle-1.5`` changes the feature dimension from 3072 to 1536.
+
+Precision, dense extraction and spacing are as for ``mettle``.
+"""
+
+from typing import Callable
+
+import torch
+from huggingface_hub import hf_hub_download
+from safetensors.torch import load_file
+from torchvision.transforms import v2
+
+from slide2vec.encoders.base import (
+    resolve_recommended_dynamic_img_size,
+    resolve_requested_output_variant,
+)
+from slide2vec.encoders.models.hoptimus import _HOPTIMUS_MEAN, _HOPTIMUS_STD
+from slide2vec.encoders.models.mettle import (
+    _EMBED_DIM,
+    _HEAD_HIDDEN_SIZE,
+    _HEAD_NUM_ATOMS,
+    _HEAD_RANK,
+    _HF_CHECKPOINT,
+    _OUTPUT_DIMS,
+    Mettle,
+    MettleRefineHead,
+    _strip_prefix,
+)
+from slide2vec.encoders.registry import register_encoder
+
+_HF_REPO_ID = "slideflow-labs/mettle-1.5"
+_HF_REVISION = "0ab55fcbf1b8d4e3c73885fc56f822fb568ff570"
+
+
+@register_encoder(
+    "mettle-1.5",
+    output_variants={
+        "cls": {"encode_dim": _OUTPUT_DIMS["cls"]},
+        "cls_patch_mean": {"encode_dim": _OUTPUT_DIMS["cls_patch_mean"]},
+    },
+    default_output_variant="cls",
+    input_size=224,
+    supports_variable_input_size=True,
+    variable_input_model_kwargs={"dynamic_img_size": True},
+    patch_size=14,
+    supported_spacing_um=0.5,  # not stated on the card; inherited from H-optimus-0
+    precision="fp16",
+    source=_HF_REPO_ID,
+)
+class Mettle15(Mettle):
+    # Mettle.__init__ hardcodes the Mettle-1 repo, so this one calls
+    # TimmTileEncoder.__init__ directly. mettle.py stays unchanged: its file hash is
+    # part of the feature identity of every cached mettle feature.
+    def __init__(
+        self,
+        *,
+        output_variant: str | None = None,
+        dynamic_img_size: bool | None = None,
+        allow_non_recommended_settings: bool = False,
+    ):
+        self._output_variant = resolve_requested_output_variant(
+            output_variant,
+            default="cls",
+            allowed=tuple(_OUTPUT_DIMS),
+        )
+        super(Mettle, self).__init__(
+            "vit_giant_patch14_reg4_dinov2",
+            output_variant="default",
+            pretrained=False,
+            init_values=1e-5,
+            img_size=224,
+            dynamic_img_size=resolve_recommended_dynamic_img_size(
+                requested=dynamic_img_size,
+                recommended=False,
+                allow_non_recommended=allow_non_recommended_settings,
+                encoder_name="mettle-1.5",
+            ),
+        )
+        self._head = MettleRefineHead(
+            dim=_EMBED_DIM,
+            num_atoms=_HEAD_NUM_ATOMS,
+            rank=_HEAD_RANK,
+            hidden_size=_HEAD_HIDDEN_SIZE,
+        )
+        state_dict = load_file(
+            hf_hub_download(repo_id=_HF_REPO_ID, filename=_HF_CHECKPOINT, revision=_HF_REVISION)
+        )
+        unexpected = [key for key in state_dict if not key.startswith(("backbone.", "head."))]
+        if unexpected:
+            raise ValueError(f"Unexpected keys in Mettle-1.5 checkpoint: {unexpected}")
+        self._model.load_state_dict(_strip_prefix(state_dict, "backbone."), strict=True)
+        self._head.load_state_dict(_strip_prefix(state_dict, "head."), strict=True)
+        self._model.eval()
+        self._head.eval()
+
+    def get_transform(self) -> Callable:
+        # Upstream's ViTImageProcessor resizes directly to 224x224, with no crop.
+        return v2.Compose([
+            v2.ToImage(),
+            v2.Resize((224, 224), interpolation=v2.InterpolationMode.BICUBIC, antialias=True),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=_HOPTIMUS_MEAN, std=_HOPTIMUS_STD),
+        ])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 7.1.4
+Version: 7.1.5
 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.4 → slide2vec-7.1.5}/slide2vec.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ slide2vec/encoders/models/hoptimus.py
 slide2vec/encoders/models/isight.py
 slide2vec/encoders/models/lunit.py
 slide2vec/encoders/models/mettle.py
+slide2vec/encoders/models/mettle_1_5.py
 slide2vec/encoders/models/midnight.py
 slide2vec/encoders/models/mstar.py
 slide2vec/encoders/models/musk.py

{slide2vec-7.1.4 → slide2vec-7.1.5}/tests/test_encoder_plugins.py

@@ -179,7 +179,7 @@ with ThreadPoolExecutor(max_workers=8) as executor:
 expected_models = listings[0]
 assert listings == [expected_models] * 8
 assert expected_models == sorted(expected_models)
-assert {"private-alpha", "private-beta", "virchow2", "mettle"} <= set(expected_models)
+assert {"private-alpha", "private-beta", "virchow2", "mettle", "mettle-1.5"} <= set(expected_models)
 assert discovered.read_text() == "discovered"
 assert not constructed.exists()
 

{slide2vec-7.1.4 → slide2vec-7.1.5}/tests/test_encoder_preprocessing.py

@@ -353,32 +353,36 @@ def test_dinov3_public_pooled_recipe_reaches_encoding(
     torch.testing.assert_close(observed[1], observed[0])  # batched == itemwise
 
 
-# bioptimus/H-optimus-0 mean/std, which slideflow-labs/Mettle's preprocessor_config.json repeats.
+# bioptimus/H-optimus-0 mean/std, which the preprocessor_config.json of slideflow-labs/Mettle
+# and slideflow-labs/mettle-1.5 repeats.
 HOPTIMUS_RED = [1.381786, -2.514934, -3.96366]
 HOPTIMUS_BLACK = [-3.3378, -2.514934, -3.96366]
+METTLE_PRESETS = ["mettle", "mettle-1.5"]
 
 
+@pytest.mark.parametrize("name", METTLE_PRESETS)
 @pytest.mark.parametrize("regime", ["pooled", "dense"])
-def test_mettle_declared_normalization_uses_hoptimus_photometrics_not_imagenet(regime):
+def test_mettle_declared_normalization_uses_hoptimus_photometrics_not_imagenet(regime, name):
     """Mettle's generic timm arch carries an ImageNet pretrained_cfg; its card uses H-optimus mean/std."""
     from slide2vec.runtime.encoder_input_contract import EncoderInputContract
 
     if regime == "pooled":
         contract = EncoderInputContract.declared_pooled(
-            "mettle", requested_tile_size_px=224, allow_non_recommended_settings=False,
+            name, requested_tile_size_px=224, allow_non_recommended_settings=False,
         )
     else:
-        contract = EncoderInputContract.declared_dense("mettle", target_size_px=224, window_size=None)
-    output = contract.get_transform(recipe_encoder("mettle"))(bordered_image(224))
+        contract = EncoderInputContract.declared_dense(name, target_size_px=224, window_size=None)
+    output = contract.get_transform(recipe_encoder(name))(bordered_image(224))
 
     assert_border_intact(output, size=224, red=HOPTIMUS_RED, black=HOPTIMUS_BLACK)
 
 
-def test_mettle_given_recipe_is_a_bicubic_224_resize_without_enlargement():
+@pytest.mark.parametrize("name", METTLE_PRESETS)
+def test_mettle_given_recipe_is_a_bicubic_224_resize_without_enlargement(name):
     from torchvision.transforms import v2
     from slide2vec.runtime.encoder_input_contract import EncoderInputContract
 
-    transform = EncoderInputContract.given().get_transform(recipe_encoder("mettle"))
+    transform = EncoderInputContract.given().get_transform(recipe_encoder(name))
 
     assert_border_intact(transform(bordered_image(224)), size=224, red=HOPTIMUS_RED, black=HOPTIMUS_BLACK)
     downsized = transform(Image.new("RGB", (448, 448), (255, 0, 0)))
@@ -386,3 +390,23 @@ def test_mettle_given_recipe_is_a_bicubic_224_resize_without_enlargement():
     torch.testing.assert_close(downsized[:, 112, 112], torch.tensor(HOPTIMUS_RED))
     resize = next(step for step in transform.transforms if isinstance(step, v2.Resize))
     assert resize.interpolation == v2.InterpolationMode.BICUBIC
+
+
+HOPTIMUS_BLUE = [-3.3378, -2.514934, 1.669603]
+
+
+def test_mettle_1_5_given_recipe_resizes_rectangular_images_directly_without_a_crop():
+    """slideflow-labs/mettle-1.5's ViTImageProcessor resizes to 224x224 with do_center_crop false."""
+    from slide2vec.runtime.encoder_input_contract import EncoderInputContract
+
+    transform = EncoderInputContract.given().get_transform(recipe_encoder("mettle-1.5"))
+    image = Image.new("RGB", (448, 224), (0, 0, 0))
+    image.paste((255, 0, 0), (0, 0, 112, 224))
+    image.paste((0, 0, 255), (336, 0, 448, 224))
+    output = transform(image)
+
+    assert tuple(output.shape) == (3, 224, 224)
+    # A shortest-side resize plus a center crop would drop both edge quarters.
+    torch.testing.assert_close(output[:, 112, 28], torch.tensor(HOPTIMUS_RED))
+    torch.testing.assert_close(output[:, 112, 112], torch.tensor(HOPTIMUS_BLACK))
+    torch.testing.assert_close(output[:, 112, 196], torch.tensor(HOPTIMUS_BLUE))

{slide2vec-7.1.4 → slide2vec-7.1.5}/tests/test_mettle.py

@@ -1,10 +1,12 @@
-"""Tests for the Mettle tile encoder.
+"""Tests for the Mettle tile encoders (``mettle`` and ``mettle-1.5``).
 
 Mettle (``slideflow-labs/Mettle``) is H-optimus-0's ViT-g/14 reg4 backbone,
-fine-tuned, plus a small ``MettleRefineHead`` applied to the CLS token. It ships
-as a ``trust_remote_code`` HF repo; slide2vec rebuilds it from timm + a vendored
-head, so these tests pin the contracts that break silently (no exception, just
-different features):
+fine-tuned, plus a small ``MettleRefineHead`` applied to the CLS token.
+Mettle-1.5 (``slideflow-labs/mettle-1.5``) differs in its weights, its default
+output (``cls``) and its given recipe (a direct 224x224 resize). Both ship as
+``trust_remote_code`` HF repos; slide2vec rebuilds them from timm + a vendored
+head, so these tests pin, for both presets, the contracts that break silently
+(no exception, just different features):
 
 * ``cls`` is the *headed* CLS token; ``cls_patch_mean`` appends the *unheaded*
   mean of the spatial patch tokens, with CLS and the 4 register tokens excluded;
@@ -25,11 +27,37 @@ import torch
 
 _IMAGE = 28  # -> 2x2 patch grid, 1 CLS + 4 registers + 4 patches
 _DIM = 384
+_PRESETS = ["mettle", "mettle-1.5"]
 
 
-def _tiny_encoder(*, output_variant: str = "cls_patch_mean"):
-    """A tiny random reg4 ViT + refine head wired into Mettle (no download)."""
-    from slide2vec.encoders.models.mettle import Mettle, MettleRefineHead
+@pytest.mark.parametrize("name, source, default_output_variant", [
+    ("mettle", "slideflow-labs/Mettle", "cls_patch_mean"),
+    ("mettle-1.5", "slideflow-labs/mettle-1.5", "cls"),
+])
+def test_registry_declares_the_mettle_presets(name, source, default_output_variant):
+    from slide2vec.encoders import encoder_registry
+
+    info = encoder_registry.info(name)
+
+    assert info["default_output_variant"] == default_output_variant
+    assert info["output_variants"] == {
+        "cls": {"encode_dim": 1536},
+        "cls_patch_mean": {"encode_dim": 3072},
+    }
+    assert info["source"] == source
+    assert info["level"] == "tile"
+    assert info["input_size"] == 224
+    assert info["patch_size"] == 14
+    assert info["supports_variable_input_size"] is True
+    assert info["variable_input_model_kwargs"] == {"dynamic_img_size": True}
+    assert info["supported_spacing_um"] == 0.5
+    assert info["precision"] == "fp16"
+
+
+def _tiny_encoder(name: str, *, output_variant: str = "cls_patch_mean"):
+    """A tiny random reg4 ViT + refine head wired into preset *name* (no download)."""
+    from slide2vec.encoders import encoder_registry
+    from slide2vec.encoders.models.mettle import MettleRefineHead
 
     torch.manual_seed(0)
     backbone = timm.create_model(
@@ -44,7 +72,8 @@ def _tiny_encoder(*, output_variant: str = "cls_patch_mean"):
         head.P.normal_()
         head.Q.normal_()
 
-    encoder = Mettle.__new__(Mettle)
+    encoder_cls = encoder_registry.require(name)
+    encoder = encoder_cls.__new__(encoder_cls)
     encoder._model = backbone
     encoder._head = head
     encoder._device = torch.device("cpu")
@@ -52,8 +81,9 @@ def _tiny_encoder(*, output_variant: str = "cls_patch_mean"):
     return encoder
 
 
-def test_cls_patch_mean_is_headed_cls_then_unheaded_spatial_patch_mean():
-    encoder = _tiny_encoder()
+@pytest.mark.parametrize("name", _PRESETS)
+def test_cls_patch_mean_is_headed_cls_then_unheaded_spatial_patch_mean(name):
+    encoder = _tiny_encoder(name)
     batch = torch.randn(2, 3, _IMAGE, _IMAGE)
     with torch.inference_mode():
         tokens = encoder._model.forward_features(batch)
@@ -67,24 +97,26 @@ def test_cls_patch_mean_is_headed_cls_then_unheaded_spatial_patch_mean():
     assert not torch.allclose(pooled[:, :_DIM], tokens[:, 0], atol=1e-3)
 
 
-def test_cls_variant_is_the_headed_cls_prefix_of_cls_patch_mean():
+@pytest.mark.parametrize("name", _PRESETS)
+def test_cls_variant_is_the_headed_cls_prefix_of_cls_patch_mean(name):
     batch = torch.randn(2, 3, _IMAGE, _IMAGE)
     with torch.inference_mode():
-        cls = _tiny_encoder(output_variant="cls").encode_tiles(batch)
-        cls_patch_mean = _tiny_encoder(output_variant="cls_patch_mean").encode_tiles(batch)
+        cls = _tiny_encoder(name, output_variant="cls").encode_tiles(batch)
+        cls_patch_mean = _tiny_encoder(name, output_variant="cls_patch_mean").encode_tiles(batch)
 
     assert cls.shape == (2, _DIM)
     torch.testing.assert_close(cls, cls_patch_mean[:, :_DIM], rtol=0, atol=0)
 
 
+@pytest.mark.parametrize("name", _PRESETS)
 @pytest.mark.parametrize("output_variant", ["cls", "cls_patch_mean"])
-def test_head_and_patch_mean_run_in_fp32_outside_autocast(output_variant):
+def test_head_and_patch_mean_run_in_fp32_outside_autocast(output_variant, name):
     """Under low-precision autocast only the backbone is cast; features come back fp32.
 
     The expected value applies the head in plain fp32 to the autocast backbone's
     CLS token; a head run under autocast would drift by the bf16 rounding error.
     """
-    encoder = _tiny_encoder(output_variant=output_variant)
+    encoder = _tiny_encoder(name, output_variant=output_variant)
     batch = torch.randn(2, 3, _IMAGE, _IMAGE)
     with torch.inference_mode():
         with torch.autocast(device_type="cpu", dtype=torch.bfloat16):
@@ -100,47 +132,70 @@ def test_head_and_patch_mean_run_in_fp32_outside_autocast(output_variant):
 
 # --- Heavy: real weights -----------------------------------------------------
 
+# Hub repo and revision per preset (``None``: the repo's default branch).
+_HUB = {
+    "mettle": ("slideflow-labs/Mettle", None),
+    "mettle-1.5": ("slideflow-labs/mettle-1.5", "0ab55fcbf1b8d4e3c73885fc56f822fb568ff570"),
+}
+_DEFAULT_DIMS = {"mettle": 3072, "mettle-1.5": 1536}
+
 
-def _require_hub_files(*filenames: str) -> None:
+def _require_hub_files(repo_id: str, revision: str | None, *filenames: str) -> None:
     """Skip when the weights / network are unavailable; fetches into the HF cache."""
     from huggingface_hub import hf_hub_download
 
     for filename in filenames:
         try:
-            hf_hub_download(repo_id="slideflow-labs/Mettle", filename=filename)
+            hf_hub_download(repo_id=repo_id, filename=filename, revision=revision)
         except Exception as exc:  # network / weights unavailable
-            pytest.skip(f"mettle {filename} unavailable: {type(exc).__name__}: {exc}")
+            pytest.skip(f"{repo_id} {filename} unavailable: {type(exc).__name__}: {exc}")
+
+
+@pytest.fixture(scope="module", params=_PRESETS)
+def preset(request) -> str:
+    """The preset under test.
+
+    The real-weight fixtures below depend on it, so pytest tears down one preset's
+    models before it builds the next: two presets' ViT-g weights are never loaded
+    at the same time.
+    """
+    return request.param
 
 
 @pytest.fixture(scope="module")
-def mettle_encoders():
+def mettle_encoders(preset):
     """Load the real encoder once per output variant (on CPU).
 
-    Only the download may skip: a strict-load mismatch in the constructor must fail.
+    ``load()`` builds the registry default. Only the download may skip: a
+    strict-load mismatch in the constructor must fail.
     """
     from slide2vec.encoders import encoder_registry
 
-    _require_hub_files("model.safetensors")
+    _require_hub_files(*_HUB[preset], "model.safetensors")
+    default = encoder_registry.info(preset)["default_output_variant"]
     loaded = {}
 
-    def load(output_variant: str = "cls_patch_mean"):
-        if output_variant not in loaded:
-            encoder = encoder_registry.require("mettle")(output_variant=output_variant)
-            loaded[output_variant] = encoder.to("cpu")
-        return loaded[output_variant]
+    def load(output_variant: str | None = None):
+        key = output_variant or default
+        if key not in loaded:
+            encoder = encoder_registry.require(preset)(output_variant=output_variant)
+            loaded[key] = encoder.to("cpu")
+        return loaded[key]
 
     return load
 
 
 @pytest.fixture(scope="module")
-def upstream_mettle():
+def upstream_mettle(preset):
     """Upstream ``AutoModel(trust_remote_code=True)`` reference, fp32 on CPU."""
     transformers = pytest.importorskip("transformers")
+    repo_id, revision = _HUB[preset]
     _require_hub_files(
+        repo_id, revision,
         "config.json", "configuration_mettle.py", "modeling_mettle.py", "model.safetensors",
     )
     model = transformers.AutoModel.from_pretrained(
-        "slideflow-labs/Mettle", trust_remote_code=True,
+        repo_id, revision=revision, trust_remote_code=True,
     )
     return model.to("cpu").eval()
 
@@ -151,19 +206,22 @@ def _tile_batch() -> torch.Tensor:
 
 
 @pytest.mark.heavy
-def test_mettle_loads_strict_and_emits_registered_shapes(mettle_encoders):
-    mettle_encoder = mettle_encoders()  # default variant: cls_patch_mean
+def test_mettle_loads_strict_and_emits_registered_shapes(preset, mettle_encoders):
+    default_encoder = mettle_encoders()
     cls_encoder = mettle_encoders("cls")
+    cls_patch_mean_encoder = mettle_encoders("cls_patch_mean")
     batch = _tile_batch()
     with torch.inference_mode():
-        cls_patch_mean = mettle_encoder.encode_tiles(batch)
+        default = default_encoder.encode_tiles(batch)
         cls = cls_encoder.encode_tiles(batch)
-        dense = mettle_encoder.encode_tiles_dense(batch)
-
-    assert mettle_encoder.encode_dim == 3072 and cls_encoder.encode_dim == 1536
-    assert mettle_encoder.patch_size == (14, 14)
-    assert cls_patch_mean.shape == (1, 3072)
-    assert cls.shape == (1, 1536)
+        cls_patch_mean = cls_patch_mean_encoder.encode_tiles(batch)
+        dense = default_encoder.encode_tiles_dense(batch)
+
+    assert default_encoder.encode_dim == _DEFAULT_DIMS[preset]
+    assert default.shape == (1, _DEFAULT_DIMS[preset])
+    assert cls_encoder.encode_dim == 1536 and cls.shape == (1, 1536)
+    assert cls_patch_mean_encoder.encode_dim == 3072 and cls_patch_mean.shape == (1, 3072)
+    assert default_encoder.patch_size == (14, 14)
     # patch 14: 224 / 14 = 16 -> a 16x16 grid of unheaded 1536-d patch tokens.
     assert dense.shape == (1, 1536, 16, 16)
 
@@ -184,13 +242,13 @@ def test_mettle_fp32_matches_upstream_remote_code(
 
 
 @pytest.mark.heavy
-def test_mettle_fp16_default_preserves_fp32_direction_on_cuda(mettle_encoders):
+def test_mettle_fp16_default_preserves_fp32_direction_on_cuda(preset, mettle_encoders):
     if not torch.cuda.is_available():
         pytest.skip("CUDA unavailable")
     from slide2vec.encoders import encoder_registry
     from slide2vec.runtime.batching import autocast_dtype
 
-    precision = encoder_registry.info("mettle")["precision"]
+    precision = encoder_registry.info(preset)["precision"]
     assert precision == "fp16"
     mettle_encoder = mettle_encoders()
     batch = _tile_batch()

{slide2vec-7.1.4 → slide2vec-7.1.5}/tests/test_patch_size_metadata.py

@@ -36,6 +36,7 @@ DENSE_PATCH_SIZES: dict[str, tuple[int, int]] = {
     "h0-mini": (14, 14),
     "lunit": (8, 8),
     "mettle": (14, 14),
+    "mettle-1.5": (14, 14),
     "prost40m": (14, 14),
     "conch": (16, 16),
     "conchv15": (16, 16),

{slide2vec-7.1.4 → slide2vec-7.1.5}/tests/test_regression_core.py

@@ -216,6 +216,7 @@ def test_get_cfg_from_args_fills_null_spacing_from_model_default(tmp_path: Path)
         ("virchow2", 224, "fp16"),
         ("midnight", 224, "fp16"),
         ("mettle", 224, "fp16"),
+        ("mettle-1.5", 224, "fp16"),
         ("musk", 384, "fp16"),
     ],
 )

{slide2vec-7.1.4 → slide2vec-7.1.5}/tests/test_regression_models.py

@@ -260,6 +260,7 @@ def test_model_embed_slide_infers_preprocessing_from_single_spacing_model(monkey
         ("virchow2", 224, "fp16"),
         ("midnight", 224, "fp16"),
         ("mettle", 224, "fp16"),
+        ("mettle-1.5", 224, "fp16"),
         ("musk", 384, "fp16"),
     ],
 )