Create app.py

app.py

@@ -0,0 +1,109 @@
+import os
+import shutil
+import tempfile
+import threading
+import subprocess
+from pathlib import Path
+
+import gradio as gr
+from PIL import Image
+
+# Config
+RIFE_REPO_URL = "https://github.com/hzwer/arXiv2020-RIFE"
+RIFE_DIR = Path("arXiv2020-RIFE")
+TRAIN_LOG_DIR = RIFE_DIR / "train_log"
+OUTPUT_DIR = RIFE_DIR / "output"
+WEIGHTS_ID = "1APIzVeI-4ZZCEuIRE1m6WYfSCaOsi_7_"  # RIFE v3.6
+
+LOCK = threading.Lock()
+RIFE_READY = False
+
+def interpolate(a: Image.Image, b: Image.Image, fps: int = 14, exp: int = 2):
+    global RIFE_READY
+
+    with LOCK:
+        # Lazy one-time setup
+        if not RIFE_READY:
+            if not RIFE_DIR.exists():
+                subprocess.run(["git", "clone", "--depth", "1", RIFE_REPO_URL, str(RIFE_DIR)], check=True)
+            TRAIN_LOG_DIR.mkdir(parents=True, exist_ok=True)
+            has_weights = any(p.suffix in {".pkl", ".pth"} for p in TRAIN_LOG_DIR.glob("*"))
+            if not has_weights:
+                zip_path = TRAIN_LOG_DIR / "RIFE_trained_model_v3.6.zip"
+                subprocess.run(["gdown", "--id", WEIGHTS_ID, "-O", str(zip_path)], check=True)
+                subprocess.run(["unzip", "-o", str(zip_path), "-d", str(TRAIN_LOG_DIR)], check=True)
+            RIFE_READY = True
+
+        # Normalize inputs
+        a = a.convert("RGB")
+        b = b.convert("RGB")
+        if b.size != a.size:
+            b = b.resize(a.size, Image.BICUBIC)
+
+        work_dir = Path(tempfile.mkdtemp(prefix="rife_run_"))
+        p1 = work_dir / "a.png"
+        p2 = work_dir / "b.png"
+        a.save(p1, "PNG")
+        b.save(p2, "PNG")
+
+        # Clean RIFE output and run inference
+        if OUTPUT_DIR.exists():
+            shutil.rmtree(OUTPUT_DIR)
+        OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+        cmd = ["python3", "inference_img.py", "--img", str(p1), str(p2)]
+        if isinstance(exp, int) and exp >= 1:
+            cmd += ["--exp", str(exp)]
+        subprocess.run(cmd, cwd=str(RIFE_DIR), check=True)
+
+        # Collect frames in natural sequence: img1.png → imgN.png
+        frames = []
+        i = 1
+        while True:
+            fp = OUTPUT_DIR / f"img{i}.png"
+            if not fp.exists():
+                break
+            frames.append(fp)
+            i += 1
+        if not frames:
+            raise RuntimeError("No frames produced by RIFE.")
+
+        # Assemble GIF
+        images = [Image.open(p).convert("RGBA") for p in frames]
+        duration_ms = max(1, int(1000 / max(1, fps)))
+        gif_path = work_dir / "interpolation.gif"
+        images[0].save(
+            gif_path,
+            save_all=True,
+            append_images=images[1:],
+            optimize=False,
+            duration=duration_ms,
+            loop=0,
+            disposal=2,
+        )
+
+        # Optional: cleanup RIFE output
+        try:
+            shutil.rmtree(OUTPUT_DIR)
+        except Exception:
+            pass
+
+        return str(gif_path)
+
+TITLE = "RIFE Interpolation → GIF (PyTorch, minimal)"
+with gr.Blocks(title=TITLE, analytics_enabled=False) as demo:
+    gr.Markdown(f"# {TITLE}")
+    with gr.Row():
+        with gr.Column():
+            img_a = gr.Image(type="pil", label="Image A")
+            img_b = gr.Image(type="pil", label="Image B")
+        with gr.Column():
+            fps = gr.Slider(6, 30, value=14, step=1, label="FPS")
+            exp = gr.Slider(1, 4, value=2, step=1, label="Interpolation exponent (2^exp frames)")
+            run = gr.Button("Interpolate", variant="primary")
+    gif_out = gr.Image(type="filepath", label="Result GIF")
+    run.click(interpolate, inputs=[img_a, img_b, fps, exp], outputs=[gif_out])
+    demo.queue(concurrency_count=1, max_size=8)
+
+if __name__ == "__main__":
+    demo.launch()