Update main.py

main.py

@@ -1,14 +1,24 @@
 from fastapi import FastAPI, UploadFile, File, Form, Request
 from fastapi.responses import FileResponse, JSONResponse
+from contextlib import asynccontextmanager
 import os
 import uuid
 import asyncio
 import gradio as gr
 
+# ==============================
+# LOGGER + QUEUE
+# ==============================
 from utils.logger import logger
 from utils.job_queue import start_worker, create_job, get_job
 from ingestion.resolver import resolve_input
 
+# ==============================
+# AUTH SYSTEM ✅ NEW
+# ==============================
+from auth.routes import router as auth_router
+from auth.database import Base, engine
+
 # ==============================
 # CORE PIPELINE
 # ==============================
@@ -35,25 +45,39 @@ from publisher.metadata_engine import generate_metadata
 from publisher.thumbnail_engine import generate_thumbnail
 
 # ==============================
-# INIT
+# INIT (LIFESPAN SAFE)
 # ==============================
-app = FastAPI(title="Basyx Whisper V10.1 Autonomous Operator")
-
 UPLOAD_DIR = "jobs"
 os.makedirs(UPLOAD_DIR, exist_ok=True)
 
-start_worker()
-init_scheduler()
 
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+
+    logger.info("Starting Basyx Whisper V10.1")
+
+    Base.metadata.create_all(bind=engine)
+
+    start_worker()
+    init_scheduler()
 
-@app.on_event("startup")
-async def startup():
-    logger.info("Starting Autonomous Publisher V10.1")
     asyncio.create_task(autonomous_loop())
 
+    yield
+
+    logger.info("Shutdown complete")
+
+
+app = FastAPI(
+    title="Basyx Whisper V10.1 Autonomous Operator",
+    lifespan=lifespan,
+)
+
+# Register Auth Routes
+app.include_router(auth_router)
 
 # ==============================
-# TASK REGISTRY (SAFE)
+# TASK REGISTRY
 # ==============================
 VALID_TASKS = {
     "autonomous",
@@ -70,7 +94,7 @@ VALID_TASKS = {
     "viral-score",
     "strategy",
     "batch",
-    "clips",   # ✅ FIXED missing alias
+    "clips",
 }
 
 
@@ -82,9 +106,10 @@ def normalize_task(task: str):
 
 
 # ==============================
-# SAFE INPUT LOADER (CRITICAL FIX)
+# SAFE INPUT RESOLVER
 # ==============================
 async def safe_resolve(file, source):
+
     try:
         if not file and not source:
             return None
@@ -92,7 +117,7 @@ async def safe_resolve(file, source):
         return await asyncio.to_thread(
             resolve_input,
             source,
-            file
+            file,
         )
 
     except Exception as e:
@@ -104,88 +129,152 @@ async def safe_resolve(file, source):
 # EXECUTION ENGINE
 # ==============================
 async def execute_task(video_path, task, payload=None, webhook=None):
+
     payload = payload or {}
     logger.info(f"[TASK] {task}")
 
-    # ---------------- BULK ----------------
+    # -------- BULK ----------
     if task == "bulk-publish":
         return await bulk_execute(payload), None
 
-    # ---------------- INPUT GUARD ----------------
     if task not in ["bulk-publish", "schedule-post"] and not video_path:
         return {"error": "No valid input resolved"}, None
 
-    # ---------------- AUTONOMOUS ----------------
+    # -------- AUTONOMOUS ----------
     if task == "autonomous":
-        result = await asyncio.to_thread(run_autonomous_engine, video_path)
+        result = await asyncio.to_thread(
+            run_autonomous_engine, video_path
+        )
         return result, None
 
     if task == "auto-publish":
-        auto = await asyncio.to_thread(run_autonomous_engine, video_path)
-        return await dispatch_publish(variants=auto.get("all_variants", [])), None
+        auto = await asyncio.to_thread(
+            run_autonomous_engine, video_path
+        )
+        return await dispatch_publish(
+            variants=auto.get("all_variants", [])
+        ), None
 
-    # ---------------- PUBLISH ----------------
+    # -------- PUBLISH ----------
     if task == "publish":
-        return await dispatch_publish(video_path=video_path, payload=payload), None
+        return await dispatch_publish(
+            video_path=video_path,
+            payload=payload,
+        ), None
 
-    # ---------------- METADATA ----------------
+    # -------- METADATA ----------
     if task == "generate-metadata":
         return generate_metadata(video_path), None
 
+    # ✅ THUMBNAIL FIX
     if task == "generate-thumbnail":
-        try:
-            thumb = generate_thumbnail(video_path, output=f"{UPLOAD_DIR}/{uuid.uuid4()}.jpg")
-            return {"thumbnail": thumb}, thumb
-        except Exception as e:
-            return {"error": str(e)}, None
 
-    # ---------------- PIPELINE ----------------
+        output_path = os.path.join(
+            UPLOAD_DIR,
+            f"{uuid.uuid4()}.jpg"
+        )
+
+        thumb = generate_thumbnail(
+            video_path,
+            output=output_path,
+        )
+
+        return {"thumbnail": thumb}, output_path
+
+    # -------- QUEUE ----------
     if task == "batch":
         job_id = create_job(video_path, webhook=webhook)
         return {"status": "queued", "job_id": job_id}, None
 
+    # -------- TRANSCRIBE ----------
     if task == "transcribe":
-        words = await asyncio.to_thread(transcribe_video, video_path)
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
         return {"words": words}, None
 
     if task == "subtitles":
-        words = await asyncio.to_thread(transcribe_video, video_path)
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
         return {"srt": generate_srt(words)}, None
 
+    # -------- RENDER ----------
     if task == "render":
-        try:
-            words = await asyncio.to_thread(transcribe_video, video_path)
-            srt = generate_srt(words)
 
-            output = os.path.join(UPLOAD_DIR, f"{uuid.uuid4()}_render.mp4")
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
 
-            await asyncio.to_thread(render_subtitles, video_path, srt, output)
+        srt = generate_srt(words)
 
-            return {"status": "render_complete"}, output
+        output = os.path.join(
+            UPLOAD_DIR,
+            f"{uuid.uuid4()}_render.mp4",
+        )
+
+        await asyncio.to_thread(
+            render_subtitles,
+            video_path,
+            srt,
+            output,
+        )
 
-        except Exception as e:
-            return {"error": f"render_failed: {str(e)}"}, None
+        return {"status": "render_complete"}, output
 
+    # -------- HIGHLIGHTS ----------
     if task == "highlights":
-        words = await asyncio.to_thread(transcribe_video, video_path)
+
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
+
         highlights = detect_highlights(words) or []
 
         clips = create_clips(video_path, highlights)
 
-        return {"clips_created": len(clips)}, (clips[0] if clips else None)
+        return {
+            "clips_created": len(clips)
+        }, (clips[0] if clips else None)
+
+    if task == "clips":
+
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
 
-    if task == "clips":   # ✅ FIXED handler
-        words = await asyncio.to_thread(transcribe_video, video_path)
         highlights = detect_highlights(words) or []
-        return {"clips": create_clips(video_path, highlights)}, None
 
+        return {
+            "clips": create_clips(video_path, highlights)
+        }, None
+
+    # -------- SCORING ----------
     if task == "viral-score":
-        words = await asyncio.to_thread(transcribe_video, video_path)
+
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
+
         segments = detect_highlights(words) or []
-        return {"scores": [score_clip(s) for s in segments]}, None
 
+        return {
+            "scores": [score_clip(s) for s in segments]
+        }, None
+
+    # -------- STRATEGY ----------
     if task == "strategy":
-        words = await asyncio.to_thread(transcribe_video, video_path)
+
+        words = await asyncio.to_thread(
+            transcribe_video,
+            video_path,
+        )
 
         script = rewrite_script(words)
         persona = predict_audience(words)
@@ -205,7 +294,7 @@ async def execute_task(video_path, task, payload=None, webhook=None):
 
 
 # ==============================
-# ROUTER
+# EXECUTE ROUTER
 # ==============================
 @app.post("/execute/{task_name}")
 async def execute_router(
@@ -216,25 +305,41 @@ async def execute_router(
     source: str = Form(None),
     webhook: str = Form(None),
 ):
+
     try:
+
         task = normalize_task(task_name)
 
         payload = {}
-        if request.headers.get("content-type", "").startswith("application/json"):
+
+        if request.headers.get(
+            "content-type", ""
+        ).startswith("application/json"):
             payload = await request.json()
 
-        video_path = await safe_resolve(file, url_input or source)
+        video_path = await safe_resolve(
+            file,
+            url_input or source,
+        )
 
-        result, output = await execute_task(video_path, task, payload, webhook)
+        result, output = await execute_task(
+            video_path,
+            task,
+            payload,
+            webhook,
+        )
 
-        if output and isinstance(output, str) and os.path.exists(output):
+        if output and os.path.exists(output):
             return FileResponse(output)
 
         return {"task": task, "result": result}
 
     except Exception as e:
         logger.exception(e)
-        return JSONResponse({"error": str(e)}, status_code=500)
+        return JSONResponse(
+            {"error": str(e)},
+            status_code=500,
+        )
 
 
 # ==============================
@@ -254,15 +359,23 @@ def status(job_id: str):
 # GRADIO UI
 # ==============================
 async def ui_handler(video, task, webhook, url_input):
+
     source = url_input or video
+
     video_path = await safe_resolve(video, source)
 
-    result, output = await execute_task(video_path, normalize_task(task), {}, webhook)
+    result, output = await execute_task(
+        video_path,
+        normalize_task(task),
+        {},
+        webhook,
+    )
 
     return str(result), output
 
 
 with gr.Blocks() as demo:
+
     gr.Markdown("# 🚀 Basyx Whisper V10.1 Stable Operator")
 
     video_input = gr.Video()