Update deps.py

app/api/deps.py

@@ -1,6 +1,7 @@
 # app/api/deps.py
-# Romeo AI Research Assistant - Ultimate Production Dependencies
-# Version: 2026.03.20.FastBoot
+# Romeo AI Research Assistant - MAI Veritas Dependencies
+# Version: 2026.03.20.Veritas
+# Description: Full shield with background loading for fast boot
 
 import logging
 import asyncio
@@ -26,6 +27,7 @@ from app.core.hf_sync import (
     stop_backup_scheduler
 )
 
+# Veritas Engine Imports
 from app.services.veritas.engine import VeritasEngine
 from app.services.veritas.shield_one import SemanticFingerprinterAsync
 from app.services.veritas.shield_two import ParaphraseDetector
@@ -36,21 +38,24 @@ from app.models.user import User
 logger = logging.getLogger("romeo_research.deps")
 
 # -----------------------------------------------------------------------------
-# 🛡️ 1. GLOBAL AI ENGINE SINGLETON
+# 🛡️ GLOBAL VERITAS ENGINE SINGLETON
 # -----------------------------------------------------------------------------
 _veritas_engine: Optional[VeritasEngine] = None
 _engine_lock = asyncio.Lock()
-_engine_ready = asyncio.Event()  # Signals when engine is ready
+_engine_ready = asyncio.Event()
 
 def _load_veritas_engine_background():
-    """🔥 Load heavy ML models in background thread (non-blocking)"""
+    """🔥 Load MAI Veritas shields in background (non-blocking)"""
     global _veritas_engine
     
     if _veritas_engine is not None:
         return
     
     try:
-        logger.info("🔄 Background: Loading Veritas Engine ML models...")
+        logger.info("🛡️ MAI Background: Initializing Veritas Shields...")
+        logger.info("   └─ Shield One: Semantic Fingerprinter")
+        logger.info("   └─ Shield Two: Paraphrase Detector")  
+        logger.info("   └─ Shield Three: Claim Verifier")
         
         semantic_svc = SemanticFingerprinterAsync(index_path=settings.VERITAS_LOCAL_INDEX_PATH)
         structural_svc = ParaphraseDetector()
@@ -63,12 +68,12 @@ def _load_veritas_engine_background():
         )
         
         _engine_ready.set()
-        logger.info("✅ Background: Veritas Engine ready")
+        logger.info("✅ MAI Veritas: All Shields Online")
     except Exception as e:
-        logger.error(f"❌ Background engine load failed: {e}")
+        logger.error(f"❌ MAI Veritas initialization failed: {e}")
 
 async def get_veritas_engine() -> VeritasEngine:
-    """Get Veritas Engine - waits for background loading if needed"""
+    """Get MAI Veritas Engine - waits for background init if needed"""
     global _veritas_engine
     
     if _veritas_engine is not None:
@@ -78,15 +83,15 @@ async def get_veritas_engine() -> VeritasEngine:
         await asyncio.wait_for(_engine_ready.wait(), timeout=60.0)
         return _veritas_engine
     except asyncio.TimeoutError:
-        logger.warning("⚠️ Background timeout, loading synchronously...")
+        logger.warning("⚠️ MAI background timeout, loading synchronously...")
         return await _load_veritas_engine_sync()
 
 async def _load_veritas_engine_sync() -> VeritasEngine:
-    """Synchronous fallback loader"""
+    """Synchronous fallback for MAI Veritas"""
     global _veritas_engine
     async with _engine_lock:
         if _veritas_engine is None:
-            logger.info("⚡ Veritas Engine: Warming up ML models...")
+            logger.info("⚡ MAI Veritas: Synchronous initialization...")
             semantic_svc = SemanticFingerprinterAsync(index_path=settings.VERITAS_LOCAL_INDEX_PATH)
             structural_svc = ParaphraseDetector()
             fact_svc = ClaimVerifier()
@@ -96,57 +101,57 @@ async def _load_veritas_engine_sync() -> VeritasEngine:
                 fact_service=fact_svc
             )
             _engine_ready.set()
-            logger.info("✅ Veritas Engine: All Shields Online.")
+            logger.info("✅ MAI Veritas: All Shields Online")
     return _veritas_engine
 
 # -----------------------------------------------------------------------------
-# 🔄 2. LIFESPAN MANAGER (Fast Boot)
+# 🔄 LIFESPAN MANAGER (MAI Fast Boot)
 # -----------------------------------------------------------------------------
-
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """
-    🔥 FAST BOOT: Start API immediately, load heavy stuff in background.
+    🔥 MAI FAST BOOT: API starts in ~5s, heavy shields load in background
     """
     try:
         Path("./data/veritas_index").mkdir(parents=True, exist_ok=True)
-        logger.info("🚀 Romeo AI: Fast Boot initiated...")
+        logger.info("🚀 MAI: Fast Boot initiated...")
         
-        # B. Background DB sync (non-blocking)
+        # B. Background HF DB sync (non-blocking)
         if os.getenv("SKIP_HF_PULL_ON_START") != "1":
             loop = asyncio.get_event_loop()
             await loop.run_in_executor(None, download_db_from_hf)
+            logger.info("💾 Database synchronized")
         else:
-            logger.info("⏭️ Skipped HF DB pull (SKIP_HF_PULL_ON_START=1)")
+            logger.info("⏭️ HF DB pull skipped (SKIP_HF_PULL_ON_START=1)")
         
-        # C. 🔥 BACKGROUND: Start ML model loading in thread (DON'T BLOCK)
+        # C. 🔥 BACKGROUND: Start MAI Veritas initialization (DON'T BLOCK)
         threading.Thread(target=_load_veritas_engine_background, daemon=True).start()
         
         # D. Start backup scheduler
         start_backup_scheduler()
         
-        logger.info("🏁 Fast Boot complete. API ready. Models loading in background...")
+        logger.info("🏁 MAI Fast Boot complete. API ready. Shields initializing...")
+        logger.info("⏳ Veritas will be ready in ~30-60 seconds...")
         
     except Exception as e:
-        logger.critical(f"❌ Startup error: {str(e)}", exc_info=True)
+        logger.critical(f"❌ MAI startup error: {str(e)}", exc_info=True)
     
     yield
     
     # SHUTDOWN
     try:
-        logger.info("🛑 Shutdown: Saving data...")
+        logger.info("🛑 MAI Shutdown: Securing research data...")
         stop_backup_scheduler()
         backup_db_to_hf()
-        logger.info("💾 Data saved to HF Hub.")
+        logger.info("💾 MAI: Database persisted to HF Hub")
     except Exception as e:
-        logger.error(f"⚠️ Shutdown backup error: {e}")
+        logger.error(f"⚠️ MAI shutdown error: {e}")
 
 # -----------------------------------------------------------------------------
-# 💾 3. DATABASE DEPENDENCY
+# 💾 DATABASE DEPENDENCY
 # -----------------------------------------------------------------------------
-
 async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """Provides an async database session with automatic cleanup."""
+    """Async database session with cleanup"""
     async with async_session_factory() as session:
         try:
             yield session
@@ -154,15 +159,13 @@ async def get_db() -> AsyncGenerator[AsyncSession, None]:
             await session.close()
 
 # -----------------------------------------------------------------------------
-# 🔑 4. AUTHENTICATION & SECURITY
+# 🔑 AUTHENTICATION & SECURITY
 # -----------------------------------------------------------------------------
-
 reusable_oauth2 = OAuth2PasswordBearer(
     tokenUrl=f"{settings.API_V1_STR.rstrip('/')}/auth/login"
 )
 
 async def _get_user_by_email(db: AsyncSession, email: str) -> Optional[User]:
-    """Internal helper to avoid circular imports."""
     result = await db.execute(select(User).where(User.email == email))
     return result.scalars().first()
 
@@ -170,7 +173,7 @@ async def get_current_user(
     db: AsyncSession = Depends(get_db),
     token: str = Depends(reusable_oauth2)
 ) -> User:
-    """JWT Validator with 5-second database circuit breaker."""
+    """JWT validator with 5s circuit breaker"""
     credentials_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,
         detail="Could not validate credentials",
@@ -188,15 +191,14 @@ async def get_current_user(
     try:
         user = await asyncio.wait_for(_get_user_by_email(db, email), timeout=5.0)
     except asyncio.TimeoutError:
-        logger.error(f"Timeout: Auth lookup for {email} failed")
-        raise HTTPException(status_code=503, detail="System busy. Try again.")
+        logger.error(f"Auth timeout for {email}")
+        raise HTTPException(status_code=503, detail="System busy")
 
     if not user:
         raise credentials_exception
     return user
 
 async def get_current_active_user(user: User = Depends(get_current_user)) -> User:
-    """Check if the user account is enabled."""
     if not user.is_active:
-        raise HTTPException(status_code=400, detail="Account disabled.")
+        raise HTTPException(status_code=400, detail="Account disabled")
     return user