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

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

@@ -0,0 +1,189 @@
+Metadata-Version: 2.2
+Name: imaging-server-kit
+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
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        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
+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 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]
+Requires-Dist: python-multipart
+Requires-Dist: tifffile
+Requires-Dist: numpy
+Requires-Dist: scikit-image
+Requires-Dist: geojson
+Requires-Dist: jinja2
+Requires-Dist: pyyaml
+Requires-Dist: dash
+Requires-Dist: dash-bootstrap-components
+Requires-Dist: a2wsgi
+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 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
+
+### Algorithm servers
+
+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): 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) -->
+
+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
+    ports:
+      - "8000:8000"
+  rembg:
+    image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
+    depends_on:
+      - servers_registry
+  skimage-log:
+    image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-skimage-log:latest
+    depends_on:
+      - servers_registry
+```
+
+Start the server with
+
+```
+docker compose up
+```
+
+The server should be accessible at http://localhost:8000.
+
+**Build the docker images yourself**
+
+To build the algorithm server images yourself (e.g. if you are not from EPFL), see [Reference Deployment](https://github.com/Imaging-Server-Kit/serverkit-deploy-docker).
+
+**Create a server for your project**
+
+To learn how to create a server for your project, see [Algorithm Server Template](https://github.com/Imaging-Server-Kit/cookiecutter-serverkit).
+
+### Python client
+
+Once the server is running, connect to it and run algorithms from Python:
+
+```python
+from imaging_server_kit import Client
+
+client = Client("http://localhost:8000")
+
+print(client.algorithms)
+# [`rembg`, `stardist`, `cellpose`]
+
+algo_output = client.run_algorithm(
+    algorithm="rembg",
+    image=(...),
+    rembg_model_name="silueta",
+)
+```
+
+### Napari plugin
+
+Once the server is running, use the [Napari Server Kit](https://github.com/Imaging-Server-Kit/napari-serverkit) plugin to connect to it and run algorithms in Napari.
+
+### QuPath extension
+
+Once the server is running, use the [QuPath Extension Server Kit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit) to connect to it and run algorithms from within QuPath.
+
+## Install locally
+
+Install the `imaging-server-kit` package with `pip`:
+
+```
+pip install imaging-server-kit
+```
+
+or clone the project and install the development version:
+
+```
+git clone https://github.com/Imaging-Server-Kit/imaging-server-kit.git
+cd imaging-server-kit
+pip install -e .
+```
+
+## Build with `docker`
+
+Build the `imaging-server-kit` docker image for a specific Python version:
+
+```
+docker build --build-arg PYTHON_VERSION=3.9 -t imaging-server-kit:3.9 .
+```
+
+Run [build.sh](./build.sh) to build docker images for Python 3.9, 3.10, 3.11, GPU and the server kit registry:
+
+```
+bash ./build.sh
+```
+
+## Contributing
+
+Contributions are very welcome.
+
+## License
+
+This software is distributed under the terms of the [BSD-3](http://opensource.org/licenses/BSD-3-Clause) license.
+
+## Issues
+
+If you encounter any problems, please file an issue along with a detailed description.

imaging_server_kit-0.0.4/README.md

@@ -0,0 +1,126 @@
+![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 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
+
+### Algorithm servers
+
+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): 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) -->
+
+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
+    ports:
+      - "8000:8000"
+  rembg:
+    image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
+    depends_on:
+      - servers_registry
+  skimage-log:
+    image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-skimage-log:latest
+    depends_on:
+      - servers_registry
+```
+
+Start the server with
+
+```
+docker compose up
+```
+
+The server should be accessible at http://localhost:8000.
+
+**Build the docker images yourself**
+
+To build the algorithm server images yourself (e.g. if you are not from EPFL), see [Reference Deployment](https://github.com/Imaging-Server-Kit/serverkit-deploy-docker).
+
+**Create a server for your project**
+
+To learn how to create a server for your project, see [Algorithm Server Template](https://github.com/Imaging-Server-Kit/cookiecutter-serverkit).
+
+### Python client
+
+Once the server is running, connect to it and run algorithms from Python:
+
+```python
+from imaging_server_kit import Client
+
+client = Client("http://localhost:8000")
+
+print(client.algorithms)
+# [`rembg`, `stardist`, `cellpose`]
+
+algo_output = client.run_algorithm(
+    algorithm="rembg",
+    image=(...),
+    rembg_model_name="silueta",
+)
+```
+
+### Napari plugin
+
+Once the server is running, use the [Napari Server Kit](https://github.com/Imaging-Server-Kit/napari-serverkit) plugin to connect to it and run algorithms in Napari.
+
+### QuPath extension
+
+Once the server is running, use the [QuPath Extension Server Kit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit) to connect to it and run algorithms from within QuPath.
+
+## Install locally
+
+Install the `imaging-server-kit` package with `pip`:
+
+```
+pip install imaging-server-kit
+```
+
+or clone the project and install the development version:
+
+```
+git clone https://github.com/Imaging-Server-Kit/imaging-server-kit.git
+cd imaging-server-kit
+pip install -e .
+```
+
+## Build with `docker`
+
+Build the `imaging-server-kit` docker image for a specific Python version:
+
+```
+docker build --build-arg PYTHON_VERSION=3.9 -t imaging-server-kit:3.9 .
+```
+
+Run [build.sh](./build.sh) to build docker images for Python 3.9, 3.10, 3.11, GPU and the server kit registry:
+
+```
+bash ./build.sh
+```
+
+## Contributing
+
+Contributions are very welcome.
+
+## License
+
+This software is distributed under the terms of the [BSD-3](http://opensource.org/licenses/BSD-3-Clause) license.
+
+## Issues
+
+If you encounter any problems, please file an issue along with a detailed description.

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.2 → 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.2 → imaging_server_kit-0.0.4}/pyproject.toml

@@ -29,11 +29,11 @@ dependencies = [
     "numpy",
     "scikit-image",
     "geojson",
-    "docker",  # For the autostartup regsitry
     "jinja2",  # For the /info route
     "pyyaml",  # For the /info route
     "dash",  # For the dash app
     "dash-bootstrap-components",  # For the dash app
+    "a2wsgi",  # For the dash app
     "pytest",  # For testing
 ]
 

{imaging_server_kit-0.0.2 → imaging_server_kit-0.0.4}/src/imaging_server_kit/__init__.py

@@ -1,8 +1,12 @@
-from imaging_server_kit._version import __version__
+from ._version import version as __version__
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
 from imaging_server_kit.client import Client
 from imaging_server_kit.server import Server, Parameters
 from imaging_server_kit.registry import Registry
-from imaging_server_kit.autostartup_registry import AutoStartupRegistry
 from imaging_server_kit.encoding import encode_contents, decode_contents
 from imaging_server_kit.serialization import (
     serialize_result_tuple,

{imaging_server_kit-0.0.2 → 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.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.4'
+__version_tuple__ = version_tuple = (0, 0, 4)

{imaging_server_kit-0.0.2 → 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:
@@ -52,7 +53,7 @@ class Client:
         algo_params_encoded = self._encode_numpy_parameters(algo_params)
 
         try:
-            endpoint = f"{self.server_url}/{algorithm}/"
+            endpoint = f"{self.server_url}/{algorithm}/process"
             response = requests.post(
                 endpoint,
                 json=algo_params_encoded,
@@ -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.2 → 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.2 → 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.2 → imaging_server_kit-0.0.4}/src/imaging_server_kit/registry.py

@@ -74,17 +74,17 @@ 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}/")
             return response.json()
 
-        @self.app.post("/{algorithm}", status_code=status.HTTP_201_CREATED)
+        @self.app.post("/{algorithm}/process", status_code=status.HTTP_201_CREATED)
         async def run_algorithm(algorithm, request: Request):
             algo_url = self.services.get(algorithm)
             data = await request.json()
-            response = requests.post(f"{algo_url}/{algorithm}/", json=data)
+            response = requests.post(f"{algo_url}/{algorithm}/process", json=data)
             return response.json()
 
         @self.app.get("/{algorithm}/parameters")

{imaging_server_kit-0.0.2 → 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.2 → imaging_server_kit-0.0.4}/src/imaging_server_kit/server.py

@@ -5,13 +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 starlette.middleware.wsgi import WSGIMiddleware
+from a2wsgi 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")
@@ -47,7 +49,7 @@ class Server:
         self.algorithm_name = algorithm_name
         self.parameters_model = parameters_model
 
-        self.app = FastAPI(title=algorithm_name)
+        self.app = FastAPI(title=algorithm_name, lifespan=self.lifespan)
         self.app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
 
         # Set up the web demo app
@@ -63,14 +65,17 @@ 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]
 
-    def register_with_registry(self):
+    @asynccontextmanager
+    async def lifespan(self, app: FastAPI):
+        await self.register_with_registry()
+        yield
+        await self.deregister_from_registry()
+
+    async def register_with_registry(self):
         try:
             response = requests.get(f"{REGISTRY_URL}/")
         except Exception:
@@ -89,7 +94,7 @@ class Server:
         else:
             print(f"Failed to register {self.algorithm_name}: {response.json()}")
 
-    def deregister_from_registry(self):
+    async def deregister_from_registry(self):
         deregister_url = f"{REGISTRY_URL}/deregister"
         response = requests.post(deregister_url, json={"name": self.algorithm_name})
         if response.status_code == 201:
@@ -124,12 +129,20 @@ class Server:
                 },
             )
 
-        @self.app.post(f"/{self.algorithm_name}/", 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=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()
@@ -142,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")