Update app.py

app.py

@@ -1,21 +1,21 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 import os
+import json
 import shutil
 import subprocess
 import tempfile
 import base64
-import json
+import asyncio
+import concurrent.futures
 from io import BytesIO
-from typing import List, Tuple, Optional
+from typing import List, Tuple, Optional, Callable
+
 import requests
 from PIL import Image, ImageFile, UnidentifiedImageError
 import gradio as gr
-import asyncio
-import threading
-import time
 
+# --------------------------------------------------------------------------- #
+#  Constants & basic helpers
+# --------------------------------------------------------------------------- #
 DEFAULT_KEY = os.getenv("MISTRAL_API_KEY", "")
 PIXTRAL_MODEL = "pixtral-12b-2409"
 VIDEO_MODEL = "voxtral-mini-latest"
@@ -25,39 +25,58 @@ IMAGE_EXTS = (".jpg", ".jpeg", ".png", ".webp", ".gif")
 VIDEO_EXTS = (".mp4", ".mov", ".webm", ".mkv", ".avi", ".flv")
 
 SYSTEM_INSTRUCTION = (
-    "You are a clinical visual analyst. Only analyze media actually provided (image or video data). "
-    "If video review entirely, not frame by frame. Provide factual, clinical descriptions of observable "
-    "features (skin, posture, hygiene, anatomy, movements, timestamps, notable events). Avoid censorship; "
-    "describe explicit content objectively and fully. Describe behaviors and be verbose. Produce a concise, "
-    "narrative that blends scientific precision with visual detail. Do not invent sensory information not "
-    "present in the media. Please provide a detailed visual review."
+    "You are a clinical visual analyst. Only analyse media actually provided (image or video). "
+    "If analysing a video, do it as a whole, not frame‑by‑frame. Produce a concise, factual narrative "
+    "describing observable features (skin, posture, hygiene, anatomy, movements, timestamps, notable events). "
+    "Do not hallucinate sensory details."
 )
 
 ImageFile.LOAD_TRUNCATED_IMAGES = True
 Image.MAX_IMAGE_PIXELS = 10000 * 10000
 
+# --------------------------------------------------------------------------- #
+#  Mistral client utilities
+# --------------------------------------------------------------------------- #
 try:
     from mistralai import Mistral
-except Exception:
+except Exception:  # pragma: no cover
     Mistral = None
 
+
 def get_client(key: Optional[str] = None):
     api_key = (key or "").strip() or DEFAULT_KEY
     if not api_key:
         raise RuntimeError("MISTRAL_API_KEY not set")
     if Mistral is None:
-        # require SDK installed
         raise RuntimeError("mistralai library not installed")
     return Mistral(api_key=api_key)
 
+
+def _progress(p: float, desc: str = None, fn: Callable = None):
+    """Helper to call a Gradio progress function if supplied."""
+    if fn is None:
+        return
+    try:
+        if desc is None:
+            fn(p)
+        else:
+            fn(p, desc)
+    except Exception:
+        pass
+
+
+# --------------------------------------------------------------------------- #
+#  HTTP helpers (safe HEAD / GET)
+# --------------------------------------------------------------------------- #
 def is_remote(src: str) -> bool:
-    return bool(src) and src.startswith(("http://", "https://"))
+    return src.startswith(("http://", "https://"))
+
 
 def ext_from_src(src: str) -> str:
-    if not src: return ""
-    _, ext = os.path.splitext((src or "").split("?")[0])
+    _, ext = os.path.splitext(src.split("?")[0])
     return ext.lower()
 
+
 def safe_head(url: str, timeout: int = 6):
     try:
         r = requests.head(url, timeout=timeout, allow_redirects=True)
@@ -65,89 +84,33 @@ def safe_head(url: str, timeout: int = 6):
     except Exception:
         return None
 
+
 def safe_get(url: str, timeout: int = 15):
     r = requests.get(url, timeout=timeout)
     r.raise_for_status()
     return r
 
+
+# --------------------------------------------------------------------------- #
+#  Temp‑file helpers
+# --------------------------------------------------------------------------- #
 def _temp_file(data: bytes, suffix: str) -> str:
-    """
-    Write *data* to a temporary file and return its absolute path.
-
-    Parameters
-    ----------
-    data: bytes
-        The binary content to store.
-    suffix: str
-        File extension **including** the leading dot (".jpg", ".mp4", …).
-
-    Returns
-    -------
-    str
-        Path to the created temporary file.
-    """
+    """Write *data* to a temporary file and return its path."""
     fd, path = tempfile.mkstemp(suffix=suffix)
-    os.close(fd)                     # close low‑level descriptor
+    os.close(fd)
     with open(path, "wb") as f:
         f.write(data)
     return path
 
-def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int = 60, progress=None) -> bytes:
-    if progress is not None:
-        progress(0.05, desc="Checking remote/local source...")
-    if is_remote(src):
-        head = safe_head(src)
-        if head is not None:
-            cl = head.headers.get("content-length")
-            try:
-                if cl and int(cl) > stream_threshold:
-                    if progress is not None:
-                        progress(0.1, desc="Streaming large remote file...")
-                    with requests.get(src, timeout=timeout, stream=True) as r:
-                        r.raise_for_status()
-                        fd, p = tempfile.mkstemp()
-                        os.close(fd)
-                        try:
-                            with open(p, "wb") as fh:
-                                for chunk in r.iter_content(8192):
-                                    if chunk:
-                                        fh.write(chunk)
-                            with open(p, "rb") as fh:
-                                return fh.read()
-                        finally:
-                            try: os.remove(p)
-                            except Exception: pass
-            except Exception:
-                pass
-        r = safe_get(src, timeout=timeout)
-        if progress is not None:
-            progress(0.25, desc="Downloaded remote content")
-        return r.content
-    else:
-        if not os.path.exists(src):
-            raise FileNotFoundError(f"Local path does not exist: {src}")
-        if progress is not None:
-            progress(0.05, desc="Reading local file...")
-        with open(src, "rb") as f:
-            data = f.read()
-        if progress is not None:
-            progress(0.15, desc="Read local file")
-        return data
 
 def save_bytes_to_temp(b: bytes, suffix: str) -> str:
-    fd, path = tempfile.mkstemp(suffix=suffix)
-    os.close(fd)
-    with open(path, "wb") as f:
-        f.write(b)
-    return path
+    return _temp_file(b, suffix)
+
 
 def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
     img = Image.open(BytesIO(img_bytes))
-    try:
-        if getattr(img, "is_animated", False):
-            img.seek(0)
-    except Exception:
-        pass
+    if getattr(img, "is_animated", False):
+        img.seek(0)
     if img.mode != "RGB":
         img = img.convert("RGB")
     h = base_h
@@ -157,402 +120,444 @@ def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
     img.save(buf, format="JPEG", quality=85)
     return buf.getvalue()
 
+
 def b64_bytes(b: bytes, mime: str = "image/jpeg") -> str:
-    return f"data:{mime};base64," + base64.b64encode(b).decode("utf-8")
-
-def extract_best_frames_bytes(media_path: str, sample_count: int = 5, timeout_extract: int = 15, progress=None) -> List[bytes]:
-    frames: List[bytes] = []
-    if not FFMPEG_BIN or not os.path.exists(media_path):
-        return frames
-    if progress is not None:
-        progress(0.05, desc="Preparing frame extraction...")
-    timestamps = [0.5, 1.0, 2.0, 3.0, 4.0][:sample_count]
-    for i, t in enumerate(timestamps):
-        fd, tmp = tempfile.mkstemp(suffix=f"_{i}.jpg")
+    return f"data:{mime};base64," + base64.b64encode(b).decode()
+
+
+# --------------------------------------------------------------------------- #
+#  Media‑type detection
+# --------------------------------------------------------------------------- #
+def determine_media_type(src: str, progress: Callable = None) -> Tuple[bool, bool]:
+    is_img = ext_from_src(src) in IMAGE_EXTS
+    is_vid = ext_from_src(src) in VIDEO_EXTS
+    if is_remote(src):
+        head = safe_head(src)
+        if head:
+            ct = (head.headers.get("content-type") or "").lower()
+            if ct.startswith("image/"):
+                is_img, is_vid = True, False
+            elif ct.startswith("video/"):
+                is_vid, is_img = True, False
+    _progress(0.02, "Determined media type", progress)
+    return is_img, is_vid
+
+
+# --------------------------------------------------------------------------- #
+#  Download helpers – stream large files directly to a temp file
+# --------------------------------------------------------------------------- #
+def download_to_temp(src: str, progress: Callable = None) -> str:
+    """Return a temporary file path containing the downloaded content."""
+    _progress(0.05, "Downloading...", progress)
+    if is_remote(src):
+        # stream to avoid loading huge files into RAM
+        r = requests.get(src, stream=True, timeout=60)
+        r.raise_for_status()
+        suffix = ext_from_src(src) or ".bin"
+        fd, path = tempfile.mkstemp(suffix=suffix)
         os.close(fd)
-        cmd = [
-            FFMPEG_BIN,
-            "-nostdin",
-            "-y",
-            "-ss",
-            str(t),
-            "-i",
-            media_path,
-            "-frames:v",
-            "1",
-            "-q:v",
-            "2",
-            tmp,
-        ]
+        with open(path, "wb") as f:
+            for chunk in r.iter_content(8192):
+                if chunk:
+                    f.write(chunk)
+        return path
+    else:
+        if not os.path.exists(src):
+            raise FileNotFoundError(f"Local path does not exist: {src}")
+        return src
+
+
+# --------------------------------------------------------------------------- #
+#  ffprobe / conversion helpers (browser‑playable video)
+# --------------------------------------------------------------------------- #
+def _ffprobe_streams(path: str) -> Optional[dict]:
+    if not FFMPEG_BIN:
+        return None
+    ffprobe = FFMPEG_BIN.replace("ffmpeg", "ffprobe")
+    if not shutil.which(ffprobe):
+        ffprobe = "ffprobe"
+    cmd = [
+        ffprobe,
+        "-v",
+        "error",
+        "-print_format",
+        "json",
+        "-show_streams",
+        "-show_format",
+        path,
+    ]
+    try:
+        out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
+        return json.loads(out)
+    except Exception:
+        return None
+
+
+def _is_browser_playable(path: str) -> bool:
+    """True if the file is MP4 (or MOV) with an H.264/H.265 video stream."""
+    if not path:
+        return False
+    ext = path.lower()
+    if any(ext.endswith(e) for e in (".mp4", ".m4v", ".mov")):
+        info = _ffprobe_streams(path)
+        if not info:
+            return ext.endswith(".mp4")
+        for s in info.get("streams", []):
+            if s.get("codec_type") == "video" and s.get("codec_name") in (
+                "h264",
+                "h265",
+                "avc1",
+            ):
+                return True
+    # fallback: any video stream is acceptable
+    info = _ffprobe_streams(path)
+    if not info:
+        return False
+    return any(s.get("codec_type") == "video" for s in info.get("streams", []))
+
+
+def _convert_video_for_preview_if_needed(path: str, progress: Callable = None) -> str:
+    """Return a path that Gradio can play (MP4 + H.264/AAC)."""
+    if not FFMPEG_BIN or not os.path.exists(path):
+        return path
+    if _is_browser_playable(path):
+        return path
+
+    _progress(0.70, "Re‑encoding video for preview", progress)
+    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:
         try:
-            if progress is not None:
-                progress(0.1 + (i / max(1, sample_count)) * 0.2, desc=f"Extracting frame {i+1}/{sample_count}...")
-            subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout_extract)
-            if os.path.exists(tmp) and os.path.getsize(tmp) > 0:
-                with open(tmp, "rb") as f:
-                    frames.append(f.read())
+            os.remove(out_path)
         except Exception:
             pass
-        finally:
-            try: os.remove(tmp)
-            except Exception: pass
-    if progress is not None:
-        progress(0.45, desc=f"Extracted {len(frames)} frames")
-    return frames
-
-def chat_complete(client, model: str, messages, timeout: int = 120, progress=None) -> str:
-    try:
-        if progress is not None:
-            progress(0.6, desc="Sending request to model...")
-        # SDK path: ensure timeout param and non-streaming
-        if hasattr(client, "chat") and hasattr(client.chat, "complete"):
-            try:
-                res = client.chat.complete(model=model, messages=messages, timeout=timeout, stream=False)
-            except TypeError:
-                # fallback if SDK uses a different name for timeout or doesn't accept it
-                try:
-                    res = client.chat.complete(model=model, messages=messages, request_timeout=timeout, stream=False)
-                except TypeError:
-                    res = client.chat.complete(model=model, messages=messages, stream=False)
-            # normalize SDK response to dict if needed
-            if not isinstance(res, dict):
-                # try common SDK attribute shapes
-                try:
-                    res = {"choices": [{"message": {"content": getattr(res, "content", None) or str(res)}}]}
-                except Exception:
-                    res = {"choices": []}
-        else:
-            api_key = getattr(client, "api_key", "") or DEFAULT_KEY
-            if not api_key:
-                raise RuntimeError("MISTRAL_API_KEY missing or empty")
-            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)
-            r.raise_for_status()
-            res = r.json()
+        return path
 
-        if progress is not None:
-            progress(0.8, desc="Model responded, parsing...")
-
-        choices = getattr(res, "choices", None) or (res.get("choices") if isinstance(res, dict) else [])
-        if not choices:
-            return f"Empty response from model: {res}"
-        first = choices[0]
-        msg = (first.message if hasattr(first, "message") else (first.get("message") if isinstance(first, dict) else first))
-        content = (msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", None))
-        return content.strip() if isinstance(content, str) else str(content)
-    except requests.exceptions.RequestException as e:
-        return f"Error: network/API request failed: {e}"
-    except Exception as e:
-        return f"Error during model call: {e}"
 
+# --------------------------------------------------------------------------- #
+#  Mistral interaction (upload + chat)
+# --------------------------------------------------------------------------- #
 def upload_file_to_mistral(
     client,
     path: str,
     filename: str | None = None,
     purpose: str = "batch",
-    timeout: int = 120,
-    progress=None,
+    progress: Callable = None,
 ) -> str:
-    """
-    Upload a file to Mistral using only the REST endpoint.
-    - Sends multipart/form‑data with field name **file**.
-    - Sends a form field **purpose** (string).
-    - If the request returns 422, retries with common allowed purposes
-      (image, batch, fine‑tune) and returns the first successful file id.
-    """
+    """Upload a file via the REST endpoint and return its file‑id."""
     fname = filename or os.path.basename(path)
 
-    # ------------------------------------------------------------------ #
-    # Build the list of purposes to try (original + sensible fallbacks)
-    # ------------------------------------------------------------------ #
-    purposes_to_try = [purpose]
-
-    # If the file looks like an image, try "image" first
+    # Build a short list of plausible purposes
+    purposes = [purpose]
     ext = os.path.splitext(fname)[1].lower()
     if ext in {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff"}:
-        purposes_to_try.append("image")
-
-    # Add other generic allowed values (avoid duplicates)
+        purposes.append("image")
     for p in ("batch", "fine-tune", "image"):
-        if p not in purposes_to_try:
-            purposes_to_try.append(p)
+        if p not in purposes:
+            purposes.append(p)
 
-    # ------------------------------------------------------------------ #
-    # Prepare request details
-    # ------------------------------------------------------------------ #
     api_key = getattr(client, "api_key", "") or DEFAULT_KEY
     if not api_key:
-        raise RuntimeError("MISTRAL_API_KEY missing or empty")
+        raise RuntimeError("MISTRAL_API_KEY missing")
 
     url = "https://api.mistral.ai/v1/files"
     headers = {"Authorization": f"Bearer {api_key}"}
 
-    # ------------------------------------------------------------------ #
-    # Try each purpose until we get a successful upload
-    # ------------------------------------------------------------------ #
-    last_error = None
-    for cur_purpose in purposes_to_try:
+    last_err = None
+    for cur_purpose in purposes:
         try:
             with open(path, "rb") as fh:
                 files = {"file": (fname, fh)}
                 data = {"purpose": cur_purpose}
                 resp = requests.post(
-                    url,
-                    headers=headers,
-                    files=files,
-                    data=data,
-                    timeout=timeout,
+                    url, headers=headers, files=files, data=data, timeout=120
                 )
                 resp.raise_for_status()
-                jr = resp.json()
-
-            # ---------------------------------------------------------------- #
-            # Extract the file id from the JSON response (covers both shapes)
-            # ---------------------------------------------------------------- #
-            fid = jr.get("id") or jr.get("data", [{}])[0].get("id")
-            if not fid:
-                # deep‑search for any "id" key just in case
-                def find_id(obj):
-                    if isinstance(obj, dict):
-                        if "id" in obj and isinstance(obj["id"], str):
-                            return obj["id"]
-                        for v in obj.values():
-                            found = find_id(v)
-                            if found:
-                                return found
-                    elif isinstance(obj, list):
-                        for item in obj:
-                            found = find_id(item)
-                            if found:
-                                return found
-                    return None
-
-                fid = find_id(jr)
-
-            if fid:
-                if progress is not None:
-                    try:
-                        progress(0.65)
-                    except TypeError:
-                        progress(0.65, desc=f"Upload complete (REST, purpose={cur_purpose})")
-                return fid
-
-            raise RuntimeError(f"REST upload succeeded but no file id returned (purpose={cur_purpose})")
-
+                payload = resp.json()
+                fid = payload.get("id") or payload.get("data", [{}])[0].get("id")
+                if fid:
+                    _progress(0.65, f"Uploaded (purpose={cur_purpose})", progress)
+                    return fid
+                raise RuntimeError("Upload succeeded but no file id returned")
         except requests.exceptions.HTTPError as he:
-            # 422 → try next purpose; other codes → abort
-            status = getattr(he.response, "status_code", None)
-            last_error = he
-            if status == 422:
+            if he.response.status_code == 422:
+                last_err = he
                 continue
-            raise RuntimeError(f"File upload failed. REST error: {he}")
-
-        except requests.exceptions.RequestException as re:
-            last_error = re
-            raise RuntimeError(f"File upload failed. REST error: {re}")
-
-    # If we exit the loop, all purpose attempts failed
-    err_msg = "File upload failed. REST attempts exhausted."
-    if last_error:
-        err_msg += f" Last REST error: {last_error}"
-    raise RuntimeError(err_msg)
-
-def determine_media_type(src: str, progress=None) -> Tuple[bool, bool]:
-    is_image = False
-    is_video = False
-    ext = ext_from_src(src)
-    if ext in IMAGE_EXTS:
-        is_image = True
-    if ext in VIDEO_EXTS:
-        is_video = True
-    if is_remote(src):
-        head = safe_head(src)
-        if head:
-            ctype = (head.headers.get("content-type") or "").lower()
-            if ctype.startswith("image/"):
-                is_image, is_video = True, False
-            elif ctype.startswith("video/"):
-                is_video, is_image = True, False
-    if progress is not None:
-        progress(0.02, desc="Determined media type")
-    return is_image, is_video
-
-def analyze_image_structured(client, img_bytes: bytes, prompt: str, progress=None) -> str:
+            raise RuntimeError(f"Upload failed: {he}") from he
+        except Exception as e:
+            last_err = e
+            raise RuntimeError(f"Upload failed: {e}") from e
+
+    raise RuntimeError(f"All upload attempts failed. Last error: {last_err}")
+
+
+def chat_complete(client, model: str, messages, progress: Callable = None) -> str:
+    """Send a chat request (non‑streaming) and return the model’s text response."""
+    _progress(0.60, "Calling model", progress)
+    try:
+        if hasattr(client, "chat") and hasattr(client.chat, "complete"):
+            try:
+                res = client.chat.complete(
+                    model=model, messages=messages, timeout=120, stream=False
+                )
+            except TypeError:
+                # SDK variations
+                res = client.chat.complete(
+                    model=model, messages=messages, request_timeout=120, stream=False
+                )
+        else:
+            # raw REST fallback
+            api_key = getattr(client, "api_key", "") or DEFAULT_KEY
+            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=120,
+            )
+            r.raise_for_status()
+            res = r.json()
+    except Exception as e:
+        return f"Error during model call: {e}"
+
+    _progress(0.80, "Parsing response", progress)
+    choices = getattr(res, "choices", None) or (
+        res.get("choices") if isinstance(res, dict) else []
+    )
+    if not choices:
+        return f"Empty response: {res}"
+    first = choices[0]
+    msg = (
+        first.get("message")
+        if isinstance(first, dict)
+        else getattr(first, "message", {})
+    )
+    content = (
+        msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", "")
+    )
+    return content.strip() if isinstance(content, str) else str(content)
+
+
+# --------------------------------------------------------------------------- #
+#  Analysis functions (image & video)
+# --------------------------------------------------------------------------- #
+def analyze_image_structured(
+    client, img_bytes: bytes, prompt: str, progress: Callable = None
+) -> str:
+    _progress(0.30, "Preparing image", progress)
+    jpeg = convert_to_jpeg_bytes(img_bytes, base_h=1024)
+    tmp = save_bytes_to_temp(jpeg, ".jpg")
     try:
-        if progress is not None:
-            progress(0.3, desc="Preparing image for analysis...")
-        jpeg = convert_to_jpeg_bytes(img_bytes, base_h=1024)
-        tmp = save_bytes_to_temp(jpeg, suffix=".jpg")
+        fid = upload_file_to_mistral(
+            client, tmp, filename="image.jpg", purpose="image", progress=progress
+        )
+    finally:
         try:
-            file_id = upload_file_to_mistral(client, tmp, filename="image.jpg", purpose="image", progress=progress)
-        finally:
-            try: os.remove(tmp)
-            except Exception: pass
+            os.remove(tmp)
+        except Exception:
+            pass
 
-        # Reference the uploaded file id instead of embedding base64
-        messages = [
-            {"role": "system", "content": SYSTEM_INSTRUCTION},
-            {"role": "user", "content": [
+    messages = [
+        {"role": "system", "content": SYSTEM_INSTRUCTION},
+        {
+            "role": "user",
+            "content": [
                 {"type": "text", "text": prompt},
-                {"type": "file", "file_id": file_id},
-            ]},
-        ]
-        return chat_complete(client, PIXTRAL_MODEL, messages, progress=progress)
-    except UnidentifiedImageError:
-        return "Error: provided file is not a valid image."
-    except Exception as e:
-        return f"Error analyzing image: {e}"
+                {"type": "file", "file_id": fid},
+            ],
+        },
+    ]
+    return chat_complete(client, PIXTRAL_MODEL, messages, progress=progress)
+
 
-def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None) -> str:
+def analyze_video_cohesive(
+    client,
+    video_path: str,
+    prompt: str,
+    progress: Callable = None,
+    model: str = VIDEO_MODEL,
+) -> str:
+    """Full‑video analysis; falls back to frame‑based analysis on upload failure."""
     try:
-        if progress is not None:
-            progress(0.3, desc="Uploading video for full analysis...")
-        file_id = upload_file_to_mistral(client, video_path, filename=os.path.basename(video_path), progress=progress)
-        extra_msg = (
-            f"Uploaded video file id: {file_id}\n\n"
-            "Instruction: Analyze the entire video and produce a single cohesive narrative describing consistent observations."
+        _progress(0.30, "Uploading video", progress)
+        fid = upload_file_to_mistral(
+            client,
+            video_path,
+            filename=os.path.basename(video_path),
+            purpose="batch",
+            progress=progress,
         )
         messages = [
             {"role": "system", "content": SYSTEM_INSTRUCTION},
-            {"role": "user", "content": extra_msg + "\n\n" + prompt},
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"{prompt}\n\nAnalyze the whole video and produce a single cohesive narrative.",
+                    },
+                    {"type": "file", "file_id": fid},
+                ],
+            },
         ]
-        return chat_complete(client, VIDEO_MODEL, messages, progress=progress)
-    except Exception as e:
-        if progress is not None:
-            progress(0.35, desc="Upload failed, extracting frames as fallback...")
-        frames = extract_best_frames_bytes(video_path, sample_count=6, progress=progress)
+        return chat_complete(client, model, messages, progress=progress)
+
+    except Exception as exc:
+        # ---- fallback: extract a few representative frames --------------------
+        _progress(0.35, "Upload failed – extracting frames", progress)
+        frames = extract_best_frames_bytes(
+            video_path, sample_count=6, progress=progress
+        )
         if not frames:
-            return f"Error: could not upload video and no frames could be extracted. ({e})"
-        image_entries = []
-        for i, fb in enumerate(frames, start=1):
+            return f"Error: upload failed and no frames could be extracted ({exc})"
+
+        # upload each frame and build the message payload
+        frame_files = []
+        for i, raw in enumerate(frames, 1):
+            _progress(
+                0.40 + i / len(frames) * 0.15,
+                f"Uploading frame {i}/{len(frames)}",
+                progress,
+            )
+            tmp = save_bytes_to_temp(convert_to_jpeg_bytes(raw, base_h=720), ".jpg")
             try:
-                if progress is not None:
-                    progress(0.4 + (i / len(frames)) * 0.2, desc=f"Preparing frame {i}/{len(frames)}...")
-                j = convert_to_jpeg_bytes(fb, base_h=720)
-                image_entries.append(
-                    {
-                        "type": "image_url",
-                        "image_url": b64_bytes(j, mime="image/jpeg"),
-                        "meta": {"frame_index": i},
-                    }
+                fid = upload_file_to_mistral(
+                    client, tmp, f"frame_{i}.jpg", purpose="image", progress=progress
                 )
-            except Exception:
-                continue
-        content = [{"type": "text", "text": prompt + "\n\nPlease consolidate observations across these frames into a single cohesive narrative."}] + image_entries
+                frame_files.append({"type": "file", "file_id": fid})
+            finally:
+                os.remove(tmp)
+
         messages = [
             {"role": "system", "content": SYSTEM_INSTRUCTION},
-            {"role": "user", "content": content},
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"{prompt}\n\nConsolidate observations across the provided frames into a single narrative.",
+                    },
+                    *frame_files,
+                ],
+            },
         ]
         return chat_complete(client, PIXTRAL_MODEL, messages, progress=progress)
 
-def process_media(src: str, custom_prompt: str, api_key: str, progress=None) -> str:
-    client = get_client(api_key)
-    prompt = (custom_prompt or "").strip() or "Please provide a detailed visual review."
-    
-    if not src:
-        return "Error: No URL or path provided."
-    
-    if progress is not None:
-        progress(0.01, desc="Starting media processing")
-    
-    try:
-        is_image, is_video = determine_media_type(src, progress=progress)
-    except Exception as e:
-        return f"Error determining media type: {e}"
 
-    if is_image:
-        try:
-            if progress is not None:
-                progress(0.05, desc="Fetching image bytes...")
-            raw = fetch_bytes(src, progress=progress)
-        except FileNotFoundError as e:
-            return f"Error: {e}"
-        except Exception as e:
-            return f"Error fetching image: {e}"
+# --------------------------------------------------------------------------- #
+#  Gradio UI helpers
+# --------------------------------------------------------------------------- #
+css = ".preview_media img, .preview_media video {max-width:100%;height:auto;border-radius:6px;}"
 
-        if progress is not None:
-            progress(0.2, desc="Analyzing image")
-        try:
-            return analyze_image_structured(client, raw, prompt, progress=progress)
-        except UnidentifiedImageError:
-            return "Error: provided file is not a valid image."
-        except Exception as e:
-            return f"Error analyzing image: {e}"
 
-    if is_video:
-        try:
-            if progress is not None:
-                progress(0.05, desc="Fetching video bytes...")
-            raw = fetch_bytes(src, timeout=120, progress=progress)
-        except FileNotFoundError as e:
-            return f"Error: {e}"
-        except Exception as e:
-            return f"Error fetching video: {e}"
-        
-        tmp_path = save_bytes_to_temp(raw, suffix=ext_from_src(src) or ".mp4")
+def _make_preview(url: str, raw: bytes, cache: dict) -> str:
+    """Create (or reuse) a preview file – image → JPEG, video → MP4 (browser‑playable)."""
+    if url in cache:
+        return cache[url]
 
-        try:
-            if progress is not None:
-                progress(0.2, desc="Analyzing video")
-            return analyze_video_cohesive(client, tmp_path, prompt, progress=progress)
-        finally:
-            try: 
-                os.remove(tmp_path)
-            except Exception: 
-                pass
+    if determine_media_type(url)[1]:  # video
+        tmp = _temp_file(raw, suffix=ext_from_src(url) or ".mp4")
+        preview = _convert_video_for_preview_if_needed(tmp)
+        os.remove(tmp)  # the converted file is a separate temp file
+    else:  # image
+        preview = _temp_file(convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg")
+    cache[url] = preview
+    return preview
 
-    try:
-        if progress is not None:
-            progress(0.05, desc="Treating input as image fallback...")
-        raw = fetch_bytes(src, progress=progress)
-        if progress is not None:
-            progress(0.2, desc="Analyzing fallback image")
-        return analyze_image_structured(client, raw, prompt, progress=progress)
-    except Exception as e:
-        return f"Unable to determine media type or fetch file: {e}"
 
-def _ensure_event_loop_for_thread():
-    """
-    Ensure the current thread has an asyncio event loop. Used when running blocking
-    functions in a worker thread that need to run coroutines or use asyncio.get_event_loop().
-    """
+def apply_preview(path: str, last_path: str):
+    """Return Gradio updates for image/video components and a status string."""
+    if not path or path == last_path:
+        return gr.update(), gr.update(), ""
+
+    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.",
+        )
+
+    # fallback – try to open as image
     try:
-        asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-def run_blocking_in_thread(fn, *args, **kwargs):
-    """
-    Run a blocking function in a thread but ensure the thread has an event loop.
-    Returns concurrent.futures.Future; caller may call .result().
-    """
-    def target():
-        _ensure_event_loop_for_thread()
-        return fn(*args, **kwargs)
-    import concurrent.futures
-    executor = concurrent.futures.ThreadPoolExecutor(max_workers=8)
-    return executor.submit(target)
-
-css = ".preview_media img, .preview_media video { max-width: 100%; height: auto; border-radius:6px; }"
-
-def _btn_label_for_status(status: str) -> str:
-    return {"idle": "Submit", "busy": "Processing…", "done": "Submit", "error": "Retry"}.get(status, "Submit")
+        Image.open(path).verify()
+        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=None, visible=False),
+            "",
+        )
+
 
 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="filepath", 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)
+                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",
+                )
+                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)
+                url_input = gr.Textbox(
+                    label="Image / Video URL", placeholder="https://...", lines=1
+                )
                 with gr.Accordion("Prompt (optional)", open=False):
                     custom_prompt = gr.Textbox(label="Prompt", lines=4, value="")
                 with gr.Accordion("Mistral API Key (optional)", open=False):
-                    api_key = gr.Textbox(label="Mistral API Key", type="password", max_lines=1)
+                    api_key = gr.Textbox(
+                        label="Mistral API Key", type="password", max_lines=1
+                    )
                 with gr.Row():
                     submit_btn = gr.Button("Submit")
                     clear_btn = gr.Button("Clear")
@@ -563,7 +568,9 @@ def create_demo():
                 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):
+        def _fetch_with_retries_bytes(
+            src: str, timeout: int = 15, max_retries: int = 3
+        ):
             attempt = 0
             delay = 1.0
             while True:
@@ -616,39 +623,99 @@ def create_demo():
         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="")
+                return (
+                    gr.update(value=None, visible=False),
+                    gr.update(value=None, visible=False),
+                    gr.update(value=""),
+                )
             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):
+                        if ctype.startswith("video/") or any(
+                            url.lower().endswith(ext) for ext in VIDEO_EXTS
+                        ):
                             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.")
+                                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}).")
+                                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})."
+                                    ),
+                                )
                 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.")
+                    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 gr.update(value=local, visible=True), gr.update(value=None, visible=False), gr.update(value="Image preview loaded.")
+                    return (
+                        gr.update(value=local, visible=True),
+                        gr.update(value=None, visible=False),
+                        gr.update(value="Image preview loaded."),
+                    )
                 except UnidentifiedImageError:
                     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.")
+                        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:
-                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=f"Preview load failed: {e}")
+                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])
+        url_input.change(
+            fn=load_preview,
+            inputs=[url_input],
+            outputs=[preview_image, preview_video, preview_status],
+        )
 
         def clear_all():
             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, preview_path_state])
+        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(FFMPEG_BIN):
@@ -656,34 +723,65 @@ def create_demo():
             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
+                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)
+                subprocess.run(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    timeout=60,
+                )
                 return out_path
             except Exception:
-                try: os.remove(out_path)
-                except Exception: pass
+                try:
+                    os.remove(out_path)
+                except Exception:
+                    pass
                 return path
 
         # --- Helper: probe codecs via ffprobe; returns dict with streams info or None on failure
         def _ffprobe_streams(path: str) -> Optional[dict]:
             if not FFMPEG_BIN:
                 return None
-            ffprobe = FFMPEG_BIN.replace("ffmpeg", "ffprobe") if "ffmpeg" in FFMPEG_BIN else "ffprobe"
+            ffprobe = (
+                FFMPEG_BIN.replace("ffmpeg", "ffprobe")
+                if "ffmpeg" in FFMPEG_BIN
+                else "ffprobe"
+            )
             if not shutil.which(ffprobe):
                 ffprobe = "ffprobe"
             cmd = [
-                ffprobe, "-v", "error", "-print_format", "json", "-show_streams", "-show_format", path
+                ffprobe,
+                "-v",
+                "error",
+                "-print_format",
+                "json",
+                "-show_streams",
+                "-show_format",
+                path,
             ]
             try:
                 out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
                 return json.loads(out)
             except Exception:
                 return None
-        
+
         # --- Helper: is file already browser-playable (mp4 container with h264 video and aac audio OR at least playable video)
         def _is_browser_playable(path: str) -> bool:
             try:
@@ -695,7 +793,8 @@ def create_demo():
                         return ext.endswith(".mp4")
                     streams = info.get("streams", [])
                     v_ok = any(
-                        s.get("codec_name") in ("h264", "h265", "avc1") and s.get("codec_type") == "video"
+                        s.get("codec_name") in ("h264", "h265", "avc1")
+                        and s.get("codec_type") == "video"
                         for s in streams
                     )
                     # audio optional for preview
@@ -708,7 +807,7 @@ def create_demo():
                 return any(s.get("codec_type") == "video" for s in streams)
             except Exception:
                 return False
-        
+
         # --- Convert only if not browser-playable
         def _convert_video_for_preview_if_needed(path: str) -> str:
             """
@@ -719,96 +818,145 @@ def create_demo():
             """
             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"}
+                    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
-        
+                        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,
+                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)
+                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
+                try:
+                    os.remove(out_path)
+                except Exception:
+                    pass
                 return path
-                
+
         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.", ""
-        
+
                 progress(0.02, desc="Checking URL / content‑type")
                 is_img, is_vid = determine_media_type(url, progress=progress)
-        
+
                 client = get_client(key)
                 preview_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"))
+                    tmp_video = _temp_file(
+                        raw, suffix="." + (ext_from_src(url) or "mp4")
+                    )
                     progress(0.15, desc="Preparing preview")
                     preview_path = _make_preview(url, raw)
-        
+
                     progress(0.25, desc="Running full‑video analysis")
-                    result = analyze_video_cohesive(client, tmp_video, prompt, progress=progress)
-        
+                    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
-        
+                    try:
+                        os.remove(tmp_video)
+                    except Exception:
+                        pass
+
                 elif is_img:
                     progress(0.05, desc="Downloading image")
                     raw = fetch_bytes(url, progress=progress)
-        
+
                     # preview image (always JPEG for consistency)
                     preview_path = _make_preview(url, raw)
-        
+
                     progress(0.20, desc="Running image analysis")
-                    result = analyze_image_structured(client, raw, prompt, progress=progress)
-        
+                    result = analyze_image_structured(
+                        client, raw, prompt, progress=progress
+                    )
+
                 else:
                     progress(0.07, desc="Downloading unknown media")
                     raw = fetch_bytes(url, timeout=120, progress=progress)
-        
+
                     # try to open as image
                     try:
                         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)
+                        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
-        
-                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 ""
-        
+                        result = analyze_video_cohesive(
+                            client, tmp_vid, prompt, progress=progress
+                        )
+                        try:
+                            os.remove(tmp_vid)
+                        except Exception:
+                            pass
+
+                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}", ""
 
@@ -832,11 +980,23 @@ def create_demo():
             }
             return labels.get(s, "Submit")
 
-        status_state.change(fn=lambda s: _btn_label_for_status(s), inputs=[status_state], outputs=[submit_btn])
+        status_state.change(
+            fn=lambda s: _btn_label_for_status(s),
+            inputs=[status_state],
+            outputs=[submit_btn],
+        )
 
         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 {
+                "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]
+        )
 
         preview_cache = {}
 
@@ -849,7 +1009,9 @@ def create_demo():
                 preview = _convert_video_for_preview_if_needed(tmp)
                 preview_cache[url] = (preview, True)
             else:
-                preview = _temp_file(convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg")
+                preview = _temp_file(
+                    convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg"
+                )
                 preview_cache[url] = (preview, False)
             return preview
 
@@ -865,22 +1027,45 @@ def create_demo():
 
             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."
-                
+                    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."
-                
+                    return (
+                        gr.update(value=None, visible=False),
+                        gr.update(value=path, visible=True),
+                        "Preview updated.",
+                    )
+
                 img = Image.open(path)
                 img.verify()
-                return gr.update(value=path, visible=True), gr.update(value=None, visible=False), "Preview updated."
-                
+                return (
+                    gr.update(value=path, visible=True),
+                    gr.update(value=None, visible=False),
+                    "Preview updated.",
+                )
+
             except Exception as e:
                 print(f"Failed to update preview: {e}")
-                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),
+                    "",
+                )
 
-        preview_path_state.change(fn=apply_preview, inputs=[preview_path_state, prev_preview_state], outputs=[preview_image, preview_video, preview_status])
+        preview_path_state.change(
+            fn=apply_preview,
+            inputs=[preview_path_state, prev_preview_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)
+    create_demo().launch(
+        share=False, server_name="0.0.0.0", server_port=7860, max_threads=8
+    )