slide2vec 5.2.0__tar.gz → 5.3.0__tar.gz

{slide2vec-5.2.0 → slide2vec-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 5.2.0
+Version: 5.3.0
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0
@@ -225,7 +225,7 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 17 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships preset configs for 22 tile-level models and 3 slide-level models.  
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI

{slide2vec-5.2.0 → slide2vec-5.3.0}/README.md

@@ -119,7 +119,7 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 17 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships preset configs for 22 tile-level models and 3 slide-level models.  
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI

{slide2vec-5.2.0 → slide2vec-5.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "5.2.0"
+version = "5.3.0"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -167,7 +167,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "5.2.0"
+current_version = "5.3.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false       # We do version bumping in CI, not as a commit
 tag = false          # Git tag already exists — we don't auto-tag

{slide2vec-5.2.0 → slide2vec-5.3.0}/slide2vec/__init__.py

@@ -11,7 +11,7 @@ from slide2vec.api import (
 from slide2vec.artifacts import HierarchicalEmbeddingArtifact, SlideEmbeddingArtifact, TileEmbeddingArtifact
 
 
-__version__ = "5.2.0"
+__version__ = "5.3.0"
 
 __all__ = [
     "Model",

{slide2vec-5.2.0 → slide2vec-5.3.0}/slide2vec/encoders/models/__init__.py

@@ -5,12 +5,16 @@ Importing this package registers all encoders in the encoder_registry.
 
 from . import (
     conch,
+    dinov2,
+    genbio,
     gigapath,
+    gpfm,
     hibou,
     hoptimus,
     lunit,
     midnight,
     moozy,
+    mstar,
     musk,
     phikon,
     prost40m,
@@ -22,12 +26,16 @@ from . import (
 
 __all__ = [
     "conch",
+    "dinov2",
+    "genbio",
     "gigapath",
+    "gpfm",
     "hibou",
     "hoptimus",
     "lunit",
     "midnight",
     "moozy",
+    "mstar",
     "musk",
     "phikon",
     "prost40m",

slide2vec-5.3.0/slide2vec/encoders/models/dinov2.py

@@ -0,0 +1,56 @@
+"""Natural-image DINOv2 ViT-B/14 control encoder.
+
+``dinov2-vitb14`` is a **non-pathology** ViT: the original DINOv2 ViT-B/14
+(Oquab et al., 2024) self-supervised on LVD-142M *natural* images, shipped by
+``timm`` as ``vit_base_patch14_dinov2.lvd142m`` (weights hosted on Hugging Face
+under ``timm/vit_base_patch14_dinov2.lvd142m`` — public, no gated access).
+
+It exists as a **control**: nearly every pathology tile encoder here (UNI,
+Virchow, GigaPath, H-optimus, Midnight, …) is a DINOv2-family ViT, so pairing
+them with a DINOv2 ViT trained on natural images holds the architecture and the
+self-supervised objective fixed and varies only the *pretraining domain*. That
+isolates the question "does pathology-pretraining actually pay off?" for a
+downstream task (e.g. cell detection).
+
+Structurally it is a plain :class:`TimmTileEncoder` (mirroring ``lunit`` /
+``prost40m`` / ``uni``): the dense (``encode_tiles_dense``) and attention
+(``encode_tiles_attention``) paths are inherited unchanged from the timm ViT
+base, so the control is dense-extraction- and attention-capable exactly like the
+pathology encoders. ``dynamic_img_size=True`` lets the (natively 518px) backbone
+run at the 224px detection tile geometry via positional-embedding interpolation,
+a no-op at the native size (verified in the shared dense-extraction suite).
+
+Spacing note: a natural-image model has **no** intrinsic micron-per-pixel
+spacing, so it declares ``supported_spacing_um=None`` — it is *spacing-agnostic*
+and :func:`validate_encoder_config` never rejects a requested spacing for it
+(unlike the pathology encoders, which are validated at a specific spacing). It
+still needs *a* spacing to tile a slide, so ``default_spacing_um=0.5`` sets the
+tiling default: 0.5 µm/px is the task-spacing the pathology tile encoders
+declare, so selecting this encoder by name lands on identical tile geometry and
+it drops in as a matched control. Because it is agnostic, sweeping other
+task-spacings (e.g. 0.25) needs no ``allow_non_recommended_settings`` escape
+hatch — any requested spacing is accepted as-is.
+"""
+
+from slide2vec.encoders.base import TimmTileEncoder
+from slide2vec.encoders.registry import register_encoder
+
+
+@register_encoder(
+    "dinov2-vitb14",
+    output_variants={"default": {"encode_dim": 768}},
+    default_output_variant="default",
+    input_size=224,
+    patch_size=14,
+    supported_spacing_um=None,  # spacing-agnostic: no intrinsic µm/px, so no validation constraint
+    default_spacing_um=0.5,  # tiling default: match the pathology encoders' task-spacing
+    precision="fp16",
+    source="timm/vit_base_patch14_dinov2.lvd142m",
+)
+class DINOv2ViTB14(TimmTileEncoder):
+    def __init__(self, *, output_variant: str | None = None):
+        super().__init__(
+            "vit_base_patch14_dinov2.lvd142m",
+            output_variant=output_variant,
+            dynamic_img_size=True,  # enable dense extraction; no-op at native size
+        )

slide2vec-5.3.0/slide2vec/encoders/models/genbio.py

@@ -0,0 +1,155 @@
+"""GenBio-PathFM tile encoder.
+
+GenBio-PathFM (GenBio AI, 2024; ``genbio-ai/genbio-pathfm``) is a 1.1B-param ViT
+histopathology tile encoder (JEDI = JEPA + DINO training on public data). It is
+loaded via HF ``AutoModel(trust_remote_code=True)`` (auto_map ->
+``GenBioPathFMModel``), so it is a custom :class:`TileEncoder`, not a
+``TimmTileEncoder``. Weights are openly downloadable (safetensors); released
+under the custom **GenBio AI Community License** (not OSI-approved — read it for
+acceptable-use / commercial restrictions; slide2vec only wraps user-downloaded
+weights and does not redistribute them).
+
+Output dim (4608, verified on real weights): the backbone is a *single-channel*
+ViT (``in_chans=1``, ``embed_dim=1536``). The model's canonical ``forward`` takes
+an RGB ``[B, 3, H, W]`` tensor, treats each colour channel as a separate
+single-channel image, encodes all three, and concatenates the three per-channel
+CLS tokens -> ``[B, embed_dim * 3] = [B, 4608]``. This per-channel-CLS
+concatenation is the model's intrinsic design (matching the HF card's advertised
+feature dimension of 4608), not an ad-hoc CLS+patch pooling; ``encode_tiles``
+therefore returns the model's default ``forward`` output directly. (Confirmed by
+running a ``(1, 3, 224, 224)`` dummy through the real weights -> shape
+``(1, 4608)``; see ``tests/test_gpfm_genbio_heavy.py``.)
+
+Normalization is **non-ImageNet** (``config.json`` ``image_mean`` / ``image_std``)
+and must be set explicitly.
+
+Dense (spatial-grid) extraction is supported via the model's
+``forward_with_patches`` (a DINOv2-style ``x_norm_patchtokens`` path): it returns
+the fused per-channel patch tokens ``(B, T, 4608)`` — the three single-channel
+patch-token grids concatenated along the feature dim, with the prefix tokens
+(CLS + storage tokens) already stripped — which fold straight into a
+``(B, 4608, h, w)`` grid. The patch size is 16 (a 224 tile -> a 14x14 = 196 grid).
+
+Attention-map extraction is **not** supported. The backbone computes attention
+with a fused ``F.scaled_dot_product_attention`` (no materialized weights, no
+``output_attentions``), and — more fundamentally — it encodes the three colour
+channels as three independent single-channel images, so there is no single
+coherent CLS-over-patches attention to extract: any "attention grid" would be
+three separate grayscale-channel attentions. Recovering it would need a bespoke
+per-channel recompute path that diverges from the shared timm/HF attention
+helpers, so GenBio deliberately opts out of ``encode_tiles_attention``.
+"""
+
+from typing import Callable
+
+import torch
+from torch import Tensor
+from torchvision.transforms import v2
+
+from slide2vec.encoders.base import (
+    TileEncoder,
+    preferred_default_device,
+    reshape_tokens_to_grid,
+    resolve_requested_output_variant,
+)
+from slide2vec.encoders.registry import register_encoder
+
+_HF_REPO_ID = "genbio-ai/genbio-pathfm"
+# Non-ImageNet normalization from the model's config.json (image_mean / image_std).
+_GENBIO_MEAN = (0.697, 0.575, 0.728)
+_GENBIO_STD = (0.188, 0.240, 0.187)
+
+
+@register_encoder(
+    "genbio-pathfm",
+    # encode_dim 4608 = embed_dim (1536) x 3 colour channels; patch_size 16 (a 224
+    # tile -> a 14x14 = 196 patch-token grid) — see module docstring.
+    output_variants={"default": {"encode_dim": 4608}},
+    default_output_variant="default",
+    input_size=224,
+    patch_size=16,
+    supported_spacing_um=0.5,  # 20x; card states no magnification, house default
+    precision="fp32",  # upstream runs plain fp32, no autocast
+    source="genbio-ai/genbio-pathfm",
+)
+class GenBioPathFM(TileEncoder):
+    def __init__(self, *, output_variant: str | None = None):
+        from transformers import AutoModel
+
+        self._model = AutoModel.from_pretrained(_HF_REPO_ID, trust_remote_code=True).eval()
+        self._device = preferred_default_device()
+        self._output_variant = resolve_requested_output_variant(output_variant)
+
+    def get_transform(self) -> Callable:
+        # Mirrors the model card: Resize to an exact 224x224 (tuple form, as the
+        # card's ``Resize((224, 224))``) + custom Normalize. No CenterCrop: the card
+        # has none, and after a square resize it would be a no-op anyway.
+        return v2.Compose([
+            v2.ToImage(),
+            v2.Resize((224, 224), interpolation=v2.InterpolationMode.BICUBIC, antialias=True),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=_GENBIO_MEAN, std=_GENBIO_STD),
+        ])
+
+    def get_dense_transform(self) -> Callable:
+        # Normalization only — no Resize/CenterCrop (see TileEncoder.get_dense_transform),
+        # so the dense grid stays registered to the full source tile.
+        return v2.Compose([
+            v2.ToImage(),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=_GENBIO_MEAN, std=_GENBIO_STD),
+        ])
+
+    def encode_tiles(self, batch: Tensor) -> Tensor:
+        # Canonical forward: per-channel CLS tokens concatenated -> (B, 4608).
+        return self._model(batch)
+
+    @property
+    def patch_size(self) -> tuple[int, int]:
+        return (16, 16)
+
+    def encode_tiles_dense(self, batch: Tensor) -> Tensor:
+        """Encode tiles into a dense spatial grid. (B, C, H, W) -> (B, d, h, w).
+
+        Uses the model's ``forward_with_patches`` (DINOv2-style), which returns the
+        fused per-channel patch tokens ``(B, T, 4608)`` — the three single-channel
+        patch-token grids concatenated along the feature dim, with the prefix
+        tokens (CLS + storage tokens) already stripped — then folds that token
+        sequence back into its spatial grid (``num_prefix_tokens=0``). ``H, W`` must
+        be divisible by the patch size; non-224 inputs rely on the backbone's
+        DINOv2 positional-embedding interpolation.
+        """
+        if batch.ndim != 4:
+            raise ValueError(
+                "encode_tiles_dense expects a (B, C, H, W) batch, got shape "
+                f"{tuple(batch.shape)}."
+            )
+        _, _, height, width = batch.shape
+        patch_h, patch_w = self.patch_size
+        if height % patch_h != 0 or width % patch_w != 0:
+            raise ValueError(
+                f"Dense extraction for '{type(self).__name__}' requires input "
+                f"divisible by the patch size: got {height}x{width}, patch "
+                f"{patch_h}x{patch_w}. Pad the tile up to a patch multiple first."
+            )
+        _, patch_tokens = self._model.forward_with_patches(batch)
+        return reshape_tokens_to_grid(
+            patch_tokens,
+            grid_h=height // patch_h,
+            grid_w=width // patch_w,
+            num_prefix_tokens=0,
+            encoder_name=type(self).__name__,
+        )
+
+    @property
+    def encode_dim(self) -> int:
+        return 4608
+
+    @property
+    def device(self) -> torch.device:
+        return self._device
+
+    def to(self, device: torch.device | str) -> "GenBioPathFM":
+        self._device = torch.device(device)
+        self._model = self._model.to(self._device)
+        return self

slide2vec-5.3.0/slide2vec/encoders/models/gpfm.py

@@ -0,0 +1,89 @@
+"""GPFM tile encoder (Generalizable Pathology Foundation Model).
+
+GPFM (Ma et al., 2024; ``birkhoffkiki/GPFM``) is a ``ViT-L/14`` DINOv2 tile
+encoder (embedding dim 1024, patch_size 14). Weights are openly available under
+the MIT license at ``majiabo/GPFM`` but ship as a standalone ``GPFM.pth``
+checkpoint, so — unlike ``hf-hub:`` timm presets — we build the timm arch
+unpretrained and ``load_state_dict`` the downloaded checkpoint (the MOOZY
+loading pattern).
+
+The published ``GPFM.pth`` is a bare DINOv2 ``state_dict`` (``cls_token``,
+``pos_embed``, ``blocks.*``, …) that loads into
+``vit_large_patch14_dinov2.lvd142m`` with ``strict=True`` and zero missing /
+unexpected keys (verified on the real weights; see
+``tests/test_gpfm_genbio_heavy.py``). The loader below still defensively unwraps
+common checkpoint wrappers (``{"model": ...}`` / ``{"teacher": ...}`` /
+``{"student": ...}`` / ``{"state_dict": ...}``) and strips ``module.`` /
+``backbone.`` prefixes so a re-exported checkpoint keeps loading strictly.
+"""
+
+from typing import Mapping
+
+import torch
+from huggingface_hub import hf_hub_download
+
+from slide2vec.encoders.base import TimmTileEncoder
+from slide2vec.encoders.registry import register_encoder
+
+_HF_REPO_ID = "majiabo/GPFM"
+_HF_CHECKPOINT = "GPFM.pth"
+_CHECKPOINT_WRAPPER_KEYS = ("model", "teacher", "student", "state_dict", "teacher_backbone")
+_STATE_DICT_PREFIXES = ("module.", "backbone.")
+
+
+def _unwrap_gpfm_state_dict(payload: Mapping[str, object]) -> dict[str, torch.Tensor]:
+    """Reduce a GPFM checkpoint payload to a bare ``state_dict``.
+
+    Unwraps a single common wrapper key if present, then strips ``module.`` /
+    ``backbone.`` prefixes off every key. A no-op on the published bare
+    ``GPFM.pth`` (no wrapper, no prefixes), so it preserves strict loading there
+    while tolerating a re-wrapped/prefixed re-export.
+    """
+    state: object = payload
+    for wrapper in _CHECKPOINT_WRAPPER_KEYS:
+        if isinstance(state, Mapping) and wrapper in state and isinstance(state[wrapper], Mapping):
+            state = state[wrapper]
+            break
+    if not isinstance(state, Mapping):
+        raise ValueError(
+            f"Unexpected GPFM checkpoint payload: expected a state_dict mapping, got {type(state)}"
+        )
+    cleaned: dict[str, torch.Tensor] = {}
+    for key, value in state.items():
+        name = key
+        for prefix in _STATE_DICT_PREFIXES:
+            if name.startswith(prefix):
+                name = name[len(prefix):]
+        cleaned[name] = value
+    return cleaned
+
+
+@register_encoder(
+    "gpfm",
+    output_variants={"default": {"encode_dim": 1024}},
+    default_output_variant="default",
+    input_size=224,
+    patch_size=14,
+    supported_spacing_um=0.5,  # 512px@0.25um (128um FOV) resized to 224 => ~0.5um/px effective (20x), as for UNI
+    precision="fp32",  # upstream runs plain fp32, no autocast
+    source="majiabo/GPFM",
+)
+class GPFM(TimmTileEncoder):
+    def __init__(self, *, output_variant: str | None = None):
+        super().__init__(
+            "vit_large_patch14_dinov2.lvd142m",
+            output_variant=output_variant,
+            pretrained=False,
+            img_size=224,
+            init_values=1e-5,
+            dynamic_img_size=True,
+        )
+        checkpoint_path = hf_hub_download(repo_id=_HF_REPO_ID, filename=_HF_CHECKPOINT)
+        payload = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+        if not isinstance(payload, Mapping):
+            raise ValueError(
+                f"Invalid GPFM checkpoint payload: expected a dict, got {type(payload)}"
+            )
+        state_dict = _unwrap_gpfm_state_dict(payload)
+        self._model.load_state_dict(state_dict, strict=True)
+        self._model.eval()

slide2vec-5.3.0/slide2vec/encoders/models/mstar.py

@@ -0,0 +1,34 @@
+"""mSTAR tile encoder implementation.
+
+mSTAR (Wang et al., 2024; ``Innse/mSTAR``) is released as a ``ViT-L/16`` patch
+encoder, not a slide aggregator: the published checkpoint is a per-tile feature
+extractor and slide2vec handles WSI -> coordinates -> per-tile features itself.
+We therefore register it as a **tile** encoder.
+
+The weights live in the **gated** Hugging Face repo `Wangyh/mSTAR`
+(``hf-hub:Wangyh/mSTAR``). Loading them requires access approval on Hugging Face
+and an ``HF_TOKEN`` in the environment.
+"""
+
+from slide2vec.encoders.base import TimmTileEncoder
+from slide2vec.encoders.registry import register_encoder
+
+
+@register_encoder(
+    "mstar",
+    output_variants={"default": {"encode_dim": 1024}},
+    default_output_variant="default",
+    input_size=224,
+    patch_size=16,
+    supported_spacing_um=0.5,  # 256px @ 20x, resized to 224 (per paper)
+    precision="fp32",  # upstream runs plain fp32, no autocast
+    source="Wangyh/mSTAR",
+)
+class mSTAR(TimmTileEncoder):
+    def __init__(self, *, output_variant: str | None = None):
+        super().__init__(
+            "hf-hub:Wangyh/mSTAR",
+            output_variant=output_variant,
+            init_values=1e-5,
+            dynamic_img_size=True,
+        )

{slide2vec-5.2.0 → slide2vec-5.3.0}/slide2vec/encoders/registry.py

@@ -41,7 +41,8 @@ def register_encoder(
     level: str = "tile",
     tile_encoder: str | None = None,
     tile_encoder_output_variant: str | None = None,
-    supported_spacing_um: float | list[float],
+    supported_spacing_um: float | list[float] | None,
+    default_spacing_um: float | None = None,
     precision: str = "fp16",
     source: str = "",
 ):
@@ -61,7 +62,22 @@ def register_encoder(
         level: Encoder output level ("tile" or "slide").
         tile_encoder: Registered tile encoder dependency for slide-level models.
         tile_encoder_output_variant: Fixed tile-encoder output variant for slide models.
-        supported_spacing_um: Supported spacing(s) in µm/px.
+        supported_spacing_um: The spacing(s) in µm/px the model was trained/validated
+            for; :func:`validate_encoder_config` rejects requests outside this set
+            unless ``allow_non_recommended_settings=True``. ``None`` marks a
+            *spacing-agnostic* encoder (e.g. a natural-image control): the spacing
+            check is skipped entirely because no spacing is more "correct" than
+            another. Agnostic encoders MUST pair this with an explicit
+            ``default_spacing_um`` so name-only selection still resolves a tiling
+            spacing.
+        default_spacing_um: The single spacing in µm/px used to tile a slide when the
+            caller selects this encoder by name without passing an explicit
+            ``requested_spacing_um``. Optional: when omitted it is derived from
+            ``supported_spacing_um`` if that is a single value. Encoders that
+            support a *list* of spacings, or are spacing-agnostic
+            (``supported_spacing_um=None``), have no derivable default and must
+            declare one here to be selectable with zero config (otherwise
+            :func:`resolve_preprocessing_defaults` requires an explicit spacing).
         precision: Recommended inference precision ("fp16" or "fp32").
         source: Model source identifier (e.g. HuggingFace hub path).
     """
@@ -78,6 +94,7 @@ def register_encoder(
         "tile_encoder": tile_encoder,
         "tile_encoder_output_variant": tile_encoder_output_variant,
         "supported_spacing_um": supported_spacing_um,
+        "default_spacing_um": default_spacing_um,
         "precision": precision,
         "source": source,
     }
@@ -133,14 +150,13 @@ def resolve_preprocessing_requirements(
 
     if level == "tile":
         input_size = require_encoder_metadata_field(encoder_name, info, "input_size")
-        spacing_um = require_encoder_metadata_field(
-            encoder_name,
-            info,
-            "supported_spacing_um",
-        )
+        # supported_spacing_um is the *validated* constraint set and may be None
+        # (spacing-agnostic). Kept lazy: do NOT resolve a default here — callers
+        # that only need the constraint (e.g. tile-size validation) must not trip
+        # over a list/agnostic encoder having no single default.
         return {
             "tile_size_px": input_size,
-            "spacing_um": spacing_um,
+            "spacing_um": info.get("supported_spacing_um"),
             "source_encoder": encoder_name,
         }
 
@@ -153,35 +169,67 @@ def resolve_preprocessing_requirements(
     raise AssertionError("unreachable")
 
 
+def _resolve_default_spacing(encoder_name: str, info: dict[str, Any]) -> float:
+    """Resolve the single spacing (µm/px) an encoder is tiled at by default.
+
+    Prefers an explicit ``default_spacing_um``. Otherwise derives it from
+    ``supported_spacing_um`` when that is a single value. Encoders that support a
+    *list* of spacings, or are spacing-agnostic (``supported_spacing_um=None``),
+    with no explicit default have no unambiguous tiling spacing and raise — the
+    caller must pass ``preprocessing.requested_spacing_um`` (or the encoder must
+    declare ``default_spacing_um``).
+    """
+    explicit = info.get("default_spacing_um")
+    if explicit is not None:
+        return float(explicit)
+
+    supported = info.get("supported_spacing_um")
+    if isinstance(supported, list):
+        unique_spacings: list[float] = []
+        for spacing in supported:
+            spacing_value = float(spacing)
+            if not any(abs(spacing_value - existing) <= 1e-8 for existing in unique_spacings):
+                unique_spacings.append(spacing_value)
+        if len(unique_spacings) == 1:
+            return unique_spacings[0]
+        supported_text = ", ".join(f"{s:g}" for s in unique_spacings)
+        raise ValueError(
+            f"Encoder '{encoder_name}' supports multiple spacings [{supported_text}]; "
+            "cannot infer a default requested_spacing_um. Declare default_spacing_um "
+            "in its registration or pass preprocessing.requested_spacing_um explicitly."
+        )
+    if isinstance(supported, (int, float)) and not isinstance(supported, bool):
+        return float(supported)
+
+    raise ValueError(
+        f"Encoder '{encoder_name}' is spacing-agnostic (supported_spacing_um=None) but "
+        "declares no default_spacing_um; declare default_spacing_um in its registration "
+        "or pass preprocessing.requested_spacing_um explicitly."
+    )
+
+
 def resolve_preprocessing_defaults(
     encoder_name: str,
     metadata: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Resolve a single unambiguous preprocessing default for an encoder.
 
-    This is stricter than :func:`resolve_preprocessing_requirements`: it only
-    succeeds when the encoder advertises exactly one supported spacing.
+    This is stricter than :func:`resolve_preprocessing_requirements`: it resolves
+    exactly one tiling spacing (see :func:`_resolve_default_spacing`) and raises
+    when the encoder advertises several supported spacings without an explicit
+    ``default_spacing_um``.
     """
     reqs = resolve_preprocessing_requirements(encoder_name, metadata)
-    spacing_um = reqs["spacing_um"]
-    if isinstance(spacing_um, list):
-        unique_spacings = []
-        for spacing in spacing_um:
-            spacing_value = float(spacing)
-            if not any(abs(spacing_value - existing) <= 1e-8 for existing in unique_spacings):
-                unique_spacings.append(spacing_value)
-        if len(unique_spacings) != 1:
-            supported_text = ", ".join(f"{s:g}" for s in unique_spacings)
-            raise ValueError(
-                f"Encoder '{encoder_name}' supports multiple spacings [{supported_text}]; "
-                "cannot infer a default requested_spacing_um. "
-                "Pass preprocessing.requested_spacing_um explicitly."
-            )
-        spacing_um = unique_spacings[0]
+    source_encoder = reqs["source_encoder"]
+    # Resolve the default off the *tile* encoder's metadata: slide/patient
+    # encoders inherit both tile size and spacing from their tile encoder, so
+    # source_encoder already points at the model that carries the spacing fields.
+    source_info = encoder_registry.info(source_encoder)
+    spacing_um = _resolve_default_spacing(source_encoder, source_info)
     return {
         "tile_size_px": int(reqs["tile_size_px"]),
         "spacing_um": float(spacing_um),
-        "source_encoder": reqs["source_encoder"],
+        "source_encoder": source_encoder,
     }
 
 

{slide2vec-5.2.0 → slide2vec-5.3.0}/slide2vec/runtime/model_settings.py

@@ -29,6 +29,10 @@ MODEL_NAME_ALIASES = {
     "prov-gigapath-tile": "gigapath",
     "prov-gigapath-slide": "gigapath-slide",
     "kaiko-midnight": "midnight",
+    "mstar-slide": "mstar",
+    "dinov2": "dinov2-vitb14",
+    "dinov2-base": "dinov2-vitb14",
+    "dinov2-vitb": "dinov2-vitb14",
 }
 
 

{slide2vec-5.2.0 → slide2vec-5.3.0}/slide2vec.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 5.2.0
+Version: 5.3.0
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0
@@ -225,7 +225,7 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 17 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships preset configs for 22 tile-level models and 3 slide-level models.  
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI

{slide2vec-5.2.0 → slide2vec-5.3.0}/slide2vec.egg-info/SOURCES.txt

@@ -31,11 +31,15 @@ slide2vec/encoders/registry.py
 slide2vec/encoders/validation.py
 slide2vec/encoders/models/__init__.py
 slide2vec/encoders/models/conch.py
+slide2vec/encoders/models/dinov2.py
+slide2vec/encoders/models/genbio.py
 slide2vec/encoders/models/gigapath.py
+slide2vec/encoders/models/gpfm.py
 slide2vec/encoders/models/hibou.py
 slide2vec/encoders/models/hoptimus.py
 slide2vec/encoders/models/lunit.py
 slide2vec/encoders/models/midnight.py
+slide2vec/encoders/models/mstar.py
 slide2vec/encoders/models/musk.py
 slide2vec/encoders/models/phikon.py
 slide2vec/encoders/models/prism.py
@@ -86,7 +90,9 @@ tests/test_attention_extraction.py
 tests/test_dense_extraction.py
 tests/test_dense_regions.py
 tests/test_dense_sliding.py
+tests/test_dinov2_natimage.py
 tests/test_encoder_registry.py
+tests/test_gpfm_genbio_heavy.py
 tests/test_hs2p_package_cutover.py
 tests/test_output_consistency.py
 tests/test_patch_size_metadata.py