Upload app.py

app.py

@@ -0,0 +1,260 @@
+"""
+Hugging Face Spaces Entry Point for CSRC Car Manual RAG System
+This is the entry point for Hugging Face Spaces deployment
+
+Note: For local development, use main.py instead.
+"""
+import os
+import sys
+from pathlib import Path
+
+# Detect if running in Hugging Face Spaces
+IS_SPACES = os.getenv("SPACE_ID") is not None or os.getenv("HF_SPACE") is not None
+
+# 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")
+
+# 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 initialize_system(config: Config) -> dict:
+    """Initialize the RAG system 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()
+        
+        if not pdf_files:
+            raise ValueError(f"No PDF files found in {config.car_manual_dir}")
+        
+        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")
+        
+        vector_store_id = vector_store_details["id"]
+        config.save_vector_store_id(vector_store_id, config.vector_store_name)
+        
+        # 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
+    rag_engine = RAGQueryEngine(client, vector_store_id, config.model)
+    
+    # Initialize question generator
+    question_generator = QuestionGenerator(client, rag_engine)
+    
+    # Initialize knowledge graph generator
+    knowledge_graph = KnowledgeGraphGenerator(client, vector_store_id, str(config.output_dir))
+    
+    # Initialize personalized learning (if available)
+    user_profiling = None
+    learning_path_generator = None
+    adaptive_engine = None
+    
+    if PERSONALIZED_LEARNING_AVAILABLE:
+        try:
+            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 Exception as e:
+            print(f"⚠️ Error initializing Personalized Learning System: {e}")
+    
+    # Initialize proactive learning (if available)
+    proactive_engine = None
+    if PROACTIVE_LEARNING_AVAILABLE and user_profiling:
+        try:
+            proactive_engine = ProactiveLearningEngine(
+                client, rag_engine, user_profiling, adaptive_engine, config.available_topics
+            )
+            print("✅ Proactive Learning Assistance initialized!")
+        except Exception as e:
+            print(f"⚠️ Error initializing Proactive Learning Assistance: {e}")
+    
+    # Initialize scenario contextualization (if available)
+    enhanced_rag_engine = None
+    if SCENARIO_CONTEXTUALIZATION_AVAILABLE:
+        try:
+            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 Exception as e:
+            print(f"⚠️ Error initializing Scenario Contextualization: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    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
+    }
+
+
+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)
+    
+    # Load configuration
+    config = Config()
+    
+    # Initialize system
+    try:
+        components = initialize_system(config)
+    except Exception as e:
+        print(f"❌ Error initializing system: {e}")
+        import gradio as gr
+        
+        # Create error interface
+        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
+        """
+        
+        def error_display():
+            return error_msg
+        
+        error_interface = gr.Interface(
+            fn=error_display,
+            inputs=None,
+            outputs=gr.Markdown(),
+            title="CSRC Car Manual RAG System",
+            description="An error occurred during initialization. Please check the logs."
+        )
+        return error_interface
+    
+    # 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"]
+    )
+    
+    demo = interface_builder.create_interface()
+    return 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()
+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
+        
+        **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()}
+        ```
+        """
+    
+    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."
+    )
+
+    
+