Update dashboard/app.py

dashboard/app.py

@@ -80,66 +80,34 @@ def run(from_results_dir, datasource, port):
         #    data[metric] = data[metric].apply(lambda x: f"{x:.2f}")
         data = data.rename(
             columns=column_mappings)
-        
-        # This is the raw data with correct dtypes for sorting
-        raw_data_for_sorting = data.copy()
 
-        # Define columns that should be numeric for sorting and have specific formatting
-        # These names must match the column names *after* renaming by column_mappings
+        # uncomment the following line if you want to return the raw DataFrame without formatting
+        # return data
+
+        # Ensure numeric columns are properly typed for sorting
         numeric_cols_to_ensure = [
-            'ITL P90 (ms)', 'TTFT P90 (ms)', 'E2E P90 (ms)', 
+            'ITL P90 (ms)', 'TTFT P90 (ms)', 'E2E P90 (ms)',
             'Throughput (tokens/s)', 'QPS'
         ]
 
         for col in numeric_cols_to_ensure:
-            if col in raw_data_for_sorting.columns:
-                # Convert column to numeric, coercing errors to NaN
-                # NaN values will be handled by the formatter's try-except or display as "nan"
-                raw_data_for_sorting[col] = pd.to_numeric(raw_data_for_sorting[col], errors='coerce')
-            # else:
-                # Optionally, log a warning if a column expected to be numeric is missing
-                # print(f"Warning: Column '{col}' not found for numeric conversion in summary_table.")
-
-
-        headers = raw_data_for_sorting.columns.tolist()
-
-        # Formatter for display purposes
-        formatter = {
-            'ITL P90 (ms)': "{:.2f}",
-            'TTFT P90 (ms)': "{:.2f}",
-            'E2E P90 (ms)': "{:.2f}",
-            'Throughput (tokens/s)': "{:.2f}",
-            'QPS': "{:.0f}"
+            if col in data.columns:
+                data[col] = pd.to_numeric(data[col], errors='coerce')
+
+        # Round numeric columns to reduce decimal places while maintaining sorting
+        rounding_rules = {
+            'ITL P90 (ms)': 2,
+            'TTFT P90 (ms)': 2,
+            'E2E P90 (ms)': 2,
+            'Throughput (tokens/s)': 2,
+            'QPS': 0  # Round to integers
         }
 
-        # Create the display_value array (list of lists)
-        display_values_list = []
-        for _, row in raw_data_for_sorting.iterrows():
-            display_row = []
-            for col_name in headers:
-                val = row[col_name]
-                if col_name in formatter:
-                    try:
-                        display_row.append(formatter[col_name].format(val))
-                    except (ValueError, TypeError): # Fallback for any unexpected non-numeric in formatted columns
-                        display_row.append(str(val))
-                else:
-                    display_row.append(str(val)) # Default string conversion for other columns
-            display_values_list.append(display_row)
-
-        # Create a styling array (list of lists for CSS). Empty strings if no specific CSS.
-        # Corrected the extra parenthesis at the end of this line
-        styling_array = [["" for _ in headers] for _ in range(len(raw_data_for_sorting))]
-
-        return {
-            # Convert the DataFrame (with corrected numeric dtypes) to a list of lists for the "data" field
-            "data": raw_data_for_sorting.values.tolist(),
-            "headers": headers,
-            "metadata": {
-                "display_value": display_values_list,
-                "styling": styling_array, # Optional: for cell-specific CSS
-            },
-        }
+        for col, decimals in rounding_rules.items():
+            if col in data.columns:
+                data[col] = data[col].round(decimals)
+
+        return data
 
     def load_bench_results(source) -> pd.DataFrame:
         data = pd.read_parquet(source)