""" Knowledge Universe API - Main FastAPI Application """ import asyncio import json import logging import os from contextlib import asynccontextmanager from fastapi import FastAPI, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import JSONResponse, FileResponse from fastapi.exceptions import RequestValidationError from fastapi.staticfiles import StaticFiles from prometheus_client import make_asgi_app from config.settings import get_settings from src.api.routes import router as block2_router from src.api.models import SourceFormat from src.api.middleware import RateLimitMiddleware, MetricsMiddleware from src.cache.redis_manager import RedisManager from src.cache.eviction_manager import EvictionManager from src.orchestration.background_tasks import BackgroundTaskManager settings = get_settings() logger = logging.getLogger(__name__) # ------------------------------------------------------------------ # 🔒 REQUEST SANITIZATION MIDDLEWARE (CRITICAL FIX) # ------------------------------------------------------------------ class RequestSanitizerMiddleware: """ Sanitizes incoming JSON before Pydantic validation. Fixes enum pollution (formats causing 422). """ def __init__(self, app: FastAPI): self.app = app async def __call__(self, scope, receive, send): if scope["type"] != "http": await self.app(scope, receive, send) return request = Request(scope, receive=receive) if request.method == "POST" and request.url.path.endswith("/discover"): try: body = await request.json() # Sanitize formats — strip invalid enum values with a warning if "formats" in body and isinstance(body["formats"], list): cleaned = [] for f in body["formats"]: try: cleaned.append(SourceFormat(f)) except Exception: logger.warning(f"Dropped invalid format value: '{f}'") body["formats"] = cleaned # Re-inject sanitized body async def receive_override(): return { "type": "http.request", "body": json.dumps(body).encode(), "more_body": False, } await self.app(scope, receive_override, send) return except Exception as e: # ── BUG 6 FIX ────────────────────────────────────────────── # GET requests have no body. Trying request.json() on them # always raises "Expecting value: line 1 column 1 (char 0)". # This is normal — not an error. Log at DEBUG not ERROR. # Only log as WARNING if this is genuinely a POST with bad JSON. if request.method == "POST": logger.warning(f"Malformed JSON on POST {request.url.path}: {e}") else: logger.debug(f"Sanitizer skipped non-POST: {e}") await self.app(scope, receive, send) # ------------------------------------------------------------------ # LIFESPAN # ------------------------------------------------------------------ @asynccontextmanager async def lifespan(app: FastAPI): logger.info("Starting Knowledge Universe API...") # ✅ ADD THIS DIAGNOSTIC logger.info("=" * 60) logger.info("ENVIRONMENT DIAGNOSTIC") logger.info(f"GITHUB_TOKEN: {'SET ✓' if os.getenv('GITHUB_TOKEN') else 'MISSING ✗'}") logger.info(f"KAGGLE_USERNAME: {'SET ✓' if os.getenv('KAGGLE_USERNAME') else 'MISSING ✗'}") logger.info(f"KAGGLE_KEY: {'SET ✓' if os.getenv('KAGGLE_KEY') else 'MISSING ✗'}") logger.info("=" * 60) # ... rest of code redis_manager = RedisManager() await redis_manager.connect() app.state.redis = redis_manager from src.utils.key_rotator import init_key_rotators init_key_rotators(redis_manager) eviction_manager = EvictionManager(redis_manager) app.state.eviction_manager = eviction_manager background_tasks = BackgroundTaskManager(redis_manager) cleanup_task = asyncio.create_task(background_tasks.start_cleanup_daemon()) app.state.cleanup_task = cleanup_task # Pre-warm the embedding model so the first real request doesn't pay # the initialization cost (~500-800ms on HuggingFace Spaces). # This runs synchronously in the lifespan — model is guaranteed ready # before any request reaches the /v1/discover handler. try: from src.integrations.shared_model import prewarm_model logger.info("Pre-warming embedding model...") prewarm_model() except Exception as e: logger.warning(f"Model pre-warm failed (non-fatal): {e}") if settings.WARMUP_ENABLED: asyncio.create_task(background_tasks.warmup_cache()) logger.info("API ready") yield cleanup_task.cancel() await redis_manager.close() logger.info("Shutdown complete") # ------------------------------------------------------------------ # APP # ------------------------------------------------------------------ app = FastAPI( title=settings.API_TITLE, version=settings.API_VERSION, description="Intelligent content aggregation and ranking for educational materials", lifespan=lifespan, docs_url="/api-docs", # moved — /docs serves our human-readable docs page redoc_url="/api-redoc", ) # 🔒 ORDER MATTERS app.add_middleware(RequestSanitizerMiddleware) app.add_middleware(RateLimitMiddleware) app.add_middleware( CORSMiddleware, allow_origins=settings.ALLOWED_ORIGINS, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) if settings.ENABLE_METRICS: app.add_middleware(MetricsMiddleware) app.mount("/metrics", make_asgi_app()) app.include_router(block2_router) # ------------------------------------------------------------------ # 🧯 VALIDATION ERROR HANDLER (422) # ------------------------------------------------------------------ @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): logger.warning(f"422 Validation error on {request.url}: {exc.errors()}") return JSONResponse( status_code=422, content={ "error": "Validation error", "details": exc.errors(), "body": exc.body, }, ) # ------------------------------------------------------------------ # GLOBAL ERROR HANDLER # ------------------------------------------------------------------ @app.exception_handler(Exception) async def global_exception_handler(request: Request, exc: Exception): logger.error(f"Unhandled exception: {exc}", exc_info=True) return JSONResponse( status_code=500, content={ "error": "Internal server error", "message": str(exc) if settings.DEBUG else "An error occurred", "path": str(request.url), }, ) # ------------------------------------------------------------------ # HEALTH # ------------------------------------------------------------------ @app.get("/health") async def health_check(request: Request): redis_manager = request.app.state.redis redis_healthy = await redis_manager.ping() return { "status": "healthy" if redis_healthy else "degraded", "version": settings.API_VERSION, "redis": "connected" if redis_healthy else "disconnected", } @app.get("/ready") async def readiness_check(request: Request): redis_manager = request.app.state.redis if not await redis_manager.ping(): return JSONResponse( status_code=503, content={"status": "not ready", "reason": "redis unavailable"}, ) return {"status": "ready"} # Project root = two levels up from src/api/main.py _PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) _LANDING_DIR = os.path.join(_PROJECT_ROOT, "landing") @app.get("/") async def root(): """Serve landing page.""" landing = os.path.join(_LANDING_DIR, "index.html") if os.path.exists(landing): return FileResponse(landing, media_type="text/html") return { "name": settings.API_TITLE, "version": settings.API_VERSION, "status": "operational", "docs": "/docs", "signup": "/v1/signup", } @app.get("/docs.html", include_in_schema=False) async def serve_docs(): """Serve the human-readable API documentation page.""" docs_path = os.path.join(_LANDING_DIR, "docs.html") if os.path.exists(docs_path): return FileResponse(docs_path, media_type="text/html") return JSONResponse( status_code=404, content={"error": "docs.html not found in landing/. Check the file exists."}, )