Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import json
 import requests
+import shutil
 import cloudinary
 import cloudinary.uploader
 from requests.adapters import HTTPAdapter
@@ -67,22 +68,20 @@ def time_to_seconds(t_str: str) -> int:
     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.get('sessionId')
     video_url = session_data.get('originalVideoUrl')
     callback_url = session_data.get('callbackBaseUrl')
     
+
+    session_dir = os.path.join(RESULT_DIR, session_id)
+    os.makedirs(session_dir, exist_ok=True)
+    
     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")
-# 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:
@@ -90,10 +89,9 @@ def background_processing(session_data: dict):
                 f.write(chunk)
     except Exception as e:
         print(f"[DOWNLOAD ERROR]: {e}")
-        # Notify backend that it failed due to download
         return
 
-    # 2. Prepare question list for the AI Pipeline
+
     final_questions = []
     skipped_failed_reports = []
     
@@ -107,47 +105,45 @@ def background_processing(session_data: dict):
                 "end_time": time_to_seconds(q['submittedAt'])
             })
         else:
-            # Handle questions that weren't answered during the session
             skipped_failed_reports.append({
                 "questionId": q['aiQuestionId'],
                 "userAnswerText": "N/A",
-                "score": 0.0,                       
-                "relevance": 0.0,
-                "confidence": 0.0,
-                "stress": 0.0,
-                "clarity": 0.0,
-                "pauses": 0.0,
-                "toneOfVoice": "N/A",
+                "score": 0.0, "relevance": 0.0, "confidence": 0.0,
+                "stress": 0.0, "clarity": 0.0, "pauses": 0.0,
+                "toneOfVoice": 3, # Natural/NA
                 "status": "skipped" if q.get('isSkipped') else "failed"
             })
 
-    # 3. Execute AI Pipeline (Analysis & Visualization)
     ai_results = []
+    final_video_path = None
+    
     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")
+
+        run_intervision_pipeline(local_input_path, final_questions, session_dir)
+        
+        report_path = os.path.join(session_dir, "report.json")
+
+        final_video_path = os.path.join(session_dir, "Intervision_Final_Report.mp4")
+        
         if os.path.exists(report_path):
             with open(report_path, "r") as f:
                 ai_results = json.load(f).get("listOfAnswerReport", [])
 
-    # 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):
+    if final_video_path and os.path.exists(final_video_path):
         try:
             upload_res = cloudinary.uploader.upload(
                 final_video_path, 
                 public_id=f"res_{session_id}", 
                 folder="intervision_results",
-                resource_type="video",
-                chunk_size=6000000
+                resource_type="video"
             )
             final_video_url = upload_res.get("secure_url")
         except Exception as e:
             print(f"[UPLOAD ERROR]: {e}")
 
-    # 5. Construct final payload and notify Backend via Callback
+
     final_payload = {
         "sessionId": session_id,
         "finalVideoUrl": final_video_url,
@@ -155,16 +151,17 @@ def background_processing(session_data: dict):
     }
     
     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 to {callback_url}. Status: {cb_response.status_code}")
+        requests.post(f"{callback_url}/api/ai-callback", json=final_payload, timeout=30)
         
-        # 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)
+
+        print(f"[LOG] Cleaning up session {session_id}...")
+        if os.path.exists(local_input_path): 
+            os.remove(local_input_path)
+        if os.path.exists(session_dir): 
+            shutil.rmtree(session_dir)
             
     except Exception as e:
-        print(f"[CALLBACK ERROR]: {e}")
+        print(f"[CALLBACK/CLEANUP ERROR]: {e}")
 
 @app.get("/")
 async def root():