slide2vec 5.8.2__tar.gz → 5.9.0__tar.gz

{slide2vec-5.8.2 → slide2vec-5.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 5.8.2
+Version: 5.9.0
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.2
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.3
 Requires-Dist: omegaconf
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2
@@ -75,7 +75,7 @@ Requires-Dist: numpy<2; extra == "fm"
 Requires-Dist: pandas; extra == "fm"
 Requires-Dist: pillow; extra == "fm"
 Requires-Dist: rich; extra == "fm"
-Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.2; extra == "fm"
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.3; extra == "fm"
 Requires-Dist: wandb; extra == "fm"
 Requires-Dist: torch<2.8,>=2.3; extra == "fm"
 Requires-Dist: torchvision>=0.18.0; extra == "fm"

{slide2vec-5.8.2 → slide2vec-5.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "5.8.2"
+version = "5.9.0"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,7 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.2",
+    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.3",
     "omegaconf",
     "matplotlib",
     "numpy<2",
@@ -100,7 +100,7 @@ fm = [
     "pandas",
     "pillow",
     "rich",
-    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.2",
+    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.3",
     "wandb",
     "torch>=2.3,<2.8",
     "torchvision>=0.18.0",
@@ -158,7 +158,7 @@ testpaths = [
     "tests",
 ]
 markers = [
-    "heavy: real-weight foundation-model inference on CPU; minutes per test. Excluded from the PR suite via `-m 'not heavy'`; run on the scheduled/manual heavy workflow (.github/workflows/nightly-heavy.yaml).",
+    "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).",
     "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`.",
 ]
 
@@ -180,14 +180,15 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "5.8.2"
+current_version = "5.9.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
-push = false         # Don't push anything in CI
+commit = false
+tag = false
+push = false
 files = [
     "pyproject.toml",
-    "slide2vec/__init__.py"
+    "slide2vec/__init__.py",
+    "docs/conf.py",
 ]
 
 [tool.bumpver.file_patterns]
@@ -198,3 +199,6 @@ files = [
 "slide2vec/__init__.py" = [
     '^__version__ = "{version}"$',
 ]
+"docs/conf.py" = [
+    '^release = "{version}"$',
+]

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/__init__.py

@@ -27,7 +27,7 @@ from slide2vec.encoders import (
 )
 
 
-__version__ = "5.8.2"
+__version__ = "5.9.0"
 
 __all__ = [
     "Model",

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/api.py

@@ -7,7 +7,7 @@ import warnings
 from dataclasses import dataclass, field, replace
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, Mapping, Protocol, Sequence
+from typing import Any, Callable, Mapping, Protocol, Sequence
 
 import torch
 from hs2p import SlideSpec
@@ -128,15 +128,12 @@ def resolve_masks(masks: Mapping[str, Any] | None) -> dict[str, Any]:
 
 def _masks_to_plain_dict(node: Any) -> dict[str, Any]:
     """Normalize a masks config node (OmegaConf, mapping, or namespace) to a plain dict."""
+    from omegaconf import OmegaConf
+
     if node is None:
         return {}
-    try:
-        from omegaconf import OmegaConf
-
-        if OmegaConf.is_config(node):
-            return copy.deepcopy(OmegaConf.to_container(node, resolve=True))  # type: ignore[return-value]
-    except ImportError:
-        pass
+    if OmegaConf.is_config(node):
+        return copy.deepcopy(OmegaConf.to_container(node, resolve=True))  # type: ignore[return-value]
     if isinstance(node, Mapping):
         return copy.deepcopy(dict(node))
     return copy.deepcopy(dict(vars(node)))
@@ -243,7 +240,6 @@ class PreprocessingConfig:
             "preview",
             _deep_merge_dicts(DEFAULT_PREPROCESSING["preview"], self.preview),
         )
-        # Complete a (possibly partial) masks mapping against the shipped default.
         object.__setattr__(self, "masks", resolve_masks(self.masks))
 
     @classmethod
@@ -710,6 +706,7 @@ class Model:
         *,
         preprocessing: PreprocessingConfig | None = None,
         execution: ExecutionOptions | None = None,
+        on_slide_persisted: Callable[[TileEmbeddingArtifact | HierarchicalEmbeddingArtifact], None] | None = None,
     ) -> list[TileEmbeddingArtifact] | list[HierarchicalEmbeddingArtifact]:
         from slide2vec.inference import embed_tiles
 
@@ -724,6 +721,7 @@ class Model:
                 tiling_results,
                 execution=resolved,
                 preprocessing=resolved_preprocessing,
+                on_slide_persisted=on_slide_persisted,
             )
 
     def aggregate_tiles(
@@ -1217,6 +1215,7 @@ class Pipeline:
         coordinates_dir: str | Path,
         *,
         slides: SlideSequence | None = None,
+        on_slide_persisted: Callable[[TileEmbeddingArtifact | HierarchicalEmbeddingArtifact], None] | None = None,
     ) -> RunResult:
         from slide2vec.inference import run_pipeline_with_coordinates
 
@@ -1229,6 +1228,7 @@ class Pipeline:
                 slides=slides,
                 preprocessing=resolved_preprocessing,
                 execution=self.execution,
+                on_slide_persisted=on_slide_persisted,
             )
 
 

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/data/tile_reader.py

@@ -52,7 +52,6 @@ def _open_wsi_backend(image_path: str, backend: str, gpu_decode: bool):
         return VIPSReader(image_path)
     elif backend == "asap":
         from hs2p.wsi.backends.asap import ASAPReader
-        from slide2vec.utils.log_utils import suppress_c_stderr
         with suppress_c_stderr():
             return ASAPReader(image_path)
     else:

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/distributed/__init__.py

@@ -133,7 +133,6 @@ class _TorchDistributedEnvironment:
 
     # Single node job with preset environment (i.e. torchrun)
     def _set_from_preset_env(self):
-        # logger.info("Initialization from preset environment")
         self.rank = int(os.environ["RANK"])
         self.world_size = int(os.environ["WORLD_SIZE"])
         assert self.rank < self.world_size
@@ -143,7 +142,6 @@ class _TorchDistributedEnvironment:
 
     # Single node and GPU job (i.e. local script run)
     def _set_from_local(self):
-        # logger.info("Initialization from local")
         self.rank = 0
         self.world_size = 1
         self.local_rank = 0
@@ -196,7 +194,6 @@ def enable(
     if set_cuda_current_device:
         torch.cuda.set_device(torch_env.local_rank)
 
-    # Finalize setup
     _RANK = torch_env.rank
     _WORLD_SIZE = torch_env.world_size
     _LOCAL_RANK = torch_env.local_rank

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/encoders/models/gigapath.py

@@ -48,13 +48,8 @@ class GigaPath(TimmTileEncoder):
         )
 
     def get_transform(self) -> Callable:
-        # POOLED transform only: center-crops the 256px tile to the model's 224px
-        # native input (paper recipe, center 224 @ native 0.5 mpp). Dense extraction
-        # must NOT route through this — it needs the full uncropped tile so the grid
-        # covers the whole source tile. The dense path supplies its own no-crop
-        # transform (Resize(256), no CenterCrop) → a 16x16 grid over the full tile;
-        # encode_tiles_dense itself is transform-agnostic (inherited from
-        # TimmTileEncoder) and operates on whatever batch the dense pipeline feeds.
+        # Pooled recipe: center 224px at native spacing. Dense extraction uses
+        # get_normalization_transform() to preserve the caller's tile geometry.
         return v2.Compose([
             v2.ToImage(),
             v2.Resize(256, interpolation=v2.InterpolationMode.BICUBIC, antialias=True),

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/encoders/models/moozy/slide.py

@@ -50,7 +50,7 @@ class MOOZYSlideEncoder(nn.Module):
                     dropout=dropout,
                     attn_dropout=attn_dropout,
                     alibi=self.pos_bias,
-                    drop_path_rate=dpr[i] if i < len(dpr) else 0.0,
+                    drop_path_rate=dpr[i],
                     qk_norm=qk_norm,
                     layerscale_init=layerscale_init,
                 )
@@ -109,26 +109,18 @@ class MOOZYSlideEncoder(nn.Module):
         x = torch.cat(tokens, dim=1)
 
         coords_xy = coords_xy.to(device=x.device, dtype=torch.float32).reshape(bsz, n_tokens, 2)
-        zeros_cls = torch.zeros(bsz, 1, 2, dtype=coords_xy.dtype, device=coords_xy.device)
-        if self.num_registers > 0:
-            zeros_reg = torch.zeros(bsz, self.num_registers, 2, dtype=coords_xy.dtype, device=coords_xy.device)
-            positions = torch.cat([zeros_cls, zeros_reg, coords_xy], dim=1)
-        else:
-            positions = torch.cat([zeros_cls, coords_xy], dim=1)
-
-        valid_flat = ~invalid_flat
-        reg_valid = (
-            torch.ones(bsz, self.num_registers, dtype=torch.bool, device=x.device)
-            if self.num_registers > 0
-            else torch.zeros(bsz, 0, dtype=torch.bool, device=x.device)
+        num_prefix = 1 + self.num_registers
+        prefix_positions = torch.zeros(
+            bsz, num_prefix, 2, dtype=coords_xy.dtype, device=coords_xy.device
         )
-        valid_with_cls = torch.cat([torch.ones(bsz, 1, dtype=torch.bool, device=x.device), reg_valid, valid_flat], dim=1)
+        positions = torch.cat([prefix_positions, coords_xy], dim=1)
+        prefix_valid = torch.ones(bsz, num_prefix, dtype=torch.bool, device=x.device)
+        valid_with_cls = torch.cat([prefix_valid, ~invalid_flat], dim=1)
 
         if mask is None and bsz == 1:
             keep = valid_with_cls[0]
-            if keep.sum() > 0:
-                x = x[:, keep, :]
-                positions = positions[:, keep, :]
+            x = x[:, keep, :]
+            positions = positions[:, keep, :]
             attn_mask = None
         else:
             pair_valid = valid_with_cls.unsqueeze(2) & valid_with_cls.unsqueeze(1)

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/inference.py

@@ -1,26 +1,14 @@
-import json
-import importlib
 import os
-import tempfile
-import threading
-import time
-from contextlib import contextmanager, nullcontext
-from dataclasses import replace
 from pathlib import Path
-from types import SimpleNamespace
 from typing import Any, Callable, Sequence
 
-import logging
-import pandas as pd
 import torch
-from hs2p import SlideSpec, tile_slides
-from hs2p.utils.stderr import run_with_filtered_stderr
+from hs2p import SlideSpec
 
 from slide2vec.runtime import (
     artifacts_collect,
     batching,
     cpu_budget,
-    distributed,
     distributed_stage,
     embedding,
     embedding_persist,
@@ -31,11 +19,9 @@ from slide2vec.runtime import (
     persist_callbacks,
     persistence,
     process_list,
-    serialization,
     slide_encode,
     tiling,
     tiling_pipeline,
-    worker_io,
 )
 from slide2vec.api import (
     EmbeddedPatient,
@@ -43,43 +29,21 @@ from slide2vec.api import (
     ExecutionOptions,
     PreprocessingConfig,
     RunResult,
-    _resolve_hierarchical_preprocessing,
 )
 from slide2vec.artifacts import (
     HierarchicalEmbeddingArtifact,
-    PatientEmbeddingArtifact,
     SlideEmbeddingArtifact,
     TileEmbeddingArtifact,
-    write_hierarchical_embeddings,
     load_array,
-    write_patient_embeddings,
-    write_tile_embedding_metadata,
 )
 from slide2vec.encoders.registry import (
     encoder_registry,
-    resolve_encoder_output,
     resolve_patch_size,
-    resolve_preprocessing_defaults,
 )
 from slide2vec.runtime.model_settings import canonicalize_model_name
 from slide2vec.runtime.types import LoadedModel
 from slide2vec.runtime.encoder_input_contract import EncoderInputContract
-from slide2vec.progress import (
-    emit_progress,
-    read_tiling_progress_snapshot,
-)
-from slide2vec.utils.log_utils import suppress_c_stderr
-from slide2vec.data.dataset import BatchTileCollator, TileIndexDataset
-from slide2vec.data.tile_reader import OnTheFlyBatchTileCollator, OnTheFlyHierarchicalBatchCollator
-from slide2vec.utils.tiling_io import (
-    load_embedding_process_df,
-    load_patient_id_mapping,
-    load_slide_manifest,
-    load_tiling_process_df,
-    load_tiling_result_from_row,
-    _optional_float,
-)
-from slide2vec.utils.utils import cpu_worker_limit, slurm_cpu_limit
+from slide2vec.progress import emit_progress
 
 from slide2vec.runtime.hierarchical import num_embedding_items
 
@@ -126,13 +90,15 @@ def load_model(
     info = encoder_registry.info(name)
     resolved_level = info["level"]
 
-    if token is None and "HF_TOKEN" in os.environ:
-        token = os.environ["HF_TOKEN"]
-
+    # Never call ``huggingface_hub.login()`` here. Every encoder resolves its auth
+    # through the process-global ``huggingface_hub.get_token()``, which reads
+    # ``HF_TOKEN`` from the environment ahead of any stored token file, so an
+    # exported ``HF_TOKEN`` is all the hub needs. ``login()`` additionally rewrites a
+    # shared ``stored_tokens`` file without a lock; under distributed extraction every
+    # rank re-runs load_model per chunk and the concurrent truncate/re-read races,
+    # crashing runs with ``ValueError: Token ... not found``.
     if token is not None:
-        from huggingface_hub import login as hf_login
-
-        hf_login(token=token, add_to_git_credential=False)
+        os.environ["HF_TOKEN"] = token
 
     encoder_cls = encoder_registry.require(name)
     # Pass allow_non_recommended_settings ONLY to encoders whose constructor accepts it
@@ -625,6 +591,7 @@ def embed_tiles(
     *,
     execution: ExecutionOptions,
     preprocessing: PreprocessingConfig | None = None,
+    on_slide_persisted: Callable[[TileEmbeddingArtifact | HierarchicalEmbeddingArtifact], None] | None = None,
 ) -> list[TileEmbeddingArtifact] | list[HierarchicalEmbeddingArtifact]:
     if execution.output_dir is None:
         raise ValueError("ExecutionOptions.output_dir is required to persist tile embeddings")
@@ -694,6 +661,8 @@ def embed_tiles(
                 annotation=embedding.tiling_result_annotation(tiling_result),
             )
         artifacts.append(artifact)
+        if on_slide_persisted is not None:
+            on_slide_persisted(artifact)
     return artifacts
 
 
@@ -714,11 +683,7 @@ def aggregate_tiles(
     outputs: list[SlideEmbeddingArtifact] = []
     for artifact in tile_artifacts:
         metadata = artifact.metadata
-        if "coordinates_npz_path" not in metadata or "coordinates_meta_path" not in metadata:
-            raise ValueError(
-                f"Tile artifact for {artifact.sample_id} is missing tiling metadata paths required for slide aggregation"
-            )
-        if not metadata["coordinates_npz_path"] or not metadata["coordinates_meta_path"]:
+        if not metadata.get("coordinates_npz_path") or not metadata.get("coordinates_meta_path"):
             raise ValueError(
                 f"Tile artifact for {artifact.sample_id} is missing tiling metadata paths required for slide aggregation"
             )
@@ -735,13 +700,12 @@ def aggregate_tiles(
             tiling_result,
             execution=execution,
         )
-        latents = None
         slide_artifact = embedding.write_slide_embedding_artifact(
             artifact.sample_id,
             slide_embedding,
             execution=execution,
             metadata=embedding.build_slide_embedding_metadata(model, image_path=metadata["image_path"]),
-            latents=latents,
+            latents=None,
         )
         outputs.append(slide_artifact)
     return outputs
@@ -921,9 +885,8 @@ def run_pipeline(
             execution=execution,
             process_list_path=process_list_path,
         )
-        embedded_slides: list[EmbeddedSlide] = []
         if pending_slides:
-            embedded_slides = embedding_pipeline.compute_embedded_slides(
+            embedding_pipeline.compute_embedded_slides(
                 model,
                 pending_slides,
                 pending_tiling_results,
@@ -972,6 +935,7 @@ def run_pipeline_with_coordinates(
     slides=None,
     preprocessing: PreprocessingConfig | None = None,
     execution: ExecutionOptions,
+    on_slide_persisted: Callable[[TileEmbeddingArtifact | HierarchicalEmbeddingArtifact], None] | None = None,
 ) -> RunResult:
     if execution.output_dir is None:
         raise ValueError("ExecutionOptions.output_dir is required for Pipeline.run_with_coordinates(...)")
@@ -1031,6 +995,7 @@ def run_pipeline_with_coordinates(
                 execution=execution,
                 output_dir=output_dir,
                 tiling_input_dir=Path(coordinates_dir),
+                on_slide_persisted=on_slide_persisted,
             )
             return RunResult(
                 tile_artifacts=tile_artifacts,
@@ -1043,6 +1008,7 @@ def run_pipeline_with_coordinates(
             preprocessing=resolved_preprocessing,
             execution=execution,
             process_list_path=process_list_path,
+            on_artifact=on_slide_persisted,
         )
         embedding_pipeline.compute_embedded_slides(
             model,

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/runtime/artifacts_collect.py

@@ -1,7 +1,7 @@
 """Collect pipeline-level tile/slide/hierarchical artifacts (local + distributed paths)."""
 
 from pathlib import Path
-from typing import Sequence
+from typing import Callable, Sequence
 
 import pandas as pd
 from hs2p import SlideSpec
@@ -154,6 +154,7 @@ def collect_distributed_pipeline_artifacts(
     execution: ExecutionOptions,
     output_dir: Path,
     tiling_input_dir: Path | None = None,
+    on_slide_persisted: Callable[[TileEmbeddingArtifact | HierarchicalEmbeddingArtifact], None] | None = None,
 ) -> tuple[
     list[TileEmbeddingArtifact],
     list[HierarchicalEmbeddingArtifact],
@@ -170,12 +171,10 @@ def collect_distributed_pipeline_artifacts(
         or include_slide_embeddings
         or persist_hierarchical_embeddings
     )
-    annotation_groups = (
-        _embeddable_annotation_groups(process_list_path) if annotation_aware else {}
-    )
     # The embedding stage must fan out per (sample_id, annotation) for every level so each class's
     # tiles are embedded independently.
     stage_annotation_groups = _embeddable_annotation_groups(process_list_path)
+    annotation_groups = stage_annotation_groups if annotation_aware else {}
     # One annotation per ``successful_slides`` entry (the tiling spine fans out per class). Carry each
     # on a lightweight placeholder so the resume gate keys by (sample_id, annotation) and the surviving
     # pending entries hand the stage the right per-class work units.
@@ -258,6 +257,9 @@ def collect_distributed_pipeline_artifacts(
             slide_artifacts=slide_artifacts,
         )
         live_updated_sample_ids.add(sample_id)
+        if on_slide_persisted is not None:
+            for artifact in [*tile_artifacts, *hierarchical_artifacts]:
+                on_slide_persisted(artifact)
 
     run_distributed_embedding_stage(
         model=model,
@@ -269,9 +271,6 @@ def collect_distributed_pipeline_artifacts(
         annotations=pending_annotations,
         on_progress_event=_update_process_list_for_finished_slide,
     )
-    # ``successful_slides`` is already one entry per (sample_id, annotation) row, so resolve a
-    # parallel annotations list (not an expansion) to re-read each entry's namespaced artifact.
-    annotations_for_collect = _annotations_parallel_to_slides(successful_slides, annotation_groups)
     tile_artifacts, hierarchical_artifacts, slide_artifacts = collect_pipeline_artifacts(
         successful_slides,
         output_dir=output_dir,
@@ -279,7 +278,7 @@ def collect_distributed_pipeline_artifacts(
         include_tile_embeddings=include_tile_embeddings,
         include_hierarchical_embeddings=persist_hierarchical_embeddings,
         include_slide_embeddings=include_slide_embeddings,
-        annotations=annotations_for_collect if annotation_aware else None,
+        annotations=stage_annotations if annotation_aware else None,
     )
     update_process_list_after_embedding(
         process_list_path,

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/runtime/batching.py

@@ -17,6 +17,7 @@ import torch
 
 from slide2vec.progress import emit_progress
 from slide2vec.runtime.types import LoadedModel
+from slide2vec.runtime.worker_io import uses_cuda_runtime
 from slide2vec.utils.log_utils import suppress_c_stderr
 
 from .preprocessing import (
@@ -29,17 +30,8 @@ from .preprocessing import (
 from .types import PreparedBatch
 
 
-def uses_cuda_runtime(device) -> bool:
-    return str(device).startswith("cuda") and torch.cuda.is_available()
-
-
-
 def should_suppress_cucim_dataloader_stderr(dataloader) -> bool:
-    if dataloader is None:
-        return False
     collate_fn = getattr(dataloader, "collate_fn", None)
-    if collate_fn is None:
-        return False
     return bool(getattr(collate_fn, "_suppress_cucim_stderr", False))
 
 

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/runtime/dense_sliding.py

@@ -73,11 +73,6 @@ def cover_origins(extent: int, size: int, stride: int) -> list[int]:
     return starts
 
 
-def _window_starts(extent: int, win: int, stride: int) -> list[int]:
-    """Patch-aligned encoder-window starts — the token-space use of :func:`cover_origins`."""
-    return cover_origins(extent, win, stride)
-
-
 def resolve_window_geometry(
     geometry: DenseGridGeometry, *, window_size: int | None, overlap: float
 ) -> tuple[tuple[int, int], tuple[int, int], list[int], list[int]]:
@@ -99,8 +94,8 @@ def resolve_window_geometry(
     keep = 1.0 - float(overlap)
     stride_h = min(win_h, _round_to(win_h * keep, ph))
     stride_w = min(win_w, _round_to(win_w * keep, pw))
-    starts_h = _window_starts(enc_h, win_h, stride_h)
-    starts_w = _window_starts(enc_w, win_w, stride_w)
+    starts_h = cover_origins(enc_h, win_h, stride_h)
+    starts_w = cover_origins(enc_w, win_w, stride_w)
     return (win_h, win_w), (stride_h, stride_w), starts_h, starts_w
 
 

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/runtime/model_settings.py

@@ -1,8 +1,5 @@
-import logging
 from typing import Any
 
-logger = logging.getLogger("slide2vec")
-
 
 PRECISION_ALIASES = {
     "fp32": "fp32",
@@ -66,8 +63,8 @@ def resolve_output_precision(output_dtype: Any, compute_precision: Any) -> str:
     """Resolve the concrete on-disk feature precision (``"fp16"`` or ``"fp32"``).
 
     ``output_dtype is None`` follows ``compute_precision``: an fp16 forward keeps fp16
-    features, while bf16 / fp32 (and an unset or unknown compute precision) widen to fp32 —
-    fp32 is bf16's lossless container and the only float dtype a numpy artifact can hold.
+    features, while bf16 / fp32 (and an unset compute precision) widen to fp32.
+    NumPy has no bfloat16 dtype, so fp32 is its lossless storage container.
     A non-null ``output_dtype`` is honored verbatim (after :func:`normalize_output_dtype`).
     This is the single source of truth shared by the pooled write path and the dense
     ``iter_regions_dense`` path.
@@ -98,4 +95,3 @@ def output_torch_dtype(precision: str):
 def canonicalize_model_name(name: str) -> str:
     normalized = name.strip().lower()
     return MODEL_NAME_ALIASES.get(normalized, normalized)
-

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/runtime/persist_callbacks.py

@@ -187,6 +187,7 @@ def build_incremental_persist_callback(
     preprocessing: PreprocessingConfig,
     execution: ExecutionOptions,
     process_list_path: Path | None = None,
+    on_artifact: Callable[[TileEmbeddingArtifact | HierarchicalEmbeddingArtifact], None] | None = None,
 ) -> tuple[
     Callable[[SlideSpec, Any, EmbeddedSlide], None] | None,
     list[TileEmbeddingArtifact] | list[HierarchicalEmbeddingArtifact],
@@ -250,6 +251,8 @@ def build_incremental_persist_callback(
         )
         if tile_artifact is not None:
             tile_artifacts.append(tile_artifact)
+            if on_artifact is not None:
+                on_artifact(tile_artifact)
         if slide_artifact is not None:
             slide_artifacts.append(slide_artifact)
         # Buffer this completion; a slide with no successful artifact is still

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/utils/log_utils.py

@@ -7,12 +7,6 @@ import sys
 from slide2vec.progress import emit_progress_log
 
 
-def _distributed_module():
-    import slide2vec.distributed as distributed
-
-    return distributed
-
-
 @contextlib.contextmanager
 def suppress_c_stderr():
     """Temporarily redirect C-level stderr to /dev/null.
@@ -62,16 +56,17 @@ def _configure_logger(
         level: The logging level to use.
         output: A file name or a directory to save log. If None, will not save log file.
             If ends with ".txt" or ".log", assumed to be a file name.
-            Otherwise, logs will be saved to `output/log.txt`.
+            Otherwise, logs will be saved to `output/logs/log.txt`.
 
     Returns:
         The configured logger.
     """
 
+    import slide2vec.distributed as distributed
+
     logger = logging.getLogger(name)
     logger.setLevel(level)
     logger.propagate = False
-    distributed = _distributed_module()
 
     # Loosely match Google glog format:
     #   [IWEF]yyyymmdd hh:mm:ss.uuuuuu threadid file:line] msg
@@ -127,7 +122,7 @@ def setup_logging(
         output: A file name or a directory to save log files. If None, log
             files will not be saved. If output ends with ".txt" or ".log", it
             is assumed to be a file name.
-            Otherwise, logs will be saved to `output/log.txt`.
+            Otherwise, logs will be saved to `output/logs/log.txt`.
         name: The name of the logger to configure, by default the root logger.
         level: The logging level to use.
         capture_warnings: Whether warnings should be captured as logs.

{slide2vec-5.8.2 → slide2vec-5.9.0}/slide2vec/utils/tiling_io.py

@@ -211,8 +211,6 @@ def _load_base_process_df(process_list_path: str | Path) -> pd.DataFrame:
         df["requested_mask_backend"] = [None] * len(df)
     if "mask_backend" not in df.columns:
         df["mask_backend"] = [None] * len(df)
-    if "annotation" not in df.columns:
-        df["annotation"] = ["tissue"] * len(df)
     reconstructed_output_mode = df["annotation"].map(
         lambda annotation: "merged" if str(annotation) == "merged" else None
     )