Update app.py

app.py

@@ -138,7 +138,259 @@
 
 
 
-# app.py
+# # app.py
+# import os
+# import uuid
+# import shutil
+# import tempfile
+# import asyncio
+# from pathlib import Path
+# from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+# from fastapi.responses import FileResponse, JSONResponse
+# from fastapi.middleware.cors import CORSMiddleware
+# import subprocess
+# # local imports
+# from task_queue import TaskQueue, TaskStatus
+# from core.pipeline import process_image_pipeline  # your real pipeline
+# from fastapi.responses import FileResponse, JSONResponse, Response
+# from fastapi.responses import JSONResponse, Response, FileResponse
+# from fastapi import HTTPException
+# from pathlib import Path
+# import base64
+# import base64
+# from pathlib import Path
+# from moviepy.video.io.VideoFileClip import VideoFileClip
+
+# # --------------------------------------------------
+# # Logging Setup
+# # --------------------------------------------------
+# import logging
+
+# logging.basicConfig(
+#     level=logging.DEBUG,
+#     format="🌀 [%(asctime)s] [%(levelname)s] %(message)s",
+#     datefmt="%H:%M:%S",
+# )
+# logger = logging.getLogger("manim_render_service")
+
+# # --------------------------------------------------
+# # App config
+# # --------------------------------------------------
+# APP_NAME = "manim_render_service"
+# TMP_ROOT = Path("tmp")/ APP_NAME
+# TASKS_DIR = TMP_ROOT / "tasks"
+# OUTPUTS_DIR = TMP_ROOT / "outputs"
+# TASKS_DIR.mkdir(parents=True, exist_ok=True)
+# OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# queue = TaskQueue(base_dir=TMP_ROOT, max_workers=os.cpu_count() or 2)
+
+# app = FastAPI(title="Manim Render Service")
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # --------------------------------------------------
+# # Lifecycle Events
+# # --------------------------------------------------
+# @app.on_event("startup")
+# async def startup_event():
+#     logger.info("🚀 Starting up backend...")
+#     logger.debug(f"Temporary root: {TMP_ROOT}")
+#     await queue.start(processor=process_image_pipeline)
+#     logger.info("✅ Queue system initialized and worker started.")
+
+
+# @app.on_event("shutdown")
+# async def shutdown_event():
+#     logger.info("🧹 Shutting down backend...")
+#     await queue.stop()
+#     logger.info("🛑 Queue stopped gracefully.")
+
+
+# # --------------------------------------------------
+# # Helpers
+# # --------------------------------------------------
+# def _make_task_dir(task_id: str) -> Path:
+#     p = TASKS_DIR / task_id
+#     p.mkdir(parents=True, exist_ok=True)
+#     logger.debug(f"📁 Created task directory: {p}")
+#     return p
+
+
+# def _secure_filename(filename: str) -> str:
+#     safe = "".join(c for c in filename if c.isalnum() or c in "._-").strip("_")
+#     logger.debug(f"🔒 Secured filename: {filename} → {safe}")
+#     return safe
+
+
+# # --------------------------------------------------
+# # Routes
+# # --------------------------------------------------
+# @app.post("/render", status_code=202)
+# async def submit_render(
+#     image: UploadFile = File(...),
+#     style: str = Form("fade-in"),
+#     quality: str = Form("final"),
+# ):
+#     logger.info(f"📨 Received new render request | style={style}, quality={quality}")
+#     logger.debug(f"Uploaded file info: {image.filename}, type={image.content_type}")
+
+#     if image.content_type.split("/")[0] != "image":
+#         logger.error("❌ Invalid file type, not an image.")
+#         raise HTTPException(status_code=400, detail="Uploaded file must be an image.")
+
+#     task_id = uuid.uuid4().hex
+#     task_dir = _make_task_dir(task_id)
+#     logger.info(f"🆔 Generated Task ID: {task_id}")
+
+#     safe_name = _secure_filename(image.filename or f"{task_id}.png")
+#     uploaded_path = task_dir / safe_name
+#     logger.debug(f"🗂 Saving upload to {uploaded_path}")
+
+#     try:
+#         with uploaded_path.open("wb") as f:
+#             content = await image.read()
+#             logger.debug(f"📦 File size: {len(content)/1024:.2f} KB")
+#             if len(content) > 25 * 1024 * 1024:
+#                 logger.warning("⚠️ Upload too large (>25MB). Rejecting.")
+#                 raise HTTPException(status_code=413, detail="File too large (max 25MB).")
+#             f.write(content)
+#     finally:
+#         await image.close()
+#         logger.debug("📁 Image file closed after writing.")
+
+#     meta = {
+#         "task_id": task_id,
+#         "input_image": str(uploaded_path),
+#         "style": style,
+#         "quality": quality,
+#         "task_dir": str(task_dir),
+#     }
+
+#     logger.debug(f"🧾 Task metadata: {meta}")
+#     queue.enqueue(meta)
+#     logger.info(f"📤 Task {task_id} successfully enqueued.")
+
+#     return JSONResponse({"task_id": task_id, "status": "queued"})
+
+
+# @app.get("/status/{task_id}")
+# async def status(task_id: str):
+#     logger.debug(f"Status check for task: {task_id}")
+#     st = queue.get_status(task_id)
+#     if st is None:
+#         logger.warning(f"Task {task_id} not found")
+#         raise HTTPException(status_code=404, detail="Task not found")
+    
+#     # Get additional info
+#     task_info = queue.get_task_info(task_id)
+#     logger.info(f"Task {task_id} status: {st.name} | info: {task_info}")
+    
+#     return JSONResponse({
+#         "task_id": task_id,
+#         "status": st.name,
+#         "details": task_info
+#     })
+
+
+
+# @app.get("/result/{task_id}")
+# async def result(task_id: str):
+#     logger.debug(f"📦 Fetching result for task: {task_id}")
+#     info = queue.get_task_info(task_id)
+#     if info is None:
+#         logger.warning(f"⚠️ Task info not found for {task_id}")
+#         raise HTTPException(status_code=404, detail="Task not found")
+#     status = queue.get_status(task_id)
+#     logger.debug(f"📈 Task {task_id} current status: {status.name}")
+#     if status != TaskStatus.COMPLETED:
+#         logger.info(f"⏳ Task {task_id} still in progress ({status.name})")
+#         return JSONResponse({"task_id": task_id, "status": status.name})
+#     info = queue.get_task_info(task_id)
+#     output_path = Path(info.get("output_path", ""))  # MOV path
+#     if not output_path.exists():
+#         logger.error(f"❌ Output file missing for task {task_id}")
+#         raise HTTPException(status_code=404, detail="Output not found")
+    
+#     # Convert MOV to optimized WEBM with reduced file size
+#     webm_path = output_path.with_suffix(".webm")
+#     if output_path.suffix.lower() == ".mov" and not webm_path.exists():
+#         try:
+#             logger.info(f"🎞️ Converting .mov → .webm (optimized for size)...")
+#             cmd = [
+#                 "ffmpeg",
+#                 "-y",
+#                 "-i", str(output_path),
+#                 "-c:v", "libvpx-vp9",
+#                 "-pix_fmt", "yuva420p",  # keep alpha channel
+#                 "-b:v", "2M",  # Reduced bitrate (from 4M to 2M) - keeps quality but smaller file
+#                 "-maxrate", "2.5M",
+#                 "-bufsize", "5M",
+#                 "-auto-alt-ref", "0",
+#                 "-cpu-used", "4",  # Speed up encoding
+#                 "-tile-columns", "2",  # Enable parallelization
+#                 "-tile-rows", "2",
+#                 str(webm_path)
+#             ]
+#             subprocess.run(cmd, check=True, capture_output=True)
+            
+#             # Log file sizes
+#             mov_size = output_path.stat().st_size / (1024 * 1024)
+#             webm_size = webm_path.stat().st_size / (1024 * 1024)
+#             logger.info(f"✅ Converted successfully → {webm_path}")
+#             logger.info(f"📊 File sizes - MOV: {mov_size:.2f}MB → WEBM: {webm_size:.2f}MB (reduction: {((1 - webm_size/mov_size) * 100):.1f}%)")
+#         except Exception as e:
+#             logger.error(f"⚠️ MOV→WEBM conversion failed: {e}")
+#             raise HTTPException(status_code=500, detail=f"Conversion failed: {e}")
+    
+#     # Read only WEBM as bytes
+#     webm_bytes = webm_path.read_bytes()
+#     webm_size = len(webm_bytes) / (1024 * 1024)
+#     logger.info(f"✅ Sending WEBM only ({webm_size:.2f}MB) for task {task_id}")
+    
+#     return JSONResponse({
+#         "task_id": task_id,
+#         "status": "COMPLETED",
+#         "results": [
+#             {
+#                 "format": "webm",
+#                 "data": base64.b64encode(webm_bytes).decode("utf-8"),
+#             },
+#         ],
+#     })
+# @app.delete("/task/{task_id}")
+# async def delete_task(task_id: str):
+#     logger.info(f"🗑 Request to delete task: {task_id}")
+#     info = queue.get_task_info(task_id)
+#     if info:
+#         task_dir = Path(info.get("task_dir", ""))
+#         if task_dir.exists():
+#             logger.debug(f"🧹 Removing directory: {task_dir}")
+#             shutil.rmtree(task_dir, ignore_errors=True)
+#         queue.remove_task(task_id)
+#         logger.info(f"✅ Task {task_id} removed successfully.")
+#         return JSONResponse({"task_id": task_id, "status": "removed"})
+#     else:
+#         logger.warning(f"⚠️ Task {task_id} not found for deletion.")
+#         raise HTTPException(status_code=404, detail="Task not found")
+
+
+
+
+
+# @app.get("/")
+# def home():
+#     return {"status": "Your Manim backend is running!"}
+
+
+
+
+
 import os
 import uuid
 import shutil
@@ -149,23 +401,16 @@ from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import subprocess
+import logging
+import base64
+
 # local imports
 from task_queue import TaskQueue, TaskStatus
-from core.pipeline import process_image_pipeline  # your real pipeline
-from fastapi.responses import FileResponse, JSONResponse, Response
-from fastapi.responses import JSONResponse, Response, FileResponse
-from fastapi import HTTPException
-from pathlib import Path
-import base64
-import base64
-from pathlib import Path
-from moviepy.video.io.VideoFileClip import VideoFileClip
+from core.pipeline import process_image_pipeline
 
 # --------------------------------------------------
 # Logging Setup
 # --------------------------------------------------
-import logging
-
 logging.basicConfig(
     level=logging.DEBUG,
     format="🌀 [%(asctime)s] [%(levelname)s] %(message)s",
@@ -177,7 +422,7 @@ logger = logging.getLogger("manim_render_service")
 # App config
 # --------------------------------------------------
 APP_NAME = "manim_render_service"
-TMP_ROOT = Path("tmp")/ APP_NAME
+TMP_ROOT = Path("tmp") / APP_NAME
 TASKS_DIR = TMP_ROOT / "tasks"
 OUTPUTS_DIR = TMP_ROOT / "outputs"
 TASKS_DIR.mkdir(parents=True, exist_ok=True)
@@ -298,167 +543,69 @@ async def status(task_id: str):
     })
 
 
-# async def result(task_id: str):
-#     logger.debug(f"📦 Fetching result for task: {task_id}")
-#     info = queue.get_task_info(task_id)
-#     if info is None:
-#         logger.warning(f"⚠️ Task info not found for {task_id}")
-#         raise HTTPException(status_code=404, detail="Task not found")
-
-#     status = queue.get_status(task_id)
-#     logger.debug(f"📈 Task {task_id} current status: {status.name}")
-
-#     if status != TaskStatus.COMPLETED:
-#         logger.info(f"⏳ Task {task_id} still in progress ({status.name})")
-#         return JSONResponse({"task_id": task_id, "status": status.name})
-
-#     output_path = Path(info.get("output_path", ""))
-#     logger.debug(f"🧩 Checking output path: {output_path}")
-#     # if not output_path.exists():
-#     #     logger.error(f"❌ Output file missing for task {task_id}")
-#     #     raise HTTPException(status_code=404, detail="Output not found on disk")
-    
-#     info = queue.get_task_info(task_id)
-#     output_bytes = info.get("output_bytes")
-
-#     if output_bytes:
-#         logger.info(f"🎬 Returning in-memory video for task {task_id}")
-#         return Response(content=output_bytes, media_type="video")
-
-# # fallback to disk if memory missing
-#     if not output_path.exists():
-#         logger.error(f"❌ Output file missing for task {task_id}")
-#         raise HTTPException(status_code=404, detail="Output not found on disk")
-
-#     logger.info(f"🎬 Returning result video from disk for task {task_id}")
-#     return FileResponse(
-#         path=str(output_path), filename=output_path.name, media_type="video"
-#         )
 @app.get("/result/{task_id}")
-# async def result(task_id: str):
-#     logger.debug(f"📦 Fetching result for task: {task_id}")
-#     info = queue.get_task_info(task_id)
-#     if info is None:
-#         logger.warning(f"⚠️ Task info not found for {task_id}")
-#         raise HTTPException(status_code=404, detail="Task not found")
-
-#     status = queue.get_status(task_id)
-#     logger.debug(f"📈 Task {task_id} current status: {status.name}")
-
-#     if status != TaskStatus.COMPLETED:
-#         logger.info(f"⏳ Task {task_id} still in progress ({status.name})")
-#         return JSONResponse({"task_id": task_id, "status": status.name})
-
-#     info = queue.get_task_info(task_id)
-#     output_path = Path(info.get("output_path", ""))  # MOV path
-
-#     if not output_path.exists():
-#         logger.error(f"❌ Output file missing for task {task_id}")
-#         raise HTTPException(status_code=404, detail="Output not found")
-    
-#     # Convert MOV to WEBM with alpha if needed
-#     webm_path = output_path.with_suffix(".webm")
-#     if output_path.suffix.lower() == ".mov" and not webm_path.exists():
-#         try:
-#             logger.info(f"🎞️ Converting .mov → .webm (keeping transparency)...")
-#             cmd = [
-#                 "ffmpeg",
-#                 "-y",
-#                 "-i", str(output_path),
-#                 "-c:v", "libvpx-vp9",
-#                 "-pix_fmt", "yuva420p",  # keep alpha channel
-#                 "-b:v", "4M",
-#                 "-auto-alt-ref", "0",
-#                 str(webm_path)
-#             ]
-#             subprocess.run(cmd, check=True, capture_output=True)
-#             logger.info(f"✅ Converted successfully → {webm_path}")
-#         except Exception as e:
-#             logger.error(f"⚠️ MOV→WEBM conversion failed: {e}")
-#             raise HTTPException(status_code=500, detail=f"Conversion failed: {e}")
-    
-#     # Read both MOV and WEBM as bytes
-#     mov_bytes = output_path.read_bytes()
-#     webm_bytes = webm_path.read_bytes()
-
-#     logger.info(f"✅ Returning both MOV + WEBM for task {task_id}")
-#     return JSONResponse({
-#         "task_id": task_id,
-#         "status": "COMPLETED",
-#         "results": [
-#             {
-#                 "format": "mov",
-#                 "data": base64.b64encode(mov_bytes).decode("utf-8"),
-#             },
-#             {
-#                 "format": "webm",
-#                 "data": base64.b64encode(webm_bytes).decode("utf-8"),
-#             },
-#         ],
-#     })
 async def result(task_id: str):
     logger.debug(f"📦 Fetching result for task: {task_id}")
     info = queue.get_task_info(task_id)
     if info is None:
         logger.warning(f"⚠️ Task info not found for {task_id}")
         raise HTTPException(status_code=404, detail="Task not found")
+    
     status = queue.get_status(task_id)
     logger.debug(f"📈 Task {task_id} current status: {status.name}")
     if status != TaskStatus.COMPLETED:
         logger.info(f"⏳ Task {task_id} still in progress ({status.name})")
         return JSONResponse({"task_id": task_id, "status": status.name})
-    info = queue.get_task_info(task_id)
-    output_path = Path(info.get("output_path", ""))  # MOV path
+    
+    output_path = Path(info.get("output_path", ""))
     if not output_path.exists():
         logger.error(f"❌ Output file missing for task {task_id}")
         raise HTTPException(status_code=404, detail="Output not found")
     
-    # Convert MOV to optimized WEBM with reduced file size
+    # Convert MOV to optimized WEBM
     webm_path = output_path.with_suffix(".webm")
     if output_path.suffix.lower() == ".mov" and not webm_path.exists():
         try:
-            logger.info(f"🎞️ Converting .mov → .webm (optimized for size)...")
+            logger.info(f"🎞️ Converting .mov → .webm (optimized)...")
             cmd = [
                 "ffmpeg",
                 "-y",
                 "-i", str(output_path),
                 "-c:v", "libvpx-vp9",
-                "-pix_fmt", "yuva420p",  # keep alpha channel
-                "-b:v", "2M",  # Reduced bitrate (from 4M to 2M) - keeps quality but smaller file
+                "-pix_fmt", "yuva420p",
+                "-b:v", "2M",
                 "-maxrate", "2.5M",
                 "-bufsize", "5M",
                 "-auto-alt-ref", "0",
-                "-cpu-used", "4",  # Speed up encoding
-                "-tile-columns", "2",  # Enable parallelization
+                "-cpu-used", "4",
+                "-tile-columns", "2",
                 "-tile-rows", "2",
                 str(webm_path)
             ]
             subprocess.run(cmd, check=True, capture_output=True)
             
-            # Log file sizes
             mov_size = output_path.stat().st_size / (1024 * 1024)
             webm_size = webm_path.stat().st_size / (1024 * 1024)
-            logger.info(f"✅ Converted successfully → {webm_path}")
-            logger.info(f"📊 File sizes - MOV: {mov_size:.2f}MB → WEBM: {webm_size:.2f}MB (reduction: {((1 - webm_size/mov_size) * 100):.1f}%)")
+            logger.info(f"✅ Converted: MOV {mov_size:.2f}MB → WEBM {webm_size:.2f}MB ({((1 - webm_size/mov_size) * 100):.1f}% smaller)")
         except Exception as e:
-            logger.error(f"⚠️ MOV→WEBM conversion failed: {e}")
+            logger.error(f"⚠️ Conversion failed: {e}")
             raise HTTPException(status_code=500, detail=f"Conversion failed: {e}")
     
-    # Read only WEBM as bytes
-    webm_bytes = webm_path.read_bytes()
-    webm_size = len(webm_bytes) / (1024 * 1024)
-    logger.info(f"✅ Sending WEBM only ({webm_size:.2f}MB) for task {task_id}")
+    if not webm_path.exists():
+        logger.error(f"❌ WEBM file not found after conversion: {webm_path}")
+        raise HTTPException(status_code=500, detail="WEBM file generation failed")
     
-    return JSONResponse({
-        "task_id": task_id,
-        "status": "COMPLETED",
-        "results": [
-            {
-                "format": "webm",
-                "data": base64.b64encode(webm_bytes).decode("utf-8"),
-            },
-        ],
-    })
+    webm_size = webm_path.stat().st_size / (1024 * 1024)
+    logger.info(f"✅ Streaming WEBM ({webm_size:.2f}MB) for task {task_id}")
+    
+    # Stream the file directly instead of base64 encoding
+    return FileResponse(
+        path=webm_path,
+        media_type="video/webm",
+        filename=f"{task_id}.webm"
+    )
+
+
 @app.delete("/task/{task_id}")
 async def delete_task(task_id: str):
     logger.info(f"🗑 Request to delete task: {task_id}")
@@ -476,10 +623,6 @@ async def delete_task(task_id: str):
         raise HTTPException(status_code=404, detail="Task not found")
 
 
-
-
-
 @app.get("/")
 def home():
-    return {"status": "Your Manim backend is running!"}
-
+    return {"status": "Your Manim backend is running!"}