lightly-studio 0.3.1__py3-none-any.whl

lightly_studio/api/routes/api/settings.py

@@ -0,0 +1,45 @@
+"""This module contains the API routes for user settings."""
+
+from fastapi import APIRouter, Depends
+from sqlmodel import Session
+from typing_extensions import Annotated
+
+from lightly_studio.api.db import get_session
+from lightly_studio.models.settings import SettingView
+from lightly_studio.resolvers import settings_resolver
+
+settings_router = APIRouter(tags=["settings"])
+
+SessionDep = Annotated[Session, Depends(get_session)]
+
+
+@settings_router.get("/settings")
+def get_settings(
+    session: SessionDep,
+) -> SettingView:
+    """Get the current settings.
+
+    Args:
+        session: Database session.
+
+    Returns:
+        The current settings.
+    """
+    return settings_resolver.get_settings(session=session)
+
+
+@settings_router.post("/settings")
+def set_settings(
+    settings: SettingView,
+    session: SessionDep,
+) -> SettingView:
+    """Update user settings.
+
+    Args:
+        settings: New settings to apply.
+        session: Database session.
+
+    Returns:
+        Updated settings.
+    """
+    return settings_resolver.set_settings(session=session, settings=settings)

lightly_studio/api/routes/api/status.py

@@ -0,0 +1,19 @@
+"""HTTP status codes for use in tests and responses."""
+
+HTTP_STATUS_OK = 200
+HTTP_STATUS_CREATED = 201
+HTTP_STATUS_ACCEPTED = 202
+HTTP_STATUS_NO_CONTENT = 204
+
+HTTP_STATUS_BAD_REQUEST = 400
+HTTP_STATUS_UNAUTHORIZED = 401
+HTTP_STATUS_FORBIDDEN = 403
+HTTP_STATUS_NOT_FOUND = 404
+HTTP_STATUS_CONFLICT = 409
+HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415
+HTTP_STATUS_UNPRECESSABLE_ENTITY = 422
+
+HTTP_STATUS_INTERNAL_SERVER_ERROR = 500
+HTTP_STATUS_NOT_IMPLEMENTED = 501
+HTTP_STATUS_BAD_GATEWAY = 502
+HTTP_STATUS_SERVICE_UNAVAILABLE = 503

lightly_studio/api/routes/api/text_embedding.py

@@ -0,0 +1,48 @@
+"""This module contains the API routes for managing text embedding."""
+
+from __future__ import annotations
+
+from typing import List
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing_extensions import Annotated
+
+from lightly_studio.api.routes.api.status import (
+    HTTP_STATUS_INTERNAL_SERVER_ERROR,
+)
+from lightly_studio.dataset.embedding_manager import (
+    EmbeddingManager,
+    EmbeddingManagerProvider,
+    TextEmbedQuery,
+)
+
+text_embedding_router = APIRouter()
+# Define a type alias for the EmbeddingManager dependency
+EmbeddingManagerDep = Annotated[
+    EmbeddingManager,
+    Depends(lambda: EmbeddingManagerProvider.get_embedding_manager()),
+]
+
+
+@text_embedding_router.get("/text_embedding/embed_text", response_model=List[float])
+def embed_text(
+    embedding_manager: EmbeddingManagerDep,
+    query_text: str = Query(..., description="The text to embed."),
+    embedding_model_id: Annotated[
+        UUID | None,
+        Query(..., description="The ID of the embedding model to use."),
+    ] = None,
+) -> list[float]:
+    """Retrieve embeddings for the input text."""
+    try:
+        text_embeddings = embedding_manager.embed_text(
+            TextEmbedQuery(query_text, embedding_model_id)
+        )
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=HTTP_STATUS_INTERNAL_SERVER_ERROR,
+            detail=f"{exc}",
+        ) from None
+
+    return text_embeddings

lightly_studio/api/routes/api/validators.py

@@ -0,0 +1,17 @@
+"""General LightlyStudio API models."""
+
+from pydantic import BaseModel, Field
+
+
+class Paginated(BaseModel):
+    """Paginated query parameters."""
+
+    offset: int = Field(0, ge=0, description="Offset for pagination")
+    limit: int = Field(100, gt=0, le=100, description="Limit for pagination")
+
+
+class PaginatedWithCursor(BaseModel):
+    """Paginated query parameters."""
+
+    offset: int = Field(0, ge=0, description="Offset for pagination", alias="cursor")
+    limit: int = Field(100, gt=0, le=100, description="Limit for pagination")

lightly_studio/api/routes/healthz.py

@@ -0,0 +1,13 @@
+"""This module contains the API routes for managing datasets."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+health_router = APIRouter()
+
+
+@health_router.get("/healthz", include_in_schema=False)
+def health_check() -> dict[str, str]:
+    """Health check endpoint to verify the service is running."""
+    return {"status": "healthy"}

lightly_studio/api/routes/images.py

@@ -0,0 +1,104 @@
+"""Image serving endpoint that supports local files."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Generator
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from sqlmodel import Session
+
+from lightly_studio.api import db
+from lightly_studio.api.routes.api import status
+from lightly_studio.models import sample
+
+app_router = APIRouter()
+
+
+@app_router.get("/sample/{sample_id}")
+async def serve_image_by_sample_id(
+    sample_id: str,
+    session: Session = Depends(db.get_session),  # noqa: B008
+) -> StreamingResponse:
+    """Serve an image by sample ID.
+
+    Args:
+        sample_id: The ID of the sample.
+        session: Database session.
+
+    Returns:
+        StreamingResponse with the image data.
+
+    Raises:
+        HTTPException: If the sample is not found or the file is not accessible.
+    """
+    # Retrieve the sample from the database.
+    sample_record = session.get(sample.SampleTable, sample_id)
+    if not sample_record:
+        raise HTTPException(
+            status_code=status.HTTP_STATUS_NOT_FOUND,
+            detail=f"Sample not found: {sample_id}",
+        )
+
+    file_path = sample_record.file_path_abs
+
+    try:
+        # Open the file.
+        with open(file_path, "rb") as file:
+            content = file.read()
+
+        # Determine content type based on file extension.
+        content_type = _get_content_type(file_path)
+
+        # Create a streaming response.
+        def generate() -> Generator[bytes, None, None]:
+            yield content
+
+        return StreamingResponse(
+            generate(),
+            media_type=content_type,
+            headers={
+                # Cache for 1 hour
+                "Cache-Control": "public, max-age=3600",
+                "Content-Length": str(len(content)),
+            },
+        )
+
+    except FileNotFoundError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_STATUS_NOT_FOUND,
+            detail=f"File not found: {file_path}",
+        ) from exc
+    except OSError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_STATUS_NOT_FOUND,
+            detail=f"Error accessing file {file_path}: {exc.strerror}",
+        ) from exc
+
+
+def _get_content_type(file_path: str) -> str:
+    """Get the appropriate content type for a file based on its extension.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        MIME type string.
+    """
+    ext = os.path.splitext(file_path)[1].lower()
+
+    content_types = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+        ".bmp": "image/bmp",
+        ".tiff": "image/tiff",
+        ".mov": "video/quicktime",
+        ".mp4": "video/mp4",
+        ".avi": "video/x-msvideo",
+    }
+
+    return content_types.get(ext, "application/octet-stream")

lightly_studio/api/routes/webapp.py

@@ -0,0 +1,51 @@
+"""This module contains the API routes for managing datasets."""
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from .api.status import HTTP_STATUS_NOT_FOUND
+
+app_router = APIRouter()
+
+# Get the current project root directory
+project_root = Path(__file__).resolve().parent.parent.parent
+
+webapp_dir = project_root / "dist_lightly_studio_view_app"
+
+# Check if the webapp directory exists and raise an error if it doesn't
+if not webapp_dir.exists():
+    raise RuntimeError(f"Directory '{webapp_dir}' does not exist in '{project_root}'")
+
+# Ensure the path is absolute
+webapp_dir = webapp_dir.resolve()
+
+# ensure the webapp index.html file exists
+index_file = webapp_dir / "index.html"
+if not index_file.exists():
+    raise RuntimeError("No index file. Did you forget to build the webapp?")
+
+
+@app_router.get("/{path:path}", include_in_schema=False)
+async def serve_static_webapp_files_or_default_index_file(
+    path: str,
+) -> FileResponse:
+    """Serve static files of webapp or serve the index.html file.
+
+    Try to serve static files with file extensions or return 404.
+    If no file extension, return the main webapp index.html.
+    """
+    file_path = webapp_dir / path
+
+    # if file has an extension, try to return the file
+    if file_path.suffix:
+        if not file_path.exists() or not file_path.is_file():
+            raise HTTPException(
+                status_code=HTTP_STATUS_NOT_FOUND,
+                detail=f"File '{path}' not found",
+            )
+        return FileResponse(file_path)
+
+    # if file has no extension, return the index.html file regardless of path
+    return FileResponse(index_file)

lightly_studio/api/server.py

@@ -0,0 +1,82 @@
+"""This module contains the Server class for running the API using Uvicorn."""
+
+import random
+import socket
+
+import uvicorn
+
+from lightly_studio.api.app import app
+from lightly_studio.dataset import env
+
+
+class Server:
+    """This class represents a server for running the API using Uvicorn."""
+
+    port: int
+    host: str
+
+    def __init__(self, host: str, port: int) -> None:
+        """Initialize the Server with host and port.
+
+        Args:
+            host (str): The hostname to bind the server to.
+            port (int): The port number to run the server on.
+        """
+        self.host = host
+        self.port = _get_available_port(host=host, preferred_port=port)
+        if port != self.port:
+            env.LIGHTLY_STUDIO_PORT = self.port
+            env.APP_URL = f"{env.LIGHTLY_STUDIO_PROTOCOL}://{env.LIGHTLY_STUDIO_HOST}:{env.LIGHTLY_STUDIO_PORT}"
+
+    def start(self) -> None:
+        """Start the API server using Uvicorn."""
+        # start the app
+        uvicorn.run(app, host=self.host, port=self.port, http="h11")
+
+
+def _get_available_port(host: str, preferred_port: int, max_tries: int = 50) -> int:
+    """Get an available port, if possible, otherwise a random one.
+
+    Args:
+        host: The hostname or IP address to bind to.
+        preferred_port: The port to try first.
+        max_tries: Maximum number of random ports to try.
+
+    Raises:
+        RuntimeError if it cannot find an available port.
+
+    Returns:
+        An available port number.
+    """
+    if _is_port_available(host=host, port=preferred_port):
+        return preferred_port
+
+    # Try random ports in the range 1024-65535
+    for _ in range(max_tries):
+        port = random.randint(1024, 65535)
+        if _is_port_available(host=host, port=port):
+            return port
+
+    raise RuntimeError("Could not find an available port.")
+
+
+def _is_port_available(host: str, port: int) -> bool:
+    # Determine address family based on host.
+    try:
+        socket.inet_pton(socket.AF_INET, host)
+        families = [socket.AF_INET]
+    except OSError:
+        try:
+            socket.inet_pton(socket.AF_INET6, host)
+            families = [socket.AF_INET6]
+        except OSError:
+            # Fallback for hostnames like 'localhost'
+            families = [socket.AF_INET, socket.AF_INET6]
+
+    for family in families:
+        with socket.socket(family, socket.SOCK_STREAM) as s:
+            try:
+                s.bind((host, port))
+            except OSError:
+                return False
+    return True