Update app.py

app.py

@@ -41,8 +41,8 @@ DEFAULT_HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl
 
 try:
     from mistralai import Mistral
-    from mistralai.exceptions import MistralAPIException # Import for better error handling
-except ImportError: # Use ImportError for module import issues
+    from mistralai.exceptions import MistralAPIException
+except ImportError:
     Mistral = None
     # Define a mock MistralAPIException for type hinting and to avoid NameError
     class MistralAPIException(Exception):
@@ -71,19 +71,51 @@ atexit.register(_cleanup_all_temp_preview_files)
 
 # --- Mistral Client and API Helpers ---
 def get_client(key: Optional[str] = None):
+    """
+    Returns a Mistral client instance. If the mistralai library is not installed
+    or the API key is missing, a mock client is returned which raises
+    MistralAPIException with specific messages.
+    """
     api_key = (key or "").strip() or DEFAULT_KEY
+
+    if not api_key:
+        class Dummy:
+            def __init__(self, k): self.api_key = k
+            class Chat:
+                def complete(self, **kwargs):
+                    raise MistralAPIException(
+                        "Mistral API key is not set. Please provide it in the UI or as MISTRAL_API_KEY environment variable.",
+                        status_code=401
+                    )
+            chat = Chat()
+            class Files:
+                def upload(self, **kwargs):
+                    raise MistralAPIException(
+                        "Mistral API key is not set. Please provide it in the UI or as MISTRAL_API_KEY environment variable.",
+                        status_code=401
+                    )
+            files = Files()
+        return Dummy(api_key)
+
     if Mistral is None:
-        class Dummy: # Mock client for no mistralai library or no key
+        class Dummy:
             def __init__(self, k): self.api_key = k
             class Chat:
                 def complete(self, **kwargs):
-                    raise RuntimeError("Mistral client library not installed or API key missing.")
+                    raise MistralAPIException(
+                        "Mistral client library is not installed. Please install it with 'pip install mistralai'.",
+                        status_code=500
+                    )
             chat = Chat()
             class Files:
                 def upload(self, **kwargs):
-                    raise RuntimeError("Mistral client library not installed or API key missing.")
+                    raise MistralAPIException(
+                        "Mistral client library is not installed. Please install it with 'pip install mistralai'.",
+                        status_code=500
+                    )
             files = Files()
         return Dummy(api_key)
+
     return Mistral(api_key=api_key)
 
 def is_remote(src: str) -> bool:
@@ -243,7 +275,7 @@ def _get_video_info_and_timestamps(media_path: str, sample_count: int) -> Tuple[
 
     return info, timestamps
 
-def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5, timeout_extract: int = 15, gallery_base_h: int = 256, progress=None) -> Tuple[List[bytes], List[str]]:
+def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5, timeout_extract: int = 15, gallery_base_h: int = 720, progress=None) -> Tuple[List[bytes], List[str]]:
     """
     Extracts frames from a video, processes them for both model input (high-res JPEG bytes)
     and gallery display (smaller JPEG temp file paths), in a single pass.
@@ -288,6 +320,8 @@ def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5,
                 jpeg_model_bytes = convert_to_jpeg_bytes(raw_frame_bytes, base_h=720) # Keep higher res for model
                 if jpeg_model_bytes: # Only append if conversion was successful
                     frames_for_model.append(jpeg_model_bytes)
+                else:
+                    print(f"Warning: Failed to convert extracted frame {i+1} to JPEG for model input.")
 
                 # 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) # Higher base_h
@@ -322,10 +356,10 @@ 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_ms=timeout * 1000)
-            else:
+            else: # This path should ideally not be reached if get_client returns a dummy with exceptions
                 api_key = getattr(client, "api_key", "") or DEFAULT_KEY
                 if not api_key:
-                    return "Error: Mistral API key is not set."
+                    return "Error: Mistral API key is not set. Cannot make direct requests."
                 url = "https://api.mistral.ai/v1/chat/completions"
                 headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
                 r = requests.post(url, json={"model": model, "messages": messages}, headers=headers, timeout=timeout)
@@ -344,13 +378,13 @@ def chat_complete(client, model: str, messages, timeout: int = 120, progress=Non
             content = (msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", None))
             return content.strip() if isinstance(content, str) else str(content)
 
-        except MistralAPIException as e: # Catch Mistral client's specific API exceptions
+        except MistralAPIException as e: # Catch Mistral client's specific API exceptions (including from Dummy client)
             if e.status_code == 429 and attempt < max_retries - 1:
                 delay = initial_delay * (2 ** attempt)
                 print(f"MistralAPIException: Rate limit exceeded (429). Retrying in {delay:.2f}s...")
                 time.sleep(delay)
             else:
-                return f"Error: Mistral API error occurred with status {e.status_code}: {e.message}"
+                return f"Error: Mistral API error occurred ({e.status_code if e.status_code else 'unknown'}): {e.message}"
         except HTTPError as e: # For direct requests calls
             if e.response.status_code == 429 and attempt < max_retries - 1:
                 delay = initial_delay * (2 ** attempt)
@@ -366,7 +400,7 @@ def chat_complete(client, model: str, messages, timeout: int = 120, progress=Non
             else:
                 return f"Error: network/API request failed after {max_retries} attempts: {e}"
         except Exception as e:
-            return f"Error during model call: {e}"
+            return f"Error during model call: An unexpected error occurred: {e}"
 
     return "Error: Maximum retries reached for API call."
 
@@ -390,7 +424,7 @@ def upload_file_to_mistral(client, path: str, filename: str | None = None, purpo
                 if progress is not None:
                     progress(0.6, desc="Upload complete")
                 return fid
-            else: # Fallback to manual requests if client.files.upload fails or Mistral is mocked
+            else: # This path should ideally not be reached if get_client returns a dummy with exceptions
                 api_key = getattr(client, "api_key", "") or DEFAULT_KEY
                 if not api_key:
                     raise RuntimeError("Mistral API key is not set for file upload.")
@@ -405,7 +439,7 @@ def upload_file_to_mistral(client, path: str, filename: str | None = None, purpo
                     if progress is not None:
                         progress(0.65, desc="Upload complete (REST)")
                     return jr.get("id") or jr.get("data", [{}])[0].get("id")
-        except MistralAPIException as e: # Catch Mistral client's specific API exceptions
+        except MistralAPIException as e: # Catch Mistral client's specific API exceptions (including from Dummy client)
             if e.status_code == 429 and attempt < max_retries - 1:
                 delay = initial_delay * (2 ** attempt)
                 print(f"MistralAPIException: Upload rate limit exceeded (429). Retrying in {delay:.2f}s...")
@@ -496,7 +530,7 @@ def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None)
         # If successful upload, still extract frames for gallery display
         # Use the combined function for gallery frames
         _, gallery_frame_paths = extract_frames_for_model_and_gallery(
-            video_path, sample_count=6, gallery_base_h=256, progress=progress # Increased gallery_base_h
+            video_path, sample_count=6, gallery_base_h=720, progress=progress # Increased gallery_base_h
         )
         return result, gallery_frame_paths
     except Exception as e:
@@ -505,7 +539,7 @@ def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None)
 
         # Use the combined extraction function for both model input and gallery display
         frames_for_model_bytes, gallery_frame_paths = extract_frames_for_model_and_gallery(
-            video_path, sample_count=6, gallery_base_h=256, progress=progress # Increased gallery_base_h
+            video_path, sample_count=6, gallery_base_h=720, progress=progress # Increased gallery_base_h
         )
 
         if not frames_for_model_bytes:
@@ -542,7 +576,9 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
         return path # Cannot convert, return original
 
     # Check if the video is already likely browser-compatible (MP4 with H.264/H.265)
-    if path.lower().endswith((".mp4", ".m4v", ".mov")):
+    # This check is a heuristic; direct ffprobe is more reliable but adds overhead.
+    # For a preview, extension check is usually sufficient.
+    if path.lower().endswith((".mp4", ".m4v")): # .mov might still need conversion
         info = _ffprobe_streams(path)
         if info:
             video_streams = [s for s in info.get("streams", []) if s.get("codec_type") == "video"]
@@ -583,46 +619,29 @@ 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 ""
 
-    # Determine media type (prioritizing hints, then byte analysis)
-    # This logic aims to be somewhat lenient for preview display
+    # Attempt to determine media type from bytes for image
     is_actually_image = False
-    is_actually_video = False
-
-    # Try to determine from bytes first, if hints are ambiguous or absent
     try:
         Image.open(BytesIO(raw_bytes)).verify()
         is_actually_image = True
-    except UnidentifiedImageError:
-        # Not an identifiable image by PIL. Now consider hints or default to video.
-        is_actually_image = False
-        if is_video_hint:
-            is_actually_video = True
-        elif is_image_hint: # If hinted as image but PIL failed, still prefer image for error clarity
-            print(f"Warning: Hinted as image but PIL failed for {src_url}. Assuming image for preview attempt.")
-            is_actually_image = True
-        else:
-            is_actually_video = True # No strong hint, not an image, assume video
-    except Exception as e:
-        print(f"Warning: Generic error during image check for {src_url}: {e}. Falling back to video preview attempt.")
-        is_actually_image = False # Clear image flag
-        is_actually_video = True # Assume video as a fallback for preview
+    except (UnidentifiedImageError, Exception):
+        pass # Not an identifiable image, or some other PIL error
 
-    # If still neither, use original hints as last resort
-    if not is_actually_image and not is_actually_video:
+    # Default to hints if byte check is inconclusive for images
+    is_actually_video = not is_actually_image and is_video_hint # Prefer video hint if not definitely an image
+    if not is_actually_image and not is_actually_video: # If still no clear type, use image hint as fallback
         is_actually_image = is_image_hint
-        is_actually_video = is_video_hint
-
 
     # --- Attempt Image Preview ---
     if is_actually_image:
-        jpeg_bytes = convert_to_jpeg_bytes(raw_bytes, base_h=1024)
+        jpeg_bytes = convert_to_jpeg_bytes(raw_bytes, base_h=1024) # High-res for main preview
         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
+            # Fall through to video logic if image conversion fails
+            is_actually_image = False
+            is_actually_video = True # Assume video as a fallback for preview
 
     # --- Attempt Video Preview ---
     if is_actually_video:
@@ -692,7 +711,6 @@ def create_demo():
             Cleans up all tracked temporary files and resets all relevant UI components.
             This function is meant to be called at the start of any new processing
             or when the user explicitly clicks "Clear".
-            Returns values for all 11 output components.
             """
             for f_path in list(_temp_preview_files_to_delete):
                 if os.path.exists(f_path):
@@ -702,7 +720,6 @@ def create_demo():
                         print(f"Error during proactive cleanup of {f_path}: {e}")
             _temp_preview_files_to_delete.clear()
 
-            # Return exactly 11 values to match the outputs list
             return "", \
                    gr.update(value=None, visible=False), \
                    gr.update(value=None, visible=False), \
@@ -730,7 +747,7 @@ def create_demo():
                 main_preview_path_state,
                 screenshot_paths_state,
                 preview_status,
-                raw_media_path_state # Clear the raw media path state as well
+                raw_media_path_state
             ]
         )
 
@@ -780,31 +797,16 @@ def create_demo():
                            gr.update(value="Preview load failed: could not make content playable.", visible=True), \
                            main_path_clear, screenshot_paths_clear, raw_media_path_clear
 
-                # 4. Re-evaluate actual type for Gradio display from the *playable path*
-                # This is important as _get_playable_preview_path_from_raw might have converted the format
-                is_img_preview = False
-                is_vid_preview = False
-
+                # 4. Determine actual type for Gradio display from the *playable path*
                 ext = ext_from_src(local_playable_path)
-                if ext in IMAGE_EXTS:
-                    is_img_preview = True
-                elif ext in VIDEO_EXTS:
-                    is_vid_preview = True
-
-                # 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()
-                        is_img_preview = True
-                    except Exception:
-                        # If not an image, assume it might be a video (or non-playable for Gradio)
-                        is_vid_preview = True # Flag as video for Gradio component decision
+                is_img_preview = ext in IMAGE_EXTS
+                is_vid_preview = ext in VIDEO_EXTS
 
                 if is_img_preview:
                     return gr.update(value=local_playable_path, visible=True), gr.update(value=None, visible=False), \
                            gr.update(value=[], visible=False), gr.update(value="Image preview loaded.", visible=True), \
                            local_playable_path, [], temp_raw_path_for_analysis # Update raw_media_path_state
-                elif is_vid_preview: # Assume video if not image
+                elif is_vid_preview:
                     return gr.update(value=None, visible=False), gr.update(value=local_playable_path, visible=True), \
                            gr.update(value=[], visible=False), gr.update(value="Video preview loaded.", visible=True), \
                            local_playable_path, [], temp_raw_path_for_analysis # Update raw_media_path_state
@@ -813,7 +815,6 @@ def create_demo():
                            gr.update(value="Preview load failed: unknown playable format.", visible=True), \
                            main_path_clear, screenshot_paths_clear, raw_media_path_clear
 
-
             except Exception as e:
                 # Cleanup temp_raw_path_for_analysis on error
                 if temp_raw_path_for_analysis in _temp_preview_files_to_delete:
@@ -857,7 +858,6 @@ def create_demo():
                 is_actually_video_for_analysis = False
 
                 try:
-                    # Try as image first, using actual bytes
                     Image.open(BytesIO(raw_bytes_for_analysis)).verify()
                     is_actually_image_for_analysis = True
                 except UnidentifiedImageError:
@@ -918,31 +918,13 @@ def create_demo():
             video_update = gr.update(value=None, visible=False)
 
             if current_main_preview_path:
-                try:
-                    is_img_preview = False
-                    is_vid_preview = False
-
-                    # Determine type based on file extension
-                    ext = ext_from_src(current_main_preview_path)
-                    if ext in IMAGE_EXTS:
-                        is_img_preview = True
-                    elif ext in VIDEO_EXTS:
-                        is_vid_preview = True
-
-                    # 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(current_main_preview_path):
-                        try:
-                            Image.open(current_main_preview_path).verify()
-                            is_img_preview = True
-                        except Exception:
-                            is_vid_preview = True # If not image, assume video for display purposes
-
-                    if is_img_preview:
-                        img_update = gr.update(value=current_main_preview_path, visible=True)
-                    elif is_vid_preview:
-                        video_update = gr.update(value=current_main_preview_path, visible=True)
-                except Exception as e:
-                    print(f"Error setting main preview from path {current_main_preview_path}: {e}")
+                ext = ext_from_src(current_main_preview_path)
+                if ext in IMAGE_EXTS:
+                    img_update = gr.update(value=current_main_preview_path, visible=True)
+                elif ext in VIDEO_EXTS:
+                    video_update = gr.update(value=current_main_preview_path, visible=True)
+                else:
+                    print(f"Warning: Unknown media type for main preview path: {current_main_preview_path}")
 
             # Gallery is visible only if there are paths
             gallery_update = gr.update(value=current_screenshot_paths, visible=bool(current_screenshot_paths))