Update app.py

app.py

@@ -98,7 +98,11 @@ def _temp_file(data: bytes, suffix: str) -> str:
     """
     Write *data* to a temporary file and return its absolute path.
     The path is added to `_temp_preview_files_to_delete` for automatic cleanup.
+    Returns empty string if data is empty.
     """
+    if not data:
+        return "" # Do not create a file for empty data
+
     fd, path = tempfile.mkstemp(suffix=suffix)
     os.close(fd)
     with open(path, "wb") as f:
@@ -150,7 +154,12 @@ def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int
         return data
 
 def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
-    img = Image.open(BytesIO(img_bytes))
+    try:
+        img = Image.open(BytesIO(img_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
+
     try:
         if getattr(img, "is_animated", False): # Handles animated GIFs by taking first frame
             img.seek(0)
@@ -245,12 +254,19 @@ def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5,
 
                 # For model: convert to high-res JPEG bytes (model expects this)
                 jpeg_model_bytes = convert_to_jpeg_bytes(raw_frame_bytes, base_h=720) # Keep higher res for model
-                frames_for_model.append(jpeg_model_bytes)
+                if jpeg_model_bytes: # Only append if conversion was successful
+                    frames_for_model.append(jpeg_model_bytes)
 
                 # For gallery: convert to smaller JPEG bytes and save as new temp file
                 jpeg_gallery_bytes = convert_to_jpeg_bytes(raw_frame_bytes, base_h=gallery_base_h)
-                temp_jpeg_path = _temp_file(jpeg_gallery_bytes, suffix=f"_gallery_{i}.jpg") # _temp_file tracks this for cleanup
-                frame_paths_for_gallery.append(temp_jpeg_path)
+                if jpeg_gallery_bytes: # Only create temp file if conversion was successful
+                    temp_jpeg_path = _temp_file(jpeg_gallery_bytes, suffix=f"_gallery_{i}.jpg") # _temp_file tracks this for cleanup
+                    if temp_jpeg_path: # Only add to gallery if temp file was successfully created
+                        frame_paths_for_gallery.append(temp_jpeg_path)
+                else:
+                    print(f"Warning: Failed to convert extracted frame {i+1} to JPEG for gallery.")
+            else:
+                print(f"Warning: Extracted frame {i+1} was empty or non-existent at {tmp_png_path}.")
 
         except Exception as e:
             print(f"Error processing frame {i+1} for model/gallery: {e}")
@@ -273,7 +289,7 @@ def chat_complete(client, model: str, messages, timeout: int = 120, progress=Non
 
             # Prefer using the Mistral client if available and functional
             if hasattr(client, "chat") and hasattr(client.chat, "complete"):
-                res = client.chat.complete(model=model, messages=messages, stream=False, timeout=timeout)
+                res = client.chat.complete(model=model, messages=messages, stream=False, timeout_ms=timeout * 1000) # FIX: use timeout_ms
             else:
                 api_key = getattr(client, "api_key", "") or DEFAULT_KEY
                 if not api_key:
@@ -394,6 +410,8 @@ def analyze_image_structured(client, img_bytes: bytes, prompt: str, progress=Non
         if progress is not None:
             progress(0.3, desc="Preparing image for analysis...")
         jpeg = convert_to_jpeg_bytes(img_bytes, base_h=1024)
+        if not jpeg: # Handle case where convert_to_jpeg_bytes failed
+            return "Error: Could not convert image for analysis."
         data_url = b64_bytes(jpeg, mime="image/jpeg")
         messages = [
             {"role": "system", "content": SYSTEM_INSTRUCTION},
@@ -484,7 +502,11 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
             if video_streams and any(s.get("codec_name") in ("h264", "h265", "avc1") for s in video_streams):
                 return path # Already playable
 
-    out_path = _temp_file(b"", suffix=".mp4") # Create an empty temp file and add to cleanup list
+    out_path = _temp_file(b"", suffix=".mp4") # Create an empty temp file and add to cleanup list (will return "" if data is b"")
+    if not out_path: # If _temp_file returned empty path
+        print(f"Error: Could not create temporary file for video conversion from {path}.")
+        return path # Fallback to original path
+
     cmd = [
         FFMPEG_BIN, "-y", "-i", path,
         "-c:v", "libx264", "-preset", "veryfast", "-crf", "28", # H.264 video codec
@@ -508,10 +530,15 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
 def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image_hint: bool, is_video_hint: bool) -> str:
     """
     Generates a playable preview file from raw bytes, using pre-determined media type hints.
-    Creates and tracks a new temporary file.
+    Creates and tracks a new temporary file. Returns empty string if no preview can be made.
     """
+    if not raw_bytes:
+        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)
 
         # If conversion created a *new* temp path, and the original raw video path
@@ -522,32 +549,52 @@ def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image
             except Exception: pass
         return playable_path
     elif is_image_hint: # Use the passed hint
-        return _temp_file(convert_to_jpeg_bytes(raw_bytes, base_h=1024), suffix=".jpg")
+        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
         try:
             # Attempt to open as image
             img_bytes_io = BytesIO(raw_bytes)
-            Image.open(img_bytes_io).verify()
+            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
-            return _temp_file(convert_to_jpeg_bytes(img_bytes_io.read(), base_h=1024), suffix=".jpg")
+            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
         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
+            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 # This may return original path if conversion fails
+            return playable_path
 
-def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3):
+
+def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3) -> bytes:
     attempt = 0
     delay = 1.0
     while True:
         attempt += 1
         try:
             if is_remote(src):
-                with requests.get(src, timeout=timeout, stream=True) as r:
-                    r.raise_for_status()
-                    return r.content
+                # Using requests.get without stream and directly returning content for simplicity here,
+                # as stream logic is primarily handled in fetch_bytes for large files.
+                # For preview, we often need the full file quickly.
+                r = requests.get(src, timeout=timeout)
+                r.raise_for_status()
+                return r.content
             else:
                 with open(src, "rb") as fh:
                     return fh.read()
@@ -570,6 +617,7 @@ def _save_local_playable_preview(src: str, is_image_hint: bool, is_video_hint: b
     """
     Fetches remote content or reads local, then ensures it's in a playable format
     for Gradio preview components, using media type hints.
+    Returns None if no playable preview could be generated.
     """
     if not src:
         return None
@@ -578,16 +626,21 @@ def _save_local_playable_preview(src: str, is_image_hint: bool, is_video_hint: b
         if os.path.exists(src):
             if is_video_hint:
                 return _convert_video_for_preview_if_needed(src)
-            # For local images, return the path directly. If it was mis-hinted,
-            # _get_playable_preview_path_from_raw's internal checks would handle it.
-            return src 
+            return src # For local images, return the path directly.
         return None
 
     # Remote source
     try:
         raw_bytes = _fetch_with_retries_bytes(src, timeout=15, max_retries=3)
-        if not raw_bytes: return None
-        return _get_playable_preview_path_from_raw(src, raw_bytes, is_image_hint, is_video_hint)
+        if not raw_bytes: # Handle case where fetch_bytes returns empty
+            print(f"Error: Failed to fetch any bytes for {src}.")
+            return None
+
+        playable_path = _get_playable_preview_path_from_raw(src, raw_bytes, is_image_hint, is_video_hint)
+        if not playable_path: # Handle case where _get_playable_preview_path_from_raw couldn't create a path
+            print(f"Error: No playable preview path generated for {src}.")
+            return None
+        return playable_path
     except Exception as e:
         print(f"Error creating local playable preview from {src}: {e}")
         return None
@@ -706,7 +759,7 @@ def create_demo():
                 elif ext in VIDEO_EXTS:
                     is_vid_preview = True
 
-                # Fallback to PIL check if extension is ambiguous or unknown
+                # Fallback to PIL check if extension is ambiguous or unknown, and if it's an actual file
                 if not is_img_preview and not is_vid_preview and os.path.exists(local_playable_path):
                     try:
                         Image.open(local_playable_path).verify()
@@ -780,7 +833,8 @@ def create_demo():
                 # --- Video Processing Path ---
                 if is_vid_worker:
                     temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
-                    # Pass determined types to _get_playable_preview_path_from_raw
+                    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")
@@ -788,7 +842,6 @@ def create_demo():
 
                 # --- Image Processing Path ---
                 elif is_img_worker:
-                    # Pass determined types to _get_playable_preview_path_from_raw
                     generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_img_worker, is_vid_worker) 
 
                     progress(0.20, desc="Running image analysis")
@@ -800,6 +853,8 @@ def create_demo():
                     # 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.")
                     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)")