pyrametric 0.0.1__tar.gz

pyrametric-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bugra Oezdemir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrametric-0.0.1/PKG-INFO

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: pyrametric
+Version: 0.0.1
+Summary: Lazy, memory-bounded connected-components labeling and per-object measurement for OME-Zarr pyramids: label pyramids (from a mask), regionprops-like feature extraction, and label filtering (pyrops plugin; wraps tilewise-ccl)
+Author-email: Bugra Oezdemir <bugraa.ozdemir@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/bugraoezdemir/pyrametric
+Keywords: ome-zarr,ngff,connected-components,labeling,segmentation,regionprops,image-pyramid,bioimage,microscopy,out-of-core
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tilewise-ccl>=0.0.4
+Requires-Dist: ome_zarr_pyramid>=0.0.7
+Requires-Dist: scipy
+Requires-Dist: numpy
+Requires-Dist: dask
+Requires-Dist: zarr
+Provides-Extra: dyna
+Requires-Dist: ome_zarr_pyramid[dyna]>=0.0.7; extra == "dyna"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pandas; extra == "dev"
+Requires-Dist: dyna-zarr>=0.0.6; extra == "dev"
+Dynamic: license-file
+
+# pyrametric
+
+Lazy, memory-bounded **connected-components labeling and per-object
+measurement** for OME-Zarr pyramids, with OME-NGFF label-image output.
+
+`pyrametric` is the OME-Zarr-aware layer over [`tilewise-ccl`](../tilewise-ccl): it
+labels the level-0 binary mask of a `Pyramid`, propagates the labels down the
+resolution levels, measures per-object features, and writes the result as a
+spec-compliant NGFF **label image** (`labels/<name>/` with `image-label`
+metadata). It works on already-segmented masks — thresholding/segmentation
+lives in [`pyrops`](../pyrops). It provides:
+
+- **`label_pyramid`** — label a mask `Pyramid` → a lazy, writable label
+  `Pyramid` (optionally with a per-object properties table).
+- **`extract_features`** / **`ObjectFeatures`** — regionprops-like per-object
+  measurement (area, bbox, moments, physical units, ...) over a label pyramid,
+  computed lazily and memory-bounded (validated against skimage in 2D and 3D).
+- **`write_label_pyramid`** — write a label pyramid as an OME-Zarr label image
+  (colors, properties, `source` back-reference; default `labels/<name>/`
+  location).
+- **`label_array`** — re-exported from `tilewise-ccl` for array-level labeling.
+
+The heavy lifting (fast tile-wise connected components, memory-bounded, exact,
+returning a lazy dask array) lives in `tilewise-ccl`; this package adds the
+pyramid, axis-handling, measurement, and NGFF I/O concerns on top.
+
+---
+
+## Installation
+
+```bash
+pip install pyrametric
+# or, from a checkout:
+pip install -e .
+```
+
+Depends on `tilewise-ccl`, `ome_zarr_pyramid`, plus `numpy`/`scipy`/`dask`/`zarr`.
+
+---
+
+## Quick start
+
+The input's level 0 must already be a **binary mask** (background 0 + one
+foreground value) — there is no thresholding here (binarize beforehand).
+
+```python
+from ome_zarr_pyramid.core.io import IO
+from pyrametric import label_pyramid, write_label_pyramid
+
+io = IO()
+mask_pyr = io.read_pyramid("mask.zarr")           # level 0 = a binary mask
+
+# label + propagate down the pyramid -> a lazy, writable label Pyramid
+label_pyr = label_pyramid(mask_pyr, connectivity=2, n_workers=8)
+
+# ...write it as a plain multiscale array,
+io.write_pyramid(label_pyr, "labels.zarr", overwrite=True)
+```
+
+### With properties + an OME-Zarr label image
+
+```python
+# also measure per-object properties (area + bounding box) - FREE from the labeling
+# metadata pass; they are stamped onto the returned pyramid's image-label metadata
+label_pyr = label_pyramid(mask_pyr, properties=True, n_workers=8)
+
+# write a spec-compliant label image under the source's labels/ group:
+#   mask.zarr/labels/cells/   (multiscales + image-label: colors, properties, source)
+write_label_pyramid(label_pyr, source="mask.zarr", name="cells")
+```
+
+### Attaching labels to the source image, written together
+
+`Pyramid.add_image_label` attaches a label pyramid to its source **image** pyramid,
+so the two travel together and a single `write_pyramid` emits the image plus its
+`labels/<name>/` sub-group in one OME-Zarr store — the common "image + its
+segmentation, side by side" layout that viewers open as one dataset:
+
+```python
+image_pyr = io.read_pyramid("image.zarr")     # the intensity image
+mask_pyr  = io.read_pyramid("mask.zarr")       # its binary mask (segment/threshold upstream)
+
+# label the mask, build its multiscale, name it, then attach it to the image
+label_pyr = label_pyramid(mask_pyr, properties=True).downscale().rename("cells")
+combined  = image_pyr.add_image_label(label_pyr, name="cells")
+
+io.write_pyramid(combined, "image_with_labels.zarr", overwrite=True)
+```
+
+### Labeling a sub-region
+
+To label only part of the image, select it first with `Pyramid.isel` (any axis,
+int/slice/list) — the label matches that sub-region's geometry:
+
+```python
+label_pyr = label_pyramid(mask_pyr.isel(c=1, z=slice(100, 150)))
+```
+
+---
+
+## API
+
+### `label_pyramid(pyramid, tile_shape=None, connectivity=2, n_workers=1, properties=False, verbose=False)`
+
+Label a binary-mask `Pyramid`'s level 0 and propagate the labels down the
+resolution levels (nearest-neighbour / stride downsampling — the correct choice
+for categorical labels). To label a sub-region, select it first with
+`Pyramid.isel` (e.g. `mask.isel(c=1, z=slice(100, 150))`).
+
+**Returns** a lazy label `Pyramid` (dtype int32 unless the object count exceeds
+int32), mirroring the source's axes, units, per-level shapes and scales. With
+`properties=True` the same pyramid additionally carries its OME `image-label`
+metadata (per-object colors + an area/bbox properties table), so it is write-ready.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `pyramid` | `Pyramid` | — | Source pyramid; level 0 is a **binary mask** (not validated — see [Notes](#notes)). Axes may be any subset of `tczyx`. |
+| `tile_shape` | sequence of int | `None` | Tile size for `tilewise-ccl`, one entry per **spatial** axis. `None` → `(303,) * n_spatial`. |
+| `connectivity` | int | `2` | Spatial `scipy.ndimage` connectivity (2D: 1=4-, 2=8-conn; 3D: 1=6-, 2=18-, 3=26-conn). |
+| `n_workers` | int | `1` | Threads for each labeling metadata pass. |
+| `properties` | bool | `False` | Also measure per-object `area` + `bbox` (free from the labeling pass) and stamp them onto the returned pyramid's `image-label` metadata (colors + properties). The return type is unchanged — always a `Pyramid`. |
+| `verbose` | bool | `False` | Forwarded to `tilewise-ccl.label_array`. |
+
+When `properties=True`, `label_pyramid` measures each object's **`area`** (voxel
+count) and **`bbox`** (half-open bounding box, per axis, in the label's own
+coordinates) and stamps them onto the returned pyramid's `image-label` metadata
+(alongside deterministic per-object `colors`), so it is write-ready. For richer
+per-object measurement (intensity / physical / shape features, filtering) pass the
+label pyramid to `extract_features(...)`.
+
+### `write_label_pyramid(label_pyramid, source=None, name="labels_0", output=None, write_colors=True, write_props=True, overwrite=False, **write_kwargs)`
+
+Write a label pyramid as an OME-Zarr **label image**, serialising the `image-label`
+metadata already on the pyramid (built by `label_pyramid(..., properties=True)` or
+`Pyramid.set_image_label`). This writer only persists it — it does not measure.
+Returns the path written.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `label_pyramid` | `Pyramid` | — | The label pyramid, carrying its `image-label` metadata. |
+| `source` | str \| Path \| `Pyramid` | `None` | The source image the labels belong to. **Required when `output` is None**: labels go to `<source>/labels/<name>/`, registered in the source's `labels` group, with `image-label.source.image = "../../"`. |
+| `name` | str | `"labels_0"` | Label-image name (the `labels/<name>` subgroup). |
+| `output` | str \| Path | `None` | Explicit output path; overrides the default `labels/<name>` location (written standalone). |
+| `write_colors` | bool | `True` | Include the pyramid's `colors` in the written metadata; `False` drops that key at write time (a lighter write for a very large object count). |
+| `write_props` | bool | `True` | Include the pyramid's `properties` table (`label-value`, `area (pixels)`, `object-coordinates`); `False` drops it at write time. |
+| `overwrite` | bool | `False` | Overwrite an existing label image. |
+| `**write_kwargs` | | | Forwarded to `IO.write_labels` / `write_pyramid` (backend, workers, ...). |
+
+The emitted `image-label` metadata (OME-NGFF
+[labels spec](https://ngff.openmicroscopy.org/specifications/0.5/index.html#labels-metadata))
+contains `version`, `colors` (`{label-value, rgba}`), `properties`
+(`{label-value, "area (pixels)", "object-coordinates": {axis: [start, stop]}}`),
+and `source`. Both NGFF 0.4 and 0.5 layouts are written correctly.
+
+---
+
+## Notes
+
+- **Binary mask required, not validated.** The level-0 array must be a binary
+  mask; this is the caller's responsibility. Validating it would force a full
+  scan of a potentially huge array, so it is deliberately skipped. (Re-labeling
+  an already-labeled dataset will be possible later, once `tilewise-ccl` grows a
+  relabel function.)
+- **Downsampling is nearest-neighbour (stride).** Categorical labels must not be
+  averaged; coarser levels are produced by striding, matching the source
+  pyramid's per-level shapes and scales.
+- **Batch axes give globally-unique ids.** When multiple `(t, c)` volumes are
+  labeled, each is labeled independently and its ids are offset so the whole
+  output is a single, globally-unique label image.
+- **Colors/properties at scale.** For very large object counts, writing explicit
+  per-object colors and properties bloats the metadata (pyrametric warns) — pass
+  `write_colors=False` / `write_props=False` to `write_label_pyramid` to drop them.
+  Viewers such as napari auto-randomise label colors when no `colors` list is
+  present, so skipping them is usually fine.
+- **Memory.** Labeling and property computation are memory-bounded by tile size
+  (see `tilewise-ccl`); the only object-count-proportional cost is the in-memory
+  properties table.
+
+## See also
+
+- [`tilewise-ccl`](../tilewise-ccl) — the storage-agnostic array-level engine
+  (`label_array`), with its own README and benchmarks.

pyrametric-0.0.1/README.md

@@ -0,0 +1,182 @@
+# pyrametric
+
+Lazy, memory-bounded **connected-components labeling and per-object
+measurement** for OME-Zarr pyramids, with OME-NGFF label-image output.
+
+`pyrametric` is the OME-Zarr-aware layer over [`tilewise-ccl`](../tilewise-ccl): it
+labels the level-0 binary mask of a `Pyramid`, propagates the labels down the
+resolution levels, measures per-object features, and writes the result as a
+spec-compliant NGFF **label image** (`labels/<name>/` with `image-label`
+metadata). It works on already-segmented masks — thresholding/segmentation
+lives in [`pyrops`](../pyrops). It provides:
+
+- **`label_pyramid`** — label a mask `Pyramid` → a lazy, writable label
+  `Pyramid` (optionally with a per-object properties table).
+- **`extract_features`** / **`ObjectFeatures`** — regionprops-like per-object
+  measurement (area, bbox, moments, physical units, ...) over a label pyramid,
+  computed lazily and memory-bounded (validated against skimage in 2D and 3D).
+- **`write_label_pyramid`** — write a label pyramid as an OME-Zarr label image
+  (colors, properties, `source` back-reference; default `labels/<name>/`
+  location).
+- **`label_array`** — re-exported from `tilewise-ccl` for array-level labeling.
+
+The heavy lifting (fast tile-wise connected components, memory-bounded, exact,
+returning a lazy dask array) lives in `tilewise-ccl`; this package adds the
+pyramid, axis-handling, measurement, and NGFF I/O concerns on top.
+
+---
+
+## Installation
+
+```bash
+pip install pyrametric
+# or, from a checkout:
+pip install -e .
+```
+
+Depends on `tilewise-ccl`, `ome_zarr_pyramid`, plus `numpy`/`scipy`/`dask`/`zarr`.
+
+---
+
+## Quick start
+
+The input's level 0 must already be a **binary mask** (background 0 + one
+foreground value) — there is no thresholding here (binarize beforehand).
+
+```python
+from ome_zarr_pyramid.core.io import IO
+from pyrametric import label_pyramid, write_label_pyramid
+
+io = IO()
+mask_pyr = io.read_pyramid("mask.zarr")           # level 0 = a binary mask
+
+# label + propagate down the pyramid -> a lazy, writable label Pyramid
+label_pyr = label_pyramid(mask_pyr, connectivity=2, n_workers=8)
+
+# ...write it as a plain multiscale array,
+io.write_pyramid(label_pyr, "labels.zarr", overwrite=True)
+```
+
+### With properties + an OME-Zarr label image
+
+```python
+# also measure per-object properties (area + bounding box) - FREE from the labeling
+# metadata pass; they are stamped onto the returned pyramid's image-label metadata
+label_pyr = label_pyramid(mask_pyr, properties=True, n_workers=8)
+
+# write a spec-compliant label image under the source's labels/ group:
+#   mask.zarr/labels/cells/   (multiscales + image-label: colors, properties, source)
+write_label_pyramid(label_pyr, source="mask.zarr", name="cells")
+```
+
+### Attaching labels to the source image, written together
+
+`Pyramid.add_image_label` attaches a label pyramid to its source **image** pyramid,
+so the two travel together and a single `write_pyramid` emits the image plus its
+`labels/<name>/` sub-group in one OME-Zarr store — the common "image + its
+segmentation, side by side" layout that viewers open as one dataset:
+
+```python
+image_pyr = io.read_pyramid("image.zarr")     # the intensity image
+mask_pyr  = io.read_pyramid("mask.zarr")       # its binary mask (segment/threshold upstream)
+
+# label the mask, build its multiscale, name it, then attach it to the image
+label_pyr = label_pyramid(mask_pyr, properties=True).downscale().rename("cells")
+combined  = image_pyr.add_image_label(label_pyr, name="cells")
+
+io.write_pyramid(combined, "image_with_labels.zarr", overwrite=True)
+```
+
+### Labeling a sub-region
+
+To label only part of the image, select it first with `Pyramid.isel` (any axis,
+int/slice/list) — the label matches that sub-region's geometry:
+
+```python
+label_pyr = label_pyramid(mask_pyr.isel(c=1, z=slice(100, 150)))
+```
+
+---
+
+## API
+
+### `label_pyramid(pyramid, tile_shape=None, connectivity=2, n_workers=1, properties=False, verbose=False)`
+
+Label a binary-mask `Pyramid`'s level 0 and propagate the labels down the
+resolution levels (nearest-neighbour / stride downsampling — the correct choice
+for categorical labels). To label a sub-region, select it first with
+`Pyramid.isel` (e.g. `mask.isel(c=1, z=slice(100, 150))`).
+
+**Returns** a lazy label `Pyramid` (dtype int32 unless the object count exceeds
+int32), mirroring the source's axes, units, per-level shapes and scales. With
+`properties=True` the same pyramid additionally carries its OME `image-label`
+metadata (per-object colors + an area/bbox properties table), so it is write-ready.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `pyramid` | `Pyramid` | — | Source pyramid; level 0 is a **binary mask** (not validated — see [Notes](#notes)). Axes may be any subset of `tczyx`. |
+| `tile_shape` | sequence of int | `None` | Tile size for `tilewise-ccl`, one entry per **spatial** axis. `None` → `(303,) * n_spatial`. |
+| `connectivity` | int | `2` | Spatial `scipy.ndimage` connectivity (2D: 1=4-, 2=8-conn; 3D: 1=6-, 2=18-, 3=26-conn). |
+| `n_workers` | int | `1` | Threads for each labeling metadata pass. |
+| `properties` | bool | `False` | Also measure per-object `area` + `bbox` (free from the labeling pass) and stamp them onto the returned pyramid's `image-label` metadata (colors + properties). The return type is unchanged — always a `Pyramid`. |
+| `verbose` | bool | `False` | Forwarded to `tilewise-ccl.label_array`. |
+
+When `properties=True`, `label_pyramid` measures each object's **`area`** (voxel
+count) and **`bbox`** (half-open bounding box, per axis, in the label's own
+coordinates) and stamps them onto the returned pyramid's `image-label` metadata
+(alongside deterministic per-object `colors`), so it is write-ready. For richer
+per-object measurement (intensity / physical / shape features, filtering) pass the
+label pyramid to `extract_features(...)`.
+
+### `write_label_pyramid(label_pyramid, source=None, name="labels_0", output=None, write_colors=True, write_props=True, overwrite=False, **write_kwargs)`
+
+Write a label pyramid as an OME-Zarr **label image**, serialising the `image-label`
+metadata already on the pyramid (built by `label_pyramid(..., properties=True)` or
+`Pyramid.set_image_label`). This writer only persists it — it does not measure.
+Returns the path written.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `label_pyramid` | `Pyramid` | — | The label pyramid, carrying its `image-label` metadata. |
+| `source` | str \| Path \| `Pyramid` | `None` | The source image the labels belong to. **Required when `output` is None**: labels go to `<source>/labels/<name>/`, registered in the source's `labels` group, with `image-label.source.image = "../../"`. |
+| `name` | str | `"labels_0"` | Label-image name (the `labels/<name>` subgroup). |
+| `output` | str \| Path | `None` | Explicit output path; overrides the default `labels/<name>` location (written standalone). |
+| `write_colors` | bool | `True` | Include the pyramid's `colors` in the written metadata; `False` drops that key at write time (a lighter write for a very large object count). |
+| `write_props` | bool | `True` | Include the pyramid's `properties` table (`label-value`, `area (pixels)`, `object-coordinates`); `False` drops it at write time. |
+| `overwrite` | bool | `False` | Overwrite an existing label image. |
+| `**write_kwargs` | | | Forwarded to `IO.write_labels` / `write_pyramid` (backend, workers, ...). |
+
+The emitted `image-label` metadata (OME-NGFF
+[labels spec](https://ngff.openmicroscopy.org/specifications/0.5/index.html#labels-metadata))
+contains `version`, `colors` (`{label-value, rgba}`), `properties`
+(`{label-value, "area (pixels)", "object-coordinates": {axis: [start, stop]}}`),
+and `source`. Both NGFF 0.4 and 0.5 layouts are written correctly.
+
+---
+
+## Notes
+
+- **Binary mask required, not validated.** The level-0 array must be a binary
+  mask; this is the caller's responsibility. Validating it would force a full
+  scan of a potentially huge array, so it is deliberately skipped. (Re-labeling
+  an already-labeled dataset will be possible later, once `tilewise-ccl` grows a
+  relabel function.)
+- **Downsampling is nearest-neighbour (stride).** Categorical labels must not be
+  averaged; coarser levels are produced by striding, matching the source
+  pyramid's per-level shapes and scales.
+- **Batch axes give globally-unique ids.** When multiple `(t, c)` volumes are
+  labeled, each is labeled independently and its ids are offset so the whole
+  output is a single, globally-unique label image.
+- **Colors/properties at scale.** For very large object counts, writing explicit
+  per-object colors and properties bloats the metadata (pyrametric warns) — pass
+  `write_colors=False` / `write_props=False` to `write_label_pyramid` to drop them.
+  Viewers such as napari auto-randomise label colors when no `colors` list is
+  present, so skipping them is usually fine.
+- **Memory.** Labeling and property computation are memory-bounded by tile size
+  (see `tilewise-ccl`); the only object-count-proportional cost is the in-memory
+  properties table.
+
+## See also
+
+- [`tilewise-ccl`](../tilewise-ccl) — the storage-agnostic array-level engine
+  (`label_array`), with its own README and benchmarks.

pyrametric-0.0.1/pyproject.toml

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyrametric"
+version = "0.0.1"
+description = "Lazy, memory-bounded connected-components labeling and per-object measurement for OME-Zarr pyramids: label pyramids (from a mask), regionprops-like feature extraction, and label filtering (pyrops plugin; wraps tilewise-ccl)"
+readme = "README.md"
+# 3.11+ to match ome_zarr_pyramid and tilewise-ccl.
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "Bugra Oezdemir", email = "bugraa.ozdemir@gmail.com"},
+]
+# Kept in sync with the GitHub repository topics.
+keywords = [
+    "ome-zarr", "ngff", "connected-components", "labeling", "segmentation",
+    "regionprops", "image-pyramid", "bioimage", "microscopy", "out-of-core",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Scientific/Engineering :: Image Processing",
+]
+dependencies = [
+    # The labeling engine. >=0.0.4: 0.0.3 carried the whole-tile guard but pinned
+    # dyna-zarr>=0.0.5, which does NOT align an integer-indexed axis - so `labels[z]`
+    # raised "needs whole tiles" on a fresh install. 0.0.4 raises that pin to >=0.0.6.
+    "tilewise-ccl>=0.0.4",
+    "ome_zarr_pyramid>=0.0.7",
+    "scipy",
+    "numpy",
+    "dask",
+    "zarr",
+]
+
+[project.optional-dependencies]
+# pyrametric never imports dyna_zarr itself - it reaches the memory-bounded backend
+# through ome_zarr_pyramid, so this just forwards that package's own extra.
+dyna = ["ome_zarr_pyramid[dyna]>=0.0.7"]
+dev = [
+    "pytest>=7.0",
+    # `ObjectFeatures.to_frame()` returns a DataFrame; the dyna extra lets the
+    # backend="dyna" tests run instead of falling back to dask.
+    "pandas",
+    "dyna-zarr>=0.0.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/bugraoezdemir/pyrametric"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["tests*"]

pyrametric-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyrametric-0.0.1/src/pyrametric/__init__.py

@@ -0,0 +1,26 @@
+"""pyrametric: connected-components labeling for OME-Zarr pyramids.
+
+The array-level labeling algorithm lives in the standalone, storage-agnostic
+`tilewise-ccl` package; `label_array` is re-exported here for convenience.
+
+`label_pyramid` is the OME-Zarr-aware layer: it labels a `Pyramid`'s level-0
+binary mask and propagates the labels down the multiscale levels, returning a
+lazy label `Pyramid` aligned to the source.
+"""
+
+__version__ = "0.0.1"
+__author__ = "Bugra Oezdemir"
+
+from tilewise_ccl import label_array
+
+from pyrametric.object_features import ObjectFeatures, extract_features
+from pyrametric.pyramid import label_pyramid
+from pyrametric.write import write_label_pyramid
+
+__all__ = [
+    "label_array",
+    "label_pyramid",
+    "write_label_pyramid",
+    "extract_features",
+    "ObjectFeatures",  # filtering is now ObjectFeatures.filter_by_size / .filter_by_feature
+]