feat: adding volumne graph

app.py

@@ -42,6 +42,7 @@ logger.info(f"Running from directory: {os.getcwd()}")
 # Global variables to store the data for reuse
 global_df = None
 global_roi_df = None
+global_volume_df = None
 
 # Configuration
 API_BASE_URL = "https://afmdb.autonolas.tech"
@@ -157,7 +158,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, adjusted APR value, ROI value, and timestamp from JSON value"""
+    """Extract APR value, adjusted APR value, ROI value, volume, and timestamp from JSON value"""
     try:
         agent_id = attr.get("agent_id", "unknown")
         logger.debug(f"Extracting APR value for agent {agent_id}")
@@ -165,7 +166,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, "adjusted_apr": None, "roi": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
+            return {"apr": None, "adjusted_apr": None, "roi": None, "volume": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
         
         # If json_value is a string, parse it
         if isinstance(attr["json_value"], str):
@@ -177,13 +178,20 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
         apr = json_data.get("apr")
         adjusted_apr = json_data.get("adjusted_apr")  # Extract adjusted_apr if present
         timestamp = json_data.get("timestamp")
+        volume = json_data.get("volume")  # Extract volume if present
         
         # Extract ROI (f_i_ratio) from calculation_metrics if it exists
         roi = None
         if "calculation_metrics" in json_data and json_data["calculation_metrics"] is not None:
             roi = json_data["calculation_metrics"].get("f_i_ratio")
         
-        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, adjusted APR value: {adjusted_apr}, ROI value: {roi}, timestamp: {timestamp}")
+        # Try to extract volume from portfolio_snapshot if it's not directly in json_data
+        if volume is None and "portfolio_snapshot" in json_data and json_data["portfolio_snapshot"] is not None:
+            portfolio = json_data["portfolio_snapshot"].get("portfolio")
+            if portfolio and isinstance(portfolio, dict):
+                volume = portfolio.get("volume")
+        
+        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, adjusted APR value: {adjusted_apr}, ROI value: {roi}, volume: {volume}, timestamp: {timestamp}")
         
         # Convert timestamp to datetime if it exists
         timestamp_dt = None
@@ -194,6 +202,7 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
             "apr": apr, 
             "adjusted_apr": adjusted_apr, 
             "roi": roi,
+            "volume": volume,
             "timestamp": timestamp_dt, 
             "agent_id": agent_id, 
             "is_dummy": False
@@ -203,7 +212,7 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
     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, "adjusted_apr": None, "roi": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
+        return {"apr": None, "adjusted_apr": None, "roi": None, "volume": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
 
 def fetch_apr_data_from_db():
     """
@@ -688,6 +697,436 @@ def generate_apr_visualizations():
     
     return combined_fig, csv_file
 
+def generate_volume_visualizations():
+    """Generate volume visualizations with real data only (no dummy data)"""
+    global global_df
+    global global_volume_df
+    
+    # Use the existing APR data which already contains volume
+    if global_df is None or global_df.empty:
+        df, _ = fetch_apr_data_from_db()
+    else:
+        df = global_df
+    
+    # Filter for records with volume data
+    volume_df = df[df['volume'].notna()].copy()
+    
+    # Set global_volume_df for access by other functions
+    global_volume_df = volume_df
+    
+    # If we got no data at all, return placeholder figures
+    if volume_df.empty:
+        logger.info("No volume data available. Using fallback visualization.")
+        # Create empty visualizations with a message using Plotly
+        fig = go.Figure()
+        fig.add_annotation(
+            x=0.5, y=0.5,
+            text="No volume data available",
+            font=dict(size=20),
+            showarrow=False
+        )
+        fig.update_layout(
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+        )
+        
+        # Save as static file for reference
+        fig.write_html("modius_volume_graph.html")
+        fig.write_image("modius_volume_graph.png")
+        
+        csv_file = None
+        return fig, csv_file
+    
+    # Save to CSV before creating visualizations
+    csv_file = save_volume_to_csv(volume_df)
+    
+    # Create combined time series graph for volume
+    combined_fig = create_combined_volume_time_series_graph(volume_df)
+    
+    return combined_fig, csv_file
+
+def save_volume_to_csv(df):
+    """Save the volume data DataFrame to a CSV file and return the file path"""
+    if df.empty:
+        logger.error("No volume data to save to CSV")
+        return None
+    
+    # Define the CSV file path
+    csv_file = "modius_volume_values.csv"
+    
+    # Save to CSV
+    df.to_csv(csv_file, index=False)
+    logger.info(f"Volume data saved to {csv_file}")
+    
+    return csv_file
+
+def create_combined_volume_time_series_graph(df):
+    """Create a time series graph showing volume values across all agents"""
+    if len(df) == 0:
+        logger.error("No data to plot combined volume graph")
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No volume data available",
+            x=0.5, y=0.5,
+            showarrow=False, font=dict(size=20)
+        )
+        return fig
+    
+    # IMPORTANT: Force data types to ensure consistency
+    df['volume'] = df['volume'].astype(float)  # Ensure volume is float
+    
+    # Get min and max time for shapes
+    min_time = df['timestamp'].min()
+    max_time = df['timestamp'].max()
+    
+    # Use the actual start date from the data
+    x_start_date = min_time
+    
+    # CRITICAL: Log the exact dataframe we're using for plotting to help debug
+    logger.info(f"Volume Graph data - shape: {df.shape}, columns: {df.columns}")
+    logger.info(f"Volume Graph data - unique agents: {df['agent_name'].unique().tolist()}")
+    logger.info(f"Volume Graph data - min volume: {df['volume'].min()}, max volume: {df['volume'].max()}")
+    
+    # Export full dataframe to CSV for debugging
+    debug_csv = "debug_volume_data.csv"
+    df.to_csv(debug_csv)
+    logger.info(f"Exported volume graph data to {debug_csv} for debugging")
+    
+    # Create Plotly figure in a clean state
+    fig = go.Figure()
+    
+    # Add background shape for volume region
+    fig.add_shape(
+        type="rect",
+        fillcolor="rgba(230, 243, 255, 0.3)",
+        line=dict(width=0),
+        y0=0, y1=df['volume'].max() * 1.1,  # Use a reasonable upper limit for volume
+        x0=min_time, x1=max_time,
+        layer="below"
+    )
+    
+    # Add zero line
+    fig.add_shape(
+        type="line",
+        line=dict(dash="solid", width=1.5, color="black"),
+        y0=0, y1=0,
+        x0=min_time, x1=max_time
+    )
+    
+    # Group by timestamp and calculate mean volume
+    avg_volume_data = df.groupby('timestamp')['volume'].mean().reset_index()
+    
+    # Sort by timestamp
+    avg_volume_data = avg_volume_data.sort_values('timestamp')
+    
+    # Log the average volume data
+    logger.info(f"Calculated average volume data with {len(avg_volume_data)} points")
+    for idx, row in avg_volume_data.iterrows():
+        logger.info(f"  Average point {idx}: timestamp={row['timestamp']}, avg_volume={row['volume']}")
+    
+    # Calculate moving average based on a time window (3 days)
+    # Sort data by timestamp
+    df_sorted = df.sort_values('timestamp')
+    
+    # Create a new dataframe for the moving average
+    avg_volume_data_with_ma = avg_volume_data.copy()
+    avg_volume_data_with_ma['moving_avg'] = None  # Initialize the moving average column
+    
+    # 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 the moving averages for each timestamp
+    for i, row in avg_volume_data_with_ma.iterrows():
+        current_time = row['timestamp']
+        window_start = current_time - time_window
+        
+        # Get all data points within the 3-day time window
+        window_data = df_sorted[
+            (df_sorted['timestamp'] >= window_start) & 
+            (df_sorted['timestamp'] <= current_time)
+        ]
+        
+        # Calculate the average volume for the 3-day time window
+        if not window_data.empty:
+            avg_volume_data_with_ma.at[i, 'moving_avg'] = window_data['volume'].mean()
+            logger.debug(f"Volume time window {window_start} to {current_time}: {len(window_data)} points, avg={window_data['volume'].mean()}")
+        else:
+            # If no data points in the window, use the current value
+            avg_volume_data_with_ma.at[i, 'moving_avg'] = row['volume']
+            logger.debug(f"No data points in time window for {current_time}, using current value {row['volume']}")
+    
+    logger.info(f"Calculated time-based moving averages with {len(avg_volume_data_with_ma)} points")
+    
+    # Find the last date where we have valid moving average data
+    last_valid_ma_date = avg_volume_data_with_ma[avg_volume_data_with_ma['moving_avg'].notna()]['timestamp'].max() if not avg_volume_data_with_ma['moving_avg'].dropna().empty else None
+    
+    # If we don't have any valid moving average data, use the max time from the original data
+    last_valid_date = last_valid_ma_date if last_valid_ma_date is not None else df['timestamp'].max()
+    
+    logger.info(f"Last valid moving average date: {last_valid_ma_date}")
+    logger.info(f"Using last valid date for graph: {last_valid_date}")
+    
+    # Plot individual agent data points with agent names in hover, but limit display for scalability
+    if not df.empty:
+        # Group by agent to use different colors for each agent
+        unique_agents = df['agent_name'].unique()
+        colors = px.colors.qualitative.Plotly[:len(unique_agents)]
+        
+        # Create a color map for agents
+        color_map = {agent: colors[i % len(colors)] for i, agent in enumerate(unique_agents)}
+        
+        # Calculate the total number of data points per agent to determine which are most active
+        agent_counts = df['agent_name'].value_counts()
+        
+        # Determine how many agents to show individually (limit to top 5 most active)
+        MAX_VISIBLE_AGENTS = 5
+        top_agents = agent_counts.nlargest(min(MAX_VISIBLE_AGENTS, len(agent_counts))).index.tolist()
+        
+        logger.info(f"Showing {len(top_agents)} agents by default out of {len(unique_agents)} total agents")
+        
+        # Add data points for each agent, but only make top agents visible by default
+        for agent_name in unique_agents:
+            agent_data = df[df['agent_name'] == agent_name]
+            
+            # Explicitly convert to Python lists
+            x_values = agent_data['timestamp'].tolist()
+            y_values = agent_data['volume'].tolist()
+            
+            # Change default visibility to False to hide all agent data points
+            is_visible = False
+            
+            # Add data points as markers for volume
+            fig.add_trace(
+                go.Scatter(
+                    x=x_values,
+                    y=y_values,
+                    mode='markers',  # Only markers for original data
+                    marker=dict(
+                        color=color_map[agent_name],
+                        symbol='circle',
+                        size=10,
+                        line=dict(width=1, color='black')
+                    ),
+                    name=f'Agent: {agent_name} (Volume)',
+                    hovertemplate='Time: %{x}<br>Volume: %{y:.2f}<br>Agent: ' + agent_name + '<extra></extra>',
+                    visible=is_visible  # All agents hidden by default
+                )
+            )
+            logger.info(f"Added volume data points for agent {agent_name} with {len(x_values)} points (visible: {is_visible})")
+        
+        # Add volume moving average as a smooth line
+        x_values_ma = avg_volume_data_with_ma['timestamp'].tolist()
+        y_values_ma = avg_volume_data_with_ma['moving_avg'].tolist()
+        
+        # Create hover template for the volume moving average line
+        hover_data_volume = []
+        for idx, row in avg_volume_data_with_ma.iterrows():
+            timestamp = row['timestamp']
+            # Format timestamp to show only up to seconds (not milliseconds)
+            formatted_timestamp = timestamp.strftime('%Y-%m-%d %H:%M:%S')
+            
+            # Calculate number of active agents in the last 24 hours
+            time_24h_ago = timestamp - pd.Timedelta(hours=24)
+            active_agents = len(df[(df['timestamp'] >= time_24h_ago) & 
+                                  (df['timestamp'] <= timestamp)]['agent_id'].unique())
+            
+            hover_data_volume.append(
+                f"Time: {formatted_timestamp}<br>Avg Volume (3d window): {row['moving_avg']:.2f}<br>Active agents (24h): {active_agents}"
+            )
+        
+        fig.add_trace(
+            go.Scatter(
+                x=x_values_ma,
+                y=y_values_ma,
+                mode='lines',  # Only lines for moving average
+                line=dict(color='purple', width=2),  # Purple line for volume
+                name='Average Volume (3d window)',
+                hovertext=hover_data_volume,
+                hoverinfo='text',
+                visible=True  # Visible by default
+            )
+        )
+        logger.info(f"Added 3-day moving average volume trace with {len(x_values_ma)} points")
+    
+    # Update layout
+    fig.update_layout(
+        title=dict(
+            text="Modius Agents Volume",
+            font=dict(
+                family="Arial, sans-serif",
+                size=22,
+                color="black",
+                weight="bold"
+            )
+        ),
+        xaxis_title=None,  # Remove x-axis title to use annotation instead
+        yaxis_title=None,  # Remove the y-axis title as we'll use annotations instead
+        template="plotly_white",
+        height=600,  # Reduced height for better fit on smaller screens
+        autosize=True,  # Enable auto-sizing for responsiveness
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1,
+            groupclick="toggleitem"
+        ),
+        margin=dict(r=30, l=120, t=40, b=50),  # Increased bottom margin for x-axis title
+        hovermode="closest"
+    )
+    
+    # Add single annotation for y-axis
+    fig.add_annotation(
+        x=-0.08,  # Position further from the y-axis to avoid overlapping with tick labels
+        y=df['volume'].max() / 2,  # Center of the y-axis
+        xref="paper",
+        yref="y",
+        text="Volume",
+        showarrow=False,
+        font=dict(size=16, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        textangle=-90,  # Rotate text to be vertical
+        align="center"
+    )
+    
+    # Update layout for legend
+    fig.update_layout(
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1,
+            groupclick="toggleitem",
+            font=dict(
+                family="Arial, sans-serif",
+                size=14,  # Adjusted font size
+                color="black",
+                weight="bold"
+            )
+        )
+    )
+    
+    # Update y-axis with autoscaling for volume
+    fig.update_yaxes(
+        showgrid=True, 
+        gridwidth=1, 
+        gridcolor='rgba(0,0,0,0.1)',
+        autorange=True,  # Enable autoscaling for volume
+        tickformat=".2f",  # Format tick labels with 2 decimal places
+        tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        title=None  # Remove the built-in axis title since we're using annotations
+    )
+    
+    # Update x-axis with better formatting and fixed range
+    fig.update_xaxes(
+        showgrid=True, 
+        gridwidth=1, 
+        gridcolor='rgba(0,0,0,0.1)',
+        # Set fixed range with start date and ending at the last valid date
+        autorange=False,  # Disable autoscaling
+        range=[x_start_date, last_valid_date],  # Set fixed range from start date to last valid date
+        tickformat="%b %d",  # Simplified date format without time
+        tickangle=-30,  # Angle the labels for better readability
+        tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        title=None  # Remove built-in title to use annotation instead
+    )
+    
+    try:
+        # Save the figure
+        graph_file = "modius_volume_graph.html"
+        fig.write_html(graph_file, include_plotlyjs='cdn', full_html=False)
+        
+        # Also save as image for compatibility
+        img_file = "modius_volume_graph.png"
+        try:
+            fig.write_image(img_file)
+            logger.info(f"Volume graph saved to {graph_file} and {img_file}")
+        except Exception as e:
+            logger.error(f"Error saving volume image: {e}")
+            logger.info(f"Volume graph saved to {graph_file} only")
+        
+        # Return the figure object for direct use in Gradio
+        return fig
+    except Exception as e:
+        # If the complex graph approach fails, create a simpler one
+        logger.error(f"Error creating advanced volume graph: {e}")
+        logger.info("Falling back to simpler volume graph")
+        
+        # Create a simpler graph as fallback
+        simple_fig = go.Figure()
+        
+        # Add zero line
+        simple_fig.add_shape(
+            type="line",
+            line=dict(dash="solid", width=1.5, color="black"),
+            y0=0, y1=0,
+            x0=min_time, x1=max_time
+        )
+        
+        # Simply plot the average volume data with moving average
+        if not avg_volume_data.empty:
+            # Add moving average as a line
+            simple_fig.add_trace(
+                go.Scatter(
+                    x=avg_volume_data_with_ma['timestamp'],
+                    y=avg_volume_data_with_ma['moving_avg'],
+                    mode='lines',
+                    name='Average Volume (3d window)',
+                    line=dict(width=2, color='purple')  # Purple line for volume
+                )
+            )
+        
+        # Simplified layout with adjusted y-axis range
+        simple_fig.update_layout(
+            title=dict(
+                text="Modius Agents Volume",
+                font=dict(
+                    family="Arial, sans-serif",
+                    size=22,
+                    color="black",
+                    weight="bold"
+                )
+            ),
+            xaxis_title=None,
+            yaxis_title=None,
+            template="plotly_white",
+            height=600,
+            autosize=True,
+            margin=dict(r=30, l=120, t=40, b=50)
+        )
+        
+        # Update y-axis with autoscaling for volume
+        simple_fig.update_yaxes(
+            showgrid=True, 
+            gridwidth=1, 
+            gridcolor='rgba(0,0,0,0.1)',
+            autorange=True,  # Enable autoscaling for volume
+            tickformat=".2f",
+            tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold"),
+            title=None  # Remove the built-in axis title since we're using annotations
+        )
+        
+        # Update x-axis with better formatting and fixed range
+        simple_fig.update_xaxes(
+            showgrid=True, 
+            gridwidth=1, 
+            gridcolor='rgba(0,0,0,0.1)',
+            autorange=False,
+            range=[x_start_date, max_time],
+            tickformat="%b %d",
+            tickangle=-30,
+            tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold")
+        )
+        
+        # Save the figure
+        graph_file = "modius_volume_graph.html"
+        simple_fig.write_html(graph_file, include_plotlyjs='cdn', full_html=False)
+        
+        # Return the simple figure
+        return simple_fig
+
 def generate_roi_visualizations():
     """Generate ROI visualizations with real data only (no dummy data)"""
     global global_roi_df
@@ -2510,7 +2949,7 @@ def dashboard():
     with gr.Blocks() as demo:
         gr.Markdown("# Average Modius Agent Performance")
         
-        # Create tabs for APR and ROI metrics
+        # Create tabs for APR, ROI, and Volume metrics
         with gr.Tabs():
             # APR Metrics tab
             with gr.Tab("APR Metrics"):
@@ -2558,16 +2997,38 @@ def dashboard():
                     
                     # Add a text area for status messages
                     roi_status_text = gr.Textbox(label="Status", value="Ready", interactive=False)
+            
+            # Volume Metrics tab
+            with gr.Tab("Volume Metrics"):
+                with gr.Column():
+                    refresh_volume_btn = gr.Button("Refresh Volume Data")
+                    
+                    # Create container for plotly figure with responsive sizing
+                    with gr.Column():
+                        combined_volume_graph = gr.Plot(label="Volume for All Agents", elem_id="responsive_volume_plot")
+                    
+                    # Create compact toggle controls at the bottom of the graph
+                    with gr.Row(visible=True):
+                        gr.Markdown("##### Toggle Graph Lines", elem_id="volume_toggle_title")
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            with gr.Row(elem_id="volume_toggle_container"):
+                                with gr.Column(scale=1, min_width=150):
+                                    volume_toggle = gr.Checkbox(label="Volume Average", value=True, elem_id="volume_toggle")
+                    
+                    # Add a text area for status messages
+                    volume_status_text = gr.Textbox(label="Status", value="Ready", interactive=False)
         
         # Add custom CSS for making the plots responsive
         gr.HTML("""
         <style>
             /* Make plots responsive */
-            #responsive_apr_plot, #responsive_roi_plot {
+            #responsive_apr_plot, #responsive_roi_plot, #responsive_volume_plot {
                 width: 100% !important;
                 max-width: 100% !important;
             }
-            #responsive_apr_plot > div, #responsive_roi_plot > div {
+            #responsive_apr_plot > div, #responsive_roi_plot > div, #responsive_volume_plot > div {
                 width: 100% !important;
                 height: auto !important;
                 min-height: 500px !important;
@@ -2586,13 +3047,17 @@ def dashboard():
                 accent-color: #3498db !important;
             }
             
+            #volume_toggle .gr-checkbox {
+                accent-color: #9b59b6 !important;
+            }
+            
             /* Make the toggle section more compact */
-            #apr_toggle_title, #roi_toggle_title {
+            #apr_toggle_title, #roi_toggle_title, #volume_toggle_title {
                 margin-bottom: 0;
                 margin-top: 10px;
             }
             
-            #apr_toggle_container, #roi_toggle_container {
+            #apr_toggle_container, #roi_toggle_container, #volume_toggle_container {
                 margin-top: 5px;
             }
             
@@ -2626,6 +3091,12 @@ def dashboard():
                 color: #3498db;
                 margin-right: 5px;
             }
+            
+            #volume_toggle .gr-checkbox-label::before {
+                content: "●";
+                color: #9b59b6;
+                margin-right: 5px;
+            }
         </style>
         """)
         
@@ -2681,6 +3152,31 @@ def dashboard():
                 )
                 return error_fig
         
+        # Function to update the Volume graph
+        def update_volume_graph(show_volume_ma=True):
+            # Generate visualization and get figure object directly
+            try:
+                combined_fig, _ = generate_volume_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 == 'Average Volume (3d window)':
+                        trace.visible = show_volume_ma
+                
+                return combined_fig
+            except Exception as e:
+                logger.exception("Error generating Volume visualization")
+                # Create error figure
+                error_fig = go.Figure()
+                error_fig.add_annotation(
+                    text=f"Error: {str(e)}", 
+                    x=0.5, y=0.5, 
+                    showarrow=False, 
+                    font=dict(size=15, color="red")
+                )
+                return error_fig
+        
         # Initialize the APR graph on load with a placeholder
         apr_placeholder_fig = go.Figure()
         apr_placeholder_fig.add_annotation(
@@ -2701,6 +3197,16 @@ def dashboard():
         )
         combined_roi_graph.value = roi_placeholder_fig
         
+        # Initialize the Volume graph on load with a placeholder
+        volume_placeholder_fig = go.Figure()
+        volume_placeholder_fig.add_annotation(
+            text="Click 'Refresh Volume Data' to load Volume graph", 
+            x=0.5, y=0.5, 
+            showarrow=False, 
+            font=dict(size=15)
+        )
+        combined_volume_graph.value = volume_placeholder_fig
+        
         # Function to update the APR graph based on toggle states
         def update_apr_graph_with_toggles(apr_visible, adjusted_apr_visible):
             return update_apr_graph(apr_visible, adjusted_apr_visible)
@@ -2793,6 +3299,41 @@ def dashboard():
             inputs=[roi_toggle],
             outputs=[combined_roi_graph]
         )
+        
+        # Function to refresh volume data
+        def refresh_volume_data():
+            """Refresh volume data from the database and update the visualization"""
+            try:
+                # Fetch new volume data
+                logger.info("Manually refreshing volume data...")
+                fetch_apr_data_from_db()  # This also fetches volume data
+                
+                # Verify data was fetched successfully
+                if global_df is None or len(global_df) == 0:
+                    logger.error("Failed to fetch volume data")
+                    return combined_volume_graph.value, "Error: Failed to fetch volume data. Check the logs for details."
+                
+                # Generate new visualization
+                logger.info("Generating new volume visualization...")
+                new_graph = update_volume_graph(volume_toggle.value)
+                return new_graph, "Volume data refreshed successfully"
+            except Exception as e:
+                logger.error(f"Error refreshing volume data: {e}")
+                return combined_volume_graph.value, f"Error: {str(e)}"
+        
+        # Set up the button click event for volume refresh
+        refresh_volume_btn.click(
+            fn=refresh_volume_data,
+            inputs=[],
+            outputs=[combined_volume_graph, volume_status_text]
+        )
+        
+        # Set up the toggle switch events for volume
+        volume_toggle.change(
+            fn=update_volume_graph,
+            inputs=[volume_toggle],
+            outputs=[combined_volume_graph]
+        )
     
     return demo