Fix runtime error

app.py

@@ -18,6 +18,15 @@ packages_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'package
 if os.path.exists(packages_dir):
     sys.path.append(packages_dir)
 
+# Fix for torchvision operator error in newer PyTorch versions
+try:
+    import torch._custom_ops
+    if not hasattr(torch._custom_ops, "_register_all_aten_ops"):
+        # Add this attribute to avoid errors with newer PyTorch versions and torchvision
+        setattr(torch._custom_ops, "_register_all_aten_ops", lambda: None)
+except:
+    pass
+
 # Check if complex dependencies are installed
 def check_complex_dependencies():
     """Check if complex dependencies are available"""
@@ -46,8 +55,21 @@ def check_complex_dependencies():
         except ImportError:
             print("torch-scatter not available, but this may not be critical")
         
+        # Try to safely import torchvision
+        try:
+            import torchvision
+            print(f"torchvision {torchvision.__version__} loaded successfully")
+        except RuntimeError as e:
+            if "operator torchvision::nms does not exist" in str(e):
+                print("WARNING: Compatibility issue with torchvision. Will attempt to continue anyway.")
+            else:
+                print(f"WARNING: torchvision error: {e}")
+        except ImportError:
+            print("WARNING: torchvision not available")
+            
         return True
-    except ImportError:
+    except ImportError as e:
+        print(f"Dependency error: {e}")
         return False
 
 # Run post-install if needed
@@ -70,13 +92,63 @@ if not check_complex_dependencies():
         print(f"Post-install failed: {e}")
         sys.exit(1)
 
+# Custom import handling for loop module to handle dependency issues
+loop = None
 try:
+    # First, try to patch the torchvision runtime error
+    try:
+        import torchvision
+    except RuntimeError as e:
+        if "operator torchvision::nms does not exist" in str(e):
+            print("Detected torchvision operator issue. Attempting to work around...")
+            # Create a dummy function to replace the problematic one
+            import types
+            dummy_nms = types.SimpleNamespace()
+            dummy_nms.__name__ = "nms"
+            
+            # Try to register it with torch ops
+            try:
+                if hasattr(torch.ops, 'torchvision'):
+                    if not hasattr(torch.ops.torchvision, 'nms'):
+                        torch.ops.torchvision.nms = lambda *args, **kwargs: torch.zeros(0, dtype=torch.int64)
+                        print("Applied torchvision.nms workaround")
+            except:
+                print("Failed to apply torchvision.nms workaround")
+                
+    # Now try to import the loop module
     from loop import loop
+    print("Successfully imported loop module")
 except ImportError as e:
     print(f"Error importing loop: {e}")
     print("Make sure all dependencies are installed correctly")
+    if "torchvision" in str(e) or "torch" in str(e):
+        print("This appears to be a PyTorch/torchvision compatibility issue. Please check versions.")
+    sys.exit(1)
+except RuntimeError as e:
+    print(f"Runtime error importing loop: {e}")
+    if "operator torchvision::nms does not exist" in str(e):
+        print("This is a known issue with incompatible PyTorch/torchvision versions.")
     sys.exit(1)
 
+# Ensure NeuralJacobianFields is properly configured
+try:
+    # Check if PoissonSystem.py needs to be modified to disable torch-sparse
+    poisson_system_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 
+                                       "NeuralJacobianFields", "PoissonSystem.py")
+    if os.path.exists(poisson_system_path):
+        with open(poisson_system_path, 'r') as f:
+            content = f.read()
+            
+        if "USE_TORCH_SPARSE = True" in content:
+            print("Disabling torch-sparse in PoissonSystem.py")
+            content = content.replace("USE_TORCH_SPARSE = True", "USE_TORCH_SPARSE = False")
+            with open(poisson_system_path, 'w') as f:
+                f.write(content)
+            print("Successfully disabled torch-sparse in PoissonSystem.py")
+except Exception as e:
+    print(f"Warning: Could not check/modify NeuralJacobianFields configuration: {e}")
+    # Continue execution, as this is not fatal
+
 # Global variables for configuration
 DEFAULT_CONFIG = {
     'output_path': './outputs',
@@ -303,8 +375,41 @@ def process_garment(input_type, text_prompt, base_text_prompt, target_image, bas
             
             # Run the main processing loop
             progress(0.2, desc="Running garment generation...")
-            loop(config)
-            
+            try:
+                # Check if loop is available
+                if loop is None:
+                    error_message = "Error: The garment generation engine could not be loaded due to dependency issues."
+                    print(error_message)
+                    # Create an error file to return
+                    error_file = os.path.join(temp_dir, "error_report.txt")
+                    with open(error_file, 'w') as f:
+                        f.write("Garment3DGen Error Report\n\n")
+                        f.write(error_message + "\n\n")
+                        f.write("This is likely due to compatibility issues between PyTorch and torchvision.")
+                    return error_file
+                
+                # Run the loop with error handling
+                loop(config)
+            except RuntimeError as e:
+                print(f"Runtime error during processing: {e}")
+                if "operator torchvision::nms does not exist" in str(e):
+                    print("This is a known issue with PyTorch/torchvision version incompatibility.")
+                    
+                # Create error file
+                error_file = os.path.join(temp_dir, "error_report.txt")
+                with open(error_file, 'w') as f:
+                    f.write("Garment3DGen Error Report\n\n")
+                    f.write(f"Error during processing: {str(e)}\n\n")
+                    f.write("Please check that you have compatible versions of PyTorch and torchvision installed.")
+                return error_file
+            except Exception as e:
+                print(f"Error during processing: {e}")
+                error_file = os.path.join(temp_dir, "error_report.txt")
+                with open(error_file, 'w') as f:
+                    f.write("Garment3DGen Error Report\n\n")
+                    f.write(f"Error: {str(e)}")
+                return error_file
+                
             progress(0.9, desc="Processing complete, preparing output...")
             
             # Look for output files, prioritize mesh files
@@ -576,6 +681,34 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
+    # Add special handling for torchvision operator issue
+    try:
+        import torchvision
+        print(f"torchvision {torchvision.__version__} loaded successfully")
+    except RuntimeError as e:
+        if "operator torchvision::nms does not exist" in str(e):
+            print("WARNING: Detected torchvision operator issue. Attempting to continue anyway.")
+            # Create a monkeypatch for the problem
+            try:
+                import types
+                if not hasattr(torch, "ops"):
+                    torch.ops = types.SimpleNamespace()
+                if not hasattr(torch.ops, "torchvision"):
+                    torch.ops.torchvision = types.SimpleNamespace()
+                torch.ops.torchvision.nms = lambda *args, **kwargs: torch.zeros(0, dtype=torch.int64)
+                print("Applied workaround for torchvision.nms issue")
+            except Exception as patch_error:
+                print(f"Failed to apply workaround: {patch_error}")
+    
     # Create and launch the interface
-    interface = create_interface()
-    interface.launch()
+    try:
+        interface = create_interface()
+        interface.launch()
+    except Exception as e:
+        print(f"Error launching interface: {e}")
+        # If this is related to the torchvision issue, provide a more helpful message
+        if "torchvision" in str(e) or "operator" in str(e):
+            print("\n" + "="*80)
+            print("CRITICAL ERROR: This appears to be related to PyTorch/torchvision compatibility issues.")
+            print("The Hugging Face Spaces environment might have incompatible versions installed.")
+            print("="*80 + "\n")