Update app.py

app.py

@@ -415,8 +415,8 @@ def create_demo():
     with gr.Blocks(title="Flux Multimodal", css=css) as 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, format="mp4")
+                preview_image = gr.Image(label="Preview Image", type="filepath", elem_classes="preview_media", visible=False)
+                preview_video = gr.Video(label="Preview Video", elem_classes="preview_media", visible=False, format="mp4", type="filepath")
                 preview_status = gr.Textbox(label="Preview status", interactive=False, lines=2, value="", visible=True)
             with gr.Column(scale=2):
                 url_input = gr.Textbox(label="Image / Video URL", placeholder="https://...", lines=1)
@@ -430,42 +430,106 @@ def create_demo():
                 progress_md = gr.Markdown("Idle")
                 output_md = gr.Markdown("")
                 status_state = gr.State("idle")
+                # hidden state to pass preview path from worker to frontend
+                preview_path_state = gr.State("")
+
+        # small helper: fetch URL into bytes with retries and respect Retry-After
+        def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3):
+            attempt = 0
+            delay = 1.0
+            while True:
+                attempt += 1
+                try:
+                    if is_remote(src):
+                        r = requests.get(src, timeout=timeout, stream=True)
+                        if r.status_code == 200:
+                            return r.content
+                        if r.status_code == 429:
+                            ra = r.headers.get("Retry-After")
+                            try:
+                                delay = float(ra) if ra is not None else delay
+                            except Exception:
+                                pass
+                        # for other 4xx/5xx raise to outer except to allow retry logic
+                        r.raise_for_status()
+                    else:
+                        with open(src, "rb") as fh:
+                            return fh.read()
+                except requests.exceptions.RequestException as e:
+                    if attempt >= max_retries:
+                        raise
+                    time.sleep(delay)
+                    delay *= 2
+                except FileNotFoundError:
+                    raise
+                except Exception:
+                    if attempt >= max_retries:
+                        raise
+                    time.sleep(delay)
+                    delay *= 2
+
+        # create a local temp file for a remote URL and return local path (or None)
+        def _save_preview_local(src: str) -> Optional[str]:
+            if not src:
+                return None
+            if not is_remote(src):
+                return src if os.path.exists(src) else None
+            try:
+                b = _fetch_with_retries_bytes(src, timeout=15, max_retries=3)
+                ext = ext_from_src(src) or ".bin"
+                fd, tmp = tempfile.mkstemp(suffix=ext)
+                os.close(fd)
+                with open(tmp, "wb") as fh:
+                    fh.write(b)
+                return tmp
+            except Exception:
+                return None
 
         def load_preview(url: str):
+            # returns (preview_image_path, preview_video_path, status_msg)
             if not url:
                 return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value="")
-            # Quick content-type/extension heuristic first
+            # If remote, check head to avoid unnecessary download when it's clearly video
             try:
                 if is_remote(url):
                     head = safe_head(url)
                     if head:
                         ctype = (head.headers.get("content-type") or "").lower()
                         if ctype.startswith("video/") or any(url.lower().endswith(ext) for ext in VIDEO_EXTS):
-                            return gr.update(value=None, visible=False), gr.update(value=url, visible=True), gr.update(value=f"Remote video detected (content-type={ctype}). Showing preview if browser-playable; converting if necessary.")
-                # Try image fetch (fast)
-                if is_remote(url):
-                    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), gr.update(value="Image preview loaded.")
+                            # save remote to temp to avoid Gradio re-download later
+                            local = _save_preview_local(url)
+                            if local:
+                                return gr.update(value=None, visible=False), gr.update(value=local, visible=True), gr.update(value=f"Remote video detected (content-type={ctype}). Showing preview if browser-playable.")
+                            else:
+                                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=f"Remote video detected but preview download failed (content-type={ctype}).")
+                # Try image fetch and load
+                local = _save_preview_local(url)
+                if not local:
+                    return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value="Preview load failed: could not fetch resource.")
+                try:
+                    img = Image.open(local)
+                    if getattr(img, "is_animated", False):
+                        img.seek(0)
+                    # return local path for gr.Image (type=filepath)
+                    return gr.update(value=local, visible=True), gr.update(value=None, visible=False), gr.update(value="Image preview loaded.")
+                except UnidentifiedImageError:
+                    # Not an image — maybe a video; return video preview if available
+                    if any(local.lower().endswith(ext) for ext in VIDEO_EXTS) or True:
+                        return gr.update(value=None, visible=False), gr.update(value=local, visible=True), gr.update(value="Non-image file — showing as video preview if playable.")
+                    return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value="Preview load failed: file is not a valid image.")
             except Exception as e:
-                msg = f"Preview load failed: {e}. If this is a video, ensure URL ends with .mp4/.webm or upload a playable file."
-                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=msg)
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=f"Preview load failed: {e}")
 
         url_input.change(fn=load_preview, inputs=[url_input], outputs=[preview_image, preview_video, preview_status])
 
         def clear_all():
-            return "", None, None, "idle", "Idle", ""
+            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])
+        clear_btn.click(fn=clear_all, inputs=[], outputs=[url_input, preview_image, preview_video, status_state, progress_md, output_md, preview_path_state])
 
         def _convert_video_for_preview(path: str) -> str:
-            if not FFMPEG_BIN or not os.path.exists(path):
+            # fix: check FFMPEG_BIN path, not 'path'
+            if not FFMPEG_BIN or not os.path.exists(FFMPEG_BIN):
                 return path
             out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
             os.close(out_fd)
@@ -482,45 +546,57 @@ def create_demo():
                 except Exception: pass
                 return path
 
+        # Worker now returns (status_state, output_md, preview_path)
         def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
             try:
                 if not url:
-                    return ("error", "**Error:** No URL provided.")
+                    return ("error", "**Error:** No URL provided.", "")
                 progress(0.01, desc="Starting processing...")
                 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}")
                 client = get_client(key)
+                preview_local = None
                 if is_vid:
                     progress(0.08, desc="Fetching video bytes (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.18, desc="Saved video to temp; converting for preview if needed...")
                     preview_tmp = _convert_video_for_preview(tmp)
-                    # Return preview path to frontend by placing it into preview_video (separate event)
+                    # ensure preview_local is a local path to avoid Gradio re-download
+                    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.98, desc="Finalizing result...")
                     try:
-                        if preview_tmp != tmp:
-                            try: os.remove(preview_tmp)
-                            except Exception: pass
+                        if preview_tmp != tmp and os.path.exists(preview_tmp):
+                            # leave preview_tmp for frontend; worker will clean tmp
+                            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))
+                    return (status, res if isinstance(res, str) else str(res), preview_local or "")
                 elif is_img:
                     progress(0.08, desc="Fetching image bytes...")
                     raw = fetch_bytes(url, progress=progress)
+                    # save preview locally so Gradio won't re-download later
+                    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.")
+                        return ("error", "Error: provided file is not a valid image.", preview_local or "")
                     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))
+                    return (status, res if isinstance(res, str) else str(res), preview_local or "")
                 else:
                     progress(0.07, desc="Unknown media type — fetching bytes for heuristics...")
                     raw = fetch_bytes(url, timeout=120, progress=progress)
@@ -530,7 +606,16 @@ def create_demo():
                         progress(0.2, desc="Image detected — analyzing...")
                         res = analyze_image_structured(client, 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))
+                        # save preview as image
+                        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
+                        return (status, res if isinstance(res, str) else str(res), preview_local or "")
                     except Exception:
                         fd, tmp = tempfile.mkstemp(suffix=ext_from_src(url) or ".mp4")
                         os.close(fd)
@@ -538,28 +623,54 @@ def create_demo():
                             fh.write(raw)
                         try:
                             progress(0.3, 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)
                             status = "done" if not (isinstance(res, str) and res.lower().startswith("error")) else "error"
-                            return (status, res if isinstance(res, str) else str(res))
+                            return (status, res if isinstance(res, str) else str(res), preview_local or "")
                         finally:
                             try: os.remove(tmp)
                             except Exception: pass
             except Exception as e:
-                return ("error", f"Unexpected worker error: {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)
+        # submit returns (status_state, output_md, preview_path_state)
+        submit_btn.click(fn=worker, inputs=[url_input, custom_prompt, api_key], outputs=[status_state, output_md, preview_path_state], queue=True)
 
+        # update submit button label from status
         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])
 
+        # map status to progress 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])
 
+        # when preview_path_state changes, update preview components appropriately
+        def apply_preview(path: str):
+            if not path:
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), ""
+            # choose whether it's image or video by extension/content
+            try:
+                if any(path.lower().endswith(ext) for ext in IMAGE_EXTS):
+                    return gr.update(value=path, visible=True), gr.update(value=None, visible=False), "Preview updated."
+                if any(path.lower().endswith(ext) for ext in VIDEO_EXTS):
+                    return gr.update(value=None, visible=False), gr.update(value=path, visible=True), "Preview updated."
+                # try load as image
+                try:
+                    Image.open(path)
+                    return gr.update(value=path, visible=True), gr.update(value=None, visible=False), "Preview updated."
+                except Exception:
+                    return gr.update(value=None, visible=False), gr.update(value=path, visible=True), "Preview updated."
+            except Exception:
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), ""
+
+        preview_path_state.change(fn=apply_preview, inputs=[preview_path_state], outputs=[preview_image, preview_video, preview_status])
+
     return demo
 
+
 if __name__ == "__main__":
     create_demo().launch(share=False, server_name="0.0.0.0", server_port=7860, max_threads=8)