kailash 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

kailash/visualization/api.py

@@ -27,7 +27,7 @@ import json
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional
 
 try:
     from fastapi import (
@@ -59,8 +59,8 @@ if FASTAPI_AVAILABLE:
     class RunRequest(BaseModel):
         """Request model for starting monitoring."""
 
-        run_id: Optional[str] = None
-        config: Optional[Dict[str, Any]] = None
+        run_id: str | None = None
+        config: dict[str, Any] | None = None
 
     class MetricsResponse(BaseModel):
         """Response model for metrics data."""
@@ -80,12 +80,12 @@ if FASTAPI_AVAILABLE:
         node_id: str
         node_type: str
         status: str
-        started_at: Optional[datetime]
-        ended_at: Optional[datetime]
-        duration: Optional[float]
-        cpu_usage: Optional[float]
-        memory_usage_mb: Optional[float]
-        error_message: Optional[str]
+        started_at: datetime | None
+        ended_at: datetime | None
+        duration: float | None
+        cpu_usage: float | None
+        memory_usage_mb: float | None
+        error_message: str | None
 
     class RunResponse(BaseModel):
         """Response model for run information."""
@@ -93,8 +93,8 @@ if FASTAPI_AVAILABLE:
         run_id: str
         workflow_name: str
         status: str
-        started_at: Optional[datetime]
-        ended_at: Optional[datetime]
+        started_at: datetime | None
+        ended_at: datetime | None
         total_tasks: int
         completed_tasks: int
         failed_tasks: int
@@ -105,7 +105,7 @@ if FASTAPI_AVAILABLE:
         run_id: str
         format: str = "html"
         include_charts: bool = True
-        compare_runs: Optional[List[str]] = None
+        compare_runs: list[str] | None = None
         detail_level: str = "detailed"
 
 
@@ -123,7 +123,7 @@ class DashboardAPIServer:
     def __init__(
         self,
         task_manager: TaskManager,
-        dashboard_config: Optional[DashboardConfig] = None,
+        dashboard_config: DashboardConfig | None = None,
     ):
         """Initialize API server.
 
@@ -145,8 +145,8 @@ class DashboardAPIServer:
         self.reporter = WorkflowPerformanceReporter(task_manager)
 
         # WebSocket connections for real-time updates
-        self._websocket_connections: List[WebSocket] = []
-        self._broadcast_task: Optional[asyncio.Task] = None
+        self._websocket_connections: list[WebSocket] = []
+        self._broadcast_task: asyncio.Task | None = None
 
         # Create FastAPI app
         self.app = FastAPI(
@@ -177,7 +177,7 @@ class DashboardAPIServer:
             """Health check endpoint."""
             return {"status": "healthy", "timestamp": datetime.now()}
 
-        @self.app.get("/api/v1/runs", response_model=List[RunResponse])
+        @self.app.get("/api/v1/runs", response_model=list[RunResponse])
         async def list_runs(limit: int = 10, offset: int = 0):
             """Get list of workflow runs."""
             try:
@@ -243,7 +243,7 @@ class DashboardAPIServer:
                 self.logger.error(f"Failed to get run {run_id}: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
-        @self.app.get("/api/v1/runs/{run_id}/tasks", response_model=List[TaskResponse])
+        @self.app.get("/api/v1/runs/{run_id}/tasks", response_model=list[TaskResponse])
         async def get_run_tasks(run_id: str):
             """Get tasks for a specific run."""
             try:
@@ -352,7 +352,7 @@ class DashboardAPIServer:
                 self.logger.error(f"Failed to get current metrics: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
-        @self.app.get("/api/v1/metrics/history", response_model=List[MetricsResponse])
+        @self.app.get("/api/v1/metrics/history", response_model=list[MetricsResponse])
         async def get_metrics_history(minutes: int = 30):
             """Get metrics history for specified time period."""
             try:
@@ -475,7 +475,7 @@ class DashboardAPIServer:
         run_id: str,
         output_path: Path,
         report_format: ReportFormat,
-        compare_runs: Optional[List[str]] = None,
+        compare_runs: list[str] | None = None,
     ):
         """Generate report in background task."""
         try:
@@ -564,7 +564,7 @@ class SimpleDashboardAPI:
     def __init__(
         self,
         task_manager: TaskManager,
-        dashboard_config: Optional[DashboardConfig] = None,
+        dashboard_config: DashboardConfig | None = None,
     ):
         """Initialize simple API interface.
 
@@ -578,7 +578,7 @@ class SimpleDashboardAPI:
         self.reporter = WorkflowPerformanceReporter(task_manager)
         self.logger = logger
 
-    def get_runs(self, limit: int = 10, offset: int = 0) -> List[Dict[str, Any]]:
+    def get_runs(self, limit: int = 10, offset: int = 0) -> list[dict[str, Any]]:
         """Get list of workflow runs."""
         all_runs = self.task_manager.list_runs()
         runs = all_runs[offset : offset + limit]
@@ -604,7 +604,7 @@ class SimpleDashboardAPI:
 
         return result
 
-    def get_run_details(self, run_id: str) -> Optional[Dict[str, Any]]:
+    def get_run_details(self, run_id: str) -> dict[str, Any] | None:
         """Get details for a specific run."""
         run = self.task_manager.get_run(run_id)
         if not run:
@@ -641,17 +641,17 @@ class SimpleDashboardAPI:
             ],
         }
 
-    def start_monitoring(self, run_id: Optional[str] = None) -> Dict[str, Any]:
+    def start_monitoring(self, run_id: str | None = None) -> dict[str, Any]:
         """Start real-time monitoring."""
         self.dashboard.start_monitoring(run_id)
         return {"status": "started", "run_id": run_id}
 
-    def stop_monitoring(self) -> Dict[str, Any]:
+    def stop_monitoring(self) -> dict[str, Any]:
         """Stop real-time monitoring."""
         self.dashboard.stop_monitoring()
         return {"status": "stopped"}
 
-    def get_current_metrics(self) -> Optional[Dict[str, Any]]:
+    def get_current_metrics(self) -> dict[str, Any] | None:
         """Get current live metrics."""
         metrics = self.dashboard.get_current_metrics()
         if not metrics:
@@ -668,7 +668,7 @@ class SimpleDashboardAPI:
             "avg_task_duration": metrics.avg_task_duration,
         }
 
-    def get_metrics_history(self, minutes: int = 30) -> List[Dict[str, Any]]:
+    def get_metrics_history(self, minutes: int = 30) -> list[dict[str, Any]]:
         """Get metrics history."""
         history = self.dashboard.get_metrics_history(minutes=minutes)
 
@@ -690,8 +690,8 @@ class SimpleDashboardAPI:
         self,
         run_id: str,
         format: str = "html",
-        output_path: Optional[Union[str, Path]] = None,
-        compare_runs: Optional[List[str]] = None,
+        output_path: str | Path | None = None,
+        compare_runs: list[str] | None = None,
     ) -> Path:
         """Generate performance report."""
         try:
@@ -708,9 +708,7 @@ class SimpleDashboardAPI:
             compare_runs=compare_runs,
         )
 
-    def generate_dashboard(
-        self, output_path: Optional[Union[str, Path]] = None
-    ) -> Path:
+    def generate_dashboard(self, output_path: str | Path | None = None) -> Path:
         """Generate live dashboard HTML."""
         if output_path is None:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -718,9 +716,7 @@ class SimpleDashboardAPI:
 
         return self.dashboard.generate_live_report(output_path, include_charts=True)
 
-    def export_metrics_json(
-        self, output_path: Optional[Union[str, Path]] = None
-    ) -> Path:
+    def export_metrics_json(self, output_path: str | Path | None = None) -> Path:
         """Export current metrics as JSON."""
         if output_path is None:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

kailash/visualization/dashboard.py

@@ -27,7 +27,7 @@ import time
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 import numpy as np
 
@@ -100,7 +100,7 @@ class RealTimeDashboard:
     """
 
     def __init__(
-        self, task_manager: TaskManager, config: Optional[DashboardConfig] = None
+        self, task_manager: TaskManager, config: DashboardConfig | None = None
     ):
         """Initialize real-time dashboard.
 
@@ -114,17 +114,17 @@ class RealTimeDashboard:
 
         # Live monitoring state
         self._monitoring = False
-        self._monitor_thread: Optional[threading.Thread] = None
-        self._metrics_history: List[LiveMetrics] = []
-        self._current_run_id: Optional[str] = None
+        self._monitor_thread: threading.Thread | None = None
+        self._metrics_history: list[LiveMetrics] = []
+        self._current_run_id: str | None = None
 
         # Event callbacks
-        self._status_callbacks: List[callable] = []
-        self._metrics_callbacks: List[callable] = []
+        self._status_callbacks: list[callable] = []
+        self._metrics_callbacks: list[callable] = []
 
         self.logger = logger
 
-    def start_monitoring(self, run_id: Optional[str] = None):
+    def start_monitoring(self, run_id: str | None = None):
         """Start real-time monitoring for a workflow run.
 
         Args:
@@ -297,11 +297,11 @@ class RealTimeDashboard:
         """
         self._status_callbacks.append(callback)
 
-    def get_current_metrics(self) -> Optional[LiveMetrics]:
+    def get_current_metrics(self) -> LiveMetrics | None:
         """Get the most recent metrics."""
         return self._metrics_history[-1] if self._metrics_history else None
 
-    def get_metrics_history(self, minutes: Optional[int] = None) -> List[LiveMetrics]:
+    def get_metrics_history(self, minutes: int | None = None) -> list[LiveMetrics]:
         """Get metrics history for specified time period.
 
         Args:
@@ -317,7 +317,7 @@ class RealTimeDashboard:
         return [m for m in self._metrics_history if m.timestamp >= cutoff]
 
     def generate_live_report(
-        self, output_path: Union[str, Path], include_charts: bool = True
+        self, output_path: str | Path, include_charts: bool = True
     ) -> Path:
         """Generate comprehensive live dashboard report.
 
@@ -396,7 +396,7 @@ class RealTimeDashboard:
 
         return html_template
 
-    def _generate_status_section(self, metrics: Optional[LiveMetrics]) -> str:
+    def _generate_status_section(self, metrics: LiveMetrics | None) -> str:
         """Generate status overview section."""
         if not metrics:
             return """
@@ -442,7 +442,7 @@ class RealTimeDashboard:
         </section>
         """
 
-    def _generate_live_metrics_section(self, history: List[LiveMetrics]) -> str:
+    def _generate_live_metrics_section(self, history: list[LiveMetrics]) -> str:
         """Generate live metrics charts section."""
         if not history:
             return """
@@ -860,7 +860,7 @@ class DashboardExporter:
         self.dashboard = dashboard
         self.logger = logger
 
-    def export_metrics_json(self, output_path: Union[str, Path]) -> Path:
+    def export_metrics_json(self, output_path: str | Path) -> Path:
         """Export current metrics as JSON.
 
         Args:
@@ -895,7 +895,7 @@ class DashboardExporter:
         self.logger.info(f"Exported metrics to: {output_path}")
         return output_path
 
-    def _metrics_to_dict(self, metrics: LiveMetrics) -> Dict[str, Any]:
+    def _metrics_to_dict(self, metrics: LiveMetrics) -> dict[str, Any]:
         """Convert LiveMetrics to dictionary."""
         return {
             "timestamp": metrics.timestamp.isoformat(),
@@ -909,8 +909,8 @@ class DashboardExporter:
         }
 
     def create_dashboard_snapshot(
-        self, output_dir: Union[str, Path], include_static_charts: bool = True
-    ) -> Dict[str, Path]:
+        self, output_dir: str | Path, include_static_charts: bool = True
+    ) -> dict[str, Path]:
         """Create complete dashboard snapshot with all assets.
 
         Args:

kailash/visualization/performance.py

@@ -23,7 +23,7 @@ Downstream Consumers:
 
 import logging
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -51,8 +51,8 @@ class PerformanceVisualizer:
         self.logger = logger
 
     def create_run_performance_summary(
-        self, run_id: str, output_dir: Optional[Path] = None
-    ) -> Dict[str, Path]:
+        self, run_id: str, output_dir: Path | None = None
+    ) -> dict[str, Path]:
         """Create comprehensive performance summary for a workflow run.
 
         Args:
@@ -63,8 +63,12 @@ class PerformanceVisualizer:
             Dictionary mapping chart names to file paths
         """
         if output_dir is None:
-            # Use relative path that works from project root or create in current directory
-            output_dir = Path.cwd() / "outputs" / "performance"
+            # Use centralized output directory
+            # Get project root and use data/outputs/visualizations/performance
+            project_root = Path(__file__).parent.parent.parent.parent
+            output_dir = (
+                project_root / "data" / "outputs" / "visualizations" / "performance"
+            )
         output_dir.mkdir(parents=True, exist_ok=True)
 
         # Get run data
@@ -108,7 +112,7 @@ class PerformanceVisualizer:
         return outputs
 
     def _create_execution_timeline(
-        self, tasks: List[TaskRun], output_path: Path
+        self, tasks: list[TaskRun], output_path: Path
     ) -> Path:
         """Create Gantt-style execution timeline."""
         fig, ax = plt.subplots(figsize=(12, max(6, len(tasks) * 0.5)))
@@ -206,7 +210,7 @@ class PerformanceVisualizer:
         return output_path
 
     def _create_resource_usage_chart(
-        self, tasks: List[TaskRun], output_path: Path
+        self, tasks: list[TaskRun], output_path: Path
     ) -> Path:
         """Create resource usage comparison chart."""
         fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12))
@@ -254,7 +258,7 @@ class PerformanceVisualizer:
         ax1.grid(True, axis="y", alpha=0.3)
 
         # Add value labels
-        for bar, value in zip(bars1, cpu_usage):
+        for bar, value in zip(bars1, cpu_usage, strict=False):
             if value > 0:
                 ax1.text(
                     bar.get_x() + bar.get_width() / 2,
@@ -291,7 +295,7 @@ class PerformanceVisualizer:
         ax3.grid(True, axis="y", alpha=0.3)
 
         # Add value labels
-        for bar, value in zip(bars3, durations):
+        for bar, value in zip(bars3, durations, strict=False):
             if value > 0:
                 ax3.text(
                     bar.get_x() + bar.get_width() / 2,
@@ -310,7 +314,7 @@ class PerformanceVisualizer:
         return output_path
 
     def _create_node_performance_comparison(
-        self, tasks: List[TaskRun], output_path: Path
+        self, tasks: list[TaskRun], output_path: Path
     ) -> Path:
         """Create performance comparison radar chart."""
         # Group tasks by node type
@@ -381,7 +385,9 @@ class PerformanceVisualizer:
 
         colors = plt.cm.tab10(np.linspace(0, 1, len(avg_metrics)))
 
-        for (node_type, metrics), color in zip(avg_metrics.items(), colors):
+        for (node_type, metrics), color in zip(
+            avg_metrics.items(), colors, strict=False
+        ):
             values = list(metrics.values())
 
             # Normalize values to 0-100 scale for better visualization
@@ -400,7 +406,7 @@ class PerformanceVisualizer:
             }
 
             normalized_values = []
-            for cat, val in zip(categories, values):
+            for cat, val in zip(categories, values, strict=False):
                 normalized_values.append((val / max_vals[cat]) * 100)
 
             normalized_values += normalized_values[:1]
@@ -431,7 +437,7 @@ class PerformanceVisualizer:
 
         return output_path
 
-    def _create_io_analysis(self, tasks: List[TaskRun], output_path: Path) -> Path:
+    def _create_io_analysis(self, tasks: list[TaskRun], output_path: Path) -> Path:
         """Create I/O operations analysis chart."""
         fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
 
@@ -539,7 +545,7 @@ class PerformanceVisualizer:
         return output_path
 
     def _create_performance_heatmap(
-        self, tasks: List[TaskRun], output_path: Path
+        self, tasks: list[TaskRun], output_path: Path
     ) -> Path:
         """Create performance metrics heatmap."""
         # Prepare data matrix
@@ -632,7 +638,7 @@ class PerformanceVisualizer:
         return output_path
 
     def _create_performance_report(
-        self, run: Any, tasks: List[TaskRun], output_path: Path
+        self, run: Any, tasks: list[TaskRun], output_path: Path
     ) -> Path:
         """Create markdown performance report."""
         lines = []
@@ -714,12 +720,19 @@ class PerformanceVisualizer:
 
         return output_path
 
-    def compare_runs(
-        self, run_ids: List[str], output_path: Optional[Path] = None
-    ) -> Path:
+    def compare_runs(self, run_ids: list[str], output_path: Path | None = None) -> Path:
         """Compare performance across multiple runs."""
         if output_path is None:
-            output_path = Path.cwd() / "outputs" / "performance" / "comparison.png"
+            # Use centralized output directory
+            project_root = Path(__file__).parent.parent.parent.parent
+            output_path = (
+                project_root
+                / "data"
+                / "outputs"
+                / "visualizations"
+                / "performance"
+                / "comparison.png"
+            )
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
         fig, axes = plt.subplots(2, 2, figsize=(15, 12))

kailash/visualization/reports.py

@@ -27,7 +27,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 import numpy as np
 
@@ -86,7 +86,7 @@ class PerformanceInsight:
     title: str
     description: str
     recommendation: str
-    metrics: Dict[str, Any] = field(default_factory=dict)
+    metrics: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -134,9 +134,7 @@ class WorkflowPerformanceReporter:
         report = reporter.generate_report(run_id, output_path="report.html")
     """
 
-    def __init__(
-        self, task_manager: TaskManager, config: Optional[ReportConfig] = None
-    ):
+    def __init__(self, task_manager: TaskManager, config: ReportConfig | None = None):
         """Initialize performance reporter.
 
         Args:
@@ -151,9 +149,9 @@ class WorkflowPerformanceReporter:
     def generate_report(
         self,
         run_id: str,
-        output_path: Optional[Union[str, Path]] = None,
+        output_path: str | Path | None = None,
         format: ReportFormat = ReportFormat.HTML,
-        compare_runs: Optional[List[str]] = None,
+        compare_runs: list[str] | None = None,
     ) -> Path:
         """Generate comprehensive performance report.
 
@@ -168,9 +166,13 @@ class WorkflowPerformanceReporter:
         """
         if output_path is None:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            # Use centralized output directory
+            project_root = Path(__file__).parent.parent.parent.parent
             output_path = (
-                Path.cwd()
+                project_root
+                / "data"
                 / "outputs"
+                / "reports"
                 / f"workflow_report_{run_id[:8]}_{timestamp}.{format.value}"
             )
 
@@ -207,7 +209,7 @@ class WorkflowPerformanceReporter:
         self.logger.info(f"Generated {format.value.upper()} report: {output_path}")
         return output_path
 
-    def _analyze_workflow_run(self, run_id: str) -> Dict[str, Any]:
+    def _analyze_workflow_run(self, run_id: str) -> dict[str, Any]:
         """Perform detailed analysis of a workflow run.
 
         Args:
@@ -260,7 +262,7 @@ class WorkflowPerformanceReporter:
         }
 
     def _calculate_workflow_summary(
-        self, run: Any, tasks: List[TaskRun]
+        self, run: Any, tasks: list[TaskRun]
     ) -> WorkflowSummary:
         """Calculate summary statistics for the workflow run."""
         summary = WorkflowSummary(
@@ -336,7 +338,7 @@ class WorkflowPerformanceReporter:
 
         return summary
 
-    def _analyze_task_performance(self, tasks: List[TaskRun]) -> Dict[str, Any]:
+    def _analyze_task_performance(self, tasks: list[TaskRun]) -> dict[str, Any]:
         """Analyze performance patterns across tasks."""
         analysis = {
             "by_node_type": {},
@@ -399,7 +401,7 @@ class WorkflowPerformanceReporter:
 
         return analysis
 
-    def _identify_bottlenecks(self, tasks: List[TaskRun]) -> List[Dict[str, Any]]:
+    def _identify_bottlenecks(self, tasks: list[TaskRun]) -> list[dict[str, Any]]:
         """Identify performance bottlenecks in the workflow."""
         bottlenecks = []
 
@@ -493,7 +495,7 @@ class WorkflowPerformanceReporter:
 
         return sorted(bottlenecks, key=lambda x: x["value"], reverse=True)
 
-    def _analyze_resource_utilization(self, tasks: List[TaskRun]) -> Dict[str, Any]:
+    def _analyze_resource_utilization(self, tasks: list[TaskRun]) -> dict[str, Any]:
         """Analyze overall resource utilization patterns."""
         analysis = {
             "cpu_distribution": {},
@@ -577,7 +579,7 @@ class WorkflowPerformanceReporter:
 
         return analysis
 
-    def _analyze_errors(self, tasks: List[TaskRun]) -> Dict[str, Any]:
+    def _analyze_errors(self, tasks: list[TaskRun]) -> dict[str, Any]:
         """Analyze error patterns and failure modes."""
         analysis = {
             "error_summary": {},
@@ -630,7 +632,7 @@ class WorkflowPerformanceReporter:
 
         return analysis
 
-    def _generate_insights(self, analysis: Dict[str, Any]) -> List[PerformanceInsight]:
+    def _generate_insights(self, analysis: dict[str, Any]) -> list[PerformanceInsight]:
         """Generate actionable insights from analysis results."""
         insights = []
 
@@ -737,8 +739,8 @@ class WorkflowPerformanceReporter:
         return insights
 
     def _generate_analysis_charts(
-        self, run_id: str, tasks: List[TaskRun]
-    ) -> Dict[str, str]:
+        self, run_id: str, tasks: list[TaskRun]
+    ) -> dict[str, str]:
         """Generate analysis charts and return file paths."""
         charts = {}
 
@@ -751,7 +753,7 @@ class WorkflowPerformanceReporter:
 
         return charts
 
-    def _compare_runs(self, run_ids: List[str]) -> Dict[str, Any]:
+    def _compare_runs(self, run_ids: list[str]) -> dict[str, Any]:
         """Compare performance across multiple runs."""
         comparison = {"runs": [], "trends": {}, "relative_performance": {}}
 
@@ -810,9 +812,9 @@ class WorkflowPerformanceReporter:
 
     def _generate_html_report(
         self,
-        analysis: Dict[str, Any],
-        insights: List[PerformanceInsight],
-        comparison_data: Optional[Dict[str, Any]] = None,
+        analysis: dict[str, Any],
+        insights: list[PerformanceInsight],
+        comparison_data: dict[str, Any] | None = None,
     ) -> str:
         """Generate HTML report content."""
         run_info = analysis["run_info"]
@@ -978,9 +980,9 @@ class WorkflowPerformanceReporter:
 
     def _generate_markdown_report(
         self,
-        analysis: Dict[str, Any],
-        insights: List[PerformanceInsight],
-        comparison_data: Optional[Dict[str, Any]] = None,
+        analysis: dict[str, Any],
+        insights: list[PerformanceInsight],
+        comparison_data: dict[str, Any] | None = None,
     ) -> str:
         """Generate Markdown report content."""
         run_info = analysis["run_info"]
@@ -1094,9 +1096,9 @@ class WorkflowPerformanceReporter:
 
     def _generate_json_report(
         self,
-        analysis: Dict[str, Any],
-        insights: List[PerformanceInsight],
-        comparison_data: Optional[Dict[str, Any]] = None,
+        analysis: dict[str, Any],
+        insights: list[PerformanceInsight],
+        comparison_data: dict[str, Any] | None = None,
     ) -> str:
         """Generate JSON report content."""
         report_data = {
@@ -1140,7 +1142,7 @@ class WorkflowPerformanceReporter:
 
         return json.dumps(report_data, indent=2, default=str)
 
-    def _generate_comparison_html(self, comparison_data: Dict[str, Any]) -> str:
+    def _generate_comparison_html(self, comparison_data: dict[str, Any]) -> str:
         """Generate HTML for run comparison section."""
         runs = comparison_data.get("runs", [])
         trends = comparison_data.get("trends", {})