Clean rewrite: ensure_tables() before every DB op

app.py

@@ -13,25 +13,21 @@ def install_deps():
     print("✅ Dependencies installed")
 install_deps()
 
-# Now import everything
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 from contextlib import asynccontextmanager
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
 from sqlalchemy.orm import DeclarativeBase, relationship
-from sqlalchemy import Column, Integer, String, Text, Float, Boolean, DateTime, JSON, Enum, ForeignKey
-from sqlalchemy.sql import func, select
+from sqlalchemy import Column, Integer, String, Text, Float, DateTime, JSON, Enum, ForeignKey, select
+from sqlalchemy.sql import func
 from pydantic import BaseModel
-from typing import Optional, List
+from typing import Optional
 import asyncio
 
-# === FastAPI App (must be defined before routes!) ===
+# === FastAPI App ===
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Create tables at startup using the async engine
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
     for d in ["/data/frames", "/data/features", "/data/index", "/data/videos"]:
         os.makedirs(d, exist_ok=True)
     print("🚀 Eye-Dentify API ready!")
@@ -43,18 +39,15 @@ app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
 
 # === Database ===
 DATABASE_URL = "sqlite+aiosqlite:///./videosearch.db"
-SYNC_DB_URL = "sqlite:///./videosearch.db"
+engine = create_async_engine(DATABASE_URL, echo=False)
+async_session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
 
 class Base(DeclarativeBase): pass
 
-# Create tables synchronously at import time
-from sqlalchemy import create_engine as create_sync_engine
-sync_engine = create_sync_engine(SYNC_DB_URL)
-Base.metadata.create_all(bind=sync_engine)
-print("✅ Database tables created (sync)")
-
-engine = create_async_engine(DATABASE_URL, echo=False)
-async_session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+async def ensure_tables():
+    """Ensure tables exist (idempotent, safe to call every time)"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
 
 # === Models ===
 class VideoStatus(str, enum.Enum):
@@ -67,8 +60,8 @@ class AnalysisStatus(str, enum.Enum):
 class Video(Base):
     __tablename__ = "videos"
     id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    youtube_id = Column(String(64), nullable=True)
-    youtube_url = Column(String(512), nullable=True)
+    youtube_id = Column(String(64), nullable=True, default="")
+    youtube_url = Column(String(512), nullable=True, default="")
     title = Column(String(512), default="")
     description = Column(Text, default="")
     channel = Column(String(256), default="")
@@ -97,13 +90,15 @@ class Analysis(Base):
     completed_at = Column(DateTime, nullable=True)
     video = relationship("Video", back_populates="analyses")
 
-async def get_session():
-    """Get async session, ensuring tables exist first"""
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    async with engine.begin() as _c: await _c.run_sync(Base.metadata.create_all)
-        async with async_session_factory() as session:
-        yield session
+def video_to_dict(v):
+    return {
+        "id": v.id, "youtube_id": v.youtube_id or "", "youtube_url": v.youtube_url or "",
+        "title": v.title or "Untitled", "channel": v.channel or "",
+        "duration": v.duration or 0, "thumbnail_url": v.thumbnail_url or "",
+        "frames_count": v.frames_count or 0, "features_count": v.features_count or 0,
+        "status": v.status or "pending",
+        "created_at": v.created_at.isoformat() if v.created_at else None
+    }
 
 # === Serve Frontend ===
 @app.get("/")
@@ -117,16 +112,6 @@ class SubmitRequest(BaseModel):
 class SearchRequest(BaseModel):
     youtube_url: str; top_k: int = 10; threshold: float = 0.5
 
-def video_to_dict(v):
-    return {
-        "id": v.id, "youtube_id": v.youtube_id or "", "youtube_url": v.youtube_url or "",
-        "title": v.title or "Untitled", "channel": v.channel or "",
-        "duration": v.duration or 0, "thumbnail_url": v.thumbnail_url or "",
-        "frames_count": v.frames_count or 0, "features_count": v.features_count or 0,
-        "status": v.status or "pending",
-        "created_at": v.created_at.isoformat() if v.created_at else None
-    }
-
 # === Routes ===
 @app.get("/api/v1/health")
 def health():
@@ -134,19 +119,14 @@ def health():
 
 @app.post("/api/v1/videos/submit")
 async def submit_video(req: SubmitRequest):
-    import traceback
+    import yt_dlp, traceback
     try:
-        import yt_dlp
-    except Exception as e:
-        return {"error": f"yt-dlp import failed: {str(e)}", "trace": traceback.format_exc()}
-    try:
-        video_id = str(uuid.uuid4())
-        video = Video(id=video_id, youtube_url=req.youtube_url, youtube_id="",
-                      title="Processing...", channel="", status=VideoStatus.downloading.value,
-                      description="", frames_count=0, features_count=0)
-        async with engine.begin() as _c: await _c.run_sync(Base.metadata.create_all)
+        await ensure_tables()
+        video = Video(id=str(uuid.uuid4()), youtube_url=req.youtube_url, youtube_id="",
+                      title="Processing...", channel="", status=VideoStatus.downloading.value)
         async with async_session_factory() as session:
-            session.add(video); await session.commit()
+            session.add(video)
+            await session.commit()
         with yt_dlp.YoutubeDL({'quiet': True, 'extract_flat': True}) as ydl:
             info = ydl.extract_info(req.youtube_url, download=False)
             video.title = info.get('title', 'Unknown')
@@ -157,17 +137,17 @@ async def submit_video(req: SubmitRequest):
             video.status = VideoStatus.completed.value
             video.frames_count = 100
             video.features_count = 100
-        async with engine.begin() as _c: await _c.run_sync(Base.metadata.create_all)
         async with async_session_factory() as session:
-            await session.merge(video); await session.commit()
+            await session.merge(video)
+            await session.commit()
         return video_to_dict(video)
     except Exception as e:
-        return {"error": str(e), "trace": traceback.format_exc()}
+        return {"error": str(e)}
 
 @app.get("/api/v1/videos/")
 async def list_videos(skip: int = 0, limit: int = 50, status: Optional[str] = None):
     try:
-        async with engine.begin() as _c: await _c.run_sync(Base.metadata.create_all)
+        await ensure_tables()
         async with async_session_factory() as session:
             stmt = select(Video).offset(skip).limit(limit)
             if status: stmt = stmt.where(Video.status == status)
@@ -179,8 +159,8 @@ async def list_videos(skip: int = 0, limit: int = 50, status: Optional[str] = No
 
 @app.get("/api/v1/videos/{video_id}")
 async def get_video(video_id: str):
-    async with engine.begin() as _c: await _c.run_sync(Base.metadata.create_all)
-        async with async_session_factory() as session:
+    await ensure_tables()
+    async with async_session_factory() as session:
         result = await session.execute(select(Video).where(Video.id == video_id))
         video = result.scalar_one_or_none()
         if not video: raise HTTPException(status_code=404, detail="Not found")
@@ -188,8 +168,8 @@ async def get_video(video_id: str):
 
 @app.delete("/api/v1/videos/{video_id}")
 async def delete_video(video_id: str):
-    async with engine.begin() as _c: await _c.run_sync(Base.metadata.create_all)
-        async with async_session_factory() as session:
+    await ensure_tables()
+    async with async_session_factory() as session:
         result = await session.execute(select(Video).where(Video.id == video_id))
         video = result.scalar_one_or_none()
         if video: await session.delete(video); await session.commit()
@@ -201,7 +181,6 @@ async def search(req: SearchRequest):
 
 @app.get("/api/v1/index/stats")
 async def index_stats():
-    import os
     idx_path = "/data/index/index.faiss"
     if os.path.exists(idx_path):
         size = os.path.getsize(idx_path)
@@ -224,7 +203,6 @@ async def create_analysis():
 async def list_analyses():
     return []
 
-# === Launch ===
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)