Upload 2 files

app.py

@@ -6,6 +6,7 @@ import shutil
 import subprocess
 from pathlib import Path
 from typing import Tuple, Optional
+import importlib.util as _import_spec
 
 import gradio as gr
 from huggingface_hub import snapshot_download
@@ -17,10 +18,10 @@ CACHE_DIR.mkdir(exist_ok=True)
 WEIGHTS_REPO = "JunhaoZhuang/FlashVSR"
 FLASH_GIT = "https://github.com/OpenImagingLab/FlashVSR.git"
 
-# ----------------------------- helpers -----------------------------
+# ----------------------------- shell helpers -----------------------------
 
 def run(cmd: list[str], cwd: Optional[Path] = None, env: Optional[dict] = None) -> Tuple[int, str, str]:
-    """Run a command and capture full stdout/stderr (so failures are visible in logs)."""
+    """Run a command and capture stdout/stderr."""
     proc = subprocess.run(
         cmd,
         cwd=str(cwd) if cwd else None,
@@ -31,6 +32,37 @@ def run(cmd: list[str], cwd: Optional[Path] = None, env: Optional[dict] = None)
     )
     return proc.returncode, proc.stdout, proc.stderr
 
+# ----------------------------- deps helpers -----------------------------
+
+def _has_module(name: str) -> bool:
+    return _import_spec.find_spec(name) is not None
+
+def ensure_python_deps(logs: list[str]) -> None:
+    """
+    Install lightweight runtime deps if missing. Safer than failing the whole run.
+    """
+    need = []
+    # Minimal set seen in FlashVSR's example imports and typical backbones
+    if not _has_module("transformers"):
+        need += ["transformers>=4.44"]
+    if not _has_module("sentencepiece"):
+        need += ["sentencepiece>=0.1.99"]
+    if not _has_module("safetensors"):
+        need += ["safetensors>=0.4.3"]
+    if not _has_module("timm"):
+        need += ["timm>=0.9.16"]
+    if not _has_module("accelerate"):
+        need += ["accelerate>=0.33"]
+
+    if need:
+        logs.append(f"Installing missing deps: {need}")
+        code, out, err = run([sys.executable, "-m", "pip", "install", "--no-cache-dir", *need])
+        logs.append(out)
+        logs.append(err)
+        if code != 0:
+            raise RuntimeError(f"Pip failed while installing {need}:\n{err or out}")
+
+# ----------------------------- repo / weights -----------------------------
 
 def ensure_flashvsr_repo() -> Path:
     """Clone FlashVSR repo if missing."""
@@ -39,11 +71,9 @@ def ensure_flashvsr_repo() -> Path:
         code, out, err = run(["git", "clone", "--depth=1", FLASH_GIT, str(repo_dir)])
         if code != 0:
             raise RuntimeError(f"Failed to clone FlashVSR.\n{err}")
-        # best-effort submodules (harmless if none)
         run(["git", "submodule", "update", "--init", "--recursive"], cwd=repo_dir)
     return repo_dir
 
-
 def ensure_weights() -> Path:
     """Download weights snapshot locally once."""
     target = CACHE_DIR / "weights"
@@ -57,14 +87,14 @@ def ensure_weights() -> Path:
         )
     return target
 
+# ----------------------------- IO utils -----------------------------
 
 def normalize_to_mp4(src_path: Path) -> Path:
     """
     Convert ANY uploaded file to a very browser-friendly MP4:
       - H.264 (yuv420p), Baseline profile
-      - Even dimensions + CFR 30 fps
-      - +faststart
-      - No-audio (avoids codec/container edge cases in browser preview)
+      - Even dimensions + CFR 30 fps, +faststart
+      - No audio (avoids browser codec edge cases)
     """
     out_path = src_path.with_name(src_path.stem + "_playable.mp4")
     vf = "scale=trunc(iw/2)*2:trunc(ih/2)*2,fps=30"
@@ -84,6 +114,7 @@ def normalize_to_mp4(src_path: Path) -> Path:
         raise RuntimeError(f"ffmpeg failed to normalize the video.\n\n{err or out}")
     return out_path
 
+# ----------------------------- ModelScope stub -----------------------------
 
 def ensure_modelscope_stub() -> Path:
     """
@@ -102,23 +133,25 @@ def ensure_modelscope_stub() -> Path:
         )
     return stub_root
 
-# ------------------------- core pipeline ---------------------------
+# ----------------------------- pipeline -----------------------------
 
 def run_flashvsr_on_video(
     in_video: Path,
     scale: int,
     prefer_sparse: bool,
     log_file: Path,
-) -> Tuple[Optional[Path], str]:
+):
     """
     Execute the FlashVSR example script and return (output_path | None, combined_logs).
-    Writes full logs to log_file either way.
     """
     logs = []
+    # 1) Make sure python deps exist
+    ensure_python_deps(logs)
 
+    # 2) Repo + weights
     repo_dir = ensure_flashvsr_repo()
     weights_dir = ensure_weights()
-    stub_root = ensure_modelscope_stub()  # <— NEW
+    stub_root = ensure_modelscope_stub()
 
     logs.append(f"Python: {sys.version}")
     logs.append(f"Repo: {repo_dir}")
@@ -138,8 +171,7 @@ def run_flashvsr_on_video(
     out_dir.mkdir(exist_ok=True)
     out_mp4 = out_dir / f"{in_video.stem}_x{scale}.mp4"
 
-    # Build env so the repo's modules (e.g., diffsynth) import WITHOUT pip install -e .
-    # And place our 'modelscope' stub at the front so its snapshot_download is used.
+    # Environment: make repo importable and put our stub first
     env = os.environ.copy()
     extra_paths = [str(stub_root), str(repo_dir), str(repo_dir / "diffsynth")]
     existing = env.get("PYTHONPATH", "")
@@ -159,7 +191,7 @@ def run_flashvsr_on_video(
             logs.append(err)
         return code == 0 and out_mp4.exists()
 
-    # Try several common arg shapes used across revisions.
+    # Try a few CLI shapes used across revisions
     if _try(["--input", str(in_video), "--output", str(out_mp4), "--scale", str(scale), "--weights", str(weights_dir)]):
         pass
     elif _try(["--video", str(in_video), "--outdir", str(out_dir), "--scale", str(scale), "--weights", str(weights_dir)]):
@@ -174,15 +206,12 @@ def run_flashvsr_on_video(
     combined = "\n".join(logs)
     log_file.write_text(combined)
 
-    # Normalize the produced result for browser playback just in case.
+    # Normalize result for browser playback
     playable = normalize_to_mp4(out_mp4) if out_mp4.exists() else None
     return playable, combined
 
-
 def infer(ui_video: str, scale: int, prefer_sparse: bool):
-    """
-    Gradio handler: return (video_path | None, diagnostics text, logs file path)
-    """
+    """Gradio handler: return (video_path | None, diagnostics text, logs file path)"""
     logs_path = CACHE_DIR / "last_run_logs.txt"
 
     if not ui_video:
@@ -197,7 +226,6 @@ def infer(ui_video: str, scale: int, prefer_sparse: bool):
         return None, msg, str(logs_path)
 
     try:
-        # Ensure the *input* itself is previewable in the browser.
         src_playable = normalize_to_mp4(src)
     except Exception as e:
         msg = f"Input normalization failed:\n{e}"
@@ -207,13 +235,11 @@ def infer(ui_video: str, scale: int, prefer_sparse: bool):
     try:
         out_path, combined = run_flashvsr_on_video(src_playable, scale, prefer_sparse, logs_path)
         if out_path is None:
-            # Show input so player still has something; include reason in diagnostics.
             return str(src_playable), "FlashVSR failed. See logs below.", str(logs_path)
         return str(out_path), "Done.", str(logs_path)
     except Exception as e:
         msg = f"Pipeline error:\n{e}"
         logs_path.write_text(msg)
-        # Fall back to showing the normalized input so the UI still previews something.
         return str(src_playable), msg, str(logs_path)
 
 # ------------------------------ UI -------------------------------

requirements.txt

@@ -6,7 +6,11 @@ opencv-python>=4.10
 einops>=0.8.0
 diffsynth>=1.1.8
 modelscope>=1.15.0
-
+transformers>=4.44
+sentencepiece>=0.1.99
+safetensors>=0.4.3
+timm>=0.9.16
+accelerate>=0.33
 
 # PyTorch (choose the wheel that matches your CUDA setup)
 # For CUDA 12.4 wheels (edit for your machine or Space):