Update app.py

app.py

@@ -56,49 +56,65 @@ def hhmmss_to_seconds(timestamp: str) -> float:
     Returns:
         float: Time in seconds
     """
-    h, m, s = map(float, timestamp.split(":"))
-    return h * 3600 + m * 60 + s
+    try:
+        h, m, s = map(float, timestamp.split(":"))
+        return h * 3600 + m * 60 + s
+    except ValueError:
+        return 0.0  # Default to 0 if parsing fails
 
-def extract_key_frames(video_file: str, key_frames_json: str) -> list:
+def extract_key_frames(video_file: str, key_frames_response: str) -> list:
     """
-    Extract key frames from the video based on JSON data.
+    Extract key frames from the video based on Gemini API response.
     
     Args:
         video_file (str): Path to the video file
-        key_frames_json (str): JSON string with key frames data
+        key_frames_response (str): Raw response from Gemini API
     
     Returns:
         list: List of tuples (image, caption)
     """
+    extracted_frames = []
+    cap = cv2.VideoCapture(video_file)
+    if not cap.isOpened():
+        print("Error: Could not open video file.")
+        return extracted_frames
+    
     try:
-        key_frames = json.loads(key_frames_json)
+        # Try parsing as JSON
+        key_frames = json.loads(key_frames_response)
         if not isinstance(key_frames, list):
-            raise ValueError("Key frames data must be a list of objects.")
-        
-        extracted_frames = []
-        cap = cv2.VideoCapture(video_file)
-        if not cap.isOpened():
-            raise ValueError("Could not open video file.")
+            raise ValueError("Response is not a list.")
+    except json.JSONDecodeError as e:
+        print(f"JSON parsing failed: {str(e)}. Raw response: {key_frames_response}")
+        # Fallback: Attempt to parse plain text with timecodes (e.g., "00:00:03 - Scene")
+        key_frames = []
+        lines = key_frames_response.strip().split("\n")
+        for line in lines:
+            if " - " in line:
+                timestamp, title = line.split(" - ", 1)
+                key_frames.append({"timecode": timestamp.strip(), "title": title.strip()})
+            elif ":" in line and len(line.split(":")) == 3:  # Rough check for HH:MM:SS
+                key_frames.append({"timecode": line.strip(), "title": "Untitled"})
+    
+    for frame in key_frames:
+        timestamp = frame.get("timecode", frame.get("timestamp", ""))
+        title = frame.get("title", frame.get("caption", "Untitled"))
+        if not timestamp:
+            continue
         
-        for frame in key_frames:
-            timestamp = frame.get("timecode", frame.get("timestamp", ""))
-            title = frame.get("title", frame.get("caption", "Untitled"))
-            if not timestamp:
-                continue
-            
-            seconds = hhmmss_to_seconds(timestamp)
-            cap.set(cv2.CAP_PROP_POS_MSEC, seconds * 1000)
-            ret, frame_img = cap.read()
-            if ret:
-                frame_rgb = cv2.cvtColor(frame_img, cv2.COLOR_BGR2RGB)
-                caption = f"{timestamp}: {title}"
-                extracted_frames.append((frame_rgb, caption))
+        seconds = hhmmss_to_seconds(timestamp)
+        if seconds == 0.0:  # Skip invalid timestamps
+            continue
         
-        cap.release()
-        return extracted_frames
-    except Exception as e:
-        print(f"Error extracting frames: {str(e)}")
-        return []
+        cap.set(cv2.CAP_PROP_POS_MSEC, seconds * 1000)
+        ret, frame_img = cap.read()
+        if ret:
+            frame_rgb = cv2.cvtColor(frame_img, cv2.COLOR_BGR2RGB)
+            caption = f"{timestamp}: {title}"
+            extracted_frames.append((frame_rgb, caption))
+    
+    cap.release()
+    return extracted_frames
 
 def analyze_video(video_file: str, user_query: str) -> tuple[str, list]:
     """
@@ -132,10 +148,11 @@ def analyze_video(video_file: str, user_query: str) -> tuple[str, list]:
         )
         summary = summary_response.text
 
-        # Step 2: Extract key frames in an agentic loop
+        # Step 2: Extract key frames
         key_frames_prompt = (
             "Identify key frames in this video and return them as a JSON array. "
-            "Each object should have 'timecode' (in HH:MM:SS format) and 'title' describing the scene."
+            "Each object must have 'timecode' (in HH:MM:SS format) and 'title' describing the scene. "
+            "Ensure the response is valid JSON."
         )
         if user_query:
             key_frames_prompt += f" Focus on: {user_query}"
@@ -144,23 +161,19 @@ def analyze_video(video_file: str, user_query: str) -> tuple[str, list]:
             model=MODEL_NAME,
             contents=[video_file_obj, key_frames_prompt]
         )
-        key_frames_json = key_frames_response.text
-        
-        # Parse and extract frames
-        key_frames = extract_key_frames(video_file, key_frames_json)
+        key_frames = extract_key_frames(video_file, key_frames_response.text)
 
-        # Generate Markdown report
+        # Generate Markdown report (without Video URI)
         markdown_report = (
             "## Video Analysis Report\n\n"
             f"**Summary:**\n{summary}\n"
-            f"**Video URI:** {video_file_obj.uri}\n"
         )
         if key_frames:
             markdown_report += "\n**Key Frames Identified:**\n"
             for i, (_, caption) in enumerate(key_frames, 1):
                 markdown_report += f"- Frame {i}: {caption}\n"
         else:
-            markdown_report += "\n*No key frames extracted.*\n"
+            markdown_report += "\n*No key frames extracted. The model may not have returned valid JSON.*\n"
 
         return markdown_report, key_frames