Update main.py

main.py

@@ -14,36 +14,35 @@ TEMP_DIR = "/tmp/whisper_jobs"
 CLEANUP_INTERVAL = 600  # 10 minutes
 FILE_MAX_AGE = 1800     # 30 minutes
 
-# --- LIFESPAN & AUTO-CLEANUP ---
+# --- BACKGROUND ASYNC TASKS ---
 
-async def auto_cleanup():
-    """Background task to ensure the Hugging Face Space disk doesn't fill up."""
+async def auto_cleanup_task():
+    """Safety net to prevent disk overflow on Hugging Face."""
     while True:
         try:
             now = time.time()
             if os.path.exists(TEMP_DIR):
                 for f in os.listdir(TEMP_DIR):
                     p = os.path.join(TEMP_DIR, f)
-                    # Delete if file is older than 30 minutes
                     if os.path.isfile(p) and (now - os.path.getmtime(p) > FILE_MAX_AGE):
                         os.remove(p)
-                        logger.info(f"Auto-cleaned stale file: {f}")
+                        logger.info(f"Disk Cleanup: Removed stale file {f}")
         except Exception as e:
-            logger.error(f"Cleanup task error: {e}")
+            logger.error(f"Cleanup Error: {e}")
         await asyncio.sleep(CLEANUP_INTERVAL)
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     os.makedirs(TEMP_DIR, exist_ok=True)
-    cleanup_task = asyncio.create_task(auto_cleanup())
+    cleanup_loop = asyncio.create_task(auto_cleanup_task())
     yield
-    cleanup_task.cancel()
+    cleanup_loop.cancel()
 
-app = FastAPI(title="Basyx TikTok Video Factory", lifespan=lifespan)
+app = FastAPI(title="Basyx Whisper Orchestrator", lifespan=lifespan)
 
-# --- GRADIO UI (Manual Interface) ---
+# --- GRADIO UI LOGIC ---
 
-def gradio_interface(audio_path):
+def gradio_transcribe_only(audio_path):
     if not audio_path: return "No file uploaded.", ""
     try:
         segments, _ = engine.run(audio_path, word_timestamps=False)
@@ -51,22 +50,54 @@ def gradio_interface(audio_path):
         return full_text, generate_srt(segments)
     except Exception as e: return f"Error: {str(e)}", ""
 
-io = gr.Interface(
-    fn=gradio_interface,
-    inputs=gr.Audio(type="filepath", label="Quick Test"),
-    outputs=[gr.Textbox(label="Transcription"), gr.Textbox(label="SRT")],
-    title="Basyx Whisper Orchestrator",
-    description="Manual testing zone. Use /v1/render-tiktok for n8n automation."
-)
+def gradio_render_video(video_path):
+    if not video_path: return None
+    try:
+        job_id = f"manual_{uuid.uuid4()}"
+        out_path = os.path.join(TEMP_DIR, f"{job_id}.mp4")
+        
+        # Process video for TikTok style
+        segments, _ = engine.run(video_path, word_timestamps=True)
+        highlight_frames = sub_engine.create_highlight_chunks(segments)
+        render_tiktok_video(video_path, highlight_frames, out_path)
+        
+        return out_path
+    except Exception as e:
+        logger.error(f"UI Rendering Failed: {e}")
+        return None
 
-# --- API ENDPOINTS ---
+# Build the Tabbed UI
+with gr.Blocks(title="Basyx Whisper Orchestrator") as demo:
+    gr.Markdown("# 🎬 Basyx Whisper & TikTok Factory")
+    gr.Markdown("Manual testing zone. Use `/v1/render-tiktok` for n8n automation.")
+    
+    with gr.Tabs():
+        with gr.TabItem("Quick Transcription"):
+            with gr.Row():
+                with gr.Column():
+                    audio_input = gr.Audio(type="filepath", label="Upload Audio/Video")
+                    transcribe_btn = gr.Button("Transcribe", variant="primary")
+                with gr.Column():
+                    text_out = gr.Textbox(label="Transcription")
+                    srt_out = gr.Textbox(label="SRT Format")
+            transcribe_btn.click(gradio_transcribe_only, inputs=audio_input, outputs=[text_out, srt_out])
+
+        with gr.TabItem("TikTok Video Renderer"):
+            with gr.Row():
+                with gr.Column():
+                    video_input = gr.Video(label="Source Video")
+                    render_btn = gr.Button("Render TikTok Style", variant="primary")
+                with gr.Column():
+                    video_output = gr.Video(label="Finished Video")
+            render_btn.click(gradio_render_video, inputs=video_input, outputs=video_output)
+
+# --- API ENDPOINTS FOR N8N ---
 
 @app.post("/v1/transcribe")
-async def transcribe(file: UploadFile = File(...), word_timestamps: bool = Form(True)):
-    """Simple text-only transcription for n8n."""
+async def transcribe_api(file: UploadFile = File(...), word_timestamps: bool = Form(True)):
+    """Standard text-only transcription."""
     job_id = str(uuid.uuid4())
     input_path = os.path.join(TEMP_DIR, f"{job_id}_{file.filename}")
-    
     with open(input_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
     
@@ -74,7 +105,6 @@ async def transcribe(file: UploadFile = File(...), word_timestamps: bool = Form(
         segments, info = engine.run(input_path, word_timestamps=word_timestamps)
         return {
             "status": "success",
-            "job_id": job_id,
             "full_text": " ".join([s.text.strip() for s in segments]),
             "srt": generate_srt(segments),
             "metadata": {"language": info.language, "duration": round(info.duration, 2)}
@@ -83,49 +113,33 @@ async def transcribe(file: UploadFile = File(...), word_timestamps: bool = Form(
         if os.path.exists(input_path): os.remove(input_path)
 
 @app.post("/v1/render-tiktok")
-async def render_tiktok(file: UploadFile = File(...)):
-    """
-    The TikTok Factory Endpoint:
-    - High-precision transcription.
-    - Pango-style word highlight chunking.
-    - MoviePy rendering with Bounce/Pop effects.
-    - Returns the finished .mp4 file.
-    """
+async def render_tiktok_api(file: UploadFile = File(...)):
+    """Full TikTok video production factory."""
     job_id = str(uuid.uuid4())
     input_path = os.path.join(TEMP_DIR, f"{job_id}_{file.filename}")
-    output_path = os.path.join(TEMP_DIR, f"render_{job_id}.mp4")
+    output_path = os.path.join(TEMP_DIR, f"api_render_{job_id}.mp4")
 
-    # Save incoming video
     with open(input_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
 
     try:
-        logger.info(f"Processing TikTok Render: {job_id}")
-        
-        # 1. Inference with word-level precision
+        logger.info(f"API Render Start: {job_id}")
         segments, _ = engine.run(input_path, word_timestamps=True)
-        
-        # 2. Process words into highlight-ready frames (Pango Logic)
         highlight_frames = sub_engine.create_highlight_chunks(segments)
-        
-        # 3. Render video (This blocks until finished)
         render_tiktok_video(input_path, highlight_frames, output_path)
 
-        # 4. Response
         return FileResponse(
             path=output_path,
-            filename=f"captioned_{file.filename}",
+            filename=f"tiktok_{file.filename}",
             media_type="video/mp4"
         )
-        
     except Exception as e:
-        logger.error(f"TikTok Render Job {job_id} failed: {e}")
+        logger.error(f"API Render Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
-    # FileResponse handles the stream. Cleanup task handles the disk later.
 
 @app.get("/health")
 async def health():
     return {"status": "ready"}
 
-# Mount Gradio to the root
-app = gr.mount_gradio_app(app, io, path="/")
+# Mount everything
+app = gr.mount_gradio_app(app, demo, path="/")