deeptutor-server 1.7.0__py3-none-any.whl

deeptutor/api/router_loader.py

@@ -0,0 +1,139 @@
+"""Defer unrelated API schemas in the experimental native-engine profile.
+
+The generated index contains only routing patterns. Authentication, dependency
+injection and handlers always come from the original FastAPI router. A stale
+index disables deferral; OpenAPI expands every router before schema generation.
+"""
+
+from __future__ import annotations
+
+from copy import copy
+import hashlib
+from importlib import import_module
+import json
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, FastAPI
+from starlette.routing import BaseRoute, Match, Route, WebSocketRoute
+
+INDEX_PATH = Path(__file__).with_name("router_index.json")
+
+
+def source_fingerprint() -> str:
+    digest = hashlib.sha256()
+    root = Path(__file__).with_name("routers")
+    for path in sorted(root.rglob("*.py")):
+        digest.update(str(path.relative_to(root)).encode())
+        digest.update(path.read_bytes())
+    return digest.hexdigest()
+
+
+async def _unreachable(*_args: Any) -> None:
+    raise RuntimeError("Deferred routing pattern cannot execute a request")
+
+
+class DeferredRouter(BaseRoute):
+    def __init__(
+        self, app: FastAPI, reference: str, options: dict[str, Any], patterns: list[dict]
+    ) -> None:
+        self.app = app
+        self.reference = reference
+        self.options = options
+        self.loaded: APIRouter | None = None
+        prefix = options.get("prefix", "")
+        self.patterns: list[BaseRoute] = []
+        for pattern in patterns:
+            path = prefix + pattern["path"]
+            if pattern["kind"] == "websocket":
+                route = WebSocketRoute(path, _unreachable, name=pattern["name"])
+            else:
+                route = Route(path, _unreachable, methods=pattern["methods"], name=pattern["name"])
+                # Starlette implicitly adds HEAD; FastAPI APIRoute does not.
+                route.methods = set(pattern["methods"])
+            self.patterns.append(route)
+
+    def load(self) -> APIRouter:
+        if self.loaded is None:
+            module, attribute = self.reference.split(":", 1)
+            router = APIRouter(redirect_slashes=False, dependency_overrides_provider=self.app)
+            router.include_router(getattr(import_module(module), attribute), **self.options)
+            # Publish only a fully constructed router. There is no await during
+            # initialization, so concurrent requests cannot observe half a load.
+            self.loaded = router
+        return self.loaded
+
+    def matches(self, scope: dict) -> tuple[Match, dict]:
+        partial: tuple[Match, dict] = (Match.NONE, {})
+        for route in self.patterns:
+            match, child = route.matches(scope)
+            if match == Match.FULL:
+                return match, child
+            if match == Match.PARTIAL and partial[0] == Match.NONE:
+                partial = (match, child)
+        return partial
+
+    async def handle(self, scope: dict, receive: Any, send: Any) -> None:
+        await self.load()(scope, receive, send)
+
+    def url_path_for(self, name: str, /, **path_params: Any) -> Any:
+        from starlette.routing import NoMatchFound
+
+        for route in self.patterns:
+            try:
+                return route.url_path_for(name, **path_params)
+            except NoMatchFound:
+                pass
+        raise NoMatchFound(name, path_params)
+
+
+class RouterLoader:
+    def __init__(self, app: FastAPI, *, lazy: bool = False) -> None:
+        self.app = app
+        self.records: dict[str, APIRouter] = {}
+        self.index: dict[str, list[dict]] = {}
+        if lazy:
+            try:
+                index = json.loads(INDEX_PATH.read_text())
+                if index["fingerprint"] == source_fingerprint():
+                    self.index = index["routers"]
+            except (OSError, ValueError, KeyError):
+                pass
+        original_openapi = app.openapi
+
+        def openapi() -> dict:
+            self.expand()
+            return original_openapi()
+
+        app.openapi = openapi
+
+    def include(
+        self, reference: str, *, exclude_paths: tuple[str, ...] = (), **options: Any
+    ) -> None:
+        if reference in self.index and not exclude_paths:
+            self.app.router.routes.append(
+                DeferredRouter(self.app, reference, options, self.index[reference])
+            )
+        else:
+            module, attribute = reference.split(":", 1)
+            router = getattr(import_module(module), attribute)
+            if exclude_paths:
+                router = copy(router)
+                prefix = options.get("prefix", "")
+                router.routes = [
+                    route
+                    for route in router.routes
+                    if not any(
+                        prefix + getattr(route, "path", "") == path
+                        or (prefix + getattr(route, "path", "")).startswith(path + "/")
+                        for path in exclude_paths
+                    )
+                ]
+            self.records[reference] = router
+            self.app.include_router(router, **options)
+
+    def expand(self) -> None:
+        routes: list[BaseRoute] = []
+        for route in self.app.router.routes:
+            routes.extend(route.load().routes if isinstance(route, DeferredRouter) else [route])
+        self.app.router.routes[:] = routes

deeptutor/api/routers/__init__.py

@@ -0,0 +1 @@
+# Init file for routers

deeptutor/api/routers/agent_config.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+"""
+Agent Configuration API - Provides agent metadata for data-driven UI.
+"""
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+# Agent registry - single source of truth for agent UI metadata
+AGENT_REGISTRY = {
+    "solve": {
+        "icon": "HelpCircle",
+        "color": "blue",
+        "label_key": "Problem Solved",
+    },
+    "question": {
+        "icon": "FileText",
+        "color": "purple",
+        "label_key": "Question Generated",
+    },
+    "research": {
+        "icon": "Search",
+        "color": "emerald",
+        "label_key": "Research Report",
+    },
+    "co_writer": {
+        "icon": "PenTool",
+        "color": "amber",
+        "label_key": "Co-Writer",
+    },
+}
+
+
+@router.get("/agents")
+async def get_agent_config():
+    """
+    Get agent UI configuration.
+
+    Returns:
+        Dict mapping agent type to UI metadata (icon, color, label_key)
+    """
+    return AGENT_REGISTRY
+
+
+@router.get("/agents/{agent_type}")
+async def get_single_agent_config(agent_type: str):
+    """
+    Get UI configuration for a specific agent.
+
+    Args:
+        agent_type: Agent type (solve, question, research, etc.)
+
+    Returns:
+        Agent UI metadata or 404 if not found
+    """
+    if agent_type in AGENT_REGISTRY:
+        return AGENT_REGISTRY[agent_type]
+    return {"error": f"Agent type '{agent_type}' not found"}

deeptutor/api/routers/attachments.py

@@ -0,0 +1,79 @@
+"""HTTP endpoint for chat attachment downloads / previews.
+
+The chat turn runtime persists every uploaded attachment to the
+:class:`~deeptutor.services.storage.AttachmentStore` and records the public
+URL on the message. The frontend preview drawer loads files via this
+router, which only serves paths the store hands back — every component is
+sanitised to defend against directory traversal.
+
+URL shape::
+
+    GET /files/attachments/{session_id}/{attachment_id}/{filename}
+
+The session id functions as the ACL boundary, mirroring how the rest of
+the app treats sessions today (single-tenant, session ownership is local
+trust). Once multi-user auth lands we should swap this for signed URLs.
+"""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from deeptutor.api.utils.http_headers import content_disposition
+from deeptutor.services.storage import (
+    LocalDiskAttachmentStore,
+    get_attachment_store,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+_content_disposition = content_disposition
+
+
+@router.get("/{session_id}/{attachment_id}/{filename:path}")
+async def get_attachment(
+    session_id: str,
+    attachment_id: str,
+    filename: str,
+):
+    """Serve a previously uploaded chat attachment.
+
+    Responds with ``Content-Disposition: inline`` so browsers preview PDFs
+    and images directly in an ``<iframe>`` / ``<img>``. For unknown types
+    the browser still falls back to download, which is fine for the
+    drawer's "Download" button path.
+    """
+    store = get_attachment_store()
+    if not isinstance(store, LocalDiskAttachmentStore):
+        # Future remote backends should issue a redirect to the signed URL
+        # here. Local-disk is the only backend today, so this branch just
+        # guards against an unexpected configuration.
+        raise HTTPException(status_code=501, detail="Attachment backend not servable")
+
+    target = store.resolve_path(
+        session_id=session_id,
+        attachment_id=attachment_id,
+        filename=filename,
+    )
+    if target is None:
+        raise HTTPException(status_code=404, detail="Attachment not found")
+
+    media_type, _ = mimetypes.guess_type(target.name)
+    if not media_type:
+        media_type = "application/octet-stream"
+
+    # ``inline`` lets the browser preview the file when possible while still
+    # honouring the suggested filename for the drawer's download action.
+    headers = {
+        "Content-Disposition": _content_disposition(target.name),
+        # User-uploaded data; do not let intermediaries cache it.
+        "Cache-Control": "private, max-age=0, must-revalidate",
+    }
+    return FileResponse(path=str(target), media_type=media_type, headers=headers)