Upload app.py

app.py

@@ -23,126 +23,90 @@ st.set_page_config(
 )
 
 def setup_llm_provider_gui():
-    """Setup GUI for LLM provider and API key management"""
+    """Setup GUI for temporary LLM provider and API key input"""
     st.subheader("🔑 LLM Provider Setup")
+    st.info("💡 API keys are used temporarily for this session only and are not saved permanently.")
     
-    # Get available providers
-    available_providers = get_available_providers()
+    # Provider selection
+    provider_options = {provider_info['name']: provider_id 
+                       for provider_id, provider_info in LLM_PROVIDERS.items()}
     
-    if not available_providers:
-        st.warning("⚠️ No API keys found. Please configure at least one LLM provider:")
-        
-        # Show setup for each provider
-        for provider_id, provider_info in LLM_PROVIDERS.items():
-            with st.expander(f"🔧 Setup {provider_info['name']}"):
-                st.markdown(f"**{provider_info['description']}**")
-                
-                # API key input
-                api_key_input = st.text_input(
-                    f"Enter your {provider_info['name']} API Key:",
-                    type="password",
-                    placeholder=get_api_key_placeholder(provider_id),
-                    help=get_provider_help_text(provider_id),
-                    key=f"api_key_{provider_id}"
-                )
-                
-                if st.button(f"💾 Save {provider_info['name']} Key", key=f"save_{provider_id}"):
-                    if api_key_input and validate_api_key_format(provider_id, api_key_input):
-                        try:
-                            save_provider_key_to_env(provider_id, api_key_input)
-                            st.success(f"✅ {provider_info['name']} API key saved successfully!")
-                            st.info("🔄 Reloading application to activate your new API key...")
-                            st.rerun()
-                        except Exception as e:
-                            st.error(f"❌ Failed to save API key: {str(e)}")
-                    else:
-                        st.error(f"❌ Invalid API key format for {provider_info['name']}")
-    else:
-        # Show configured providers
-        st.success(f"✅ {len(available_providers)} provider(s) configured")
-        
-        for provider_id in available_providers:
-            provider_info = LLM_PROVIDERS[provider_id]
-            current_key = get_api_key(provider_id)
-            masked_key = mask_api_key(current_key)
+    selected_provider_name = st.selectbox(
+        "Select LLM Provider:",
+        options=list(provider_options.keys()),
+        help="Choose your preferred LLM provider"
+    )
+    
+    selected_provider = provider_options[selected_provider_name]
+    provider_info = LLM_PROVIDERS[selected_provider]
+    
+    st.markdown(f"**{provider_info['description']}**")
+    
+    # API key input
+    session_key = f"temp_api_key_{selected_provider}"
+    current_key = st.session_state.get(session_key, "")
+    
+    api_key_input = st.text_input(
+        f"Enter your {provider_info['name']} API Key:",
+        value=current_key,
+        type="password",
+        placeholder=get_api_key_placeholder(selected_provider),
+        help=f"{get_provider_help_text(selected_provider)} (Temporary use only - not saved)",
+        key=f"api_key_input_{selected_provider}"
+    )
+    
+    # Validate and store in session
+    if api_key_input:
+        if validate_api_key_format(selected_provider, api_key_input):
+            st.session_state[session_key] = api_key_input
+            st.session_state['selected_provider'] = selected_provider
+            st.success(f"✅ {provider_info['name']} API key ready for use")
             
-            # Check if user wants to change this provider's key
-            if st.session_state.get(f'show_key_input_{provider_id}'):
-                # Show input form for changing API key
-                with st.expander(f"🔧 Change {provider_info['name']} API Key", expanded=True):
-                    new_api_key = st.text_input(
-                        f"Enter new {provider_info['name']} API Key:",
-                        type="password",
-                        placeholder=get_api_key_placeholder(provider_id),
-                        key=f"new_key_{provider_id}"
-                    )
-                    
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        if st.button(f"💾 Update {provider_info['name']} Key", key=f"update_{provider_id}"):
-                            if new_api_key and validate_api_key_format(provider_id, new_api_key):
-                                try:
-                                    save_provider_key_to_env(provider_id, new_api_key)
-                                    st.success(f"✅ {provider_info['name']} API key updated successfully!")
-                                    st.session_state[f'show_key_input_{provider_id}'] = False
-                                    st.rerun()
-                                except Exception as e:
-                                    st.error(f"❌ Failed to update API key: {str(e)}")
-                            else:
-                                st.error(f"❌ Invalid API key format for {provider_info['name']}")
-                    
-                    with col2:
-                        if st.button("❌ Cancel", key=f"cancel_change_{provider_id}"):
-                            st.session_state[f'show_key_input_{provider_id}'] = False
-                            st.rerun()
-            else:
-                # Show normal display with change button
-                col1, col2 = st.columns([3, 1])
-                with col1:
-                    st.info(f"**{provider_info['name']}**: {masked_key}")
-                with col2:
-                    if st.button(f"🔄 Change", key=f"change_{provider_id}"):
-                        st.session_state[f'show_key_input_{provider_id}'] = True
-                        st.rerun()
-        
-        # Add new provider section
-        st.markdown("---")
-        if st.button("➕ Add Another Provider"):
-            st.session_state.show_add_provider = True
-            st.rerun()
-        
-        if st.session_state.get('show_add_provider'):
-            setup_additional_provider()
+            # Show masked key
+            masked_key = mask_api_key(api_key_input)
+            st.info(f"🔐 Current key: {masked_key}")
+        else:
+            st.error(f"❌ Invalid API key format for {provider_info['name']}")
+            if session_key in st.session_state:
+                del st.session_state[session_key]
+    else:
+        st.warning(f"⚠️ Please enter your {provider_info['name']} API key to continue")
+        if session_key in st.session_state:
+            del st.session_state[session_key]
+    
+    return selected_provider, api_key_input
 
 def get_current_provider_and_model():
-    """Get current provider and model from session state or defaults"""
-    # Check session state first
-    if 'selected_provider' in st.session_state and 'selected_model' in st.session_state:
-        return st.session_state.selected_provider, st.session_state.selected_model
-    
-    # Get defaults based on available providers
-    try:
-        return get_default_provider_and_model()
-    except:
-        # If no providers available, return None
-        return None, None
+    """Get current provider and model from session state"""
+    provider = st.session_state.get('selected_provider')
+    model = st.session_state.get('selected_model')
+    
+    # If no provider set, try to get first available one
+    if not provider:
+        available_providers = list(LLM_PROVIDERS.keys())
+        if available_providers:
+            provider = available_providers[0]
+    
+    # If no model set, try to get first available model for provider
+    if not model and provider:
+        available_models = get_models_for_provider(provider)
+        if available_models:
+            model = list(available_models.keys())[0]
+    
+    return provider, model
 
 def get_api_key_for_current_provider():
-    """Get API key for currently selected provider"""
+    """Get API key for currently selected provider from session state"""
     provider, _ = get_current_provider_and_model()
     if provider:
-        return get_api_key(provider)
-    return None
+        session_key = f"temp_api_key_{provider}"
+        return st.session_state.get(session_key, "")
+    return ""
 
-def refresh_provider_status():
-    """Force refresh of provider status after API key changes"""
-    from dotenv import load_dotenv
-    # Reload environment variables to pick up any .env file changes
-    load_dotenv(override=True)
-    
-    # Only clear cached states that are specifically related to stale API operations
-    # Don't clear active user interface states like show_key_input_
-    pass
+def is_provider_configured():
+    """Check if current provider is configured with API key"""
+    api_key = get_api_key_for_current_provider()
+    return bool(api_key and api_key.strip())
 
 def get_api_key_placeholder(provider_id):
     """Get placeholder text for API key input"""
@@ -186,117 +150,6 @@ def mask_api_key(api_key):
         return api_key[:8] + "..." + api_key[-4:]
     return "***configured***"
 
-def save_provider_key_to_env(provider_id, api_key):
-    """Save provider API key to .env file"""
-    env_var = LLM_PROVIDERS[provider_id]["api_key_env"]
-    env_path = ".env"
-    
-    try:
-        # Read existing content
-        env_content = ""
-        if os.path.exists(env_path):
-            with open(env_path, 'r') as f:
-                env_content = f.read()
-        
-        # Update or add the API key
-        lines = env_content.split('\n')
-        updated_lines = []
-        key_found = False
-        
-        for line in lines:
-            # Check for existing key (both active and commented)
-            if line.startswith(f"{env_var}=") or line.startswith(f"# {env_var}="):
-                # Replace with active key
-                updated_lines.append(f"{env_var}={api_key}")
-                key_found = True
-            else:
-                updated_lines.append(line)
-        
-        if not key_found:
-            # Add new key if not found
-            if updated_lines and updated_lines[-1] != '':
-                updated_lines.append('')
-            updated_lines.append(f"{env_var}={api_key}")
-        
-        # Write to file
-        with open(env_path, 'w') as f:
-            f.write('\n'.join(updated_lines))
-        
-        # CRITICAL FIX: Reload environment variables immediately
-        # Set the environment variable directly in the current process
-        os.environ[env_var] = api_key
-        
-        # Also reload the .env file to pick up any other changes
-        from dotenv import load_dotenv
-        load_dotenv(override=True)
-        
-    except Exception as e:
-        raise Exception(f"Failed to save {env_var}: {str(e)}")
-
-def setup_additional_provider():
-    """Setup additional provider interface"""
-    st.subheader("➕ Add Another Provider")
-    
-    # Get providers not yet configured
-    available_providers = get_available_providers()
-    unconfigured_providers = [p for p in LLM_PROVIDERS.keys() if p not in available_providers]
-    
-    if not unconfigured_providers:
-        st.info("✅ All providers are already configured!")
-        st.success("🎉 You have access to all available LLM providers")
-        if st.button("❌ Close"):
-            st.session_state.show_add_provider = False
-            st.rerun()
-        return
-    
-    # Provider selection
-    provider_names = {p: LLM_PROVIDERS[p]["name"] for p in unconfigured_providers}
-    selected_provider_name = st.selectbox(
-        "Select Provider to Configure:",
-        options=list(provider_names.values())
-    )
-    
-    # Find provider ID from name
-    selected_provider_id = None
-    for pid, pname in provider_names.items():
-        if pname == selected_provider_name:
-            selected_provider_id = pid
-            break
-    
-    if selected_provider_id:
-        provider_info = LLM_PROVIDERS[selected_provider_id]
-        st.markdown(f"**{provider_info['description']}**")
-        
-        # API key input
-        api_key_input = st.text_input(
-            f"Enter your {provider_info['name']} API Key:",
-            type="password",
-            placeholder=get_api_key_placeholder(selected_provider_id),
-            help=get_provider_help_text(selected_provider_id),
-            key=f"add_api_key_{selected_provider_id}"
-        )
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button(f"💾 Save {provider_info['name']} Key"):
-                if api_key_input and validate_api_key_format(selected_provider_id, api_key_input):
-                    try:
-                        save_provider_key_to_env(selected_provider_id, api_key_input)
-                        st.success(f"✅ {provider_info['name']} API key saved successfully!")
-                        st.info("🔄 Reloading application to activate your new API key...")
-                        st.session_state.show_add_provider = False
-                        st.rerun()
-                    except Exception as e:
-                        st.error(f"❌ Failed to save API key: {str(e)}")
-                else:
-                    st.error(f"❌ Invalid API key format for {provider_info['name']}")
-        
-        with col2:
-            if st.button("❌ Cancel"):
-                st.session_state.show_add_provider = False
-                st.rerun()
-
-
 def initialize_crewai_system():
     """Initialize CrewAI system with current settings"""
     provider, model = get_current_provider_and_model()
@@ -449,45 +302,25 @@ def main():
     st.title("🏗️ Soil Boring Log Analyzer")
     st.markdown("Upload soil boring logs (PDF/Image) to automatically extract and analyze soil layers using AI")
     
-    # Force refresh provider status on each run to catch any newly saved API keys
-    refresh_provider_status()
-    
     # Show system status
-    available_providers = get_available_providers()
-    if available_providers:
-        provider_names = [LLM_PROVIDERS[p]["name"] for p in available_providers]
-        st.success(f"✅ **Ready to use** - Configured providers: {', '.join(provider_names)}")
+    if is_provider_configured():
+        provider, _ = get_current_provider_and_model()
+        if provider:
+            provider_name = LLM_PROVIDERS[provider]["name"]
+            st.success(f"✅ **Ready to use** - Using {provider_name} (API key provided)")
     else:
-        st.info("🔧 **Setup Required** - Please configure at least one LLM provider below to start analyzing soil boring logs")
-    
-    # LLM Provider Management
-    available_providers = get_available_providers()
-    
-    if not available_providers:
-        st.error("⚠️ At least one LLM provider API key is required to use this application")
-        setup_llm_provider_gui()
-        return
+        st.info("🔧 **Setup Required** - Please enter your API key in the sidebar to start analyzing soil boring logs")
     
-    # Show provider management in sidebar
+    # LLM Provider Management in Sidebar
     with st.sidebar:
+        selected_provider, api_key = setup_llm_provider_gui()
+        
+        # Only show rest of sidebar if API key is provided
+        if not is_provider_configured():
+            st.warning("⚠️ Please enter a valid API key above to continue")
+            return
+        
         st.markdown("---")
-        setup_llm_provider_gui()
-    
-    # Initialize components lazily
-    if 'document_processor' not in st.session_state:
-        st.session_state.document_processor = DocumentProcessor()
-    
-    if 'agent' not in st.session_state:
-        st.session_state.agent = SoilAnalysisAgent()
-    
-    if 'visualizer' not in st.session_state:
-        st.session_state.visualizer = SoilProfileVisualizer()
-    
-    if 'analysis_results' not in st.session_state:
-        st.session_state.analysis_results = None
-    
-    # Sidebar
-    with st.sidebar:
         st.header("Upload Document")
         uploaded_file = st.file_uploader(
             "Choose a soil boring log file",
@@ -506,42 +339,9 @@ def main():
             help="CrewAI uses two specialized agents with quality control"
         )
         
-        # Provider and Model selection
-        st.subheader("🤖 LLM Provider & Model Selection")
-        
-        # Get available providers
-        available_providers = get_available_providers()
-        
-        if not available_providers:
-            st.error("⚠️ No LLM providers configured. Please set up at least one provider in the sidebar.")
-            return
-        
-        # Provider selection
-        provider_names = {p: LLM_PROVIDERS[p]["name"] for p in available_providers}
-        current_provider, current_model = get_current_provider_and_model()
-        
-        # Default provider selection
-        default_provider_name = None
-        if current_provider and current_provider in provider_names:
-            default_provider_name = provider_names[current_provider]
-        elif provider_names:
-            default_provider_name = list(provider_names.values())[0]
-        
-        selected_provider_name = st.selectbox(
-            "Select LLM Provider:",
-            options=list(provider_names.values()),
-            index=list(provider_names.values()).index(default_provider_name) if default_provider_name else 0,
-            help="Choose your preferred LLM provider"
-        )
-        
-        # Find provider ID from name
-        selected_provider = None
-        for pid, pname in provider_names.items():
-            if pname == selected_provider_name:
-                selected_provider = pid
-                break
-        
         # Model selection for selected provider
+        st.subheader("🤖 Model Selection")
+        
         if selected_provider:
             available_models = get_models_for_provider(selected_provider)
             
@@ -557,6 +357,7 @@ def main():
                     model_options[label] = model_id
                 
                 # Default model selection
+                current_model = st.session_state.get('selected_model')
                 default_model_label = None
                 if current_model and current_model in available_models:
                     for label, model_id in model_options.items():
@@ -568,7 +369,7 @@ def main():
                     default_model_label = list(model_options.keys())[0]
                 
                 selected_label = st.selectbox(
-                    f"Select Model for {selected_provider_name}:",
+                    f"Select Model:",
                     options=list(model_options.keys()),
                     index=list(model_options.keys()).index(default_model_label) if default_model_label else 0,
                     help="⭐ = Recommended | 📝 = Text-only (no image support)"
@@ -576,6 +377,9 @@ def main():
                 
                 selected_model = model_options[selected_label]
                 
+                # Store model selection in session state
+                st.session_state.selected_model = selected_model
+                
                 # Show model info
                 if selected_model in AVAILABLE_MODELS:
                     model_info = AVAILABLE_MODELS[selected_model]
@@ -591,14 +395,7 @@ def main():
                     else:
                         st.warning("📝 This model supports text-only analysis (images will be ignored)")
             else:
-                st.error(f"No models available for {selected_provider_name}")
-                selected_model = None
-        else:
-            selected_model = None
-        
-        # Store selections in session state
-        st.session_state.selected_provider = selected_provider
-        st.session_state.selected_model = selected_model
+                st.error(f"No models available for {LLM_PROVIDERS[selected_provider]['name']}")
         
         if st.button("🔄 Reset Analysis"):
             st.session_state.analysis_results = None
@@ -678,6 +475,24 @@ Notes: All strength values from SPT testing. Su calculated using Su=5*N for clay
                 except Exception as e:
                     st.error(f"❌ Sample analysis error: {str(e)}")
     
+    # Check if provider is configured before proceeding
+    if not is_provider_configured():
+        st.warning("⚠️ Please configure an API key in the sidebar to start using the application")
+        return
+    
+    # Initialize components lazily
+    if 'document_processor' not in st.session_state:
+        st.session_state.document_processor = DocumentProcessor()
+    
+    if 'agent' not in st.session_state:
+        st.session_state.agent = SoilAnalysisAgent()
+    
+    if 'visualizer' not in st.session_state:
+        st.session_state.visualizer = SoilProfileVisualizer()
+    
+    if 'analysis_results' not in st.session_state:
+        st.session_state.analysis_results = None
+    
     # Main content
     if uploaded_file is not None:
         # Process document