Types of Graphs in Data Visualization: A Comprehensive Guide

import matplotlib.pyplot as plt
import pandas as pd
from io.thecodeforge.data import DataLoader

def create_production_bar_chart(metrics_df: pd.DataFrame):
    """
    Creates a production-ready bar chart for service comparison
    """
    fig, ax = plt.subplots(figsize=(12, 6))
    
    # Filter to last 24 hours of data
    recent_data = DataLoader.filter_last_n_hours(metrics_df, hours=24)
    
    # Group by service and calculate p95 latency
    service_latency = recent_data.groupby('service')['latency_ms'].quantile(0.95)
    
    # Create bars with conditional coloring
    colors = ['#e74c3c' if x > 500 else '#2ecc71' for x in service_latency]
    bars = ax.bar(service_latency.index, service_latency.values, color=colors)
    
    # Add value labels on bars
    for bar in bars:
        height = bar.get_height()
        ax.text(bar.get_x() + bar.get_width()/2., height,
                f'{height:.1f}ms', ha='center', va='bottom')
    
    ax.set_ylabel('P95 Latency (ms)')
    ax.set_title('Service Performance Comparison - Last 24 Hours')
    ax.axhline(y=500, color='orange', linestyle='--', alpha=0.5, label='SLA Threshold')
    
    return fig

import plotly.graph_objects as go
from datetime import datetime, timedelta
from io.thecodeforge.monitoring import MetricsCollector

def create_multi_line_dashboard(metrics: dict):
    """
    Creates a production monitoring dashboard with multiple line graphs
    """
    fig = go.Figure()
    
    # Add traces for each metric with appropriate styling
    for metric_name, data in metrics.items():
        fig.add_trace(go.Scatter(
            x=data['timestamps'],
            y=data['values'],
            mode='lines',
            name=metric_name,
            line=dict(
                width=2,
                dash='solid' if 'latency' in metric_name else 'dot'
            ),
            hovertemplate=f'<b>{metric_name}</b><br>' +
                         'Time: %{x}<br>' +
                         'Value: %{y:.2f}<extra></extra>'
        ))
    
    # Add threshold lines
    fig.add_hline(y=1000, line_dash="dash", line_color="red",
                  annotation_text="Critical Threshold")
    
    fig.update_layout(
        title='System Health - Last 6 Hours',
        xaxis_title='Time',
        yaxis_title='Value',
        hovermode='x unified',
        template='plotly_dark'
    )
    
    return fig

// Production pie chart with accessibility considerations
function createAccessiblePieChart(data, containerId) {
  const total = data.reduce((sum, item) => sum + item.value, 0);
  
  // Create SVG with proper ARIA labels
  const svg = d3.select(`#${containerId}`)
    .append('svg')
    .attr('role', 'img')
    .attr('aria-label', 'Pie chart showing resource distribution');
  
  // Generate pie layout
  const pie = d3.pie()
    .value(d => d.value)
    .sort(null);
  
  const arc = d3.arc()
    .innerRadius(0)
    .outerRadius(100);
  
  // Add slices with accessible colors
  const slices = svg.selectAll('path')
    .data(pie(data))
    .enter()
    .append('path')
    .attr('d', arc)
    .attr('fill', (d, i) => io.thecodeforge.colors.getAccessibleColor(i))
    .attr('aria-label', d => `${d.data.label}: ${d.data.value} (${((d.data.value/total)*100).toFixed(1)}%)`);
  
  // Add percentage labels
  slices.append('text')
    .attr('transform', d => `translate(${arc.centroid(d)})`)
    .attr('text-anchor', 'middle')
    .text(d => `${((d.data.value/total)*100).toFixed(0)}%`);
  
  return svg.node();
}

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
from io.thecodeforge.statistics import DistributionAnalyzer

def create_production_histogram(data, metric_name):
    """
    Creates histogram with statistical annotations for production analysis
    """
    fig, ax = plt.subplots(figsize=(10, 6))
    
    # Calculate optimal bin width using Freedman-Diaconis rule
    bin_width = 2 * stats.iqr(data) / (len(data) ** (1/3))
    bins = np.arange(min(data), max(data) + bin_width, bin_width)
    
    # Create histogram
    n, bins, patches = ax.hist(data, bins=bins, alpha=0.7,
                               color='#3498db', edgecolor='white')
    
    # Add statistical markers
    mean_val = np.mean(data)
    median_val = np.median(data)
    p95_val = np.percentile(data, 95)
    
    ax.axvline(mean_val, color='red', linestyle='--', linewidth=2,
               label=f'Mean: {mean_val:.2f}')
    ax.axvline(median_val, color='green', linestyle='-', linewidth=2,
               label=f'Median: {median_val:.2f}')
    ax.axvline(p95_val, color='orange', linestyle=':', linewidth=2,
               label=f'P95: {p95_val:.2f}')
    
    ax.set_xlabel(metric_name)
    ax.set_ylabel('Frequency')
    ax.set_title(f'Distribution of {metric_name}')
    ax.legend()
    
    # Add distribution test results
    normality_p = stats.normaltest(data).pvalue
    ax.text(0.02, 0.95, f'Normality test p={normality_p:.4f}',
            transform=ax.transAxes, bbox=dict(facecolor='white', alpha=0.8))
    
    return fig

import seaborn as sns
import pandas as pd
from io.thecodeforge.analysis import CorrelationAnalyzer

def create_correlation_scatter(df, x_col, y_col, hue_col=None):
    """
    Creates scatter plot with correlation analysis for production debugging
    """
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
    
    # Main scatter plot
    scatter = sns.scatterplot(
        data=df, x=x_col, y=y_col, hue=hue_col,
        alpha=0.6, s=50, ax=axes[0]
    )
    
    # Calculate and display correlation
    corr_coef = df[x_col].corr(df[y_col])
    axes[0].set_title(f'Correlation: r = {corr_coef:.3f}')
    
    # Add regression line if strong correlation
    if abs(corr_coef) > 0.3:
        sns.regplot(
            data=df, x=x_col, y=y_col,
            scatter=False, ax=axes[0],
            line_kws={'color': 'red', 'alpha': 0.8}
        )
    
    # Marginal distributions
    sns.histplot(df[x_col], kde=True, ax=axes[1])
    axes[1].set_title(f'Distribution of {x_col}')
    
    plt.tight_layout()
    return fig