fix 11

app.py

@@ -13,26 +13,64 @@
 
 import os
 import json
-import gradio as gr
+import logging
+import subprocess
 from pathlib import Path
+from typing import Optional, Tuple
+
+import gradio as gr
 
+# --------------------------------------------------------------------------------------
+# Early GPU/perf diagnostics (IMPORT FIRST so logs show even if pipeline import fails)
+# --------------------------------------------------------------------------------------
+logger = logging.getLogger("backgroundfx_pro")
+if not logger.handlers:
+    h = logging.StreamHandler()
+    h.setFormatter(logging.Formatter("[%(asctime)s] %(levelname)s: %(message)s"))
+    logger.addHandler(h)
+logger.setLevel(logging.INFO)
+
+# Try to load perf_tuning (forces CUDA or warns; sets cuDNN/TF32; logs banner)
+try:
+    import perf_tuning  # noqa: F401
+    logger.info("perf_tuning imported successfully.")
+except Exception as e:
+    logger.warning(f"perf_tuning not loaded: {e}")
+
+def _log_gpu_diag():
+    # Torch info
+    try:
+        import torch
+        logger.info(f"torch.__version__={torch.__version__} | torch.version.cuda={getattr(torch.version, 'cuda', None)}")
+        logger.info(f"torch.cuda.is_available()={torch.cuda.is_available()}")
+        if torch.cuda.is_available():
+            try:
+                idx = torch.cuda.current_device()
+                name = torch.cuda.get_device_name(idx)
+                cap = torch.cuda.get_device_capability(idx)
+                logger.info(f"Current CUDA device: {idx} | {name} | cc {cap[0]}.{cap[1]}")
+            except Exception as e:
+                logger.info(f"CUDA device query failed: {e}")
+    except Exception as e:
+        logger.warning(f"Could not import torch for GPU diag: {e}")
+
+    # nvidia-smi
+    try:
+        out = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True)
+        if out.returncode == 0:
+            logger.info("nvidia-smi -L:\n" + out.stdout.strip())
+        else:
+            logger.warning("nvidia-smi -L failed or unavailable.")
+    except Exception as e:
+        logger.warning(f"nvidia-smi not runnable: {e}")
+
+_log_gpu_diag()
+
+# --------------------------------------------------------------------------------------
 # Local pipeline
+# --------------------------------------------------------------------------------------
 import pipeline
 
-# --- Compact styling to resemble older v4 look ---
-CSS = """
-/* Narrow overall width */
-.gradio-container { max-width: 1200px !important; }
-
-/* Tighten gaps between elements */
-.gap-4, .gap-6, .gap-8 { gap: 0.5rem !important; }
-
-/* Keep video panels from growing too tall */
-#in_video video, #out_video video { max-height: 420px; }
-
-/* Trim markdown spacing */
-.prose h1 { margin-bottom: 0.5rem !important; }
-"""
 
 def _process_entry(video, bg_image, point_x, point_y, auto_box, progress=gr.Progress(track_tqdm=True)):
     """
@@ -59,18 +97,7 @@ def _process_entry(video, bg_image, point_x, point_y, auto_box, progress=gr.Prog
     return (out_path if out_path else None), json.dumps(diag, indent=2)
 
 
-with gr.Blocks(
-    title="BackgroundFX Pro (SAM2 + MatAnyone)",
-    theme=gr.themes.Soft(
-        primary_hue="blue",
-        radius_size=gr.themes.sizes.radius_sm,
-        spacing_size=gr.themes.sizes.spacing_sm,
-        text_size=gr.themes.sizes.text_md,
-    ),
-    css=CSS,
-    fill_height=True,
-    analytics_enabled=False
-) as demo:
+with gr.Blocks(title="BackgroundFX Pro (SAM2 + MatAnyone)", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
         # 🎬 BackgroundFX Pro
@@ -82,24 +109,10 @@ def _process_entry(video, bg_image, point_x, point_y, auto_box, progress=gr.Prog
         """
     )
 
-    with gr.Row(equal_height=True):
+    with gr.Row():
         with gr.Column(scale=2):
-            in_video = gr.Video(
-                label="Input Video",
-                sources=["upload"],
-                interactive=True,
-                elem_id="in_video",
-                show_label=True,
-                height=420,
-                autoplay=False
-            )
-            in_bg = gr.Image(
-                label="Background Image",
-                type="filepath",
-                interactive=True,
-                image_mode="RGB",
-                show_label=True
-            )
+            in_video = gr.Video(label="Input Video", sources=["upload"], interactive=True)
+            in_bg = gr.Image(label="Background Image", type="filepath", interactive=True)
         with gr.Column(scale=1):
             point_x = gr.Number(label="Foreground point X (optional)", value=None, precision=0)
             point_y = gr.Number(label="Foreground point Y (optional)", value=None, precision=0)
@@ -107,18 +120,11 @@ def _process_entry(video, bg_image, point_x, point_y, auto_box, progress=gr.Prog
             process_btn = gr.Button("Process", variant="primary")
 
     with gr.Row():
-        out_video = gr.Video(
-            label="Output (H.264 MP4)",
-            elem_id="out_video",
-            height=420,
-            autoplay=False,
-            show_download_button=True
-        )
-        out_diag = gr.JSON(label="Diagnostics", show_label=True)
+        out_video = gr.Video(label="Output (H.264 MP4)")
+        out_diag = gr.JSON(label="Diagnostics")
 
     def _on_click(video, bg, px, py, auto):
         v, d = _process_entry(video, bg, px, py, auto)
-        # Gradio's Video output expects a filepath; JSON expects dict (we have string)
         try:
             d_dict = json.loads(d)
         except Exception:
@@ -135,5 +141,5 @@ def _on_click(video, bg, px, py, auto):
     # Dynamic host/port via env; suitable defaults for Hugging Face Spaces
     host = os.environ.get("HOST", "0.0.0.0")
     port = int(os.environ.get("PORT", "7860"))
-    # Gradio 5.x: no concurrency_count
+    # NOTE: gradio>=5 removed concurrency_count; use max_size only
     demo.queue(max_size=16).launch(server_name=host, server_port=port, show_error=True)

pipeline.py

@@ -12,12 +12,12 @@
 - Fallbacks: MediaPipe SelfieSegmentation → else OpenCV GrabCut
 - H.264 MP4 output (ffmpeg when available; OpenCV fallback)
 - Audio mux: original audio copied into final output (AAC) if present
-- NEW: Stage-A transparent export (VP9 with alpha or checkerboard preview)
+- Stage-A transparent export (VP9 with alpha or checkerboard preview)
 
 Environment knobs (all optional):
 - THIRD_PARTY_SAM2_DIR, THIRD_PARTY_MATANY_DIR
 - SAM2_MODEL_CFG, SAM2_CHECKPOINT, SAM2_DEVICE
-- MATANY_REPO_ID, MATANY_CHECKPOINT, MATANY_DEVICE
+- MATANY_REPO_ID, MATANY_CHECKPOINT, MATANY_DEVICE, ENABLE_MATANY=1|0
 - FFMPEG_BIN
 - REFINE_GRABCUT=1 | 0                (enable/disable seed mask GrabCut refinement)
 - REFINE_GRABCUT_ITERS=2              (GrabCut iterations)
@@ -39,6 +39,7 @@
 import tempfile
 import logging
 import subprocess
+import inspect
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, Union
 
@@ -405,9 +406,15 @@ def _build_stage_a_checkerboard_from_mask(
     return ok_any
 
 # --------------------------------------------------------------------------------------
-# SAM2 Integration
+# SAM2 Integration (robust to different build_sam2 signatures)
 # --------------------------------------------------------------------------------------
 def load_sam2() -> Tuple[Optional[object], bool, Dict[str, Any]]:
+    """
+    Robust SAM2 loader that adapts to different build_sam2 signatures:
+    - config_file vs model_cfg
+    - checkpoint vs ckpt_path vs weights
+    - optional device kwarg
+    """
     meta = {"sam2_import_ok": False, "sam2_init_ok": False}
     try:
         from sam2.build_sam import build_sam2             # type: ignore
@@ -422,12 +429,50 @@ def load_sam2() -> Tuple[Optional[object], bool, Dict[str, Any]]:
     ckpt = os.environ.get("SAM2_CHECKPOINT", "")
 
     try:
-        sam = build_sam2(checkpoint=ckpt if ckpt else None, model_cfg=cfg, device=device)
+        params = set(inspect.signature(build_sam2).parameters.keys())
+        kwargs = {}
+
+        # Config arg
+        if "config_file" in params:
+            kwargs["config_file"] = cfg
+        elif "model_cfg" in params:
+            kwargs["model_cfg"] = cfg
+        else:
+            # if neither is present, try positional later
+            pass
+
+        # Checkpoint arg
+        if ckpt:
+            if "checkpoint" in params:
+                kwargs["checkpoint"] = ckpt
+            elif "ckpt_path" in params:
+                kwargs["ckpt_path"] = ckpt
+            elif "weights" in params:
+                kwargs["weights"] = ckpt
+
+        # Device (if supported via kwarg)
+        if "device" in params:
+            kwargs["device"] = device
+
+        # Try keyword call first
+        try:
+            sam = build_sam2(**kwargs)
+        except TypeError:
+            # Fallback to positional (cfg, ckpt?, device?)
+            pos = [cfg]
+            if ckpt:
+                pos.append(ckpt)
+            if "device" not in kwargs:
+                pos.append(device)
+            sam = build_sam2(*pos)
+
         predictor = SAM2ImagePredictor(sam)
-        meta["sam2_init_ok"] = True
-        meta["sam2_device"] = device
-        meta["sam2_cfg"] = cfg
-        meta["sam2_ckpt"] = ckpt or "(repo default)"
+        meta.update({
+            "sam2_init_ok": True,
+            "sam2_device": device,
+            "sam2_cfg": cfg,
+            "sam2_ckpt": ckpt or "(repo default)"
+        })
         return predictor, True, meta
     except Exception as e:
         logger.error(f"SAM2 init failed: {e}")
@@ -508,10 +553,23 @@ def _refine_mask_grabcut(image_bgr: np.ndarray,
         return m
 
 # --------------------------------------------------------------------------------------
-# MatAnyone Integration
+# MatAnyone Integration (robust + disable switch)
 # --------------------------------------------------------------------------------------
 def load_matany() -> Tuple[Optional[object], bool, Dict[str, Any]]:
+    """
+    MatAnyone loader that:
+    - Skips if ENABLE_MATANY=0
+    - Detects forks that require a `network` arg and exits cleanly with diagnostics
+    - Otherwise tries repo/checkpoint style constructors
+    """
     meta = {"matany_import_ok": False, "matany_init_ok": False}
+
+    enable_env = os.environ.get("ENABLE_MATANY", "1").strip().lower()
+    if enable_env in {"0", "false", "off", "no"}:
+        logger.info("MatAnyone disabled by ENABLE_MATANY=0.")
+        meta["disabled"] = True
+        return None, False, meta
+
     try:
         try:
             from inference_core import InferenceCore  # type: ignore
@@ -526,6 +584,20 @@ def load_matany() -> Tuple[Optional[object], bool, Dict[str, Any]]:
     repo_id = os.environ.get("MATANY_REPO_ID", "")
     ckpt = os.environ.get("MATANY_CHECKPOINT", "")
 
+    # If this fork needs a prebuilt network, tell the user and skip
+    try:
+        sig = inspect.signature(InferenceCore)
+        if "network" in sig.parameters and sig.parameters["network"].default is inspect._empty:
+            logger.error(
+                "This MatAnyone fork expects `InferenceCore(network=...)`. "
+                "Pin a fork/commit that supplies a checkpoint-based constructor, "
+                "or set ENABLE_MATANY=0 to skip."
+            )
+            meta["needs_network_arg"] = True
+            return None, False, meta
+    except Exception:
+        pass
+
     candidates = [
         {"kwargs": {"repo_id": repo_id or None, "checkpoint": ckpt or None, "device": device}},
         {"kwargs": {"checkpoint": ckpt or None, "device": device}},
@@ -544,7 +616,7 @@ def load_matany() -> Tuple[Optional[object], bool, Dict[str, Any]]:
             last_err = e
             continue
 
-    logger.error(f"MatAnyone init failed: {last_err}")
+    logger.error(f"MatAnyone init failed with all fallbacks: {last_err}")
     return None, False, meta
 
 def run_matany(matany: object,