Update app.py

app.py

@@ -581,111 +581,143 @@ def create_demo():
                 return False
         
         # --- Convert only if not browser-playable
-        def _convert_video_for_preview_if_needed(path: str) -> str:
-            try:
-                if _is_browser_playable(path):
-                    return path
-            except Exception:
-                pass
-            return _convert_video_for_preview(path)
+def _convert_video_for_preview_if_needed(path: str) -> str:
+    """
+    Return a path that the Gradio video component can play.
+    If the original file is already MP4 with H.264 (or another browser‑compatible codec),
+    the original path is returned unchanged.
+    Otherwise the file is re‑encoded to MP4 (H.264 + AAC) and the new path is returned.
+    """
+    if not FFMPEG_BIN or not os.path.exists(path):
+        return path
+
+    # Quick check: extension + ffprobe for codecs
+    if path.lower().endswith((".mp4", ".m4v", ".mov")):
+        info = _ffprobe_streams(path)
+        if info:
+            codecs = {s.get("codec_name") for s in info.get("streams", []) if s.get("codec_type") == "video"}
+            if "h264" in codecs or "h265" in codecs:
+                return path   # already playable
+
+    # Need conversion → write to a new temp MP4
+    out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
+    os.close(out_fd)
+    cmd = [
+        FFMPEG_BIN, "-y", "-i", path,
+        "-c:v", "libx264", "-preset", "veryfast", "-crf", "28",
+        "-c:a", "aac", "-movflags", "+faststart", out_path,
+    ]
+    try:
+        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=60)
+        return out_path
+    except Exception:
+        # If conversion fails, fall back to the original (Gradio will show its own warning)
+        try: os.remove(out_path)
+        except Exception: pass
+        return path
         
-        # Worker now returns (status_state, output_md, preview_path_state)
-        def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
+def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
+    """Return (status, markdown_output, preview_path)."""
+    try:
+        if not url:
+            return "error", "**Error:** No URL provided.", ""
+
+        # ------------------------------------------------------------------
+        # 1️⃣  Determine media type – use a *single* call to avoid duplicate work
+        # ------------------------------------------------------------------
+        progress(0.02, desc="Checking URL / content‑type")
+        is_img, is_vid = determine_media_type(url, progress=progress)
+
+        client = get_client(key)
+        preview_path = ""
+
+        # ------------------------------------------------------------------
+        # 2️⃣  Helper to write a temp file with a *correct* suffix
+        # ------------------------------------------------------------------
+        def _temp_file(data: bytes, suffix: str) -> str:
+            fd, p = tempfile.mkstemp(suffix=suffix)
+            os.close(fd)
+            with open(p, "wb") as f:
+                f.write(data)
+            return p
+
+        # ------------------------------------------------------------------
+        # 3️⃣  VIDEO PATH
+        # ------------------------------------------------------------------
+        if is_vid:
+            progress(0.05, desc="Downloading video")
+            raw = fetch_bytes(url, timeout=120, progress=progress)
+            if not raw:
+                return "error", "Failed to download video bytes.", ""
+
+            # write with a proper video extension
+            tmp_video = _temp_file(raw, suffix=ext_from_src(url) or ".mp4")
+            progress(0.15, desc="Preparing preview")
+            preview_path = _convert_video_for_preview_if_needed(tmp_video)
+
+            progress(0.25, desc="Running full‑video analysis")
+            result = analyze_video_cohesive(client, tmp_video, prompt, progress=progress)
+
+            # clean‑up the *raw* temp file (preview may be a different file)
+            try: os.remove(tmp_video)
+            except Exception: pass
+
+        # ------------------------------------------------------------------
+        # 4️⃣  IMAGE PATH
+        # ------------------------------------------------------------------
+        elif is_img:
+            progress(0.05, desc="Downloading image")
+            raw = fetch_bytes(url, progress=progress)
+
+            # preview image (always JPEG for consistency)
+            preview_path = _temp_file(convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg")
+
+            progress(0.20, desc="Running image analysis")
+            result = analyze_image_structured(client, raw, prompt, progress=progress)
+
+        # ------------------------------------------------------------------
+        # 5️⃣  FALLBACK – try image first, then video
+        # ------------------------------------------------------------------
+        else:
+            progress(0.07, desc="Downloading unknown media")
+            raw = fetch_bytes(url, timeout=120, progress=progress)
+
+            # try to open as image
             try:
-                if not url:
-                    return ("error", "**Error:** No URL provided.", "")
-        
-                progress(0.01, desc="Starting processing...")          # Initial processing
-                progress(0.03, desc="Checking URL / content-type...") # URL check
-                is_img, is_vid = determine_media_type(url, progress=progress)
-                progress(0.06, desc=f"Determined media type: image={is_img}, video={is_vid}")
-        
-                client = get_client(key)
-                preview_local = None
-        
-                if is_vid:
-                    progress(0.08, desc="Fetching video bytes (may take a while)...")
-                    # Ensure video bytes fetching has proper error handling
-                    raw = fetch_bytes(url, timeout=120, progress=progress)
-                    if raw is None:
-                        return ("error", "Failed to fetch video bytes.", "")
-        
-                    tmp = save_bytes_to_temp(raw, suffix=ext_from_src(url) or ".mp4")
-                    progress(0.18, desc="Saved video to temp; converting for preview if needed...")
-                    preview_tmp = _convert_video_for_preview(tmp)
-                    preview_local = preview_tmp if os.path.exists(preview_tmp) else tmp
-        
-                    progress(0.25, desc="Starting video analysis...")
-                    res = analyze_video_cohesive(client, tmp, prompt or "", progress=progress)
-                    progress(0.90, desc="Finalizing results...")
-        
-                elif is_img:
-                    progress(0.08, desc="Fetching image bytes...")
-                    raw = fetch_bytes(url, progress=progress)
-        
-                    try:
-                        preview_fd, preview_path = tempfile.mkstemp(suffix=".jpg")
-                        os.close(preview_fd)
-                        with open(preview_path, "wb") as fh:
-                            fh.write(convert_to_jpeg_bytes(raw, base_h=1024))
-                        preview_local = preview_path
-                    except Exception:
-                        preview_local = None
-        
-                    progress(0.18, desc="Analyzing image...")
-                    try:
-                        res = analyze_image_structured(client, raw, prompt or "", progress=progress)
-                    except UnidentifiedImageError:
-                        return ("error", "Error: provided file is not a valid image.", preview_local or "")
-        
-                    progress(0.98, desc="Finalizing result...")
-        
-                else:
-                    progress(0.07, desc="Unknown media type — fetching bytes for heuristics...")
-                    raw = fetch_bytes(url, timeout=120, progress=progress)
-        
-                    try:
-                        progress(0.15, desc="Attempting to interpret as image...")
-                        Image.open(BytesIO(raw))
-                        progress(0.20, desc="Image detected — analyzing...")
-                        res = analyze_image_structured(client, raw, prompt or "", progress=progress)
-        
-                        try:
-                            preview_fd, preview_path = tempfile.mkstemp(suffix=".jpg")
-                            os.close(preview_fd)
-                            with open(preview_path, "wb") as fh:
-                                fh.write(convert_to_jpeg_bytes(raw, base_h=1024))
-                            preview_local = preview_path
-                        except Exception:
-                            preview_local = None
-        
-                    except Exception:
-                        fd, tmp = tempfile.mkstemp(suffix=ext_from_src(url) or ".mp4")
-                        os.close(fd)
-                        with open(tmp, "wb") as fh:
-                            fh.write(raw)
-        
-                        try:
-                            progress(0.30, desc="Saved fallback video file; analyzing...")
-                            preview_tmp = _convert_video_for_preview(tmp)
-                            preview_local = preview_tmp if os.path.exists(preview_tmp) else tmp
-                            res = analyze_video_cohesive(client, tmp, prompt or "", progress=progress)
-                        finally:
-                            try:
-                                os.remove(tmp)
-                            except Exception:
-                                pass
-        
-                # Determine final status and return
-                status = "done" if not (isinstance(res, str) and res.lower().startswith("error")) else "error"
-                return (status, res if isinstance(res, str) else str(res), preview_local or "")
-        
-            except Exception as e:
-                return ("error", f"Unexpected worker error: {e}", "")
-        
+                Image.open(BytesIO(raw)).verify()
+                is_img = True
+            except Exception:
+                is_img = False
+
+            if is_img:
+                preview_path = _temp_file(convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg")
+                result = analyze_image_structured(client, raw, prompt, progress=progress)
+            else:
+                tmp_vid = _temp_file(raw, suffix=ext_from_src(url) or ".mp4")
+                preview_path = _convert_video_for_preview_if_needed(tmp_vid)
+                result = analyze_video_cohesive(client, tmp_vid, prompt, progress=progress)
+                try: os.remove(tmp_vid)
+                except Exception: pass
+
+        # ------------------------------------------------------------------
+        # 6️⃣  Final status
+        # ------------------------------------------------------------------
+        status = "done" if not (isinstance(result, str) and result.lower().startswith("error")) else "error"
+        return status, result if isinstance(result, str) else str(result), preview_path or ""
+
+    except Exception as exc:
+        return "error", f"Unexpected worker error: {exc}", ""
+
+        def _start_processing(url, prompt, key):
+            # set state to busy and launch the worker in the same call
+            return "busy", None, None   # temporary values; the real result will replace them
         
-        # UI wiring
-        submit_btn.click(fn=lambda: "busy", inputs=[], outputs=[status_state])
+        submit_btn.click(
+            fn=_start_processing,
+            inputs=[url_input, custom_prompt, api_key],
+            outputs=[status_state, output_md, preview_path_state],
+            queue=False,               # this tiny wrapper runs instantly
+        )
         
         submit_btn.click(
             fn=worker,
@@ -695,7 +727,7 @@ def create_demo():
             show_progress="full",
             show_progress_on=progress_md,
         )
-        
+
         def _btn_label_for_status(s):
             labels = {
                 "idle": "Submit",