Download components/run_selector.py from ACA050/aegislm: direct link, hf CLI and curl.
- Browser
- Download file 7.05 kB
-
https://huggingface.co/spaces/ACA050/aegislm/resolve/main/components/run_selector.py
- Command line
-
hf download hf://spaces/ACA050/aegislm/components/run_selector.py
-
curl -L -o run_selector.py https://huggingface.co/spaces/ACA050/aegislm/resolve/main/components/run_selector.py
7.05 kB
| """ | |
| Run Selector Component | |
| Gradio component for selecting evaluation runs. | |
| """ | |
| import logging | |
| from typing import Any, Dict, List, Optional, Tuple | |
| import gradio as gr | |
| from dashboard.data_loader import DashboardDataLoader | |
| from dashboard.utils import format_timestamp, log_dashboard_event | |
| logger = logging.getLogger(__name__) | |
| def create_run_selector( | |
| data_loader: DashboardDataLoader, | |
| ) -> Tuple[gr.Dropdown, gr.DataFrame]: | |
| """ | |
| Create run selector component. | |
| Args: | |
| data_loader: DashboardDataLoader instance | |
| Returns: | |
| Tuple of (dropdown, dataframe) components | |
| """ | |
| def load_runs() -> List[Tuple[str, str]]: | |
| """ | |
| Load available runs for dropdown. | |
| Returns: | |
| List of (run_id, label) tuples | |
| """ | |
| try: | |
| runs = data_loader.get_all_runs() | |
| options = [] | |
| for run in runs: | |
| label = f"{run['model_name']} ({run['timestamp'][:19] if run.get('timestamp') else 'N/A'}) - {run['status']}" | |
| options.append((label, run["id"])) | |
| return options | |
| except Exception as e: | |
| logger.error(f"Error loading runs: {e}") | |
| return [("No runs available", "")] | |
| def get_run_details(run_id: str) -> Dict[str, Any]: | |
| """ | |
| Get run details for display. | |
| Args: | |
| run_id: Selected run ID | |
| Returns: | |
| Dictionary of run details | |
| """ | |
| if not run_id: | |
| return { | |
| "model": "", | |
| "version": "", | |
| "dataset": "", | |
| "timestamp": "", | |
| "status": "", | |
| "score": "", | |
| } | |
| try: | |
| run = data_loader.get_run_by_id(run_id) | |
| log_dashboard_event("DASHBOARD_VIEW_RUN", run_id=run_id) | |
| if run: | |
| return { | |
| "model": run.get("model_name", "N/A"), | |
| "version": run.get("model_version", "N/A"), | |
| "dataset": run.get("dataset_version", "N/A"), | |
| "timestamp": run.get("timestamp", "N/A")[:19] if run.get("timestamp") else "N/A", | |
| "status": run.get("status", "N/A"), | |
| "score": f"{run.get('composite_score', 0):.4f}" if run.get("composite_score") else "N/A", | |
| } | |
| except Exception as e: | |
| logger.error(f"Error fetching run details: {e}") | |
| return { | |
| "model": "Error", | |
| "version": "", | |
| "dataset": "", | |
| "timestamp": "", | |
| "status": "", | |
| "score": "", | |
| } | |
| # Create components | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| run_dropdown = gr.Dropdown( | |
| label="Select Evaluation Run", | |
| choices=load_runs(), | |
| value=None, | |
| interactive=True, | |
| ) | |
| with gr.Column(scale=1): | |
| refresh_btn = gr.Button("🔄 Refresh", variant="secondary") | |
| # Run details display | |
| with gr.Row(): | |
| details_df = gr.DataFrame( | |
| headers=["Property", "Value"], | |
| label="Run Details", | |
| interactive=False, | |
| visible=True, | |
| ) | |
| # Event handlers | |
| def on_select(run_id: str) -> Dict[str, Any]: | |
| """Handle run selection.""" | |
| details = get_run_details(run_id) | |
| data = [ | |
| ["Model", details["model"]], | |
| ["Model Version", details["version"]], | |
| ["Dataset Version", details["dataset"]], | |
| ["Timestamp", details["timestamp"]], | |
| ["Status", details["status"]], | |
| ["Composite Score", details["score"]], | |
| ] | |
| return {"data": data} | |
| def on_refresh() -> List[Tuple[str, str]]: | |
| """Handle refresh button click.""" | |
| return load_runs() | |
| run_dropdown.change( | |
| fn=on_select, | |
| inputs=[run_dropdown], | |
| outputs=[details_df], | |
| ) | |
| refresh_btn.click( | |
| fn=on_refresh, | |
| inputs=[], | |
| outputs=[run_dropdown], | |
| ) | |
| return run_dropdown, details_df | |
| def create_run_selector_simple( | |
| data_loader: DashboardDataLoader, | |
| ) -> gr.Dropdown: | |
| """ | |
| Create simple run selector dropdown. | |
| Args: | |
| data_loader: DashboardDataLoader instance | |
| Returns: | |
| Dropdown component | |
| """ | |
| def load_runs() -> List[str]: | |
| """ | |
| Load available run IDs. | |
| Returns: | |
| List of run ID strings | |
| """ | |
| try: | |
| runs = data_loader.get_all_runs() | |
| return [run["id"] for run in runs] | |
| except Exception as e: | |
| logger.error(f"Error loading runs: {e}") | |
| return [] | |
| dropdown = gr.Dropdown( | |
| label="Select Evaluation Run", | |
| choices=load_runs(), | |
| value=None, | |
| interactive=True, | |
| ) | |
| return dropdown | |
| class RunSelector: | |
| """ | |
| Run selector component with caching and state management. | |
| """ | |
| def __init__(self, data_loader: DashboardDataLoader): | |
| """ | |
| Initialize run selector. | |
| Args: | |
| data_loader: DashboardDataLoader instance | |
| """ | |
| self._data_loader = data_loader | |
| self._runs_cache = None | |
| self._selected_run = None | |
| def get_runs(self, force_refresh: bool = False) -> List[Dict[str, Any]]: | |
| """ | |
| Get list of runs. | |
| Args: | |
| force_refresh: Force refresh cache | |
| Returns: | |
| List of run dictionaries | |
| """ | |
| if self._runs_cache is None or force_refresh: | |
| self._runs_cache = self._data_loader.get_all_runs() | |
| return self._runs_cache | |
| def get_run_choices(self) -> List[Tuple[str, str]]: | |
| """ | |
| Get run choices for dropdown. | |
| Returns: | |
| List of (label, run_id) tuples | |
| """ | |
| runs = self.get_runs() | |
| choices = [] | |
| for run in runs: | |
| label = f"{run['model_name']} ({run.get('timestamp', 'N/A')[:19]})" | |
| choices.append((label, run["id"])) | |
| return choices | |
| def set_selected_run(self, run_id: str) -> None: | |
| """ | |
| Set selected run ID. | |
| Args: | |
| run_id: Run ID to select | |
| """ | |
| self._selected_run = run_id | |
| log_dashboard_event("DASHBOARD_VIEW_RUN", run_id=run_id) | |
| def get_selected_run(self) -> Optional[str]: | |
| """ | |
| Get currently selected run ID. | |
| Returns: | |
| Selected run ID or None | |
| """ | |
| return self._selected_run | |