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

{imaging_server_kit-0.0.5 → imaging_server_kit-0.0.6}/Dockerfile

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

{imaging_server_kit-0.0.5 → imaging_server_kit-0.0.6}/Dockerfile-GPU

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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: imaging-server-kit
-Version: 0.0.5
+Version: 0.0.6
 Summary: Deploy image processing algorithms in FastAPI servers. 
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -50,6 +50,8 @@ License-File: LICENSE
 Requires-Dist: fastapi
 Requires-Dist: uvicorn[standard]
 Requires-Dist: python-multipart
+Requires-Dist: fastapi-users[sqlalchemy]
+Requires-Dist: aiosqlite
 Requires-Dist: tifffile
 Requires-Dist: numpy
 Requires-Dist: scikit-image
@@ -62,6 +64,7 @@ Requires-Dist: dash
 Requires-Dist: dash-bootstrap-components
 Requires-Dist: a2wsgi
 Requires-Dist: pytest
+Dynamic: license-file
 
 ![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
@@ -91,19 +94,19 @@ All of these algorithm servers can be installed locally or built and run with do
 
 ```{docker-compose.yml}
 services:
-  servers_registry:
+  algorithm_hub:
     image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
-    command: python3 start_registry.py
+    command: python3 start_algorithm_hub.py
   rembg:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
     depends_on:
-      - servers_registry
+      - algorithm_hub
   skimage-log:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-skimage-log:latest
     depends_on:
-      - servers_registry
+      - algorithm_hub
 ```
 
 Start the server with
@@ -173,7 +176,7 @@ 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:
+Run [build.sh](./build.sh) to build docker images for Python 3.9, 3.10, 3.11, GPU and the algorithm hub:
 
 ```
 bash ./build.sh

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

@@ -26,19 +26,19 @@ All of these algorithm servers can be installed locally or built and run with do
 
 ```{docker-compose.yml}
 services:
-  servers_registry:
+  algorithm_hub:
     image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
-    command: python3 start_registry.py
+    command: python3 start_algorithm_hub.py
   rembg:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-rembg:latest
     depends_on:
-      - servers_registry
+      - algorithm_hub
   skimage-log:
     image: registry.rcp.epfl.ch/imaging-server-kit/serverkit-skimage-log:latest
     depends_on:
-      - servers_registry
+      - algorithm_hub
 ```
 
 Start the server with
@@ -108,7 +108,7 @@ 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:
+Run [build.sh](./build.sh) to build docker images for Python 3.9, 3.10, 3.11, GPU and the algorithm hub:
 
 ```
 bash ./build.sh

imaging_server_kit-0.0.6/main.py

@@ -0,0 +1,10 @@
+import uvicorn
+import imaging_server_kit as serverkit
+
+server = serverkit.AlgorithmServer(
+    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.5 → imaging_server_kit-0.0.6}/pyproject.toml

@@ -25,6 +25,8 @@ dependencies = [
     "fastapi",
     "uvicorn[standard]",
     "python-multipart",
+    "fastapi-users[sqlalchemy]",
+    "aiosqlite",
     "tifffile",
     "numpy",
     "scikit-image",

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

@@ -1,12 +1,14 @@
 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.server import AlgorithmServer, Parameters
+from imaging_server_kit.authenticated_server import AuthenticatedAlgorithmServer
+from imaging_server_kit.algorithm_hub import AlgorithmHub
 from imaging_server_kit.encoding import encode_contents, decode_contents
 from imaging_server_kit.serialization import (
     serialize_result_tuple,
@@ -17,6 +19,10 @@ from imaging_server_kit.geometry import (
     instance_mask2features,
     features2mask,
     features2instance_mask,
+    features2mask_3d,
+    mask2features_3d,
+    instance_mask2features_3d,
+    features2instance_mask_3d,
     boxes2features,
     features2boxes,
     points2features,

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

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.5'
-__version_tuple__ = version_tuple = (0, 0, 5)
+__version__ = version = '0.0.6'
+__version_tuple__ = version_tuple = (0, 0, 6)

imaging_server_kit-0.0.5/src/imaging_server_kit/registry.py → imaging_server_kit-0.0.6/src/imaging_server_kit/algorithm_hub.py

@@ -11,7 +11,7 @@ static_dir = importlib.resources.files("imaging_server_kit").joinpath("static")
 templates = Jinja2Templates(directory=str(templates_dir))
 
 
-class Registry:
+class AlgorithmHub:
     def __init__(self) -> None:
         self.app = FastAPI()
         self.app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")

imaging_server_kit-0.0.6/src/imaging_server_kit/authenticated_server.py

@@ -0,0 +1,249 @@
+import importlib.resources
+import os
+from typing import List, Tuple, Type
+
+import imaging_server_kit as serverkit
+import requests
+import yaml
+from fastapi import FastAPI, Request, status, HTTPException, Depends
+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 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")
+
+templates = Jinja2Templates(directory=str(templates_dir))
+
+PROCESS_TIMEOUT_SEC = 3600
+
+from imaging_server_kit.users_utils import (
+    create_db_and_tables,
+    fastapi_users,
+    auth_backend,
+    UserRead,
+    UserUpdate,
+    UserCreate,
+    User,
+    current_active_user,
+)
+
+
+def load_from_yaml(file_path: str):
+    with open(file_path, "r") as file:
+        data = yaml.safe_load(file)
+    return data
+
+
+def parse_algo_params_schema(algo_params_schema):
+    algo_params = algo_params_schema.get("properties")
+    required_params = algo_params_schema.get("required")
+    for param in algo_params.keys():
+        algo_params[param]["required"] = param in required_params
+    return algo_params
+
+
+ALGORITHM_HUB_URL = os.getenv("ALGORITHM_HUB_URL", "http://algorithm_hub:8000")
+
+
+class Parameters(BaseModel):
+    ...
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AuthenticatedAlgorithmServer:
+    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)
+
+        # Users
+        self.app.include_router(
+            fastapi_users.get_auth_router(auth_backend),
+            prefix="/auth/jwt",
+            tags=["auth"],
+        )
+        self.app.include_router(
+            fastapi_users.get_register_router(UserRead, UserCreate),
+            prefix="/auth",
+            tags=["auth"],
+        )
+        self.app.include_router(
+            fastapi_users.get_reset_password_router(),
+            prefix="/auth",
+            tags=["auth"],
+        )
+        self.app.include_router(
+            fastapi_users.get_verify_router(UserRead),
+            prefix="/auth",
+            tags=["auth"],
+        )
+        self.app.include_router(
+            fastapi_users.get_users_router(UserRead, UserUpdate),
+            prefix="/users",
+            tags=["users"],
+        )
+
+        # Info HTML
+        self.app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+        # Web demo app
+        algo_params = parameters_model.model_json_schema().get("properties")
+
+        dash_app = generate_dash_app(
+            algorithm_name,
+            algo_params,
+            run_fnct=self.run_algorithm,
+            sample_image_fnct=self.load_sample_images,
+            prefix=f"/{algorithm_name}/demo/",
+        )
+
+        self.app.mount(f"/{algorithm_name}/demo", WSGIMiddleware(dash_app.server))
+
+        self.register_routes()
+
+        self.services = [self.algorithm_name]
+
+    @asynccontextmanager
+    async def lifespan(self, app: FastAPI):
+        await self.register_with_algohub()
+        await create_db_and_tables()
+        yield
+        await self.deregister_from_algohub()
+
+    async def register_with_algohub(self):
+        try:
+            response = requests.get(f"{ALGORITHM_HUB_URL}/")
+        except Exception:
+            print("Algorithm hub unavailable.")
+            return
+
+        response = requests.post(
+            f"{ALGORITHM_HUB_URL}/register",
+            json={
+                "name": self.algorithm_name,
+                "url": f"http://{self.algorithm_name}:8000",
+            },
+        )
+        if response.status_code == 201:
+            print(f"Service {self.algorithm_name} registered successfully.")
+        else:
+            print(f"Failed to register {self.algorithm_name}: {response.json()}")
+
+    async def deregister_from_algohub(self):
+        deregister_url = f"{ALGORITHM_HUB_URL}/deregister"
+        response = requests.post(deregister_url, json={"name": self.algorithm_name})
+        if response.status_code == 201:
+            print(f"Service {self.algorithm_name} deregistered.")
+        else:
+            print(f"Failed to deregister {self.algorithm_name}: {response.json()}")
+
+    def register_routes(self):
+        @self.app.get("/")
+        def home():
+            return list_services()
+
+        @self.app.get("/services")
+        def list_services():
+            return {"services": self.services}
+
+        @self.app.get("/version")
+        def get_version():
+            return serverkit.__version__
+
+        @self.app.get(f"/{self.algorithm_name}/info", response_class=HTMLResponse)
+        def info(request: Request):
+            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(
+                "info.html",
+                {
+                    "request": request,
+                    "algo_info": algo_info,
+                    "algo_params": algo_params,
+                },
+            )
+
+        @self.app.get(f"/register", response_class=HTMLResponse)
+        def register(request: Request):
+            return templates.TemplateResponse("register.html", {"request": request})
+
+        @self.app.get(f"/login", response_class=HTMLResponse)
+        def login(request: Request):
+            return templates.TemplateResponse("login.html", {"request": request})
+
+        @self.app.post(
+            f"/{self.algorithm_name}/process", status_code=status.HTTP_201_CREATED
+        )
+        async def run_algo(
+            algo_params: self.parameters_model,
+            user: User = Depends(current_active_user),
+        ):
+            try:
+                result_data_tuple = await asyncio.wait_for(
+                    self._run_algorithm(**algo_params.dict()),
+                    timeout=PROCESS_TIMEOUT_SEC,
+                )
+            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=PROCESS_TIMEOUT_SEC,
+                )
+            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()
+
+        @self.app.get(f"/{self.algorithm_name}/sample_images", response_model=dict)
+        def get_sample_images():
+            images = self.load_sample_images()
+            encoded_images = [
+                {"sample_image": serverkit.encode_contents(image)} for image in images
+            ]
+            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.5 → imaging_server_kit-0.0.6}/src/imaging_server_kit/client.py

@@ -1,4 +1,5 @@
 import requests
+import webbrowser
 from typing import List, Dict, Tuple
 import numpy as np
 import imaging_server_kit as serverkit
@@ -17,6 +18,8 @@ class Client:
         self._algorithms = {}
         if server_url != "":
             self.connect(server_url)
+        
+        self.token = None
 
     def connect(self, server_url: str) -> None:
         self.server_url = server_url
@@ -31,6 +34,31 @@ class Client:
             self.algorithms = services
         else:
             raise AlgorithmServerError(response.status_code, response.text)
+        
+    # def browser_login(self):
+    #     webbrowser.open(f"{self.server_url}/login")
+    #     # How to retreive the access_token when the user logs in via the web page?
+    #     # self.token = [...]
+    #     # This might be complicated...
+    
+    def login(self, username, password):
+        endpoint = f"{self.server_url}/auth/jwt/login"
+        try:
+            response = requests.post(
+                endpoint,
+                data={
+                    "username": username,
+                    "password": password,
+                },
+            )
+        except requests.exceptions.RequestException as e:
+            raise ServerRequestError(endpoint, e)
+
+        if response.status_code == 200:
+            token = response.json().get("access_token")
+            self.token = token
+        else:
+            raise AlgorithmServerError(response.status_code, response.text)
 
     @property
     def server_url(self) -> str:
@@ -60,6 +88,7 @@ class Client:
                 headers={
                     "Content-Type": "application/json",
                     "accept": "application/json",
+                    "Authorization": f"Bearer {self.token}",
                 },
             )
         except requests.exceptions.RequestException as e:
@@ -111,10 +140,7 @@ class Client:
                     return image
             return images
         else:
-            print(
-                f"Error status while attempting to get algorithm sample images: {response.status_code}"
-            )
-            return -1
+            raise AlgorithmServerError(response.status_code, response.text)
 
     def _validate_algorithm(self, algorithm=None) -> str:
         if algorithm is None:

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

@@ -5,11 +5,11 @@ import numpy as np
 from imantics import Mask
 
 
-def instance_mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
+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
-         object instance set to an int value
+        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
@@ -21,18 +21,18 @@ def instance_mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
     if indices.size == 0:
         return features
     
-    for detection_id in indices:
-        mask = segmentation_mask == int(detection_id)
+    for pixel_class in indices:
+        mask = segmentation_mask == int(pixel_class)
         polygons = Mask(mask).polygons()
-        for contour in polygons.points:
+        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": int(detection_id), 
-                    "Class": 1
+                    "Detection ID": detection_id, 
+                    "Class": int(pixel_class),  # the int() casting solves a bug with json serialization
                 }
             )
             features.append(feature)
@@ -40,11 +40,24 @@ def instance_mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
     return features
 
 
-def mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
+def features2mask(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)
+        feature_properites = feature.get("properties")
+        feature_class = feature_properites.get("Class")
+        segmentation_mask[feature_mask] = feature_class
+    return segmentation_mask
+
+
+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 
-        class set to an int value
+        segm_mask: Segmentation mask with the background pixels set to zero and the pixels assigned to a segmented
+         object instance set to an int value
 
     Returns:
         A list containing the contours of each object as a geojson.Feature
@@ -56,18 +69,18 @@ def mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
     if indices.size == 0:
         return features
     
-    for pixel_class in indices:
-        mask = segmentation_mask == int(pixel_class)
+    for detection_id in indices:
+        mask = segmentation_mask == int(detection_id)
         polygons = Mask(mask).polygons()
-        for detection_id, contour in enumerate(polygons.points, start=1):
+        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": detection_id, 
-                    "Class": pixel_class
+                    "Detection ID": int(detection_id), 
+                    "Class": 1
                 }
             )
             features.append(feature)
@@ -75,7 +88,7 @@ def mask2features(segmentation_mask: np.ndarray) -> List[Feature]:
     return features
 
 
-def features2mask(features, image_shape):
+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"])
@@ -83,21 +96,58 @@ def features2mask(features, image_shape):
         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
+        feature_id = feature_properites.get("Detection ID")
+        segmentation_mask[feature_mask] = feature_id
     return segmentation_mask
 
 
-def features2instance_mask(features, image_shape):
+def mask2features_3d(segmentation_mask: np.ndarray) -> List[Feature]:
+    features = []
+    for z_idx, mask_2d in enumerate(segmentation_mask):
+        features_2d = mask2features(mask_2d)
+        for feature_2d in features_2d:
+            feature_2d.properties["z_idx"] = z_idx
+            features.append(feature_2d)
+    return features
+
+
+def features2mask_3d(features, image_shape):
     segmentation_mask = np.zeros(image_shape, dtype=np.uint16)
+    _, ry, rx = image_shape
     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_xy_coordinates = np.array(feature["geometry"]["coordinates"])
+        feature_xy_coordinates = np.squeeze(feature_xy_coordinates)
+        feature_xy_coordinates = feature_xy_coordinates[:, ::-1]  # Invert XY
+        feature_mask = polygon2mask((ry, rx), feature_xy_coordinates)
+        feature_z_idx = feature["properties"]["z_idx"]
+        feature_properites = feature.get("properties")
+        feature_id = feature_properites.get("Class")
+        segmentation_mask[feature_z_idx][feature_mask] = feature_id
+    return segmentation_mask
+
+
+def instance_mask2features_3d(segmentation_mask: np.ndarray) -> List[Feature]:
+    features = []
+    for z_idx, mask_2d in enumerate(segmentation_mask):
+        features_2d = instance_mask2features(mask_2d)
+        for feature_2d in features_2d:
+            feature_2d.properties["z_idx"] = z_idx
+            features.append(feature_2d)
+    return features
+
+
+def features2instance_mask_3d(features, image_shape):
+    segmentation_mask = np.zeros(image_shape, dtype=np.uint16)
+    _, ry, rx = image_shape
+    for feature in features:
+        feature_xy_coordinates = np.array(feature["geometry"]["coordinates"])
+        feature_xy_coordinates = np.squeeze(feature_xy_coordinates)
+        feature_xy_coordinates = feature_xy_coordinates[:, ::-1]  # Invert XY
+        feature_mask = polygon2mask((ry, rx), feature_xy_coordinates)
+        feature_z_idx = feature["properties"]["z_idx"]
         feature_properites = feature.get("properties")
         feature_id = feature_properites.get("Detection ID")
-        segmentation_mask[feature_mask] = feature_id
+        segmentation_mask[feature_z_idx][feature_mask] = feature_id
     return segmentation_mask