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

{imaging_server_kit-0.0.4 → 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.4 → 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.4 → 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.4
+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
@@ -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
@@ -50,9 +50,13 @@ 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
+Requires-Dist: opencv-contrib-python-headless
+Requires-Dist: imantics
 Requires-Dist: geojson
 Requires-Dist: jinja2
 Requires-Dist: pyyaml
@@ -60,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
@@ -89,18 +94,19 @@ All of these algorithm servers can be installed locally or built and run with do
 
 ```{docker-compose.yml}
 services:
-  servers_registry:
-    image: mallorywittwerepfl/imaging-server-kit:registry
+  algorithm_hub:
+    image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
+    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
@@ -170,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.4 → imaging_server_kit-0.0.6}/README.md

@@ -26,18 +26,19 @@ All of these algorithm servers can be installed locally or built and run with do
 
 ```{docker-compose.yml}
 services:
-  servers_registry:
-    image: mallorywittwerepfl/imaging-server-kit:registry
+  algorithm_hub:
+    image: mallorywittwerepfl/imaging-server-kit:latest
     ports:
       - "8000:8000"
+    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
@@ -107,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.4 → imaging_server_kit-0.0.6}/pyproject.toml

@@ -25,9 +25,13 @@ dependencies = [
     "fastapi",
     "uvicorn[standard]",
     "python-multipart",
+    "fastapi-users[sqlalchemy]",
+    "aiosqlite",
     "tifffile",
     "numpy",
     "scikit-image",
+    "opencv-contrib-python-headless",
+    "imantics",
     "geojson",
     "jinja2",  # For the /info route
     "pyyaml",  # For the /info route
@@ -38,8 +42,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.4 → 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,
@@ -14,7 +16,13 @@ from imaging_server_kit.serialization import (
 )
 from imaging_server_kit.geometry import (
     mask2features,
+    instance_mask2features,
     features2mask,
+    features2instance_mask,
+    features2mask_3d,
+    mask2features_3d,
+    instance_mask2features_3d,
+    features2instance_mask_3d,
     boxes2features,
     features2boxes,
     points2features,

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

imaging_server_kit-0.0.4/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.4 → 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: