Update app.py

app.py

@@ -159,6 +159,9 @@ def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
     except UnidentifiedImageError:
         print(f"Warning: convert_to_jpeg_bytes received unidentifiable image data.")
         return b"" # Return empty bytes if data is not an identifiable image
+    except Exception as e:
+        print(f"Warning: Error opening image for JPEG conversion: {e}")
+        return b""
 
     try:
         if getattr(img, "is_animated", False): # Handles animated GIFs by taking first frame
@@ -524,7 +527,7 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
             _temp_preview_files_to_delete.remove(out_path)
         try: os.remove(out_path)
         except Exception: pass
-        return path 
+        return path
 
 # --- Preview Generation Logic ---
 def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image_hint: bool, is_video_hint: bool) -> str:
@@ -536,50 +539,62 @@ def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image
         print(f"Error: No raw bytes provided for preview generation of {src_url}.")
         return ""
 
-    if is_video_hint: # Use the passed hint
-        temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
-        if not temp_raw_video_path: return "" # Handle if _temp_file failed
-        playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
+    # Determine media type (prioritizing hints, then byte analysis)
+    is_actually_image = False
+    is_actually_video = False
 
-        # If conversion created a *new* temp path, and the original raw video path
-        # is no longer needed (and different), remove the raw path's tracking.
-        if playable_path != temp_raw_video_path and temp_raw_video_path in _temp_preview_files_to_delete:
-            _temp_preview_files_to_delete.remove(temp_raw_video_path)
-            try: os.remove(temp_raw_video_path)
-            except Exception: pass
-        return playable_path
-    elif is_image_hint: # Use the passed hint
-        jpeg_bytes = convert_to_jpeg_bytes(raw_bytes, base_h=1024)
-        if not jpeg_bytes: # Handle if convert_to_jpeg_bytes failed
-            print(f"Warning: Could not convert image bytes for {src_url} to JPEG.")
-            return ""
-        return _temp_file(jpeg_bytes, suffix=".jpg")
-    else:
-        # Fallback if hints are unclear, try image first, then video
+    if is_image_hint:
+        is_actually_image = True
+    elif is_video_hint:
+        is_actually_video = True
+    else: # If hints are not definitive, try to determine from bytes
         try:
             # Attempt to open as image
-            img_bytes_io = BytesIO(raw_bytes)
-            img = Image.open(img_bytes_io)
-            img.verify() # Checks if it's a valid image without loading all pixels
-            img_bytes_io.seek(0) # Reset stream position after verify
-            jpeg_bytes = convert_to_jpeg_bytes(img_bytes_io.read(), base_h=1024)
-            if jpeg_bytes: # If conversion yielded bytes, create temp file
-                return _temp_file(jpeg_bytes, suffix=".jpg")
-            else: # If convert_to_jpeg_bytes failed even after verify
-                raise UnidentifiedImageError("Could not convert verified image to JPEG.") # Re-raise to fall to video path
+            # We don't need to load the whole image, just verify format.
+            Image.open(BytesIO(raw_bytes)).verify()
+            is_actually_image = True
         except UnidentifiedImageError:
-            # If not an image, assume it's a video for preview purposes
-            print(f"Warning: Unknown media type for {src_url}, falling back to video preview attempt.")
-            temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
-            if not temp_raw_video_path: return "" # If _temp_file returns empty due to empty raw_bytes
-            playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
-            return playable_path
-        except Exception as e: # Catch other potential PIL/IO errors during image check
+            # Not an identifiable image by PIL, assume video
+            is_actually_video = True
+        except Exception as e:
+            # Other PIL errors, assume video as a fallback for preview
             print(f"Warning: Generic error during image check for {src_url}: {e}. Falling back to video preview attempt.")
-            temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
-            if not temp_raw_video_path: return ""
-            playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
-            return playable_path
+            is_actually_video = True
+
+    # --- Attempt Image Preview ---
+    if is_actually_image:
+        jpeg_bytes = convert_to_jpeg_bytes(raw_bytes, base_h=1024)
+        if jpeg_bytes:
+            return _temp_file(jpeg_bytes, suffix=".jpg")
+        else:
+            # If image conversion fails, even if it seemed like an image, fall back to video
+            print(f"Warning: Could not convert image bytes for {src_url} to JPEG. Attempting video fallback.")
+            is_actually_image = False # Clear image flag
+            is_actually_video = True # Set video flag for next block
+
+    # --- Attempt Video Preview ---
+    if is_actually_video:
+        # Create a temporary file for the raw video bytes first
+        temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
+        if not temp_raw_video_path:
+            print(f"Error: Failed to create temporary raw video file for {src_url}.")
+            return ""
+
+        playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
+
+        # If _convert_video_for_preview_if_needed created a new file,
+        # the original temp_raw_video_path is no longer needed. Remove it from tracking
+        # and delete it if it's no longer the returned playable_path.
+        if playable_path != temp_raw_video_path and os.path.exists(temp_raw_video_path):
+             if temp_raw_video_path in _temp_preview_files_to_delete:
+                 _temp_preview_files_to_delete.remove(temp_raw_video_path)
+             try: os.remove(temp_raw_video_path)
+             except Exception as e: print(f"Error during cleanup of intermediate raw video temp file {temp_raw_video_path}: {e}")
+
+        return playable_path
+
+    print(f"Error: No playable preview path generated for {src_url}.")
+    return ""
 
 
 def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3) -> bytes:
@@ -822,44 +837,56 @@ def create_demo():
                 if not raw_bytes:
                     return "error", "Failed to download media bytes.", "", []
 
-                # Check for image type with PIL if initial determination was uncertain
-                if not is_img_worker and not is_vid_worker:
+                # Determine type more definitively using raw bytes
+                # This step is now more robustly handled inside _get_playable_preview_path_from_raw itself for preview,
+                # but we need it here for deciding analysis path (image model vs. video model)
+                is_actually_image_for_analysis = is_img_worker
+                is_actually_video_for_analysis = is_vid_worker
+
+                if not is_actually_image_for_analysis and not is_actually_video_for_analysis:
                     try:
+                        # Attempt to open as image
                         Image.open(BytesIO(raw_bytes)).verify()
-                        is_img_worker = True
-                    except Exception:
-                        pass # Not an image, proceed to video or generic fallback
+                        is_actually_image_for_analysis = True
+                    except UnidentifiedImageError:
+                        is_actually_video_for_analysis = True # Not an image, assume video
+                    except Exception as e:
+                        print(f"Warning: Could not definitively determine media type for {url} based on bytes: {e}. Attempting video analysis.")
+                        is_actually_video_for_analysis = True # Generic error, fallback to video
+
+                # Get playable preview path (this internally handles image/video decision and conversion for preview)
+                generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_actually_image_for_analysis, is_actually_video_for_analysis)
+                if not generated_main_preview_path:
+                    print(f"Error: Could not generate main preview for analysis: {url}") # Log this specific failure point
+                    return "error", "Could not generate a playable preview for display.", "", []
+
 
                 # --- Video Processing Path ---
-                if is_vid_worker:
+                if is_actually_video_for_analysis:
                     temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
                     if not temp_media_file_for_analysis: # Handle if _temp_file failed
                         return "error", "Failed to create temporary video file for analysis.", "", []
-                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_img_worker, is_vid_worker) 
-
                     progress(0.25, desc="Running full‑video analysis")
                     result_text, generated_screenshot_paths = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
 
                 # --- Image Processing Path ---
-                elif is_img_worker:
-                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_img_worker, is_vid_worker) 
-
+                elif is_actually_image_for_analysis:
                     progress(0.20, desc="Running image analysis")
                     result_text = analyze_image_structured(client, raw_bytes, prompt, progress=progress)
                     # No screenshots for images
 
-                # --- Unknown Media Type (Fallback to Video) ---
+                # --- Fallback if still no clear analysis path (should be rare with refined logic) ---
                 else:
-                    # If after all checks, it's still unknown, treat as video by default for analysis.
-                    print(f"Warning: Could not definitively determine media type for {url}. Attempting video analysis.")
+                    # This block should ideally not be reached if previous type determination is robust.
+                    # As a final fallback, treat as video for analysis.
+                    print(f"Warning: No definitive analysis type determined for {url} after all checks. Attempting video analysis fallback.")
                     temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
-                    if not temp_media_file_for_analysis: # Handle if _temp_file failed
-                        return "error", "Failed to create temporary video file for analysis (unknown type fallback).", "", []
-                    # Even though type is 'unknown', we'll hint as video for preview creation if it's not an image
-                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, False, True) 
-                    progress(0.25, desc="Running video analysis (fallback for unknown type)")
+                    if not temp_media_file_for_analysis:
+                        return "error", "Failed to create temporary video file for final analysis fallback.", "", []
+                    progress(0.25, desc="Running video analysis (final fallback for unknown type)")
                     result_text, generated_screenshot_paths = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
 
+
                 status = "done" if not (isinstance(result_text, str) and result_text.lower().startswith("error")) else "error"
 
                 return status, result_text, generated_main_preview_path, generated_screenshot_paths