Update app.py

after app_minimal

app.py

@@ -1,126 +1,350 @@
 """
-Minimal version of app.py for Hugging Face Spaces
-Use this for testing if the full version doesn't work
+Hugging Face Spaces Entry Point for CSRC Car Manual RAG System
+Optimized version with timeout protection and lazy loading
 """
 import os
-import gradio as gr
+import sys
+from pathlib import Path
+import signal
+from contextlib import contextmanager
+
+# Add the current directory to Python path for Spaces environment
+sys.path.insert(0, str(Path(__file__).parent))
+
 from openai import OpenAI
+from src.config import Config
+from src.vector_store import VectorStoreManager
+from src.rag_query import RAGQueryEngine
+from src.question_generator import QuestionGenerator
+from src.knowledge_graph import KnowledgeGraphGenerator
+from src.gradio_interface import GradioInterfaceBuilder
+
+# Import personalized learning if available
+try:
+    from modules.personalized_learning import UserProfilingSystem, LearningPathGenerator, AdaptiveLearningEngine
+    PERSONALIZED_LEARNING_AVAILABLE = True
+except ImportError:
+    PERSONALIZED_LEARNING_AVAILABLE = False
+    print("⚠️ Personalized learning modules not available")
+
+# Import proactive learning if available
+try:
+    from modules.proactive_learning import ProactiveLearningEngine
+    PROACTIVE_LEARNING_AVAILABLE = True
+except ImportError:
+    PROACTIVE_LEARNING_AVAILABLE = False
+    print("⚠️ Proactive learning modules not available")
 
-# Simple configuration
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-VECTOR_STORE_ID = os.getenv("VECTOR_STORE_ID", "vs_69022a9edd74819199bf9a34a83e877b")
-MODEL = "gpt-4o-mini"
+# Import scenario contextualization if available
+try:
+    from modules.scenario_contextualization.database.scenario_database import ScenarioDatabase
+    from modules.scenario_contextualization.integration.feature_extractor import ADASFeatureExtractor
+    from modules.scenario_contextualization.retrieval.scenario_retriever import ScenarioRetriever
+    from modules.scenario_contextualization.formatting.constructive_formatter import ConstructiveFormatter
+    from modules.scenario_contextualization.integration.enhanced_rag_engine import EnhancedRAGEngine
+    SCENARIO_CONTEXTUALIZATION_AVAILABLE = True
+except ImportError as e:
+    SCENARIO_CONTEXTUALIZATION_AVAILABLE = False
+    print(f"⚠️ Scenario contextualization modules not available: {e}")
 
 
-def query_rag(question: str) -> str:
-    """Simple RAG query function"""
-    if not OPENAI_API_KEY:
-        return "❌ Error: OPENAI_API_KEY not set in Spaces Secrets"
+class TimeoutError(Exception):
+    pass
+
+
+@contextmanager
+def timeout(seconds):
+    """Context manager for timeout operations"""
+    def timeout_handler(signum, frame):
+        raise TimeoutError(f"Operation timed out after {seconds} seconds")
     
-    if not VECTOR_STORE_ID:
-        return "❌ Error: VECTOR_STORE_ID not set"
+    # Set the signal handler
+    old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(seconds)
     
     try:
-        client = OpenAI(api_key=OPENAI_API_KEY)
-        
-        # Create assistant with file search
-        assistant = client.beta.assistants.create(
-            name="Car Manual Assistant",
-            instructions="You are a helpful assistant that answers questions about car manuals.",
-            model=MODEL,
-            tools=[{"type": "file_search"}],
-            tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}}
+        yield
+    finally:
+        # Restore the old handler
+        signal.alarm(0)
+        signal.signal(signal.SIGALRM, old_handler)
+
+
+def initialize_system(config: Config) -> dict:
+    """Initialize the RAG system components"""
+    print("🔧 Initializing core components...")
+    
+    # Initialize OpenAI client
+    if not config.openai_api_key:
+        raise ValueError(
+            "OPENAI_API_KEY not found! Please set it in Hugging Face Spaces Secrets. "
+            "Go to Settings > Secrets and add OPENAI_API_KEY"
         )
+    
+    client = OpenAI(api_key=config.openai_api_key)
+    
+    # Initialize vector store manager
+    vector_store_manager = VectorStoreManager(client)
+    
+    # Get or create vector store
+    vector_store_id = config.get_vector_store_id()
+    
+    if not vector_store_id:
+        print("📦 Creating new vector store...")
+        pdf_files = config.get_pdf_files()
         
-        # Create thread and run
-        thread = client.beta.threads.create()
+        if not pdf_files:
+            raise ValueError(f"No PDF files found in {config.car_manual_dir}")
         
-        message = client.beta.threads.messages.create(
-            thread_id=thread.id,
-            role="user",
-            content=question
-        )
+        vector_store_details = vector_store_manager.create_vector_store(config.vector_store_name)
+        if not vector_store_details:
+            raise RuntimeError("Failed to create vector store")
         
-        run = client.beta.threads.runs.create_and_poll(
-            thread_id=thread.id,
-            assistant_id=assistant.id
-        )
+        vector_store_id = vector_store_details["id"]
+        config.save_vector_store_id(vector_store_id, config.vector_store_name)
         
-        if run.status == 'completed':
-            messages = client.beta.threads.messages.list(thread_id=thread.id)
-            response = messages.data[0].content[0].text.value
-            
-            # Cleanup
-            client.beta.assistants.delete(assistant.id)
-            
-            return response
-        else:
-            return f"❌ Query failed with status: {run.status}"
-            
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
+        # Upload files
+        upload_stats = vector_store_manager.upload_pdf_files(pdf_files, vector_store_id)
+        if upload_stats["successful_uploads"] == 0:
+            raise RuntimeError("Failed to upload any files")
+    else:
+        print(f"✅ Using existing vector store: {vector_store_id}")
+    
+    # Initialize RAG query engine
+    print("🔧 Initializing RAG engine...")
+    rag_engine = RAGQueryEngine(client, vector_store_id, config.model)
+    
+    # Initialize question generator
+    print("🔧 Initializing question generator...")
+    question_generator = QuestionGenerator(client, rag_engine)
+    
+    # Initialize knowledge graph generator
+    print("🔧 Initializing knowledge graph...")
+    knowledge_graph = KnowledgeGraphGenerator(client, vector_store_id, str(config.output_dir))
+    
+    # Initialize personalized learning (if available) - with timeout
+    user_profiling = None
+    learning_path_generator = None
+    adaptive_engine = None
+    
+    if PERSONALIZED_LEARNING_AVAILABLE:
+        try:
+            print("🔧 Initializing personalized learning...")
+            with timeout(10):
+                user_profiling = UserProfilingSystem()
+                learning_path_generator = LearningPathGenerator(user_profiling, config.available_topics)
+                adaptive_engine = AdaptiveLearningEngine(user_profiling, learning_path_generator)
+            print("✅ Personalized Learning System initialized!")
+        except TimeoutError:
+            print("⚠️ Personalized Learning System initialization timed out - skipping")
+        except Exception as e:
+            print(f"⚠️ Error initializing Personalized Learning System: {e}")
+    
+    # Initialize proactive learning (if available) - with timeout
+    proactive_engine = None
+    if PROACTIVE_LEARNING_AVAILABLE and user_profiling:
+        try:
+            print("🔧 Initializing proactive learning...")
+            with timeout(10):
+                proactive_engine = ProactiveLearningEngine(
+                    client, rag_engine, user_profiling, adaptive_engine, config.available_topics
+                )
+            print("✅ Proactive Learning Assistance initialized!")
+        except TimeoutError:
+            print("⚠️ Proactive Learning Assistance initialization timed out - skipping")
+        except Exception as e:
+            print(f"⚠️ Error initializing Proactive Learning Assistance: {e}")
+    
+    # Initialize scenario contextualization (if available) - with timeout
+    enhanced_rag_engine = None
+    if SCENARIO_CONTEXTUALIZATION_AVAILABLE:
+        try:
+            print("🔧 Initializing scenario contextualization...")
+            with timeout(15):
+                scenario_database = ScenarioDatabase()
+                feature_extractor = ADASFeatureExtractor(use_llm=False, client=client)
+                scenario_retriever = ScenarioRetriever(
+                    scenario_database=scenario_database,
+                    scenario_vector_store_id=None,
+                    client=client
+                )
+                formatter = ConstructiveFormatter()
+                enhanced_rag_engine = EnhancedRAGEngine(
+                    base_rag_engine=rag_engine,
+                    scenario_retriever=scenario_retriever,
+                    feature_extractor=feature_extractor,
+                    formatter=formatter
+                )
+            print("✅ Scenario Contextualization initialized!")
+        except TimeoutError:
+            print("⚠️ Scenario Contextualization initialization timed out - skipping")
+        except Exception as e:
+            print(f"⚠️ Error initializing Scenario Contextualization: {e}")
+    
+    print("✅ Core system initialized!")
+    return {
+        "client": client,
+        "vector_store_manager": vector_store_manager,
+        "rag_engine": rag_engine,
+        "question_generator": question_generator,
+        "knowledge_graph": knowledge_graph,
+        "user_profiling": user_profiling,
+        "learning_path_generator": learning_path_generator,
+        "adaptive_engine": adaptive_engine,
+        "proactive_engine": proactive_engine,
+        "enhanced_rag_engine": enhanced_rag_engine,
+        "config": config
+    }
 
 
-# Create Gradio interface
-def create_interface():
-    """Create minimal Gradio interface"""
+def create_app():
+    """Create and return the Gradio app for Hugging Face Spaces"""
+    print("=" * 60)
+    print("🚗 CSRC Car Manual RAG System - Hugging Face Spaces")
+    print("=" * 60)
     
-    with gr.Blocks(title="CSRC Car Manual RAG") as demo:
-        gr.Markdown("""
-        # 🚗 CSRC Car Manual RAG System
-        ## Minimal Version for Testing
+    # Load configuration
+    config = Config()
+    
+    # Initialize system with timeout
+    try:
+        print("⏱️  Starting initialization (max 90 seconds)...")
+        with timeout(90):
+            components = initialize_system(config)
+    except TimeoutError:
+        print("❌ System initialization timed out!")
+        import gradio as gr
+        error_msg = """
+        # ❌ Initialization Timeout
         
-        This is a simplified version for testing Hugging Face Spaces deployment.
-        """)
+        The system took too long to initialize. This usually happens when:
+        1. Vector store creation is slow
+        2. Too many modules are being loaded at startup
         
-        with gr.Row():
-            with gr.Column():
-                question_input = gr.Textbox(
-                    label="Your Question",
-                    placeholder="Ask anything about the car manual...",
-                    lines=3
-                )
-                submit_btn = gr.Button("Submit", variant="primary")
-                
-            with gr.Column():
-                answer_output = gr.Textbox(
-                    label="Answer",
-                    lines=10
-                )
+        **Suggested solutions:**
+        1. Reduce the number of modules loaded at startup
+        2. Use a smaller vector store
+        3. Implement lazy loading for optional features
+        """
+        return gr.Interface(
+            fn=lambda: error_msg,
+            inputs=None,
+            outputs=gr.Markdown(),
+            title="CSRC Car Manual RAG System",
+        )
+    except Exception as e:
+        print(f"❌ Error initializing system: {e}")
+        import traceback
+        traceback.print_exc()
+        import gradio as gr
+        
+        error_msg = f"""
+        # ❌ Initialization Error
+        
+        **Error:** {str(e)}
+        
+        **Possible solutions:**
+        1. Check if OPENAI_API_KEY is set in Spaces Secrets (Settings > Secrets)
+        2. Ensure PDF files are in the `car_manual/` directory
+        3. Check the logs for more details
         
-        gr.Examples(
-            examples=[
-                ["What are the main features of the adaptive cruise control?"],
-                ["How do I use the parking assist system?"],
-                ["What should I check during regular maintenance?"]
-            ],
-            inputs=question_input
+        **Traceback:**
+        ```
+        {traceback.format_exc()}
+        ```
+        """
+        
+        return gr.Interface(
+            fn=lambda: error_msg,
+            inputs=None,
+            outputs=gr.Markdown(),
+            title="CSRC Car Manual RAG System",
         )
+    
+    # Build Gradio interface with timeout
+    print("\n🌐 Building Gradio interface...")
+    try:
+        print("⏱️  Creating interface (max 30 seconds)...")
+        with timeout(30):
+            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"]
+            )
+            
+            print("📦 Creating interface components...")
+            demo = interface_builder.create_interface()
+        print("✅ Gradio interface created successfully!")
+        return demo
+    except TimeoutError:
+        print("❌ Gradio interface creation timed out!")
+        import gradio as gr
+        error_msg = """
+        # ❌ Interface Creation Timeout
         
-        submit_btn.click(
-            fn=query_rag,
-            inputs=question_input,
-            outputs=answer_output
+        The Gradio interface took too long to create. This usually happens when:
+        1. Too many components are being created
+        2. Complex initialization in component callbacks
+        
+        **Suggested solutions:**
+        1. Simplify the interface
+        2. Use lazy loading for complex components
+        3. Move initialization logic out of interface creation
+        """
+        return gr.Interface(
+            fn=lambda: error_msg,
+            inputs=None,
+            outputs=gr.Markdown(),
+            title="CSRC Car Manual RAG System",
         )
+    except Exception as e:
+        print(f"❌ Error building Gradio interface: {e}")
+        import traceback
+        traceback.print_exc()
         
-        gr.Markdown("""
-        ---
-        ### Status
-        - ✅ Using vector store: `{}`
-        - 🔑 API Key: {}
-        """.format(
-            VECTOR_STORE_ID,
-            "✅ Set" if OPENAI_API_KEY else "❌ Not Set"
-        ))
-    
-    return demo
+        import gradio as gr
+        error_msg = f"""
+        # ❌ Interface Building Error
+        
+        **Error:** {str(e)}
+        
+        **Traceback:**
+        ```
+        {traceback.format_exc()}
+        ```
+        """
+        
+        return gr.Interface(
+            fn=lambda: error_msg,
+            inputs=None,
+            outputs=gr.Markdown(),
+            title="CSRC Car Manual RAG System",
+        )
+
+
+# Prevent multiple initializations
+_app_instance = None
 
+def get_app():
+    """Get or create the app instance (singleton pattern)"""
+    global _app_instance
+    if _app_instance is None:
+        print("🔄 Creating new app instance...")
+        _app_instance = create_app()
+        print("✅ App instance created!")
+    else:
+        print("♻️  Reusing existing app instance")
+    return _app_instance
 
-# Create and launch
-print("🔄 Creating minimal app...")
-demo = create_interface()
-print("✅ App created!")
 
+# For Hugging Face Spaces
 if __name__ == "__main__":
-    print("🚀 Launching app...")
-    demo.launch()
+    demo = get_app()
+    demo.launch()
+else:
+    # Module-level variable for Spaces auto-detection
+    demo = get_app()