Update app.py

app.py

@@ -6,16 +6,16 @@ import cloudinary.uploader
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 from fastapi import FastAPI, Body, HTTPException, BackgroundTasks
-from pydantic import BaseModel, HttpUrl
-from typing import List, Optional
 from dotenv import load_dotenv
+from datetime import datetime
+from pydantic import BaseModel, HttpUrl
+from typing import List
 from pipeline import run_intervision_pipeline
 
-# --- 1. Setup Retry Strategy for Robust Downloads ---
-# This ensures that if the video download fails momentarily, it retries 3 times.
+# --- Setup Retry Strategy ---
 retry_strategy = Retry(
     total=3,
-    backoff_factor=1, 
+    backoff_factor=1, # Wait 1s, 2s, 4s between retries
     status_forcelist=[429, 500, 502, 503, 504],
 )
 adapter = HTTPAdapter(max_retries=retry_strategy)
@@ -26,71 +26,63 @@ http.mount("http://", adapter)
 # Load environment variables from .env file
 load_dotenv()
 
-app = FastAPI(
-    title="Intervision AI Engine",
-    description="Asynchronous AI Pipeline for Interview Analysis",
-    version="1.1.0"
-)
+app = FastAPI(title="Intervision AI Engine")
 
-# --- 2. Cloudinary Configuration ---
-cloudinary.config(
-    cloud_name=os.getenv("CLOUDINARY_CLOUD_NAME"),
-    api_key=os.getenv("CLOUDINARY_API_KEY"),
-    api_secret=os.getenv("CLOUDINARY_API_SECRET")
+# Cloudinary Configuration
+cloudinary.config( 
+    cloud_name = os.getenv("CLOUDINARY_CLOUD_NAME"), 
+    api_key = os.getenv("CLOUDINARY_API_KEY"), 
+    api_secret = os.getenv("CLOUDINARY_API_SECRET") 
 )
 
-# --- 3. Directory Setup ---
+# Directory Setup
 RESULT_DIR = "temp_data/results"
 UPLOAD_DIR = "temp_data/uploads"
 os.makedirs(RESULT_DIR, exist_ok=True)
 os.makedirs(UPLOAD_DIR, exist_ok=True)
 
-# --- 4. Pydantic Models (Fixes the "additionalProp1" issue) ---
-class AnswerDetail(BaseModel):
+class Answer(BaseModel):
     aiQuestionId: int
     questionText: str
     expectedAnswer: str
     isAnswered: bool
     isSkipped: bool
-    startedAt: str  # Expected format "HH:MM:SS"
-    submittedAt: str # Expected format "HH:MM:SS"
+    isFailed: bool
+    startedAt: str
+    submittedAt: str
 
 class InterviewRequest(BaseModel):
     sessionId: str
     originalVideoUrl: HttpUrl
     callbackBaseUrl: HttpUrl
-    answers: List[AnswerDetail]
+    answers: List[Answer]
+    
+class DeleteVideoRequest(BaseModel):
+    videoUrl: str
 
-# --- 5. Helper Functions ---
 def time_to_seconds(t_str: str) -> int:
-    """Converts HH:MM:SS or MM:SS timestamp format to total seconds."""
-    if not t_str or ":" not in t_str: return 0
-    parts = list(map(int, t_str.split(':')))
-    if len(parts) == 3:
-        h, m, s = parts
-        return h * 3600 + m * 60 + s
-    elif len(parts) == 2:
-        m, s = parts
-        return m * 60 + s
-    return 0
-
-# --- 6. Background Processing Logic ---
-def background_processing(session_data: InterviewRequest):
+    """Converts HH:MM:SS timestamp format to total seconds."""
+    if not t_str: return 0
+    h, m, s = map(int, t_str.split(':'))
+    return h * 3600 + m * 60 + s
+
+def background_processing(session_data: dict):
     """
     Handles heavy AI processing: video download, pipeline execution, 
     result upload, and backend notification (callback).
     """
-    session_id = session_data.sessionId
-    video_url = str(session_data.originalVideoUrl)
-    callback_url = str(session_data.callbackBaseUrl)
+    session_id = session_data.get('sessionId')
+    video_url = session_data.get('originalVideoUrl')
+    callback_url = session_data.get('callbackBaseUrl')
     
     print(f"[LOG] Processing started for session: {session_id}")
     
+    # 1. Download the original video from the provided URL
     local_input_path = os.path.join(UPLOAD_DIR, f"{session_id}_input.mp4")
-
-    # Step 1: Download the original video
+# 1. Download with increased timeout and Retry logic
     try:
         print(f"[LOG] Downloading video: {video_url}")
+        # Increased timeout to 300s (5 minutes) for large files
         response = http.get(video_url, stream=True, timeout=300)
         response.raise_for_status()
         with open(local_input_path, 'wb') as f:
@@ -98,60 +90,64 @@ def background_processing(session_data: InterviewRequest):
                 f.write(chunk)
     except Exception as e:
         print(f"[DOWNLOAD ERROR]: {e}")
+        # Notify backend that it failed due to download
         return
 
-    # Step 2: Prepare questions for the Pipeline
+    # 2. Prepare question list for the AI Pipeline
     final_questions = []
     skipped_failed_reports = []
     
-    for q in session_data.answers:
-        if q.isAnswered:
+    for q in session_data.get('answers', []):
+        if q.get('isAnswered'):
             final_questions.append({
-                "question_id": q.aiQuestionId,
-                "question_text": q.questionText,
-                "ideal_answer": q.expectedAnswer,
-                "start_time": time_to_seconds(q.startedAt),
-                "end_time": time_to_seconds(q.submittedAt)
+                "question_id": q['aiQuestionId'],
+                "question_text": q['questionText'],
+                "ideal_answer": q['expectedAnswer'],
+                "start_time": time_to_seconds(q['startedAt']),
+                "end_time": time_to_seconds(q['submittedAt'])
             })
         else:
+            # Handle questions that weren't answered during the session
             skipped_failed_reports.append({
-                "questionId": q.aiQuestionId,
+                "questionId": q['aiQuestionId'],
                 "userAnswerText": "N/A",
-                "score": 0.0,
+                "score": 0.0,                       
                 "relevance": 0.0,
                 "confidence": 0.0,
                 "stress": 0.0,
                 "clarity": 0.0,
                 "pauses": 0.0,
-                "toneOfVoice": 3, # Default to Natural/N/A
-                "status": "skipped" if q.isSkipped else "failed"
+                "toneOfVoice": "N/A",
+                "status": "skipped" if q.get('isSkipped') else "failed"
             })
 
-    # Step 3: Execute AI Pipeline
+    # 3. Execute AI Pipeline (Analysis & Visualization)
     ai_results = []
     if final_questions:
+        # run_intervision_pipeline generates Intervision_Final_Result.mp4
         run_intervision_pipeline(local_input_path, final_questions, RESULT_DIR)
         report_path = os.path.join(RESULT_DIR, "report.json")
         if os.path.exists(report_path):
             with open(report_path, "r") as f:
                 ai_results = json.load(f).get("listOfAnswerReport", [])
 
-    # Step 4: Upload processed video to Cloudinary
+    # 4. Upload the processed video to Cloudinary
     final_video_path = os.path.join(RESULT_DIR, "Intervision_Final_Result.mp4")
     final_video_url = None
     if os.path.exists(final_video_path):
         try:
             upload_res = cloudinary.uploader.upload(
-                final_video_path,
-                public_id=f"res_{session_id}",
+                final_video_path, 
+                public_id=f"res_{session_id}", 
                 folder="intervision_results",
-                resource_type="video"
+                resource_type="video",
+                chunk_size=6000000
             )
             final_video_url = upload_res.get("secure_url")
         except Exception as e:
             print(f"[UPLOAD ERROR]: {e}")
 
-    # Step 5: Construct final payload and notify Backend
+    # 5. Construct final payload and notify Backend via Callback
     final_payload = {
         "sessionId": session_id,
         "finalVideoUrl": final_video_url,
@@ -159,48 +155,57 @@ def background_processing(session_data: InterviewRequest):
     }
     
     try:
+        # Notify backend that processing is complete
         cb_response = requests.post(f"{callback_url}/api/ai-callback", json=final_payload, timeout=30)
-        print(f"[LOG] Callback sent. Status: {cb_response.status_code}")
+        print(f"[LOG] Callback sent to {callback_url}. Status: {cb_response.status_code}")
         
-        # Cleanup local files
+        # 6. Local Cleanup: Remove files to save disk space
         if os.path.exists(local_input_path): os.remove(local_input_path)
         if os.path.exists(final_video_path): os.remove(final_video_path)
+            
     except Exception as e:
         print(f"[CALLBACK ERROR]: {e}")
 
-# --- 7. API Routes ---
-
 @app.get("/")
 async def root():
-    """Health check endpoint to verify the service is running."""
     return {
-        "status": "online", 
-        "message": "Intervision AI Engine is running",
-        "documentation": "/docs"
+        "status": "Intervision AI Engine Running",
+        "message": "API is working successfully"
     }
 
-@app.post("/process-interview/")
+@app.post("/process-interview")
 async def process_interview(background_tasks: BackgroundTasks, data: InterviewRequest):
-    """
-    Entry point to start the AI analysis asynchronously.
-    Receives validated data via InterviewRequest model.
-    """
-    background_tasks.add_task(background_processing, data)
-    return {"message": "Processing started", "sessionId": data.sessionId}
+    background_tasks.add_task(background_processing, data.dict())
+    return {
+        "message": "Processing started",
+        "sessionId": data.sessionId
+    }
 
-@app.post("/delete-video-by-url/")
-async def delete_video_by_url(payload: dict = Body(...)):
-    """Deletes a video from Cloudinary based on its URL."""
-    video_url = payload.get("videoUrl")
+@app.post("/delete-video-by-url")
+async def delete_video_by_url(data: DeleteVideoRequest):
+
+    video_url = data.videoUrl
     if not video_url:
         raise HTTPException(status_code=400, detail="videoUrl is required")
+
     try:
+        # Logic to extract the public_id from a Cloudinary URL
+        # Example: .../folder/public_id.mp4 -> folder/public_id
         url_parts = video_url.split('/')
-        filename = url_parts[-1].split('.')[0]
-        folder = "intervision_results" if "intervision_results" in video_url else ""
+        filename_with_ext = url_parts[-1]
+        filename = filename_with_ext.split('.')[0]
+        
+        # Check if the video is inside the results folder
+        folder = url_parts[-2] if "intervision_results" in url_parts[-2] else ""
         public_id = f"{folder}/{filename}" if folder else filename
+
+        # Trigger deletion from Cloudinary
         result = cloudinary.uploader.destroy(public_id, resource_type="video")
-        return {"status": result.get("result"), "public_id": public_id}
+
+        if result.get("result") == "ok":
+            return {"status": "success", "message": f"Deleted {public_id}"}
+        return {"status": "failed", "details": result}
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))