Update app/streamlit_app.py

app/streamlit_app.py

@@ -279,116 +279,6 @@ class StreamlitAppManager:
             logger.warning(f"Could not fetch traffic status: {e}")
             return None
 
-    def trigger_manual_operation(self, operation_type: str, parameters: dict = None, async_execution: bool = True) -> dict:
-        """Trigger a manual operation via API"""
-        try:
-            if not self.api_available:
-                return {'error': 'API not available'}
-            
-            request_data = {
-                'operation_type': operation_type,
-                'parameters': parameters or {},
-                'async_execution': async_execution,
-                'priority': 5,
-                'timeout_seconds': 300
-            }
-            
-            response = self.session.post(
-                f"{self.config['api_url']}/operations/trigger",
-                json=request_data,
-                timeout=30
-            )
-            
-            if response.status_code == 200:
-                return response.json()
-            else:
-                return {'error': f'API Error: {response.status_code} - {response.text}'}
-        
-        except Exception as e:
-            return {'error': f'Request failed: {str(e)}'}
-    
-    def get_operation_status(self, operation_id: str) -> dict:
-        """Get status of a triggered operation"""
-        try:
-            if not self.api_available:
-                return {'error': 'API not available'}
-            
-            response = self.session.get(
-                f"{self.config['api_url']}/operations/{operation_id}/status",
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                return response.json()
-            else:
-                return {'error': f'API Error: {response.status_code}'}
-        
-        except Exception as e:
-            return {'error': f'Request failed: {str(e)}'}
-    
-    def list_operations(self, status_filter: str = None, limit: int = 20) -> dict:
-        """List recent operations"""
-        try:
-            if not self.api_available:
-                return {'error': 'API not available'}
-            
-            params = {'limit': limit}
-            if status_filter:
-                params['status'] = status_filter
-            
-            response = self.session.get(
-                f"{self.config['api_url']}/operations",
-                params=params,
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                return {'operations': response.json()}
-            else:
-                return {'error': f'API Error: {response.status_code}'}
-        
-        except Exception as e:
-            return {'error': f'Request failed: {str(e)}'}
-    
-    def get_available_operation_types(self) -> dict:
-        """Get available operation types"""
-        try:
-            if not self.api_available:
-                return {'error': 'API not available'}
-            
-            response = self.session.get(
-                f"{self.config['api_url']}/operations/types",
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                return response.json()
-            else:
-                return {'error': f'API Error: {response.status_code}'}
-        
-        except Exception as e:
-            return {'error': f'Request failed: {str(e)}'}
-    
-    def cancel_operation(self, operation_id: str) -> dict:
-        """Cancel a pending operation"""
-        try:
-            if not self.api_available:
-                return {'error': 'API not available'}
-            
-            response = self.session.post(
-                f"{self.config['api_url']}/operations/{operation_id}/cancel",
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                return response.json()
-            else:
-                return {'error': f'API Error: {response.status_code}'}
-        
-        except Exception as e:
-            return {'error': f'Request failed: {str(e)}'}
-
-
 
 # Initialize app manager
 app_manager = StreamlitAppManager()
@@ -1165,15 +1055,14 @@ def main():
                 '<div class="error-message">🔴 API Service: Offline</div>', unsafe_allow_html=True)
 
     # Main content area
-    tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8 = st.tabs([
+    tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs([
         "🔍 Prediction",
         "📊 Batch Analysis", 
         "📈 Analytics",
         "🎯 Model Training",
         "📋 Logs",
         "⚙️ System Status",
-        "📊 Monitoring",  # New monitoring tab
-        "⚙️ Manual Triggers"
+        "📊 Monitoring"  # New monitoring tab
     ])
 
 
@@ -1704,11 +1593,6 @@ def main():
         st.divider()
         render_deployment_status()
 
-    
-    # Tab 8: Manual Triggers
-     render_manual_triggers_tab()
-
-
 def render_system_status():
     """Render system status tab"""
     st.header("System Status & Monitoring")
@@ -1933,310 +1817,6 @@ def render_deployment_status():
     else:
         st.warning("Deployment status not available")
 
-
-# Manual Triggering Endpoint UI
-def render_manual_triggers_tab():
-    """Render the manual triggers tab"""
-    st.header("⚙️ Manual System Operations")
-    
-    # Quick status check
-    col1, col2 = st.columns([3, 1])
-    
-    with col1:
-        if st.session_state.get('last_operation_check'):
-            last_check = st.session_state.last_operation_check
-            st.info(f"Last operation check: {last_check}")
-        else:
-            st.info("No recent operations")
-    
-    with col2:
-        if st.button("🔄 Refresh Status", use_container_width=True):
-            st.session_state.last_operation_check = datetime.now().strftime('%H:%M:%S')
-            st.rerun()
-    
-    # Initialize session state for operations
-    if 'triggered_operations' not in st.session_state:
-        st.session_state.triggered_operations = {}
-    
-    # Operation trigger section
-    st.subheader("🚀 Available Operations")
-    
-    # Get available operation types
-    operation_types_data = app_manager.get_available_operation_types()
-    
-    if 'error' in operation_types_data:
-        st.error(f"Could not load operation types: {operation_types_data['error']}")
-        return
-    
-    available_ops = operation_types_data.get('available_operations', {})
-    
-    # Create operation trigger interface
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        # Operation selection
-        operation_names = {
-            'data_validation': 'Data Validation',
-            'model_health_check': 'Model Health Check',
-            'system_cleanup': 'System Cleanup',
-            'metrics_export': 'Metrics Export',
-            'log_rotation': 'Log Rotation',
-            'cache_refresh': 'Cache Refresh',
-            'data_quality_audit': 'Data Quality Audit',
-            'prediction_batch_test': 'Prediction Batch Test'
-        }
-        
-        selected_operation = st.selectbox(
-            "Select Operation:",
-            options=list(operation_names.keys()),
-            format_func=lambda x: operation_names[x],
-            index=0
-        )
-        
-        # Show operation description
-        if selected_operation in available_ops:
-            op_info = available_ops[selected_operation]
-            st.info(f"**Description:** {op_info['description']}")
-            st.caption(f"**Typical Duration:** {op_info['typical_duration']}")
-    
-    with col2:
-        # Execution mode
-        async_mode = st.checkbox("Async Execution", value=True, 
-                                help="Run operation in background (recommended)")
-        
-        # Priority setting
-        priority = st.selectbox("Priority", options=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 
-                               index=4, help="1 = Highest, 10 = Lowest")
-    
-    # Operation-specific parameters
-    st.subheader("⚙️ Operation Parameters")
-    parameters = {}
-    
-    if selected_operation == 'data_validation':
-        parameters['include_integrity_check'] = st.checkbox("Include Integrity Check", value=True)
-    
-    elif selected_operation == 'model_health_check':
-        parameters['test_count'] = st.number_input("Number of Test Predictions", 
-                                                  min_value=1, max_value=20, value=4)
-    
-    elif selected_operation == 'system_cleanup':
-        parameters['clean_cache'] = st.checkbox("Clean Cache Files", value=False)
-    
-    elif selected_operation == 'metrics_export':
-        parameters['format'] = st.selectbox("Export Format", options=['json'], index=0)
-        parameters['include_raw_data'] = st.checkbox("Include Raw Data", value=False)
-    
-    elif selected_operation == 'log_rotation':
-        col_a, col_b = st.columns(2)
-        with col_a:
-            parameters['max_file_size_mb'] = st.number_input("Max File Size (MB)", 
-                                                           min_value=1, max_value=100, value=10)
-        with col_b:
-            parameters['max_files_per_type'] = st.number_input("Max Files to Keep", 
-                                                             min_value=1, max_value=20, value=5)
-    
-    elif selected_operation == 'cache_refresh':
-        parameters['regenerate_cache'] = st.checkbox("Regenerate Cache", value=True)
-    
-    elif selected_operation == 'prediction_batch_test':
-        col_a, col_b = st.columns(2)
-        with col_a:
-            parameters['num_tests'] = st.number_input("Number of Tests", 
-                                                    min_value=1, max_value=50, value=10)
-        with col_b:
-            parameters['test_timeout'] = st.number_input("Test Timeout (seconds)", 
-                                                       min_value=10, max_value=120, value=30)
-    
-    # Trigger button
-    st.divider()
-    
-    col1, col2, col3 = st.columns([2, 1, 1])
-    
-    with col1:
-        if st.button(f"▶️ Execute {operation_names[selected_operation]}", 
-                     type="primary", use_container_width=True):
-            
-            with st.spinner(f"Triggering {operation_names[selected_operation]}..."):
-                result = app_manager.trigger_manual_operation(
-                    operation_type=selected_operation,
-                    parameters=parameters,
-                    async_execution=async_mode
-                )
-            
-            if 'error' in result:
-                st.error(f"Failed to trigger operation: {result['error']}")
-            else:
-                operation_id = result['operation_id']
-                st.session_state.triggered_operations[operation_id] = {
-                    'operation_type': selected_operation,
-                    'operation_name': operation_names[selected_operation],
-                    'triggered_at': datetime.now().isoformat(),
-                    'status': result['status'],
-                    'async_mode': async_mode
-                }
-                
-                st.success(f"✅ Operation triggered successfully!")
-                st.info(f"**Operation ID:** {operation_id}")
-                st.info(f"**Status:** {result['status']}")
-                st.info(f"**Estimated Duration:** {result['estimated_duration']}")
-                
-                if async_mode:
-                    st.info("Operation is running in the background. Check status below.")
-    
-    with col2:
-        # Quick operation buttons
-        st.write("**Quick Actions:**")
-        if st.button("🔍 Health Check", use_container_width=True):
-            result = app_manager.trigger_manual_operation('model_health_check', {}, True)
-            if 'operation_id' in result:
-                st.success(f"Health check started: {result['operation_id'][:8]}...")
-    
-    with col3:
-        if st.button("🧹 Quick Cleanup", use_container_width=True):
-            result = app_manager.trigger_manual_operation('system_cleanup', {'clean_cache': False}, True)
-            if 'operation_id' in result:
-                st.success(f"Cleanup started: {result['operation_id'][:8]}...")
-    
-    # Operation status monitoring
-    st.divider()
-    st.subheader("📊 Operation Status Monitor")
-    
-    # Recent operations from session state
-    if st.session_state.triggered_operations:
-        st.write("**Recent Operations (This Session):**")
-        
-        for op_id, op_info in list(st.session_state.triggered_operations.items())[-5:]:
-            with st.expander(f"{op_info['operation_name']} - {op_id[:8]}... ({op_info['status']})"):
-                col1, col2 = st.columns([3, 1])
-                
-                with col1:
-                    st.write(f"**Operation:** {op_info['operation_name']}")
-                    st.write(f"**ID:** {op_id}")
-                    st.write(f"**Triggered:** {op_info['triggered_at']}")
-                    st.write(f"**Mode:** {'Async' if op_info['async_mode'] else 'Sync'}")
-                
-                with col2:
-                    if st.button(f"🔄 Check Status", key=f"check_{op_id}"):
-                        status_result = app_manager.get_operation_status(op_id)
-                        
-                        if 'error' in status_result:
-                            st.error(f"Status check failed: {status_result['error']}")
-                        else:
-                            # Update session state
-                            st.session_state.triggered_operations[op_id]['status'] = status_result['status']
-                            
-                            # Display detailed status
-                            st.json(status_result)
-                            
-                            # Show results if completed
-                            if status_result['status'] == 'completed' and status_result.get('result_data'):
-                                st.success("✅ Operation completed successfully!")
-                                with st.expander("📋 Results"):
-                                    st.json(status_result['result_data'])
-                            
-                            elif status_result['status'] == 'failed':
-                                st.error("❌ Operation failed!")
-                                if status_result.get('error_message'):
-                                    st.error(f"Error: {status_result['error_message']}")
-    
-    # All operations from API
-    st.subheader("📋 All Recent Operations")
-    
-    col1, col2, col3 = st.columns(3)
-    
-    with col1:
-        status_filter = st.selectbox(
-            "Filter by Status:",
-            options=[None, "pending", "running", "completed", "failed", "cancelled"],
-            format_func=lambda x: "All" if x is None else x.title()
-        )
-    
-    with col2:
-        limit = st.number_input("Max Results", min_value=5, max_value=50, value=20)
-    
-    with col3:
-        if st.button("🔍 Load Operations", use_container_width=True):
-            operations_result = app_manager.list_operations(status_filter, limit)
-            
-            if 'error' in operations_result:
-                st.error(f"Failed to load operations: {operations_result['error']}")
-            else:
-                operations = operations_result.get('operations', [])
-                
-                if operations:
-                    st.success(f"Loaded {len(operations)} operations")
-                    
-                    # Create operations dataframe
-                    ops_data = []
-                    for op in operations:
-                        ops_data.append({
-                            'ID': op['operation_id'][:8] + '...',
-                            'Type': op['operation_type'].replace('_', ' ').title(),
-                            'Status': op['status'].title(),
-                            'Started': op['started_at'][:19] if op['started_at'] else 'N/A',
-                            'Duration': f"{op['duration_seconds']:.1f}s" if op.get('duration_seconds') else 'N/A',
-                            'Full ID': op['operation_id']
-                        })
-                    
-                    df = pd.DataFrame(ops_data)
-                    
-                    # Display operations table
-                    st.dataframe(df[['ID', 'Type', 'Status', 'Started', 'Duration']], 
-                               use_container_width=True)
-                    
-                    # Detailed view for selected operation
-                    selected_short_id = st.selectbox(
-                        "View Details for Operation:",
-                        options=df['ID'].tolist(),
-                        index=0 if df['ID'].tolist() else None
-                    )
-                    
-                    if selected_short_id:
-                        selected_full_id = df[df['ID'] == selected_short_id]['Full ID'].iloc[0]
-                        selected_op = next(op for op in operations if op['operation_id'] == selected_full_id)
-                        
-                        st.subheader(f"📄 Operation Details: {selected_short_id}")
-                        
-                        col_detail1, col_detail2 = st.columns(2)
-                        
-                        with col_detail1:
-                            st.write(f"**Full ID:** {selected_op['operation_id']}")
-                            st.write(f"**Type:** {selected_op['operation_type']}")
-                            st.write(f"**Status:** {selected_op['status']}")
-                            st.write(f"**Started:** {selected_op['started_at']}")
-                        
-                        with col_detail2:
-                            if selected_op.get('completed_at'):
-                                st.write(f"**Completed:** {selected_op['completed_at']}")
-                            if selected_op.get('duration_seconds'):
-                                st.write(f"**Duration:** {selected_op['duration_seconds']:.2f} seconds")
-                            if selected_op.get('error_message'):
-                                st.error(f"**Error:** {selected_op['error_message']}")
-                        
-                        # Show logs
-                        if selected_op.get('logs'):
-                            with st.expander("📜 Operation Logs"):
-                                for log_entry in selected_op['logs']:
-                                    st.text(log_entry)
-                        
-                        # Show results
-                        if selected_op.get('result_data'):
-                            with st.expander("📊 Results Data"):
-                                st.json(selected_op['result_data'])
-                        
-                        # Action buttons
-                        if selected_op['status'] == 'pending':
-                            if st.button(f"❌ Cancel Operation", key=f"cancel_{selected_full_id}"):
-                                cancel_result = app_manager.cancel_operation(selected_full_id)
-                                if 'error' in cancel_result:
-                                    st.error(f"Cancel failed: {cancel_result['error']}")
-                                else:
-                                    st.success("Operation cancelled successfully!")
-                                    st.rerun()
-                else:
-                    st.info("No operations found")
-
-
 # Auto-refresh logic
 if st.session_state.auto_refresh:
     time_since_refresh = datetime.now() - st.session_state.last_refresh