Update app.py

app.py

@@ -46,6 +46,34 @@ from basicsr.utils.download_util import load_file_from_url
 from realesrgan import RealESRGANer
 from realesrgan.archs.srvgg_arch import SRVGGNetCompact
 
+_num = re.compile(r'(\d+)')
+
+def _natural_key(p: Path | str):
+    s = str(p)
+    return [int(t) if t.isdigit() else t.lower() for t in _num.split(s)]
+
+def sample_paths(paths: List[Path] | List[str], n: int = 30) -> List[str]:
+    """Evenly sample up to n items across the entire list, in order."""
+    if not paths:
+        return []
+    # Ensure stable numeric ordering first (00001, 00002, ... 01000)
+    paths = sorted(paths, key=_natural_key)
+    total = len(paths)
+    n = max(1, min(n, total))
+    if n == total:
+        return [str(p) for p in paths]
+    # Even spacing (no duplicates), covering start→end
+    step = (total - 1) / (n - 1)
+    idxs = [round(i * step) for i in range(n)]
+    # De-dupe in case of edge rounding on tiny sets
+    out = []
+    seen = set()
+    for i in idxs:
+        if i not in seen:
+            out.append(str(paths[i]))
+            seen.add(i)
+    return out
+    
 # Flag so UI can know if realesrgan is importable
 HAVE_REALESRGAN = True
 
@@ -158,13 +186,22 @@ def clamp_scale_for_model(outscale: int, model_id: str) -> int:
 
 
 def sample_paths(paths: List[Path] | List[str], n: int = 30) -> List[str]:
-    """Return up to n items sampled evenly across the list, preserving order (as strings)."""
+    """Evenly sample up to n items across the entire list (deterministic), in natural numeric order."""
     if not paths:
         return []
-    n = max(1, min(n, len(paths)))
-    idxs = np.linspace(0, len(paths) - 1, num=n, dtype=int).tolist()
-    idxs = sorted(dict.fromkeys(idxs))
-    return [str(paths[i]) for i in idxs]
+    paths = sorted(paths, key=_natural_key)  # ensure numeric order first
+    total = len(paths)
+    n = max(1, min(n, total))
+    if n == total:
+        return [str(p) for p in paths]
+    step = (total - 1) / (n - 1)  # cover both ends
+    idxs = [round(i * step) for i in range(n)]
+    out, seen = [], set()
+    for i in idxs:
+        if i not in seen:
+            out.append(str(paths[int(i)]))
+            seen.add(int(i))
+    return out
 
 
 def sanitize_prefix(txt: str) -> str:
@@ -281,6 +318,8 @@ def build_ffmpeg_extract(
     cmd += ["-frame_pts", "1", out_pattern]
     return cmd
 
+    frames = sorted(raw_dir.glob(f"{prefix}_*.{out_format}"), key=_natural_key)
+    gallery = sample_paths(frames, 30)
 
 def realesrgan(img, model_name, denoise_strength, face_enhance, outscale):
     if img is None:
@@ -480,8 +519,7 @@ def step1_extract(
                 last_html = render_progress(0.0, f"Extracting… {created} created")
     ret = proc.wait()
 
-    frames = sorted(raw_dir.glob(f"{prefix}_*.{out_format}"))
-    if ret != 0 or not frames:
+    frames = sorted(raw_dir.glob(f"{prefix}_*.{out_format}"), key=_natural_key)
         try:
             err = proc.stderr.read() if proc.stderr else ""
         except Exception:
@@ -516,14 +554,12 @@ def save_uploaded_images(files: List[gr.File] | None, prefix: str = "upload") ->
 
 def step2_upscale(
     frames_list: List[str] | None,
-    ui_model_name: str,
-    outscale: int,
+    model_name: str,
+    scale: int,
     tile: int,
     precision: str,
     prog_html: str,
     uploaded_imgs: List[gr.File] | None,
-    denoise_strength: float = 0.5, # NEW: accepted but currently unused
-    face_enhance: bool = False,    # NEW: accepted but currently unused (needs GFPGAN)
 ):
 
     # decide source: uploaded images take priority, else frames from step 1
@@ -534,7 +570,8 @@ def step2_upscale(
         src_paths = frames_list or []
 
     if not src_paths:
-        return None, None, "No images provided. Upload files or run Step 1 first.", prog_html
+        yield None, None, "No images provided. Upload files or run Step 1 first.", prog_html
+        return
 
     # Map demo model -> internal, clamp scale to supported values
     model_id = map_ui_model_to_internal(ui_model_name)
@@ -550,6 +587,8 @@ def step2_upscale(
     total = len(src_paths)
     done = 0
     up_paths: List[Path] = []
+
+    last_pct = -1
     for fp in src_paths:
         try:
             img = Image.open(fp).convert("RGB")
@@ -561,22 +600,29 @@ def step2_upscale(
         except Exception:
             pass
         done += 1
-        pct = (done/total)*100 if total else 0
-        prog_html = render_progress(pct, f"Upscaling {done}/{total}")
+        if total:
+            pct = int(round((done / total) * 100))
+            remaining = max(0, total - done)
+            if pct != last_pct:
+                label = f"Upscaling… {pct}% · {remaining}/{total} remaining"
+                prog_html = render_progress(pct, label)
+                # stream progress (gallery/zip stay None until the end)
+                yield None, None, label, prog_html
+                last_pct = pct
 
     if not up_paths:
-        return None, None, "Upscaling produced no outputs.", prog_html
+        yield None, None, "Upscaling produced no outputs.", prog_html
+        return
 
+    # Final outputs
     gallery = sample_paths(up_paths, 30)
     zip_path = work / "upscaled.zip"
     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
         for p in up_paths:
             zf.write(p, p.name)
 
-    detail = (f"Upscaled: {len(up_paths)} | Model: {ui_model_name}→{model_id} | "
-              f"Scale: x{scale} | Tile: {tile} | Precision: {precision}")
-    
-    return gallery, str(zip_path), f"Upscaled: {len(up_paths)}", render_progress(100.0, "Upscaling complete")
+    final_label = f"Upscaled: {len(up_paths)}"
+    yield gallery, str(zip_path), final_label, render_progress(100.0, "Upscaling complete")
 
 # ───────────────── Encode (Step 3) — supports uploaded frames/ZIP & optional audio source
 
@@ -752,7 +798,7 @@ def quick_mode(video: gr.File | None, start_time: str, end_time: str, resize_lon
             zf.write(p, p.name)
     zip_up = work / "upscaled.zip"
     with zipfile.ZipFile(zip_up, "w", zipfile.ZIP_DEFLATED) as zf:
-        for p in sorted(up_dir.glob("*.jpg")):
+        for p in sorted(up_dir.glob("*.jpg"), key=_natural_key):
             zf.write(p, p.name)
 
     return str(out_file), str(zip_frames), str(zip_up), "Quick Mode complete.", render_progress(100.0, "All done")