Upload app.py with huggingface_hub

app.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Hugging Face Spaces - load all modules first, then execute"""
+"""Hugging Face Spaces - intelligent module loading"""
 import os
 import sys
 import importlib.util
@@ -9,45 +9,131 @@ from types import ModuleType
 app_dir = Path("/app")
 sys.path.insert(0, str(app_dir))
 
-print("Setting up module namespace...\n")
+print("Loading application...\n")
 
 # Create src package
 src_package = ModuleType("src")
 src_package.__path__ = [str(app_dir / "src")]
 sys.modules["src"] = src_package
 
-# Step 1: Register ALL modules in sys.modules first (without executing)
-print("Registering src modules:")
-modules_to_load = []
+# Read all src files and fix their imports
+src_files_content = {}
+print("Reading src files:")
 for item in sorted(app_dir.iterdir()):
     name = item.name
-    if name.startswith("src\\") and name.endswith(".py") and not name.endswith("__pycache__"):
+    if name.startswith("src\\") and name.endswith(".py") and name != "src\\__init__.py":
         module_name = name.split("\\")[-1].replace(".py", "")
-        if module_name == "__init__":
-            continue
-        
-        full_name = f"src.{module_name}"
         try:
-            spec = importlib.util.spec_from_file_location(full_name, str(item))
-            module = importlib.util.module_from_spec(spec)
-            sys.modules[full_name] = module
-            sys.modules[module_name] = module
-            setattr(src_package, module_name, module)
-            modules_to_load.append((full_name, spec, module))
-            print(f"   Registered {full_name}")
+            with open(str(item), 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+            # Fix imports: convert backslash paths to forward slash
+            content = content.replace("from src\\", "from src.")
+            content = content.replace("import src\\", "import src.")
+            # Also handle cases where backslash is in string
+            src_files_content[module_name] = content
+            print(f"   Read {module_name}")
         except Exception as e:
-            print(f"    {full_name}: {str(e)[:50]}")
+            print(f"    {module_name}: {e}")
+
+# Execute modules in order (simple modules first)
+load_order = [
+    "models",
+    "parser", 
+    "indexing",
+    "intent",
+    "retrieval",
+    "reasoning",
+    "dependencies",
+    "groq_integration",
+    "evaluation",
+    "notebook_downloader",
+]
 
-# Step 2: Now execute all modules (imports will work now)
 print("\nExecuting src modules:")
-for full_name, spec, module in modules_to_load:
+executed_modules = {}
+
+for module_name in load_order:
+    if module_name not in src_files_content:
+        continue
+    
     try:
-        spec.loader.exec_module(module)
-        print(f"   Executed {full_name}")
+        # Create module
+        full_name = f"src.{module_name}"
+        module = ModuleType(full_name)
+        module.__file__ = str(app_dir / f"src\\{module_name}.py")
+        module.__loader__ = None
+        
+        # Create namespace with all previously loaded modules
+        namespace = {
+            "__name__": full_name,
+            "__file__": module.__file__,
+            "__package__": "src",
+            "src": src_package,
+        }
+        
+        # Add all already-loaded src modules
+        for loaded_name, loaded_module in executed_modules.items():
+            namespace[loaded_name] = loaded_module
+            setattr(src_package, loaded_name, loaded_module)
+        
+        # Execute the code
+        code = src_files_content[module_name]
+        exec(compile(code, module.__file__, "exec"), namespace)
+        
+        # Update module with namespace
+        for key, value in namespace.items():
+            if not key.startswith("_"):
+                setattr(module, key, value)
+        
+        # Register
+        sys.modules[full_name] = module
+        sys.modules[module_name] = module
+        setattr(src_package, module_name, module)
+        executed_modules[module_name] = module
+        
+        print(f"   Loaded {full_name}")
+        
     except Exception as e:
-        print(f"    {full_name}: {str(e)[:60]}")
+        print(f"    {module_name}: {str(e)[:60]}")
+        import traceback
+        traceback.print_exc()
 
-# Step 3: Load ui/app.py
+# Load remaining modules not in load_order
+print("\nLoading remaining modules:")
+for module_name in src_files_content:
+    if module_name not in executed_modules:
+        try:
+            full_name = f"src.{module_name}"
+            module = ModuleType(full_name)
+            module.__file__ = str(app_dir / f"src\\{module_name}.py")
+            
+            namespace = {
+                "__name__": full_name,
+                "__file__": module.__file__,
+                "__package__": "src",
+                "src": src_package,
+            }
+            
+            for loaded_name, loaded_module in executed_modules.items():
+                namespace[loaded_name] = loaded_module
+                setattr(src_package, loaded_name, loaded_module)
+            
+            code = src_files_content[module_name]
+            exec(compile(code, module.__file__, "exec"), namespace)
+            
+            for key, value in namespace.items():
+                if not key.startswith("_"):
+                    setattr(module, key, value)
+            
+            sys.modules[full_name] = module
+            sys.modules[module_name] = module
+            setattr(src_package, module_name, module)
+            executed_modules[module_name] = module
+            print(f"   Loaded {full_name}")
+        except Exception as e:
+            print(f"    {module_name}: {str(e)[:60]}")
+
+# Now load ui/app.py
 print("\nLoading ui/app.py:")
 ui_app_path = None
 for item in app_dir.iterdir():
@@ -56,21 +142,20 @@ for item in app_dir.iterdir():
         break
 
 if ui_app_path and ui_app_path.exists():
-    with open(str(ui_app_path), 'r', encoding='utf-8', errors='ignore') as f:
-        code = f.read()
-    
-    exec_globals = {
-        "__name__": "__main__",
-        "__file__": str(ui_app_path),
-        "src": src_package,
-    }
-    
-    # Add all src modules to globals
-    for key in list(sys.modules.keys()):
-        if key.startswith("src."):
-            exec_globals[key.split(".")[-1]] = sys.modules[key]
-    
     try:
+        with open(str(ui_app_path), 'r', encoding='utf-8', errors='ignore') as f:
+            code = f.read()
+        
+        exec_globals = {
+            "__name__": "__main__",
+            "__file__": str(ui_app_path),
+            "src": src_package,
+        }
+        
+        # Add all src modules
+        for module_name, module in executed_modules.items():
+            exec_globals[module_name] = module
+        
         print("  Executing ui/app.py...")
         exec(compile(code, str(ui_app_path), "exec"), exec_globals)
         
@@ -85,7 +170,6 @@ if ui_app_path and ui_app_path.exists():
             )
         else:
             print("   create_gradio_app not found")
-            
     except Exception as e:
         print(f"   Error: {e}\n")
         import traceback