Move API key middleware to main.py and add startup/shutdown lifecycle management

api/router.py

@@ -10,31 +10,10 @@ logger = logging.getLogger(__name__)
 # Routeur principal
 router = APIRouter()
 
-# --- Middleware (Laissé ici pour l'instant) ---
-@router.middleware("http")
-async def api_key_middleware(request: Request, call_next):
-    # Skip if we're in debug mode or during startup
-    if os.environ.get("DEBUG") == "1":
-        return await call_next(request)
-
-    # Pour les routes Hugging Face Space, Gradio, etc.
-    # (Liste simplifiée, ajuster si nécessaire)
-    public_paths = ['/assets/', '/file=', '/queue/', '/startup-logs', '/config', '/info', '/gradio', '/favicon.ico', '/']
-    if any(request.url.path.startswith(p) for p in public_paths):
-        return await call_next(request)
-    
-    # Optionnel: Vérification globale de clé API (si non gérée par Depends)
-    # Désactivé par défaut pour se fier aux Depends sur les endpoints
-    # try:
-    #     api_key = request.headers.get("X-API-Key")
-    #     await verify_api_key(api_key) # Ne fonctionnera pas directement ici
-    # except HTTPException as e:
-    #     return Response(content=e.detail, status_code=e.status_code)
-
-    response = await call_next(request)
-    return response
+# --- Suppression du Middleware --- 
+# Le middleware doit être appliqué à l'instance FastAPI (app) dans main.py
 
 # --- Inclusion des sous-routeurs ---
 router.include_router(prediction.router)       # Routes de prédiction (/batch_predict)
 router.include_router(management.router)       # Routes de gestion (/manage/load_model, /manage/update_model)
-router.include_router(management.public_router) # Routes d'info publiques (/models, /models/{id})
+# router.include_router(management.public_router) # Routes d'info publiques (/models, /models/{id}) - Supprimé par l'utilisateur

main.py

@@ -1,13 +1,14 @@
 import logging
-from fastapi import FastAPI
+import os
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request, Response
 import gradio as gr
 from gradio.routes import mount_gradio_app
 
 from api.router import router
-from api.dependencies import verify_api_key
 from db.models import fetch_models_for_group
 from models.loader import load_models, model_pipelines
-from config.settings import RESOURCE_GROUP
+from config.settings import RESOURCE_GROUP, DATABASE_URL
 
 # Configuration de base des logs
 logging.basicConfig(
@@ -16,15 +17,75 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# --- Événements Startup/Shutdown (Lifespan Manager) ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Code exécuté au démarrage
+    logger.info("Starting up API...")
+    logger.info(f"Attempting to connect to database: {DATABASE_URL[:DATABASE_URL.find('@')] + '@...'}") # Masquer les crédentiels
+    try:
+        models_to_load = await fetch_models_for_group(RESOURCE_GROUP)
+        if models_to_load:
+            await load_models(models_to_load)
+            logger.info("Initial models loaded successfully.")
+        else:
+            logger.warning(f"No models found for resource group '{RESOURCE_GROUP}'. API starting without preloaded models.")
+    except Exception as e:
+        logger.exception(f"Failed to load initial models during startup: {e}")
+        # Décider s'il faut empêcher le démarrage de l'API ou continuer sans modèles
+        # raise RuntimeError("Could not load initial models, API startup aborted.") from e
+    
+    yield
+    # Code exécuté à l'arrêt
+    logger.info("Shutting down API...")
+    # Ajouter ici le code de nettoyage si nécessaire (ex: fermer connexions persistantes)
+
 # Créer l'application FastAPI
 app = FastAPI(
     title="Tamis AI Inference API",
     description="API pour l'inférence des modèles de classification d'objets",
     version="0.1.0",
+    lifespan=lifespan # Correction: Utilisation de la fonction lifespan définie ci-dessus
 )
 
-# Ajouter middleware d'authentification
-app.middleware("http")(verify_api_key)
+# Ajout du Middleware ici
+@app.middleware("http")
+async def api_key_middleware(request: Request, call_next):
+    """Middleware pour vérifier la clé API et exempter certaines routes."""
+    # Skip if we're in debug mode or during startup
+    if os.environ.get("DEBUG") == "1":
+        logger.debug("DEBUG mode active, skipping API key check.")
+        return await call_next(request)
+
+    # Liste des chemins publics ou internes à exempter de la vérification de clé
+    public_paths = [
+        '/docs', '/openapi.json', # Documentation Swagger/OpenAPI
+        '/health',                # Health check endpoint
+        '/',                      # Racine (Interface Gradio)
+        '/assets/',               # Assets Gradio
+        '/file=',                 # Fichiers Gradio
+        '/queue/',                # Queue Gradio
+        '/startup-logs',          # Logs HF Space
+        '/config',                # Config Gradio/HF
+        '/info',                  # Info Gradio/HF
+        '/gradio',                # Potentiel préfixe Gradio
+        '/favicon.ico'            # Favicon
+    ]
+    
+    # Vérifie si le chemin commence par un des préfixes publics
+    is_public = any(request.url.path == p or (p.endswith('/') and request.url.path.startswith(p)) for p in public_paths)
+
+    if is_public:
+        logger.debug(f"Public path accessed: {request.url.path}, skipping API key check.")
+        response = await call_next(request)
+        return response
+    else:
+        # Pour toutes les autres routes, la vérification se fait via Depends() sur l'endpoint lui-même.
+        # Ce middleware ne fait donc plus de vérification active ici,
+        # il sert juste à logger et potentiellement à exempter certaines routes si besoin.
+        logger.debug(f"Protected path accessed: {request.url.path}. API key verification delegated to endpoint.")
+        response = await call_next(request)
+        return response
 
 # Inclure les routes
 app.include_router(router)