vggt

app.py

@@ -25,14 +25,14 @@ def initialize_backend():
         print(f"🔧 Backend API object type: {type(backend_api)}")
         print(f"🔧 Backend API object attributes: {dir(backend_api)}")
         
-        # Check if it's an Interface object and has fn
-        if hasattr(backend_api, 'fn'):
+        # Check if it's a Blocks object and has fns
+        if hasattr(backend_api, 'fns') and backend_api.fns:
             print(f"✅ Backend connection successful!")
-            print("✅ Backend API function is available")
+            print(f"🔧 Available functions in fns: {list(backend_api.fns.keys())}")
             BACKEND_AVAILABLE = True
             return True
         else:
-            print("❌ Backend API function not found")
+            print("❌ Backend API functions not found")
             print(f"🔧 Available methods: {[attr for attr in dir(backend_api) if not attr.startswith('_')]}")
             BACKEND_AVAILABLE = False
             return False
@@ -96,15 +96,15 @@ def handle_video_upload(video):
         return None, None, [], 50, 756, 3
     
     try:
-        if BACKEND_AVAILABLE and backend_api:
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
             # Try to use backend API
             try:
                 print("🔧 Calling backend API for video upload...")
                 
-                # For gr.Interface, we can call the function directly
-                if hasattr(backend_api, 'fn'):
-                    print("🔧 Using backend Interface function")
-                    result = backend_api.fn(video, [], 50, 756, 3)
+                # For gr.Blocks, we use predict method
+                if 0 in backend_api.fns:
+                    print("🔧 Using backend Blocks predict method")
+                    result = backend_api.predict(0, [video, [], 50, 756, 3])
                     
                     print(f"✅ Backend video upload API call successful!")
                     print(f"🔧 Result type: {type(result)}")
@@ -120,7 +120,7 @@ def handle_video_upload(video):
                         # Fallback to local processing
                         pass
                 else:
-                    print("Backend function not found")
+                    print("Backend function 0 not found")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -153,19 +153,30 @@ def select_point(original_img: str, sel_pix: list, point_type: str, evt: gr.Sele
         return None, []
     
     try:
-        if BACKEND_AVAILABLE and backend_api:
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
             # Try to use backend API
             try:
                 print(f"🔧 Calling backend select point API: x={evt.index[0]}, y={evt.index[1]}, type={point_type}")
                 
-                # For gr.Interface, we can call the function directly
-                if hasattr(backend_api, 'fn'):
-                    print("🔧 Using backend Interface function for point selection")
-                    # Note: This might not work as expected since the interface expects different inputs
-                    # For now, fallback to local processing
-                    pass
+                # For gr.Blocks, we use predict method
+                if 1 in backend_api.fns:
+                    print("🔧 Using backend Blocks predict method for point selection")
+                    result = backend_api.predict(1, [original_img, sel_pix, point_type, evt.index[0], evt.index[1]])
+                    
+                    print(f"✅ Backend select point API call successful!")
+                    print(f"🔧 Result type: {type(result)}")
+                    
+                    # Parse the result - expect (display_image, new_sel_pix)
+                    if isinstance(result, tuple) and len(result) == 2:
+                        display_image_b64, new_sel_pix = result
+                        display_image = base64_to_image(display_image_b64)
+                        return display_image, new_sel_pix
+                    else:
+                        print("Backend returned unexpected format, using local fallback")
+                        # Fallback to local processing
+                        pass
                 else:
-                    print("Backend function not found")
+                    print("Backend function 1 (select point) not found")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -228,19 +239,30 @@ def reset_points(original_img: str, sel_pix):
         return None, []
     
     try:
-        if BACKEND_AVAILABLE and backend_api:
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
             # Try to use backend API
             try:
                 print("🔧 Calling backend reset points API")
                 
-                # For gr.Interface, we can call the function directly
-                if hasattr(backend_api, 'fn'):
-                    print("🔧 Using backend Interface function for reset")
-                    # Note: This might not work as expected since the interface expects different inputs
-                    # For now, fallback to local processing
-                    pass
+                # For gr.Blocks, we use predict method
+                if 2 in backend_api.fns:
+                    print("🔧 Using backend Blocks predict method for reset")
+                    result = backend_api.predict(2, [original_img, sel_pix])
+                    
+                    print(f"✅ Backend reset points API call successful!")
+                    print(f"🔧 Result type: {type(result)}")
+                    
+                    # Parse the result - expect (display_image, new_sel_pix)
+                    if isinstance(result, tuple) and len(result) == 2:
+                        display_image_b64, new_sel_pix = result
+                        display_image = base64_to_image(display_image_b64)
+                        return display_image, new_sel_pix
+                    else:
+                        print("Backend returned unexpected format, using local fallback")
+                        # Fallback to local processing
+                        pass
                 else:
-                    print("Backend function not found")
+                    print("Backend function 2 (reset points) not found")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -275,18 +297,18 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
         return None, None
     
     try:
-        if BACKEND_AVAILABLE and backend_api:
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
             # Try to use backend API
             try:
                 print(f"🔧 Calling backend API with parameters: grid_size={grid_size}, vo_points={vo_points}, fps={fps}")
                 print(f"🔧 Original image state type: {type(original_image_state)}")
                 print(f"🔧 Original image state preview: {str(original_image_state)[:100]}...")
                 
-                # For gr.Interface, we can call the function directly
-                if hasattr(backend_api, 'fn'):
-                    print("🔧 Using backend Interface function")
+                # For gr.Blocks, we use predict method
+                if 0 in backend_api.fns:
+                    print("🔧 Using backend Blocks predict method")
                     # For now, we'll use empty points since we're in local mode
-                    result = backend_api.fn(None, [], grid_size, vo_points, fps)
+                    result = backend_api.predict(0, [None, [], grid_size, vo_points, fps])
                     
                     print(f"✅ Backend API call successful!")
                     print(f"🔧 Result type: {type(result)}")
@@ -302,7 +324,7 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
                         # Fallback to error message
                         pass
                 else:
-                    print("Backend function not found")
+                    print("Backend function 0 not found")
                     # Fallback to error message
                     pass
             except Exception as e:
@@ -331,6 +353,7 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
                 <p style='color: #666; font-size: 12px; margin: 0;'>Backend API Object: {backend_api is not None}</p>
                 <p style='color: #666; font-size: 12px; margin: 0;'>Backend URL: {BACKEND_SPACE_URL}</p>
                 <p style='color: #666; font-size: 12px; margin: 0;'>Backend Type: {type(backend_api) if backend_api else 'None'}</p>
+                <p style='color: #666; font-size: 12px; margin: 0;'>Available Functions: {list(backend_api.fns.keys()) if backend_api and hasattr(backend_api, 'fns') else 'None'}</p>
             </div>
             <p style='color: #2d3436; font-weight: bold; margin-top: 15px;'>
                 Current Status: Backend unavailable - Running in limited mode
@@ -370,12 +393,13 @@ def test_backend_connection():
     try:
         # Try a simple API call to test connection
         print("Testing backend connection with a simple call...")
-        # Check if we have fn available
-        if hasattr(backend_api, 'fn'):
-            print("✅ Backend API function is available")
+        # Check if we have fns available
+        if hasattr(backend_api, 'fns') and backend_api.fns:
+            print("✅ Backend API functions are available")
+            print(f"🔧 Available function indices: {list(backend_api.fns.keys())}")
             return True
         else:
-            print("❌ Backend API function not found")
+            print("❌ Backend API functions not found")
             BACKEND_AVAILABLE = False
             return False
     except Exception as e:
@@ -392,12 +416,13 @@ def test_backend_api():
     try:
         print("🧪 Testing backend API functions...")
         
-        # Test if fn exists
-        if hasattr(backend_api, 'fn'):
-            print("✅ Backend has function available")
-            print(f"✅ Function type: {type(backend_api.fn)}")
+        # Test if fns exist and show available indices
+        if hasattr(backend_api, 'fns') and backend_api.fns:
+            print(f"✅ Backend has {len(backend_api.fns)} functions available")
+            for idx in backend_api.fns.keys():
+                print(f"✅ Function {idx} is available")
         else:
-            print("❌ No function available in backend")
+            print("❌ No functions available in backend")
         
         return True
     except Exception as e: