ml-dash 0.6.1__py3-none-any.whl

ml_dash/cli_commands/list.py

@@ -0,0 +1,319 @@
+"""
+List command for ML-Dash CLI.
+
+Allows users to discover projects and experiments on the remote server.
+"""
+
+import argparse
+import json
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from ..client import RemoteClient
+from ..config import Config
+
+console = Console()
+
+
+def _format_timestamp(iso_timestamp: str) -> str:
+    """Format ISO timestamp as human-readable relative time."""
+    try:
+        dt = datetime.fromisoformat(iso_timestamp.replace('Z', '+00:00'))
+        now = datetime.now(dt.tzinfo)
+        diff = now - dt
+
+        if diff.days > 365:
+            years = diff.days // 365
+            return f"{years} year{'s' if years > 1 else ''} ago"
+        elif diff.days > 30:
+            months = diff.days // 30
+            return f"{months} month{'s' if months > 1 else ''} ago"
+        elif diff.days > 0:
+            return f"{diff.days} day{'s' if diff.days > 1 else ''} ago"
+        elif diff.seconds > 3600:
+            hours = diff.seconds // 3600
+            return f"{hours} hour{'s' if hours > 1 else ''} ago"
+        elif diff.seconds > 60:
+            minutes = diff.seconds // 60
+            return f"{minutes} minute{'s' if minutes > 1 else ''} ago"
+        else:
+            return "just now"
+    except:
+        return iso_timestamp
+
+
+def _get_status_style(status: str) -> str:
+    """Get rich style for status."""
+    status_styles = {
+        "COMPLETED": "green",
+        "RUNNING": "yellow",
+        "FAILED": "red",
+        "ARCHIVED": "dim",
+    }
+    return status_styles.get(status, "white")
+
+
+def list_projects(
+    remote_client: RemoteClient,
+    output_json: bool = False,
+    verbose: bool = False
+) -> int:
+    """
+    List all projects for the user.
+
+    Args:
+        remote_client: Remote API client
+        output_json: Output as JSON
+        verbose: Show verbose output
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        # Get projects via GraphQL
+        projects = remote_client.list_projects_graphql()
+
+        if output_json:
+            # JSON output
+            output = {
+                "projects": projects,
+                "count": len(projects)
+            }
+            console.print(json.dumps(output, indent=2))
+            return 0
+
+        # Human-readable output
+        if not projects:
+            console.print(f"[yellow]No projects found[/yellow]")
+            return 0
+
+        console.print(f"\n[bold]Projects[/bold]\n")
+
+        # Create table
+        table = Table(box=box.ROUNDED)
+        table.add_column("Project", style="cyan", no_wrap=True)
+        table.add_column("Experiments", justify="right")
+        table.add_column("Description", style="dim")
+
+        for project in projects:
+            exp_count = project.get('experimentCount', 0)
+            description = project.get('description', '') or ''
+            if len(description) > 50:
+                description = description[:47] + "..."
+
+            table.add_row(
+                project['slug'],
+                str(exp_count),
+                description
+            )
+
+        console.print(table)
+        console.print(f"\n[dim]Total: {len(projects)} project(s)[/dim]\n")
+
+        return 0
+
+    except Exception as e:
+        console.print(f"[red]Error listing projects:[/red] {e}")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())
+        return 1
+
+
+def list_experiments(
+    remote_client: RemoteClient,
+    project: str,
+    status_filter: Optional[str] = None,
+    tags_filter: Optional[List[str]] = None,
+    output_json: bool = False,
+    detailed: bool = False,
+    verbose: bool = False
+) -> int:
+    """
+    List experiments in a project.
+
+    Args:
+        remote_client: Remote API client
+        project: Project slug
+        status_filter: Filter by status (COMPLETED, RUNNING, FAILED, ARCHIVED)
+        tags_filter: Filter by tags
+        output_json: Output as JSON
+        detailed: Show detailed information
+        verbose: Show verbose output
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        # Get experiments via GraphQL
+        experiments = remote_client.list_experiments_graphql(
+            project, status=status_filter
+        )
+
+        # Filter by tags if specified
+        if tags_filter:
+            experiments = [
+                exp for exp in experiments
+                if any(tag in exp.get('tags', []) for tag in tags_filter)
+            ]
+
+        if output_json:
+            # JSON output
+            output = {
+                "project": project,
+                "experiments": experiments,
+                "count": len(experiments)
+            }
+            console.print(json.dumps(output, indent=2))
+            return 0
+
+        # Human-readable output
+        if not experiments:
+            console.print(f"[yellow]No experiments found in project: {project}[/yellow]")
+            return 0
+
+        console.print(f"\n[bold]Experiments in project: {project}[/bold]\n")
+
+        # Create table
+        table = Table(box=box.ROUNDED)
+        table.add_column("Experiment", style="cyan", no_wrap=True)
+        table.add_column("Status", justify="center")
+        table.add_column("Metrics", justify="right")
+        table.add_column("Logs", justify="right")
+        table.add_column("Files", justify="right")
+
+        if detailed:
+            table.add_column("Tags", style="dim")
+            table.add_column("Created", style="dim")
+
+        for exp in experiments:
+            status = exp.get('status', 'UNKNOWN')
+            status_style = _get_status_style(status)
+
+            # Count metrics
+            metrics_count = len(exp.get('metrics', []))
+
+            # Count logs
+            log_metadata = exp.get('logMetadata') or {}
+            logs_count = log_metadata.get('totalLogs', 0)
+
+            # Count files
+            files_count = len(exp.get('files', []))
+
+            row = [
+                exp['name'],
+                f"[{status_style}]{status}[/{status_style}]",
+                str(metrics_count),
+                str(logs_count),
+                str(files_count),
+            ]
+
+            if detailed:
+                # Add tags
+                tags = exp.get('tags', [])
+                tags_str = ', '.join(tags[:3])
+                if len(tags) > 3:
+                    tags_str += f" +{len(tags) - 3}"
+                row.append(tags_str or '-')
+
+                # Add created time
+                created_at = exp.get('createdAt', '')
+                row.append(_format_timestamp(created_at) if created_at else '-')
+
+            table.add_row(*row)
+
+        console.print(table)
+        console.print(f"\n[dim]Total: {len(experiments)} experiment(s)[/dim]\n")
+
+        return 0
+
+    except Exception as e:
+        console.print(f"[red]Error listing experiments:[/red] {e}")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())
+        return 1
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    """
+    Execute list command.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    # Load config
+    config = Config()
+
+    # Get remote URL (command line > config)
+    remote_url = args.remote or config.remote_url
+    if not remote_url:
+        console.print("[red]Error:[/red] --remote URL is required (or set in config)")
+        return 1
+
+    # Get API key (command line > config > auto-loaded from storage)
+    api_key = args.api_key or config.api_key
+
+    # Create remote client
+    try:
+        remote_client = RemoteClient(base_url=remote_url, api_key=api_key)
+    except Exception as e:
+        console.print(f"[red]Error connecting to remote:[/red] {e}")
+        return 1
+
+    # List projects or experiments
+    if args.project:
+        # Parse tags if provided
+        tags_filter = None
+        if args.tags:
+            tags_filter = [tag.strip() for tag in args.tags.split(',')]
+
+        return list_experiments(
+            remote_client=remote_client,
+            project=args.project,
+            status_filter=args.status,
+            tags_filter=tags_filter,
+            output_json=args.json,
+            detailed=args.detailed,
+            verbose=args.verbose
+        )
+    else:
+        return list_projects(
+            remote_client=remote_client,
+            output_json=args.json,
+            verbose=args.verbose
+        )
+
+
+def add_parser(subparsers) -> None:
+    """Add list command parser to subparsers."""
+    parser = subparsers.add_parser(
+        "list",
+        help="List projects and experiments on remote server",
+        description="Discover projects and experiments available on the remote ML-Dash server."
+    )
+
+    # Remote configuration
+    parser.add_argument("--remote", type=str, help="Remote server URL")
+    parser.add_argument(
+        "--api-key",
+        type=str,
+        help="JWT authentication token (auto-loaded from storage if not provided)"
+    )
+    # Filtering options
+    parser.add_argument("--project", type=str, help="List experiments in this project")
+    parser.add_argument("--status", type=str,
+                       choices=["COMPLETED", "RUNNING", "FAILED", "ARCHIVED"],
+                       help="Filter experiments by status")
+    parser.add_argument("--tags", type=str, help="Filter experiments by tags (comma-separated)")
+
+    # Output options
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    parser.add_argument("--detailed", action="store_true", help="Show detailed information")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")

ml_dash/cli_commands/login.py

@@ -0,0 +1,225 @@
+"""Login command for ml-dash CLI."""
+
+import sys
+import webbrowser
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ml_dash.auth.device_flow import DeviceFlowClient
+from ml_dash.auth.device_secret import get_or_create_device_secret
+from ml_dash.auth.token_storage import get_token_storage
+from ml_dash.auth.exceptions import (
+    DeviceCodeExpiredError,
+    AuthorizationDeniedError,
+    TokenExchangeError,
+)
+from ml_dash.config import config
+
+
+def add_parser(subparsers):
+    """Add login command parser.
+
+    Args:
+        subparsers: Subparsers object from argparse
+    """
+    parser = subparsers.add_parser(
+        "login",
+        help="Authenticate with ml-dash using device authorization flow",
+        description="Login to ml-dash server using OAuth2 device authorization flow",
+    )
+
+    parser.add_argument(
+        "--remote",
+        type=str,
+        help="ML-Dash server URL (e.g., https://api.ml-dash.com)",
+    )
+
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't automatically open browser for authorization",
+    )
+
+
+def generate_qr_code_ascii(url: str) -> str:
+    """Generate ASCII QR code for the given URL.
+
+    Args:
+        url: URL to encode in QR code
+
+    Returns:
+        ASCII art QR code string
+    """
+    try:
+        import qrcode
+
+        qr = qrcode.QRCode(border=1)
+        qr.add_data(url)
+        qr.make(fit=True)
+
+        # Generate ASCII art
+        output = []
+        for row in qr.get_matrix():
+            line = ""
+            for cell in row:
+                line += "██" if cell else "  "
+            output.append(line)
+
+        return "\n".join(output)
+    except ImportError:
+        return "[QR code unavailable - install qrcode: pip install qrcode]"
+    except Exception:
+        return "[QR code generation failed]"
+
+
+def cmd_login(args) -> int:
+    """Execute login command.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    console = Console()
+
+    # Get remote URL
+    remote_url = args.remote or config.remote_url
+    if not remote_url:
+        console.print(
+            "[red]Error: No remote URL configured.[/red]\n\n"
+            "Please specify with --remote or set default:\n"
+            "  ml-dash login --remote https://api.ml-dash.com"
+        )
+        return 1
+
+    try:
+        # Initialize device flow
+        console.print("[bold]Initializing device authorization...[/bold]\n")
+
+        device_secret = get_or_create_device_secret(config)
+        device_client = DeviceFlowClient(
+            device_secret=device_secret, ml_dash_server_url=remote_url
+        )
+
+        # Start device flow with vuer-auth
+        flow = device_client.start_device_flow()
+
+        # Generate QR code
+        qr_code = generate_qr_code_ascii(flow.verification_uri_complete)
+
+        # Display rich UI with QR code
+        panel_content = (
+            f"[bold cyan]1. Visit this URL:[/bold cyan]\n\n"
+            f"   {flow.verification_uri}\n\n"
+            f"[bold cyan]2. Enter this code:[/bold cyan]\n\n"
+            f"   [bold green]{flow.user_code}[/bold green]\n\n"
+        )
+
+        # Add QR code if available
+        if "unavailable" not in qr_code and "failed" not in qr_code:
+            panel_content += f"[bold cyan]Or scan QR code:[/bold cyan]\n\n{qr_code}\n\n"
+
+        panel_content += f"[dim]Code expires in {flow.expires_in // 60} minutes[/dim]"
+
+        panel = Panel(
+            panel_content,
+            title="[bold blue]DEVICE AUTHORIZATION REQUIRED[/bold blue]",
+            border_style="blue",
+            expand=False,
+        )
+        console.print(panel)
+        console.print()
+
+        # Auto-open browser unless disabled
+        if not args.no_browser:
+            try:
+                webbrowser.open(flow.verification_uri_complete)
+                console.print("[dim]✓ Opened browser automatically[/dim]\n")
+            except Exception:
+                # Silent failure - user can manually open URL
+                pass
+
+        # Poll for authorization with progress indicator
+        console.print("[bold]Waiting for authorization...[/bold]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task("Polling", total=None)
+
+            def update_progress(elapsed: int):
+                progress.update(task, description=f"Waiting ({elapsed}s)")
+
+            try:
+                vuer_auth_token = device_client.poll_for_token(
+                    max_attempts=120, progress_callback=update_progress
+                )
+            except DeviceCodeExpiredError:
+                console.print(
+                    "\n[red]✗ Device code expired[/red]\n\n"
+                    "The authorization code expired after 10 minutes.\n"
+                    "Please run 'ml-dash login' again."
+                )
+                return 1
+            except AuthorizationDeniedError:
+                console.print(
+                    "\n[red]✗ Authorization denied[/red]\n\n"
+                    "You declined the authorization request in your browser.\n\n"
+                    "To try again:\n"
+                    "  ml-dash login"
+                )
+                return 1
+            except TimeoutError:
+                console.print(
+                    "\n[red]✗ Authorization timed out[/red]\n\n"
+                    "No response after 10 minutes.\n\n"
+                    "Please run 'ml-dash login' again."
+                )
+                return 1
+
+        console.print("[green]✓ Authorization successful![/green]\n")
+
+        # Exchange vuer-auth token for ml-dash token
+        console.print("[bold]Exchanging token with ml-dash server...[/bold]")
+
+        try:
+            ml_dash_token = device_client.exchange_token(vuer_auth_token)
+        except TokenExchangeError as e:
+            console.print(f"\n[red]✗ Token exchange failed:[/red] {e}\n")
+            return 1
+
+        # Store ml-dash permanent token
+        storage = get_token_storage()
+        storage.store("ml-dash-token", ml_dash_token)
+
+        console.print("[green]✓ Token exchanged successfully![/green]\n")
+
+        # Success message
+        console.print(
+            "[bold green]✓ Logged in successfully![/bold green]\n\n"
+            "Your authentication token has been securely stored.\n"
+            "You can now use ml-dash commands without --api-key.\n\n"
+            "Examples:\n"
+            "  ml-dash upload ./experiments\n"
+            "  ml-dash download ./output\n"
+            "  ml-dash list"
+        )
+
+        return 0
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]Login cancelled by user.[/yellow]")
+        return 1
+    except Exception as e:
+        console.print(f"\n[red]✗ Unexpected error:[/red] {e}")
+        import traceback
+
+        console.print(f"\n[dim]{traceback.format_exc()}[/dim]")
+        return 1

ml_dash/cli_commands/logout.py

@@ -0,0 +1,54 @@
+"""Logout command for ml-dash CLI."""
+
+from rich.console import Console
+
+from ml_dash.auth.token_storage import get_token_storage
+from ml_dash.auth.exceptions import StorageError
+
+
+def add_parser(subparsers):
+    """Add logout command parser.
+
+    Args:
+        subparsers: Subparsers object from argparse
+    """
+    parser = subparsers.add_parser(
+        "logout",
+        help="Clear stored authentication token",
+        description="Logout from ml-dash by clearing stored authentication token",
+    )
+
+
+def cmd_logout(args) -> int:
+    """Execute logout command.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    console = Console()
+
+    try:
+        # Get storage backend
+        storage = get_token_storage()
+
+        # Delete stored token
+        storage.delete("ml-dash-token")
+
+        console.print(
+            "[bold green]✓ Logged out successfully![/bold green]\n\n"
+            "Your authentication token has been cleared.\n\n"
+            "To log in again:\n"
+            "  ml-dash login"
+        )
+
+        return 0
+
+    except StorageError as e:
+        console.print(f"[red]✗ Storage error:[/red] {e}")
+        return 1
+    except Exception as e:
+        console.print(f"[red]✗ Unexpected error:[/red] {e}")
+        return 1