change approach via applauncher

app_launcher.py

@@ -0,0 +1,217 @@
+"""
+Streamlit app launcher - A simpler wrapper to ensure proper initialization
+Place this file in the root of your project directory
+"""
+import streamlit as st
+import os
+import sys
+import logging
+from pathlib import Path
+import time
+
+# Configure page
+st.set_page_config(
+    page_title="Assurant 10-K Analysis & Risk Assessment App",
+    page_icon="📊",
+    layout="wide"
+)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Add project root to path
+project_root = Path(__file__).parent.absolute()
+sys.path.insert(0, str(project_root))
+logger.info(f"Project root: {project_root}")
+
+# Initialize session state
+if "initialized" not in st.session_state:
+    st.session_state["initialized"] = False
+    st.session_state["initialization_error"] = None
+    st.session_state["chat_history"] = []
+
+def initialize_app():
+    """Initialize all app components safely"""
+    if st.session_state["initialized"]:
+        return True
+    
+    try:
+        st.info("Initializing application components... This may take a moment.")
+        
+        # Import key components with proper error handling
+        try:
+            from src.llamaindex_app.instrumentation import setup_instrumentation
+            from src.llamaindex_app.config import Settings
+            from src.llamaindex_app.index_manager import IndexManager
+            from src.llamaindex_app.classifier import QueryClassifier
+            from src.llamaindex_app.main import init_openai_client, process_interaction
+            logger.info("Successfully imported all required modules")
+        except ImportError as e:
+            logger.error(f"Import error: {e}")
+            st.session_state["initialization_error"] = f"Failed to import modules: {str(e)}"
+            return False
+            
+        # Initialize step by step
+        # 1. Settings
+        settings = Settings()
+        st.session_state["settings"] = settings
+        logger.info("Settings loaded")
+        
+        # 2. OpenAI client
+        try:
+            openai_client = init_openai_client()
+            st.session_state["openai_client"] = openai_client
+            logger.info("OpenAI client initialized")
+        except Exception as e:
+            logger.error(f"OpenAI client error: {e}")
+            st.session_state["initialization_error"] = f"OpenAI client error: {str(e)}"
+            return False
+            
+        # 3. Instrumentation
+        try:
+            tracer_provider = setup_instrumentation()
+            tracer = tracer_provider.get_tracer("llamaindex_app")
+            st.session_state["tracer"] = tracer
+            logger.info("Instrumentation setup complete")
+        except Exception as e:
+            logger.error(f"Instrumentation error: {e}")
+            st.session_state["initialization_error"] = f"Instrumentation error: {str(e)}"
+            return False
+        
+        # 4. Index manager and query engine (most resource-intensive step)
+        try:
+            logger.info("Creating IndexManager...")
+            index_manager = IndexManager(openai_client=openai_client)
+            logger.info("Getting query engine...")
+            query_engine = index_manager.get_query_engine()
+            
+            # Store in session state
+            st.session_state["index_manager"] = index_manager
+            st.session_state["query_engine"] = query_engine
+            logger.info("Index manager and query engine initialized")
+        except Exception as e:
+            logger.error(f"Index manager error: {e}")
+            st.session_state["initialization_error"] = f"Index/query engine error: {str(e)}"
+            return False
+            
+        # 5. Classifier (depends on query engine)
+        try:
+            classifier = QueryClassifier(
+                query_engine=query_engine,
+                openai_client=openai_client
+            )
+            st.session_state["classifier"] = classifier
+            logger.info("Query classifier initialized")
+        except Exception as e:
+            logger.error(f"Classifier error: {e}")
+            st.session_state["initialization_error"] = f"Classifier error: {str(e)}"
+            return False
+        
+        # If we get here, we're fully initialized
+        st.session_state["initialized"] = True
+        logger.info("App initialization complete")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Unexpected initialization error: {e}", exc_info=True)
+        st.session_state["initialization_error"] = f"Unexpected error: {str(e)}"
+        return False
+
+def main():
+    """Main app function"""
+    st.title("Assurant 10-K Analysis & Risk Assessment App")
+    
+    # Initialize app
+    if not st.session_state["initialized"]:
+        with st.spinner("Setting up application components..."):
+            success = initialize_app()
+            
+        if not success:
+            st.error(f"Initialization failed: {st.session_state['initialization_error']}")
+            
+            # Show troubleshooting info
+            with st.expander("Troubleshooting information"):
+                st.write("Please check that:")
+                st.write("1. All required environment variables are set (especially OPENAI_API_KEY)")
+                st.write("2. Your data directory contains the necessary PDF files")
+                st.write("3. All dependencies are installed correctly")
+                
+                # Show environment info
+                st.subheader("Environment")
+                for key, value in os.environ.items():
+                    if key.startswith(("OPENAI_", "LLAMA_", "STREAMLIT_")):
+                        masked_value = "****" if "KEY" in key else value
+                        st.write(f"- {key}: {masked_value}")
+            
+            return
+    
+    # App successfully initialized, show the interface
+    with st.sidebar:
+        st.subheader("About this app")
+        st.write("""
+        This application analyzes Assurant's 10-K reports and provides risk assessment.
+        
+        You can ask questions about:
+        - Assurant's financial performance
+        - Risk factors
+        - Business operations
+        - Market trends
+        """)
+    
+    # Query section
+    st.subheader("Ask a question about Assurant's 10-K")
+    user_question = st.text_input("Your question:", placeholder="e.g., How did Assurant perform last quarter?")
+    
+    if st.button("Submit Question") and user_question.strip():
+        # Get components from session state
+        query_engine = st.session_state["query_engine"]
+        classifier = st.session_state["classifier"]
+        tracer = st.session_state["tracer"]
+        session_id = str(hash(user_question))
+        
+        with st.spinner("Analyzing your question..."):
+            from src.llamaindex_app.main import process_interaction
+            
+            response, error = process_interaction(
+                query_engine,
+                classifier,
+                tracer,
+                user_question,
+                session_id
+            )
+            
+            # Store in chat history
+            st.session_state["chat_history"].append(("user", user_question))
+            
+            if error:
+                st.session_state["chat_history"].append(("assistant", f"Error: {error}"))
+                st.error(f"Error: {error}")
+            else:
+                st.session_state["chat_history"].append(("assistant", response.response))
+                
+                # Store sources if available
+                if hasattr(response, "source_nodes") and response.source_nodes:
+                    sources = "\n".join([
+                        f"- {node.metadata.get('file_name', 'Unknown source')}"
+                        for node in response.source_nodes
+                    ])
+                    st.session_state["chat_history"].append(("sources", sources))
+    
+    # Display conversation history
+    st.subheader("Conversation")
+    for idx, (role, content) in enumerate(st.session_state["chat_history"]):
+        if role == "user":
+            st.markdown(f"**You**: {content}")
+        elif role == "assistant":
+            st.markdown(f"**Assistant**: {content}")
+        elif role == "sources":
+            with st.expander("View Sources"):
+                st.markdown(content)
+
+if __name__ == "__main__":
+    main()