patchworks 0.11.15__tar.gz → 0.11.17__tar.gz

{patchworks-0.11.15 → patchworks-0.11.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchworks
-Version: 0.11.15
+Version: 0.11.17
 Summary: Tiled processing of arbitrarily large images with globally consistent labels
 Project-URL: Homepage, https://github.com/imcf/patchworks
 Project-URL: Issues, https://github.com/imcf/patchworks/issues

{patchworks-0.11.15 → patchworks-0.11.17}/src/patchworks/plugins/napari.py

@@ -142,6 +142,36 @@ def _resolve_image(
     return source
 
 
+def _pyramid_scale(path: Union[str, Path], ndim: int) -> list[float] | None:
+    """Read the level-0 physical scale (µm/px) from an OME-ZARR's own metadata.
+
+    Without this, napari shows every axis with an implicit scale of 1, so a
+    volume with anisotropic voxels (e.g. z coarser than x/y) renders with the
+    wrong aspect ratio and no real-world units.
+
+    Parameters
+    ----------
+    path : str or Path
+        OME-ZARR store path (image or label group) — each carries its own
+        ``multiscales`` metadata, so image and label stores are read
+        independently.
+    ndim : int
+        Number of spatial dimensions of the loaded array (2 -> "yx", 3 ->
+        "zyx"), used to align the calibration to the right axes.
+
+    Returns
+    -------
+    list of float or None
+        Physical size per axis, or ``None`` if the store carries no
+        calibration (napari then falls back to its uncalibrated default).
+    """
+    from .ome_zarr import _base_scale, _default_axes, _read_zarr_calibration
+
+    axes = _default_axes(ndim)
+    pixel_size = _read_zarr_calibration(str(path), axes)
+    return _base_scale(axes, pixel_size) if pixel_size else None
+
+
 def _inner_label_names(store: Union[str, Path]) -> list[str]:
     """List label images registered under an OME-ZARR's ``labels/`` group.
 
@@ -248,11 +278,14 @@ def view_in_napari(
     napari = _require_napari()
 
     img = _resolve_image(image, channel)
+    img_ndim = img[0].ndim if isinstance(img, list) else img.ndim
+    img_scale = _pyramid_scale(image, img_ndim) if _is_zarr(image) else None
     viewer = napari.Viewer()
     viewer.add_image(
         img,
         name=image_name,
         multiscale=isinstance(img, list),
+        scale=img_scale,
         **add_image_kwargs,
     )
 
@@ -288,16 +321,32 @@ def view_in_napari(
 
     if labels is not None:
         lab = _resolve_labels(labels, labels_component)
-        viewer.add_labels(lab, name=labels_name, **label_kwargs)
+        lab_ndim = lab[0].ndim if isinstance(lab, list) else lab.ndim
+        lab_scale = _pyramid_scale(labels, lab_ndim) if _is_zarr(labels) else None
+        viewer.add_labels(
+            lab,
+            name=labels_name,
+            multiscale=isinstance(lab, list),
+            scale=lab_scale,
+            **label_kwargs,
+        )
     elif _is_zarr(image):
         # No labels given → auto-overlay every label image stored inside the
         # OME-ZARR under labels/<name>/ (the default place tile_process writes
-        # them), each as its own multi-scale Labels layer.
+        # them), each as its own multi-scale Labels layer. Kept as a list (not
+        # unwrapped to a single array) even for one level, so napari always
+        # treats it as multiscale — required for 3D resolution switching, see
+        # https://napari.org/stable/gallery/add_multiscale_volume.html
         for name in _inner_label_names(image):
-            levels = _multiscale_levels(f"{image}/labels/{name}", None)
+            store = f"{image}/labels/{name}"
+            levels = _multiscale_levels(store, None)
             lab = [lvl.astype("int32") for lvl in levels]
             viewer.add_labels(
-                lab if len(lab) > 1 else lab[0], name=name, **label_kwargs
+                lab,
+                name=name,
+                multiscale=True,
+                scale=_pyramid_scale(store, lab[0].ndim),
+                **label_kwargs,
             )
             logger.info("auto-loaded labels/%s from %s", name, image)
 

{patchworks-0.11.15 → patchworks-0.11.17}/workflow/config/config.yaml

@@ -51,3 +51,7 @@ cellpose:
 pyramid_levels: 5
 pyramid_downscale: 2
 sequential_labels: true # renumber merged labels to a contiguous 1..N range
+
+# ---- merge performance --------------------------------------------------
+# null -> use the "merge" rule's actual cpus_per_task (profile/slurm/config.yaml).
+merge_workers: null

{patchworks-0.11.15 → patchworks-0.11.17}/workflow/profile/slurm/config.yaml

@@ -5,7 +5,13 @@
 # Edit the partitions / account / GPU request for your cluster.
 
 executor: slurm
-jobs: 64 # max concurrent SLURM jobs (≈ how many GPUs you can grab at once)
+# Max concurrent SLURM jobs Snakemake will have in flight at once. This is a
+# submission-side cap, not a cluster limit — raising it just lets more
+# "segment" tiles queue/run together; scicore's scheduler still enforces your
+# real GPU quota (MaxTRESPU) and backfills the rest, so it's safe to raise.
+# Check your actual per-user GPU cap with:
+#   sacctmgr show assoc user=$USER format=account,partition,maxjobs,GrpTRES
+jobs: 128
 latency-wait: 60
 rerun-incomplete: true
 # Only re-run when an output is missing/stale — NOT when the patchworks code,
@@ -26,8 +32,12 @@ default-resources:
 # Per-rule overrides.
 set-resources:
   convert:
+    # bioio/dask's default threaded scheduler uses every visible core, so
+    # this scales conversion for free. Verify actual scaling with `seff
+    # <jobid>` after a run and dial back if efficiency is low (scicore
+    # fair-share asks you not to sit on idle cores).
     mem_mb: 64000
-    cpus_per_task: 8
+    cpus_per_task: 32
     runtime: 360
   prepare:
     mem_mb: 32000
@@ -44,6 +54,8 @@ set-resources:
     cpus_per_task: 4
     runtime: 360 # 6 hours — must match the QOS, NOT 120 (=2h → killed early)
   merge:
+    # merge_tile_labels now uses n_workers = this allocation (see merge.py /
+    # config.yaml's merge_workers) instead of silently capping at 4 threads.
     mem_mb: 128000
-    cpus_per_task: 8
+    cpus_per_task: 32
     runtime: 240

{patchworks-0.11.15 → patchworks-0.11.17}/workflow/scripts/merge.py

@@ -5,6 +5,7 @@ boundaries, optionally renumbers them) and writes the result back into the
 image store under ``labels/<name>/`` as a calibrated, multi-scale pyramid.
 """
 
+import os
 import shutil
 from pathlib import Path
 
@@ -19,11 +20,17 @@ work_dir = cfg["work_dir"]
 image_store = str(Path(work_dir) / "image.zarr")
 merged_store = str(Path(work_dir) / "_merged.zarr")
 
+# merge_tile_labels defaults to min(4, cpu_count) workers, so it ignores
+# whatever cpus_per_task the "merge" rule was actually allocated in the SLURM
+# profile. Read the real allocation (SLURM_CPUS_PER_TASK) so the job uses all
+# the cores it's paying for; merge_workers: in config.yaml can still override.
+default_workers = int(os.environ.get("SLURM_CPUS_PER_TASK", os.cpu_count() or 4))
 merged = merge_tile_labels(
     stage_path(work_dir),
     write_to=merged_store,
     input_component="staged",
     sequential_labels=cfg.get("sequential_labels", True),
+    n_workers=cfg.get("merge_workers", default_workers),
     progress=False,
 )
 group = write_labels(
@@ -37,5 +44,10 @@ group = write_labels(
 
 shutil.rmtree(merged_store, ignore_errors=True)
 shutil.rmtree(stage_path(work_dir), ignore_errors=True)
+# Also drop the checkpoint's completion sentinel (stage.zarr.done): the
+# "prepare" rule's stage=touch(STAGE_OK) output must not outlive the store it
+# claims exists, or a future rerun (e.g. re-segmenting for new labels) skips
+# "prepare" and "segment" tries to open a stage.zarr that's already gone.
+Path(f"{stage_path(work_dir)}.done").unlink(missing_ok=True)
 print(f"[patchworks] labels written to {group}")
 open(snakemake.output[0], "w").close()  # noqa: F821