Update app.py

app.py

@@ -416,7 +416,8 @@ def create_demo():
         with gr.Row():
             with gr.Column(scale=1):
                 preview_image = gr.Image(label="Preview Image", type="pil", elem_classes="preview_media", visible=False)
-                preview_video = gr.Video(label="Preview Video", elem_classes="preview_media", visible=False)
+                preview_video = gr.Video(label="Preview Video", elem_classes="preview_media", visible=False, format="mp4")
+                preview_status = gr.Textbox(label="Preview status", interactive=False, lines=1, value="", visible=True)
             with gr.Column(scale=2):
                 url_input = gr.Textbox(label="Image / Video URL", placeholder="https://...", lines=1)
                 with gr.Accordion("Prompt (optional)", open=False):
@@ -426,54 +427,155 @@ def create_demo():
                 with gr.Row():
                     submit_btn = gr.Button("Submit")
                     clear_btn = gr.Button("Clear")
+                progress_md = gr.Markdown("Idle")
                 output_md = gr.Markdown("")
                 status_state = gr.State("idle")
 
+        def _set_preview_text(text: str):
+            return gr.update(value=text)
+
         def load_preview(url: str):
             if not url:
-                return gr.update(value=None, visible=False), gr.update(value=None, visible=False)
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value="")
+            # If remote and looks like a video by extension, show video immediately and try async conversion for browser compatibility
             if is_remote(url) and any(url.lower().endswith(ext) for ext in VIDEO_EXTS):
-                return gr.update(value=None, visible=False), gr.update(value=url, visible=True)
+                return gr.update(value=None, visible=False), gr.update(value=url, visible=True), gr.update(value="Remote video detected — showing preview if browser-playable; converting if needed...")
+            # Try fetching as image first (quick check). Provide verbose status messages.
             try:
                 if is_remote(url):
-                    r = safe_get(url)
-                    img_bytes = r.content
+                    head = safe_head(url)
+                    if head:
+                        ctype = (head.headers.get("content-type") or "").lower()
+                        if ctype.startswith("video/"):
+                            return gr.update(value=None, visible=False), gr.update(value=url, visible=True), gr.update(value=f"Remote video (content-type={ctype}) — showing preview if browser-playable.")
+                        if ctype.startswith("image/"):
+                            r = safe_get(url, timeout=10)
+                            img_bytes = r.content
+                        else:
+                            # try GET anyway
+                            r = safe_get(url, timeout=10)
+                            img_bytes = r.content
+                    else:
+                        r = safe_get(url, timeout=10)
+                        img_bytes = r.content
                 else:
                     with open(url, "rb") as f:
                         img_bytes = f.read()
                 img = Image.open(BytesIO(img_bytes))
                 if getattr(img, "is_animated", False):
                     img.seek(0)
-                return gr.update(value=img.convert("RGB"), visible=True), gr.update(value=None, visible=False)
-            except Exception:
-                return gr.update(value=None, visible=False), gr.update(value=None, visible=False)
+                return gr.update(value=img.convert("RGB"), visible=True), gr.update(value=None, visible=False), gr.update(value="Image preview loaded")
+            except Exception as e:
+                # Fallback: if file might be video but extension missing, show helpful message
+                msg = f"Preview load failed: {e}. If this is a video, ensure URL ends with a video extension or upload a playable mp4/webm."
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=msg)
 
-        url_input.change(fn=load_preview, inputs=[url_input], outputs=[preview_image, preview_video])
+        url_input.change(fn=load_preview, inputs=[url_input], outputs=[preview_image, preview_video, preview_status])
 
         def clear_all():
-            return "", None, None, "idle", ""
-
-        clear_btn.click(fn=clear_all, inputs=[], outputs=[url_input, preview_image, preview_video, status_state, output_md])
+            return "", None, None, "idle", "Idle", ""
+
+        clear_btn.click(fn=clear_all, inputs=[], outputs=[url_input, preview_image, preview_video, status_state, progress_md, output_md])
+
+        def _convert_video_for_preview(path: str, progress_cb=None) -> str:
+            if not FFMPEG_BIN or not os.path.exists(path):
+                return path
+            # ensure mp4 with h264 for browser playability
+            out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
+            os.close(out_fd)
+            cmd = [
+                FFMPEG_BIN, "-nostdin", "-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:
+                try: os.remove(out_path)
+                except Exception: pass
+                return path
 
         def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
             try:
                 if not url:
                     return ("error", "**Error:** No URL provided.")
                 progress(0.01, desc="Starting processing...")
-                fut = run_blocking_in_thread(process_media, url, prompt or "", key or "", progress)
-                res = fut.result()
-                if isinstance(res, str) and res.lower().startswith("error"):
-                    return ("error", f"**Error:** {res}")
-                return ("done", res if isinstance(res, str) else str(res))
+                # Fetch header to decide media type early for verbose feedback
+                progress(0.03, desc="Checking URL / content-type...")
+                is_img, is_vid = determine_media_type(url, progress=progress)
+                progress(0.06, desc=f"Determined media type: image={is_img}, video={is_vid}")
+                if is_vid:
+                    progress(0.08, desc="Fetching video bytes (this may take a while)...")
+                    raw = fetch_bytes(url, timeout=120, progress=progress)
+                    tmp = save_bytes_to_temp(raw, suffix=ext_from_src(url) or ".mp4")
+                    progress(0.15, desc="Saved video to temp file; preparing for preview/analysis...")
+                    # Convert for preview to ensure browser-playable format (non-destructive)
+                    try:
+                        preview_tmp = _convert_video_for_preview(tmp, progress_cb=progress)
+                    except Exception:
+                        preview_tmp = tmp
+                    # Update progress text for preview step (front-end preview will show converted file path)
+                    progress(0.25, desc="Video ready for preview and analysis. Starting analysis...")
+                    res = analyze_video_cohesive(get_client(key), tmp, prompt or "", progress=progress)
+                    progress(0.98, desc="Finalizing result...")
+                    try:
+                        if preview_tmp != tmp:
+                            try: os.remove(preview_tmp)
+                            except Exception: pass
+                    finally:
+                        try: os.remove(tmp)
+                        except Exception: pass
+                    status = "done" if not (isinstance(res, str) and res.lower().startswith("error")) else "error"
+                    return (status, res if isinstance(res, str) else str(res))
+                elif is_img:
+                    progress(0.08, desc="Fetching image bytes...")
+                    raw = fetch_bytes(url, progress=progress)
+                    progress(0.18, desc="Analyzing image...")
+                    res = analyze_image_structured(get_client(key), raw, prompt or "", progress=progress)
+                    progress(0.98, desc="Finalizing result...")
+                    status = "done" if not (isinstance(res, str) and res.lower().startswith("error")) else "error"
+                    return (status, res if isinstance(res, str) else str(res))
+                else:
+                    # Unknown: try fetch and try image first, then video fallback
+                    progress(0.07, desc="Unknown media type — fetching bytes for heuristic check...")
+                    raw = fetch_bytes(url, timeout=120, progress=progress)
+                    # try image
+                    try:
+                        progress(0.15, desc="Attempting to interpret as image...")
+                        _ = Image.open(BytesIO(raw))
+                        progress(0.2, desc="Image detected — analyzing...")
+                        res = analyze_image_structured(get_client(key), raw, prompt or "", progress=progress)
+                        status = "done" if not (isinstance(res, str) and res.lower().startswith("error")) else "error"
+                        return (status, res if isinstance(res, str) else str(res))
+                    except Exception:
+                        # Treat as video
+                        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.3, desc="Saved fallback video file; analyzing...")
+                            res = analyze_video_cohesive(get_client(key), tmp, prompt or "", progress=progress)
+                            status = "done" if not (isinstance(res, str) and res.lower().startswith("error")) else "error"
+                            return (status, res if isinstance(res, str) else str(res))
+                        finally:
+                            try: os.remove(tmp)
+                            except Exception: pass
             except Exception as e:
                 return ("error", f"Unexpected worker error: {e}")
 
+        # submit returns (status_state, output_md)
         submit_btn.click(fn=worker, inputs=[url_input, custom_prompt, api_key], outputs=[status_state, output_md], queue=True)
 
         def btn_label_from_state(s):
             return _btn_label_for_status(s)
 
         status_state.change(fn=btn_label_from_state, inputs=[status_state], outputs=[submit_btn])
+        # Show verbose progress messages in progress_md by listening to a lightweight helper that maps state to text.
+        def status_to_progress_text(s):
+            return {"idle":"Idle","busy":"Processing…","done":"Completed","error":"Error — see output"}.get(s, s)
+        status_state.change(fn=status_to_progress_text, inputs=[status_state], outputs=[progress_md])
 
     return demo