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

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: imaging-server-kit
-Version: 0.0.3
+Version: 0.0.4
 Summary: Deploy image processing algorithms in FastAPI servers. 
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -64,7 +64,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,15 +77,15 @@ 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:

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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,15 +14,15 @@ 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:

imaging_server_kit-0.0.4/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.4}/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.4}/src/imaging_server_kit/_version.py

@@ -12,5 +12,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.4'
+__version_tuple__ = version_tuple = (0, 0, 4)

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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.4}/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.4}/src/imaging_server_kit/geometry.py

@@ -17,37 +17,34 @@ def mask2features(segmentation_mask: np.ndarray) -> List[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]
+
+    if indices.size == 0:
+        return features
+
+    # TODO: This is really inefficient for big images! Will need to improve it.
+    for i in indices.tolist():
+        mask = np.array(segmentation_mask == i)
+        mask = np.pad(mask > 0, 1)
+        contours_find = find_contours(mask, 0.5)
+        for detection_id, contour in enumerate(contours_find):
             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}))
+            features.append(Feature(geometry=geom, properties={"Detection ID": detection_id, "Class": i}))
+
     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
         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_class = feature_properites.get("Class")
+        segmentation_mask[feature_mask] = feature_class
     return segmentation_mask
 
 

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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.4}/src/imaging_server_kit/serialization.py

@@ -69,6 +69,7 @@ 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 == "labels3d":

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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")
@@ -65,9 +65,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]
@@ -134,10 +131,18 @@ class Server:
 
         @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=60)
+            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=10)
+            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)
         def get_algo_params():
             return self.parameters_model.model_json_schema()
@@ -150,8 +155,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")
-
+    
     def run_algorithm(self, **algo_params) -> List[Tuple]:
         raise NotImplementedError("Subclasses should implement this method")

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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.4}/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.4
 Summary: Deploy image processing algorithms in FastAPI servers. 
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -64,7 +64,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,15 +77,15 @@ 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:

{imaging_server_kit-0.0.3 → imaging_server_kit-0.0.4}/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.4/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