backend

app.py

@@ -4,34 +4,208 @@ import json
 import numpy as np
 import cv2
 import base64
+import requests
+import time
 from typing import List, Tuple
 
 # Backend Space URL - replace with your actual backend space URL
 BACKEND_SPACE_URL = "Yuxihenry/SpatialTrackerV2_Backend"  # Replace with actual backend space URL
 hf_token = os.getenv("HF_TOKEN")  # Replace with your actual Hugging Face token
 
+# Debug information
+print(f"🔧 Environment Debug Info:")
+print(f"   - Backend URL: {BACKEND_SPACE_URL}")
+print(f"   - HF Token available: {'Yes' if hf_token else 'No'}")
+print(f"   - HF Token length: {len(hf_token) if hf_token else 0}")
+
 # Flag to track if backend is available
 BACKEND_AVAILABLE = False
 backend_client = None
 
+def check_user_permissions():
+    """Check if user has necessary permissions"""
+    print("🔐 Checking user permissions...")
+    
+    if not hf_token:
+        print("❌ No HF Token found")
+        print("🔧 To get a token:")
+        print("   1. Go to https://huggingface.co/settings/tokens")
+        print("   2. Create a new token with 'read' permissions")
+        print("   3. Set it as environment variable: export HF_TOKEN='your_token'")
+        return False
+    
+    # Try to access user info
+    try:
+        headers = {'Authorization': f'Bearer {hf_token}'}
+        response = requests.get('https://huggingface.co/api/whoami', headers=headers, timeout=5)
+        
+        if response.status_code == 200:
+            user_info = response.json()
+            username = user_info.get('name', 'Unknown')
+            print(f"✅ Authenticated as: {username}")
+            
+            # Check if user has access to the specific space
+            space_url = f"https://huggingface.co/api/spaces/{BACKEND_SPACE_URL}"
+            space_response = requests.get(space_url, headers=headers, timeout=5)
+            
+            if space_response.status_code == 200:
+                print("✅ You have access to the backend Space")
+                return True
+            elif space_response.status_code == 401:
+                print("❌ You don't have access to the backend Space")
+                print("🔧 Solutions:")
+                print("   1. Contact the Space owner to add you as collaborator")
+                print("   2. Ask the owner to make the Space public")
+                return False
+            elif space_response.status_code == 404:
+                print("❌ Backend Space not found")
+                print("🔧 Please check if the Space URL is correct")
+                return False
+            else:
+                print(f"⚠️  Unexpected response checking Space access: {space_response.status_code}")
+                return False
+                
+        else:
+            print(f"❌ Token validation failed: {response.status_code}")
+            print("🔧 Your token might be invalid or expired")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error checking permissions: {e}")
+        return False
+
+def check_backend_space_status():
+    """Check if backend space is running via HTTP request"""
+    try:
+        backend_url = f"https://huggingface.co/spaces/{BACKEND_SPACE_URL}"
+        print(f"🔍 Checking backend space status: {backend_url}")
+        
+        # Prepare headers with authentication if token is available
+        headers = {}
+        if hf_token:
+            headers['Authorization'] = f'Bearer {hf_token}'
+            print(f"🔐 Using HF Token for authentication")
+        
+        # Try to access the space page
+        response = requests.get(backend_url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            print("✅ Backend space page is accessible")
+            
+            # Check if space is running (look for common indicators)
+            page_content = response.text.lower()
+            if "runtime error" in page_content:
+                print("❌ Backend space has runtime error")
+                return False
+            elif "building" in page_content:
+                print("🔄 Backend space is building...")
+                return False
+            elif "sleeping" in page_content:
+                print("😴 Backend space is sleeping")
+                return False
+            else:
+                print("✅ Backend space appears to be running")
+                return True
+                
+        elif response.status_code == 401:
+            print("❌ Authentication failed (HTTP 401)")
+            print("🔧 This means:")
+            print("   - The backend Space is private")
+            print("   - Your HF Token doesn't have access to this Space")
+            print("   - You need to be added as a collaborator to the Space")
+            print("   - Or the Space owner needs to make it public")
+            return False
+            
+        elif response.status_code == 404:
+            print("❌ Backend space not found (HTTP 404)")
+            print("🔧 Please check if the Space URL is correct:")
+            print(f"   Current URL: {BACKEND_SPACE_URL}")
+            return False
+            
+        else:
+            print(f"❌ Backend space not accessible (HTTP {response.status_code})")
+            print(f"🔧 Response: {response.text[:200]}...")
+            return False
+            
+    except requests.RequestException as e:
+        print(f"❌ Failed to check backend space status: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error checking backend: {e}")
+        return False
+
 def initialize_backend():
     """Initialize backend connection using gradio_client"""
     global backend_client, BACKEND_AVAILABLE
+    
+    # First check user permissions
+    print("🔍 Step 1: Checking user permissions...")
+    has_permissions = check_user_permissions()
+    
+    if not has_permissions:
+        print("⚠️  Permission check failed, but continuing with connection attempt...")
+    
+    # Then check if the backend space is actually running
+    print("🔍 Step 2: Verifying backend space status...")
+    space_running = check_backend_space_status()
+    
+    if not space_running:
+        print("⚠️  Backend space is not running or accessible")
+        print("🔧 Possible solutions:")
+        print("   1. If HTTP 401: Contact the Space owner to add you as collaborator")
+        print("   2. If HTTP 404: Verify the Space URL is correct")
+        print("   3. If sleeping: Wait for the space to wake up")
+        print("   4. Try accessing the Space directly in browser first")
+        print(f"   5. Space URL: https://huggingface.co/spaces/{BACKEND_SPACE_URL}")
+        
+        # For now, let's continue and try the gradio_client anyway
+        # Sometimes the web page check fails but the API still works
+        print("🔄 Continuing with gradio_client attempt despite web check failure...")
+        # Don't return False here, let's try the gradio_client connection
+        pass
+    
     try:
-        print(f"Attempting to connect to backend: {BACKEND_SPACE_URL}")
+        print(f"🔍 Step 3: Attempting gradio_client connection to: {BACKEND_SPACE_URL}")
         
         # Use gradio_client for proper API access
         from gradio_client import Client
-        backend_client = Client(f"https://huggingface.co/spaces/{BACKEND_SPACE_URL}", hf_token=hf_token)
         
-        print(f"✅ Backend connection successful!")
+        # Try to connect with timeout and better error handling
+        print("🔄 Creating gradio client connection...")
+        backend_client = Client(f"{BACKEND_SPACE_URL}", hf_token=hf_token, download_files=False) 
+        
+        print(f"✅ Backend API loaded successfully!")
         print(f"🔧 Backend client: {backend_client}")
         
+        # Skip the problematic API config check and directly mark as available
+        # Since the client was created successfully and Space is public
+        print("🔧 Skipping API config check due to known issues")
+        print("🔧 Marking backend as available for direct API calls")
         BACKEND_AVAILABLE = True
         return True
-            
+        
+    except ImportError as import_error:
+        print(f"❌ gradio_client import failed: {import_error}")
+        print("📦 Please install gradio_client: pip install gradio_client")
+        BACKEND_AVAILABLE = False
+        return False
+        
     except Exception as e:
         print(f"❌ Backend connection failed: {e}")
+        print(f"🔧 Error type: {type(e).__name__}")
+        print(f"🔧 Error details: {str(e)}")
+        
+        # Check if it's a specific configuration issue
+        if "Could not fetch config" in str(e):
+            print("🔧 This might be due to:")
+            print("   - Backend Space is not running or deployed")
+            print("   - Backend Space is private and requires authentication")
+            print("   - Network connectivity issues")
+            print("   - Backend Space URL is incorrect")
+            
+        elif "timeout" in str(e).lower():
+            print("🔧 Connection timeout - backend might be slow to respond")
+            
         print("⚠️  Running in standalone mode (some features may be limited)")
         BACKEND_AVAILABLE = False
         return False
@@ -195,6 +369,21 @@ def select_point(original_img: str, sel_pix: list, point_type: str, evt: gr.Sele
                     pass
             except Exception as e:
                 print(f"Backend API call failed: {e}")
+                
+                # Check for specific gradio_client errors
+                if "AppError" in str(type(e)):
+                    print("🔧 Backend Space has internal errors (AppError)")
+                    print("🔧 The backend Space code has bugs or configuration issues")
+                    print("🔧 Contact the Space owner to fix the backend implementation")
+                elif "Could not fetch config" in str(e):
+                    print("🔧 Config fetch failed - possible Gradio version mismatch")
+                    print("🔧 Frontend and backend may be using incompatible Gradio versions")
+                elif "timeout" in str(e).lower():
+                    print("🔧 Backend request timed out - Space might be overloaded")
+                else:
+                    print(f"🔧 Unexpected error type: {type(e).__name__}")
+                
+                print("🔄 Showing error message instead of visualization...")
                 # Fallback to local processing
                 pass
         
@@ -341,6 +530,21 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
                 print(f"❌ Backend API call failed: {e}")
                 print(f"🔧 Error type: {type(e)}")
                 print(f"🔧 Error details: {str(e)}")
+                
+                # Check for specific gradio_client errors
+                if "AppError" in str(type(e)):
+                    print("🔧 Backend Space has internal errors (AppError)")
+                    print("🔧 The backend Space code has bugs or configuration issues")
+                    print("🔧 Contact the Space owner to fix the backend implementation")
+                elif "Could not fetch config" in str(e):
+                    print("🔧 Config fetch failed - possible Gradio version mismatch")
+                    print("🔧 Frontend and backend may be using incompatible Gradio versions")
+                elif "timeout" in str(e).lower():
+                    print("🔧 Backend request timed out - Space might be overloaded")
+                else:
+                    print(f"🔧 Unexpected error type: {type(e).__name__}")
+                
+                print("🔄 Showing error message instead of visualization...")
                 # Fallback to local processing
                 pass
         
@@ -663,9 +867,16 @@ with gr.Blocks(
     
     """)
     
-    # Status indicator
-    status_text = "🟢 Backend Connected" if BACKEND_AVAILABLE else "🟡 Running in Standalone Mode"
+    # Status indicator with more detailed information
+    if BACKEND_AVAILABLE:
+        status_text = "🟢 Backend Connected"
+        status_details = f"Connected to: {BACKEND_SPACE_URL}"
+    else:
+        status_text = "🟡 Running in Standalone Mode"
+        status_details = f"Backend unavailable: {BACKEND_SPACE_URL}"
+    
     gr.Markdown(f"**Status:** {status_text}")
+    gr.Markdown(f"<small style='color: #666;'>{status_details}</small>", elem_id="status-details")
     
     # GitHub Star Reminder - Added back!
     gr.HTML("""