ml-dash 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

ml_dash/cli.py

@@ -25,7 +25,7 @@ def create_parser() -> argparse.ArgumentParser:
     )
 
     # Import and add command parsers
-    from .cli_commands import upload, download, list as list_cmd, login, logout, profile, api
+    from .cli_commands import upload, download, list as list_cmd, login, logout, profile, api, create
 
     # Authentication commands
     login.add_parser(subparsers)
@@ -35,6 +35,9 @@ def create_parser() -> argparse.ArgumentParser:
     # API commands
     api.add_parser(subparsers)
 
+    # Project commands
+    create.add_parser(subparsers)
+
     # Data commands
     upload.add_parser(subparsers)
     download.add_parser(subparsers)
@@ -71,6 +74,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     elif args.command == "profile":
         from .cli_commands import profile
         return profile.cmd_profile(args)
+    elif args.command == "create":
+        from .cli_commands import create
+        return create.cmd_create(args)
     elif args.command == "upload":
         from .cli_commands import upload
         return upload.cmd_upload(args)

ml_dash/cli_commands/create.py

@@ -0,0 +1,145 @@
+"""Create command for ml-dash CLI - create projects."""
+
+import argparse
+from typing import Optional
+
+from rich.console import Console
+
+from ml_dash.client import RemoteClient
+from ml_dash.config import config
+
+
+def add_parser(subparsers):
+    """Add create command parser."""
+    parser = subparsers.add_parser(
+        "create",
+        help="Create a new project",
+        description="""Create a new project in ml-dash.
+
+Examples:
+  # Create a project in current user's namespace
+  ml-dash create -p new-project
+
+  # Create a project in a specific namespace
+  ml-dash create -p geyang/new-project
+
+  # Create with description
+  ml-dash create -p geyang/tutorials -d "ML tutorials and examples"
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "-p", "--prefix",
+        type=str,
+        required=True,
+        help="Project name or namespace/project",
+    )
+    parser.add_argument(
+        "-d", "--description",
+        type=str,
+        help="Project description (optional)",
+    )
+    parser.add_argument(
+        "--dash-url",
+        type=str,
+        help="ML-Dash server URL (default: https://api.dash.ml)",
+    )
+
+
+def cmd_create(args) -> int:
+    """Execute create command."""
+    console = Console()
+
+    # Get remote URL
+    remote_url = args.dash_url or config.remote_url or "https://api.dash.ml"
+
+    # Parse the prefix
+    prefix = args.prefix.strip("/")
+    parts = prefix.split("/")
+
+    if len(parts) > 2:
+        console.print(
+            f"[red]Error:[/red] Prefix can have at most 2 parts (namespace/project).\n"
+            f"Got: {args.prefix}\n\n"
+            f"Examples:\n"
+            f"  ml-dash create -p new-project\n"
+            f"  ml-dash create -p geyang/new-project"
+        )
+        return 1
+
+    if len(parts) == 1:
+        # Format: project (use current user's namespace)
+        namespace = None
+        project_name = parts[0]
+    else:
+        # Format: namespace/project
+        namespace = parts[0]
+        project_name = parts[1]
+
+    return _create_project(
+        namespace=namespace,
+        project_name=project_name,
+        description=args.description,
+        dash_url=remote_url,
+        console=console,
+    )
+
+
+def _create_project(
+    namespace: Optional[str],
+    project_name: str,
+    description: Optional[str],
+    dash_url: str,
+    console: Console,
+) -> int:
+    """Create a new project."""
+    try:
+        # Initialize client (namespace will be auto-fetched from server if not provided)
+        client = RemoteClient(base_url=dash_url, namespace=namespace)
+
+        # Get namespace (triggers server query if not set)
+        namespace = client.namespace
+
+        if not namespace:
+            console.print("[red]Error:[/red] Could not determine namespace. Please login first.")
+            return 1
+
+        console.print(f"[dim]Creating project '{project_name}' in namespace '{namespace}'[/dim]")
+
+        # Create project using unified node API
+        response = client._client.post(
+            f"/namespaces/{namespace}/nodes",
+            json={
+                "type": "PROJECT",
+                "name": project_name,
+                "slug": project_name,
+                "description": description or "",
+            }
+        )
+        response.raise_for_status()
+        result = response.json()
+
+        # Extract project info
+        project = result.get("project", {})
+        project_id = project.get("id")
+        project_slug = project.get("slug")
+
+        # Success message
+        console.print(f"[green]✓[/green] Project created successfully!")
+        console.print(f"  Name: [bold]{project_slug}[/bold]")
+        console.print(f"  Namespace: [bold]{namespace}[/bold]")
+        console.print(f"  ID: {project_id}")
+        if description:
+            console.print(f"  Description: {description}")
+        console.print(f"\n  View at: https://dash.ml/@{namespace}/{project_slug}")
+
+        return 0
+
+    except Exception as e:
+        # Check if it's a 409 conflict (project already exists)
+        if hasattr(e, 'response') and hasattr(e.response, 'status_code') and e.response.status_code == 409:
+            console.print(f"[yellow]⚠[/yellow] Project '[bold]{project_name}[/bold]' already exists in namespace '[bold]{namespace}[/bold]'")
+            return 0
+
+        console.print(f"[red]Error creating project:[/red] {e}")
+        return 1

ml_dash/cli_commands/download.py

@@ -615,6 +615,158 @@ class ExperimentDownloader:
       return {"success": False, "error": str(e), "bytes": 0}
 
 
+# ============================================================================
+# Track Download Command
+# ============================================================================
+
+
+def cmd_download_track(args: argparse.Namespace) -> int:
+  """Download track data from remote server."""
+  # Load configuration
+  config = Config()
+  remote_url = args.dash_url or config.remote_url
+  api_key = args.api_key or config.api_key
+
+  # Validate inputs
+  if not remote_url:
+    console.print("[red]Error:[/red] --dash-url is required (or set in config)")
+    return 1
+
+  if not args.tracks:
+    console.print("[red]Error:[/red] Track path is required")
+    return 1
+
+  # Parse track path: namespace/project/experiment/topic...
+  # The challenge is determining where experiment ends and topic begins
+  # Strategy: Try to find the experiment by checking server, working backwards from the end
+  track_path = args.tracks.strip("/")
+  parts = track_path.split("/")
+
+  if len(parts) < 4:
+    console.print(
+      "[red]Error:[/red] Track path must be in format: "
+      "'namespace/project/experiment/topic'"
+    )
+    console.print("Examples:")
+    console.print("  geyang/project/experiment/position")
+    console.print("  geyang/project/experiment/robot/position")
+    console.print("  geyang/project/folder/experiment/robot/camera/position")
+    return 1
+
+  # Extract namespace and project (always first 2 parts)
+  namespace = parts[0]
+  project = parts[1]
+
+  # Try to find the experiment by iterating backwards
+  # We assume experiment is a single name (not a path), and topic comes after it
+  experiment_name = None
+  topic = None
+
+  # Initialize client early to test experiment existence
+  try:
+    remote_client = RemoteClient(base_url=remote_url, namespace=namespace, api_key=api_key)
+  except Exception as e:
+    console.print(f"[red]Error:[/red] Failed to connect to server: {e}")
+    return 1
+
+  # Try different split points: experiment could be at index 2, 3, 4, etc.
+  # Topic is everything after the experiment
+  for exp_idx in range(2, len(parts) - 1):  # Experiment must leave at least 1 part for topic
+    potential_exp_name = parts[exp_idx]
+    potential_topic = "/".join(parts[exp_idx + 1:])
+
+    # Try to fetch this experiment from server
+    try:
+      exp_data = remote_client.get_experiment_graphql(project, potential_exp_name, namespace)
+      if exp_data:
+        # Found the experiment!
+        experiment_name = potential_exp_name
+        topic = potential_topic
+        break
+    except Exception:
+      # This experiment doesn't exist, try next index
+      continue
+
+  if not experiment_name or not topic:
+    console.print(
+      f"[red]Error:[/red] Could not find valid experiment in path: {track_path}"
+    )
+    console.print("\nTried the following experiment names:")
+    for exp_idx in range(2, len(parts) - 1):
+      console.print(f"  - {parts[exp_idx]}")
+    console.print(f"\nMake sure the experiment exists in project '{project}'")
+    return 1
+
+  console.print(f"[bold]Downloading track data...[/bold]")
+  console.print(f"  Namespace: {namespace}")
+  console.print(f"  Project: {project}")
+  console.print(f"  Experiment: {experiment_name}")
+  console.print(f"  Topic: {topic}")
+  console.print(f"  Format: {args.format}")
+
+  try:
+    # Get experiment ID (we already validated it exists during path parsing)
+    exp_data = remote_client.get_experiment_graphql(project, experiment_name, namespace)
+    experiment_id = exp_data["id"]
+
+    # Download track data
+    console.print(f"\n[cyan]Fetching track data from server...[/cyan]")
+    track_data = remote_client.get_track_data(
+      experiment_id=experiment_id,
+      topic=topic,
+      format=args.format,
+    )
+
+    # Determine output filename
+    if args.output:
+      output_path = Path(args.output)
+    else:
+      # Generate filename from topic and format
+      safe_topic = topic.replace("/", "_")
+      extension = {
+        "json": "json",
+        "jsonl": "jsonl",
+        "parquet": "parquet",
+        "mcap": "mcap",
+      }.get(args.format, args.format)
+      output_path = Path(f"{safe_topic}.{extension}")
+
+    # Write to file
+    if args.format in ("jsonl", "parquet", "mcap"):
+      # Binary data
+      output_path.write_bytes(track_data)
+    else:
+      # JSON data
+      if isinstance(track_data, dict):
+        output_path.write_text(json.dumps(track_data, indent=2))
+      else:
+        output_path.write_text(str(track_data))
+
+    # Show success message
+    file_size = output_path.stat().st_size
+    console.print(
+      f"\n[green]✓ Track data downloaded successfully[/green]"
+    )
+    console.print(f"  Output: {output_path}")
+    console.print(f"  Size: {_format_bytes(file_size)}")
+    console.print(f"  Format: {args.format}")
+
+    # Show entry count if available
+    if args.format == "json" and isinstance(track_data, dict):
+      entry_count = track_data.get("count", len(track_data.get("entries", [])))
+      if entry_count:
+        console.print(f"  Entries: {entry_count}")
+
+    return 0
+
+  except Exception as e:
+    console.print(f"[red]Error downloading track data:[/red] {e}")
+    if args.verbose:
+      import traceback
+      console.print(traceback.format_exc())
+    return 1
+
+
 # ============================================================================
 # Main Command
 # ============================================================================
@@ -622,6 +774,10 @@ class ExperimentDownloader:
 
 def cmd_download(args: argparse.Namespace) -> int:
   """Execute download command."""
+  # Handle track download if --tracks is specified
+  if args.tracks:
+    return cmd_download_track(args)
+
   # Load configuration
   config = Config()
   remote_url = args.dash_url or config.remote_url
@@ -800,6 +956,27 @@ def add_parser(subparsers):
     help="Local storage directory (default: ./.dash)",
   )
 
+  # Track download mode
+  parser.add_argument(
+    "--tracks",
+    type=str,
+    help="Download track data from path (e.g., 'namespace/project/exp/robot/position')",
+  )
+  parser.add_argument(
+    "-f",
+    "--format",
+    type=str,
+    choices=["json", "jsonl", "parquet", "mcap"],
+    default="jsonl",
+    help="Track export format (default: jsonl)",
+  )
+  parser.add_argument(
+    "-o",
+    "--output",
+    type=str,
+    help="Output file path (default: auto-generated from topic)",
+  )
+
   # Remote configuration
   parser.add_argument(
     "--dash-url",

ml_dash/cli_commands/list.py

@@ -18,6 +18,101 @@ from ..config import Config
 console = Console()
 
 
+def list_tracks(
+    remote_client: RemoteClient,
+    experiment_path: str,
+    topic_filter: Optional[str] = None,
+    output_json: bool = False,
+    verbose: bool = False
+) -> int:
+    """
+    List tracks in an experiment.
+
+    Args:
+        remote_client: Remote API client
+        experiment_path: Experiment path (namespace/project/experiment)
+        topic_filter: Optional topic filter (e.g., "robot/*")
+        output_json: Output as JSON
+        verbose: Show verbose output
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    # Parse experiment path
+    parts = experiment_path.strip("/").split("/")
+    if len(parts) < 3:
+        console.print("[red]Error:[/red] Experiment path must be 'namespace/project/experiment'")
+        return 1
+
+    namespace = parts[0]
+    project = parts[1]
+    experiment = parts[2]
+
+    try:
+        # Get experiment ID
+        exp_data = remote_client.get_experiment_graphql(project, experiment)
+        if not exp_data:
+            console.print(f"[red]Error:[/red] Experiment '{experiment}' not found in project '{project}'")
+            return 1
+
+        experiment_id = exp_data["id"]
+
+        # List tracks
+        tracks = remote_client.list_tracks(experiment_id, topic_filter)
+
+        if output_json:
+            # JSON output
+            output = {
+                "tracks": tracks,
+                "count": len(tracks),
+                "experiment": experiment_path
+            }
+            console.print(json.dumps(output, indent=2))
+            return 0
+
+        # Human-readable output
+        if not tracks:
+            console.print(f"[yellow]No tracks found[/yellow]")
+            return 0
+
+        console.print(f"\n[bold]Tracks in {experiment_path}[/bold]\n")
+
+        # Create table
+        table = Table(box=box.ROUNDED)
+        table.add_column("Topic", style="cyan", no_wrap=True)
+        table.add_column("Entries", justify="right")
+        table.add_column("Columns", style="dim")
+        table.add_column("Time Range", style="dim")
+
+        for track in tracks:
+            topic = track["topic"]
+            entries = str(track.get("totalEntries", 0))
+            columns = ", ".join(track.get("columns", [])[:5])
+            if len(track.get("columns", [])) > 5:
+                columns += f", ... (+{len(track['columns']) - 5})"
+
+            first_ts = track.get("firstTimestamp")
+            last_ts = track.get("lastTimestamp")
+            if first_ts is not None and last_ts is not None:
+                time_range = f"{first_ts:.3f} - {last_ts:.3f}"
+            else:
+                time_range = "N/A"
+
+            table.add_row(topic, entries, columns, time_range)
+
+        console.print(table)
+        console.print(f"\n[dim]Total tracks: {len(tracks)}[/dim]\n")
+
+        return 0
+
+    except Exception as e:
+        console.print(f"[red]Error listing tracks:[/red] {e}")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())
+        return 1
+
+
 def _format_timestamp(iso_timestamp: str) -> str:
     """Format ISO timestamp as human-readable relative time."""
     try:
@@ -248,6 +343,45 @@ def cmd_list(args: argparse.Namespace) -> int:
     Returns:
         Exit code (0 for success, 1 for error)
     """
+    # Handle track listing if --tracks is specified
+    if args.tracks:
+        # Load config
+        config = Config()
+        remote_url = args.dash_url or config.remote_url
+        api_key = args.api_key or config.api_key
+
+        if not remote_url:
+            console.print("[red]Error:[/red] --dash-url is required (or set in config)")
+            return 1
+
+        if not args.project:
+            console.print("[red]Error:[/red] --project is required for listing tracks")
+            console.print("Example: ml-dash list --tracks --project namespace/project/experiment")
+            return 1
+
+        # Extract namespace from project path
+        parts = args.project.strip("/").split("/")
+        if len(parts) < 3:
+            console.print("[red]Error:[/red] For tracks, --project must be 'namespace/project/experiment'")
+            return 1
+
+        namespace = parts[0]
+
+        # Create remote client
+        try:
+            remote_client = RemoteClient(base_url=remote_url, namespace=namespace, api_key=api_key)
+        except Exception as e:
+            console.print(f"[red]Error connecting to remote:[/red] {e}")
+            return 1
+
+        return list_tracks(
+            remote_client=remote_client,
+            experiment_path=args.project,
+            topic_filter=args.topic_filter,
+            output_json=args.json,
+            verbose=args.verbose
+        )
+
     # Load config
     config = Config()
 
@@ -463,6 +597,18 @@ def add_parser(subparsers) -> None:
                        help="Filter experiments by status")
     parser.add_argument("--tags", type=str, help="Filter experiments by tags (comma-separated)")
 
+    # Track listing mode
+    parser.add_argument(
+        "--tracks",
+        action="store_true",
+        help="List tracks in experiment (requires --project as 'namespace/project/experiment')"
+    )
+    parser.add_argument(
+        "--topic-filter",
+        type=str,
+        help="Filter tracks by topic (e.g., 'robot/*')"
+    )
+
     # Output options
     parser.add_argument("--json", action="store_true", help="Output as JSON")
     parser.add_argument("--detailed", action="store_true", help="Show detailed information")