scikit-ops 0.1.0.dev0__py3-none-any.whl

scikit_ops-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,372 @@
+Metadata-Version: 2.5
+Name: scikit-ops
+Version: 0.1.0.dev0
+Summary: Appose-powered ops, and the machinery for running them.
+Project-URL: homepage, https://github.com/apposed/scikit-ops
+Project-URL: documentation, https://github.com/apposed/scikit-ops/blob/main/README.md
+Project-URL: source, https://github.com/apposed/scikit-ops
+Project-URL: download, https://pypi.org/project/scikit-ops
+Project-URL: tracker, https://github.com/apposed/appose/issues
+Author: scikit-ops developers
+License-Expression: BSD-2-Clause
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# scikit-ops
+
+A collection of image-processing **ops**, and `skop` — the machinery that runs
+them.
+
+An op is an ordinary Python function. The same function can be called directly,
+run in its own isolated environment through
+[Appose](https://github.com/apposed/appose), or wrapped in a GUI. Nothing about
+the op changes between those modes.
+
+Design notes — why the machinery is shaped this way, and what else was
+considered — are in [`docs/`](docs/README.md). How an op describes itself is
+[opspec](opspec/README.md), a separate package kept in this repository.
+
+## Install
+
+Not on PyPI yet, so from GitHub:
+
+```sh
+pip install "git+https://github.com/apposed/scikit-ops"
+```
+
+That brings opspec with it. opspec on its own, standard library only, for
+a host or plugin that describes ops without running them:
+
+```sh
+pip install "opspec @ git+https://github.com/apposed/scikit-ops#subdirectory=opspec"
+```
+
+Working on the code instead, from a checkout: `uv sync`, which installs both,
+editable. See [Development](#development).
+
+## Layout
+
+```
+envs/<env-id>/pixi.toml   environment definitions, named and shared between ops
+envs/<env-id>/init.py     optional; runs in each worker before its I/O loop
+src/skop/                 op-independent machinery
+src/skop/ops/<ns>.py      an op namespace, when its ops share one environment
+src/skop/ops/<ns>/<op>.py an op namespace, when its ops do not
+opspec/                   how an op describes itself: @op, OpSpec, roles, plans
+src/imgops/               napari/magicgui front ends (not published)
+```
+
+Environments are keyed by ID, and several ops may declare the same one. Ops
+sharing an environment also share a warm worker process, unless one asks for
+`exclusive=True`.
+
+## What's here
+
+| Op | Environment | Does |
+| --- | --- | --- |
+| `skop.ops.threshold:*` | `skimage` | Global thresholding: Otsu, isodata, Li, mean, minimum, triangle, Yen, multi-Otsu |
+| `skop.ops.smooth:*` | `skimage` | Smoothing and denoising: Gaussian, median, mean, Kuwahara, bilateral, TV, wavelet, NL-means, Butterworth |
+| `skop.ops.edges:*` | `skimage` | Derivative filters: Sobel, Scharr, Prewitt, Farid, Roberts, Laplace, DoG, unsharp mask, Frangi, Sato, Meijering |
+| `skop.ops.morphology:*` | `skimage` | Grayscale morphology: erosion, dilation, opening, closing, white/black tophat |
+| `skop.ops.kernels.psf:gaussian_psf` | `skimage` | Gaussian PSF, 2D or 3D |
+| `skop.ops.kernels.paraxial:paraxial_psf` | `skimage` | Paraxial PSF, from wavelength and NA |
+| `skop.ops.kernels.paraxial:paraxial_otf` | `skimage` | Paraxial OTF, the transform of the above |
+| `skop.ops.kernels.gibson_lanni:gibson_lanni` | `sdeconv` | Gibson-Lanni 3D PSF, with spherical aberration |
+| `skop.ops.deconvolve.richardson_lucy:richardson_lucy` | `skimage` | Richardson-Lucy, on the CPU |
+| `skop.ops.deconvolve.richardson_lucy_cupy:richardson_lucy_cupy` | `cupy` | Richardson-Lucy, on an NVIDIA GPU |
+| `skop.ops.segment.cellpose:cellpose` | `cellpose` | Cellpose segmentation |
+| `skop.ops.segment.stardist2d:stardist2d_fluo` | `stardist-tf` | StarDist 2D, pretrained fluorescence |
+| `skop.ops.segment.stardist2d:stardist2d_he` | `stardist-tf` | StarDist 2D, pretrained H&E |
+| `skop.ops.segment.stardist2d:stardist2d_custom` | `stardist-tf` | StarDist 2D, model loaded from a directory |
+| `skop.ops.train.stardist2d:train_stardist2d` | `stardist-tf` | StarDist 2D training, file pairs in, model path out |
+| `skop.ops.segment.starfun3d:segment_nuclei` | `stardist-tf` | StarDist 3D nuclei |
+| `skop.ops.labels:connect` | `skimage` | One label per object along an axis, by linking overlaps |
+| `skop.ops.generate:synthetic_nuclei` | `skimage` | Synthetic 3D test volume |
+| `skop.ops.segment.unseg:unseg` | `unseg-cv` | Unsupervised nuclei + cells |
+| `skop.ops.detect.fastsam:fastsam` | `pytorch` | Class-agnostic boxes, via FastSAM |
+| `skop.ops.detect.object_aware_yolo:object_aware_yolo` | `segment-everything` | Class-agnostic boxes, via MobileSAMv2 |
+| `skop.ops.detect.yolo:yolo` | `pytorch` | Tiled YOLO detection, with automatic GPU batching, confidences and classes |
+| `skop.ops.toy:*` | `minimal` | Exercises for skop itself |
+
+Those are the fully qualified op IDs, as `discover()` reports them. Callers
+import from the namespace instead, and never need to know whether it is one
+module or a package of them:
+
+```python
+from skop.ops.threshold import otsu
+from skop.ops.segment import cellpose, stardist2d_fluo
+```
+
+`stardist2d_fluo` and `segment_nuclei` share one TensorFlow build and one warm
+worker — the point of naming environments rather than tying them to ops.
+`unseg-cv` shares nothing with anything: it pins Python 3.9, numpy 1.24 and an
+old scikit-image, which is exactly why it needs an environment of its own.
+
+The two Richardson-Lucy ops are the same algorithm against different hardware,
+and there are two of them because `@op(env=...)` is fixed per function — a
+backend cannot be chosen at call time. Their signatures are identical and a
+test holds them numerically equivalent, so picking one is picking on speed.
+
+To list what the collection currently offers:
+
+```python
+import oprunner
+
+specs, failures = oprunner.discover()
+```
+
+For a large image and a YOLO `.pt` model:
+
+```python
+from pathlib import Path
+from skop.ops.detect import yolo
+
+with oprunner.Runner() as runner:
+    found = runner.run(
+        yolo, image=image, weights=Path("best.pt"),
+        object_size=100, overlap=0.15, gpu_fraction=0.9,
+    )
+# found.boxes: [min_y, min_x, max_y, max_x]
+# found.confidences and found.classes: one value per box
+```
+
+`object_size` is area in pixels²; `None` runs the whole image once. Areas
+outside 0.1%-50% of the image select square tiles with side
+`ceil(sqrt(1.5 * object_size / 0.001))`. Input size comes from the checkpoint.
+Tiles align with the image edges. Class-aware GreedyNMM matches SAHI 0.12.8:
+same-class boxes with IoS at least `merge_threshold` become an enclosing box
+with the maximum confidence. This includes matches within a tile. The default
+merge threshold is 0.5, independent of the per-tile NMS `iou` parameter.
+Outputs follow class order, then SAHI's keeper order within each class.
+A multiscale grid finds nearby candidates without an all-pairs matrix; the
+runtime needs no SAHI dependency. To run the optional reference comparisons:
+
+```sh
+uv run --with sahi==0.12.8 pytest tests/test_yolo.py -k sahi
+```
+
+GPU batches are calibrated after warm-up, with intermediate sizes before
+larger batches. Measured peaks adjust the size up or down; an out-of-memory
+retry establishes an upper bound rather than permanently halving throughput.
+CUDA measures the reserved allocator footprint; MPS samples driver memory.
+One CPU batch is prepared ahead of inference, using pinned buffers for CUDA.
+Inference transfers only detection data back to the host. The image must fit
+in host RAM; only the current resized batch enters the GPU.
+
+## Writing an op
+
+```python
+from typing import Annotated, NamedTuple
+
+import numpy as np
+from opspec.op import op
+from opspec.types import ImageOf, LabelsOf
+
+
+class Result(NamedTuple):
+    labels: LabelsOf[np.ndarray]
+    count: int
+
+
+@op(env="stardist-tf")
+def segment(
+    image: ImageOf[np.ndarray],
+    prob_thresh: Annotated[
+        float, {"widget_type": "FloatSlider", "min": 0.0, "max": 1.0}
+    ] = 0.5,
+) -> Result:
+    """Segment nuclei."""
+    from stardist.models import StarDist3D  # NB: heavy imports go in the body.
+
+    ...
+```
+
+Two rules, and both exist for the same reason — ops are discovered by importing
+them into a minimal environment that has little more than numpy:
+
+1. **Heavy imports go inside the function body.** A module-scope
+   `import tensorflow` makes the op undiscoverable.
+2. **Type your inputs and outputs with plain types.** Annotations *are*
+   evaluated at discovery time, so `-> tf.Tensor` fails even if the import is
+   in the body.
+
+Multiple outputs come from a `NamedTuple`: its field names become the names of
+the op's outputs. `progress(...)` and `cancel_requested()`, from
+`opspec.runtime`, report to whoever is running the op, and do nothing when it
+is called directly.
+
+### Saying what an array is
+
+Every op here passes `np.ndarray` around, which tells a front end nothing
+about how to display it. opspec's types add that missing half:
+
+| Write | Role | napari shows it as |
+| --- | --- | --- |
+| `ImageOf[np.ndarray]` | `Role.image` | an Image layer |
+| `LabelsOf[np.ndarray]` | `Role.labels` | a Labels layer |
+| `PointsOf[np.ndarray]` | `Role.points` | a Points layer |
+| `VectorsOf[np.ndarray]` | `Role.vectors` | a Vectors layer |
+| `TracksOf[np.ndarray]` | `Role.tracks` | a Tracks layer |
+| `BoxesOf[np.ndarray]` | `Role.boxes` | a Shapes layer |
+| `MasksOf[np.ndarray]` | `Role.masks` | a Labels layer, once projected |
+
+`MasksOf` is the odd one: an `(N, Y, X)` stack of masks that may overlap, so
+it is not a label image and no viewer shows it directly. A front end projects
+it with `ophelper.masks` — flattened to 2-D, or kept as a rotatable 3-D stack —
+and gets to offer that as a choice, since re-projecting costs a numpy call
+rather than another run of the op.
+
+They are `Annotated[np.ndarray, ...]`, so nothing else changes: the codec
+still sees an array, direct callers still get an array, and `ParamSpec.type`
+is still `np.ndarray`. They compose with the rest —
+`Out[LabelsOf[np.ndarray]]` and
+`Annotated[LabelsOf[np.ndarray], {"label": "Nuclei"}]` both work.
+
+Roles are advisory and never guessed. An unannotated array reports
+`role is None`, and deciding what to do with that is the front end's business,
+not opspec's. Nothing in `opspec.types` imports napari; the roles simply
+mirror `napari.types` so that mapping is a lookup rather than a judgement call,
+and `Role` is equally the hook a Fiji or plain-magicgui front end reads.
+
+### Where it goes
+
+Ops live in a namespace under `skop/ops/`, named for what they do. How the
+namespace is laid out inside depends on its ops, and the split point is the
+environment:
+
+- **One module** when the ops are variations on one call sharing one
+  environment — every `skop.ops.threshold` op is a few lines against
+  `skimage.filters`, so they share `threshold.py`.
+- **A package, one module per op**, when they do not — `skop.ops.segment`
+  spans three environments and each op carries its own models and types, so
+  each gets a file and `segment/__init__.py` re-exports them.
+
+An op needing several files of its own becomes a package
+(`segment/unseg/__init__.py` plus siblings). Underscore-prefixed modules are
+private and never imported by discovery, which is where shared helpers and
+vendored code belong.
+
+Because `from skop.ops.<ns> import <op>` reads the same either way, a
+namespace can grow from a module into a package without breaking callers.
+
+### Computation forms
+
+Following [SciJava Ops](https://ops.scijava.org/en/latest/Concepts.html), an op
+is one of three forms, declared through its signature:
+
+| Form | Signature | Meaning |
+| --- | --- | --- |
+| function | `def f(image) -> Result` | allocates and returns its output |
+| computer | `def f(image, out: Out[np.ndarray])` | fills a buffer the caller owns |
+| inplace | `def f(image: Mut[np.ndarray])` | mutates its input |
+
+`Out` parameters are hidden from generated GUIs — a user is never asked for an
+output buffer. Adapting between forms is not implemented yet: a computer or
+inplace op must be handed its buffers.
+
+## Running an op
+
+```python
+import oprunner
+from skop.ops import toy
+
+# Directly, in this process, using this process's dependencies.
+toy.add(2, 3)
+
+# Or in the op's own environment, in a worker process.
+with oprunner.Runner() as runner:
+    runner.run(toy.add, a=2, b=3)
+```
+
+The first run of an environment builds it, which takes a while. Later runs
+reuse it, since Appose keys environments by name.
+
+Because that build happens inside `run()`, a caller with a progress bar can
+subscribe to it:
+
+```python
+runner.subscribe_build_progress(lambda title, current, maximum: ...)
+runner.subscribe_build_output(lambda text: ...)
+runner.subscribe_build_error(lambda text: ...)
+```
+
+These pass straight through to Appose's builder. Progress titles name the
+phase — `Solving`, `Installing conda packages`, `Downloading PyPI packages`,
+`Installing PyPI packages`, `Done` — and come with a real denominator.
+
+Two things worth knowing. Subscribing to progress is what *enables* it:
+Appose's `PixiInstallMonitor` runs pixi under `-vv` to read its phase
+transitions, and only wires up when a progress subscriber exists. And
+`build_error` is the stderr *stream* rather than a failure report — pixi
+writes its ordinary status there, and under `-vv` its whole debug log as
+well. A build that actually fails raises out of `run()`.
+
+This needs Appose newer than 0.11, which is why `pyproject.toml` currently
+sources it from the main branch.
+
+## Development
+
+```sh
+uv sync --all-groups
+uv run pytest
+uv run ruff check --fix && uv run ruff format
+```
+
+### Testing the ops for real
+
+Ops are exercised end to end in their own environments, in `test_ops_e2e.py`.
+Each such test declares what it needs with `@pytest.mark.env("<env-id>")`, and
+is skipped when that environment is not built — so a plain `pytest` run stays
+fast and offline, testing against whatever happens to be installed already.
+
+To run them all, building whatever is missing:
+
+```sh
+uv run pytest --build-envs        # everything; slow the first time
+uv run pytest --build-envs -m env # only the op tests
+uv run pytest -m "not env"        # only the fast ones
+```
+
+Running the notebooks and the interactive tests is a separate setup, since they
+need a host environment and the ops do not run in it:
+[notebooks/README.md](notebooks/README.md).
+
+### Checking that the environments still solve
+
+Building is slow; solving is not. `scripts/check_envs.py` resolves every
+`envs/*/pixi.toml` without downloading anything, and exits non-zero if one is
+unsatisfiable:
+
+```sh
+python scripts/check_envs.py
+```
+
+This catches what the tests structurally cannot: they run *inside* an
+environment, and so cannot tell you whether that environment could still be
+created today. One already built keeps working from its lock file however
+broken its `pixi.toml` becomes — which is how an unsolvable `envs/pytorch`
+survived a week. Run it after editing anything under `envs/`.
+
+CI runs `--build-envs`, since these ops are the whole point of the project and
+nothing else validates them against the stacks they target. The flag is also
+settable as `PYTEST_ADDOPTS=--build-envs`, which is handy when the pytest
+invocation is not yours to edit.

scikit_ops-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,66 @@
+skop/__init__.py,sha256=q3aBnPDP8M-mFYHVcXGB3nIwAJ9Woq6i5TKJp-T6_3o,518
+skop/models.py,sha256=fWPjTVLoqISXYBsf2HllaRhCx0c_QoOInA5cxp6mgH4,5311
+skop/ops/__init__.py,sha256=DYALgX7N8j17grfDurLsAEYe90MY6xnAvWBH1ctJWik,808
+skop/ops/_util.py,sha256=4aTMa_NVv6IqmRXmVnQB6NZY_qHa7yvjduMYme-rGd4,4076
+skop/ops/edges.py,sha256=oom-p_Qgvdp64dG2k5clqvzNNMeSTC7u_LsC1pem3DA,13777
+skop/ops/generate.py,sha256=0cKxIdDyJXIRloFfAeypx7DxIYhvvxdux1WwrkgBMBw,2722
+skop/ops/labels.py,sha256=-fE2apWk4KcQQ5u0BHigUwMKNTb2amtCE7bSTlg6svo,6382
+skop/ops/morphology.py,sha256=9vUMsuo5ZiC-hCYnw-5tgBWA3bMPmdcYwb3H_V1DTWI,7600
+skop/ops/normalize.py,sha256=f_pKdDDXBjRS83rcsxZZF3pBuB-BEHyCLwsTrTksqTY,3652
+skop/ops/smooth.py,sha256=bz0wYYQ7UzruNXp6V4-7pKolgxmbANkLy7_YMzkFrNk,17615
+skop/ops/threshold.py,sha256=CZ2ETPRt8kcFqc2sC50fxiLWrRlCCAmGdtylJVM7Pig,9988
+skop/ops/toy.py,sha256=7VCUBpkINYc6wsHteYvNypN02CsMb_4jXiyw8qGA_fg,3330
+skop/ops/deconvolve/__init__.py,sha256=Xx_xR_3qXdLPfkB5f_onTXLuOQwY2p5Kxn5cgj-D-G0,728
+skop/ops/deconvolve/_edges.py,sha256=nlavBoTw1J8D_uHIMusWgXxBmkuD_OtQyEc7g0ehEBM,3345
+skop/ops/deconvolve/_pad.py,sha256=0k3bnKJOLC9ihVXpS_Rhy-ti2CIeBeqZZmt1-0viaVA,3535
+skop/ops/deconvolve/richardson_lucy.py,sha256=tHNWcgQVpDBBEfzN8DQOy7E39qK1qjufqfXtktu-TGU,3767
+skop/ops/deconvolve/richardson_lucy_cupy.py,sha256=yhlpdgyaj-BpR6zE2oQ8oe8pJF_oEEZ-lgijs-GpEgo,4838
+skop/ops/detect/__init__.py,sha256=mSBR9M8xmfKBjGsN6ZBHqhDZsfkSeC9OJUdKJTq618Y,1145
+skop/ops/detect/_result.py,sha256=hQqN7TgLkK8ZcuydbGogbh1ydMgWqIZNVWLI1br6nq4,1578
+skop/ops/detect/fastsam.py,sha256=g1L4B29H4JtosA1gfuJzWsFlcTaQjbziI3Vf_W99j_w,3517
+skop/ops/detect/jdll_yolo.py,sha256=G55NAmLj2FN_to8Dt6nV5I56JijSv2JcBaoXy50P24A,4172
+skop/ops/detect/object_aware_yolo.py,sha256=ybY5fjTHR5zLLsBqJ_m1MJP4X7iwFdKlkOxbR2l1y9Q,4226
+skop/ops/detect/yolo.py,sha256=E43l_-j-WLeax2dTjedKNPBy5y1m1_o3RaKLEW3uTRE,18559
+skop/ops/kernels/__init__.py,sha256=GCCv7rT8Uu46oSh7emDwn-C1xm54zEYPGulTr1J7HFo,1422
+skop/ops/kernels/_fluorophore.py,sha256=Dh2apJl1Dgfl4LfY6cgHH_YjwB3L_atyyerV2uDpzaw,1654
+skop/ops/kernels/_recenter.py,sha256=jHQYKKK-l84HTQgCZgH3UQQzxekazeviG2sNzRAc0tk,2370
+skop/ops/kernels/gibson_lanni.py,sha256=NngT_BAZnnwViHcCbLt0abK5SWYdGzJfr6K4kfGXov4,6745
+skop/ops/kernels/paraxial.py,sha256=CEqv4Fzq0ZXlIFelqWTOsbVuHEcgEWQLxz87zISTxbc,5554
+skop/ops/kernels/psf.py,sha256=wntCqZ6wsq9HeVA9wtA6tSotns03BrpVOLwFNZGOH-Q,2087
+skop/ops/mask/__init__.py,sha256=hk0mQqFiypPG9ZucNuKfU1tjQkab5H5jRsG6kTuZx6s,1387
+skop/ops/mask/_result.py,sha256=OtEe58jlYC88g-uTujypyUaMoucMDO_OT9VIhPGBkJk,1717
+skop/ops/mask/microsam.py,sha256=Rq3CxPKPu2gn-7w8PN1v3ow0yp41H_lc6U2rlV073yg,4670
+skop/ops/mask/mobilesam.py,sha256=PqiXvF0CrH4n7PnJPItXg_24PpMMw0JzRoqnzBu8FXk,7436
+skop/ops/segment/__init__.py,sha256=GblPOpbYOPKcTUZMP2X3VU8m3EMAuFMttEhicnlIw8E,667
+skop/ops/segment/cellpose3.py,sha256=GxEAVOpAMYurYMcbTf5hMlzQDt0KgJq1qMPTxRFFF60,10375
+skop/ops/segment/cellpose4.py,sha256=y7g7ZXK0M8l11IJAPKJ-OtIZBrxWK5-mmNdJRUUMlqc,5149
+skop/ops/segment/instanseg.py,sha256=TvQbmwqDm4_pqBbQX6H1kYvKuNb5fdppxoIIJOK8G9M,6296
+skop/ops/segment/stardist2d.py,sha256=XSG4kabcfeY5fsQr1e3kYmGbkWOqyoTTyEp98MB679M,6605
+skop/ops/segment/starfun3d.py,sha256=03RB3QL59NkkbgVABXTf9_VKZ-1Li_wUeJFPFjTqeAQ,3417
+skop/ops/segment/unseg/__init__.py,sha256=nxfXLG3xmnL5zwAlUB7YPdFeLNQk5R6L8JZ8BQ3c1nk,5088
+skop/ops/segment/unseg/_algorithm.py,sha256=M1l3g8g7hBr3af9aEwLBvnUbo_PvikEoZHRNiED7mfA,68689
+skop/ops/train/__init__.py,sha256=dIxjseVRpKvmW9nPvfQCWmZUsBfs4t31CeJagj9Ym0s,3000
+skop/ops/train/_util.py,sha256=lZi2PjsJ4SQtir2pu7qAeZkZa53HenTbpl7aA1cijvk,5749
+skop/ops/train/cellpose3.py,sha256=uh1SI72eYwnmSQjo0jmKhlkTW3FE5MKTd_H9_6onwac,8482
+skop/ops/train/cellpose4.py,sha256=akcfij7wsR4kdqlw9AmBBZ5Jh3UCF6dMLSyUnxFhVYA,7212
+skop/ops/train/stardist2d.py,sha256=dioZYyyw6coHoPLGWIBJxVIYmAHtOp6GjxsDkGDBCSQ,18876
+skop/ops/workflows/__init__.py,sha256=7GyWvVd9hIuDhup-ElcIeinjoI6xAe_JLwS67UDsIZM,1934
+skop/ops/workflows/deconvolve/__init__.py,sha256=7f6Sd4cJCfPPfEVwlXo3TIyN00P974zjXA-s3xv5YZ8,189
+skop/ops/workflows/deconvolve/with_psf.py,sha256=yATu3eqPW37haDJPEFxtI3DEMuWqaMxtrgFK0glZadM,4260
+skop/ops/workflows/mask/__init__.py,sha256=nKt0l8GrX44sCQ9jTtExBARnNrPZu6Y2AWVsMBPzdto,190
+skop/ops/workflows/mask/detect_then_mask.py,sha256=-6DtBC0rdrs1XZKM5rN-ruFO7kRJatIpZGDp4cb0ZA0,4166
+skop/ops/workflows/segment/__init__.py,sha256=RBdgluVVsBwuyPgYdkXbfYnb6sAWUrMQ7vcMV8rxOB4,184
+skop/ops/workflows/segment/connect_2d_in_3d.py,sha256=gV9M5AJQbV0Q4weeP-BF_LHiOg6TSoBUsZhndc5jzhU,6377
+skop/envs/cellpose3/pixi.toml,sha256=hvpkH9eTrUa1xbbJkWM-LwlVXBDJjpRJclCOQvbqUr4,1785
+skop/envs/cupy/pixi.toml,sha256=cQ4bFbGOYMolGnO8IeSO_6JEf806YeXLgtxuybWn09c,1546
+skop/envs/minimal/pixi.toml,sha256=WjHWc35qybmlHaP1KeUD2E-518Rue1fjmNOpIVR1AxE,1200
+skop/envs/pytorch/pixi.toml,sha256=3BU2nmhZMmt6x-MGGu4lQqsnk_1TqUwZwQpi2I7GkY0,3813
+skop/envs/sdeconv/pixi.toml,sha256=o5GhRrDG-ypUj155RriWR0W77CDPBunru-2xriFrLRs,3991
+skop/envs/segment-everything/pixi.toml,sha256=KMq2GUazmzN_Sw3dd5FuuAKMdiMCKtJTcXmhcWoc76Y,3943
+skop/envs/skimage/pixi.toml,sha256=X7W1E79E4UBHYSFiybeCgAYXvKumGCBT00reQnfNOHo,1305
+skop/envs/stardist-tf/pixi.toml,sha256=WyiniXNs6w2_-vz2XX1l_jr62vIVIG2mUOiLeyXV9dg,3656
+skop/envs/unseg-cv/pixi.toml,sha256=TwcYzpAnfBd5taAB0b-kRXBhbw5aXHoLzoKRaebvyDw,1065
+scikit_ops-0.1.0.dev0.dist-info/METADATA,sha256=-rNlEQzsKaScbKYxSG6vMSOVhhjFmy9z7D9FLx70ehQ,16089
+scikit_ops-0.1.0.dev0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+scikit_ops-0.1.0.dev0.dist-info/entry_points.txt,sha256=0gDhmxYQNjvBwJO4L0Q2fB-5fIEBbRVUS5u5heCYulQ,43
+scikit_ops-0.1.0.dev0.dist-info/RECORD,,

scikit_ops-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

scikit_ops-0.1.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[opspec.collections]
+scikit-ops = skop.ops

skop/__init__.py

@@ -0,0 +1,14 @@
+"""skop: scikit-ops' collection of image-processing ops.
+
+Each op is an ordinary Python function declared with opspec's ``@op``, in
+``skop.ops.<namespace>``; its environment is in ``envs/<id>/pixi.toml``. Call
+one directly, or run it in its own environment with oprunner::
+
+    from oprunner import Runner
+    from skop.ops.smooth import gaussian
+
+    with Runner() as runner:
+        blurred = runner.run(gaussian, image=image, sigma=2.0)
+
+skop is the working name; the collection will be renamed before release.
+"""

skop/envs/cellpose3/pixi.toml

@@ -0,0 +1,46 @@
+[workspace]
+name = "skop-cellpose3"
+description = "Cellpose 3, whose cyto3 and nuclei models predate CellposeSAM."
+channels = ["conda-forge"]
+platforms = ["osx-arm64", "linux-64", "win-64"]
+version = "0.1.0"
+
+[system-requirements]
+cuda = "12.0"
+
+# NB: an environment of its own rather than a version knob on envs/cellpose.
+# Cellpose 4 replaced the model zoo with a single CellposeSAM model and moved
+# the API with it -- v3's models.Cellpose became v4's models.CellposeModel,
+# and eval lost a return value. One environment cannot hold both, and an op
+# that branched on cellpose.version would be back to the runtime version
+# sniffing this project exists to avoid.
+#
+# Deliberately shaped like envs/pytorch and envs/cellpose otherwise: same
+# python, same per-platform torch split. pixi caches conda packages globally,
+# so the torch and CUDA payload is shared with those environments rather than
+# downloaded again -- provided cellpose 3 does not drag the solve onto older
+# builds of them. It is the one thing worth watching in the lock file.
+[dependencies]
+python = "3.11.*"
+numpy = "*"
+cellpose = ">=3,<4"
+# appose comes with the pinned scikit-ops below, as in envs/pytorch.
+
+[pypi-dependencies]
+# Pinned, as in every environment: a Fiji with no scikit-ops checkout runs
+# this copy. See envs/pytorch for why the pin is deliberate.
+scikit-ops = { git = "https://github.com/apposed/scikit-ops.git", rev = "00925fea3d92f3c974b7b1ec67d6633307d27bcc" }
+
+# PyTorch varies by platform: CUDA builds where there are GPUs to use,
+# and the plain package on Apple Silicon, where MPS comes built in.
+[target.linux-64.dependencies]
+pytorch-gpu = "*"
+cudnn = "*"
+cuda-version = "12.2"
+
+[target.win-64.dependencies]
+pytorch-gpu = "*"
+cudnn = "*"
+
+[target.osx-arm64.dependencies]
+pytorch = "*"

skop/envs/cupy/pixi.toml

@@ -0,0 +1,35 @@
+[workspace]
+name = "skop-cupy"
+description = "GPU array computing on CUDA, with cupy."
+channels = ["conda-forge"]
+# No macOS: CUDA is not available there. Listing a platform this env cannot
+# resolve on would turn a clean "no such platform" into a solver failure.
+platforms = ["linux-64", "win-64"]
+version = "0.1.0"
+
+[system-requirements]
+cuda = "12.0"
+
+[dependencies]
+python = "3.11.*"
+numpy = "*"
+cupy = "*"
+# NB: pinned as envs/cellpose pins it. cuda-version selects which CUDA runtime
+# the packages are built against, and it must not exceed what the installed
+# driver supports.
+cuda-version = "12.2"
+# NB: appose is not listed as a conda dependency here, unlike in
+# envs/unseg-cv, and this is temporary. A conda appose does satisfy the
+# pinned scikit-ops' PyPI dependency on it -- but only once the pin is new
+# enough to have dropped scikit-ops' [tool.uv.sources] git source for
+# appose, which uv honors transitively and which makes the solve
+# unsatisfiable. So this goes back to `appose = ">=0.12"` above as soon as
+# the rev below is bumped past that change and conda-forge carries 0.12.
+
+[pypi-dependencies]
+# Note: pinned deliberately -- this is part of the environment's identity,
+# so bumping it rebuilds every environment. A checkout still shadows it,
+# because skop.host.INIT puts src at sys.path[0]. See
+# docs/spec/fiji-front-end.md; it becomes an ordinary version constraint
+# once scikit-ops is released.
+scikit-ops = { git = "https://github.com/apposed/scikit-ops.git", rev = "00925fea3d92f3c974b7b1ec67d6633307d27bcc" }

skop/envs/minimal/pixi.toml

@@ -0,0 +1,25 @@
+[workspace]
+name = "skop-minimal"
+description = "Smallest environment an op can run in: python, numpy, appose."
+channels = ["conda-forge"]
+platforms = ["osx-arm64", "osx-64", "linux-64", "win-64"]
+version = "0.1.0"
+
+[dependencies]
+python = "3.11.*"
+numpy = "*"
+# NB: appose is not listed as a conda dependency here, unlike in
+# envs/unseg-cv, and this is temporary. A conda appose does satisfy the
+# pinned scikit-ops' PyPI dependency on it -- but only once the pin is new
+# enough to have dropped scikit-ops' [tool.uv.sources] git source for
+# appose, which uv honors transitively and which makes the solve
+# unsatisfiable. So this goes back to `appose = ">=0.12"` above as soon as
+# the rev below is bumped past that change and conda-forge carries 0.12.
+
+[pypi-dependencies]
+# Note: pinned deliberately -- this is part of the environment's identity,
+# so bumping it rebuilds every environment. A checkout still shadows it,
+# because skop.host.INIT puts src at sys.path[0]. See
+# docs/spec/fiji-front-end.md; it becomes an ordinary version constraint
+# once scikit-ops is released.
+scikit-ops = { git = "https://github.com/apposed/scikit-ops.git", rev = "00925fea3d92f3c974b7b1ec67d6633307d27bcc" }

skop/envs/pytorch/pixi.toml

@@ -0,0 +1,88 @@
+[workspace]
+name = "skop-pytorch"
+description = "The shared PyTorch environment: well-maintained torch libraries that can coexist."
+channels = ["conda-forge"]
+platforms = ["osx-arm64", "linux-64", "win-64"]
+version = "0.1.0"
+
+# This environment is meant to hold several ops, not one. Torch installs are
+# large and slow, so anything torch-based that solves cleanly alongside what is
+# already here belongs here rather than in an environment of its own.
+#
+# Three occupants now: ultralytics for the FastSAM detector, micro_sam for the
+# mask detector of docs/design/0008, and Cellpose, whose own environment this
+# replaced -- which is why envs/cellpose is gone.
+#
+# Conda-forge alone until Cellpose 4.2, which it does not carry; see
+# [pypi-dependencies].
+#
+# envs/cellpose3 stays separate, and is the exception that shows the rule:
+# Cellpose 4 replaced the v3 model zoo and moved the API with it, so the two
+# cannot share an environment at any version pin.
+
+[system-requirements]
+cuda = "12.0"
+
+[dependencies]
+python = "3.11.*"
+numpy = "*"
+ultralytics = ">=8.3"
+# NB: appose is not listed as a conda dependency here, unlike in
+# envs/unseg-cv, and this is temporary. A conda appose does satisfy the
+# pinned scikit-ops' PyPI dependency on it -- but only once the pin is new
+# enough to have dropped scikit-ops' [tool.uv.sources] git source for
+# appose, which uv honors transitively and which makes the solve
+# unsatisfiable. So this goes back to `appose = ">=0.12"` above as soon as
+# the rev below is bumped past that change and conda-forge carries 0.12.
+
+# NB: micro_sam depends on `napari >=0.5,<0.6` and `pyqt` outright -- it ships
+# a napari plugin and does not split it out. So this environment installs a GUI
+# stack that nothing in it imports; the ops use micro_sam.util and
+# micro_sam.prompt_based_segmentation, neither of which touches napari. Heavy
+# but harmless: a worker process never opens a window, and 0002's whole point
+# is that this napari pin cannot reach the front end's.
+#
+# It also carries `zarr <3` and `xarray <2025.3` -- worth knowing when the next
+# occupant fails to solve.
+micro_sam = ">=1.6"
+
+# NB: torchvision is required explicitly even though nothing here imports it
+# directly. conda's ultralytics does not depend on it, but reads
+# `importlib.metadata.version("torchvision")` at import time and raises
+# PackageNotFoundError when it is absent -- so leaving it out fails at the
+# first `from ultralytics import ...`, not at some later feature.
+torchvision = "*"
+
+# PyTorch varies by platform: CUDA builds where there are GPUs to use,
+# and the plain package on Apple Silicon, where MPS comes built in.
+
+[pypi-dependencies]
+# Conda-forge stops at cellpose 4.1.1, and 4.2 is where the DINO models
+# arrived; dinov3 is only on GitHub. Neither pulls a second torch -- pixi maps
+# the conda pytorch onto the `torch` requirement.
+cellpose = ">=4.2"
+dinov3 = { git = "https://github.com/facebookresearch/dinov3" }
+
+# InstanSeg is plain torch, PyPI only. Since 0.1 its file readers (bioio,
+# rasterio, slideio) are an optional `io` extra, left out: the op is handed
+# an array. The base install is torch, numpy, scikit-image and small helpers.
+instanseg-torch = "*"
+
+# Note: pinned deliberately -- this is part of the environment's identity,
+# so bumping it rebuilds every environment. A checkout still shadows it,
+# because skop.host.INIT puts src at sys.path[0]. See
+# docs/spec/fiji-front-end.md; it becomes an ordinary version constraint
+# once scikit-ops is released.
+scikit-ops = { git = "https://github.com/apposed/scikit-ops.git", rev = "00925fea3d92f3c974b7b1ec67d6633307d27bcc" }
+
+[target.linux-64.dependencies]
+pytorch-gpu = "*"
+cudnn = "*"
+cuda-version = "12.2"
+
+[target.win-64.dependencies]
+pytorch-gpu = "*"
+cudnn = "*"
+
+[target.osx-arm64.dependencies]
+pytorch = "*"