Upload app.py with huggingface_hub

app.py

@@ -1,4 +1,4 @@
-"""SAM 3D Objects – kaolin stubbed for ZeroGPU (PyTorch 2.10+cu128)."""
+"""SAM 3D Objects – kaolin+pytorch3d stubbed for ZeroGPU (PyTorch 2.10+cu128)."""
 import os, sys, subprocess
 os.environ.setdefault("CUDA_HOME", "/usr/local/cuda")
 os.environ.setdefault("CONDA_PREFIX", "/usr/local")
@@ -16,29 +16,33 @@ from pathlib import Path
 if os.environ.get("HF_TOKEN"):
     login(token=os.environ["HF_TOKEN"])
 
-# --- Kaolin stub (must be before sam3d imports) ---
-STUB = Path("/home/user/app/kaolin_stub")
-if STUB.exists():
-    sys.path.insert(0, str(STUB))
-    print("Kaolin stub path added")
+# --- Stubs (must be before sam3d imports) ---
+STUB_KAOLIN = Path("/home/user/app/kaolin_stub")
+STUB_PT3D = Path("/home/user/app/pytorch3d_stub")
+for stub in [STUB_KAOLIN, STUB_PT3D]:
+    if stub.exists():
+        sys.path.insert(0, str(stub))
+        print(f"Stub added: {stub.name}")
 
 # --- Runtime pip installs ---
 def _pip(*a):
     r = subprocess.run([sys.executable, "-m", "pip", "install", "--no-cache-dir"] + list(a),
                        capture_output=True, text=True, timeout=1200)
     ok = r.returncode == 0
-    if not ok:
-        print(f"  pip FAIL ({a[-1][:40]}): {r.stderr[-200:]}")
+    tag = a[-1][:50] if a else "?"
+    if ok:
+        print(f"  pip OK: {tag}")
     else:
-        print(f"  pip OK: {a[-1][:40]}")
+        print(f"  pip FAIL: {tag}")
+        print(f"    stderr: {r.stderr[-300:]}")
     return ok
 
 print("=== Runtime installs ===")
 _pip("open3d>=0.18.0")
-_pip("utils3d")
+# utils3d - pure Python wheel, install with verbose
+_pip("-v", "utils3d")
 _pip("iopath")
 _pip("--no-deps", "sam2>=1.1.0")
-_pip("--no-deps", "pytorch3d")
 _pip("--no-deps", "git+https://github.com/microsoft/MoGe.git@a8c37341bc0325ca99b9d57981cc3bb2bd3e255b")
 
 # gsplat
@@ -47,6 +51,14 @@ for idx in ["https://docs.gsplat.studio/whl/pt210cu128",
     if _pip("--no-deps", f"--extra-index-url={idx}", "gsplat"):
         break
 
+# Quick verify
+for mod in ["utils3d", "open3d", "gsplat", "kaolin", "pytorch3d"]:
+    try:
+        __import__(mod)
+        print(f"  import {mod}: OK")
+    except ImportError as e:
+        print(f"  import {mod}: FAIL - {e}")
+
 # --- Clone sam-3d-objects ---
 SAM3D_PATH = Path("/home/user/app/sam-3d-objects")
 if not SAM3D_PATH.exists():
@@ -77,73 +89,35 @@ if hf_ckpt.exists() and not local_ckpt.exists():
     local_ckpt.symlink_to(hf_ckpt)
 CONFIG_PATH = str(local_ckpt / "pipeline.yaml")
 print(f"Config exists: {Path(CONFIG_PATH).exists()}")
-
 print("=== Startup complete ===")
 
 # --- Endpoints ---
 
 @spaces.GPU(duration=60)
 def diagnose():
-    """Safe diagnostic - test each module individually."""
     import torch
     lines = [f"torch={torch.__version__}", f"cuda={torch.cuda.is_available()}"]
     if torch.cuda.is_available():
         lines.append(f"gpu={torch.cuda.get_device_name()}")
-
-    # Test each module safely
-    for mod_name in ["kaolin", "open3d", "utils3d", "iopath"]:
+    for mod in ["kaolin", "open3d", "utils3d", "iopath", "gsplat", "pytorch3d", "moge"]:
         try:
-            __import__(mod_name)
-            lines.append(f"{mod_name}: OK")
+            m = __import__(mod)
+            lines.append(f"{mod}: OK ({getattr(m, '__version__', '-')})")
         except Exception as e:
-            lines.append(f"{mod_name}: FAIL - {e}")
-
-    # Test sam2 (careful - no CUDA init at import)
+            lines.append(f"{mod}: FAIL - {e}")
     try:
         from sam2.automatic_mask_generator import SAM2AutomaticMaskGenerator
         lines.append("sam2: OK")
     except Exception as e:
         lines.append(f"sam2: FAIL - {e}")
-
-    # Test gsplat carefully
-    try:
-        import gsplat
-        lines.append(f"gsplat: OK ({gsplat.__version__})")
-    except Exception as e:
-        lines.append(f"gsplat: FAIL - {e}")
-
-    # Test pytorch3d carefully
-    try:
-        import pytorch3d
-        lines.append("pytorch3d: OK")
-    except Exception as e:
-        lines.append(f"pytorch3d: FAIL - {e}")
-
-    # Test MoGe
-    try:
-        import moge
-        lines.append("MoGe: OK")
-    except Exception as e:
-        lines.append(f"MoGe: FAIL - {e}")
-
-    # Test SAM3D inference
     try:
         from inference import Inference
-        lines.append("SAM3D inference: importable")
+        lines.append("SAM3D Inference: importable")
     except Exception as e:
-        lines.append(f"SAM3D inference: FAIL - {e}")
-
-    # Config exists?
+        lines.append(f"SAM3D Inference: FAIL - {e}")
     lines.append(f"config: {Path(CONFIG_PATH).exists()}")
-
     return "\n".join(lines)
 
-@spaces.GPU(duration=60)
-def diagnose_minimal():
-    """Absolutely minimal GPU test."""
-    import torch
-    return f"torch={torch.__version__}, cuda={torch.cuda.is_available()}, gpu={torch.cuda.get_device_name() if torch.cuda.is_available() else 'none'}"
-
 @spaces.GPU(duration=300)
 def reconstruct_objects(image: np.ndarray):
     if image is None:
@@ -153,14 +127,11 @@ def reconstruct_objects(image: np.ndarray):
         t0 = time.time()
         print(f"GPU: {torch.cuda.get_device_name()}")
 
-        # Load SAM2
         from sam2.automatic_mask_generator import SAM2AutomaticMaskGenerator
         sam2_gen = SAM2AutomaticMaskGenerator.from_pretrained("facebook/sam2-hiera-large")
-        print(f"  SAM2 ready ({time.time()-t0:.0f}s)")
+        print(f"  SAM2 loaded ({time.time()-t0:.0f}s)")
 
         image_np = np.array(image) if not isinstance(image, np.ndarray) else image
-
-        # Detect objects
         masks = sam2_gen.generate(image_np)
         if not masks:
             return None, image_np, "No objects detected"
@@ -169,21 +140,17 @@ def reconstruct_objects(image: np.ndarray):
 
         preview = image_np.copy()
         preview[best_mask] = (preview[best_mask] * 0.5 + np.array([0, 255, 0]) * 0.5).astype(np.uint8)
-        print(f"  {len(masks)} masks ({time.time()-t0:.0f}s)")
+        print(f"  {len(masks)} masks, largest area={masks[0]['area']} ({time.time()-t0:.0f}s)")
 
-        # Load SAM3D
         from inference import Inference
         sam3d = Inference(CONFIG_PATH, compile=False)
-        print(f"  SAM3D ready ({time.time()-t0:.0f}s)")
+        print(f"  SAM3D loaded ({time.time()-t0:.0f}s)")
 
-        # Reconstruct
         result = sam3d(image=image_np, mask=best_mask, seed=42)
         print(f"  Reconstructed ({time.time()-t0:.0f}s)")
-
         if result is None:
             return None, preview, "Reconstruction returned None"
 
-        # Export to GLB
         od = tempfile.mkdtemp()
         glb = f"{od}/object.glb"
 
@@ -191,7 +158,7 @@ def reconstruct_objects(image: np.ndarray):
         if hasattr(result, "save_ply"):
             gs = result
         elif isinstance(result, dict):
-            for k in ("gs", "gaussian", "gaussians"):
+            for k in ("gs", "gaussian", "gaussians", "scene"):
                 v = result.get(k)
                 if v is not None:
                     gs = v[0] if isinstance(v, (list, tuple)) else v
@@ -212,15 +179,22 @@ def reconstruct_objects(image: np.ndarray):
             pcd.estimate_normals()
             mesh, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=8)
             o3d.io.write_triangle_mesh(glb, mesh)
+        elif isinstance(result, dict) and "mesh" in result:
+            m = result["mesh"]
+            if hasattr(m, "export"):
+                m.export(glb)
+            else:
+                import open3d as o3d
+                o3d.io.write_triangle_mesh(glb, m)
         else:
-            return None, preview, f"Cannot extract 3D from {type(result)}"
+            keys = list(result.keys()) if isinstance(result, dict) else dir(result)
+            return None, preview, f"Cannot extract 3D. Keys: {keys}"
 
         n = 0
         try:
             n = len(trimesh.load(glb, force="mesh").faces)
         except Exception:
             pass
-
         elapsed = int(time.time() - t0)
         return glb, preview, f"OK: {len(masks)} objects, {n:,} faces ({elapsed}s)"
     except Exception as e:
@@ -245,12 +219,8 @@ with gr.Blocks(title="SAM 3D Objects") as demo:
         btn.click(reconstruct_objects, inputs=[inp], outputs=[m3d, prev, stat])
         m3d.change(lambda x: x, inputs=[m3d], outputs=[dl])
     with gr.Tab("Diagnose"):
-        dbtn = gr.Button("Full Diagnose")
+        dbtn = gr.Button("Diagnose GPU & Modules")
         dout = gr.Textbox(lines=15)
         dbtn.click(diagnose, outputs=[dout])
-        gr.Markdown("---")
-        mbtn = gr.Button("Minimal GPU Test")
-        mout = gr.Textbox(lines=3)
-        mbtn.click(diagnose_minimal, outputs=[mout])
 
 demo.launch(mcp_server=True)