chore: add line for ajusted apr graph button to select the graph line

app.py

@@ -156,7 +156,7 @@ def get_agent_name(agent_id: int, agents: List[Dict[str, Any]]) -> str:
     return "Unknown"
 
 def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
-    """Extract APR value and timestamp from JSON value"""
+    """Extract APR value, adjusted APR value, and timestamp from JSON value"""
     try:
         agent_id = attr.get("agent_id", "unknown")
         logger.debug(f"Extracting APR value for agent {agent_id}")
@@ -164,7 +164,7 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
         # The APR value is stored in the json_value field
         if attr["json_value"] is None:
             logger.debug(f"Agent {agent_id}: json_value is None")
-            return {"apr": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
+            return {"apr": None, "adjusted_apr": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
         
         # If json_value is a string, parse it
         if isinstance(attr["json_value"], str):
@@ -174,22 +174,23 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
             json_data = attr["json_value"]
         
         apr = json_data.get("apr")
+        adjusted_apr = json_data.get("adjusted_apr")  # Extract adjusted_apr if present
         timestamp = json_data.get("timestamp")
         
-        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, timestamp: {timestamp}")
+        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, adjusted APR value: {adjusted_apr}, timestamp: {timestamp}")
         
         # Convert timestamp to datetime if it exists
         timestamp_dt = None
         if timestamp:
             timestamp_dt = datetime.fromtimestamp(timestamp)
             
-        result = {"apr": apr, "timestamp": timestamp_dt, "agent_id": agent_id, "is_dummy": False}
+        result = {"apr": apr, "adjusted_apr": adjusted_apr, "timestamp": timestamp_dt, "agent_id": agent_id, "is_dummy": False}
         logger.debug(f"Agent {agent_id}: Extracted result: {result}")
         return result
     except (json.JSONDecodeError, KeyError, TypeError) as e:
         logger.error(f"Error parsing JSON value: {e} for agent_id: {attr.get('agent_id')}")
         logger.error(f"Problematic json_value: {attr.get('json_value')}")
-        return {"apr": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
+        return {"apr": None, "adjusted_apr": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
 
 def fetch_apr_data_from_db():
     """
@@ -278,6 +279,22 @@ def fetch_apr_data_from_db():
         logger.info(f"Created DataFrame with {len(global_df)} rows")
         logger.info(f"DataFrame columns: {global_df.columns.tolist()}")
         logger.info(f"APR statistics: min={global_df['apr'].min()}, max={global_df['apr'].max()}, mean={global_df['apr'].mean()}")
+        
+        # Log adjusted APR statistics if available
+        if 'adjusted_apr' in global_df.columns and global_df['adjusted_apr'].notna().any():
+            logger.info(f"Adjusted APR statistics: min={global_df['adjusted_apr'].min()}, max={global_df['adjusted_apr'].max()}, mean={global_df['adjusted_apr'].mean()}")
+            logger.info(f"Number of records with adjusted_apr: {global_df['adjusted_apr'].notna().sum()} out of {len(global_df)}")
+            
+            # Log the difference between APR and adjusted APR
+            valid_rows = global_df[global_df['adjusted_apr'].notna()]
+            if not valid_rows.empty:
+                avg_diff = (valid_rows['apr'] - valid_rows['adjusted_apr']).mean()
+                max_diff = (valid_rows['apr'] - valid_rows['adjusted_apr']).max()
+                min_diff = (valid_rows['apr'] - valid_rows['adjusted_apr']).min()
+                logger.info(f"APR vs Adjusted APR difference: avg={avg_diff:.2f}, max={max_diff:.2f}, min={min_diff:.2f}")
+        else:
+            logger.info("No adjusted APR values found in the data")
+            
         # All values are APR type (excluding zero and -100 values)
         logger.info("All values are APR type (excluding zero and -100 values)")
         logger.info(f"Agents count: {global_df['agent_name'].value_counts().to_dict()}")
@@ -622,46 +639,38 @@ def create_combined_time_series_graph(df):
     avg_apr_data_with_ma = avg_apr_data.copy()
     avg_apr_data_with_ma['moving_avg'] = None  # Initialize the moving average column
     
-    # Define the time window for the moving average (6 hours)
-    time_window = pd.Timedelta(hours=6)
+    # Define the time window for the moving average (3 days)
+    time_window = pd.Timedelta(days=3)
     logger.info(f"Calculating moving average with time window of {time_window}")
     
-    # Calculate two moving averages: one with 2-hour window and one with infinite window
-    avg_apr_data_with_ma['moving_avg'] = None  # 2-hour window
-    avg_apr_data_with_ma['infinite_avg'] = None  # Infinite window (all data up to timestamp)
+    # Calculate moving averages: one for APR and one for adjusted APR
+    avg_apr_data_with_ma['moving_avg'] = None  # 3-day window for APR
+    avg_apr_data_with_ma['adjusted_moving_avg'] = None  # 3-day window for adjusted APR
     
     # Calculate the moving averages for each timestamp
     for i, row in avg_apr_data_with_ma.iterrows():
         current_time = row['timestamp']
         window_start = current_time - time_window
         
-        # Get all data points within the 2-hour time window
+        # Get all data points within the 3-day time window
         window_data = apr_data_sorted[
             (apr_data_sorted['timestamp'] >= window_start) & 
             (apr_data_sorted['timestamp'] <= current_time)
         ]
         
-        # Get all data points up to the current timestamp (infinite window)
-        infinite_window_data = apr_data_sorted[
-            apr_data_sorted['timestamp'] <= current_time
-        ]
-        
-        # Calculate the average APR for the 2-hour time window
+        # Calculate the average APR for the 3-day time window
         if not window_data.empty:
             avg_apr_data_with_ma.at[i, 'moving_avg'] = window_data['apr'].mean()
-            logger.debug(f"Time window {window_start} to {current_time}: {len(window_data)} points, avg={window_data['apr'].mean()}")
+            logger.debug(f"APR time window {window_start} to {current_time}: {len(window_data)} points, avg={window_data['apr'].mean()}")
+            
+            # Calculate adjusted APR moving average if data exists
+            if 'adjusted_apr' in window_data.columns and window_data['adjusted_apr'].notna().any():
+                avg_apr_data_with_ma.at[i, 'adjusted_moving_avg'] = window_data['adjusted_apr'].mean()
+                logger.debug(f"Adjusted APR time window {window_start} to {current_time}: {len(window_data)} points, avg={window_data['adjusted_apr'].mean()}")
         else:
             # If no data points in the window, use the current value
             avg_apr_data_with_ma.at[i, 'moving_avg'] = row['apr']
             logger.debug(f"No data points in time window for {current_time}, using current value {row['apr']}")
-        
-        # Calculate the average APR for the infinite window
-        if not infinite_window_data.empty:
-            avg_apr_data_with_ma.at[i, 'infinite_avg'] = infinite_window_data['apr'].mean()
-            logger.debug(f"Infinite window up to {current_time}: {len(infinite_window_data)} points, avg={infinite_window_data['apr'].mean()}")
-        else:
-            # This should never happen, but just in case
-            avg_apr_data_with_ma.at[i, 'infinite_avg'] = row['apr']
     
     logger.info(f"Calculated time-based moving averages with {len(avg_apr_data_with_ma)} points")
     
@@ -694,7 +703,7 @@ def create_combined_time_series_graph(df):
             # Determine if this agent should be visible by default
             is_visible = agent_name in top_agents
             
-            # Add data points as markers
+            # Add data points as markers for APR
             fig.add_trace(
                 go.Scatter(
                     x=x_values,
@@ -706,23 +715,46 @@ def create_combined_time_series_graph(df):
                         size=10,
                         line=dict(width=1, color='black')
                     ),
-                    name=f'Agent: {agent_name}',
+                    name=f'Agent: {agent_name} (APR)',
                     hovertemplate='Time: %{x}<br>APR: %{y:.2f}<br>Agent: ' + agent_name + '<extra></extra>',
                     visible=is_visible  # Only top agents visible by default
                 )
             )
-            logger.info(f"Added data points for agent {agent_name} with {len(x_values)} points (visible: {is_visible})")
+            logger.info(f"Added APR data points for agent {agent_name} with {len(x_values)} points (visible: {is_visible})")
+            
+            # Add data points for adjusted APR if it exists
+            if 'adjusted_apr' in agent_data.columns and agent_data['adjusted_apr'].notna().any():
+                x_values_adj = agent_data['timestamp'].tolist()
+                y_values_adj = agent_data['adjusted_apr'].tolist()
+                
+                fig.add_trace(
+                    go.Scatter(
+                        x=x_values_adj,
+                        y=y_values_adj,
+                        mode='markers',  # Only markers for original data
+                        marker=dict(
+                            color=color_map[agent_name],
+                            symbol='diamond',  # Different symbol for adjusted APR
+                            size=10,
+                            line=dict(width=1, color='black')
+                        ),
+                        name=f'Agent: {agent_name} (Adjusted APR)',
+                        hovertemplate='Time: %{x}<br>Adjusted APR: %{y:.2f}<br>Agent: ' + agent_name + '<extra></extra>',
+                        visible=is_visible  # Only top agents visible by default
+                    )
+                )
+                logger.info(f"Added Adjusted APR data points for agent {agent_name} with {len(x_values_adj)} points (visible: {is_visible})")
         
-        # Add 2-hour moving average as a smooth line
+        # Add APR moving average as a smooth line
         x_values_ma = avg_apr_data_with_ma['timestamp'].tolist()
         y_values_ma = avg_apr_data_with_ma['moving_avg'].tolist()
         
-        # Create hover template for the 2-hour moving average line
-        hover_data_2h = []
+        # Create hover template for the APR moving average line
+        hover_data_apr = []
         for idx, row in avg_apr_data_with_ma.iterrows():
             timestamp = row['timestamp']
-            hover_data_2h.append(
-                f"Time: {timestamp}<br>Moving Avg APR (6h window): {row['moving_avg']:.2f}"
+            hover_data_apr.append(
+                f"Time: {timestamp}<br>Moving Avg APR (3d window): {row['moving_avg']:.2f}"
             )
         
         fig.add_trace(
@@ -731,36 +763,47 @@ def create_combined_time_series_graph(df):
                 y=y_values_ma,
                 mode='lines',  # Only lines for moving average
                 line=dict(color='red', width=2),  # Thinner line
-                name='Moving Average APR (6h window)',
-                hovertext=hover_data_2h,
-                hoverinfo='text'
+                name='Moving Average APR (3d window)',
+                hovertext=hover_data_apr,
+                hoverinfo='text',
+                visible=True  # Visible by default
             )
         )
-        logger.info(f"Added 2-hour moving average APR trace with {len(x_values_ma)} points")
-        
-        # Add infinite window moving average as another line
-        y_values_infinite = avg_apr_data_with_ma['infinite_avg'].tolist()
+        logger.info(f"Added 3-day moving average APR trace with {len(x_values_ma)} points")
         
-        # Create hover template for the infinite window moving average line
-        hover_data_infinite = []
-        for idx, row in avg_apr_data_with_ma.iterrows():
-            timestamp = row['timestamp']
-            hover_data_infinite.append(
-                f"Time: {timestamp}<br>Cumulative Avg APR (all data): {row['infinite_avg']:.2f}"
+        # Add adjusted APR moving average line if it exists
+        if 'adjusted_moving_avg' in avg_apr_data_with_ma.columns and avg_apr_data_with_ma['adjusted_moving_avg'].notna().any():
+            y_values_adj_ma = avg_apr_data_with_ma['adjusted_moving_avg'].tolist()
+            
+            # Create hover template for the adjusted APR moving average line
+            hover_data_adj = []
+            for idx, row in avg_apr_data_with_ma.iterrows():
+                timestamp = row['timestamp']
+                if pd.notna(row['adjusted_moving_avg']):
+                    hover_data_adj.append(
+                        f"Time: {timestamp}<br>Moving Avg Adjusted APR (3d window): {row['adjusted_moving_avg']:.2f}"
+                    )
+                else:
+                    hover_data_adj.append(
+                        f"Time: {timestamp}<br>Moving Avg Adjusted APR (3d window): N/A"
+                    )
+            
+            fig.add_trace(
+                go.Scatter(
+                    x=x_values_ma,
+                    y=y_values_adj_ma,
+                    mode='lines',  # Only lines for moving average
+                    line=dict(color='green', width=4),  # Thicker solid line for adjusted APR
+                    name='Moving Average Adjusted APR (3d window)',
+                    hovertext=hover_data_adj,
+                    hoverinfo='text',
+                    visible=True  # Visible by default
+                )
             )
+            logger.info(f"Added 3-day moving average Adjusted APR trace with {len(x_values_ma)} points")
         
-        fig.add_trace(
-            go.Scatter(
-                x=x_values_ma,
-                y=y_values_infinite,
-                mode='lines',  # Only lines for moving average
-                line=dict(color='green', width=4),  # Thicker solid line
-                name='Cumulative Average APR (all data)',
-                hovertext=hover_data_infinite,
-                hoverinfo='text'
-            )
-        )
-        logger.info(f"Added infinite window moving average APR trace with {len(x_values_ma)} points")
+        # Removed cumulative APR as requested
+        logger.info("Cumulative APR graph line has been removed as requested")
     
     # Update layout - use simple boolean values everywhere
     # Increase the width and height for better visualization
@@ -1015,6 +1058,20 @@ def save_to_csv(df):
     stats_df.to_csv(stats_csv, index=False)
     logger.info(f"Statistics saved to {stats_csv}")
     
+    # Log detailed statistics about adjusted APR
+    if 'adjusted_apr' in df.columns and df['adjusted_apr'].notna().any():
+        adjusted_stats = stats_df[stats_df['avg_adjusted_apr'].notna()]
+        logger.info(f"Agents with adjusted APR data: {len(adjusted_stats)} out of {len(stats_df)}")
+        
+        for _, row in adjusted_stats.iterrows():
+            if row['agent_id'] != 'ALL':  # Skip the overall stats row
+                logger.info(f"Agent {row['agent_name']} adjusted APR stats: avg={row['avg_adjusted_apr']:.2f}, min={row['min_adjusted_apr']:.2f}, max={row['max_adjusted_apr']:.2f}")
+        
+        # Log overall adjusted APR stats
+        overall_row = stats_df[stats_df['agent_id'] == 'ALL']
+        if not overall_row.empty and pd.notna(overall_row['avg_adjusted_apr'].iloc[0]):
+            logger.info(f"Overall adjusted APR stats: avg={overall_row['avg_adjusted_apr'].iloc[0]:.2f}, min={overall_row['min_adjusted_apr'].iloc[0]:.2f}, max={overall_row['max_adjusted_apr'].iloc[0]:.2f}")
+    
     return csv_file
 
 def generate_statistics_from_data(df):
@@ -1039,6 +1096,9 @@ def generate_statistics_from_data(df):
         perf_data = agent_data[agent_data['metric_type'] == 'Performance']
         real_perf = perf_data[perf_data['is_dummy'] == False]
         
+        # Check if adjusted_apr exists and has non-null values
+        has_adjusted_apr = 'adjusted_apr' in apr_data.columns and apr_data['adjusted_apr'].notna().any()
+        
         stats = {
             'agent_id': agent_id,
             'agent_name': agent_name,
@@ -1051,6 +1111,9 @@ def generate_statistics_from_data(df):
             'avg_performance': perf_data['apr'].mean() if not perf_data.empty else None,
             'max_apr': apr_data['apr'].max() if not apr_data.empty else None,
             'min_apr': apr_data['apr'].min() if not apr_data.empty else None,
+            'avg_adjusted_apr': apr_data['adjusted_apr'].mean() if has_adjusted_apr else None,
+            'max_adjusted_apr': apr_data['adjusted_apr'].max() if has_adjusted_apr else None,
+            'min_adjusted_apr': apr_data['adjusted_apr'].min() if has_adjusted_apr else None,
             'latest_timestamp': agent_data['timestamp'].max().strftime('%Y-%m-%d %H:%M:%S') if not agent_data.empty else None
         }
         stats_list.append(stats)
@@ -1059,6 +1122,9 @@ def generate_statistics_from_data(df):
     apr_only = df[df['metric_type'] == 'APR']
     perf_only = df[df['metric_type'] == 'Performance']
     
+    # Check if adjusted_apr exists and has non-null values for overall stats
+    has_adjusted_apr_overall = 'adjusted_apr' in apr_only.columns and apr_only['adjusted_apr'].notna().any()
+    
     overall_stats = {
         'agent_id': 'ALL',
         'agent_name': 'All Agents',
@@ -1071,6 +1137,9 @@ def generate_statistics_from_data(df):
         'avg_performance': perf_only['apr'].mean() if not perf_only.empty else None,
         'max_apr': apr_only['apr'].max() if not apr_only.empty else None,
         'min_apr': apr_only['apr'].min() if not apr_only.empty else None,
+        'avg_adjusted_apr': apr_only['adjusted_apr'].mean() if has_adjusted_apr_overall else None,
+        'max_adjusted_apr': apr_only['adjusted_apr'].max() if has_adjusted_apr_overall else None,
+        'min_adjusted_apr': apr_only['adjusted_apr'].min() if has_adjusted_apr_overall else None,
         'latest_timestamp': df['timestamp'].max().strftime('%Y-%m-%d %H:%M:%S') if not df.empty else None
     }
     stats_list.append(overall_stats)
@@ -1419,11 +1488,82 @@ def dashboard():
                 # Create container for plotly figure (combined graph only)
                 combined_graph = gr.Plot(label="APR for All Agents")
                 
+                # Create compact toggle controls at the bottom of the graph
+                with gr.Row(visible=True):
+                    gr.Markdown("##### Toggle Graph Lines", elem_id="toggle_title")
+                
+                with gr.Row():
+                    with gr.Column():
+                        with gr.Row(elem_id="toggle_container"):
+                            with gr.Column(scale=1, min_width=150):
+                                apr_toggle = gr.Checkbox(label="APR Moving Average", value=True, elem_id="apr_toggle")
+                            
+                            with gr.Column(scale=1, min_width=150):
+                                adjusted_apr_toggle = gr.Checkbox(label="Adjusted APR Moving Average", value=True, elem_id="adjusted_apr_toggle")
+                
+                # Add custom CSS for styling the toggle checkboxes
+                gr.HTML("""
+                <style>
+                    /* Style for toggle checkboxes */
+                    #apr_toggle .gr-checkbox {
+                        accent-color: #e74c3c !important;
+                    }
+                    
+                    #adjusted_apr_toggle .gr-checkbox {
+                        accent-color: #2ecc71 !important;
+                    }
+                    
+                    /* Make the toggle section more compact */
+                    #toggle_title {
+                        margin-bottom: 0;
+                        margin-top: 10px;
+                    }
+                    
+                    #toggle_container {
+                        margin-top: 5px;
+                    }
+                    
+                    /* Style the checkbox labels */
+                    .gr-form.gr-box {
+                        border: none !important;
+                        background: transparent !important;
+                    }
+                    
+                    /* Make checkboxes and labels appear on the same line */
+                    .gr-checkbox-container {
+                        display: flex !important;
+                        align-items: center !important;
+                    }
+                    
+                    /* Add colored indicators */
+                    #apr_toggle .gr-checkbox-label::before {
+                        content: "●";
+                        color: #e74c3c;
+                        margin-right: 5px;
+                    }
+                    
+                    #adjusted_apr_toggle .gr-checkbox-label::before {
+                        content: "●";
+                        color: #2ecc71;
+                        margin-right: 5px;
+                    }
+                </style>
+                """)
+                
                 # Function to update the graph
-                def update_apr_graph():
+                def update_apr_graph(show_apr_ma=True, show_adjusted_apr_ma=True):
                     # Generate visualization and get figure object directly
                     try:
                         combined_fig, _ = generate_apr_visualizations()
+                        
+                        # Update visibility of traces based on toggle values
+                        for i, trace in enumerate(combined_fig.data):
+                            # Check if this is a moving average trace
+                            if trace.name == 'Moving Average APR (3d window)':
+                                trace.visible = show_apr_ma
+                            elif trace.name == 'Moving Average Adjusted APR (3d window)':
+                                trace.visible = show_adjusted_apr_ma
+                        
                         return combined_fig
                     except Exception as e:
                         logger.exception("Error generating APR visualization")
@@ -1447,8 +1587,29 @@ def dashboard():
                 )
                 combined_graph.value = placeholder_fig
                 
+                # Function to update the graph based on toggle states
+                def update_graph_with_toggles(apr_visible, adjusted_apr_visible):
+                    return update_apr_graph(apr_visible, adjusted_apr_visible)
+                
+                # Function to update the graph without parameters (for refresh button)
+                def refresh_graph():
+                    return update_apr_graph(apr_toggle.value, adjusted_apr_toggle.value)
+                
                 # Set up the button click event
-                refresh_btn.click(fn=update_apr_graph, outputs=[combined_graph])
+                refresh_btn.click(fn=refresh_graph, inputs=None, outputs=[combined_graph])
+                
+                # Set up the toggle switch events
+                apr_toggle.change(
+                    fn=update_graph_with_toggles,
+                    inputs=[apr_toggle, adjusted_apr_toggle],
+                    outputs=[combined_graph]
+                )
+                
+                adjusted_apr_toggle.change(
+                    fn=update_graph_with_toggles,
+                    inputs=[apr_toggle, adjusted_apr_toggle],
+                    outputs=[combined_graph]
+                )
         
     return demo