Upload app.py

app.py

@@ -13,6 +13,9 @@ IS_SPACES = os.getenv("SPACE_ID") is not None or os.getenv("HF_SPACE") is not No
 # Add the current directory to Python path for Spaces environment
 sys.path.insert(0, str(Path(__file__).parent))
 
+# Global flag to prevent duplicate initialization
+_app_initialized = False
+
 from openai import OpenAI
 from src.config import Config
 from src.vector_store import VectorStoreManager
@@ -212,71 +215,98 @@ def create_app():
     
     # Build Gradio interface
     print("\n🌐 Building Gradio interface...")
-    interface_builder = GradioInterfaceBuilder(
-        rag_engine=components["rag_engine"],
-        question_generator=components["question_generator"],
-        knowledge_graph=components["knowledge_graph"],
-        config=components["config"],
-        user_profiling=components["user_profiling"],
-        adaptive_engine=components["adaptive_engine"],
-        proactive_engine=components["proactive_engine"]
-    )
-    
-    # Create interface (without auth parameter to avoid compatibility issues)
-    demo = interface_builder.create_interface()
-    
-    # Set authentication for Hugging Face Spaces
-    # Note: In Gradio 6.0 on Spaces, auth should be set via launch() parameters
-    # Since Spaces auto-launches, we'll store auth config for potential use
-    if auth_username and auth_password:
-        auth_config = (auth_username, auth_password)
-        # Store auth config - Spaces may use this when auto-launching
-        # For Gradio 6.0, we can't directly set demo.auth before launch
-        # Spaces will handle authentication if configured properly
-        demo._hf_auth = auth_config
-        print("✅ Authentication credentials stored (Spaces will handle on launch)")
-    
-    return demo
+    try:
+        interface_builder = GradioInterfaceBuilder(
+            rag_engine=components["rag_engine"],
+            question_generator=components["question_generator"],
+            knowledge_graph=components["knowledge_graph"],
+            config=components["config"],
+            user_profiling=components["user_profiling"],
+            adaptive_engine=components["adaptive_engine"],
+            proactive_engine=components["proactive_engine"]
+        )
+        
+        # Create interface (without auth parameter to avoid compatibility issues)
+        print("Creating Gradio Blocks...")
+        demo = interface_builder.create_interface()
+        print("✅ Gradio interface created successfully!")
+        
+        # Set authentication for Hugging Face Spaces
+        # Note: In Gradio 6.0 on Spaces, auth should be set via launch() parameters
+        # Since Spaces auto-launches, we'll store auth config for potential use
+        if auth_username and auth_password:
+            auth_config = (auth_username, auth_password)
+            # Store auth config - Spaces may use this when auto-launching
+            # For Gradio 6.0, we can't directly set demo.auth before launch
+            # Spaces will handle authentication if configured properly
+            demo._hf_auth = auth_config
+            print("✅ Authentication credentials stored (Spaces will handle on launch)")
+        
+        return demo
+    except Exception as e:
+        print(f"❌ Error building Gradio interface: {e}")
+        import traceback
+        traceback.print_exc()
+        # Return a simple error interface
+        import gradio as gr
+        error_demo = gr.Interface(
+            fn=lambda: f"Error building interface: {str(e)}",
+            inputs=None,
+            outputs="text",
+            title="CSRC Car Manual RAG System - Interface Error"
+        )
+        return error_demo
 
 
 # Create the app for Hugging Face Spaces
 # Spaces will automatically detect Gradio and run this
-# Wrap in try-except to ensure demo is always defined
-try:
-    demo = create_app()
-    print("✅ App created successfully!")
-except Exception as e:
-    print(f"❌ Fatal error creating app: {e}")
-    import traceback
-    traceback.print_exc()
-    
-    # Create a minimal error interface
-    import gradio as gr
-    
-    def show_error():
-        return f"""
-        # ❌ Application Error
+# Use global flag to prevent duplicate initialization
+if not _app_initialized:
+    _app_initialized = True
+    try:
+        demo = create_app()
+        print("✅ App created successfully!")
+        print(f"✅ Demo type: {type(demo)}")
+    except Exception as e:
+        print(f"❌ Fatal error creating app: {e}")
+        import traceback
+        traceback.print_exc()
         
-        **Fatal Error:** {str(e)}
+        # Create a minimal error interface
+        import gradio as gr
         
-        Please check:
-        1. OPENAI_API_KEY is set in Spaces Secrets
-        2. All required files are uploaded
-        3. Check the logs for detailed error information
+        def show_error():
+            return f"""
+            # ❌ Application Error
+            
+            **Fatal Error:** {str(e)}
+            
+            Please check:
+            1. OPENAI_API_KEY is set in Spaces Secrets
+            2. All required files are uploaded
+            3. Check the logs for detailed error information
+            
+            **Traceback:**
+            ```
+            {traceback.format_exc()}
+            ```
+            """
         
-        **Traceback:**
-        ```
-        {traceback.format_exc()}
-        ```
-        """
-    
-    demo = gr.Interface(
-        fn=show_error,
-        inputs=None,
-        outputs=gr.Markdown(),
-        title="CSRC Car Manual RAG System - Error",
-        description="An error occurred. Please check the logs."
-    )
+        demo = gr.Interface(
+            fn=show_error,
+            inputs=None,
+            outputs=gr.Markdown(),
+            title="CSRC Car Manual RAG System - Error",
+            description="An error occurred. Please check the logs."
+        )
+else:
+    # If already initialized, skip to avoid duplicate initialization
+    print("⚠️  App already initialized, skipping duplicate initialization")
+    # demo should already be defined from first initialization
+    if 'demo' not in globals():
+        # Fallback: create a simple demo if somehow not defined
+        import gradio as gr
+        demo = gr.Interface(fn=lambda: "App is initializing...", inputs=None, outputs="text")
 
 # Note: Do NOT call demo.launch() here
 # Hugging Face Spaces will automatically detect and launch the demo