Create analytics_viewer.py

analytics_viewer.py

@@ -0,0 +1,679 @@
+"""
+Analysis Viewer Component for Pharmaceutical Analytics Application
+
+This module provides a dedicated view for watching the agents work in real-time,
+displaying generated code, SQL queries, and visualization steps as they happen.
+"""
+
+import streamlit as st
+import pandas as pd
+import time
+import plotly.graph_objects as go
+from datetime import datetime
+import json
+
+def render_progress_bar(current_step, steps=None):
+    """Render a progress bar for the current workflow state"""
+    if steps is None:
+        steps = ["planning", "data_collection", "analysis", "validation", "insights", "complete"]
+    
+    step_idx = steps.index(current_step) if current_step in steps else 0
+    progress = (step_idx + 1) / len(steps)
+    
+    st.progress(progress)
+    
+    # Step indicators with more detailed descriptions
+    cols = st.columns(5)
+    
+    step_descriptions = {
+        "planning": "Decomposes problem & plans analysis approach",
+        "data_collection": "Translates to SQL & retrieves data",
+        "analysis": "Performs statistical analysis & modeling",
+        "validation": "Validates results & checks quality",
+        "insights": "Creates visualizations & recommendations"
+    }
+    
+    with cols[0]:
+        check = "✅" if step_idx >= 0 else "🔄"
+        check = "🔄" if step_idx == 0 else check
+        st.markdown(f"{check} **Planning**")
+        if current_step == "planning":
+            st.caption(step_descriptions["planning"])
+    
+    with cols[1]:
+        check = "✅" if step_idx >= 1 else "⏳"
+        check = "🔄" if step_idx == 1 else check
+        st.markdown(f"{check} **Data Collection**")
+        if current_step == "data_collection":
+            st.caption(step_descriptions["data_collection"])
+    
+    with cols[2]:
+        check = "✅" if step_idx >= 2 else "⏳"
+        check = "🔄" if step_idx == 2 else check
+        st.markdown(f"{check} **Analysis**")
+        if current_step == "analysis":
+            st.caption(step_descriptions["analysis"])
+    
+    with cols[3]:
+        check = "✅" if step_idx >= 3 else "⏳"
+        check = "🔄" if step_idx == 3 else check
+        st.markdown(f"{check} **Validation**")
+        if current_step == "validation":
+            st.caption(step_descriptions["validation"])
+    
+    with cols[4]:
+        check = "✅" if step_idx >= 4 else "⏳"
+        check = "🔄" if step_idx == 4 else check
+        st.markdown(f"{check} **Insights**")
+        if current_step == "insights":
+            st.caption(step_descriptions["insights"])
+
+
+def render_planning_agent_view(state):
+    """Render the Planning Agent activity view"""
+    st.markdown("### 🧠 Planning Agent")
+    st.markdown("The Planning Agent is decomposing the problem and creating an analysis plan.")
+    
+    # Show input alert
+    alert_container = st.container(border=True)
+    with alert_container:
+        st.markdown("**Input Alert:**")
+        st.info(state.get("alert", ""))
+    
+    # Thinking animation or finished plan
+    if state.get("plan") is None:
+        # Show thinking animation
+        thinking_messages = [
+            "Identifying required data sources...",
+            "Determining appropriate analytical approaches...",
+            "Creating task dependency graph...",
+            "Designing validation strategy..."
+        ]
+        
+        thinking_placeholder = st.empty()
+        for i in range(len(thinking_messages)):
+            thinking_placeholder.info(thinking_messages[i % len(thinking_messages)])
+            time.sleep(0.5)
+    else:
+        # Show the created plan
+        plan = state.get("plan")
+        
+        # Show problem statement
+        st.markdown("#### 🎯 Problem Statement")
+        st.markdown(plan.problem_statement)
+        
+        # Show required data sources in a table
+        st.markdown("#### 📊 Required Data Sources")
+        data_sources_df = pd.DataFrame(plan.required_data_sources)
+        st.table(data_sources_df)
+        
+        # Show analysis approaches
+        st.markdown("#### 🔍 Analysis Approaches")
+        approaches_df = pd.DataFrame(plan.analysis_approaches)
+        st.table(approaches_df)
+        
+        # Show expected insights
+        st.markdown("#### 💡 Expected Insights")
+        for i, insight in enumerate(plan.expected_insights):
+            st.markdown(f"{i+1}. {insight}")
+
+
+def render_data_agent_view(state):
+    """Render the Data Agent activity view"""
+    st.markdown("### 🗃️ Data Agent")
+    st.markdown("The Data Agent is translating requirements into SQL queries and collecting data.")
+    
+    # Show data requests
+    st.markdown("#### 📋 Data Requests")
+    data_requests = state.get("data_requests", [])
+    
+    if not data_requests:
+        st.info("Preparing data requests...")
+    else:
+        for i, request in enumerate(data_requests):
+            with st.expander(f"Request {i+1}: {request.description}", expanded=True):
+                st.markdown(f"**Tables:** {', '.join(request.tables)}")
+                st.markdown(f"**Purpose:** {request.purpose}")
+    
+    # Show SQL generation and results
+    data_sources = state.get("data_sources", {})
+    if data_sources:
+        st.markdown("#### 📊 Generated Data Sources")
+        
+        for source_id, source in data_sources.items():
+            with st.expander(f"Data Source: {source.name}", expanded=True):
+                # Show SQL query (mocked here - in real implementation you'd extract from the pipeline)
+                if st.session_state.show_sql:
+                    mock_sql = f"""
+                    -- Query for {source.name}
+                    SELECT 
+                        r.region_name,
+                        p.product_name,
+                        strftime('%Y-%m', s.sale_date) as month,
+                        SUM(s.units_sold) as total_units,
+                        SUM(s.revenue) as total_revenue,
+                        SUM(s.margin) as total_margin
+                    FROM 
+                        sales s
+                    JOIN 
+                        regions r ON s.region_id = r.region_id
+                    JOIN
+                        products p ON s.product_id = p.product_id
+                    WHERE 
+                        p.product_id = 'DRX'
+                        AND s.sale_date >= date('now', '-90 days')
+                    GROUP BY 
+                        r.region_name, p.product_name, month
+                    ORDER BY 
+                        r.region_name, month;
+                    """
+                    st.code(mock_sql, language="sql")
+                
+                # Show data preview
+                st.markdown("**Data Preview:**")
+                st.dataframe(source.content.head(5), use_container_width=True)
+                st.caption(f"Shape: {source.content.shape[0]} rows, {source.content.shape[1]} columns")
+
+
+def render_analytics_agent_view(state):
+    """Render the Analytics Agent activity view"""
+    st.markdown("### 📊 Analytics Agent")
+    st.markdown("The Analytics Agent is performing statistical analysis and modeling.")
+    
+    # Show analytics requests
+    analysis_requests = state.get("analysis_requests", [])
+    if not analysis_requests:
+        st.info("Preparing analysis requests...")
+    else:
+        st.markdown("#### 📋 Analysis Requests")
+        for i, request in enumerate(analysis_requests):
+            st.markdown(f"**Request {i+1}:** {request.description} ({request.analysis_type})")
+    
+    # Show analysis results
+    analysis_results = state.get("analysis_results", {})
+    if analysis_results:
+        st.markdown("#### 📈 Analysis Results")
+        
+        for analysis_id, result in analysis_results.items():
+            with st.expander(f"Analysis: {result.name}", expanded=True):
+                # Show generated Python code
+                if st.session_state.show_code and result.code:
+                    st.markdown("**Generated Python Code:**")
+                    st.code(result.code, language="python")
+                
+                # Show insights
+                if result.insights:
+                    st.markdown("**Key Findings:**")
+                    for insight in result.insights:
+                        st.markdown(f"- **{insight.get('finding', '')}**: {insight.get('details', '')}")
+                
+                # Show metrics
+                if result.metrics:
+                    st.markdown("**Metrics:**")
+                    metrics_df = pd.DataFrame([result.metrics])
+                    st.table(metrics_df.T)
+                
+                # Show attribution
+                if result.attribution:
+                    st.markdown("**Attribution Analysis:**")
+                    fig = go.Figure([
+                        go.Bar(
+                            x=list(result.attribution.values()),
+                            y=list(result.attribution.keys()),
+                            orientation='h'
+                        )
+                    ])
+                    fig.update_layout(
+                        title="Factor Attribution",
+                        xaxis_title="Attribution (%)",
+                        height=300
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+
+
+def render_qa_agent_view(state):
+    """Render the QA Agent activity view"""
+    st.markdown("### 🔍 QA Agent")
+    st.markdown("The QA Agent is validating the analysis results for accuracy and completeness.")
+    
+    # Show validation requests
+    validation_requests = state.get("validation_requests", [])
+    if not validation_requests:
+        st.info("Preparing validation requests...")
+    
+    # Show validation results
+    validation_results = state.get("validation_results", {})
+    if validation_results:
+        st.markdown("#### 🧪 Validation Results")
+        
+        for validation_id, validation in validation_results.items():
+            with st.expander(f"Validation: {validation_id}", expanded=True):
+                # Show validation scores
+                scores_col1, scores_col2, scores_col3 = st.columns(3)
+                
+                with scores_col1:
+                    st.metric("Data Quality", f"{validation.data_quality_score:.0%}")
+                
+                with scores_col2:
+                    st.metric("Analysis Quality", f"{validation.analysis_quality_score:.0%}")
+                
+                with scores_col3:
+                    st.metric("Insight Quality", f"{validation.insight_quality_score:.0%}")
+                
+                # Show validation checks as a table
+                st.markdown("**Validation Checks:**")
+                checks_df = pd.DataFrame(validation.validation_checks)
+                checks_df = checks_df[["check", "result", "details", "score"]]
+                st.table(checks_df)
+                
+                # Show recommendations
+                if validation.recommendations:
+                    st.markdown("**Recommendations:**")
+                    for rec in validation.recommendations:
+                        st.markdown(f"- {rec}")
+                
+                # Show critical issues if any
+                if validation.critical_issues:
+                    st.error("**Critical Issues:**")
+                    for issue in validation.critical_issues:
+                        st.markdown(f"- {issue}")
+
+
+def render_insights_agent_view(state):
+    """Render the Insights Agent activity view"""
+    st.markdown("### 💡 Insights Agent")
+    st.markdown("The Insights Agent is generating visualizations and actionable recommendations.")
+    
+    # Show insight requests
+    insight_requests = state.get("insight_requests", [])
+    if not insight_requests:
+        st.info("Preparing insight requests...")
+    
+    # Show insight cards
+    insight_cards = state.get("insight_cards", {})
+    visualizations = state.get("visualizations", [])
+    
+    if insight_cards:
+        st.markdown("#### 📊 Generated Insights")
+        
+        for card_id, card in insight_cards.items():
+            with st.expander(f"{card.title}", expanded=True):
+                st.markdown(card.description)
+                
+                # Display visualizations if available
+                if card.charts and visualizations:
+                    # Create sample visualizations based on chart names
+                    st.markdown("**Visualizations:**")
+                    cols = st.columns(min(len(card.charts), 2))
+                    
+                    for i, chart_name in enumerate(card.charts[:2]):
+                        with cols[i % 2]:
+                            if "trend" in chart_name.lower():
+                                # Create sample time series for demonstration
+                                months = pd.date_range(start='2023-01-01', periods=12, freq='M')
+                                sales = [1200, 1250, 1300, 1400, 1500, 1600, 1550, 1500, 1450, 1300, 1200, 1150]
+                                targets = [1200, 1250, 1300, 1350, 1400, 1450, 1500, 1550, 1600, 1650, 1700, 1750]
+                                
+                                fig = go.Figure()
+                                fig.add_trace(go.Scatter(
+                                    x=months, y=sales, mode='lines+markers', name='Actual Sales',
+                                    line=dict(color='blue', width=2)
+                                ))
+                                fig.add_trace(go.Scatter(
+                                    x=months, y=targets, mode='lines+markers', name='Target',
+                                    line=dict(color='green', width=2, dash='dash')
+                                ))
+                                
+                                # Add annotation
+                                fig.add_vline(
+                                    x=months[9], line_dash="dash", line_color="red",
+                                    annotation_text="Competitor Launch"
+                                )
+                                
+                                fig.update_layout(
+                                    title="Sales Trend Analysis",
+                                    height=300
+                                )
+                                
+                                st.plotly_chart(fig, use_container_width=True)
+                            
+                            elif "competitor" in chart_name.lower():
+                                # Create sample competitor visualization
+                                st.markdown(f"**{chart_name}**")
+                                st.text("Visualization being generated...")
+                            
+                            else:
+                                st.markdown(f"**{chart_name}**")
+                                st.text("Visualization being generated...")
+                
+                # Display key findings
+                if card.key_findings:
+                    st.markdown("**Key Findings:**")
+                    for finding in card.key_findings:
+                        st.markdown(f"- **{finding.get('finding', '')}**: {finding.get('details', '')}")
+                        if 'impact' in finding:
+                            st.markdown(f"  *Impact: {finding.get('impact', '')}*")
+                
+                # Display action items
+                if card.action_items:
+                    st.markdown("**Recommended Actions:**")
+                    action_df = []
+                    for action in card.action_items:
+                        action_df.append({
+                            "Action": action.get("action", ""),
+                            "Owner": action.get("owner", ""),
+                            "Timeline": action.get("timeline", ""),
+                            "Priority": action.get("priority", "Medium")
+                        })
+                    st.table(pd.DataFrame(action_df))
+
+
+def render_complete_analysis_view(state):
+    """Render a complete view of the analysis results"""
+    st.markdown("### ✅ Analysis Complete")
+    
+    # Display the alert
+    st.markdown("#### 📱 Alert Analyzed")
+    st.info(state["alert"])
+    
+    # Display the problem statement
+    if state.get("plan"):
+        st.markdown("#### 🎯 Problem Analysis")
+        st.markdown(state["plan"].problem_statement)
+    
+    # Display insight cards
+    st.markdown("---")
+    st.markdown("### 💡 Key Insights")
+    
+    insight_cards = state.get("insight_cards", {})
+    visualizations = state.get("visualizations", [])
+    
+    if not insight_cards:
+        st.warning("No insights were generated. Please check the logs for errors.")
+    else:
+        for card_id, card in insight_cards.items():
+            # Create a card-like container
+            with st.container():
+                st.subheader(card.title)
+                st.markdown(card.description)
+                
+                # Display visualizations if available
+                if card.charts and len(visualizations) > 0:
+                    # Create sample visualizations
+                    cols = st.columns(min(len(card.charts), 2))
+                    
+                    for i, chart_name in enumerate(card.charts[:2]):
+                        with cols[i % 2]:
+                            # Create a sample chart based on chart name
+                            if "trend" in chart_name.lower():
+                                # Create sample time series
+                                months = pd.date_range(start='2023-01-01', periods=12, freq='M')
+                                sales = [1200, 1250, 1300, 1400, 1500, 1600, 1550, 1500, 1450, 1300, 1200, 1150]
+                                targets = [1200, 1250, 1300, 1350, 1400, 1450, 1500, 1550, 1600, 1650, 1700, 1750]
+                                
+                                fig = go.Figure()
+                                fig.add_trace(go.Scatter(
+                                    x=months, y=sales, mode='lines+markers', name='Actual Sales',
+                                    line=dict(color='blue', width=2)
+                                ))
+                                fig.add_trace(go.Scatter(
+                                    x=months, y=targets, mode='lines+markers', name='Target',
+                                    line=dict(color='green', width=2, dash='dash')
+                                ))
+                                
+                                # Add competitor launch annotation
+                                fig.add_vline(
+                                    x=months[9], line_dash="dash", line_color="red",
+                                    annotation_text="Competitor Launch"
+                                )
+                                
+                                fig.update_layout(
+                                    title="DrugX Sales Trend",
+                                    xaxis_title="Month",
+                                    yaxis_title="Sales ($K)",
+                                    height=300
+                                )
+                                
+                                st.plotly_chart(fig, use_container_width=True)
+                            
+                            elif "competitor" in chart_name.lower():
+                                # Create sample competitor comparison
+                                fig = go.Figure()
+                                
+                                # Market share data
+                                months = pd.date_range(start='2023-01-01', periods=12, freq='M')
+                                drugx_share = [65, 64, 66, 67, 68, 67, 66, 65, 64, 58, 54, 50]
+                                competitor_share = [0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 10, 15]
+                                other_share = [35, 36, 34, 33, 32, 33, 34, 35, 36, 37, 36, 35]
+                                
+                                fig.add_trace(go.Bar(
+                                    x=months, y=drugx_share, name='DrugX',
+                                    marker_color='blue'
+                                ))
+                                fig.add_trace(go.Bar(
+                                    x=months, y=competitor_share, name='CompDrug2',
+                                    marker_color='red'
+                                ))
+                                fig.add_trace(go.Bar(
+                                    x=months, y=other_share, name='Others',
+                                    marker_color='gray'
+                                ))
+                                
+                                fig.update_layout(
+                                    title="Market Share Comparison",
+                                    xaxis_title="Month",
+                                    yaxis_title="Market Share (%)",
+                                    barmode='stack',
+                                    height=300
+                                )
+                                
+                                st.plotly_chart(fig, use_container_width=True)
+                            
+                            elif "supply" in chart_name.lower():
+                                # Create sample supply chain visualization
+                                fig = go.Figure()
+                                
+                                # Inventory data
+                                months = pd.date_range(start='2023-01-01', periods=12, freq='M')
+                                inventory = [40, 38, 42, 45, 43, 41, 39, 37, 35, 25, 20, 18]
+                                stockouts = [0, 0, 0, 0, 0, 0, 0, 0, 5, 15, 22, 25]
+                                
+                                fig.add_trace(go.Scatter(
+                                    x=months, y=inventory, mode='lines+markers', name='Inventory Days',
+                                    line=dict(color='blue', width=2)
+                                ))
+                                
+                                fig.add_trace(go.Bar(
+                                    x=months, y=stockouts, name='Stockout %',
+                                    marker_color='red'
+                                ))
+                                
+                                fig.update_layout(
+                                    title="Supply Chain Metrics",
+                                    xaxis_title="Month",
+                                    yaxis_title="Inventory Days / Stockout %",
+                                    height=300
+                                )
+                                
+                                st.plotly_chart(fig, use_container_width=True)
+                            
+                            else:
+                                # Create a generic chart placeholder
+                                st.image("https://img.icons8.com/fluency/240/000000/graph.png", width=100)
+                                st.markdown(f"*{chart_name}*")
+                
+                # Display key findings
+                if card.key_findings:
+                    st.markdown("#### Key Findings")
+                    for i, finding in enumerate(card.key_findings):
+                        expander = st.expander(f"{finding.get('finding', 'Finding')}")
+                        with expander:
+                            st.markdown(f"**Details:** {finding.get('details', '')}")
+                            if 'evidence' in finding:
+                                st.markdown(f"**Evidence:** {finding.get('evidence', '')}")
+                            if 'impact' in finding:
+                                st.markdown(f"**Impact:** {finding.get('impact', '')}")
+                
+                # Display metrics
+                if card.metrics:
+                    st.markdown("#### Key Metrics")
+                    metric_cols = st.columns(min(len(card.metrics), 4))
+                    for i, (metric_name, metric_value) in enumerate(card.metrics.items()):
+                        with metric_cols[i % len(metric_cols)]:
+                            st.metric(
+                                label=metric_name.replace('_', ' ').title(),
+                                value=metric_value
+                            )
+                
+                # Display action items
+                if card.action_items:
+                    st.markdown("#### Recommended Actions")
+                    for i, action in enumerate(card.action_items):
+                        priority = action.get('priority', 'Medium')
+                        priority_color = {
+                            'High': 'red',
+                            'Medium': 'orange',
+                            'Low': 'blue'
+                        }.get(priority, 'gray')
+                        
+                        st.markdown(f"**{i+1}. {action.get('action', 'Action')}** "
+                                   f"<span style='color:{priority_color};'>[{priority}]</span>", 
+                                   unsafe_allow_html=True)
+                        
+                        action_cols = st.columns(3)
+                        with action_cols[0]:
+                            st.markdown(f"**Owner:** {action.get('owner', 'TBD')}")
+                        with action_cols[1]:
+                            st.markdown(f"**Timeline:** {action.get('timeline', 'TBD')}")
+                        with action_cols[2]:
+                            st.markdown(f"**Expected Impact:** {action.get('expected_impact', 'TBD')}")
+                
+                st.markdown("---")
+
+
+def render_debug_info(state):
+    """Render debug information about the workflow state"""
+    with st.expander("🔧 Debug Information", expanded=False):
+        # Show workflow status
+        st.markdown(f"**Current Status:** {state.get('status', 'Unknown')}")
+        
+        # Show state summary
+        state_summary = {
+            "alert": state.get("alert", "None"),
+            "data_requests": len(state.get("data_requests", [])),
+            "data_sources": len(state.get("data_sources", {})),
+            "analysis_requests": len(state.get("analysis_requests", [])),
+            "analysis_results": len(state.get("analysis_results", {})),
+            "validation_requests": len(state.get("validation_requests", [])),
+            "validation_results": len(state.get("validation_results", {})),
+            "insight_requests": len(state.get("insight_requests", [])),
+            "insight_cards": len(state.get("insight_cards", {})),
+            "visualizations": len(state.get("visualizations", [])),
+        }
+        
+        st.json(state_summary)
+        
+        # Show logs
+        if "logs" in state and state["logs"]:
+            st.markdown("**Workflow Logs:**")
+            for log in state["logs"]:
+                timestamp = log.get("timestamp", "")
+                message = log.get("message", "")
+                log_type = log.get("type", "info")
+                
+                if log_type == "error":
+                    st.error(f"{timestamp}: {message}")
+                else:
+                    st.text(f"{timestamp}: {message}")
+
+
+def render_analysis_viewer(state=None):
+    """Main function to render the analysis viewer"""
+    # If no state is provided, use the session state
+    if state is None:
+        state = st.session_state.workflow_state
+    
+    # If no workflow state, show a message
+    if state is None:
+        st.info("No analysis is currently running. Start an analysis from the main tab.")
+        return
+    
+    # Display header with current status
+    current_step = state.get("status", "planning")
+    st.markdown(f"## 🔬 Analysis Progress: {current_step.upper()}")
+    
+    # Show progress bar
+    render_progress_bar(current_step)
+    
+    # Show page tabs for different views
+    tab_names = ["Live View", "Planning", "Data", "Analysis", "Validation", "Insights", "Debug"]
+    tabs = st.tabs(tab_names)
+    
+    # Live View Tab - shows current active agent
+    with tabs[0]:
+        if current_step == "planning":
+            render_planning_agent_view(state)
+        elif current_step == "data_collection":
+            render_data_agent_view(state)
+        elif current_step == "analysis":
+            render_analytics_agent_view(state)
+        elif current_step == "validation":
+            render_qa_agent_view(state)
+        elif current_step == "insights":
+            render_insights_agent_view(state)
+        elif current_step == "complete":
+            render_complete_analysis_view(state)
+        elif current_step == "error":
+            st.error(f"Analysis failed: {state.get('error', 'Unknown error')}")
+            if "error_details" in st.session_state:
+                for i, error in enumerate(st.session_state.error_details):
+                    with st.expander(f"Error Detail {i+1}", expanded=True):
+                        st.code(error)
+    
+    # Planning Tab
+    with tabs[1]:
+        render_planning_agent_view(state)
+    
+    # Data Tab
+    with tabs[2]:
+        render_data_agent_view(state)
+    
+    # Analysis Tab
+    with tabs[3]:
+        render_analytics_agent_view(state)
+    
+    # Validation Tab
+    with tabs[4]:
+        render_qa_agent_view(state)
+    
+    # Insights Tab
+    with tabs[5]:
+        render_insights_agent_view(state)
+    
+    # Debug Tab
+    with tabs[6]:
+        render_debug_info(state)
+    
+    # Auto refresh if analysis is not complete
+    if current_step not in ["complete", "error"]:
+        time.sleep(1)
+        st.rerun()
+
+
+if __name__ == "__main__":
+    # For testing standalone
+    st.title("Analysis Viewer (Test Mode)")
+    st.markdown("This is a standalone test of the Analysis Viewer component.")
+    
+    # Create mock state
+    mock_state = {
+        "alert": "Sales of DrugX down 15% in Northeast region over past 30 days compared to forecast.",
+        "status": "planning",
+        "data_requests": [],
+        "data_sources": {},
+        "logs": [
+            {"timestamp": datetime.now().isoformat(), "message": "Workflow initialized", "type": "info"}
+        ]
+    }
+    
+    render_analysis_viewer(mock_state)