yanex 0.1.0__py3-none-any.whl

yanex/cli/commands/archive.py

@@ -0,0 +1,177 @@
+"""
+Archive experiments - move them to archived directory.
+"""
+
+from typing import Optional
+
+import click
+
+from ...core.constants import EXPERIMENT_STATUSES
+from ..filters import ExperimentFilter, parse_time_spec
+from .confirm import (
+    confirm_experiment_operation,
+    find_experiments_by_filters,
+    find_experiments_by_identifiers,
+)
+
+
+@click.command("archive")
+@click.argument("experiment_identifiers", nargs=-1)
+@click.option(
+    "--status",
+    type=click.Choice(EXPERIMENT_STATUSES),
+    help="Archive experiments with specific status",
+)
+@click.option(
+    "--name",
+    "name_pattern",
+    help="Archive experiments matching name pattern (glob syntax)",
+)
+@click.option(
+    "--tag", "tags", multiple=True, help="Archive experiments with ALL specified tags"
+)
+@click.option(
+    "--started-after",
+    help="Archive experiments started after date/time (e.g., '2025-01-01', 'yesterday', '1 week ago')",
+)
+@click.option("--started-before", help="Archive experiments started before date/time")
+@click.option("--ended-after", help="Archive experiments ended after date/time")
+@click.option("--ended-before", help="Archive experiments ended before date/time")
+@click.option("--force", is_flag=True, help="Skip confirmation prompt")
+@click.pass_context
+def archive_experiments(
+    ctx,
+    experiment_identifiers: tuple,
+    status: Optional[str],
+    name_pattern: Optional[str],
+    tags: tuple,
+    started_after: Optional[str],
+    started_before: Optional[str],
+    ended_after: Optional[str],
+    ended_before: Optional[str],
+    force: bool,
+):
+    """
+    Archive experiments by moving them to archived directory.
+
+    EXPERIMENT_IDENTIFIERS can be experiment IDs or names.
+    If no identifiers provided, experiments are filtered by options.
+
+    Examples:
+    \\b
+        yanex archive exp1 exp2              # Archive specific experiments
+        yanex archive --status failed        # Archive all failed experiments
+        yanex archive --status completed --ended-before "1 month ago"
+        yanex archive --name "*training*"    # Archive experiments with "training" in name
+        yanex archive --tag experiment-v1   # Archive experiments with specific tag
+    """
+    try:
+        filter_obj = ExperimentFilter()
+
+        # Validate mutually exclusive targeting
+        has_identifiers = len(experiment_identifiers) > 0
+        has_filters = any(
+            [
+                status,
+                name_pattern,
+                tags,
+                started_after,
+                started_before,
+                ended_after,
+                ended_before,
+            ]
+        )
+
+        if has_identifiers and has_filters:
+            click.echo(
+                "Error: Cannot use both experiment identifiers and filter options. Choose one approach.",
+                err=True,
+            )
+            ctx.exit(1)
+
+        if not has_identifiers and not has_filters:
+            click.echo(
+                "Error: Must specify either experiment identifiers or filter options",
+                err=True,
+            )
+            ctx.exit(1)
+
+        # Parse time specifications
+        started_after_dt = parse_time_spec(started_after) if started_after else None
+        started_before_dt = parse_time_spec(started_before) if started_before else None
+        ended_after_dt = parse_time_spec(ended_after) if ended_after else None
+        ended_before_dt = parse_time_spec(ended_before) if ended_before else None
+
+        # Find experiments to archive
+        if experiment_identifiers:
+            # Archive specific experiments by ID/name
+            experiments = find_experiments_by_identifiers(
+                filter_obj,
+                list(experiment_identifiers),
+                include_archived=False,  # Can't archive already archived experiments
+            )
+        else:
+            # Archive experiments by filter criteria
+
+            experiments = find_experiments_by_filters(
+                filter_obj,
+                status=status,
+                name_pattern=name_pattern,
+                tags=list(tags) if tags else None,
+                started_after=started_after_dt,
+                started_before=started_before_dt,
+                ended_after=ended_after_dt,
+                ended_before=ended_before_dt,
+                include_archived=False,  # Can't archive already archived experiments
+            )
+
+        # Filter out already archived experiments (extra safety)
+        experiments = [exp for exp in experiments if not exp.get("archived", False)]
+
+        if not experiments:
+            click.echo("No experiments found to archive.")
+            return
+
+        # Show experiments and get confirmation
+        if not confirm_experiment_operation(
+            experiments, "archive", force, default_yes=True
+        ):
+            click.echo("Archive operation cancelled.")
+            return
+
+        # Archive experiments
+        click.echo(f"Archiving {len(experiments)} experiment(s)...")
+
+        success_count = 0
+        for exp in experiments:
+            try:
+                experiment_id = exp["id"]
+                filter_obj.manager.storage.archive_experiment(experiment_id)
+
+                # Show progress
+                exp_name = exp.get("name", "[unnamed]")
+                click.echo(f"  ✓ Archived {experiment_id} ({exp_name})")
+                success_count += 1
+
+            except Exception as e:
+                exp_name = exp.get("name", "[unnamed]")
+                click.echo(
+                    f"  ✗ Failed to archive {experiment_id} ({exp_name}): {e}", err=True
+                )
+
+        # Summary
+        if success_count == len(experiments):
+            click.echo(f"Successfully archived {success_count} experiment(s).")
+        else:
+            failed_count = len(experiments) - success_count
+            click.echo(
+                f"Archived {success_count} experiment(s), {failed_count} failed.",
+                err=True,
+            )
+            ctx.exit(1)
+
+    except click.ClickException:
+        raise  # Re-raise ClickException to show proper error message
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        ctx.exit(1)

yanex/cli/commands/compare.py

@@ -0,0 +1,320 @@
+"""
+Compare experiments - interactive table with parameters and metrics.
+"""
+
+from typing import Optional
+
+import click
+
+from ...core.comparison import ExperimentComparisonData
+from ...core.constants import EXPERIMENT_STATUSES
+from ...ui.compare_table import run_comparison_table
+from ..filters import ExperimentFilter, parse_time_spec
+from .confirm import find_experiments_by_filters, find_experiments_by_identifiers
+
+
+@click.command("compare")
+@click.argument("experiment_identifiers", nargs=-1)
+@click.option(
+    "--status",
+    type=click.Choice(EXPERIMENT_STATUSES),
+    help="Compare experiments with specific status",
+)
+@click.option(
+    "--name",
+    "name_pattern",
+    help="Compare experiments matching name pattern (glob syntax)",
+)
+@click.option(
+    "--tag", "tags", multiple=True, help="Compare experiments with ALL specified tags"
+)
+@click.option(
+    "--started-after",
+    help="Compare experiments started after date/time (e.g., '2025-01-01', 'yesterday', '1 week ago')",
+)
+@click.option("--started-before", help="Compare experiments started before date/time")
+@click.option("--ended-after", help="Compare experiments ended after date/time")
+@click.option("--ended-before", help="Compare experiments ended before date/time")
+@click.option(
+    "--archived",
+    is_flag=True,
+    help="Include archived experiments (default: only regular experiments)",
+)
+@click.option(
+    "--params",
+    help="Show only specified parameters (comma-separated, e.g., 'learning_rate,epochs')",
+)
+@click.option(
+    "--metrics",
+    help="Show only specified metrics (comma-separated, e.g., 'accuracy,loss')",
+)
+@click.option(
+    "--only-different",
+    is_flag=True,
+    help="Show only columns where values differ between experiments",
+)
+@click.option(
+    "--export",
+    "export_path",
+    help="Export comparison data to CSV file instead of interactive view",
+)
+@click.option(
+    "--no-interactive",
+    is_flag=True,
+    help="Print static table instead of interactive view",
+)
+@click.option(
+    "--max-rows",
+    type=int,
+    help="Limit number of experiments displayed",
+)
+@click.pass_context
+def compare_experiments(
+    ctx,
+    experiment_identifiers: tuple,
+    status: Optional[str],
+    name_pattern: Optional[str],
+    tags: tuple,
+    started_after: Optional[str],
+    started_before: Optional[str],
+    ended_after: Optional[str],
+    ended_before: Optional[str],
+    archived: bool,
+    params: Optional[str],
+    metrics: Optional[str],
+    only_different: bool,
+    export_path: Optional[str],
+    no_interactive: bool,
+    max_rows: Optional[int],
+):
+    """
+    Compare experiments in an interactive table showing parameters and metrics.
+
+    EXPERIMENT_IDENTIFIERS can be experiment IDs or names.
+    If no identifiers provided, experiments are filtered by options.
+
+    The interactive table supports:
+    - Navigation with arrow keys or hjkl
+    - Sorting by any column (s/S for asc/desc, 1/2 for numeric)
+    - Export to CSV (press 'e' in interactive mode)
+    - Help (press '?' for keyboard shortcuts)
+
+    Examples:
+    \\b
+        yanex compare                                    # All experiments
+        yanex compare exp1 exp2 exp3                    # Specific experiments
+        yanex compare --status completed                # Completed experiments
+        yanex compare --tag training --only-different  # Training experiments, show differences only
+        yanex compare --params learning_rate,epochs    # Show only specified parameters
+        yanex compare --export results.csv             # Export to CSV
+        yanex compare --no-interactive                  # Static table output
+    """
+    try:
+        filter_obj = ExperimentFilter()
+
+        # Validate mutually exclusive targeting
+        has_identifiers = len(experiment_identifiers) > 0
+        has_filters = any(
+            [
+                status,
+                name_pattern,
+                tags,
+                started_after,
+                started_before,
+                ended_after,
+                ended_before,
+            ]
+        )
+
+        if has_identifiers and has_filters:
+            click.echo(
+                "Error: Cannot use both experiment identifiers and filter options. Choose one approach.",
+                err=True,
+            )
+            ctx.exit(1)
+
+        if not has_identifiers and not has_filters:
+            # No filters specified - use all experiments
+            pass
+
+        # Parse time specifications
+        started_after_dt = parse_time_spec(started_after) if started_after else None
+        started_before_dt = parse_time_spec(started_before) if started_before else None
+        ended_after_dt = parse_time_spec(ended_after) if ended_after else None
+        ended_before_dt = parse_time_spec(ended_before) if ended_before else None
+
+        # Find experiments to compare
+        if experiment_identifiers:
+            # Compare specific experiments by ID/name
+            experiments = find_experiments_by_identifiers(
+                filter_obj, list(experiment_identifiers), include_archived=archived
+            )
+        else:
+            # Compare experiments by filter criteria
+            experiments = find_experiments_by_filters(
+                filter_obj,
+                status=status,
+                name_pattern=name_pattern,
+                tags=list(tags) if tags else None,
+                started_after=started_after_dt,
+                started_before=started_before_dt,
+                ended_after=ended_after_dt,
+                ended_before=ended_before_dt,
+                include_archived=archived,
+            )
+
+        if not experiments:
+            location = "archived" if archived else "regular"
+            click.echo(f"No {location} experiments found to compare.")
+            return
+
+        # Limit number of experiments if requested
+        if max_rows and len(experiments) > max_rows:
+            experiments = experiments[:max_rows]
+            click.echo(f"Limiting display to first {max_rows} experiments.")
+
+        # Extract experiment IDs from the experiment metadata dictionaries
+        experiment_ids = [exp["id"] for exp in experiments]
+
+        # Parse parameter and metric lists
+        param_list = None
+        if params:
+            param_list = [p.strip() for p in params.split(",") if p.strip()]
+
+        metric_list = None
+        if metrics:
+            metric_list = [m.strip() for m in metrics.split(",") if m.strip()]
+
+        # Get comparison data
+        comparison_data_extractor = ExperimentComparisonData()
+        comparison_data = comparison_data_extractor.get_comparison_data(
+            experiment_ids=experiment_ids,
+            params=param_list,
+            metrics=metric_list,
+            only_different=only_different,
+            include_archived=archived,
+        )
+
+        if not comparison_data.get("rows"):
+            click.echo("No comparison data available.")
+            return
+
+        # Handle export mode
+        if export_path:
+            _export_comparison_data(comparison_data, export_path)
+            click.echo(f"Comparison data exported to {export_path}")
+            return
+
+        # Handle static table mode
+        if no_interactive:
+            _print_static_table(comparison_data)
+            return
+
+        # Run interactive table
+        total_experiments = comparison_data.get("total_experiments", 0)
+        param_count = len(comparison_data.get("param_columns", []))
+        metric_count = len(comparison_data.get("metric_columns", []))
+
+        title = f"yanex compare - {total_experiments} experiments, {param_count} params, {metric_count} metrics"
+
+        # Set default export path
+        default_export = export_path or "yanex_comparison.csv"
+
+        run_comparison_table(comparison_data, title=title, export_path=default_export)
+
+    except click.ClickException:
+        raise  # Re-raise ClickException to show proper error message
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        ctx.exit(1)
+
+
+def _export_comparison_data(comparison_data: dict, file_path: str) -> None:
+    """Export comparison data to CSV file."""
+    import csv
+    from pathlib import Path
+
+    rows = comparison_data.get("rows", [])
+    if not rows:
+        raise ValueError("No data to export")
+
+    # Get column order - use same order as UI
+    first_row = rows[0]
+    column_keys = list(first_row.keys())
+
+    # Generate headers
+    column_headers = []
+    for key in column_keys:
+        if key.startswith("param:"):
+            column_headers.append(f"param_{key[6:]}")  # Remove emoji for CSV
+        elif key.startswith("metric:"):
+            column_headers.append(f"metric_{key[7:]}")  # Remove emoji for CSV
+        else:
+            column_headers.append(key)
+
+    # Write CSV
+    path = Path(file_path)
+    with path.open("w", newline="", encoding="utf-8") as csvfile:
+        writer = csv.writer(csvfile)
+
+        # Write header
+        writer.writerow(column_headers)
+
+        # Write data rows
+        for row_data in rows:
+            row_values = [row_data.get(key, "-") for key in column_keys]
+            writer.writerow(row_values)
+
+
+def _print_static_table(comparison_data: dict) -> None:
+    """Print comparison data as a static table."""
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    rows = comparison_data.get("rows", [])
+
+    if not rows:
+        console.print("No data to display")
+        return
+
+    # Create table
+    table = Table(show_header=True, header_style="bold magenta")
+
+    # Get column order
+    first_row = rows[0]
+    column_keys = list(first_row.keys())
+
+    # Add columns with formatted headers
+    for key in column_keys:
+        if key.startswith("param:"):
+            header = f"📊 {key[6:]}"
+        elif key.startswith("metric:"):
+            header = f"📈 {key[7:]}"
+        elif key == "duration":
+            header = "Duration"
+        elif key == "tags":
+            header = "Tags"
+        elif key == "id":
+            header = "ID"
+        elif key == "name":
+            header = "Name"
+        else:
+            header = key.title()
+        table.add_column(header)
+
+    # Add rows
+    for row_data in rows:
+        row_values = [str(row_data.get(key, "-")) for key in column_keys]
+        table.add_row(*row_values)
+
+    # Print table
+    console.print(table)
+
+    # Print summary
+    param_count = len(comparison_data.get("param_columns", []))
+    metric_count = len(comparison_data.get("metric_columns", []))
+
+    console.print(
+        f"\n[dim]Showing {len(rows)} experiments with {param_count} parameters and {metric_count} metrics[/dim]"
+    )

yanex/cli/commands/confirm.py

@@ -0,0 +1,198 @@
+"""
+Confirmation utilities for bulk operations on experiments.
+"""
+
+from typing import Any, Dict, List
+
+import click
+
+from ..filters import ExperimentFilter
+from ..formatters.console import ExperimentTableFormatter
+
+
+def confirm_experiment_operation(
+    experiments: List[Dict[str, Any]],
+    operation: str,
+    force: bool = False,
+    operation_verb: str = None,
+    default_yes: bool = False,
+) -> bool:
+    """
+    Show experiments and confirm operation.
+
+    Args:
+        experiments: List of experiment dictionaries to show
+        operation: Operation name (e.g., "archive", "delete")
+        force: Skip confirmation if True
+        operation_verb: Past tense verb for confirmation (e.g., "archived", "deleted")
+        default_yes: If True, default to Yes instead of No
+
+    Returns:
+        True if user confirms, False otherwise
+    """
+    if not experiments:
+        click.echo(f"No experiments found to {operation}.")
+        return False
+
+    if operation_verb is None:
+        operation_verb = f"{operation}d"  # Default: "archive" -> "archived"
+
+    # Display table of experiments
+    formatter = ExperimentTableFormatter()
+
+    click.echo(
+        f"The following {len(experiments)} experiment(s) will be {operation_verb}:"
+    )
+    click.echo()
+
+    formatter.print_experiments_table(experiments)
+    click.echo()
+
+    # Skip confirmation if force flag is set
+    if force:
+        return True
+
+    # Get confirmation from user
+    if len(experiments) == 1:
+        message = f"{operation.capitalize()} this experiment?"
+    else:
+        message = f"{operation.capitalize()} these {len(experiments)} experiments?"
+
+    return click.confirm(message, default=default_yes)
+
+
+def find_experiments_by_identifiers(
+    filter_obj: ExperimentFilter,
+    identifiers: List[str],
+    include_archived: bool = False,
+    archived_only: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Find experiments by list of identifiers (IDs or names).
+
+    Args:
+        filter_obj: ExperimentFilter instance
+        identifiers: List of experiment IDs or names
+        include_archived: Whether to search archived experiments
+        archived_only: If True, search ONLY archived experiments (for unarchive command)
+
+    Returns:
+        List of found experiments
+
+    Raises:
+        click.ClickException: If any identifier is not found or ambiguous
+    """
+    from .show import find_experiment  # Import here to avoid circular import
+
+    all_experiments = []
+
+    for identifier in identifiers:
+        if archived_only:
+            # For unarchive: search all experiments but only consider archived ones
+            result = find_experiment(filter_obj, identifier, include_archived=True)
+
+            if result is None:
+                raise click.ClickException(
+                    f"No archived experiment found with ID or name '{identifier}'"
+                )
+
+            if isinstance(result, list):
+                # Filter to only archived experiments
+                archived_results = [exp for exp in result if exp.get("archived", False)]
+
+                if not archived_results:
+                    raise click.ClickException(
+                        f"No archived experiment found with name '{identifier}'"
+                    )
+                elif len(archived_results) == 1:
+                    result = archived_results[0]
+                else:
+                    # Multiple archived experiments with same name
+                    click.echo(
+                        f"Multiple archived experiments found with name '{identifier}':"
+                    )
+                    click.echo()
+
+                    formatter = ExperimentTableFormatter()
+                    formatter.print_experiments_table(archived_results)
+                    click.echo()
+                    click.echo(
+                        "Please use specific experiment IDs instead of names for bulk operations."
+                    )
+                    raise click.ClickException(
+                        f"Ambiguous archived experiment name: '{identifier}'"
+                    )
+            else:
+                # Single result - check if it's archived
+                if not result.get("archived", False):
+                    raise click.ClickException(
+                        f"Experiment '{identifier}' is not archived"
+                    )
+        else:
+            # Normal mode: search as specified
+            result = find_experiment(filter_obj, identifier, include_archived)
+
+            if result is None:
+                location = "archived" if include_archived else "regular"
+                raise click.ClickException(
+                    f"No {location} experiment found with ID or name '{identifier}'"
+                )
+
+            if isinstance(result, list):
+                # Multiple experiments with same name
+                click.echo(f"Multiple experiments found with name '{identifier}':")
+                click.echo()
+
+                formatter = ExperimentTableFormatter()
+                formatter.print_experiments_table(result)
+                click.echo()
+                click.echo(
+                    "Please use specific experiment IDs instead of names for bulk operations."
+                )
+                raise click.ClickException(f"Ambiguous experiment name: '{identifier}'")
+
+        # Single experiment found
+        all_experiments.append(result)
+
+    return all_experiments
+
+
+def find_experiments_by_filters(
+    filter_obj: ExperimentFilter,
+    status: str = None,
+    name_pattern: str = None,
+    tags: List[str] = None,
+    started_after=None,
+    started_before=None,
+    ended_after=None,
+    ended_before=None,
+    include_archived: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Find experiments using filter criteria.
+
+    Args:
+        filter_obj: ExperimentFilter instance
+        status: Filter by status
+        name_pattern: Filter by name pattern
+        tags: Filter by tags
+        started_after: Filter by start time
+        started_before: Filter by start time
+        ended_after: Filter by end time
+        ended_before: Filter by end time
+        include_archived: Whether to search archived experiments
+
+    Returns:
+        List of found experiments
+    """
+    return filter_obj.filter_experiments(
+        status=status,
+        name_pattern=name_pattern,
+        tags=tags,
+        started_after=started_after,
+        started_before=started_before,
+        ended_after=ended_after,
+        ended_before=ended_before,
+        include_all=True,  # Get all matching experiments for bulk operations
+        include_archived=include_archived,
+    )