patchworks 0.11.20__tar.gz → 1.0.0__tar.gz

{patchworks-0.11.20 → patchworks-1.0.0}/.github/workflows/release.yml

@@ -48,17 +48,3 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
-
-  # Rebuild the org-wide pdoc apidocs site so it picks up the new version.
-  apidocs:
-    needs: release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger imcf.github.io apidocs rebuild
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          # Fine-grained PAT with "Contents: write" on imcf/imcf.github.io,
-          # stored as the APIDOCS_DISPATCH_TOKEN secret in this repo.
-          token: ${{ secrets.APIDOCS_DISPATCH_TOKEN }}
-          repository: imcf/imcf.github.io
-          event-type: dispatch-event

{patchworks-0.11.20 → patchworks-1.0.0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: patchworks
-Version: 0.11.20
+Version: 1.0.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
-Author: IMCF Basel
+Author-email: Laurent Guerard <laurent.guerard@unibas.ch>
 License: GPL-3.0-only
 License-File: LICENSE
 Keywords: bioimage,chunked,dask,image processing,segmentation,tiling,zarr
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3

{patchworks-0.11.20 → patchworks-1.0.0}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "Tiled processing of arbitrarily large images with globally consistent labels"
 readme = "README.md"
 license = { text = "GPL-3.0-only" }
-authors = [{ name = "IMCF Basel" }]
+authors = [{ name = "Laurent Guerard", email = "laurent.guerard@unibas.ch" }]
 keywords = [
     "image processing",
     "tiling",
@@ -19,7 +19,7 @@ keywords = [
     "bioimage",
 ]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
     "Programming Language :: Python :: 3",

{patchworks-0.11.20 → patchworks-1.0.0}/src/patchworks/_chunks.py

@@ -179,7 +179,7 @@ def auto_tile_shape(
     --------
     >>> tile = auto_tile_shape((128, 2048, 2048), "uint16")
     >>> tile
-    (8, 2048, 2048)
+    (128, 512, 512)
     """
     n_workers = n_workers or os.cpu_count() or 1
     itemsize = np.dtype(dtype).itemsize

{patchworks-0.11.20 → patchworks-1.0.0}/src/patchworks/_relabel.py

@@ -33,7 +33,7 @@ def relabel_sequential_array(labels: np.ndarray) -> np.ndarray:
     Examples
     --------
     >>> relabel_sequential_array(np.array([0, 500000, 500000, 7]))
-    array([0, 2, 2, 1])
+    array([0, 2, 2, 1], dtype=uint16)
     """
     uniq = np.unique(labels)
     max_label = int(uniq[-1])
@@ -53,11 +53,41 @@ def relabel_sequential_array(labels: np.ndarray) -> np.ndarray:
 
 
 def relabel_sequential_zarr(store_path: str, component: str = "labels") -> int:
-    """Relabel a written label zarr to contiguous ids, in place. Returns N.
+    """Relabel a written label zarr to contiguous ids, in place.
 
     Two-pass streaming algorithm — safe for arrays far larger than RAM.
-    Pass 1 collects unique ids (bounded memory: a set). Pass 2 applies the
-    lookup-table remap chunk by chunk.
+    Pass 1 collects unique ids (bounded memory: a Python ``set``, not the
+    voxels themselves). Pass 2 applies the lookup-table remap chunk by
+    chunk, writing back into the same store.
+
+    Parameters
+    ----------
+    store_path : str
+        Path to the zarr store containing the label array.
+    component : str, optional
+        Array name inside the store to relabel in place (default
+        ``"labels"``).
+
+    Returns
+    -------
+    int
+        Number of distinct objects (``N``); the array now holds ``1..N``
+        (background ``0`` unchanged).
+
+    Examples
+    --------
+    >>> import zarr
+    >>> root = zarr.open_group("staged.zarr", mode="w")  # doctest: +SKIP
+    >>> root.create_array(
+    ...     "labels", shape=(4, 4), chunks=(4, 4), dtype="int32"
+    ... )[:] = [
+    ...     [0, 500000, 500000, 0],
+    ...     [0, 0, 0, 7],
+    ...     [0, 0, 0, 0],
+    ...     [0, 0, 0, 0],
+    ... ]  # doctest: +SKIP
+    >>> relabel_sequential_zarr("staged.zarr")  # doctest: +SKIP
+    2
     """
     root = zarr.open_group(store_path, mode="r+")
     z = root[component]

{patchworks-0.11.20 → patchworks-1.0.0}/src/patchworks/plugins/ome_zarr.py

@@ -953,10 +953,41 @@ def add_pyramid(
     ``multiscales`` metadata. Existing calibration is preserved; pass
     *pixel_size* to set it.
 
+    Parameters
+    ----------
+    group_path : str or Path
+        Zarr group containing the full-resolution array at *base*.
+    base : str, optional
+        Component name of the existing full-resolution level (default
+        ``"0"``). Auto-detected from existing ``multiscales`` metadata if
+        present, overriding this.
+    axes : str, optional
+        One letter per axis, e.g. ``"zyx"``. ``None`` → inferred from
+        existing metadata, or from the array's dimensionality.
+    pixel_size : dict, tuple or None, optional
+        Physical voxel size in micrometers. ``None`` → read from the store's
+        existing calibration, if any.
+    n_levels : int, optional
+        Maximum number of levels including the existing full-resolution one
+        (default 5).
+    downscale : int, optional
+        Per-level X/Y downsampling factor (default 2).
+    chunks : tuple of int, optional
+        Chunk shape for the written levels. ``None`` → a bounded default.
+    shard : bool or tuple of int, optional
+        Sharding request (see :func:`to_ome_zarr`'s *shard*).
+    progress : bool, optional
+        Show a per-level dask progress bar (default ``True``).
+
     Returns
     -------
     str
         The path to the updated group.
+
+    Examples
+    --------
+    >>> add_pyramid("scan.zarr", n_levels=4)  # doctest: +SKIP
+    'scan.zarr'
     """
     if downscale < 2:
         raise ValueError("downscale must be >= 2")
@@ -1023,10 +1054,38 @@ def register_labels(
     ``labels/.zattrs``, and inherits the parent image's pixel calibration
     (unless *pixel_size* is given).
 
+    Parameters
+    ----------
+    image_store : str or Path
+        OME-ZARR store path containing the image this label belongs to.
+    name : str, optional
+        Label image name under ``labels/`` (default ``"labels"``).
+    axes : str, optional
+        One letter per axis. ``None`` → inferred from the label array.
+    pixel_size : dict, tuple or None, optional
+        Physical voxel size in micrometers. ``None`` → inherited from the
+        parent image's own calibration.
+    n_levels : int, optional
+        Maximum number of pyramid levels including full resolution
+        (default 5).
+    downscale : int, optional
+        Per-level X/Y downsampling factor (default 2).
+    chunks : tuple of int, optional
+        Chunk shape for the written levels. ``None`` → a bounded default.
+    shard : bool or tuple of int, optional
+        Sharding request (see :func:`to_ome_zarr`'s *shard*).
+    progress : bool, optional
+        Show a per-level dask progress bar (default ``True``).
+
     Returns
     -------
     str
         Path to the label group (``image_store/labels/<name>``).
+
+    Examples
+    --------
+    >>> register_labels("scan.zarr", "cells")  # doctest: +SKIP
+    'scan.zarr/labels/cells'
     """
     store = str(image_store)
     group = f"{store}/labels/{name}"
@@ -1078,10 +1137,49 @@ def write_labels(
     single OME-ZARR store. Calibration is inherited from the parent image
     unless *pixel_size* is given.
 
+    Parameters
+    ----------
+    image_store : str or Path
+        OME-ZARR store this label image belongs to.
+    labels : da.Array or np.ndarray
+        Integer label array (0 = background), same spatial shape as the
+        image.
+    name : str, optional
+        Label image name under ``labels/`` (default ``"labels"``).
+    axes : str, optional
+        One letter per axis. ``None`` → inferred from *labels*'
+        dimensionality.
+    pixel_size : dict, tuple or None, optional
+        Physical voxel size in micrometers. ``None`` → inherited from the
+        parent image's own calibration.
+    n_levels : int, optional
+        Maximum number of pyramid levels including full resolution
+        (default 5).
+    downscale : int, optional
+        Per-level X/Y downsampling factor (default 2).
+    chunks : tuple of int, optional
+        Chunk shape for the written levels. ``None`` → a bounded default.
+    shard : bool or tuple of int, optional
+        Sharding request (see :func:`to_ome_zarr`'s *shard*).
+    progress : bool, optional
+        Show a per-level dask progress bar (default ``True``).
+    overwrite : bool, optional
+        Replace an existing label image of the same *name* (default
+        ``False``).
+
     Returns
     -------
     str
         Path to the written label group (``image_store/labels/<name>``).
+
+    Examples
+    --------
+    >>> from patchworks import merge_tile_labels
+    >>> merged = merge_tile_labels(
+    ...     "stage.zarr", input_component="staged", write_to="merged.zarr"
+    ... )  # doctest: +SKIP
+    >>> write_labels("scan.zarr", merged, name="cells")  # doctest: +SKIP
+    'scan.zarr/labels/cells'
     """
     arr = labels if isinstance(labels, da.Array) else da.asarray(labels)
     if axes is None:

{patchworks-0.11.20 → patchworks-1.0.0}/tests/test_relations.py

@@ -17,7 +17,9 @@ def test_label_relations_majority_overlap():
     b[0:2, 6:8] = 21  # 4 voxels overlap with label 2 -> tie, but let's skew it
     b[0:2, 6:7] = 20  # tip the tie: label 20 now has 6 voxels vs 21's 2
 
-    table = label_relations(da.from_array(a, chunks=(2, 5)), da.from_array(b, chunks=(2, 5)))
+    table = label_relations(
+        da.from_array(a, chunks=(2, 5)), da.from_array(b, chunks=(2, 5))
+    )
 
     assert table[1]["match"] == 10
     assert table[1]["overlap_voxels"] == 4
@@ -32,7 +34,9 @@ def test_label_relations_no_overlap_omitted():
     a[0, 0] = 1
     b = np.zeros((2, 2), dtype=np.int32)  # all background, no overlap anywhere
 
-    table = label_relations(da.from_array(a, chunks=(2, 2)), da.from_array(b, chunks=(2, 2)))
+    table = label_relations(
+        da.from_array(a, chunks=(2, 2)), da.from_array(b, chunks=(2, 2))
+    )
     assert table == {}