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

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

@@ -2,6 +2,7 @@ __pycache__/
 *.py[cod]
 *$py.class
 old/
+tmp/
 data/
 env/
 build/
@@ -26,4 +27,10 @@ venv/
 **/_version.py
 
 push.sh
-todo.txt
+todo.txt
+release.md
+TODO.md
+AGENTS.md
+CLAUDE.md
+.claude/
+summary.md

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imaging-server-kit
-Version: 0.1.2
+Version: 0.2.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
@@ -39,50 +39,57 @@ 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 :: Only
-Classifier: Programming Language :: Python :: 3.9
 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: Topic :: Scientific/Engineering :: Image Processing
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
+Requires-Dist: pandas
 Requires-Dist: tifffile
 Requires-Dist: tqdm
 Requires-Dist: pydantic>=2.0
 Requires-Dist: scikit-image[optional]
 Requires-Dist: jinja2
 Requires-Dist: PyYAML
-Requires-Dist: cookiecutter
-Requires-Dist: opencv-contrib-python-headless
 Requires-Dist: imantics
 Requires-Dist: geojson
 Requires-Dist: fastapi
 Requires-Dist: uvicorn[standard]
 Requires-Dist: python-multipart
 Requires-Dist: msgpack
-Requires-Dist: httpx
+Requires-Dist: networkx
+Provides-Extra: napari
+Requires-Dist: qtpy; extra == "napari"
+Requires-Dist: napari[all]>=0.4.16; extra == "napari"
+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"
 Provides-Extra: docs
 Requires-Dist: jupyter-book<2.0; extra == "docs"
 Requires-Dist: jupytext; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: httpx; extra == "test"
 Provides-Extra: all
-Requires-Dist: imaging-server-kit[docs,test]; extra == "all"
+Requires-Dist: imaging-server-kit[docs,napari,qupath,test]; extra == "all"
 Dynamic: license-file
 
-![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
 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 [QuPath](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit), [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), or [Python](./sections/08_python) via HTTP requests.
+- [**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.
 
-https://github.com/user-attachments/assets/36bda69d-996e-4240-9a53-7e76d9ea3894
+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.
+- [**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.
 
 https://github.com/user-attachments/assets/1ff572f7-f159-4f5a-afd4-7a157de3d9f8
 
@@ -94,6 +101,10 @@ https://github.com/user-attachments/assets/47c2f734-5683-49d9-8aea-388c3a2bc16d
 
 https://github.com/user-attachments/assets/a3f69a9f-fb68-4580-a804-6c57d5807b9a
 
+## Development status
+
+The Imaging Server Kit is being actively developed and is iterating rapidly. It is likely that there will be **compatibility-breaking changes** in future versions.
+
 ## Installation
 
 Install the `imaging-server-kit` package with `pip`:
@@ -110,6 +121,18 @@ cd imaging-server-kit
 pip install -e .
 ```
 
+To use the **Napari-related functionalities**, you additionally have to install [`napari`](https://github.com/napari/napari) and [`napari-toolkit`](https://github.com/MIC-DKFZ/napari_toolkit) which are not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[napari]"
+```
+
+To use the **QuPath-related functionalities**, you additionally have to install [`qubalab>=0.2.0`](https://pypi.org/project/qubalab/#history), which is not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[qupath]"
+```
+
 ## Getting started
 
 The documentation is available on [this page](https://imaging-server-kit.github.io/imaging-server-kit).

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

@@ -1,13 +1,12 @@
-![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
 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 [QuPath](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit), [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), or [Python](./sections/08_python) via HTTP requests.
+- [**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.
 
-https://github.com/user-attachments/assets/36bda69d-996e-4240-9a53-7e76d9ea3894
+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.
+- [**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.
 
 https://github.com/user-attachments/assets/1ff572f7-f159-4f5a-afd4-7a157de3d9f8
 
@@ -19,6 +18,10 @@ https://github.com/user-attachments/assets/47c2f734-5683-49d9-8aea-388c3a2bc16d
 
 https://github.com/user-attachments/assets/a3f69a9f-fb68-4580-a804-6c57d5807b9a
 
+## Development status
+
+The Imaging Server Kit is being actively developed and is iterating rapidly. It is likely that there will be **compatibility-breaking changes** in future versions.
+
 ## Installation
 
 Install the `imaging-server-kit` package with `pip`:
@@ -35,6 +38,18 @@ cd imaging-server-kit
 pip install -e .
 ```
 
+To use the **Napari-related functionalities**, you additionally have to install [`napari`](https://github.com/napari/napari) and [`napari-toolkit`](https://github.com/MIC-DKFZ/napari_toolkit) which are not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[napari]"
+```
+
+To use the **QuPath-related functionalities**, you additionally have to install [`qubalab>=0.2.0`](https://pypi.org/project/qubalab/#history), which is not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[qupath]"
+```
+
 ## Getting started
 
 The documentation is available on [this page](https://imaging-server-kit.github.io/imaging-server-kit).

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/_toc.yml

@@ -10,6 +10,5 @@ chapters:
   - file: sections/06_tiled
   - file: sections/07_server
   - file: sections/08_python
-  - file: sections/09_docker
-  - file: sections/10_types
-  - file: sections/11_examples
+  - file: sections/09_layers
+  - file: sections/10_examples

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/index.md

@@ -12,13 +12,13 @@ Server Kit algorithms are versatile objects that allow you run computations in a
 
 For example, you can
 
-- [**Turn your algorithm into a web server**](./sections/07_server.md), connect to it and run computations from [QuPath](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit), [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), or [Python](./sections/08_python) via HTTP requests.
+- [**Turn your algorithm into a web server**](./sections/07_server.md), connect to it and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](./sections/08_python) via HTTP requests.
 
 <video width=512 controls loop autoplay>
-  <source src="./_static/stardist_blobs.mp4" type="video/mp4">
+  <source src="./_static/cellpose_example.mp4" type="video/mp4">
 </video>
 
-- [**Generate a dock widget**](./sections/01_algorithm) to run your algorithm interactively in Napari.
+- [**Generate a dock widget**](./sections/01_algorithm) to run your algorithm interactively in Napari or QuPath.
 
 <video width=512 controls loop autoplay>
   <source src="./_static/oripy_threshold.mp4" type="video/mp4">
@@ -36,9 +36,9 @@ For example, you can
   <source src="./_static/yolo-stream.mp4" type="video/webm">
 </video>
 
-On top of that, you can [**validate data**](./sections/08_python) passed as algorithm parameters, provide [**samples**](./sections/02_samples), and generate [**documentation**](./sections/03_metadata) for your algorithm that you can share with users.
+On top of that, you can provide [**samples**](./sections/02_samples) and automatically generate a [**documentation**](./sections/03_metadata) page for your algorithm that you can share with users.
 
-This documentation will give you a conceptual overview of the package, and walk you through the steps to learn [how to create an algorithm](./sections/01_algorithm), and give you some [suggestions of use cases](./sections/11_examples).
+This documentation will give you a conceptual overview of the package, and walk you through the steps to learn [how to create an algorithm](./sections/01_algorithm), and give you some [suggestions of use cases](./sections/10_examples).
 
 ## Contents
 
@@ -61,17 +61,17 @@ cd imaging-server-kit
 pip install -e .
 ```
 
-**Napari plugin**
-
-Install the [napari-serverkit](https://github.com/Imaging-Server-Kit/napari-serverkit) plugin with `pip` to enable all [Napari](https://napari.org/stable/)-related functionalities.
+To use the **Napari-related functionalities**, you additionally have to install [`napari`](https://github.com/napari/napari) and [`napari-toolkit`](https://github.com/MIC-DKFZ/napari_toolkit) which are not included by default. Install the package with:
 
 ```sh
-pip install napari-serverkit
+pip install "imaging-server-kit[napari]"
 ```
 
-**QuPath extention**
+To use the **QuPath-related functionalities**, you additionally have to install [`qubalab>=0.2.0`](https://pypi.org/project/qubalab/#history), which is not included by default. Install the package with:
 
-To use the Imaging Server Kit in [QuPath](https://qupath.github.io/), follow the installation instructions at [qupath-extension-serverkit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit).
+```sh
+pip install "imaging-server-kit[qupath]"
+```
 
 ## License
 

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/00_getting_started.md

@@ -1,14 +1,6 @@
 # Getting started
 
-The following section will give you a first introduction to the Imaging Server Kit using a set of **interactive demos**.
-
-## Prerequisites
-
-Make sure to have installed the required packages:
-
-```
-pip install imaging-server-kit napari-serverkit
-```
+The following section will give you a first introduction to the Imaging Server Kit via **interactive demos**.
 
 ## Run the Napari demo
 
@@ -18,11 +10,11 @@ The Napari demo will give you a first idea of what the package can do. From a te
 serverkit demo napari
 ```
 
-This command should open a **Napari viewer** with the *Server Kit* plugin already loaded. In the *Algorithm* dropdown, you will see a list of available algorithms.
+This command should open a **Napari viewer** with the *Imaging Server Kit* plugin already loaded. In the *Algorithm* dropdown, you will see a list of "demo" algorithms.
 
 ![Demo-Napari](../assets/demo_napari_screenshot.png)
 
-When you select an **algorithm**, the *Parameters* panel will update to display a list of tunable **parameters** for the algorithm.
+When you select an **algorithm**, the *Parameters* panel will update to display a list of tunable **parameters** for this algorithm.
 
 Most algorithms require an input image. You can **load a sample image** from the *Samples* dropdown. Once you have loaded an image, you can **run** the algorithm and visualize the results in the Napari viewer.
 
@@ -51,10 +43,10 @@ This launches a web server on your local machine at http://localhost:8000. If yo
 While your server is running, you can connect to it directly from Napari. Open another terminal and run:
 
 ```
-napari -w napari-serverkit
+napari -w imaging-server-kit
 ```
 
-This is equivalent to opening the plugin in Napari from `Plugins > Server Kit (Napari Server Kit)`.
+This is equivalent to opening the plugin in Napari from `Plugins > Imaging Server Kit > Connect to server`.
 
 In the plugin panel, enter the server address (http://localhost:8000) and press *Connect*. The *Algorithm* dropdown will populate with the available algorithms. You can use them just like in the local case.
 
@@ -68,9 +60,23 @@ In this demo, both client and server run on your local machine, but keep in mind
 
 ### Connect from QuPath
 
-You can also use Server Kit algorithms direction from QuPath, for segmentation and object detection tasks. To try this out, follow the instructions in the [qupath-extension-serverkit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit) repository.
+You can also use Imaging Server Kit algorithms direction from QuPath via [QuBaLab](https://github.com/qupath/qubalab), for segmentation and bounding box detection tasks. To try this out, you can run the command:
+
+```sh
+serverkit qupath
+```
+
+This will bring up a user interface similar to the dock widget you used in Napari, with an extra field for connecting to QuPath via Py4J. Next, in a QuPath project:
+
+- Open an image, for example `blobs.tif`.
+- Draw a rectangular annotation in a region of interest (or use `Ctrl+Shift+A` to select the whole image).
+- Assign a class to this annotation via the QuPath `Annotations` menu, for example the class `Region`.
+
+After that, start a **Py4J** gateway from QuPath via the [qupath-extension-py4j](https://github.com/qupath/qupath-extension-py4j) (you can specify a token and port if needed). Then, click `Connect to QuPath` in the Imaging Server Kit window. The `Annotation` dropdown should now be filled with annotation class names (e.g., `Region`).
+
+Finally, with your server still active on http://localhost:8000, click on `Connect` to discover and use the algorithms available on that server. For this demonstration, you should be able to run a simple threshold on an image in QuPath!
 
-![threshold-qupath](../assets/threshold_qupath.png)
+![threshold-qupath](../assets/threshold_qubalab.png)
 
 ## Next steps
 

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/01_algorithm.ipynb

@@ -12,26 +12,6 @@
     "In this section, we will cover the basics of how to create Server Kit algorithms."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "2d1813a7",
-   "metadata": {},
-   "source": [
-    "## Prerequisites\n",
-    "\n",
-    "Before continuing, make sure to have installed the required packages:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "05618c50",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install imaging-server-kit napari-serverkit"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "04caf48c",
@@ -181,10 +161,6 @@
     "\n",
     "![Screenshot](../assets/gaussian_result.png)\n",
     "\n",
-    "```{note}\n",
-    "`sk.to_napari()` will only be available if you have installed the [napari-serverkit](https://github.com/Imaging-Server-Kit/napari-serverkit) plugin.\n",
-    "```\n",
-    "\n",
     "At this stage, the algorithm works, however a few things are not optimal. For example, users could enter a negative value for sigma, which would raise an error. To fix this, we need to **annotate parameters**."
    ]
   },
@@ -229,7 +205,7 @@
     "- `step` (for UI sliders)\n",
     "- `name` (label next to the parameter)\n",
     "\n",
-    "There are many more data layers available. For a full list, see: [Data layers](./10_types)\n",
+    "There are many more data layers available. For a full list, see: [Data layers](./09_layers)\n",
     "```\n",
     "\n",
     "While `parameters={}` is the most explicit and reliable annotation method, you can also use:\n",
@@ -363,7 +339,7 @@
     "\n",
     "    # Return all annotated outputs\n",
     "    return (\n",
-    "        sk.Image(blurred_image, name=\"Blurred\", meta={\"colormap\": \"viridis\"}),\n",
+    "        sk.Image(blurred_image, name=\"Blurred\", colormap=\"viridis\"),\n",
     "        sk.Mask(mask, name=\"Binary mask\"), \n",
     "        sk.String(f\"Area fraction: {fract:.02f}\", name=\"Fraction of True pixels\"),\n",
     "    )\n",
@@ -379,7 +355,7 @@
     "Notice that this algorithm \n",
     "\n",
     "- produces **several outputs** of different types: `sk.Image`, `sk.Mask`, `sk.String`.\n",
-    "- includes **metadata** in the outputs; for example, `meta={\"colormap\": \"viridis\"}` controls the colormap used to display the image in Napari."
+    "- includes **metadata** in the outputs; for example, `colormap=\"viridis\"` is used to control the colormap used to display the image in Napari."
    ]
   },
   {
@@ -416,7 +392,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.13.14"
   }
  },
  "nbformat": 4,

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/02_samples.ipynb

@@ -98,7 +98,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.13.14"
   }
  },
  "nbformat": 4,

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/03_metadata.ipynb

@@ -93,7 +93,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.13.14"
   }
  },
  "nbformat": 4,

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/04_multialgo.ipynb

@@ -106,7 +106,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.17"
+   "version": "3.13.14"
   }
  },
  "nbformat": 4,

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/05_streams.ipynb

@@ -36,13 +36,15 @@
    "outputs": [],
    "source": [
     "import imaging_server_kit as sk\n",
+    "import numpy as np\n",
     "import time\n",
     "\n",
     "@sk.algorithm\n",
-    "def threshold_algo(image):\n",
-    "    for threshold in range(0, 255, 20):  # Progressively increase the threshold value\n",
+    "def threshold_algo(image, steps=20):\n",
+    "    for k, threshold in enumerate(np.linspace(0, 255, steps)):  # Progressively increase the threshold value\n",
     "        mask = image > threshold\n",
     "        yield sk.Mask(mask), sk.String(f\"Threshold: {threshold}\")  # <- \"Stream\" the outputs\n",
+    "        yield sk.Progress(k, max_val=steps)  # <- Update the progress bar\n",
     "        time.sleep(0.5)\n",
     "\n",
     "viewer = sk.to_napari(threshold_algo)\n",
@@ -104,7 +106,7 @@
    "id": "d8d1138d",
    "metadata": {},
    "source": [
-    "In this example, the algorithm notifies the user that processing has started, then returns a segmentation mask, and finally prints out the final measurement."
+    "In this example, the algorithm notifies the user that processing has started, then yields a segmentation mask, and finally prints out the final measurement."
    ]
   },
   {
@@ -139,7 +141,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.13.14"
   }
  },
  "nbformat": 4,

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/06_tiled.ipynb

@@ -7,19 +7,11 @@
    "source": [
     "# Tiled inference\n",
     "\n",
-    "Tiled inference consists in **running an algorithm tile-by-tile** on individual subpatches (tiles) instead of the whole image at once. The results from each tiles are assembled to form the final result.\n",
+    "Tiled inference can be used to run image processing filters, segmentation, or detection algorithms tile-by-tile instead of on the whole input image at once. The processed tiles are progressively assembled to form the final result.\n",
     "\n",
-    "Tiled inference can be useful in these contexts:\n",
+    "By default, this functionality is disabled; you can enable it by setting `tileable=True` when defining an algorithm.\n",
     "\n",
-    "- The algorithm is **embarrassingly parallel** (Note: this is not the case for instance segmentation, for example).\n",
-    "- Users need to see the results appear progressively (if needed, they can cancel the process before it finishes).\n",
-    "- To apply a deep learning model with a fixed context window (input size) on images of varying sizes.\n",
-    "\n",
-    "All Server Kit algorithms are tileable. You can control the **tile size** (in pixels), **overlap** (fraction), processing **order** of the tiles (random or not), and the time delay introduced between processing of consecutive tiles. \n",
-    "\n",
-    "```{note}\n",
-    "Tiled inference is an **experimental feature**. We aren't fully done implementing and testing it yet. Expect some improvements in the near future!\n",
-    "```"
+    "When running an algiorithm tile-by-tile, you can adjust the **tile size** in pixels, the amount of **overlap** between tiles, and the **order** in which tiles are processed (random or not)."
    ]
   },
   {
@@ -41,7 +33,7 @@
    "source": [
     "import imaging_server_kit as sk\n",
     "\n",
-    "@sk.algorithm\n",
+    "@sk.algorithm(tileable=True)  # <- Set tileable=True\n",
     "def threshold_algo(image, threshold=128):\n",
     "    mask = image > threshold\n",
     "    return sk.Mask(mask)\n",
@@ -71,8 +63,7 @@
    "source": [
     "## Summary\n",
     "\n",
-    "- You can run algorithms tile-by-tile on subparts of the algorithm inputs.\n",
-    "- This is only meaningful for embarassingly parallel tasks.\n",
+    "- You can enable running an algorithm tile-by-tile by setting `tileable=True` in the algorithm definition.\n",
     "\n",
     "## Next steps\n",
     "\n",
@@ -81,7 +72,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "06613872",
+   "id": "cc2ef706",
    "metadata": {},
    "source": []
   }
@@ -102,7 +93,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.13.14"
   }
  },
  "nbformat": 4,

{imaging_server_kit-0.1.2 → imaging_server_kit-0.2.0}/docs/sections/07_server.md

@@ -2,11 +2,6 @@
 
 Any Imaging Server Kit algorithm can be **served as a web API** using a built-in [FastAPI](https://fastapi.tiangolo.com/) server. This turns algorithms into web servers that you can interact with from Napari, QuPath, or Python via HTTP requests.
 
-Serving an algorithm is particularly useful when:
-
-- You want to run computations on a remote machine and visualize the results on your local machine.
-- You want to use algorithms in **QuPath** via the `qupath-extension-serverkit` extension.
-
 ## Using `sk.serve`
 
 Let's consider the threshold algorithm once again. You can serve this algorithm by passing it to `sk.serve()`. 
@@ -42,13 +37,17 @@ Once the server is running, you can connect to it from Napari, QuPath, or direct
 
 ### Connecting from Napari
 
-The [Napari Server Kit](https://github.com/Imaging-Server-Kit/napari-serverkit) plugin provides a widget for connecting to algorithm servers.
-
-To try it out, open a new terminal window, start Napari, and then open the plugin from `Plugins > Server Kit (Napari Server Kit)`. In the `Server URL` field, enter: http://localhost:8000, and press *Connect*. You should see your threshold algorithm listed, with all related functionalities (load samples, run algorithm, access documentation) available.
+You can connect to algorithm servers from Napari via the menu `Plugins > Imaging Server Kit > Connect to server`. In the `Server URL` field, enter: http://localhost:8000, and press *Connect*. You should see your threshold algorithm listed, with all related functionalities (load samples, run algorithm, access documentation) available.
 
 ### Connecting from QuPath
 
-You can also connect to algorithm servers via QuPath through the [qupath-extension-serverkit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit) extension. The QuPath extension can handle compatible algorithm outputs, including segmentation masks, bounding boxes, vectors, points, and classification tasks.
+You can also connect to algorithm servers and use algorithms via QuPath. From the terminal, run:
+
+```sh
+serverkit qupath
+```
+
+to bring up the QuPath connection panel. Algorithms compatible with QuPath include those that take a single image as input (interpreted as the QuPath image), and return segmentation masks or bounding boxes.
 
 ## Summary