patchworks 2.5.1__tar.gz → 2.6.0__tar.gz

{patchworks-2.5.1 → patchworks-2.6.0}/.gitignore

@@ -9,3 +9,6 @@ site/
 *.log
 .snakemake/
 .pixi/
+
+# graft's local graph cache — regenerable, not committed (run `graft build`).
+graft/

{patchworks-2.5.1 → patchworks-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchworks
-Version: 2.5.1
+Version: 2.6.0
 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
@@ -115,6 +115,13 @@ patchworks splits a large image into tiles, runs **any callable** on each
 tile in parallel, and merges the results into a globally consistent label array.
 It handles terabyte-scale images without loading them into memory.
 
+> [!NOTE]
+> **On how this was written.** Large parts of patchworks were vibe coded —
+> written with heavy LLM assistance rather than line by line. It is covered by
+> a test suite and has been run on real data, so it is not untested, but the
+> usual caveats apply: read the code before you trust it with anything
+> irreplaceable, and please open an issue if something looks off.
+
 ---
 
 ## Installation

{patchworks-2.5.1 → patchworks-2.6.0}/README.md

@@ -25,6 +25,13 @@ patchworks splits a large image into tiles, runs **any callable** on each
 tile in parallel, and merges the results into a globally consistent label array.
 It handles terabyte-scale images without loading them into memory.
 
+> [!NOTE]
+> **On how this was written.** Large parts of patchworks were vibe coded —
+> written with heavy LLM assistance rather than line by line. It is covered by
+> a test suite and has been run on real data, so it is not untested, but the
+> usual caveats apply: read the code before you trust it with anything
+> irreplaceable, and please open an issue if something looks off.
+
 ---
 
 ## Installation

{patchworks-2.5.1 → patchworks-2.6.0}/docs/guide/snakemake.md

@@ -53,7 +53,8 @@ convert_chunks: null           # null → bounded auto chunks; or [c,z,y,x]
 shard: false                   # true → pack chunks into shards (fewer files)
 
 # tiling
-channel: 0                     # channel to segment (null = keep all)
+channel: 0                     # channel to segment, 0-based (null = keep all)
+nuclei_channel: null           # optional 2nd channel for Cellpose (see below)
 level: 0                       # pyramid level (0 = full resolution)
 tile_shape: "auto"             # "auto", or e.g. [16, 1024, 1024] (zyx)
 gpu_memory_gb: null            # for "auto" on SLURM: your segment GPU's VRAM
@@ -299,6 +300,7 @@ cellpose:
 # config/config_cyto.yaml — only the differences
 label_name: "cyto_labels"
 channel: 0                # cytoplasm/membrane channel
+nuclei_channel: 1         # optional: nuclear stain, as Cellpose's 2nd input
 overlap: [4, 30, 30]
 method: "cellpose"
 cellpose:
@@ -307,6 +309,29 @@ cellpose:
   do_3D: true
 ```
 
+### Giving Cellpose a nuclei channel
+
+`nuclei_channel` hands Cellpose a second channel — the nuclear stain — which
+usually improves cytoplasm segmentation. Both indices are 0-based, like
+`channel`.
+
+Only the `segment` step reads it. The pair is stacked on a leading axis that
+is *carried* into each tile rather than tiled, so the tile geometry, the
+occupancy map and the staged labels are byte-for-byte what a single-channel
+run produces, and `merge` and `label_relations` need no changes. Two things
+follow from that:
+
+- A tile holds twice the bytes, so a hand-set `tile_shape` sized to fill a GPU
+  may need halving. `tile_shape: "auto"` sizes from the single-channel array
+  and does not yet know about the pair.
+- The translation is version-specific. Cellpose 3 gets `channels: [1, 2]`
+  (1-based into the channel axis, `0` = grayscale); Cellpose 4 (cpsam) dropped
+  `channels` entirely and simply reads both. Either is overridable by setting
+  `channels:` or `channel_axis:` in the `cellpose:` block.
+
+`nuclei_channel` applies to the SLURM/Snakemake path. The single-process
+`tile_process` API still takes one `channel`.
+
 Run them as two independent SLURM submissions — they touch disjoint files, so
 they can run concurrently. Give each its own `--directory`, because
 Snakemake's lock lives in the working directory, not in the config:
@@ -475,6 +500,24 @@ These cover what SLURM cannot: a local run with no scheduler at all, and
 failures where the useful content is the Python traceback rather than an exit
 code.
 
+Check it works without waiting for a multi-hour step:
+
+```bash
+python scripts/run_multi.py --config config/multi.yaml --test-email
+```
+
+It prints the address it actually resolved from the merged config, the exact
+`sbatch` flags the jobs will carry, and whether a test message was accepted —
+which separates "the address never reached the config" from "it did and the
+mail was dropped downstream". Those look identical otherwise: no email either
+way.
+
+!!! warning "No mail from `segment`"
+    `segment` is excluded on purpose, so a run that is only segmenting tiles
+    sends nothing. Mail comes from `convert`, `occupancy` and `merge`, plus
+    the workflow-level success/failure message — if those already completed
+    before you set the address, there is nothing left in the run to mail you.
+
 !!! note "Delivery is best-effort, by design"
     A notification can never fail a run. If no local `sendmail` exists and no
     SMTP server answers on localhost, the failure is logged as a warning and

{patchworks-2.5.1 → patchworks-2.6.0}/src/patchworks/_distributed.py

@@ -166,6 +166,7 @@ def stage_tile(
     tile_shape: tuple[int, ...],
     overlap: Overlap = 0,
     component: str = "staged",
+    channel_axis: int | None = None,
 ) -> int:
     """Run *fn* on a single tile and write it into the shared stage store.
 
@@ -192,6 +193,13 @@ def stage_tile(
         :func:`normalize_overlap`).
     component : str, optional
         Array name inside the stage store.
+    channel_axis : int or None, optional
+        Axis of *image* holding channels, which is **not** tiled: it is read
+        whole and handed to *fn* alongside the tile's voxels. ``tile_shape``,
+        ``overlap`` and the stage store stay purely spatial, so *fn* still
+        returns one label per voxel with no channel axis (e.g. Cellpose fed a
+        cytoplasm + nuclei pair returns a single label volume). ``None`` (the
+        default) means *image* is already single-channel.
 
     Returns
     -------
@@ -202,18 +210,30 @@ def stage_tile(
         by a cumulative sum, instead of rewriting the whole store to make the
         ids unique.
     """
-    shape = image.shape
-    sl = spatial_tiles(shape, tile_shape)[index]
+    shape = tuple(image.shape)
+    # The channel axis is carried, not tiled: geometry (tiles, halo, the stage
+    # store) stays spatial, so nothing downstream of fn learns about channels.
+    if channel_axis is None:
+        spatial_shape = shape
+    else:
+        channel_axis %= len(shape)
+        spatial_shape = shape[:channel_axis] + shape[channel_axis + 1 :]
+    sl = spatial_tiles(spatial_shape, tile_shape)[index]
     halo = normalize_overlap(overlap, len(sl), tile_shape=tile_shape)
     expanded, trims = [], []
-    for s, dim, ov in zip(sl, shape, halo):
+    for s, dim, ov in zip(sl, spatial_shape, halo):
         lo = max(0, s.start - ov)
         hi = min(dim, s.stop + ov)
         expanded.append(slice(lo, hi))
         trims.append((s.start - lo, hi - s.stop))
-    block = np.asarray(image[tuple(expanded)])
+    read = list(expanded)
+    if channel_axis is not None:
+        read.insert(channel_axis, slice(None))
+    block = np.asarray(image[tuple(read)])
+    # What fn owes us back: one label per voxel, channel axis consumed.
+    block_spatial = tuple(e.stop - e.start for e in expanded)
     out = np.asarray(fn(block))
-    if out.shape != block.shape:
+    if out.shape != block_spatial:
         # Caught here rather than 6 frames deep in zarr's codec pipeline as
         # "could not broadcast input array from shape (13,1020,1020) into
         # shape (14,1024,1024)", which says nothing about which function is
@@ -224,7 +244,7 @@ def stage_tile(
         name = getattr(fn, "__name__", type(fn).__name__)
         raise ValueError(
             f"segmentation function {name!r} returned shape {out.shape} for "
-            f"a tile of shape {block.shape} (tile {index}). It must return "
+            f"a tile of shape {block_spatial} (tile {index}). It must return "
             "one label per input voxel. Some deconvolution backends crop "
             "their output -- pad or centre it back to the input shape before "
             "returning."

{patchworks-2.5.1 → patchworks-2.6.0}/src/patchworks/_io.py

@@ -95,7 +95,61 @@ def load_ome_zarr(
 
     arr = da.from_zarr(str(store_path), component=path, chunks=zarr_chunks)
     if channel is not None:
-        arr = arr[channel]
+        arr = _select_channel(arr, channel, _ms[0], store_path)
+    return arr
+
+
+def _select_channel(arr, channel: int, multiscale: dict, store_path):
+    """Index *arr*'s channel axis, or leave it alone when there isn't one.
+
+    ``arr[channel]`` used to be applied unconditionally, so on a
+    single-channel store written as plain ``zyx`` the default ``channel: 0``
+    silently sliced away **z** instead. The result stayed a valid array, just
+    one dimension short, and surfaced much later as a tile-count mismatch
+    against the occupancy grid rather than as anything about channels.
+
+    Parameters
+    ----------
+    arr : da.Array
+        The full array as stored.
+    channel : int
+        Requested channel index.
+    multiscale : dict
+        The store's multiscales entry, read for its ``axes``.
+    store_path : str or Path
+        Only used in messages.
+
+    Returns
+    -------
+    da.Array
+        *arr* with the channel axis indexed away, or unchanged when the store
+        has no channel axis and channel 0 was requested.
+    """
+    axes = [
+        (a.get("name") if isinstance(a, dict) else a) or ""
+        for a in (multiscale.get("axes") or [])
+    ]
+    if "c" in axes:
+        idx = axes.index("c")
+        return arr[(slice(None),) * idx + (channel,)]
+
+    # No axes metadata: fall back to shape. A 4-D array is c,z,y,x by the
+    # convention this package writes; a 3-D one is z,y,x.
+    if not axes and arr.ndim >= 4:
+        return arr[channel]
+
+    if channel:
+        raise ValueError(
+            f"channel={channel} was requested but {store_path!r} has no "
+            f"channel axis (axes={axes or 'unknown'}, shape={arr.shape}). "
+            "Set channel: null in the config for a single-channel image."
+        )
+    logger.info(
+        "%s has no channel axis; ignoring channel=0 and using the whole "
+        "array (shape %s).",
+        store_path,
+        arr.shape,
+    )
     return arr
 
 

{patchworks-2.5.1 → patchworks-2.6.0}/src/patchworks/_notify.py

@@ -14,6 +14,7 @@ turn a real error into a confusing one about email.
 from __future__ import annotations
 
 import logging
+import re
 import shutil
 import socket
 import subprocess
@@ -155,3 +156,44 @@ def slurm_mail_extra(
     # Keep SLURM's own order, not the config's, so the string is stable.
     types = [mapping[k] for k in ("start", "finish", "error") if k in chosen]
     return f"--mail-type={','.join(types)} --mail-user={email}"
+
+
+def failing_step(
+    snakemake_log: Union[str, Path, None],
+) -> "tuple[Union[str, None], Union[str, None]]":
+    """Find which rule failed, and its log, from Snakemake's own log file.
+
+    Guessing from step-log timestamps does not work: a `segment` failure
+    leaves `prepare.log` as the most recently written of the sequential
+    steps, so a mail built that way quotes a log that *succeeded* and names
+    the wrong step. Snakemake records the failing rule and the exact log path
+    it used, so read that instead.
+
+    Parameters
+    ----------
+    snakemake_log : str or Path or None
+        Path to Snakemake's own log (the ``log`` variable inside an
+        ``onerror`` handler).
+
+    Returns
+    -------
+    tuple
+        ``(rule_name, log_path)``, either of which may be None when the log
+        is unreadable or records no rule error.
+    """
+    try:
+        text = Path(snakemake_log).read_text(errors="replace")
+    except (OSError, TypeError, ValueError):
+        return None, None
+
+    blocks = text.split("Error in rule ")
+    if len(blocks) < 2:
+        return None, None
+    last = blocks[-1]
+    rule = re.match(r"(\S+?):", last)
+    # The log: line inside that error block points at the step's own log.
+    path = re.search(r"^\s*log:\s*(\S+?)(?:,|\s|$)", last, re.M)
+    return (
+        rule.group(1) if rule else None,
+        path.group(1) if path else None,
+    )

{patchworks-2.5.1 → patchworks-2.6.0}/src/patchworks/plugins/cellpose.py

@@ -161,9 +161,13 @@ def _make_config(
     gpu : bool
         Run on the GPU.
     channels : list of int or None
-        Cellpose-3 ``[cyto, nucleus]`` channels; defaults to ``[0, 0]``.
+        *Cellpose 3 only.* ``[cyto, nucleus]``, 1-based into the channel axis
+        (0 = grayscale). ``None`` resolves per tile: ``[1, 2]`` when the tile
+        carries two channels, else ``[0, 0]``. Cellpose 4 dropped this
+        argument, so it is ignored there.
     channel_axis : int or None
-        Cellpose-4 channel axis.
+        Axis of the tile holding channels, forwarded to ``eval`` for both
+        Cellpose 3 and 4. ``None`` means single-channel tiles.
     diameter : float or None
         Expected cell diameter in pixels.
     do_3D : bool
@@ -179,7 +183,9 @@ def _make_config(
     return {
         "model": model,
         "gpu": gpu,
-        "channels": channels if channels is not None else [0, 0],
+        # Left as None ("auto") rather than [0, 0]: _run only knows how many
+        # channels a tile actually carries once it has one in hand.
+        "channels": channels,
         "channel_axis": channel_axis,
         "diameter": diameter,
         "do_3D": do_3D,
@@ -284,37 +290,50 @@ def _run(block: np.ndarray, cellpose_dict: dict[str, Any]) -> np.ndarray:
         Integer (``int32``) label array of the same spatial shape.
     """
     do_3D = cellpose_dict["do_3D"]
+    channel_axis = cellpose_dict.get("channel_axis")
+    n_channels = block.shape[channel_axis] if channel_axis is not None else 1
+
+    kwargs: dict[str, Any] = dict(
+        channel_axis=channel_axis,
+        diameter=cellpose_dict["diameter"],
+        do_3D=do_3D,
+        **cellpose_dict.get("cellpose_kwargs", {}),
+    )
+    if not _CELLPOSE_V4:
+        # Cellpose 4 (cpsam) dropped `channels` and reads whatever channels
+        # the array carries; Cellpose 3 needs the cyto/nucleus pairing named.
+        channels = cellpose_dict.get("channels")
+        if channels is None:
+            channels = [1, 2] if n_channels >= 2 else [0, 0]
+        kwargs["channels"] = channels
 
-    if _CELLPOSE_V4:
-        kwargs: dict[str, Any] = dict(
-            channel_axis=cellpose_dict.get("channel_axis"),
-            diameter=cellpose_dict["diameter"],
-            do_3D=do_3D,
-            **cellpose_dict.get("cellpose_kwargs", {}),
-        )
-    else:
-        kwargs = dict(
-            channels=cellpose_dict["channels"],
-            diameter=cellpose_dict["diameter"],
-            do_3D=do_3D,
-            **cellpose_dict.get("cellpose_kwargs", {}),
-        )
+    # Where z sits once the channel axis is accounted for.
+    z_axis = 1 if channel_axis == 0 else 0
 
     if do_3D:
-        kwargs["z_axis"] = 0
+        kwargs["z_axis"] = z_axis
         masks = _eval_with_oom_fallback(block, kwargs, cellpose_dict)
         return masks.astype("int32")
     else:
         # Squeeze singleton z so Cellpose gets a clean 2-D image
-        squeeze = block.ndim == 3 and block.shape[0] == 1
-        if block.ndim == 3 and not squeeze:
+        spatial = list(block.shape)
+        if channel_axis is not None:
+            spatial.pop(channel_axis)
+        squeeze = len(spatial) == 3 and spatial[0] == 1
+        if len(spatial) == 3 and not squeeze:
             raise ValueError(
-                f"do_3D is False but this tile has {block.shape[0]} z-planes. "
+                f"do_3D is False but this tile has {spatial[0]} z-planes. "
                 "Cellpose would receive the stack with no z_axis and treat "
                 "the leading axis as channels. Set do_3D: true, or tile with "
                 "z=1 to segment plane by plane."
             )
-        img = block[0] if squeeze else block
+        if squeeze:
+            img = block[(slice(None),) * z_axis + (0,)]
+            # Dropping z shifts any channel axis that sat behind it.
+            if channel_axis is not None and channel_axis > z_axis:
+                kwargs["channel_axis"] = channel_axis - 1
+        else:
+            img = block
         masks = _eval_with_oom_fallback(img, kwargs, cellpose_dict)
         masks = masks.astype("int32")
         return masks[np.newaxis] if squeeze else masks

{patchworks-2.5.1 → patchworks-2.6.0}/src/patchworks/plugins/napari.py

@@ -406,21 +406,57 @@ def view_in_napari(
         # 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):
-            store = f"{image}/labels/{name}"
-            levels = _multiscale_levels(store, None)
-            lab = [lvl.astype("int32") for lvl in levels]
-            lab_scale, lab_units = _pyramid_calibration(store, lab[0].ndim)
-            viewer.add_labels(
-                lab,
-                name=name,
-                multiscale=True,
-                scale=lab_scale,
-                units=lab_units,
-                metadata=_label_hint(store),
-                **label_kwargs,
+        names = _inner_label_names(image)
+        if not names:
+            logger.warning(
+                "%s has no label images under labels/, so nothing was "
+                "overlaid. Pass labels=<path> explicitly if they live "
+                "somewhere else.",
+                image,
+            )
+        else:
+            logger.info(
+                "auto-loading %d label image(s) from %s/labels: %s",
+                len(names),
+                image,
+                ", ".join(names),
             )
+        loaded = 0
+        for name in names:
+            store = f"{image}/labels/{name}"
+            # Guarded per label: without this, one bad label group raised
+            # *after* the image had been added, so the viewer opened showing
+            # the image alone and every remaining label was skipped -- which
+            # looks exactly like "there were no labels".
+            try:
+                levels = _multiscale_levels(store, None)
+                lab = [lvl.astype("int32") for lvl in levels]
+                lab_scale, lab_units = _pyramid_calibration(store, lab[0].ndim)
+                viewer.add_labels(
+                    lab,
+                    name=name,
+                    multiscale=True,
+                    scale=lab_scale,
+                    units=lab_units,
+                    metadata=_label_hint(store),
+                    **label_kwargs,
+                )
+            except Exception:
+                logger.exception(
+                    "could not add labels/%s as a layer; skipping it and "
+                    "continuing with the rest.",
+                    name,
+                )
+                continue
+            loaded += 1
             logger.info("auto-loaded labels/%s from %s", name, image)
+        if names and not loaded:
+            logger.error(
+                "found %d label image(s) in %s/labels but none could be "
+                "added -- see the errors above.",
+                len(names),
+                image,
+            )
 
     if show:
         napari.run()

{patchworks-2.5.1 → patchworks-2.6.0}/tests/test_core.py

@@ -357,3 +357,35 @@ def test_tile_process_max_workers():
     arr = da.from_array(_make_image((2, 32, 32)), chunks=(1, 32, 32))
     result = tile_process(arr, _label_fn, max_workers=1).compute()
     assert result.shape == (2, 32, 32)
+
+
+def test_channel_selection_respects_the_stores_axes(tmp_path):
+    """`channel: 0` on a store with no channel axis must not slice away z.
+
+    arr[channel] was applied unconditionally, so a single-channel image
+    written as plain zyx silently lost its z axis. The array stayed valid,
+    just one dimension short, and only surfaced later as a tile count that
+    disagreed with the occupancy grid.
+    """
+    import dask.array as da
+    import pytest
+
+    from patchworks import load_ome_zarr
+    from patchworks.plugins.ome_zarr import to_ome_zarr
+
+    vol = da.zeros((8, 64, 64), chunks=(4, 32, 32), dtype="uint16")
+    store = str(tmp_path / "zyx.zarr")
+    to_ome_zarr(vol, store, axes="zyx", n_levels=1, progress=False)
+
+    # channel 0 on a zyx store: keep the whole volume, do not index axis 0.
+    assert load_ome_zarr(store, channel=0, level=0).shape == (8, 64, 64)
+    assert load_ome_zarr(store, channel=None, level=0).shape == (8, 64, 64)
+    # A non-zero channel really is a mistake here, and is named as one.
+    with pytest.raises(ValueError, match="no channel axis"):
+        load_ome_zarr(store, channel=2, level=0)
+
+    # A czyx store still selects the channel as before.
+    vol4 = da.zeros((3, 8, 64, 64), chunks=(1, 4, 32, 32), dtype="uint16")
+    store4 = str(tmp_path / "czyx.zarr")
+    to_ome_zarr(vol4, store4, axes="czyx", n_levels=1, progress=False)
+    assert load_ome_zarr(store4, channel=1, level=0).shape == (8, 64, 64)

{patchworks-2.5.1 → patchworks-2.6.0}/tests/test_distributed.py

@@ -399,3 +399,96 @@ def test_separate_objects_keep_distinct_labels(tmp_path):
     ids = np.unique(merged[merged > 0])
     assert ids.size == 4, f"expected 4 distinct objects, got {ids.size}"
     assert set(ids.tolist()) == {1, 2, 3, 4}  # contiguous after relabel
+
+
+def test_stage_tile_carries_a_channel_axis(tmp_path):
+    """A channel axis reaches fn but is never tiled.
+
+    Cellpose's cyto+nucleus pair: tile geometry, the halo and the stage store
+    all stay purely spatial, so fn sees ``(2, z, y, x)`` and owes back
+    ``(z, y, x)``. Without this, a second channel would either be tiled like a
+    spatial axis or trip stage_tile's shape check.
+    """
+    import numpy as np
+    import zarr
+
+    from patchworks import create_stage, stage_tile
+
+    # Channel 0 carries the signal, channel 1 is blank -- so a swapped or
+    # collapsed channel axis fails rather than quietly segmenting the wrong one.
+    img = np.stack(
+        [
+            np.arange(4 * 8 * 8).reshape(4, 8, 8) % 5,
+            np.zeros((4, 8, 8), dtype=int),
+        ]
+    )
+    assert img.shape == (2, 4, 8, 8)
+
+    tile_shape = (4, 4, 4)
+    stage = create_stage(tmp_path / "s.zarr", (4, 8, 8), tile_shape)
+
+    seen = {}
+
+    def fn(block):
+        seen["shape"] = block.shape
+        assert not block[1].any(), "channel 1 should be the blank one"
+        return (block[0] > 2).astype("int32")
+
+    n = stage_tile(
+        img,
+        fn,
+        stage,
+        0,
+        tile_shape=tile_shape,
+        overlap=1,
+        channel_axis=0,
+    )
+
+    # z is already the full extent, y/x grow by the 1-voxel halo.
+    assert seen["shape"] == (2, 4, 5, 5)
+    assert n == 1
+    staged = zarr.open_group(str(stage))["staged"][:]
+    assert staged.shape == (4, 8, 8)  # store never learned about channels
+    assert staged[:, :4, :4].any()  # the tile actually landed
+
+
+def test_cellpose_run_pairs_channels_and_shifts_z(monkeypatch):
+    """A 2-channel tile must set z_axis past the channel axis.
+
+    With channels stacked on axis 0, z moves to axis 1; leaving z_axis=0 would
+    tell Cellpose the channel axis is z. Cellpose 3 also needs the pair named
+    as ``channels=[1, 2]`` (1-based, 0 = grayscale), which Cellpose 4 dropped.
+    """
+    import numpy as np
+
+    from patchworks.plugins import cellpose as cp
+
+    calls = {}
+
+    class _FakeModel:
+        def eval(self, img, **kwargs):
+            calls["img_shape"] = img.shape
+            calls["kwargs"] = kwargs
+            return np.zeros(img.shape[1:], dtype="int32"), None
+
+    monkeypatch.setattr(cp, "_get_model", lambda _cfg: _FakeModel())
+
+    cfg = cp._make_config("cyto3", diameter=30, do_3D=True, channel_axis=0)
+    block = np.zeros((2, 4, 8, 8), dtype="uint16")
+    out = cp._run(block, cfg)
+
+    assert out.shape == (4, 8, 8)  # labels come back spatial
+    assert calls["kwargs"]["z_axis"] == 1
+    assert calls["kwargs"]["channel_axis"] == 0
+    if cp._CELLPOSE_V4:
+        assert "channels" not in calls["kwargs"]
+    else:
+        assert calls["kwargs"]["channels"] == [1, 2]
+
+    # Single-channel tiles keep the old geometry and grayscale pairing.
+    cfg1 = cp._make_config("cyto3", diameter=30, do_3D=True)
+    cp._run(np.zeros((4, 8, 8), dtype="uint16"), cfg1)
+    assert calls["kwargs"]["z_axis"] == 0
+    assert calls["kwargs"]["channel_axis"] is None
+    if not cp._CELLPOSE_V4:
+        assert calls["kwargs"]["channels"] == [0, 0]

{patchworks-2.5.1 → patchworks-2.6.0}/tests/test_notify.py

@@ -73,3 +73,38 @@ def test_log_tail_quotes_the_end_and_survives_a_missing_file(tmp_path):
     assert "could not read" in log_tail(tmp_path / "nope.log")
     (tmp_path / "empty.log").write_text("")
     assert "empty" in log_tail(tmp_path / "empty.log")
+
+
+def test_failing_step_reads_the_rule_from_snakemakes_log(tmp_path):
+    """The failing rule must come from Snakemake, not from log timestamps.
+
+    Guessing by mtime named the wrong step in the most common case: a
+    `segment` failure leaves prepare.log the newest of the sequential steps,
+    so the failure mail quoted a log that had *succeeded*.
+    """
+    from patchworks._notify import failing_step
+
+    log = tmp_path / "sm.log"
+    log.write_text(
+        "Building DAG of jobs...\n"
+        "[Wed Jul 30 11:17:20 2026]\n"
+        "Error in rule segment:\n"
+        "    jobid: 812\n"
+        "    output: seg/203.done\n"
+        "    log: /w/nuclei_labels/logs/segment/203.log (check log file(s))\n"
+    )
+    assert failing_step(log) == (
+        "segment",
+        "/w/nuclei_labels/logs/segment/203.log",
+    )
+
+
+def test_failing_step_degrades_quietly(tmp_path):
+    """It runs inside an error handler, so it must never raise itself."""
+    from patchworks._notify import failing_step
+
+    assert failing_step(None) == (None, None)
+    assert failing_step(tmp_path / "missing.log") == (None, None)
+    clean = tmp_path / "ok.log"
+    clean.write_text("Building DAG of jobs...\n3 of 3 steps (100%) done\n")
+    assert failing_step(clean) == (None, None)