imaging-server-kit 0.2.0__tar.gz → 0.3.0__tar.gz

imaging_server_kit-0.3.0/.github/workflows/deploy.yml

@@ -0,0 +1,53 @@
+name: Docs
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: docs-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: pip
+        cache-dependency-path: pyproject.toml
+
+    - name: Install dependencies
+      run: pip install ".[docs]"
+
+    - name: Build the docs
+      run: mkdocs build --strict
+
+    - name: Upload artifact
+      if: github.event_name == 'push'
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: site
+
+  deploy:
+    if: github.event_name == 'push'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v4

{imaging_server_kit-0.2.0 → imaging_server_kit-0.3.0}/.github/workflows/publish.yml

@@ -1,17 +1,16 @@
-# Build the package and publish it to PyPI on tag push.
 name: Publish to PyPI
 on:
   push:
     tags:
       - "v*"
 
-permissions:
-  contents: write
-
 jobs:
   publish:
     name: publish
     runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
     steps:
       - name: Checkout source
         uses: actions/checkout@v4
@@ -24,10 +23,7 @@ jobs:
           python -m pip install -U pip build
           python -m build
       - name: Publish
-        uses: pypa/gh-action-pypi-publish@v1.5.0
-        with:
-          user: __token__
-          password: ${{ secrets.TWINE_API_KEY }}
+        uses: pypa/gh-action-pypi-publish@v1.13.0
       - name: Create Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{imaging_server_kit-0.2.0 → imaging_server_kit-0.3.0}/.gitignore

@@ -17,7 +17,7 @@ eggs/
 .coverage
 .coverage.*
 .cache
-docs/_build/
+site/
 .idea/
 venv/
 .vscode/
@@ -33,4 +33,5 @@ TODO.md
 AGENTS.md
 CLAUDE.md
 .claude/
-summary.md
+summary.md
+docs_missing.md

{imaging_server_kit-0.2.0 → imaging_server_kit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imaging-server-kit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Convert image processing functions to GUIs, FastAPI servers, and more.
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -33,10 +33,7 @@ License: Copyright (c) 2024, EPFL
         
 Project-URL: repository, https://github.com/Imaging-Server-Kit/imaging-server-kit
 Project-URL: documentation, https://imaging-server-kit.github.io/imaging-server-kit
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -50,12 +47,13 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: tifffile
-Requires-Dist: tqdm
+Requires-Dist: rich
 Requires-Dist: pydantic>=2.0
 Requires-Dist: scikit-image[optional]
 Requires-Dist: jinja2
 Requires-Dist: PyYAML
-Requires-Dist: imantics
+Requires-Dist: rasterio
+Requires-Dist: shapely>=2.0
 Requires-Dist: geojson
 Requires-Dist: fastapi
 Requires-Dist: uvicorn[standard]
@@ -69,14 +67,16 @@ Requires-Dist: napari-toolkit; extra == "napari"
 Requires-Dist: opencv-contrib-python-headless; extra == "napari"
 Provides-Extra: qupath
 Requires-Dist: imaging-server-kit[napari]; extra == "qupath"
-Requires-Dist: qubalab>=0.2.0; extra == "qupath"
+Requires-Dist: qubalab>=0.2.0; python_version >= "3.11" and extra == "qupath"
 Provides-Extra: docs
-Requires-Dist: jupyter-book<2.0; extra == "docs"
-Requires-Dist: jupytext; extra == "docs"
+Requires-Dist: mkdocs<2,>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
+Requires-Dist: ruff; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"
-Requires-Dist: httpx; extra == "test"
+Requires-Dist: httpx2; extra == "test"
 Provides-Extra: all
 Requires-Dist: imaging-server-kit[docs,napari,qupath,test]; extra == "all"
 Dynamic: license-file
@@ -85,19 +85,19 @@ Dynamic: license-file
 
 Turn Python-based image processing workflows into **algorithms** that gain extra functionalities.
 
-- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/sections/07_server.html) and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](https://imaging-server-kit.github.io/imaging-server-kit/sections/08_python.html) via HTTP requests.
+- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/serve.html) and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/python.html) via HTTP requests.
 
 https://github.com/user-attachments/assets/0be819ea-fcc1-48ee-8fae-7265e63a00d4
 
-- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/sections/01_algorithm.html) to run your algorithms interactively in Napari or QuPath.
+- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/napari.html) to run your algorithms interactively in Napari or QuPath.
 
 https://github.com/user-attachments/assets/1ff572f7-f159-4f5a-afd4-7a157de3d9f8
 
-- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/sections/06_tiled.html) on the input data.
+- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/tiling.html) on the input data.
 
 https://github.com/user-attachments/assets/47c2f734-5683-49d9-8aea-388c3a2bc16d
 
-- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/sections/05_streams.html) to inspect them in real-time.
+- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/live-updates.html) to inspect them in real-time.
 
 https://github.com/user-attachments/assets/a3f69a9f-fb68-4580-a804-6c57d5807b9a
 
@@ -151,22 +151,9 @@ If you encounter any problems, please file an issue along with a detailed descri
 
 ## Citing
 
-[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
-
-If you use the Imaging Server Kit in the context of scientific publication, you can cite it as below.
-
-BibTeX:
+If you use *Imaging Server Kit* in the context of scientific publication, you can cite it from the Zenodo repository:
 
-```
-@software{mallory_wittwer_2025_15673152,
-  author       = {Mallory Wittwer and Edward Andò and Maud Barthélemy and Florian Aymanns},
-  title        = {Imaging-Server-Kit/imaging-server-kit: v0.0.14},
-  url          = {https://doi.org/10.5281/zenodo.15673152},
-  doi          = {10.5281/zenodo.15673152},
-  version      = {v0.0.14},
-  year         = 2025,
-}
-```
+[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
 
 ## Acknowledgements
 

{imaging_server_kit-0.2.0 → imaging_server_kit-0.3.0}/README.md

@@ -2,19 +2,19 @@
 
 Turn Python-based image processing workflows into **algorithms** that gain extra functionalities.
 
-- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/sections/07_server.html) and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](https://imaging-server-kit.github.io/imaging-server-kit/sections/08_python.html) via HTTP requests.
+- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/serve.html) and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/python.html) via HTTP requests.
 
 https://github.com/user-attachments/assets/0be819ea-fcc1-48ee-8fae-7265e63a00d4
 
-- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/sections/01_algorithm.html) to run your algorithms interactively in Napari or QuPath.
+- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/napari.html) to run your algorithms interactively in Napari or QuPath.
 
 https://github.com/user-attachments/assets/1ff572f7-f159-4f5a-afd4-7a157de3d9f8
 
-- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/sections/06_tiled.html) on the input data.
+- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/tiling.html) on the input data.
 
 https://github.com/user-attachments/assets/47c2f734-5683-49d9-8aea-388c3a2bc16d
 
-- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/sections/05_streams.html) to inspect them in real-time.
+- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/live-updates.html) to inspect them in real-time.
 
 https://github.com/user-attachments/assets/a3f69a9f-fb68-4580-a804-6c57d5807b9a
 
@@ -68,22 +68,9 @@ If you encounter any problems, please file an issue along with a detailed descri
 
 ## Citing
 
-[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
-
-If you use the Imaging Server Kit in the context of scientific publication, you can cite it as below.
-
-BibTeX:
+If you use *Imaging Server Kit* in the context of scientific publication, you can cite it from the Zenodo repository:
 
-```
-@software{mallory_wittwer_2025_15673152,
-  author       = {Mallory Wittwer and Edward Andò and Maud Barthélemy and Florian Aymanns},
-  title        = {Imaging-Server-Kit/imaging-server-kit: v0.0.14},
-  url          = {https://doi.org/10.5281/zenodo.15673152},
-  doi          = {10.5281/zenodo.15673152},
-  version      = {v0.0.14},
-  year         = 2025,
-}
-```
+[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
 
 ## Acknowledgements
 

imaging_server_kit-0.3.0/docs/assets/extra.css

@@ -0,0 +1,11 @@
+/* Videos scale with their container (content area or grid card). */
+.md-typeset video {
+  display: block;
+  max-width: 100%;
+  height: auto;
+  border-radius: 0.2rem;
+}
+
+.md-typeset .grid.cards video {
+  margin-top: 0.6rem;
+}

imaging_server_kit-0.3.0/docs/citing.md

@@ -0,0 +1,22 @@
+# Citing
+
+If you use *Imaging Server Kit* in a scientific publication, please cite it using its Zenodo record:
+
+[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
+
+The DOI [10.5281/zenodo.15673151](https://doi.org/10.5281/zenodo.15673151) always resolves to the latest version. Zenodo also provides citations for specific versions, in several formats including BibTeX.
+
+For example, for version 0.0.14:
+
+```bibtex
+@software{mallory_wittwer_2025_15673152,
+  author       = {Mallory Wittwer and Edward Andò and Maud Barthélemy and Florian Aymanns},
+  title        = {Imaging-Server-Kit/imaging-server-kit: v0.0.14},
+  url          = {https://doi.org/10.5281/zenodo.15673152},
+  doi          = {10.5281/zenodo.15673152},
+  version      = {v0.0.14},
+  year         = 2025,
+}
+```
+
+The repository also contains a [`CITATION.cff`](https://github.com/Imaging-Server-Kit/imaging-server-kit/blob/main/CITATION.cff) file.

imaging_server_kit-0.3.0/docs/concepts/algorithms.md

@@ -0,0 +1,65 @@
+# Algorithms
+
+## Algorithms
+
+An **algorithm** (`sk.Algorithm`) wraps a Python function together with a description of its inputs and outputs. It is usually created with the `@sk.algorithm` decorator.
+
+From the function signature and the annotations, the algorithm knows:
+
+- Which [data layer](layers-and-stacks.md) corresponds to each parameter the function takes.
+- How to interpret the **outputs** of the function as data layers.
+- Extra information (samples, name, description, compatibility with tiling, etc.).
+
+This representation is what allows the package to generate user interfaces, documentation pages, and web APIs for the algorithm without extra code.
+
+### Matching parameters with data layers
+
+Each parameter of the function is matched with a data layer. The layer is chosen from the first of these sources that applies:
+
+1. **Explicit annotations** in `parameters={}`, for example `parameters={"sigma": sk.Float(min=0)}`.
+2. **Type hints**: `int`, `float`, `bool`, `str`, data layer classes such as `sk.Image`, or `np.ndarray` (interpreted as an image).
+3. **Default values**: a data layer instance (for example `sigma=sk.Float(default=1.0)`), or a value whose type is used as in type hints (for example `sigma=1.0` gives an `sk.Float`).
+4. **Variable names**, for parameters without a type hint or default value: `image`, `mask`, `points`, `vectors`, `boxes`, `paths`, and `tracks` are matched with the corresponding data layer.
+
+Parameters that cannot be resolved, for example custom classes, lists, or dictionaries, become `sk.Any` layers. They are not shown in user interfaces, and they may not work with servers if they cannot be serialized.
+
+### Matching outputs with data layers
+
+The values returned (or [yielded](../how-to/live-updates.md)) by the function are converted to data layers:
+
+- Data layers, such as `sk.Mask(mask)`, are used as they are.
+- Values of simple types (`int`, `float`, `bool`, `str`, `np.ndarray`, and `None`) are converted to the matching layer. A NumPy array becomes an `sk.Image`.
+- A tuple or a list is treated as several outputs, each converted separately.
+- Any other value becomes an `sk.Any` layer.
+
+Wrapping outputs in data layers explicitly is recommended for arrays, since only the data layer tells whether an array is an image, a mask, or a set of points.
+
+## Algorithm collections
+
+An **algorithm collection** (`sk.MultiAlgorithm`) groups several algorithms under one name. It is created with [`sk.combine`](../how-to/combine.md). In user interfaces, the algorithms of a collection appear in a single dropdown. In Python, methods take an extra `algorithm` argument to select an algorithm by name.
+
+## Clients
+
+A **client** (`sk.Client`) is connected to an [algorithm server](../tutorial/serve.md). It gives access to the algorithms of the server, and sends the computations to the server when it runs them.
+
+## Shared interface
+
+Algorithms, collections, and clients share the same interface, defined by the `AlgorithmRunner` base class:
+
+| Method | Description |
+|---|---|
+| `run()` | Run an algorithm and return a [`Stack`](layers-and-stacks.md) of results. Supports [tiling](../how-to/tiling.md) and [regions](../how-to/regions.md). |
+| `get_sample()` | Get a sample as a `Stack` of parameters. |
+| `get_n_samples()` | Get the number of samples. |
+| `info()` | Open the documentation page in a web browser. |
+| `get_parameters()` | Get the parameters schema. |
+| `algorithms` | The list of available algorithm names. |
+
+As a result, the same code works on a local algorithm, an algorithm collection, or a remote server, and the same Napari widget works for all three via `sk.to_napari`.
+
+```python
+# All three work the same way:
+results = threshold_algo.run(image, threshold=100)
+results = multi_algo.run(image, algorithm="threshold", threshold=100)
+results = sk.Client("http://localhost:8000").run(image, threshold=100)
+```

imaging_server_kit-0.3.0/docs/concepts/coordinates.md

@@ -0,0 +1,96 @@
+# Pixel space
+
+## Coordinates
+
+Spatial layers (images, masks, points, etc.) have a `position`, which places them in **global pixel coordinates**. A layer's data is expressed in *local* coordinates, and `position` is the offset that translates them to global coordinates.
+
+For example, an image cropped from a larger image keeps track of where the crop came from: its data starts at index `(0, 0)`, while its `position` records where that pixel is in the original image.
+
+You can set the position when creating a layer:
+
+```python
+import imaging_server_kit as sk
+import numpy as np
+
+img = sk.Image(np.zeros((100, 200)), position=(50, 20))
+
+print(img)             # <Image 'Image' float64 (100, 200), at (50, 20)>
+print(img.position)    # (50, 20)
+print(img.extent)      # Domain(position=(50, 20), size=(100, 200))
+print(img.coords_min)  # (50.0, 20.0)
+print(img.coords_max)  # (150.0, 220.0)
+```
+
+For object layers such as points, the extent is the bounding box of the objects:
+
+```python
+pts = sk.Points(np.array([[30, 10], [60, 90]]))
+
+print(pts.position)    # (0, 0)
+print(pts.coords_min)  # (30.0, 10.0)
+print(pts.coords_max)  # (61.0, 91.0)
+```
+
+Stacks have a position and an extent too. Setting the position of a stack moves all of its layers:
+
+```python
+stack = sk.Stack([img, pts])
+
+print(stack.extent)  # Domain(position=(30, 10), size=(120, 210))
+
+stack.position = (10, 10)
+
+print(img.position)  # (60, 30)
+print(pts.position)  # (10, 10)
+```
+
+Layers and stacks share the following properties:
+
+| Property | Type | Description |
+|---|---|---|
+| `position` | `tuple` | Offset of the local coordinates in global pixel coordinates. |
+| `extent` | `sk.Domain` | Region covered by the data, in global coordinates. |
+| `coords_min` | `tuple` | Lower corner of the extent (top-left in 2D). |
+| `coords_max` | `tuple` | Upper corner of the extent (bottom-right in 2D). |
+| `size` | `tuple` | Size of the extent along each axis. |
+| `ndim` | `int` | Number of spatial dimensions. |
+
+## Domains
+
+Extents are `sk.Domain` objects. A domain is a box defined by a `size` and a `position` (its lower corner, which defaults to the origin):
+
+```python
+roi = sk.Domain(position=(20, 30), size=(60, 80))
+
+print(roi.coords_min)  # (20.0, 30.0)
+print(roi.coords_max)  # (80.0, 110.0)
+```
+
+Domains are used to describe regions of interest and to [restrict computations](../how-to/regions.md), for example.
+
+## Merging data
+
+### Merging tiles
+
+When an algorithm runs [tile-by-tile](../how-to/tiling.md), the input layers are split into tiles, the algorithm runs on each tile, and the results are merged into a single stack. How results are merged depends on the layer type:
+
+| Layer | Merging |
+|---|---|
+| `sk.Image` | Intensities are **averaged** in overlapping regions. |
+| `sk.Mask` | By default, the **last tile overwrites** overlapping regions. With `merger="instances"` and a non-zero overlap between tiles, labels are made unique across tiles and objects crossing tiles are stitched together (experimental). |
+| `sk.Points`, `sk.Vectors`, `sk.Boxes` | Each object belongs to the tile that contains it (vectors are placed based on their origin, boxes based on their center). When tiles overlap, objects in overlapping regions are returned once per tile. |
+| Other layers (`sk.Paths`, `sk.Tracks`, values, etc.) | Each tile **replaces** the previous value. |
+
+### Merging layers
+
+You can use `sk.merge_layers()` to merge a list of layers of the same kind into a new layer, using the rules above. For example, to assemble two images:
+
+```python
+left = sk.Image(np.ones((100, 100)))
+right = sk.Image(np.full((100, 100), 2.0), position=(0, 100))
+
+merged = sk.merge_layers([left, right])
+
+print(merged)           # <Image 'Image' float32 (100, 200)>
+print(merged.position)  # (0.0, 0.0)
+```

imaging_server_kit-0.3.0/docs/concepts/layers-and-stacks.md

@@ -0,0 +1,44 @@
+# Data layers
+
+## Data layers
+
+A **data layer** holds a single piece of data, such as an image, a segmentation mask, a set of points, or a numeric value, together with information about what that data means. All data layers derive from `sk.Layer`, and the available types are listed in [Data layers](../reference/api/layers.md).
+
+Data layers play two roles:
+
+- **Describing parameters.** Layers passed in `parameters={}` describe the algorithm's inputs: their type, constraints such as `min` and `max`, a default value, a name, and a description. User interfaces and documentation pages are generated from these descriptions, and parameter values are validated against them.
+- **Holding results.** Layers returned by an algorithm wrap its outputs, so that each output is displayed and handled correctly. For example, an array wrapped in `sk.Mask` is shown as a `Labels` layer in Napari.
+
+Every layer has the following attributes:
+
+| Attribute | Description |
+|---|---|
+| `data` | The data itself, for example a NumPy array or a number. |
+| `name` | The name of the layer. Defaults to the name of the layer type, such as `"Mask"`. |
+| `meta` | A dictionary of metadata: the description, the merging strategy, and any extra keyword arguments passed to the layer (for example `colormap="viridis"`). |
+| `kind` | A short string identifying the layer type, such as `"mask"`. |
+
+Spatial layers also have a position and an extent in global pixel coordinates (see [Coordinates, domains and tile merging](coordinates.md)).
+
+## Stacks
+
+A **stack** (`sk.Stack`) is an ordered collection of data layers. `.run()` returns the results of an algorithm as a stack, and `.get_sample()` returns samples as a stack of parameter layers.
+
+```python
+import imaging_server_kit as sk
+import numpy as np
+
+stack = sk.Stack([sk.Image(np.zeros((10, 10))), sk.Mask(np.ones((10, 10), dtype=int))])
+
+image_layer = stack[0]           # By index
+mask_layer = stack.read("Mask")  # By name
+```
+
+Within a stack, layer names are unique. When a layer is added with `stack.add()` under a name that is already taken, a suffix is appended to its name, for example `Image-01`.
+
+When results are merged into a stack, layers are matched by name:
+
+- A layer with a *new name* is **added** to the stack.
+- A layer with the *same name* as an existing layer **updates** that layer's data and metadata.
+
+This concept is the basis of [live updates](../how-to/live-updates.md) and [tiled inference](../how-to/tiling.md); each yielded output, or processed tile, is merged into a single result stack according to the rule above, based on layer name.

imaging_server_kit-0.3.0/docs/developers/ai_policy.md

@@ -0,0 +1,21 @@
+# AI policy
+
+*Imaging Server Kit* is being developed with passion and intent by humans, with the occasional help of AI to **improve the overall quality of the project**. The table below summarizes the respective contributions of humans and AI agents within the project.
+
+| Human contributions |
+| ----- |
+| Conceptualization of the project |
+| Implementing core functionalities (public API) |
+| Deciding which features to prioritize |
+| Writing the initial documentation site |
+| Reviewing and validating AI-generated outputs |
+| Reviewing tests and testing the package on real scientific data |
+
+| AI contributions |
+| -- |
+| Catching and fixing bugs |
+| Identifying series of actions that lead to unexpected results |
+| Targeted refactoring to improve code clarity or maintainability |
+| Enhancing the documentation site |
+| Writing or fixing public docstrings |
+| Writing tests and testing the package on toy scientific data |

imaging_server_kit-0.3.0/docs/examples.md

@@ -0,0 +1,3 @@
+# Examples
+
+The [extra-examples](https://github.com/Imaging-Server-Kit/extra-examples) repository contains a gallery of Imaging Server Kit algorithms implemented for a selection of open-source projects.

imaging_server_kit-0.3.0/docs/getting-started/demos.md

@@ -0,0 +1,68 @@
+# Try the demos
+
+The package comes with a set of demo algorithms. Running them is the quickest way to get a feel for what *Imaging Server Kit* does before writing any code.
+
+!!! note
+    The demos below use Napari. Install it with `pip install "imaging-server-kit[napari]"` (see [Installation](installation.md)).
+
+## Napari demo
+
+From a terminal, run:
+
+```sh
+serverkit demo napari
+```
+
+This opens a **Napari viewer** with the *Imaging Server Kit* plugin already loaded. The *Algorithm* dropdown lists the demo algorithms.
+
+![Demo algorithms in Napari](../assets/images/demo_napari_screenshot.png)
+
+When you select an **algorithm**, the *Parameters* panel updates to show the tunable **parameters** of that algorithm.
+
+Most algorithms need an input image. You can **load a sample image** by selecting it in the *Samples* dropdown and clicking *Load*. Once an image is loaded, you can run the algorithm and look at the results.
+
+![Intensity threshold in Napari](../assets/images/screenshot_napari_threshold.png)
+
+Some algorithms re-run automatically when you change a parameter. For example, *Intensity threshold* updates its output as soon as you adjust the threshold value.
+
+!!! tip "Algorithm documentation"
+    Click the **🌐 Doc** button to open the **documentation page** of an algorithm in a web browser.
+
+## Server demo
+
+To see how algorithms can be served over HTTP, start the demo server:
+
+```sh
+serverkit demo serve
+```
+
+This starts a web server on your machine at http://localhost:8000. If you open this address in a browser, you will see an overview of the algorithms available on the server.
+
+![Algorithm server page](../assets/images/screenshot_server.png)
+
+### Connecting from Napari
+
+While the server is running, open another terminal and run:
+
+```sh
+napari -w imaging-server-kit
+```
+
+This is equivalent to opening `Plugins > Imaging Server Kit > Connect to server` in Napari.
+
+In the plugin panel, enter the server address (http://localhost:8000) and press *Connect*. The *Algorithm* dropdown fills with the algorithms available on the server, which you can use just like in the local demo.
+
+<video width="640" controls loop autoplay muted playsinline>
+  <source src="../assets/videos/server_napari.mp4" type="video/mp4">
+</video>
+
+!!! note
+    In this demo, the client and the server run on the same machine. The server could just as well run on another machine of your network, such as a workstation or a cluster node (see [Serve an algorithm](../how-to/deploy-server.md)).
+
+### Connecting from QuPath
+
+Algorithm servers can also be used from QuPath, for segmentation and object detection tasks. See [Usage with QuPath](../how-to/qupath.md) for a walkthrough with the demo server.
+
+## Next steps
+
+Learn how to [create your own algorithm](../tutorial/create-algorithm.md), so that it can be served and used in Napari just like the demos.

imaging_server_kit-0.3.0/docs/getting-started/installation.md

@@ -0,0 +1,55 @@
+# Installation
+
+The Imaging Server Kit supports Python 3.10 to 3.13.
+
+## Installing with pip
+
+Install the `imaging-server-kit` package with `pip`:
+
+```sh
+pip install imaging-server-kit
+```
+
+## Optional dependencies
+
+The Napari and QuPath integrations rely on extra packages that are not installed by default. Install them through the corresponding extras:
+
+| Command | Adds |
+|---|---|
+| `pip install "imaging-server-kit[napari]"` | [Napari](https://github.com/napari/napari) and [napari-toolkit](https://github.com/MIC-DKFZ/napari_toolkit), for dock widgets and the Napari plugin |
+| `pip install "imaging-server-kit[qupath]"` | [QuBaLab](https://pypi.org/project/qubalab/) (`>=0.2.0`) and the Napari extra, for the QuPath integration |
+| `pip install "imaging-server-kit[all]"` | All the above, plus the documentation and test dependencies |
+
+!!! note
+    The `qupath` extra requires Python 3.11 or later, because of QuBaLab.
+
+## Agent skills
+
+The package includes two skills for AI coding agents such as [Claude Code](https://claude.com/claude-code). They help the agent write algorithms with `@sk.algorithm` and build Napari or QuPath interfaces for them. Agents do not pick up skills from installed Python packages, so install them with:
+
+```sh
+serverkit install-skills
+```
+
+This copies the skills to `.claude/skills/` in the current directory, which makes them available in that project. To make them available in all projects, use `serverkit install-skills --user` (installs to `~/.claude/skills/`).
+
+| Skill | Helps with |
+|---|---|
+| `isk-write-algorithm` | Turning a function into an algorithm: parameters, outputs, samples, tiling, and servers |
+| `isk-napari-qupath-gui` | Running algorithms in Napari or QuPath, and troubleshooting the widgets |
+
+Existing skills are not overwritten unless you pass `--force`, so after upgrading the package, run `serverkit install-skills --force` to get the updated skills. See [Command line](../reference/cli.md) for all options.
+
+## Development version
+
+Clone the repository and install the package in editable mode:
+
+```sh
+git clone https://github.com/Imaging-Server-Kit/imaging-server-kit.git
+cd imaging-server-kit
+pip install -e ".[all]"
+```
+
+## Next steps
+
+[Try the demos](demos.md) to get a first look at what the package can do.