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

ml_dash/__init__.py

@@ -37,7 +37,7 @@ Usage:
 """
 
 from .client import RemoteClient
-from .experiment import Experiment, OperationMode, RunManager, ml_dash_experiment
+from .experiment import Experiment, OperationMode, ml_dash_experiment
 from .log import LogBuilder, LogLevel
 from .params import ParametersBuilder
 from .run import RUN
@@ -49,7 +49,6 @@ __all__ = [
   "Experiment",
   "ml_dash_experiment",
   "OperationMode",
-  "RunManager",
   "RemoteClient",
   "LocalStorage",
   "LogLevel",

ml_dash/auto_start.py

@@ -43,10 +43,7 @@ _user = get_jwt_user()
 _username = _user["username"] if _user else getpass.getuser()
 _now = datetime.now()
 
-dxp = Experiment(
-  prefix=f"{_username}/scratch/{_now:%Y-%m-%d/%H%M%S}",
-  dash_url="https://api.dash.ml",
-)
+dxp = Experiment()
 
 
 # Register cleanup handler to complete experiment on Python exit (if still open)

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/upload.py

@@ -265,7 +265,11 @@ def discover_experiments(
 
   Args:
       local_path: Root path of local storage
-      project_filter: Glob pattern to filter experiments by prefix (e.g., "tom/*/exp*")
+      project_filter: Either a simple project name (e.g., "proj1") or a glob
+                     pattern for the full path (e.g., "tom/*/exp*"). If the
+                     filter contains '/', '*', or '?', it's treated as a glob
+                     pattern matched against the full relative path. Otherwise,
+                     it's matched exactly against the project name.
       experiment_filter: Only discover this experiment (requires project_filter)
 
   Returns:
@@ -319,9 +323,18 @@ def discover_experiments(
 
       # Apply filters with glob pattern support
       if project_filter:
-        # Support glob pattern matching on the full relative path
-        if not fnmatch.fnmatch(full_relative_path, project_filter):
-          continue
+        # Check if project_filter is a glob pattern or simple project name
+        is_glob_pattern = any(c in project_filter for c in ['*', '?', '/'])
+
+        if is_glob_pattern:
+          # Treat as glob pattern - match against full relative path
+          if not fnmatch.fnmatch(full_relative_path, project_filter):
+            continue
+        else:
+          # Treat as simple project name - match against parsed project
+          if project_name != project_filter:
+            continue
+
       if experiment_filter and exp_name != experiment_filter:
         continue
 

ml_dash/client.py

@@ -9,18 +9,19 @@ import httpx
 class RemoteClient:
     """Client for communicating with ML-Dash server."""
 
-    def __init__(self, base_url: str, namespace: str, api_key: Optional[str] = None):
+    def __init__(self, base_url: str, namespace: Optional[str] = None, api_key: Optional[str] = None):
         """
         Initialize remote client.
 
         Args:
             base_url: Base URL of ML-Dash server (e.g., "http://localhost:3000")
-            namespace: Namespace slug (e.g., "my-namespace")
+            namespace: Namespace slug (e.g., "my-namespace"). If not provided, will be queried from server.
             api_key: JWT token for authentication (optional - auto-loads from storage if not provided)
 
         Note:
             If no api_key is provided, token will be loaded from storage on first API call.
             If still not found, AuthenticationError will be raised at that time.
+            If no namespace is provided, it will be fetched from the server on first API call.
         """
         # Store original base URL for GraphQL (no /api prefix)
         self.graphql_base_url = base_url.rstrip("/")
@@ -28,9 +29,6 @@ class RemoteClient:
         # Add /api prefix to base URL for REST API calls
         self.base_url = base_url.rstrip("/") + "/api"
 
-        # Store namespace
-        self.namespace = namespace
-
         # If no api_key provided, try to load from storage
         if not api_key:
             from .auth.token_storage import get_token_storage
@@ -39,10 +37,70 @@ class RemoteClient:
             api_key = storage.load("ml-dash-token")
 
         self.api_key = api_key
+
+        # Store namespace (can be None, will be fetched on first API call if needed)
+        self._namespace = namespace
+        self._namespace_fetched = False
+
         self._rest_client = None
         self._gql_client = None
         self._id_cache: Dict[str, str] = {}  # Cache for slug -> ID mappings
 
+    @property
+    def namespace(self) -> str:
+        """
+        Get namespace, fetching from server if not already set.
+
+        Returns:
+            Namespace slug
+
+        Raises:
+            AuthenticationError: If not authenticated
+            ValueError: If namespace cannot be determined
+        """
+        if self._namespace:
+            return self._namespace
+
+        if not self._namespace_fetched:
+            # Fetch namespace from server
+            self._namespace = self._fetch_namespace_from_server()
+            self._namespace_fetched = True
+
+        if not self._namespace:
+            raise ValueError("Could not determine namespace. Please provide --namespace explicitly.")
+
+        return self._namespace
+
+    @namespace.setter
+    def namespace(self, value: str):
+        """Set namespace."""
+        self._namespace = value
+        self._namespace_fetched = True
+
+    def _fetch_namespace_from_server(self) -> Optional[str]:
+        """
+        Fetch current user's namespace from server.
+
+        Returns:
+            Namespace slug or None if cannot be determined
+        """
+        try:
+            self._ensure_authenticated()
+
+            # Query server for current user's namespace
+            query = """
+            query GetMyNamespace {
+              me {
+                username
+              }
+            }
+            """
+            result = self.graphql_query(query)
+            username = result.get("me", {}).get("username")
+            return username
+        except Exception:
+            return None
+
     def _ensure_authenticated(self):
         """Check if authenticated, raise error if not."""
         if not self.api_key: