slide2vec 4.4.0__tar.gz → 4.5.0__tar.gz

{slide2vec-4.4.0 → slide2vec-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 4.4.0
+Version: 4.5.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.0.1
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.0.5
 Requires-Dist: omegaconf
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2
@@ -65,7 +65,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.0.1; extra == "fm"
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.0.5; 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-4.4.0 → slide2vec-4.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "4.4.0"
+version = "4.5.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.0.1",
+    "hs2p[asap,cucim,openslide,sam2,vips]>=4.0.5",
     "omegaconf",
     "matplotlib",
     "numpy<2",
@@ -88,7 +88,7 @@ fm = [
     "pandas",
     "pillow",
     "rich",
-    "hs2p[asap,cucim,openslide,sam2,vips]>=4.0.1",
+    "hs2p[asap,cucim,openslide,sam2,vips]>=4.0.5",
     "wandb",
     "torch>=2.3,<2.8",
     "torchvision>=0.18.0",
@@ -164,7 +164,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "4.4.0"
+current_version = "4.5.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-4.4.0 → slide2vec-4.5.0}/slide2vec/__init__.py

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

{slide2vec-4.4.0 → slide2vec-4.5.0}/slide2vec/api.py

@@ -111,20 +111,14 @@ class PreprocessingConfig:
             int(channel) for channel in preview_cfg.tissue_contour_color
         )
         preview_kwargs["mask_overlay_alpha"] = float(preview_cfg.mask_overlay_alpha)
+        region_size_px = getattr(tiling.params, "requested_region_size_px", None)
+        region_tile_multiple = getattr(tiling.params, "region_tile_multiple", None)
         return cls(
             backend=tiling.backend,
             requested_spacing_um=float(tiling.params.requested_spacing_um),
             requested_tile_size_px=int(tiling.params.requested_tile_size_px),
-            requested_region_size_px=(
-                int(v)
-                if (v := getattr(tiling.params, "requested_region_size_px", None)) is not None
-                else None
-            ),
-            region_tile_multiple=(
-                int(v)
-                if (v := getattr(tiling.params, "region_tile_multiple", None)) is not None
-                else None
-            ),
+            requested_region_size_px=int(region_size_px) if region_size_px is not None else None,
+            region_tile_multiple=int(region_tile_multiple) if region_tile_multiple is not None else None,
             tolerance=float(tiling.params.tolerance),
             overlap=float(tiling.params.overlap),
             tissue_threshold=float(tiling.params.tissue_threshold),
@@ -615,11 +609,9 @@ def _require_output_dir_for_persistence(execution: ExecutionOptions, *, method_n
 
 
 def _recommended_execution_precision(model: Model | None) -> str:
-    name = None if model is None else model.name
-    if name and name in encoder_registry:
-        info = encoder_registry.info(name)
-        return info["precision"] if "precision" in info and info["precision"] is not None else "fp32"
-    return "fp32"
+    if model is None or model.name not in encoder_registry:
+        return "fp32"
+    return encoder_registry.info(model.name).get("precision") or "fp32"
 
 
 def _resolve_direct_api_preprocessing(

{slide2vec-4.4.0 → slide2vec-4.5.0}/slide2vec/cli.py

@@ -1,8 +1,8 @@
 import argparse
 
 from slide2vec.api import ExecutionOptions, Model, Pipeline, PreprocessingConfig
+from slide2vec.progress import activate_progress_reporter, create_cli_progress_reporter
 from slide2vec.utils.config import setup, hf_login
-import slide2vec.progress as progress
 
 
 def get_args_parser(add_help: bool = True):
@@ -27,10 +27,8 @@ def build_model_and_pipeline(args):
     hf_login()
     model = Model.from_preset(
         cfg.model.name,
-        output_variant=getattr(cfg.model, "output_variant", None),
-        allow_non_recommended_settings=bool(
-            getattr(cfg.model, "allow_non_recommended_settings", False)
-        ),
+        output_variant=cfg.model.output_variant,
+        allow_non_recommended_settings=bool(cfg.model.allow_non_recommended_settings),
         device="cpu" if args.run_on_cpu else "auto",
     )
     preprocessing = PreprocessingConfig.from_config(cfg)
@@ -42,8 +40,8 @@ def build_model_and_pipeline(args):
 def main(argv=None):
     args = parse_args(argv)
     pipeline, cfg = build_model_and_pipeline(args)
-    reporter = progress.create_cli_progress_reporter(output_dir=getattr(cfg, "output_dir", None))
-    with progress.activate_progress_reporter(reporter):
+    reporter = create_cli_progress_reporter(output_dir=cfg.output_dir)
+    with activate_progress_reporter(reporter):
         return pipeline.run(
             manifest_path=cfg.csv,
             tiling_only=args.tiling_only,

{slide2vec-4.4.0 → slide2vec-4.5.0}/slide2vec/distributed/direct_embed_worker.py

@@ -18,15 +18,12 @@ def main(argv=None) -> int:
     import torch.distributed as dist
 
     import slide2vec.distributed as distributed
+    import slide2vec.inference as inference
     from slide2vec.api import Model
-    from slide2vec.inference import (
-        _build_hierarchical_index,
-        _compute_embedded_slides,
-        _compute_hierarchical_embedding_shard_for_slide,
-        _compute_tile_embeddings_for_slide,
-        _is_hierarchical_preprocessing,
-        _resolve_hierarchical_geometry,
-        load_successful_tiled_slides,
+    from slide2vec.runtime.hierarchical import (
+        build_hierarchical_index,
+        is_hierarchical_preprocessing,
+        resolve_hierarchical_geometry,
     )
     from slide2vec.progress import JsonlProgressReporter, activate_progress_reporter
     from slide2vec.runtime.serialization import deserialize_execution, deserialize_preprocessing
@@ -52,7 +49,10 @@ def main(argv=None) -> int:
         )
         preprocessing = deserialize_preprocessing(request["preprocessing"])
         execution = deserialize_execution(request["execution"])
-        slide_records, tiling_results = load_successful_tiled_slides(output_dir)
+        load_successful_tiled_slides_fn = getattr(inference, "load_successful_tiled_slides", None)
+        if not callable(load_successful_tiled_slides_fn):
+            from slide2vec.runtime.manifest import load_successful_tiled_slides as load_successful_tiled_slides_fn
+        slide_records, tiling_results = load_successful_tiled_slides_fn(output_dir)
         paired_by_sample = {
             slide.sample_id: (slide, tiling_result)
             for slide, tiling_result in zip(slide_records, tiling_results)
@@ -74,15 +74,24 @@ def main(argv=None) -> int:
                 sample_id = request["sample_id"]
                 slide, tiling_result = paired_by_sample[sample_id]
                 loaded = model._load_backend()
-                if _is_hierarchical_preprocessing(preprocessing):
-                    geometry = _resolve_hierarchical_geometry(preprocessing, tiling_result)
-                    index = _build_hierarchical_index(
+                if is_hierarchical_preprocessing(preprocessing):
+                    geometry = resolve_hierarchical_geometry(preprocessing, tiling_result)
+                    index = build_hierarchical_index(
                         tiling_result,
                         region_tile_multiple=int(preprocessing.region_tile_multiple),
                         tile_size_lv0=int(geometry["tile_size_lv0"]),
                     )
                     flat_indices = np.array_split(index.flat_index, world_size)[global_rank]
-                    shard_indices, tile_embeddings = _compute_hierarchical_embedding_shard_for_slide(
+                    compute_hierarchical_embedding_shard_for_slide_fn = getattr(
+                        inference,
+                        "_compute_hierarchical_embedding_shard_for_slide",
+                        None,
+                    )
+                    if not callable(compute_hierarchical_embedding_shard_for_slide_fn):
+                        from slide2vec.runtime.embedding_pipeline import (
+                            compute_hierarchical_embedding_shard_for_slide as compute_hierarchical_embedding_shard_for_slide_fn,
+                        )
+                    shard_indices, tile_embeddings = compute_hierarchical_embedding_shard_for_slide_fn(
                         loaded,
                         slide,
                         tiling_result,
@@ -98,7 +107,16 @@ def main(argv=None) -> int:
                 else:
                     num_tiles = len(tiling_result.x)
                     tile_indices = np.array_split(np.arange(num_tiles, dtype=np.int64), world_size)[global_rank]
-                    tile_embeddings = _compute_tile_embeddings_for_slide(
+                    compute_tile_embeddings_for_slide_fn = getattr(
+                        inference,
+                        "_compute_tile_embeddings_for_slide",
+                        None,
+                    )
+                    if not callable(compute_tile_embeddings_for_slide_fn):
+                        from slide2vec.runtime.embedding_pipeline import (
+                            compute_tile_embeddings_for_slide as compute_tile_embeddings_for_slide_fn,
+                        )
+                    tile_embeddings = compute_tile_embeddings_for_slide_fn(
                         loaded,
                         model,
                         slide,
@@ -128,7 +146,10 @@ def main(argv=None) -> int:
                 }
                 torch.save(payload, coordination_dir / f"{embedded_slide.sample_id}.embedded.pt")
 
-            _compute_embedded_slides(
+            compute_embedded_slides_fn = getattr(inference, "_compute_embedded_slides", None)
+            if not callable(compute_embedded_slides_fn):
+                from slide2vec.runtime.embedding_pipeline import compute_embedded_slides as compute_embedded_slides_fn
+            compute_embedded_slides_fn(
                 model,
                 assigned_slides,
                 assigned_tiling_results,

{slide2vec-4.4.0 → slide2vec-4.5.0}/slide2vec/distributed/pipeline_worker.py

@@ -17,12 +17,9 @@ def main(argv=None) -> int:
     import torch.distributed as dist
 
     import slide2vec.distributed as distributed
+    import slide2vec.inference as inference
     from slide2vec.api import Model
-    from slide2vec.inference import (
-        _build_incremental_persist_callback,
-        _compute_embedded_slides,
-        load_successful_tiled_slides,
-    )
+    from slide2vec.runtime.persist_callbacks import build_incremental_persist_callback
     from slide2vec.progress import JsonlProgressReporter, activate_progress_reporter
     from slide2vec.runtime.serialization import deserialize_execution, deserialize_preprocessing
 
@@ -47,7 +44,20 @@ def main(argv=None) -> int:
         preprocessing = deserialize_preprocessing(request["preprocessing"])
         execution = deserialize_execution(request["execution"])
         tiling_input_dir = Path(request.get("tiling_input_dir", str(output_dir)))
-        slide_records, tiling_results = load_successful_tiled_slides(tiling_input_dir)
+        load_successful_tiled_slides_fn = getattr(inference, "load_successful_tiled_slides", None)
+        if not callable(load_successful_tiled_slides_fn):
+            from slide2vec.runtime.manifest import load_successful_tiled_slides as load_successful_tiled_slides_fn
+        slide_records, tiling_results = load_successful_tiled_slides_fn(tiling_input_dir)
+        requested_sample_ids = request.get("sample_ids")
+        if requested_sample_ids is not None:
+            requested_sample_id_set = {str(sample_id) for sample_id in requested_sample_ids}
+            paired = [
+                (slide, tiling_result)
+                for slide, tiling_result in zip(slide_records, tiling_results)
+                if slide.sample_id in requested_sample_id_set
+            ]
+            slide_records = [slide for slide, _ in paired]
+            tiling_results = [tiling_result for _, tiling_result in paired]
         assignments = assign_slides_to_ranks(slide_records, tiling_results, num_gpus=world_size)
         assigned_ids = assignments.get(global_rank, [])
         if not assigned_ids:
@@ -70,13 +80,17 @@ def main(argv=None) -> int:
         )
         context = activate_progress_reporter(reporter) if reporter is not None else nullcontext()
         with context:
-            persist_callback, _, _ = _build_incremental_persist_callback(
+            build_incremental_persist_callback_fn = getattr(inference, "_build_incremental_persist_callback", build_incremental_persist_callback)
+            persist_callback, _, _ = build_incremental_persist_callback_fn(
                 model=model,
                 preprocessing=preprocessing,
                 execution=execution,
                 process_list_path=None,
             )
-            _compute_embedded_slides(
+            compute_embedded_slides_fn = getattr(inference, "_compute_embedded_slides", None)
+            if not callable(compute_embedded_slides_fn):
+                from slide2vec.runtime.embedding_pipeline import compute_embedded_slides as compute_embedded_slides_fn
+            compute_embedded_slides_fn(
                 model,
                 assigned_slides,
                 assigned_tiling_results,

{slide2vec-4.4.0 → slide2vec-4.5.0}/slide2vec/encoders/__init__.py

@@ -21,7 +21,7 @@ from slide2vec.encoders.registry import (
 )
 
 # Trigger registration of all built-in encoders.
-from slide2vec.encoders import models as _models_pkg  # noqa: F401
+from slide2vec.encoders import models  # noqa: F401
 
 __all__ = [
     "Encoder",