slide2vec 7.1.0__tar.gz → 7.1.1__tar.gz

{slide2vec-7.1.0 → slide2vec-7.1.1}/PKG-INFO

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

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

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/__init__.py

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

{slide2vec-7.1.0 → slide2vec-7.1.1}/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, Callable, Mapping, Protocol, Sequence
+from typing import Any, Callable, Mapping, NamedTuple, Protocol, Sequence
 
 import torch
 from hs2p import (
@@ -261,9 +261,12 @@ class ExecutionOptions:
     #: (capped by CPU / SLURM limit, then split across the resolved GPU count).
     #: Image-only routes safely use zero when auto selection happens after model loading.
     num_workers_per_gpu: int | None = None
-    #: Tiling worker count. ``None`` means auto (capped by CPU / SLURM limit).
+    #: Tiling worker count. ``None`` means auto. The field keeps the requested value;
+    #: :meth:`resolved_num_preprocessing_workers` gives the count a run uses, capped by the
+    #: CPU / SLURM limit.
     num_preprocessing_workers: int | None = None
-    #: Number of GPUs to use. ``None`` defaults to all available GPUs.
+    #: Number of GPUs to use. ``None`` means all available GPUs. The field keeps the
+    #: requested value; :meth:`resolved_num_gpus` gives the count a run uses.
     num_gpus: int | None = None
     #: Forward-pass dtype — ``"fp16"``, ``"bf16"``, ``"fp32"``,
     #: or ``None`` (auto-determined from the model preset).
@@ -313,11 +316,9 @@ class ExecutionOptions:
         )
 
     def __post_init__(self) -> None:
-        resolved_num_gpus = _default_num_gpus() if self.num_gpus is None else self.num_gpus
-        object.__setattr__(self, "num_gpus", resolved_num_gpus)
         object.__setattr__(self, "precision", normalize_precision_name(self.precision))
         object.__setattr__(self, "output_dtype", normalize_output_dtype(self.output_dtype))
-        if resolved_num_gpus < 1:
+        if self.num_gpus is not None and self.num_gpus < 1:
             raise ValueError("ExecutionOptions.num_gpus must be at least 1")
         if self.batch_size < 1:
             raise ValueError("ExecutionOptions.batch_size must be at least 1")
@@ -325,40 +326,62 @@ class ExecutionOptions:
             raise ValueError("ExecutionOptions.prefetch_factor must be at least 1")
         if self.num_workers_per_gpu is not None and self.num_workers_per_gpu < 0:
             raise ValueError("ExecutionOptions.num_workers_per_gpu must be non-negative")
+        if self.num_preprocessing_workers is not None and self.num_preprocessing_workers < 0:
+            raise ValueError("ExecutionOptions.num_preprocessing_workers must be non-negative")
         if self.on_image_mismatch not in IMAGE_MISMATCH_POLICIES:
             raise ValueError(
                 "ExecutionOptions.on_image_mismatch must be one of "
                 f"{', '.join(repr(policy) for policy in IMAGE_MISMATCH_POLICIES)}; "
                 f"got {self.on_image_mismatch!r}"
             )
+
+    def resolved_num_gpus(self) -> int:
+        """GPU count a run uses: :attr:`num_gpus`, or every visible GPU when it is ``None``."""
+        return self._machine_resolution.num_gpus
+
+    def resolved_num_preprocessing_workers(self) -> int:
+        """Tiling worker count a run uses: :attr:`num_preprocessing_workers`, or the CPU /
+        SLURM limit when it is ``None``, and never more than that limit."""
+        return self._machine_resolution.num_preprocessing_workers
+
+    def resolved_num_workers_per_gpu(self) -> int:
+        if self.num_workers_per_gpu is not None:
+            return self.num_workers_per_gpu
+        return max(1, cpu_worker_limit() // self.resolved_num_gpus())
+
+    @functools.cached_property
+    def _machine_resolution(self) -> "_MachineResolution":
+        # Resolved once per instance, on first use, so every reader in a run agrees and the
+        # log line is written once. The cache sits outside the dataclass fields: equality,
+        # hashing and repr see only what the caller asked for.
+        num_gpus = _default_num_gpus() if self.num_gpus is None else self.num_gpus
         cap = cpu_worker_limit()
-        cpu_count = os.cpu_count() or 1
-        slurm_limit = slurm_cpu_limit()
-        capped_num_preprocessing_workers = (
+        num_preprocessing_workers = (
             cap if self.num_preprocessing_workers is None else min(self.num_preprocessing_workers, cap)
         )
-        object.__setattr__(self, "num_preprocessing_workers", capped_num_preprocessing_workers)
-        logger = logging.getLogger(__name__)
-        cap_source = f"slurm_cpu_limit={slurm_limit}" if slurm_limit is not None else f"cpu_count={cpu_count}"
-        resolved_num_workers = self.resolved_num_workers_per_gpu()
-        num_workers_per_gpu_label = (
-            f"{resolved_num_workers} (requested=auto)"
-            if self.num_workers_per_gpu is None
-            else str(resolved_num_workers)
+        num_workers_per_gpu = (
+            max(1, cap // num_gpus) if self.num_workers_per_gpu is None else self.num_workers_per_gpu
+        )
+        slurm_limit = slurm_cpu_limit()
+        cap_source = (
+            f"slurm_cpu_limit={slurm_limit}" if slurm_limit is not None else f"cpu_count={os.cpu_count() or 1}"
         )
-        logger.info(
-            "ExecutionOptions: num_workers_per_gpu=%s, num_preprocessing_workers=%d "
+        logging.getLogger(__name__).info(
+            "ExecutionOptions: num_gpus=%s, num_workers_per_gpu=%s, num_preprocessing_workers=%d "
             "(preprocessing cap=%d via %s)",
-            num_workers_per_gpu_label,
-            capped_num_preprocessing_workers,
+            _auto_label(num_gpus, requested=self.num_gpus),
+            _auto_label(num_workers_per_gpu, requested=self.num_workers_per_gpu),
+            num_preprocessing_workers,
             cap,
             cap_source,
         )
+        return _MachineResolution(num_gpus=num_gpus, num_preprocessing_workers=num_preprocessing_workers)
 
-    def resolved_num_workers_per_gpu(self) -> int:
-        if self.num_workers_per_gpu is not None:
-            return self.num_workers_per_gpu
-        return max(1, cpu_worker_limit() // self.num_gpus)
+    def __getstate__(self) -> dict[str, Any]:
+        # A copy or an unpickled instance resolves again on the machine that uses it.
+        state = dict(self.__dict__)
+        state.pop("_machine_resolution", None)
+        return state
 
     def resolved_image_num_workers_per_gpu(self) -> int:
         """Resolve safe post-model-load image-transform workers for this rank."""
@@ -898,8 +921,9 @@ class Model:
         The dense counterpart of the pooled coordinate path: each ``SlideRegions`` names a
         slide + a set of level-0 ROI coordinates, and every ROI is read, encoded through the
         dense transform, and written to ``dense_embeddings/[<class>/]<sample_id>/<x>_<y>.pt``
-        plus a geometry sidecar. The run splits its ROIs across all visible GPUs
-        (``execution.num_gpus``); ``num_gpus=1`` encodes fully in-process. Resume is
+        plus a geometry sidecar. The run splits its ROIs across
+        ``execution.resolved_num_gpus()`` GPUs (all visible GPUs by default);
+        ``num_gpus=1`` encodes fully in-process. Resume is
         automatic — only ROIs whose sidecar has the same source-spacing declaration,
         resolved hs2p read plan and feature identity are skipped. Returns one
         :class:`~slide2vec.artifacts.DenseRegionArtifact` per input ROI.
@@ -932,10 +956,10 @@ class Model:
         **normalization-only** transform, padded up to the encoder's patch multiple, encoded
         — whole-image, or by sliding the encoder's native field and blending the token grids
         — and written to ``dense_image_embeddings/<sample_id>.pt`` plus a geometry sidecar.
-        The run splits its images across all visible GPUs (``execution.num_gpus``);
-        ``num_gpus=1`` encodes fully in-process. Resume is automatic: an image is skipped
-        only when its payload exists and its sidecar records the same normalized source
-        identity and complete extraction recipe. Returns one
+        The run splits its images across ``execution.resolved_num_gpus()`` GPUs (all
+        visible GPUs by default); ``num_gpus=1`` encodes fully in-process. Resume is
+        automatic: an image is skipped only when its payload exists and its sidecar records
+        the same normalized source identity and complete extraction recipe. Returns one
         :class:`~slide2vec.artifacts.DenseImageArtifact` per input image, in input order.
 
         Every source is opened through hs2p. PNG/JPEG inputs use hs2p's one-level PIL reader
@@ -977,12 +1001,12 @@ class Model:
         set — and slide2vec neither tiles nor reads a slide. Each :class:`ImageSpec` is
         decoded, preprocessed with the encoder's **shipped** transform, encoded, and written
         to ``image_embeddings/<sample_id>.pt`` plus a provenance sidecar. The run splits its
-        images across all visible GPUs (``execution.num_gpus``); ``num_gpus=1`` encodes
-        fully in-process. Resume is automatic: an image is skipped only when its sidecar
-        records this ``output_format``, the requested ``image_path`` and the full feature
-        identity. A different recorded feature identity raises; a different recorded
-        ``image_path`` raises unless ``execution.on_image_mismatch="reencode"``; missing
-        provenance re-encodes. Returns
+        images across ``execution.resolved_num_gpus()`` GPUs (all visible GPUs by
+        default); ``num_gpus=1`` encodes fully in-process. Resume is automatic: an image is
+        skipped only when its sidecar records this ``output_format``, the requested
+        ``image_path`` and the full feature identity. A different recorded feature identity
+        raises; a different recorded ``image_path`` raises unless
+        ``execution.on_image_mismatch="reencode"``; missing provenance re-encodes. Returns
         one :class:`~slide2vec.artifacts.ImageEmbeddingArtifact` per input image, in input
         order.
 
@@ -1342,6 +1366,15 @@ def _default_num_gpus() -> int:
     return max(1, torch.cuda.device_count()) if torch.cuda.is_available() else 1
 
 
+class _MachineResolution(NamedTuple):
+    num_gpus: int
+    num_preprocessing_workers: int
+
+
+def _auto_label(resolved: int, *, requested: int | None) -> str:
+    return f"{resolved} (requested=auto)" if requested is None else str(resolved)
+
+
 def _require_output_dir_for_persistence(execution: ExecutionOptions, *, method_name: str) -> None:
     if execution.output_dir is None:
         raise ValueError(f"ExecutionOptions.output_dir is required for {method_name}")

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/inference.py

@@ -261,7 +261,7 @@ def embed_slides(
     slide_records = [manifest.coerce_slide_spec(slide) for slide in slides]
     if not slide_records:
         raise ValueError("At least one slide is required")
-    if execution.num_gpus > 1:
+    if execution.resolved_num_gpus() > 1:
         distributed_stage.validate_multi_gpu_execution(model, execution)
     emit_progress(
         "run.started",
@@ -282,7 +282,7 @@ def embed_slides(
                 slide_records,
                 preprocessing,
                 output_dir=work_dir,
-                num_workers=execution.num_preprocessing_workers,
+                num_workers=execution.resolved_num_preprocessing_workers(),
             )
             process_list.emit_tiling_summary(
                 process_list_path,
@@ -306,19 +306,19 @@ def embed_slides(
                 execution=execution,
             )
             emit_progress("embedding.started", slide_count=len(embeddable_slides))
-            if execution.num_gpus > 1 and len(embeddable_slides) > 1:
+            if execution.resolved_num_gpus() > 1 and len(embeddable_slides) > 1:
                 emit_progress(
                     "embedding.assignment.started",
                     slide_count=len(embeddable_slides),
-                    num_gpus=execution.num_gpus,
+                    num_gpus=execution.resolved_num_gpus(),
                 )
                 emit_progress(
                     "embedding.assignment.finished",
                     slide_count=len(embeddable_slides),
-                    num_gpus=execution.num_gpus,
+                    num_gpus=execution.resolved_num_gpus(),
                 )
             local_persist_callback = None
-            if execution.output_dir is not None and execution.num_gpus <= 1:
+            if execution.output_dir is not None and execution.resolved_num_gpus() <= 1:
                 local_persist_callback, _, _ = persist_callbacks.build_incremental_persist_callback(
                     model=model,
                     preprocessing=preprocessing,
@@ -334,7 +334,7 @@ def embed_slides(
                 work_dir=work_dir,
                 on_embedded_slide=local_persist_callback,
             )
-            if execution.output_dir is not None and execution.num_gpus > 1:
+            if execution.output_dir is not None and execution.resolved_num_gpus() > 1:
                 tile_artifacts: list[TileEmbeddingArtifact] = []
                 hierarchical_artifacts: list[HierarchicalEmbeddingArtifact] = []
                 slide_artifacts: list[SlideEmbeddingArtifact] = []
@@ -464,7 +464,7 @@ def embed_patients(
                 slide_records,
                 preprocessing,
                 output_dir=work_dir,
-                num_workers=execution.num_preprocessing_workers,
+                num_workers=execution.resolved_num_preprocessing_workers(),
             )
             process_list.emit_tiling_summary(
                 process_list_path,
@@ -562,7 +562,7 @@ def _select_embedding_path(
     work_dir: Path,
     on_embedded_slide: Callable[[SlideSpec, Any, EmbeddedSlide], None] | None = None,
 ):
-    if execution.num_gpus > 1:
+    if execution.resolved_num_gpus() > 1:
         if len(slide_records) == 1:
             return [
                 distributed_stage.embed_single_slide_distributed(
@@ -780,7 +780,7 @@ def run_pipeline(
     # initialize their own CUDA and do not depend on this parent-side check.
     # Initializing a CUDA context in the parent here only buys needless fork
     # risk for the downstream tiling pool with no benefit.
-    if not tiling_only and execution.num_gpus > 1:
+    if not tiling_only and execution.resolved_num_gpus() > 1:
         distributed_stage.validate_multi_gpu_execution(model, execution)
 
     resolved_preprocessing = tiling_pipeline.resolve_model_preprocessing(model, preprocessing)
@@ -803,7 +803,7 @@ def run_pipeline(
             slide_records,
             resolved_preprocessing,
             output_dir=output_dir,
-            num_workers=execution.num_preprocessing_workers,
+            num_workers=execution.resolved_num_preprocessing_workers(),
         )
         process_list.emit_tiling_summary(
             process_list_path,
@@ -872,7 +872,7 @@ def run_pipeline(
                 process_list_path=process_list_path,
             )
 
-        if execution.num_gpus > 1:
+        if execution.resolved_num_gpus() > 1:
             tile_artifacts, hierarchical_artifacts, slide_artifacts = artifacts_collect.collect_distributed_pipeline_artifacts(
                 model=model,
                 successful_slides=embeddable_slides,
@@ -990,7 +990,7 @@ def run_pipeline_with_coordinates(
 ) -> RunResult:
     if execution.output_dir is None:
         raise ValueError("ExecutionOptions.output_dir is required for Pipeline.run_with_coordinates(...)")
-    if execution.num_gpus > 1:
+    if execution.resolved_num_gpus() > 1:
         distributed_stage.validate_multi_gpu_execution(model, execution)
 
     output_dir = Path(execution.output_dir)
@@ -1036,7 +1036,7 @@ def run_pipeline_with_coordinates(
             execution=execution,
         )
         emit_progress("embedding.started", slide_count=len(embeddable_slides))
-        if execution.num_gpus > 1:
+        if execution.resolved_num_gpus() > 1:
             tile_artifacts, hierarchical_artifacts, slide_artifacts = artifacts_collect.collect_distributed_pipeline_artifacts(
                 model=model,
                 successful_slides=embeddable_slides,

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/cpu_budget.py

@@ -34,7 +34,7 @@ def serialize_execution(
     if preprocessing is not None and preprocessing.on_the_fly and preprocessing.read_tiles_from is None:
         effective_num_workers_per_gpu, _ = resolve_on_the_fly_num_workers(
             preprocessing.num_cucim_workers,
-            num_gpus=execution.num_gpus,
+            num_gpus=execution.resolved_num_gpus(),
         )
     return serialize_execution_dict(
         execution,
@@ -56,7 +56,7 @@ def log_on_the_fly_worker_override_once(
         return
     effective_num_workers_per_gpu, worker_context = resolve_on_the_fly_num_workers(
         preprocessing.num_cucim_workers,
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
     if effective_num_workers_per_gpu == execution.resolved_num_workers_per_gpu():
         return

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/dense_image_stage.py

@@ -179,7 +179,7 @@ def embed_images_dense(
         recipe,
         read_plans=read_plans,
         resolve_transform=deferred_transform_record(
-            model, on_cpu_copy=execution.num_gpus > 1
+            model, on_cpu_copy=execution.resolved_num_gpus() > 1
         ),
     )
     if skipped:
@@ -192,10 +192,10 @@ def embed_images_dense(
         total=len(specs),
         skipped=skipped,
         encoding=len(remaining),
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
     if remaining:
-        if execution.num_gpus == 1:
+        if execution.resolved_num_gpus() == 1:
             _run_dense_images_in_process(
                 model,
                 remaining,
@@ -286,7 +286,7 @@ def _run_dense_images_distributed(
         run_torchrun_worker(
             module="slide2vec.distributed.dense_image_worker",
             pin_gpus=True,  # No collectives: each rank needs only its own GPU.
-            num_gpus=execution.num_gpus,
+            num_gpus=execution.resolved_num_gpus(),
             output_dir=out_dir,
             request_path=request_path,
             failure_title="Distributed dense image feature extraction failed",

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/dense_stage.py

@@ -207,7 +207,7 @@ def embed_regions_dense(
         out_dir,
         identity,
         resolve_transform=deferred_transform_record(
-            model, on_cpu_copy=execution.num_gpus > 1
+            model, on_cpu_copy=execution.resolved_num_gpus() > 1
         ),
     )
     if skipped:
@@ -220,10 +220,10 @@ def embed_regions_dense(
         total=len(flat),
         skipped=skipped,
         encoding=len(remaining),
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
     if remaining:
-        if execution.num_gpus == 1:
+        if execution.resolved_num_gpus() == 1:
             _run_dense_in_process(
                 model, remaining, dense=dense, execution=execution, out_dir=out_dir,
                 identity=identity,
@@ -323,7 +323,7 @@ def _run_dense_distributed(model, specs, *, dense, execution, out_dir) -> None:
         run_torchrun_worker(
             module="slide2vec.distributed.dense_worker",
             pin_gpus=True,  # No collectives: each rank needs only its own GPU.
-            num_gpus=execution.num_gpus,
+            num_gpus=execution.resolved_num_gpus(),
             output_dir=out_dir,
             request_path=request_path,
             failure_title="Distributed dense feature extraction failed",

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/distributed_stage.py

@@ -41,9 +41,9 @@ def validate_multi_gpu_execution(model, execution: ExecutionOptions) -> None:
     if not torch.cuda.is_available():
         raise RuntimeError("ExecutionOptions.num_gpus > 1 requires CUDA")
     available_gpus = int(torch.cuda.device_count())
-    if execution.num_gpus > available_gpus:
+    if execution.resolved_num_gpus() > available_gpus:
         raise ValueError(
-            f"ExecutionOptions.num_gpus={execution.num_gpus} exceeds available CUDA devices ({available_gpus})"
+            f"ExecutionOptions.num_gpus={execution.resolved_num_gpus()} exceeds available CUDA devices ({available_gpus})"
         )
 
 
@@ -140,16 +140,16 @@ def run_distributed_embedding_stage(
     emit_progress(
         "embedding.assignment.started",
         slide_count=len(successful_slides),
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
     emit_progress(
         "embedding.assignment.finished",
         slide_count=len(successful_slides),
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
     run_torchrun_worker(
         module="slide2vec.distributed.pipeline_worker",
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
         output_dir=output_dir,
         request_path=request_path,
         failure_title="Distributed feature extraction failed",
@@ -187,7 +187,7 @@ def run_distributed_direct_embedding_stage(
     request_path.write_text(json.dumps(request_payload, indent=2, sort_keys=True), encoding="utf-8")
     run_torchrun_worker(
         module="slide2vec.distributed.direct_embed_worker",
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
         output_dir=output_dir,
         request_path=request_path,
         failure_title="Distributed direct embedding failed",
@@ -276,7 +276,7 @@ def embed_multi_slides_distributed(
     assignments = assign_slides_to_ranks(
         slide_records,
         tiling_results,
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
     with distributed_coordination_dir(work_dir) as coordination_dir:
         run_distributed_direct_embedding_stage(

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/embedding_pipeline.py

@@ -144,7 +144,7 @@ def compute_tile_embeddings_for_slide(
     if preprocessing.on_the_fly and preprocessing.read_tiles_from is None and resolved_backend == "cucim":
         effective_num_workers, _ = resolve_on_the_fly_num_workers(
             preprocessing.num_cucim_workers,
-            num_gpus=execution.num_gpus,
+            num_gpus=execution.resolved_num_gpus(),
         )
         loader_kwargs["num_workers"] = effective_num_workers
         if effective_num_workers == 0:
@@ -280,7 +280,7 @@ def _encode_hierarchical_subtiles(
     if resolved_backend == "cucim":
         effective_num_workers, _ = resolve_on_the_fly_num_workers(
             preprocessing.num_cucim_workers,
-            num_gpus=execution.num_gpus,
+            num_gpus=execution.resolved_num_gpus(),
         )
         loader_kwargs["num_workers"] = effective_num_workers
         if effective_num_workers == 0:

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/image_stage.py

@@ -275,7 +275,7 @@ def embed_images(model, images: Sequence[ImageSpec], *, execution) -> list[Image
         output_format=execution.output_format,
         identity=identity,
         resolve_transform=deferred_transform_record(
-            model, on_cpu_copy=execution.num_gpus > 1
+            model, on_cpu_copy=execution.resolved_num_gpus() > 1
         ),
         on_image_mismatch=execution.on_image_mismatch,
     )
@@ -291,7 +291,7 @@ def embed_images(model, images: Sequence[ImageSpec], *, execution) -> list[Image
         total=len(specs),
         skipped=skipped,
         encoding=len(remaining),
-        num_gpus=execution.num_gpus,
+        num_gpus=execution.resolved_num_gpus(),
     )
 
     # The shard loop invalidates each image's stale files right before writing it, so a
@@ -300,7 +300,7 @@ def embed_images(model, images: Sequence[ImageSpec], *, execution) -> list[Image
     # encodes nothing deletes nothing.
     encoded_width = None
     if remaining:
-        if execution.num_gpus == 1:
+        if execution.resolved_num_gpus() == 1:
             encoded_width = _run_images_in_process(
                 model, remaining, execution=execution, out_dir=out_dir, identity=identity,
                 stale=plan.stale,
@@ -417,7 +417,7 @@ def _run_images_distributed(model, specs, *, execution, out_dir, stale) -> int:
         run_torchrun_worker(
             module="slide2vec.distributed.image_worker",
             pin_gpus=True,  # No collectives: each rank needs only its own GPU.
-            num_gpus=execution.num_gpus,
+            num_gpus=execution.resolved_num_gpus(),
             output_dir=out_dir,
             request_path=request_path,
             failure_title="Distributed image feature extraction failed",

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/serialization.py

@@ -87,8 +87,10 @@ def serialize_execution(
             if effective_num_workers_per_gpu is not None
             else execution.num_workers_per_gpu
         ),
-        "num_preprocessing_workers": execution.num_preprocessing_workers,
-        "num_gpus": execution.num_gpus,
+        # The launcher's resolution, not the request: a torchrun rank pinned to one GPU must
+        # still split its CPU budget across the launcher's world size.
+        "num_preprocessing_workers": execution.resolved_num_preprocessing_workers(),
+        "num_gpus": execution.resolved_num_gpus(),
         "precision": execution.precision,
         "output_dtype": execution.output_dtype,
         "prefetch_factor": execution.prefetch_factor,

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec/runtime/slide_encode.py

@@ -89,6 +89,7 @@ def describe_device_mode(model, execution: ExecutionOptions) -> str:
     requested_device = getattr(model, "_requested_device", None)
     if requested_device == "cpu":
         return "cpu"
-    if execution.num_gpus and execution.num_gpus > 1:
-        return f"{execution.num_gpus} gpus"
+    num_gpus = execution.resolved_num_gpus()
+    if num_gpus > 1:
+        return f"{num_gpus} gpus"
     return "gpu"

{slide2vec-7.1.0 → slide2vec-7.1.1}/slide2vec.egg-info/PKG-INFO

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

@@ -141,6 +141,7 @@ tests/test_encoder_plugins.py
 tests/test_encoder_preprocessing.py
 tests/test_encoder_provider_failures.py
 tests/test_encoder_registry.py
+tests/test_execution_options.py
 tests/test_feature_identity.py
 tests/test_gigapath.py
 tests/test_gpfm_genbio_heavy.py