working dashboard for viewing test results and comparing multiple tests

Author: SPra03

sources/dashboard/app.py

@@ -0,0 +1,20 @@
+import dash
+import dash_bootstrap_components as dbc
+from components.layout import create_layout
+from data.data_loader import load_metadata
+from callbacks import register_callbacks
+
+# Initialize the app
+app = dash.Dash(__name__, external_stylesheets=[dbc.themes.CYBORG])
+
+# Load metadata
+metadata_list = load_metadata()
+
+# Create layout
+app.layout = create_layout(metadata_list)
+
+# Register callbacks
+register_callbacks(app, metadata_list)
+
+if __name__ == '__main__':
+    app.run_server(debug=True, port=8270) 

sources/dashboard/callbacks/__init__.py

@@ -0,0 +1,11 @@
+from .file_selection import register_file_selection_callbacks
+from .graph_updates import register_graph_callbacks
+from .metrics_updates import register_metrics_callbacks
+from .table_updates import register_table_callbacks
+
+def register_callbacks(app, metadata_list):
+    """Register all callbacks with the app."""
+    register_file_selection_callbacks(app, metadata_list)
+    register_graph_callbacks(app)
+    register_metrics_callbacks(app)
+    register_table_callbacks(app) 

sources/dashboard/callbacks/file_selection.py

@@ -0,0 +1,44 @@
+import json
+import os
+from dash.dependencies import Input, Output
+from dash import html, dcc
+
+def register_file_selection_callbacks(app, metadata_list):
+    @app.callback(
+        [Output('selected-file-path', 'data'),
+         Output('selected-uuid', 'data'),
+         Output('file-selected-message', 'children')],
+        Input('metadata-table', 'selected_rows'),
+        prevent_initial_call=True
+    )
+    def select_file(selected_rows):
+        if selected_rows is None or len(selected_rows) == 0:
+            return None, None, 'No file selected.'
+        selected_row = selected_rows[0]
+        selected_file = metadata_list[selected_row]['file_path']
+        selected_uuid = metadata_list[selected_row]['uuid']
+        message = f"Selected File: {os.path.basename(selected_file)}"
+        return selected_file, selected_uuid, message
+
+    @app.callback(
+        [Output('main-question-dropdown', 'options'),
+         Output('unit-tests-store', 'data'),
+         Output('test-results-heading', 'children'),
+         Output('question-answer-container', 'style')],
+        [Input('selected-file-path', 'data'),
+         Input('selected-uuid', 'data')]
+    )
+    def update_main_questions(selected_file, selected_uuid):
+        if selected_file is None:
+            return [], None, '', {'display': 'none'}
+        try:
+            with open(selected_file, 'r') as f:
+                data = json.load(f)
+            unit_tests = data.get('unit_tests', [])
+            options = [{'label': test['question'], 'value': idx} 
+                      for idx, test in enumerate(unit_tests)]
+            heading = f"Test Results: {selected_uuid}"
+            return options, unit_tests, heading, {'marginTop': '20px', 'display': 'block'}
+        except Exception as e:
+            print(f"Error loading {selected_file}: {e}")
+            return [], None, '', {'display': 'none'} 

sources/dashboard/callbacks/graph_updates.py

@@ -0,0 +1,133 @@
+import json
+from dash.dependencies import Input, Output, State
+from dash import html, dcc
+import plotly.graph_objects as go
+
+def register_graph_callbacks(app):
+    @app.callback(
+        [Output('file-accuracy-graph', 'children'),
+         Output('question-accuracy-graph', 'children')],
+        [Input('metadata-table', 'data')]
+    )
+    def update_comparison_graphs(data):
+        if not data:
+            return "Please select files to compare.", "Please select files to compare."
+        
+        try:
+            # Get selected files for comparison (checked boxes)
+            selected_files = [row for row in data if row.get('compare') == '☒']
+            
+            if not selected_files:
+                return "Please select files to compare.", "Please select files to compare."
+            
+            file_accuracies = process_file_accuracies(selected_files)
+            question_accuracies = process_question_accuracies(selected_files)
+            
+            file_accuracy_fig = create_file_accuracy_figure(file_accuracies)
+            question_accuracy_fig = create_question_accuracy_figure(question_accuracies)
+            
+            return [
+                dcc.Graph(figure=file_accuracy_fig),
+                dcc.Graph(figure=question_accuracy_fig)
+            ]
+            
+        except Exception as e:
+            print(f"Error updating comparison graphs: {e}")
+            return "Error loading comparison.", "Error loading comparison."
+
+def process_file_accuracies(selected_files):
+    file_accuracies = []
+    for idx, row in enumerate(selected_files):
+        with open(row['file_path'], 'r') as f:
+            data = json.load(f)
+            for metric in data.get('metrics', []):
+                if metric.get('metric_name') == 'Accuracy':
+                    file_accuracies.append({
+                        'File': row['uuid'][:8],
+                        'Accuracy': metric.get('metric_result', 0) * 100,
+                        'Index': idx
+                    })
+    return sorted(file_accuracies, key=lambda x: x['File'])
+
+def process_question_accuracies(selected_files):
+    question_accuracies = []
+    for row in selected_files:
+        with open(row['file_path'], 'r') as f:
+            data = json.load(f)
+            for metric in data.get('metrics', []):
+                if metric.get('metric_name') == 'Accuracy':
+                    question_wise = metric.get('metric_result_question_test_wise', [[]])[0]
+                    question_accuracies.append({
+                        'file_id': row['uuid'][:8],
+                        'accuracies': [acc * 100 for acc in question_wise]
+                    })
+    return question_accuracies
+
+def create_file_accuracy_figure(file_accuracies):
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatter(
+        x=list(range(len(file_accuracies))),
+        y=[fa['Accuracy'] for fa in file_accuracies],
+        mode='lines+markers',
+        name='Accuracy',
+        line=dict(color='#5cb85c', width=2),
+        marker=dict(size=8)
+    ))
+    
+    fig.update_layout(
+        title=f'Accuracy Comparison Across Files ({len(file_accuracies)} files)',
+        plot_bgcolor='#2b2b2b',
+        paper_bgcolor='#2b2b2b',
+        font_color='white',
+        xaxis_title="File ID",
+        yaxis_title="Accuracy (%)",
+        yaxis_range=[0, 100],
+        xaxis=dict(
+            showgrid=True,
+            gridcolor='rgba(255, 255, 255, 0.1)',
+            tickangle=45,
+            tickmode='array',
+            ticktext=[fa['File'] for fa in file_accuracies],
+            tickvals=list(range(len(file_accuracies)))
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridcolor='rgba(255, 255, 255, 0.1)'
+        ),
+        showlegend=False
+    )
+    
+    return fig
+
+def create_question_accuracy_figure(question_accuracies):
+    fig = go.Figure()
+    
+    for qa in question_accuracies:
+        fig.add_trace(go.Scatter(
+            x=list(range(1, len(qa['accuracies']) + 1)),
+            y=qa['accuracies'],
+            mode='lines+markers',
+            name=qa['file_id']
+        ))
+    
+    fig.update_layout(
+        title=f'Question-wise Accuracy Comparison ({len(question_accuracies)} files)',
+        xaxis_title="Question Number",
+        yaxis_title="Accuracy (%)",
+        plot_bgcolor='#2b2b2b',
+        paper_bgcolor='#2b2b2b',
+        font_color='white',
+        yaxis_range=[0, 100],
+        showlegend=True,
+        xaxis=dict(
+            showgrid=True,
+            gridcolor='rgba(255, 255, 255, 0.1)'
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridcolor='rgba(255, 255, 255, 0.1)'
+        )
+    )
+    
+    return fig 

sources/dashboard/callbacks/metrics_updates.py

@@ -0,0 +1,156 @@
+import json
+from dash.dependencies import Input, Output
+from dash import html, dcc
+import plotly.graph_objects as go
+
+def register_metrics_callbacks(app):
+    @app.callback(
+        [Output('test-statistics-content', 'children'),
+         Output('accuracy-chart', 'children'),
+         Output('hallucination-rate', 'children'),
+         Output('llm-drift-rate', 'children'),
+         Output('custom-metric-1', 'children'),
+         Output('custom-metric-2', 'children')],
+        [Input('selected-file-path', 'data')]
+    )
+    def update_metrics(selected_file):
+        default_values = get_default_metric_values()
+        
+        if selected_file is None:
+            return default_values
+        
+        try:
+            with open(selected_file, 'r') as f:
+                data = json.load(f)
+                metrics = data.get('metrics', [])
+                
+                return process_metrics(metrics)
+                
+        except Exception as e:
+            print(f"Error loading metrics from {selected_file}: {e}")
+            return default_values
+
+def get_default_metric_values():
+    """Return default values for all metrics."""
+    default_stats = html.Div([
+        html.P(f"Total Tests: N/A"),
+        html.P(f"Test Cases: N/A"),
+        html.P(f"Paraphrased: N/A"),
+        html.P(f"Iterations: N/A"),
+        html.P(f"Passed: N/A"),
+        html.P(f"Failed: N/A")
+    ])
+
+    default_gauge = html.Div([
+        html.H3("N/A", style={'textAlign': 'center', 'color': 'gray', 'marginTop': '20px'})
+    ])
+
+    default_percentage = html.Div([
+        html.H3("N/A", style={'textAlign': 'center', 'color': 'gray'})
+    ])
+
+    return (
+        default_stats,
+        default_gauge,
+        default_percentage,
+        default_percentage,
+        default_percentage,
+        default_percentage
+    )
+
+def process_metrics(metrics):
+    """Process metrics data and return formatted components."""
+    statistics = get_default_metric_values()[0]  # Default value
+    accuracy = get_default_metric_values()[1]    # Default value
+    hallucination = get_default_metric_values()[2]  # Default value
+    drift = get_default_metric_values()[3]       # Default value
+    custom1 = get_default_metric_values()[4]     # Default value
+    custom2 = get_default_metric_values()[5]     # Default value
+    
+    for metric in metrics:
+        metric_name = metric.get('metric_name', '')
+        
+        if metric_name == 'Statistics':
+            tests = metric.get('tests', {})
+            statistics = html.Div([
+                html.P(f"Total Tests: {tests.get('Total', 'N/A')}"),
+                html.P(f"Test Cases: {tests.get('Test_cases', 'N/A')}"),
+                html.P(f"Paraphrased: {tests.get('Paraphrased', 'N/A')}"),
+                html.P(f"Iterations: {tests.get('Iteration', 'N/A')}"),
+                html.P(f"Passed: {tests.get('Passed', 'N/A')}"),
+                html.P(f"Failed: {tests.get('Failed', 'N/A')}")
+            ])
+        
+        elif metric_name == 'Accuracy':
+            accuracy_value = metric.get('metric_result', 0) * 100
+            accuracy = create_accuracy_gauge(accuracy_value)
+        
+        elif metric_name == 'Hallucination_rate':
+            hall_rate = metric.get('metric_result', 0)
+            hallucination = html.Div([
+                html.H3(f"{hall_rate:.1f}%", 
+                       style={'textAlign': 'center', 
+                             'color': '#d9534f' if hall_rate > 20 else '#5cb85c'})
+            ])
+        
+        elif metric_name == 'LLM Drift rate':
+            drift_rate = metric.get('metric_result', 0)
+            drift = html.Div([
+                html.H3(f"{drift_rate:.1f}%", 
+                       style={'textAlign': 'center', 
+                             'color': '#d9534f' if drift_rate > 30 else '#5cb85c'})
+            ])
+        
+        elif metric_name == 'Custom metric - 1':
+            custom_rate1 = metric.get('metric_result', 0)
+            custom1 = html.Div([
+                html.H3(f"{custom_rate1:.1f}%", 
+                       style={'textAlign': 'center', 
+                             'color': '#d9534f' if custom_rate1 > 50 else '#5cb85c'})
+            ])
+        
+        elif metric_name == 'Custom metric - 2':
+            custom_rate2 = metric.get('metric_result', 0)
+            custom2 = html.Div([
+                html.H3(f"{custom_rate2:.1f}%", 
+                       style={'textAlign': 'center', 
+                             'color': '#d9534f' if custom_rate2 > 50 else '#5cb85c'})
+            ])
+    
+    return statistics, accuracy, hallucination, drift, custom1, custom2
+
+def create_accuracy_gauge(accuracy_value):
+    """Create an accuracy gauge figure."""
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=accuracy_value,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        gauge={
+            'axis': {'range': [0, 100], 'tickwidth': 1},
+            'bar': {'color': "#5cb85c"},
+            'bgcolor': "white",
+            'borderwidth': 2,
+            'bordercolor': "gray",
+            'steps': [
+                {'range': [0, 30], 'color': '#d9534f'},
+                {'range': [30, 70], 'color': '#f0ad4e'},
+                {'range': [70, 100], 'color': '#5cb85c'}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 70
+            }
+        }
+    ))
+
+    fig.update_layout(
+        paper_bgcolor='#2b2b2b',
+        font={'color': "white", 'family': "Arial"},
+        height=200,
+        margin=dict(l=30, r=30, t=30, b=0)
+    )
+
+    return html.Div([
+        dcc.Graph(figure=fig, config={'displayModeBar': False})
+    ])