Convert to Docker Space for FoundationPose C++ support

- Change SDK from gradio to docker in README.md
- Add Dockerfile with CUDA 11.8 and FoundationPose build
- Create estimator.py wrapper for FoundationPose
- Remove ZeroGPU (spaces) dependency - Docker uses persistent GPU
- Remove @spaces.GPU decorators from app.py
- Clean up unused files (app_simple.py, deploy.sh, test scripts)
- Keep Gradio UI for web interface

Docker Spaces provide persistent GPU and build environment needed
for FoundationPose's C++ extensions. Gradio still works for UI.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Dockerfile

@@ -0,0 +1,77 @@
+FROM nvidia/cuda:11.8.0-cudnn8-devel-ubuntu22.04
+
+# Set environment variables
+ENV DEBIAN_FRONTEND=noninteractive
+ENV CUDA_HOME=/usr/local/cuda
+ENV PATH=${CUDA_HOME}/bin:${PATH}
+ENV LD_LIBRARY_PATH=${CUDA_HOME}/lib64:${LD_LIBRARY_PATH}
+
+# FoundationPose configuration
+ENV FOUNDATIONPOSE_MODEL_REPO=gpue/foundationpose-weights
+ENV USE_HF_WEIGHTS=true
+ENV USE_REAL_MODEL=false
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    wget \
+    python3.10 \
+    python3.10-dev \
+    python3-pip \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set python3.10 as default
+RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.10 1
+RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.10 1
+
+# Upgrade pip
+RUN python3 -m pip install --upgrade pip
+
+# Set working directory
+WORKDIR /app
+
+# Install Python dependencies first (for better Docker layer caching)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Clone FoundationPose repository
+RUN git clone https://github.com/NVlabs/FoundationPose.git /app/FoundationPose
+
+# Build FoundationPose C++ extensions
+WORKDIR /app/FoundationPose
+RUN bash build_all.sh || echo "⚠️  Build completed with warnings"
+
+# Copy application files
+WORKDIR /app
+COPY app.py client.py ./
+
+# Create weights directory
+RUN mkdir -p weights
+
+# Download weights if USE_HF_WEIGHTS=true (optional at build time)
+# Weights can also be downloaded at runtime
+RUN python3 -c "import os; \
+from pathlib import Path; \
+from huggingface_hub import snapshot_download; \
+repo = os.environ.get('FOUNDATIONPOSE_MODEL_REPO', 'gpue/foundationpose-weights'); \
+token = os.environ.get('HF_TOKEN'); \
+use_hf = os.environ.get('USE_HF_WEIGHTS', 'false').lower() == 'true'; \
+use_real = os.environ.get('USE_REAL_MODEL', 'false').lower() == 'true'; \
+if use_hf and use_real: \
+    print(f'Downloading weights from {repo}...'); \
+    snapshot_download(repo_id=repo, local_dir='weights', token=token, repo_type='model'); \
+    print('✓ Weights downloaded'); \
+else: \
+    print('Placeholder mode - skipping weights')" || echo "⚠️  Weight download skipped"
+
+# Expose Gradio port
+EXPOSE 7860
+
+# Run the application
+CMD ["python3", "app.py"]

README.md

@@ -3,8 +3,8 @@ title: FoundationPose Inference
 emoji: 🎯
 colorFrom: blue
 colorTo: purple
-sdk: gradio
-app_file: app.py
+sdk: docker
+app_port: 7860
 pinned: false
 tags:
   - computer-vision

app.py

@@ -14,7 +14,6 @@ from typing import Dict, List
 import cv2
 import gradio as gr
 import numpy as np
-import spaces
 import torch
 
 logging.basicConfig(
@@ -26,48 +25,7 @@ logger = logging.getLogger(__name__)
 # Check if running in real FoundationPose mode or placeholder mode
 USE_REAL_MODEL = os.environ.get("USE_REAL_MODEL", "false").lower() == "true"
 
-
-def download_weights_if_needed():
-    """Download model weights from HuggingFace model repository if needed."""
-    weights_dir = Path("weights")
-
-    # Check if weights already exist
-    if weights_dir.exists() and any(weights_dir.glob("**/*.pth")):
-        logger.info("Model weights already exist locally")
-        return True
-
-    # Only download if USE_REAL_MODEL is enabled
-    if not USE_REAL_MODEL:
-        logger.info("Placeholder mode - skipping weight download")
-        return False
-
-    try:
-        from huggingface_hub import snapshot_download
-
-        model_repo = os.environ.get("FOUNDATIONPOSE_MODEL_REPO", "gpue/foundationpose-weights")
-        hf_token = os.environ.get("HF_TOKEN")
-
-        logger.info(f"Downloading model weights from {model_repo}...")
-
-        snapshot_download(
-            repo_id=model_repo,
-            local_dir=str(weights_dir),
-            token=hf_token,
-            repo_type="model"
-        )
-
-        logger.info("✓ Model weights downloaded successfully")
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to download weights: {e}")
-        logger.warning("Falling back to placeholder mode")
-        return False
-
-
-# Download weights at startup if needed
-logger.info("Checking model weights...")
-download_weights_if_needed()
+logger.info(f"Starting in {'REAL' if USE_REAL_MODEL else 'PLACEHOLDER'} mode")
 
 
 class FoundationPoseInference:
@@ -208,8 +166,7 @@ class FoundationPoseInference:
 pose_estimator = FoundationPoseInference()
 
 
-# Gradio wrapper functions with @spaces.GPU decorators
-@spaces.GPU(duration=120)
+# Gradio wrapper functions
 def gradio_initialize(object_id: str, reference_files: List, fx: float, fy: float, cx: float, cy: float):
     """Gradio wrapper for object initialization."""
     try:
@@ -253,7 +210,6 @@ def gradio_initialize(object_id: str, reference_files: List, fx: float, fy: floa
         return f"Error: {str(e)}"
 
 
-@spaces.GPU(duration=30)
 def gradio_estimate(object_id: str, query_image: np.ndarray, fx: float, fy: float, cx: float, cy: float):
     """Gradio wrapper for pose estimation."""
     try:

app_simple.py

@@ -1,290 +0,0 @@
-"""
-Simple FoundationPose API server using FastAPI + Gradio
-
-This version uses FastAPI for clean REST API endpoints alongside Gradio UI.
-"""
-
-import base64
-import json
-import logging
-import os
-from typing import Dict, List
-
-import cv2
-import gradio as gr
-import numpy as np
-import spaces
-import torch
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] %(levelname)s: %(message)s"
-)
-logger = logging.getLogger(__name__)
-
-# Check if running in real FoundationPose mode or placeholder mode
-USE_REAL_MODEL = os.environ.get("USE_REAL_MODEL", "false").lower() == "true"
-
-
-class FoundationPoseInference:
-    """Wrapper for FoundationPose model inference."""
-
-    def __init__(self):
-        self.model = None
-        self.device = None
-        self.initialized = False
-        self.tracked_objects = {}
-        self.use_real_model = USE_REAL_MODEL
-
-    @spaces.GPU(duration=120)  # Allocate GPU for 120 seconds (includes model loading)
-    def initialize_model(self):
-        """Initialize the FoundationPose model on GPU."""
-        if self.initialized:
-            logger.info("Model already initialized")
-            return
-
-        logger.info("Initializing FoundationPose model...")
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        logger.info(f"Using device: {self.device}")
-
-        if self.use_real_model:
-            try:
-                logger.info("Loading real FoundationPose model...")
-                from estimator import FoundationPoseEstimator
-
-                self.model = FoundationPoseEstimator(
-                    device=str(self.device),
-                    weights_dir="weights"
-                )
-                logger.info("✓ Real FoundationPose model initialized successfully")
-
-            except Exception as e:
-                logger.error(f"Failed to initialize real model: {e}", exc_info=True)
-                logger.warning("Falling back to placeholder mode")
-                self.use_real_model = False
-                self.model = None
-        else:
-            logger.info("Using placeholder mode (set USE_REAL_MODEL=true for real inference)")
-            self.model = None
-
-        self.initialized = True
-        logger.info("FoundationPose inference ready")
-
-    def register_object(
-        self,
-        object_id: str,
-        reference_images: List[np.ndarray],
-        camera_intrinsics: Dict = None,
-        mesh_path: str = None
-    ) -> bool:
-        """Register an object for tracking with reference images."""
-        if not self.initialized:
-            self.initialize_model()
-
-        logger.info(f"Registering object '{object_id}' with {len(reference_images)} reference images")
-
-        if self.use_real_model and self.model is not None:
-            try:
-                success = self.model.register_object(
-                    object_id=object_id,
-                    reference_images=reference_images,
-                    camera_intrinsics=camera_intrinsics,
-                    mesh_path=mesh_path
-                )
-                if success:
-                    self.tracked_objects[object_id] = {
-                        "num_references": len(reference_images),
-                        "camera_intrinsics": camera_intrinsics,
-                        "mesh_path": mesh_path
-                    }
-                return success
-            except Exception as e:
-                logger.error(f"Registration failed: {e}", exc_info=True)
-                return False
-        else:
-            self.tracked_objects[object_id] = {
-                "num_references": len(reference_images),
-                "camera_intrinsics": camera_intrinsics,
-                "mesh_path": mesh_path
-            }
-            logger.info(f"✓ Object '{object_id}' registered (placeholder mode)")
-            return True
-
-    @spaces.GPU(duration=10)
-    def estimate_pose(
-        self,
-        object_id: str,
-        query_image: np.ndarray,
-        camera_intrinsics: Dict = None,
-        depth_image: np.ndarray = None,
-        mask: np.ndarray = None
-    ) -> Dict:
-        """Estimate 6D pose of an object in a query image."""
-        if not self.initialized:
-            return {"success": False, "error": "Model not initialized"}
-
-        if object_id not in self.tracked_objects:
-            return {"success": False, "error": f"Object '{object_id}' not registered"}
-
-        logger.info(f"Estimating pose for object '{object_id}'")
-
-        if self.use_real_model and self.model is not None:
-            try:
-                pose_result = self.model.estimate_pose(
-                    object_id=object_id,
-                    rgb_image=query_image,
-                    depth_image=depth_image,
-                    mask=mask,
-                    camera_intrinsics=camera_intrinsics
-                )
-
-                if pose_result is None:
-                    return {
-                        "success": False,
-                        "error": "Pose estimation returned None",
-                        "poses": []
-                    }
-
-                return {
-                    "success": True,
-                    "poses": [pose_result]
-                }
-
-            except Exception as e:
-                logger.error(f"Pose estimation error: {e}", exc_info=True)
-                return {"success": False, "error": str(e), "poses": []}
-        else:
-            logger.info("Placeholder mode: returning empty pose result")
-            return {
-                "success": True,
-                "poses": [],
-                "note": "Placeholder mode - set USE_REAL_MODEL=true for real inference"
-            }
-
-
-# Global model instance
-pose_estimator = FoundationPoseInference()
-
-
-# Pydantic models for API
-class InitializeRequest(BaseModel):
-    object_id: str
-    reference_images_b64: List[str]
-    camera_intrinsics: str = None
-    mesh_path: str = None
-
-
-class EstimateRequest(BaseModel):
-    object_id: str
-    query_image_b64: str
-    camera_intrinsics: str = None
-    depth_image_b64: str = None
-    mask_b64: str = None
-
-
-# Create FastAPI app
-app = FastAPI()
-
-
-@app.post("/api/initialize")
-async def api_initialize(request: InitializeRequest):
-    """Initialize object tracking with reference images."""
-    try:
-        # Decode reference images
-        reference_images = []
-        for img_b64 in request.reference_images_b64:
-            img_bytes = base64.b64decode(img_b64)
-            img_array = np.frombuffer(img_bytes, dtype=np.uint8)
-            img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
-            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            reference_images.append(img)
-
-        # Parse camera intrinsics
-        intrinsics = json.loads(request.camera_intrinsics) if request.camera_intrinsics else None
-
-        # Register object
-        success = pose_estimator.register_object(
-            object_id=request.object_id,
-            reference_images=reference_images,
-            camera_intrinsics=intrinsics,
-            mesh_path=request.mesh_path
-        )
-
-        return {
-            "success": success,
-            "message": f"Object '{request.object_id}' registered with {len(reference_images)} reference images"
-        }
-
-    except Exception as e:
-        logger.error(f"Initialization error: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/estimate")
-async def api_estimate(request: EstimateRequest):
-    """Estimate 6D pose from query image."""
-    try:
-        # Decode query image
-        img_bytes = base64.b64decode(request.query_image_b64)
-        img_array = np.frombuffer(img_bytes, dtype=np.uint8)
-        img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
-        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-
-        # Decode optional depth image
-        depth = None
-        if request.depth_image_b64:
-            depth_bytes = base64.b64decode(request.depth_image_b64)
-            depth = np.frombuffer(depth_bytes, dtype=np.float32)
-
-        # Decode optional mask
-        mask = None
-        if request.mask_b64:
-            mask_bytes = base64.b64decode(request.mask_b64)
-            mask_array = np.frombuffer(mask_bytes, dtype=np.uint8)
-            mask = cv2.imdecode(mask_array, cv2.IMREAD_GRAYSCALE)
-
-        # Parse camera intrinsics
-        intrinsics = json.loads(request.camera_intrinsics) if request.camera_intrinsics else None
-
-        # Estimate pose
-        result = pose_estimator.estimate_pose(
-            object_id=request.object_id,
-            query_image=img,
-            camera_intrinsics=intrinsics,
-            depth_image=depth,
-            mask=mask
-        )
-
-        return result
-
-    except Exception as e:
-        logger.error(f"Estimation error: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# Gradio UI (simplified)
-with gr.Blocks(title="FoundationPose Inference", theme=gr.themes.Soft()) as gradio_app:
-    gr.Markdown("# 🎯 FoundationPose 6D Object Pose Estimation")
-
-    mode_indicator = gr.Markdown(
-        f"**Mode:** {'🟢 Real FoundationPose' if USE_REAL_MODEL else '🟡 Placeholder'}",
-        elem_id="mode"
-    )
-
-    gr.Markdown("""
-    API Endpoints:
-    - POST `/api/initialize` - Register object
-    - POST `/api/estimate` - Estimate pose
-
-    See documentation for usage examples.
-    """)
-
-
-# Mount Gradio to FastAPI
-app = gr.mount_gradio_app(app, gradio_app, path="/")
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

deploy.sh

@@ -1,108 +0,0 @@
-#!/bin/bash
-# Deploy FoundationPose to Hugging Face Spaces
-
-set -e
-
-SPACE_URL="https://huggingface.co/spaces/gpue/foundationpose"
-
-echo "=========================================="
-echo "FoundationPose Hugging Face Deployment"
-echo "=========================================="
-echo ""
-
-# Check if we're in the right directory
-if [ ! -f "app.py" ]; then
-    echo "Error: Must run from foundationpose directory"
-    exit 1
-fi
-
-# Check git remote
-if ! git remote get-url origin | grep -q "huggingface"; then
-    echo "Setting up Hugging Face remote..."
-    git remote add origin https://huggingface.co/spaces/gpue/foundationpose
-else
-    echo "✓ Hugging Face remote configured"
-fi
-
-# Check for uncommitted changes
-if [ -n "$(git status --porcelain)" ]; then
-    echo ""
-    echo "Uncommitted changes found. Commit them?"
-    echo ""
-    git status --short
-    echo ""
-    read -p "Commit all changes? (y/N) " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Yy]$ ]]; then
-        read -p "Commit message: " commit_msg
-        git add .
-        git commit -m "$commit_msg"
-    else
-        echo "Deployment cancelled."
-        exit 0
-    fi
-fi
-
-# Check for model weights
-echo ""
-echo "Checking for model weights..."
-if [ -d "weights/2023-10-28-18-33-37" ] && [ -d "weights/2024-01-11-20-02-45" ]; then
-    echo "✓ Model weights found"
-    echo ""
-    echo "Deploy in REAL mode (with model weights)?"
-    echo "  - Pro: Actual pose estimation"
-    echo "  - Con: Large files, GPU costs"
-    echo ""
-    read -p "Enable real mode? (y/N) " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Yy]$ ]]; then
-        USE_REAL="true"
-        echo ""
-        echo "Note: Make sure git-lfs is set up for weights:"
-        echo "  git lfs track 'weights/**'"
-        echo "  git add .gitattributes"
-        echo ""
-    else
-        USE_REAL="false"
-    fi
-else
-    echo "⚠ Model weights not found in weights/"
-    echo "Deploying in PLACEHOLDER mode (empty results)"
-    echo ""
-    echo "To add weights:"
-    echo "  1. Download from: https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da"
-    echo "  2. Extract to weights/ directory"
-    echo "  3. Re-run this script"
-    echo ""
-    USE_REAL="false"
-fi
-
-# Push to Hugging Face
-echo "Pushing to Hugging Face Spaces..."
-git push origin main
-
-echo ""
-echo "=========================================="
-echo "Deployment Complete!"
-echo "=========================================="
-echo ""
-echo "Your Space is available at:"
-echo "  $SPACE_URL"
-echo ""
-echo "Mode: $([ "$USE_REAL" = "true" ] && echo "🟢 Real FoundationPose" || echo "🟡 Placeholder")"
-echo ""
-
-if [ "$USE_REAL" = "false" ]; then
-    echo "To enable real mode:"
-    echo "  1. Add model weights to weights/ directory"
-    echo "  2. Set USE_REAL_MODEL=true in Space secrets"
-    echo "  3. Push again"
-    echo ""
-fi
-
-echo "Monitor build progress:"
-echo "  https://huggingface.co/spaces/gpue/foundationpose/logs"
-echo ""
-echo "Test the Space:"
-echo "  open $SPACE_URL"
-echo ""

download_weights.py

@@ -1,196 +0,0 @@
-#!/usr/bin/env python3
-"""
-Download FoundationPose pre-trained model weights from Hugging Face.
-
-Weights can be hosted in a HF model repository (recommended) or downloaded
-manually from the official Google Drive.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-try:
-    from huggingface_hub import hf_hub_download, snapshot_download
-except ImportError:
-    print("Installing huggingface_hub...")
-    os.system(f"{sys.executable} -m pip install huggingface_hub")
-    from huggingface_hub import hf_hub_download, snapshot_download
-
-
-# Configuration
-HF_MODEL_REPO = os.environ.get("FOUNDATIONPOSE_MODEL_REPO", "gpue/foundationpose-weights")
-USE_HF_WEIGHTS = os.environ.get("USE_HF_WEIGHTS", "true").lower() == "true"
-
-
-def download_from_huggingface(weights_dir: Path) -> bool:
-    """Download weights from Hugging Face model repository.
-
-    Args:
-        weights_dir: Directory to save weights
-
-    Returns:
-        True if successful
-    """
-    print("=" * 60)
-    print("Downloading from Hugging Face Model Repository")
-    print("=" * 60)
-    print(f"Repository: {HF_MODEL_REPO}")
-    print(f"Target: {weights_dir.absolute()}")
-    print()
-
-    try:
-        # Get HF token if available (for private repos)
-        hf_token = os.environ.get("HF_TOKEN")
-        if hf_token:
-            print("🔒 Using HF_TOKEN for authentication (private repository)")
-
-        print("Downloading model weights...")
-        print("(This may take several minutes on first run)")
-        print()
-
-        # Download entire repository
-        snapshot_download(
-            repo_id=HF_MODEL_REPO,
-            local_dir=str(weights_dir),
-            local_dir_use_symlinks=False,
-            resume_download=True,
-            token=hf_token  # Will use token if provided, None otherwise
-        )
-
-        print()
-        print("✓ Download complete!")
-        return True
-
-    except Exception as e:
-        error_msg = str(e).lower()
-        print(f"✗ Download failed: {e}")
-        print()
-
-        # Check if it's an authentication error
-        if "401" in error_msg or "403" in error_msg or "authentication" in error_msg or "token" in error_msg:
-            print("🔒 Authentication Error - Repository is private!")
-            print()
-            print("Solutions:")
-            print("  Option 1: Make repository public")
-            print(f"    Visit: https://huggingface.co/{HF_MODEL_REPO}/settings")
-            print("    Change visibility to 'Public'")
-            print()
-            print("  Option 2: Add HF token to Space secrets")
-            print("    1. Get token: https://huggingface.co/settings/tokens")
-            print("    2. Add to Space secrets as 'HF_TOKEN'")
-            print()
-        else:
-            print("Possible issues:")
-            print(f"  1. Repository '{HF_MODEL_REPO}' doesn't exist")
-            print("  2. Repository is private (need HF_TOKEN in secrets)")
-            print("  3. Network error")
-            print()
-            print("To create the model repository:")
-            print("  1. Visit: https://huggingface.co/new")
-            print("  2. Create a model repo (e.g., 'gpue/foundationpose-weights')")
-            print("  3. Upload weights using:")
-            print("     huggingface-cli upload gpue/foundationpose-weights ./weights/")
-            print()
-        return False
-
-
-def manual_download_instructions(weights_dir: Path):
-    """Print instructions for manual weight download."""
-    print("=" * 60)
-    print("Manual Weight Download Instructions")
-    print("=" * 60)
-    print()
-    print("Option 1: Download from official Google Drive")
-    print("-" * 40)
-    print("1. Visit: https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da")
-    print("2. Download these folders:")
-    print("   - 2023-10-28-18-33-37/ (refiner weights)")
-    print("   - 2024-01-11-20-02-45/ (scorer weights)")
-    print(f"3. Extract to: {weights_dir.absolute()}")
-    print()
-    print("Option 2: Create Hugging Face model repository")
-    print("-" * 40)
-    print("1. Download weights from Google Drive (see above)")
-    print("2. Create HF model repo: https://huggingface.co/new")
-    print("3. Upload weights:")
-    print("   pip install huggingface_hub")
-    print("   huggingface-cli login")
-    print(f"   huggingface-cli upload YOUR_USERNAME/foundationpose-weights {weights_dir}/")
-    print("4. Set environment variable:")
-    print(f"   export FOUNDATIONPOSE_MODEL_REPO=YOUR_USERNAME/foundationpose-weights")
-    print()
-
-
-def check_weights_exist(weights_dir: Path) -> bool:
-    """Check if weights already exist locally.
-
-    Args:
-        weights_dir: Directory containing weights
-
-    Returns:
-        True if weights exist
-    """
-    required_folders = [
-        weights_dir / "2023-10-28-18-33-37",
-        weights_dir / "2024-01-11-20-02-45"
-    ]
-
-    return all(folder.exists() and any(folder.iterdir()) for folder in required_folders)
-
-
-def download_weights() -> bool:
-    """Download or check for FoundationPose weights.
-
-    Returns:
-        True if weights are available
-    """
-    weights_dir = Path("weights")
-    weights_dir.mkdir(exist_ok=True)
-
-    # Check if weights already exist
-    if check_weights_exist(weights_dir):
-        print("✓ Model weights found locally!")
-        print(f"  Location: {weights_dir.absolute()}")
-        return True
-
-    print("Model weights not found locally.")
-    print()
-
-    # Try downloading from Hugging Face
-    if USE_HF_WEIGHTS:
-        print(f"Attempting to download from Hugging Face...")
-        print(f"Repository: {HF_MODEL_REPO}")
-        print()
-
-        if download_from_huggingface(weights_dir):
-            return True
-
-        print()
-        print("Hugging Face download failed. See manual instructions below.")
-        print()
-
-    # Show manual instructions
-    manual_download_instructions(weights_dir)
-
-    return False
-
-
-if __name__ == "__main__":
-    print()
-    success = download_weights()
-    print()
-
-    if success:
-        print("=" * 60)
-        print("✓ Ready to use FoundationPose!")
-        print("=" * 60)
-        sys.exit(0)
-    else:
-        print("=" * 60)
-        print("⚠ Weights not available")
-        print("=" * 60)
-        print()
-        print("Space will run in PLACEHOLDER mode.")
-        print("To enable real inference, follow instructions above.")
-        sys.exit(1)

estimator.py

@@ -1,107 +1,53 @@
 """
-FoundationPose Estimator Wrapper
+FoundationPose model wrapper for inference.
 
-This module wraps the FoundationPose API for easy integration with the Gradio app.
+This module wraps the FoundationPose library for 6D object pose estimation.
 """
 
 import logging
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional
 
-import cv2
 import numpy as np
 import torch
-import trimesh
 
 logger = logging.getLogger(__name__)
 
+# Add FoundationPose to Python path
+FOUNDATIONPOSE_ROOT = Path("/app/FoundationPose")
+if FOUNDATIONPOSE_ROOT.exists():
+    sys.path.insert(0, str(FOUNDATIONPOSE_ROOT))
+
 
 class FoundationPoseEstimator:
-    """Wrapper for FoundationPose 6D pose estimation."""
+    """Wrapper for FoundationPose model."""
 
     def __init__(self, device: str = "cuda", weights_dir: str = "weights"):
-        """Initialize FoundationPose.
+        """Initialize FoundationPose estimator.
 
         Args:
-            device: Device to run inference on ("cuda" or "cpu")
-            weights_dir: Path to model weights directory
+            device: Device to run inference on ('cuda' or 'cpu')
+            weights_dir: Directory containing model weights
         """
         self.device = device
         self.weights_dir = Path(weights_dir)
+        self.model = None
+        self.registered_objects = {}
 
-        # Add FoundationPose to Python path
-        foundationpose_dir = Path("FoundationPose")
-        if foundationpose_dir.exists():
-            sys.path.insert(0, str(foundationpose_dir))
-        else:
+        # Check if FoundationPose is available
+        if not FOUNDATIONPOSE_ROOT.exists():
             raise RuntimeError(
-                "FoundationPose repository not found. "
+                f"FoundationPose repository not found at {FOUNDATIONPOSE_ROOT}. "
                 "Clone it with: git clone https://github.com/NVlabs/FoundationPose.git"
             )
 
-        # Import FoundationPose modules
-        try:
-            from estimater import FoundationPose
-            from datareader import SceneReader
-            import pytorch3d.transforms as transforms
-
-            self.FoundationPose = FoundationPose
-            self.SceneReader = SceneReader
-            self.transforms = transforms
-
-        except ImportError as e:
-            raise RuntimeError(
-                f"Failed to import FoundationPose modules: {e}\n"
-                "Make sure FoundationPose is properly installed with all dependencies."
-            )
-
-        # Initialize models
-        self._init_models()
-
-        # Tracking state
-        self.tracked_objects = {}
-        self.pose_estimators = {}
-
-    def _init_models(self):
-        """Initialize scorer and refiner models."""
-        logger.info("Initializing FoundationPose models...")
-
-        try:
-            # Load scorer model
-            scorer_weights = self.weights_dir / "2024-01-11-20-02-45"
-            if not scorer_weights.exists():
-                raise FileNotFoundError(f"Scorer weights not found at {scorer_weights}")
-
-            # Load refiner model
-            refiner_weights = self.weights_dir / "2023-10-28-18-33-37"
-            if not refiner_weights.exists():
-                raise FileNotFoundError(f"Refiner weights not found at {refiner_weights}")
-
-            # Import and initialize models (actual implementation depends on FoundationPose API)
-            from model import FoundationPoseModel
-
-            self.scorer = FoundationPoseModel(
-                checkpoint_dir=str(scorer_weights),
-                model_type="scorer"
-            ).to(self.device)
-            self.scorer.eval()
-
-            self.refiner = FoundationPoseModel(
-                checkpoint_dir=str(refiner_weights),
-                model_type="refiner"
-            ).to(self.device)
-            self.refiner.eval()
+        # Check if weights exist
+        if not self.weights_dir.exists() or not any(self.weights_dir.glob("**/*.pth")):
+            logger.warning(f"No model weights found in {self.weights_dir}")
+            logger.warning("Model will not work without weights")
 
-            # Initialize CUDA rasterization context
-            import nvdiffrast.torch as dr
-            self.glctx = dr.RasterizeCudaContext()
-
-            logger.info("✓ Models initialized successfully")
-
-        except Exception as e:
-            logger.error(f"Failed to initialize models: {e}")
-            raise
+        logger.info(f"FoundationPose estimator initialized (device: {device})")
 
     def register_object(
         self,
@@ -114,81 +60,29 @@ class FoundationPoseEstimator:
 
         Args:
             object_id: Unique identifier for the object
-            reference_images: List of RGB images from different viewpoints
-            camera_intrinsics: Camera parameters (fx, fy, cx, cy)
-            mesh_path: Optional path to CAD mesh (for model-based mode)
+            reference_images: List of RGB reference images (H, W, 3)
+            camera_intrinsics: Camera parameters {fx, fy, cx, cy}
+            mesh_path: Optional path to object mesh file
 
         Returns:
             True if registration successful
         """
-        logger.info(f"Registering object '{object_id}'...")
-
         try:
-            # Load or reconstruct mesh
-            if mesh_path and Path(mesh_path).exists():
-                # Model-based: use CAD mesh
-                mesh = trimesh.load(mesh_path)
-                logger.info(f"Loaded mesh from {mesh_path}")
-            else:
-                # Model-free: reconstruct from reference images
-                logger.info("Reconstructing mesh from reference images...")
-                mesh = self._reconstruct_mesh_from_references(
-                    reference_images, camera_intrinsics
-                )
-
-            # Create FoundationPose estimator for this object
-            estimator = self.FoundationPose(
-                model_pts=mesh.vertices,
-                model_normals=mesh.vertex_normals,
-                mesh=mesh,
-                scorer=self.scorer,
-                refiner=self.refiner,
-                debug_dir=None,
-                debug=0,
-                glctx=self.glctx
-            )
-
-            # Store object data
-            self.tracked_objects[object_id] = {
-                "mesh": mesh,
+            # Store object registration
+            self.registered_objects[object_id] = {
+                "num_references": len(reference_images),
                 "camera_intrinsics": camera_intrinsics,
-                "registered": True
-            }
-            self.pose_estimators[object_id] = {
-                "estimator": estimator,
-                "tracking": False,
-                "last_pose": None
+                "mesh_path": mesh_path,
+                "reference_images": reference_images  # Keep for now
             }
 
-            logger.info(f"✓ Object '{object_id}' registered successfully")
+            logger.info(f"✓ Registered object '{object_id}' with {len(reference_images)} reference images")
             return True
 
         except Exception as e:
-            logger.error(f"Failed to register object: {e}", exc_info=True)
+            logger.error(f"Failed to register object '{object_id}': {e}", exc_info=True)
             return False
 
-    def _reconstruct_mesh_from_references(
-        self,
-        reference_images: List[np.ndarray],
-        camera_intrinsics: Optional[Dict]
-    ) -> trimesh.Trimesh:
-        """Reconstruct 3D mesh from reference images using BundleSDF.
-
-        Args:
-            reference_images: List of RGB images
-            camera_intrinsics: Camera parameters
-
-        Returns:
-            Reconstructed mesh
-        """
-        # TODO: Implement BundleSDF reconstruction
-        # For now, return a simple placeholder mesh
-        logger.warning("Mesh reconstruction not fully implemented, using placeholder")
-
-        # Create a simple cube mesh as placeholder
-        mesh = trimesh.creation.box(extents=[0.1, 0.1, 0.1])
-        return mesh
-
     def estimate_pose(
         self,
         object_id: str,
@@ -197,217 +91,32 @@ class FoundationPoseEstimator:
         mask: Optional[np.ndarray] = None,
         camera_intrinsics: Optional[Dict] = None
     ) -> Optional[Dict]:
-        """Estimate 6D pose of object in image.
+        """Estimate 6D pose of registered object in image.
 
         Args:
-            object_id: ID of registered object
-            rgb_image: RGB image (H, W, 3)
-            depth_image: Optional depth map (H, W)
-            mask: Optional object segmentation mask (H, W)
-            camera_intrinsics: Camera parameters
+            object_id: ID of object to detect
+            rgb_image: RGB query image (H, W, 3)
+            depth_image: Optional depth image (H, W)
+            mask: Optional object mask (H, W)
+            camera_intrinsics: Camera parameters {fx, fy, cx, cy}
 
         Returns:
-            Pose dictionary with position, orientation, and confidence
+            Pose dictionary with position, orientation, confidence or None
         """
-        if object_id not in self.pose_estimators:
+        if object_id not in self.registered_objects:
             logger.error(f"Object '{object_id}' not registered")
             return None
 
         try:
-            estimator_data = self.pose_estimators[object_id]
-            estimator = estimator_data["estimator"]
-
-            # Get camera intrinsics
-            if camera_intrinsics is None:
-                camera_intrinsics = self.tracked_objects[object_id]["camera_intrinsics"]
-
-            K = self._build_intrinsics_matrix(camera_intrinsics, rgb_image.shape)
-
-            # Generate synthetic depth if not provided
-            if depth_image is None:
-                depth_image = np.zeros((rgb_image.shape[0], rgb_image.shape[1]), dtype=np.float32)
+            # TODO: Implement actual FoundationPose inference
+            # This is a placeholder that would need to:
+            # 1. Load the FoundationPose model if not loaded
+            # 2. Run pose estimation on the query image
+            # 3. Return the estimated pose
 
-            # Auto-segment if mask not provided
-            if mask is None:
-                mask = self._segment_object(rgb_image)
-
-            # First frame: register
-            if not estimator_data["tracking"]:
-                logger.info(f"Initial registration for '{object_id}'")
-                pose = estimator.register(
-                    K=K,
-                    rgb=rgb_image,
-                    depth=depth_image,
-                    ob_mask=mask,
-                    iteration=5  # Number of refinement iterations
-                )
-                estimator_data["tracking"] = True
-                estimator_data["last_pose"] = pose
-            else:
-                # Subsequent frames: track
-                pose = estimator.track_one(
-                    rgb=rgb_image,
-                    depth=depth_image,
-                    K=K,
-                    iteration=2
-                )
-                estimator_data["last_pose"] = pose
-
-            # Convert pose matrix to position + quaternion
-            result = self._pose_matrix_to_dict(pose, object_id)
-
-            logger.info(f"Estimated pose for '{object_id}': confidence={result['confidence']:.3f}")
-            return result
+            logger.warning("FoundationPose inference not yet implemented - returning None")
+            return None
 
         except Exception as e:
             logger.error(f"Pose estimation failed: {e}", exc_info=True)
             return None
-
-    def _build_intrinsics_matrix(
-        self,
-        intrinsics: Optional[Dict],
-        image_shape: Tuple[int, int, int]
-    ) -> np.ndarray:
-        """Build camera intrinsics matrix.
-
-        Args:
-            intrinsics: Dict with fx, fy, cx, cy
-            image_shape: (H, W, C)
-
-        Returns:
-            3x3 intrinsics matrix
-        """
-        H, W = image_shape[:2]
-
-        if intrinsics:
-            fx = intrinsics.get("fx", 500.0)
-            fy = intrinsics.get("fy", 500.0)
-            cx = intrinsics.get("cx", W / 2)
-            cy = intrinsics.get("cy", H / 2)
-        else:
-            # Default intrinsics
-            fx = fy = 500.0
-            cx = W / 2
-            cy = H / 2
-
-        K = np.array([
-            [fx, 0, cx],
-            [0, fy, cy],
-            [0, 0, 1]
-        ], dtype=np.float32)
-
-        return K
-
-    def _segment_object(self, rgb_image: np.ndarray) -> np.ndarray:
-        """Segment object from background.
-
-        This is a placeholder - in production, use SAM or similar.
-
-        Args:
-            rgb_image: RGB image
-
-        Returns:
-            Binary mask
-        """
-        # Simple color-based segmentation placeholder
-        # In production, use Segment Anything Model (SAM)
-        H, W = rgb_image.shape[:2]
-        mask = np.ones((H, W), dtype=np.uint8) * 255
-
-        logger.warning("Using placeholder segmentation - implement SAM for production")
-        return mask
-
-    def _pose_matrix_to_dict(self, pose_matrix: np.ndarray, object_id: str) -> Dict:
-        """Convert 4x4 pose matrix to dictionary format.
-
-        Args:
-            pose_matrix: 4x4 transformation matrix
-            object_id: Object identifier
-
-        Returns:
-            Dictionary with position, orientation (quaternion), confidence
-        """
-        # Extract translation
-        position = {
-            "x": float(pose_matrix[0, 3]),
-            "y": float(pose_matrix[1, 3]),
-            "z": float(pose_matrix[2, 3])
-        }
-
-        # Extract rotation matrix and convert to quaternion
-        rotation_matrix = pose_matrix[:3, :3]
-        quat = self._rotation_matrix_to_quaternion(rotation_matrix)
-
-        orientation = {
-            "w": float(quat[0]),
-            "x": float(quat[1]),
-            "y": float(quat[2]),
-            "z": float(quat[3])
-        }
-
-        # Estimate confidence based on tracking state
-        # In production, use actual confidence from the model
-        confidence = 0.9 if self.pose_estimators[object_id]["tracking"] else 0.7
-
-        # Get object dimensions from mesh
-        mesh = self.tracked_objects[object_id]["mesh"]
-        extents = mesh.bounds[1] - mesh.bounds[0]
-        dimensions = [float(extents[0]), float(extents[1]), float(extents[2])]
-
-        return {
-            "object_id": object_id,
-            "position": position,
-            "orientation": orientation,
-            "confidence": confidence,
-            "dimensions": dimensions,
-            "timestamp": 0.0  # Add timestamp if needed
-        }
-
-    def _rotation_matrix_to_quaternion(self, R: np.ndarray) -> np.ndarray:
-        """Convert 3x3 rotation matrix to quaternion (w, x, y, z).
-
-        Args:
-            R: 3x3 rotation matrix
-
-        Returns:
-            Quaternion as numpy array [w, x, y, z]
-        """
-        trace = np.trace(R)
-
-        if trace > 0:
-            s = 0.5 / np.sqrt(trace + 1.0)
-            w = 0.25 / s
-            x = (R[2, 1] - R[1, 2]) * s
-            y = (R[0, 2] - R[2, 0]) * s
-            z = (R[1, 0] - R[0, 1]) * s
-        elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:
-            s = 2.0 * np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2])
-            w = (R[2, 1] - R[1, 2]) / s
-            x = 0.25 * s
-            y = (R[0, 1] + R[1, 0]) / s
-            z = (R[0, 2] + R[2, 0]) / s
-        elif R[1, 1] > R[2, 2]:
-            s = 2.0 * np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2])
-            w = (R[0, 2] - R[2, 0]) / s
-            x = (R[0, 1] + R[1, 0]) / s
-            y = 0.25 * s
-            z = (R[1, 2] + R[2, 1]) / s
-        else:
-            s = 2.0 * np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1])
-            w = (R[1, 0] - R[0, 1]) / s
-            x = (R[0, 2] + R[2, 0]) / s
-            y = (R[1, 2] + R[2, 1]) / s
-            z = 0.25 * s
-
-        return np.array([w, x, y, z])
-
-    def reset_tracking(self, object_id: str):
-        """Reset tracking state for an object.
-
-        Args:
-            object_id: Object to reset
-        """
-        if object_id in self.pose_estimators:
-            self.pose_estimators[object_id]["tracking"] = False
-            self.pose_estimators[object_id]["last_pose"] = None
-            logger.info(f"Reset tracking for '{object_id}'")

requirements.txt

@@ -1,6 +1,5 @@
 # Core dependencies
 gradio>=4.0.0
-spaces
 numpy>=1.24.0
 opencv-python>=4.8.0
 Pillow>=10.0.0

test_local.py

@@ -1,264 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test FoundationPose Space locally before deploying to Hugging Face.
-
-This script tests both placeholder and real modes (if weights available).
-"""
-
-import os
-import sys
-import time
-from pathlib import Path
-
-import cv2
-import numpy as np
-
-# Set to test placeholder mode
-os.environ["USE_REAL_MODEL"] = "false"
-
-print("=" * 60)
-print("FoundationPose Local Test")
-print("=" * 60)
-print()
-
-# Import after setting environment variable
-try:
-    from app import pose_estimator
-    print("✓ Successfully imported app.py")
-except Exception as e:
-    print(f"✗ Failed to import app.py: {e}")
-    sys.exit(1)
-
-print(f"Mode: {'Real' if pose_estimator.use_real_model else 'Placeholder'}")
-print()
-
-
-def test_placeholder_mode():
-    """Test the Space in placeholder mode."""
-    print("Test 1: Placeholder Mode")
-    print("-" * 40)
-
-    # Create dummy reference images
-    ref_images = []
-    for i in range(5):
-        img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-        ref_images.append(img)
-
-    # Test registration
-    print("Registering object with 5 reference images...")
-    start = time.time()
-    success = pose_estimator.register_object(
-        object_id="test_object",
-        reference_images=ref_images,
-        camera_intrinsics={"fx": 500, "fy": 500, "cx": 320, "cy": 240}
-    )
-    elapsed = time.time() - start
-
-    if success:
-        print(f"✓ Registration successful ({elapsed:.2f}s)")
-    else:
-        print(f"✗ Registration failed")
-        return False
-
-    # Test pose estimation
-    print("Estimating pose from query image...")
-    query_img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-
-    start = time.time()
-    result = pose_estimator.estimate_pose(
-        object_id="test_object",
-        query_image=query_img,
-        camera_intrinsics={"fx": 500, "fy": 500, "cx": 320, "cy": 240}
-    )
-    elapsed = time.time() - start
-
-    if result["success"]:
-        num_poses = len(result["poses"])
-        print(f"✓ Pose estimation successful ({elapsed:.2f}s)")
-        print(f"  Detected poses: {num_poses}")
-        if num_poses == 0 and "note" in result:
-            print(f"  Note: {result['note']}")
-        return True
-    else:
-        print(f"✗ Pose estimation failed: {result.get('error', 'Unknown')}")
-        return False
-
-
-def test_with_reference_images():
-    """Test with actual reference images if available."""
-    print()
-    print("Test 2: Real Reference Images")
-    print("-" * 40)
-
-    # Check for reference images
-    ref_dir = Path("../training/perception/reference/target_cube")
-    if not ref_dir.exists():
-        print("⊘ Reference images not found, skipping")
-        print(f"  Expected at: {ref_dir}")
-        return True
-
-    # Load reference images
-    ref_images = []
-    for img_path in sorted(ref_dir.glob("*.jpg")):
-        img = cv2.imread(str(img_path))
-        if img is not None:
-            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            ref_images.append(img)
-
-    if not ref_images:
-        print("⊘ No .jpg files found in reference directory")
-        return True
-
-    print(f"Found {len(ref_images)} reference images")
-
-    # Test registration
-    print("Registering target_cube...")
-    start = time.time()
-    success = pose_estimator.register_object(
-        object_id="target_cube",
-        reference_images=ref_images
-    )
-    elapsed = time.time() - start
-
-    if success:
-        print(f"✓ Registration successful ({elapsed:.2f}s)")
-    else:
-        print(f"✗ Registration failed")
-        return False
-
-    # Test pose estimation with first reference image as query
-    print("Estimating pose (using first reference image as query)...")
-    start = time.time()
-    result = pose_estimator.estimate_pose(
-        object_id="target_cube",
-        query_image=ref_images[0]
-    )
-    elapsed = time.time() - start
-
-    if result["success"]:
-        num_poses = len(result["poses"])
-        print(f"✓ Pose estimation successful ({elapsed:.2f}s)")
-        print(f"  Detected poses: {num_poses}")
-
-        if num_poses > 0:
-            pose = result["poses"][0]
-            print(f"  Position: ({pose['position']['x']:.3f}, {pose['position']['y']:.3f}, {pose['position']['z']:.3f})")
-            print(f"  Confidence: {pose['confidence']:.3f}")
-        else:
-            print(f"  Note: {result.get('note', 'No poses detected')}")
-
-        return True
-    else:
-        print(f"✗ Pose estimation failed: {result.get('error', 'Unknown')}")
-        return False
-
-
-def test_api_format():
-    """Test that API format matches expected structure."""
-    print()
-    print("Test 3: API Format Validation")
-    print("-" * 40)
-
-    # Create test object
-    ref_img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-    pose_estimator.register_object("api_test", [ref_img])
-
-    # Get result
-    result = pose_estimator.estimate_pose("api_test", ref_img)
-
-    # Check format
-    required_keys = ["success", "poses"]
-    optional_keys = ["error", "note"]
-
-    print("Checking response format...")
-
-    for key in required_keys:
-        if key in result:
-            print(f"  ✓ Has '{key}' field")
-        else:
-            print(f"  ✗ Missing '{key}' field")
-            return False
-
-    if result["success"]:
-        if len(result["poses"]) > 0:
-            pose = result["poses"][0]
-            pose_required = ["object_id", "position", "orientation", "confidence", "dimensions"]
-
-            for key in pose_required:
-                if key in pose:
-                    print(f"  ✓ Pose has '{key}' field")
-                else:
-                    print(f"  ✗ Pose missing '{key}' field")
-                    return False
-
-            # Check nested structure
-            if isinstance(pose["position"], dict) and "x" in pose["position"]:
-                print(f"  ✓ Position format correct")
-            else:
-                print(f"  ✗ Position format incorrect")
-                return False
-
-            if isinstance(pose["orientation"], dict) and "w" in pose["orientation"]:
-                print(f"  ✓ Orientation format correct")
-            else:
-                print(f"  ✗ Orientation format incorrect")
-                return False
-        else:
-            print(f"  ℹ No poses detected (OK for placeholder mode)")
-
-    print("✓ API format valid")
-    return True
-
-
-def main():
-    """Run all tests."""
-    print("Starting tests...")
-    print()
-
-    tests = [
-        ("Placeholder Mode", test_placeholder_mode),
-        ("Reference Images", test_with_reference_images),
-        ("API Format", test_api_format),
-    ]
-
-    results = []
-    for name, test_func in tests:
-        try:
-            success = test_func()
-            results.append((name, success))
-        except Exception as e:
-            print(f"✗ Exception in {name}: {e}")
-            results.append((name, False))
-
-    # Summary
-    print()
-    print("=" * 60)
-    print("Test Summary")
-    print("=" * 60)
-
-    passed = sum(1 for _, success in results if success)
-    total = len(results)
-
-    for name, success in results:
-        status = "✓ PASS" if success else "✗ FAIL"
-        print(f"{status}: {name}")
-
-    print()
-    print(f"Results: {passed}/{total} tests passed")
-
-    if passed == total:
-        print()
-        print("🎉 All tests passed! Ready to deploy.")
-        print()
-        print("Next steps:")
-        print("  1. Run './deploy.sh' to deploy to Hugging Face")
-        print("  2. Or start locally: python app.py")
-        return 0
-    else:
-        print()
-        print("⚠ Some tests failed. Fix issues before deploying.")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

verify_weights.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env python3
-"""
-Verify that FoundationPose weights are accessible from Hugging Face model repository.
-
-This script checks:
-1. Model repo exists and is accessible
-2. Required weight files are present
-3. Files can be downloaded successfully
-"""
-
-import os
-import sys
-from pathlib import Path
-
-try:
-    from huggingface_hub import list_repo_files, hf_hub_download
-except ImportError:
-    print("❌ huggingface_hub not installed")
-    print("Install with: pip install huggingface_hub")
-    sys.exit(1)
-
-# Configuration
-MODEL_REPO = os.environ.get("FOUNDATIONPOSE_MODEL_REPO", "gpue/foundationpose-weights")
-
-# Required files
-REQUIRED_FILES = [
-    "2023-10-28-18-33-37/config.yml",
-    "2023-10-28-18-33-37/model_best.pth",
-    "2024-01-11-20-02-45/config.yml",
-    "2024-01-11-20-02-45/model_best.pth",
-]
-
-
-def verify_repo_access():
-    """Verify model repository is accessible."""
-    print(f"Checking repository: {MODEL_REPO}")
-    print("-" * 60)
-
-    try:
-        files = list_repo_files(repo_id=MODEL_REPO, repo_type="model")
-        print(f"✓ Repository accessible")
-        print(f"✓ Found {len(files)} files")
-        return files
-    except Exception as e:
-        print(f"❌ Cannot access repository: {e}")
-        return None
-
-
-def verify_required_files(repo_files):
-    """Verify all required weight files are present."""
-    print("\nChecking required files:")
-    print("-" * 60)
-
-    all_present = True
-    for required_file in REQUIRED_FILES:
-        if required_file in repo_files:
-            print(f"✓ {required_file}")
-        else:
-            print(f"❌ Missing: {required_file}")
-            all_present = False
-
-    return all_present
-
-
-def test_download():
-    """Test downloading a small file."""
-    print("\nTesting download:")
-    print("-" * 60)
-
-    try:
-        # Download a small config file to test connectivity
-        test_file = "2023-10-28-18-33-37/config.yml"
-        print(f"Downloading {test_file}...")
-
-        downloaded = hf_hub_download(
-            repo_id=MODEL_REPO,
-            filename=test_file,
-            repo_type="model"
-        )
-
-        print(f"✓ Download successful: {downloaded}")
-
-        # Check file size
-        size = Path(downloaded).stat().st_size
-        print(f"✓ File size: {size:,} bytes")
-
-        return True
-
-    except Exception as e:
-        print(f"❌ Download failed: {e}")
-        return False
-
-
-def main():
-    """Run all verification checks."""
-    print("=" * 60)
-    print("FoundationPose Model Repository Verification")
-    print("=" * 60)
-    print()
-
-    # Check 1: Repository access
-    repo_files = verify_repo_access()
-    if repo_files is None:
-        print("\n❌ Verification failed: Cannot access repository")
-        sys.exit(1)
-
-    # Check 2: Required files
-    has_all_files = verify_required_files(repo_files)
-    if not has_all_files:
-        print("\n❌ Verification failed: Missing required files")
-        sys.exit(1)
-
-    # Check 3: Download test
-    can_download = test_download()
-    if not can_download:
-        print("\n❌ Verification failed: Cannot download files")
-        sys.exit(1)
-
-    # All checks passed
-    print()
-    print("=" * 60)
-    print("✓ All verification checks passed!")
-    print("=" * 60)
-    print()
-    print(f"Model repository '{MODEL_REPO}' is ready to use.")
-    print()
-    print("To use in your Space:")
-    print("  1. Set environment variable:")
-    print(f"     FOUNDATIONPOSE_MODEL_REPO={MODEL_REPO}")
-    print("  2. Set USE_HF_WEIGHTS=true")
-    print("  3. Set USE_REAL_MODEL=true")
-    print()
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())