imaging-server-kit 0.0.3__tar.gz → 0.0.5__tar.gz

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/Dockerfile

@@ -12,4 +12,5 @@ RUN python -m pip install -e .
 
 EXPOSE 8000
 
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["python3", "main.py"]
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: imaging-server-kit
-Version: 0.0.3
+Version: 0.0.5
 Summary: Deploy image processing algorithms in FastAPI servers. 
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -31,8 +31,8 @@ License: Copyright (c) 2024, EPFL
         OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
         
-Project-URL: homepage, https://gitlab.com/epfl-center-for-imaging/imaging-server-kit
-Project-URL: repository, https://gitlab.com/epfl-center-for-imaging/imaging-server-kit
+Project-URL: homepage, https://github.com/Imaging-Server-Kit/imaging-server-kit
+Project-URL: repository, https://github.com/Imaging-Server-Kit/imaging-server-kit
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -53,6 +53,8 @@ Requires-Dist: python-multipart
 Requires-Dist: tifffile
 Requires-Dist: numpy
 Requires-Dist: scikit-image
+Requires-Dist: opencv-contrib-python-headless
+Requires-Dist: imantics
 Requires-Dist: geojson
 Requires-Dist: jinja2
 Requires-Dist: pyyaml
@@ -64,7 +66,12 @@ Requires-Dist: pytest
 ![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
-Deploy image processing algorithms in FastAPI servers and easily run them in Napari, QuPath, and more.
+Deploy image processing algorithms in FastAPI servers and easily run them from Napari, QuPath, and more.
+
+The algorithm servers implement a common set of API endpoints for processing and to document the project. These include:
+  - `/process`: Runs the algorithm
+  - `/info`: Displays documentation about the algorithm usage
+  - `/sample_images`: Provides one or multiple sample images
 
 ## Usage
 
@@ -72,22 +79,23 @@ Deploy image processing algorithms in FastAPI servers and easily run them in Nap
 
 Set up and run a server with one, or multiple algorithms from the Imaging Server Kit collection (or your own):
 
-- [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist)
-- [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose)
-- [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow)
-- [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg)
-- [Scikit-image LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG)
-- [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy)
+  - [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist): Object detection with star-convex shapes
+  - [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose): A generalist algorithm for cellular segmentation
+  - [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow): Accurate and efficient spot detection
+  - [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg): A tool to remove images background
+  - [LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG): Laplacian of Gaussian filter
+  - [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy): Measurement of greyscale orientations
 <!-- - [Tau Fibrils Detector](https://github.com/Imaging-Server-Kit/serverkit-tau-fibrils-yolo) -->
 
-To do that, the recommended way is to edit a `docker-compose.yml` file and pull server images from `registry.rcp.epfl.ch` (EPFL users only):
+All of these algorithm servers can be installed locally or built and run with docker. To use docker and serve multiple algorithms, the recommended way is to edit a `docker-compose.yml` file and pull server images from `registry.rcp.epfl.ch` (EPFL users only):
 
 ```{docker-compose.yml}
 services:
   servers_registry:
-    image: mallorywittwerepfl/imaging-server-kit:registry
+    image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
+    command: python3 start_registry.py
   rembg:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
     depends_on:

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/README.md

@@ -1,7 +1,12 @@
 ![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
-Deploy image processing algorithms in FastAPI servers and easily run them in Napari, QuPath, and more.
+Deploy image processing algorithms in FastAPI servers and easily run them from Napari, QuPath, and more.
+
+The algorithm servers implement a common set of API endpoints for processing and to document the project. These include:
+  - `/process`: Runs the algorithm
+  - `/info`: Displays documentation about the algorithm usage
+  - `/sample_images`: Provides one or multiple sample images
 
 ## Usage
 
@@ -9,22 +14,23 @@ Deploy image processing algorithms in FastAPI servers and easily run them in Nap
 
 Set up and run a server with one, or multiple algorithms from the Imaging Server Kit collection (or your own):
 
-- [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist)
-- [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose)
-- [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow)
-- [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg)
-- [Scikit-image LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG)
-- [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy)
+  - [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist): Object detection with star-convex shapes
+  - [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose): A generalist algorithm for cellular segmentation
+  - [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow): Accurate and efficient spot detection
+  - [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg): A tool to remove images background
+  - [LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG): Laplacian of Gaussian filter
+  - [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy): Measurement of greyscale orientations
 <!-- - [Tau Fibrils Detector](https://github.com/Imaging-Server-Kit/serverkit-tau-fibrils-yolo) -->
 
-To do that, the recommended way is to edit a `docker-compose.yml` file and pull server images from `registry.rcp.epfl.ch` (EPFL users only):
+All of these algorithm servers can be installed locally or built and run with docker. To use docker and serve multiple algorithms, the recommended way is to edit a `docker-compose.yml` file and pull server images from `registry.rcp.epfl.ch` (EPFL users only):
 
 ```{docker-compose.yml}
 services:
   servers_registry:
-    image: mallorywittwerepfl/imaging-server-kit:registry
+    image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
+    command: python3 start_registry.py
   rembg:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
     depends_on:

imaging_server_kit-0.0.5/build.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+docker build --build-arg PYTHON_VERSION=3.9 -t imaging-server-kit .
+
+# echo "Building image for Python 3.9, GPU-compatible..."
+# docker build -t imaging-server-kit:gpu --file Dockerfile-GPU .

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/main.py

@@ -1,4 +1,8 @@
+import uvicorn
 import imaging_server_kit as serverkit
 
 server = serverkit.Server(algorithm_name="foo", parameters_model=serverkit.Parameters)
 app = server.app
+
+if __name__=='__main__':
+    uvicorn.run("main:app", host="0.0.0.0", port=8000)

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/pyproject.toml

@@ -28,6 +28,8 @@ dependencies = [
     "tifffile",
     "numpy",
     "scikit-image",
+    "opencv-contrib-python-headless",
+    "imantics",
     "geojson",
     "jinja2",  # For the /info route
     "pyyaml",  # For the /info route
@@ -38,8 +40,8 @@ dependencies = [
 ]
 
 [project.urls]
-homepage = "https://gitlab.com/epfl-center-for-imaging/imaging-server-kit"
-repository = "https://gitlab.com/epfl-center-for-imaging/imaging-server-kit"
+homepage = "https://github.com/Imaging-Server-Kit/imaging-server-kit"
+repository = "https://github.com/Imaging-Server-Kit/imaging-server-kit"
 
 [build-system]
 requires = ["setuptools>=42.0.0", "wheel", "setuptools_scm"]

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/__init__.py

@@ -14,7 +14,9 @@ from imaging_server_kit.serialization import (
 )
 from imaging_server_kit.geometry import (
     mask2features,
+    instance_mask2features,
     features2mask,
+    features2instance_mask,
     boxes2features,
     features2boxes,
     points2features,

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/_version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.3'
-__version_tuple__ = version_tuple = (0, 0, 3)
+__version__ = version = '0.0.5'
+__version_tuple__ = version_tuple = (0, 0, 5)

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/client.py

@@ -7,6 +7,7 @@ from imaging_server_kit.errors import (
     AlgorithmServerError,
     InvalidAlgorithmParametersError,
     ServerRequestError,
+    AlgorithmTimeoutError,
 )
 
 
@@ -29,7 +30,7 @@ class Client:
             services = response.json().get("services")
             self.algorithms = services
         else:
-            raise AlgorithmServerError(response.status_code, response.json())
+            raise AlgorithmServerError(response.status_code, response.text)
 
     @property
     def server_url(self) -> str:
@@ -68,8 +69,10 @@ class Client:
             return serverkit.deserialize_result_tuple(response.json())
         elif response.status_code == 422:
             raise InvalidAlgorithmParametersError(response.status_code, response.json())
+        elif response.status_code == 504:
+            raise AlgorithmTimeoutError(response.status_code, response.text)
         else:
-            raise AlgorithmServerError(response.status_code, response.json())
+            raise AlgorithmServerError(response.status_code, response.text)
 
     def get_algorithm_parameters(self, algorithm=None) -> Dict:
         algorithm = self._validate_algorithm(algorithm)
@@ -84,7 +87,7 @@ class Client:
         if response.status_code == 200:
             return response.json()
         else:
-            raise AlgorithmServerError(response.status_code, response.json())
+            raise AlgorithmServerError(response.status_code, response.text)
 
     def get_sample_images(
         self, algorithm=None, first_only: bool = False

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/errors.py

@@ -13,17 +13,27 @@ class AlgorithmServerError(Exception):
     def __init__(self, status_code, response_body, message="Algorithm server returned an unexpected status_code"):
         self.status_code = status_code
         self.response_body = response_body
-        self.message = f"{message}: {status_code}\nResponse body: {response_body}"
+        self.message = f"{message}: {status_code}\nResponse: {response_body}"
+        super().__init__(self.message)
+
+
+class AlgorithmTimeoutError(Exception):
+    """Exception raised when a request to an algorithm server exceeds the time limit."""
+
+    def __init__(self, status_code, response_text, message="Algorithm server returned an unexpected status_code"):
+        self.status_code = status_code
+        self.response_text = response_text
+        self.message = f"{message}: {status_code}\nResponse: {response_text}"
         super().__init__(self.message)
 
 
 class InvalidAlgorithmParametersError(Exception):
     """Exception raised when a request to an algorithm server is made with invalid algorithm parameters."""
 
-    def __init__(self, status_code, response_body, message="Algorithm parameters were invalidated by the server"):
+    def __init__(self, status_code, response_text, message="Algorithm parameters were invalidated by the server"):
         self.status_code = status_code
-        self.response_body = response_body
-        pydantic_details = response_body.get("detail")[0]
+        self.response_text = response_text
+        pydantic_details = response_text.get("detail")[0]
         pydantic_validation_msg = pydantic_details.get("msg")
         pydantic_failing_param = pydantic_details.get("loc")[1]
         pydantic_failing_param_value = pydantic_details.get("input")

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/geometry.py

@@ -1,53 +1,103 @@
 from typing import List
-from skimage.measure import find_contours
 from skimage.draw import polygon2mask
 from geojson import Feature, Polygon, Point, LineString
 import numpy as np
+from imantics import Mask
 
 
-def mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
+def instance_mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
     """
     Args:
         segm_mask: Segmentation mask with the background pixels set to zero and the pixels assigned to a segmented
-         object set to an int value
+         object instance set to an int value
 
     Returns:
         A list containing the contours of each object as a geojson.Feature
     """
     features = []
     indices = np.unique(segmentation_mask)
-    indices = np.delete(indices, indices == 0)  # remove background
-    if indices.size > 0:
-        for i in indices.tolist():
-            mask = np.array(segmentation_mask == i)
-            mask = np.pad(mask > 0, 1)
-            contours_find = find_contours(mask, 0.5)
-            if len(contours_find) == 1:
-                index = 0
-            else:
-                # TODO: Change this to handle panoptic segmentation cases
-                # if more than one contour is found, the largest one is returned
-                n_pixels = []
-                for _, item in enumerate(contours_find):
-                    n_pixels.append(len(item))
-                index = np.argmax(n_pixels)
-            contour = contours_find[index]
-            contour -= 1  # reset padding
-            contour_as_numpy = contour[:, np.argsort([1, 0])]  # Fix XY
-            geom = Polygon([contour_as_numpy.tolist()])
-            features.append(Feature(geometry=geom, properties={"Detection ID": i}))
+    indices = indices[indices != 0] # remove background
+
+    if indices.size == 0:
+        return features
+    
+    for detection_id in indices:
+        mask = segmentation_mask == int(detection_id)
+        polygons = Mask(mask).polygons()
+        for contour in polygons.points:
+            coords = np.array(contour)
+            coords = np.vstack([coords, coords[0]])  # Close the polygon for QuPath
+            geom = Polygon(coordinates=[coords.tolist()])
+            feature = Feature(
+                geometry=geom, 
+                properties={
+                    "Detection ID": int(detection_id), 
+                    "Class": 1
+                }
+            )
+            features.append(feature)
+
+    return features
+
+
+def mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
+    """
+    Args:
+        segm_mask: Segmentation mask with the background pixels set to zero and the pixels assigned to a segmented 
+        class set to an int value
+
+    Returns:
+        A list containing the contours of each object as a geojson.Feature
+    """
+    features = []
+    indices = np.unique(segmentation_mask)
+    indices = indices[indices != 0] # remove background
+
+    if indices.size == 0:
+        return features
+    
+    for pixel_class in indices:
+        mask = segmentation_mask == int(pixel_class)
+        polygons = Mask(mask).polygons()
+        for detection_id, contour in enumerate(polygons.points, start=1):
+            coords = np.array(contour)
+            coords = np.vstack([coords, coords[0]])  # Close the polygon for QuPath
+            geom = Polygon(coordinates=[coords.tolist()])
+            feature = Feature(
+                geometry=geom, 
+                properties={
+                    "Detection ID": detection_id, 
+                    "Class": pixel_class
+                }
+            )
+            features.append(feature)
+
     return features
 
 
 def features2mask(features, image_shape):
     segmentation_mask = np.zeros(image_shape, dtype=np.uint16)
-    for idx, feature in enumerate(features):
-        label_idx = idx+1  # Labels start at 1
+    for feature in features:
+        feature_coordinates = np.array(feature["geometry"]["coordinates"])
+        feature_coordinates = np.squeeze(feature_coordinates)
+        feature_coordinates = feature_coordinates[:, ::-1]  # Invert XY
+        feature_mask = polygon2mask(image_shape, feature_coordinates)
+        feature_properites = feature.get("properties")
+        feature_class = feature_properites.get("Class")
+        segmentation_mask[feature_mask] = feature_class
+    return segmentation_mask
+
+
+def features2instance_mask(features, image_shape):
+    segmentation_mask = np.zeros(image_shape, dtype=np.uint16)
+    for feature in features:
         feature_coordinates = np.array(feature["geometry"]["coordinates"])
         feature_coordinates = np.squeeze(feature_coordinates)
         feature_coordinates = feature_coordinates[:, ::-1]  # Invert XY
         feature_mask = polygon2mask(image_shape, feature_coordinates)
-        segmentation_mask[feature_mask] = label_idx
+        feature_properites = feature.get("properties")
+        feature_id = feature_properites.get("Detection ID")
+        segmentation_mask[feature_mask] = feature_id
     return segmentation_mask
 
 

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/registry.py

@@ -74,7 +74,7 @@ class Registry:
         #     response = requests.get(f"{self.services.get(algorithm)}/demo")
         #     return HTMLResponse(content=response.text, status_code=response.status_code)
 
-        @self.app.get("/{algorithm}")
+        @self.app.get("/{algorithm}/")
         async def get_algorithm(request: Request, algorithm: str):
             algo_url = self.services.get(algorithm)
             response = requests.get(f"{algo_url}/")

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/serialization.py

@@ -69,8 +69,13 @@ def serialize_result_tuple(result_data_tuple: List[Tuple]) -> List[Dict]:
         if data_type == "image":
             features = serverkit.encode_contents(data.astype(np.float32))
         elif data_type == "labels":
+            data = data.astype(np.uint16)
             features = serverkit.mask2features(data)
             data_params['image_shape'] = data.shape
+        elif data_type == "instance_mask":
+            data = data.astype(np.uint16)
+            features = serverkit.instance_mask2features(data)
+            data_params['image_shape'] = data.shape
         elif data_type == "labels3d":
             features = serverkit.encode_contents(data.astype(np.uint16))
         elif data_type == "points":
@@ -84,8 +89,13 @@ def serialize_result_tuple(result_data_tuple: List[Tuple]) -> List[Dict]:
             features = serverkit.vectors2features(data)
         elif data_type == "tracks":
             features = serverkit.encode_contents(data.astype(np.float32))
+        elif data_type == "class":
+            features = data  # A simple string
+        elif data_type == "text":
+            features = data  # A text string
         else:
             print(f"Unknown data_type: {data_type}")
+            features = None
         
         serialized_results.append(
             {
@@ -113,6 +123,9 @@ def deserialize_result_tuple(serialized_results: List[Dict]) -> List[Tuple]:
         elif data_type == "labels":
             image_shape = data_params.pop('image_shape')
             data = serverkit.features2mask(features, image_shape)
+        elif data_type == "instance_mask":
+            image_shape = data_params.pop('image_shape')
+            data = serverkit.features2instance_mask(features, image_shape)
         elif data_type == "labels3d":
             data = serverkit.decode_contents(features).astype(int)
         elif data_type == "points":
@@ -125,6 +138,10 @@ def deserialize_result_tuple(serialized_results: List[Dict]) -> List[Tuple]:
             data = serverkit.features2vectors(features)
         elif data_type == "tracks":
             data = serverkit.decode_contents(features).astype(float)
+        elif data_type == "class":
+            data = features  # A simple string
+        elif data_type == "text":
+            data = features  # A text string
         else:
             print(f"Unknown data_type: {data_type}")
 

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/server.py

@@ -5,15 +5,15 @@ from typing import List, Tuple, Type
 import imaging_server_kit as serverkit
 import requests
 import yaml
-from fastapi import FastAPI, Request, status
+from fastapi import FastAPI, Request, status, HTTPException
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from imaging_server_kit.web_demo import generate_dash_app
 from pydantic import BaseModel, ConfigDict
 from a2wsgi import WSGIMiddleware
-# from starlette.middleware.wsgi import WSGIMiddleware
 from contextlib import asynccontextmanager
+import asyncio
 
 templates_dir = importlib.resources.files("imaging_server_kit").joinpath("templates")
 static_dir = importlib.resources.files("imaging_server_kit").joinpath("static")
@@ -45,10 +45,20 @@ class Parameters(BaseModel):
 
 
 class Server:
-    def __init__(self, algorithm_name: str, parameters_model: Type[BaseModel]):
+    def __init__(
+        self,
+        algorithm_name: str,
+        parameters_model: Type[BaseModel],
+        metadata_file: str = None,
+    ):
         self.algorithm_name = algorithm_name
         self.parameters_model = parameters_model
 
+        if metadata_file is None:
+            self.metadata_file = "metadata.yaml"
+        else:
+            self.metadata_file = metadata_file
+
         self.app = FastAPI(title=algorithm_name, lifespan=self.lifespan)
         self.app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
 
@@ -65,9 +75,6 @@ class Server:
 
         self.app.mount(f"/{algorithm_name}/demo", WSGIMiddleware(dash_app.server))
 
-        # self.app.on_event("startup")(self.register_with_registry)
-        # self.app.on_event("shutdown")(self.deregister_from_registry)
-
         self.register_routes()
 
         self.services = [self.algorithm_name]
@@ -120,7 +127,7 @@ class Server:
 
         @self.app.get(f"/{self.algorithm_name}/info", response_class=HTMLResponse)
         def info(request: Request):
-            algo_info = load_from_yaml("metadata.yaml")
+            algo_info = load_from_yaml(self.metadata_file)
             algo_params_schema = get_algo_params()
             algo_params = parse_algo_params_schema(algo_params_schema)
             return templates.TemplateResponse(
@@ -132,10 +139,29 @@ class Server:
                 },
             )
 
-        @self.app.post(f"/{self.algorithm_name}/process", status_code=status.HTTP_201_CREATED)
+        @self.app.post(
+            f"/{self.algorithm_name}/process", status_code=status.HTTP_201_CREATED
+        )
         async def run_algo(algo_params: self.parameters_model):
-            result_data_tuple = self.run_algorithm(**algo_params.dict())
-            serialized_results = serverkit.serialize_result_tuple(result_data_tuple)
+            try:
+                result_data_tuple = await asyncio.wait_for(
+                    self._run_algorithm(**algo_params.dict()), timeout=600
+                )
+            except (
+                asyncio.TimeoutError
+            ):  # This works but doesn't actually kill the process... we need something else to terminate it
+                raise HTTPException(
+                    status_code=504, detail="Request timeout during processing."
+                )
+            try:
+                serialized_results = await asyncio.wait_for(
+                    self._serialize_result_tuple(result_data_tuple), timeout=600
+                )
+            except asyncio.TimeoutError:
+                raise HTTPException(
+                    status_code=504, detail="Request timeout during serialization."
+                )
+
             return serialized_results
 
         @self.app.get(f"/{self.algorithm_name}/parameters", response_model=dict)
@@ -150,6 +176,16 @@ class Server:
             ]
             return {"sample_images": encoded_images}
 
+    async def _serialize_result_tuple(self, result_data_tuple):
+        serialized_results = await asyncio.to_thread(
+            serverkit.serialize_result_tuple, result_data_tuple
+        )
+        return serialized_results
+
+    async def _run_algorithm(self, **algo_params):
+        result_data_tuple = await asyncio.to_thread(self.run_algorithm, **algo_params)
+        return result_data_tuple
+
     def load_sample_images(self) -> List["np.ndarray"]:
         raise NotImplementedError("Subclasses should implement this method")
 

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit/templates/info.html

@@ -38,7 +38,7 @@
                     <p>Server Kit Repository</p>
                 </div>
             </a>
-            <a href="/demo">
+            <a href="demo">
                 <div class="card-category">
                     <i class="fa-solid fa-rocket"></i>
                     <p>Web demo</p>
@@ -46,7 +46,6 @@
             </a>
         </div>
 
-        <!-- <h3><strong>Parameters</strong></h3> -->
         <table>
             <thead>
                 <tr>

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: imaging-server-kit
-Version: 0.0.3
+Version: 0.0.5
 Summary: Deploy image processing algorithms in FastAPI servers. 
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -31,8 +31,8 @@ License: Copyright (c) 2024, EPFL
         OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
         
-Project-URL: homepage, https://gitlab.com/epfl-center-for-imaging/imaging-server-kit
-Project-URL: repository, https://gitlab.com/epfl-center-for-imaging/imaging-server-kit
+Project-URL: homepage, https://github.com/Imaging-Server-Kit/imaging-server-kit
+Project-URL: repository, https://github.com/Imaging-Server-Kit/imaging-server-kit
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -53,6 +53,8 @@ Requires-Dist: python-multipart
 Requires-Dist: tifffile
 Requires-Dist: numpy
 Requires-Dist: scikit-image
+Requires-Dist: opencv-contrib-python-headless
+Requires-Dist: imantics
 Requires-Dist: geojson
 Requires-Dist: jinja2
 Requires-Dist: pyyaml
@@ -64,7 +66,12 @@ Requires-Dist: pytest
 ![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
-Deploy image processing algorithms in FastAPI servers and easily run them in Napari, QuPath, and more.
+Deploy image processing algorithms in FastAPI servers and easily run them from Napari, QuPath, and more.
+
+The algorithm servers implement a common set of API endpoints for processing and to document the project. These include:
+  - `/process`: Runs the algorithm
+  - `/info`: Displays documentation about the algorithm usage
+  - `/sample_images`: Provides one or multiple sample images
 
 ## Usage
 
@@ -72,22 +79,23 @@ Deploy image processing algorithms in FastAPI servers and easily run them in Nap
 
 Set up and run a server with one, or multiple algorithms from the Imaging Server Kit collection (or your own):
 
-- [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist)
-- [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose)
-- [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow)
-- [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg)
-- [Scikit-image LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG)
-- [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy)
+  - [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist): Object detection with star-convex shapes
+  - [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose): A generalist algorithm for cellular segmentation
+  - [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow): Accurate and efficient spot detection
+  - [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg): A tool to remove images background
+  - [LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG): Laplacian of Gaussian filter
+  - [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy): Measurement of greyscale orientations
 <!-- - [Tau Fibrils Detector](https://github.com/Imaging-Server-Kit/serverkit-tau-fibrils-yolo) -->
 
-To do that, the recommended way is to edit a `docker-compose.yml` file and pull server images from `registry.rcp.epfl.ch` (EPFL users only):
+All of these algorithm servers can be installed locally or built and run with docker. To use docker and serve multiple algorithms, the recommended way is to edit a `docker-compose.yml` file and pull server images from `registry.rcp.epfl.ch` (EPFL users only):
 
 ```{docker-compose.yml}
 services:
   servers_registry:
-    image: mallorywittwerepfl/imaging-server-kit:registry
+    image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
+    command: python3 start_registry.py
   rembg:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
     depends_on:

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@
 .gitignore
 Dockerfile
 Dockerfile-GPU
-Dockerfile-registry
 LICENSE
 MANIFEST.in
 README.md

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.5}/src/imaging_server_kit.egg-info/requires.txt

@@ -4,6 +4,8 @@ python-multipart
 tifffile
 numpy
 scikit-image
+opencv-contrib-python-headless
+imantics
 geojson
 jinja2
 pyyaml

imaging_server_kit-0.0.5/start_registry.py

@@ -0,0 +1,8 @@
+import uvicorn
+import imaging_server_kit as serverkit
+
+server = serverkit.Registry()
+app = server.app
+
+if __name__=='__main__':
+    uvicorn.run("start_registry:app", host="0.0.0.0", port=8000)

imaging_server_kit-0.0.3/Dockerfile-registry

@@ -1,5 +0,0 @@
-FROM mallorywittwerepfl/imaging-server-kit:3.9
-
-COPY start_registry.py .
-
-CMD ["uvicorn", "start_registry:app", "--host", "0.0.0.0", "--port", "8000"]

imaging_server_kit-0.0.3/build.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-PYTHON_VERSIONS=("3.9" "3.10" "3.11")
-
-for version in "${PYTHON_VERSIONS[@]}"; do
-  echo "Building image for Python $version..."
-  docker build --build-arg PYTHON_VERSION=$version -t imaging-server-kit:$version .
-done
-
-# echo "Building image for Python 3.9, GPU-compatible..."
-# docker build -t imaging-server-kit:gpu --file Dockerfile-GPU .
-
-echo "Building image for Python 3.9, serverkit registry..."
-docker build -t imaging-server-kit:registry --file Dockerfile-registry .

imaging_server_kit-0.0.3/start_registry.py

@@ -1,4 +0,0 @@
-import imaging_server_kit as serverkit
-
-server = serverkit.Registry()
-app = server.app