ml-dash 0.6.9__tar.gz → 0.6.11__tar.gz

{ml_dash-0.6.9 → ml_dash-0.6.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ml-dash
-Version: 0.6.9
+Version: 0.6.11
 Summary: ML experiment tracking and data storage
 Keywords: machine-learning,experiment-tracking,mlops,data-storage
 Author: Ge Yang, Tom Tao

{ml_dash-0.6.9 → ml_dash-0.6.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ml-dash"
-version = "0.6.9"
+version = "0.6.11"
 description = "ML experiment tracking and data storage"
 readme = "README.md"
 requires-python = ">=3.9"

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/__init__.py

@@ -36,14 +36,60 @@ Usage:
         exp.log("Training started")
 """
 
-from .client import RemoteClient
+from .client import RemoteClient, userinfo
 from .experiment import Experiment, OperationMode, ml_dash_experiment
 from .log import LogBuilder, LogLevel
 from .params import ParametersBuilder
 from .run import RUN
 from .storage import LocalStorage
 
-__version__ = "0.6.4"
+__version__ = "0.6.10"
+
+# Minimum version required - blocks older versions
+MINIMUM_REQUIRED_VERSION = "0.6.10"
+
+
+def _check_version_compatibility():
+    """
+    Enforce minimum version requirement.
+
+    Raises ImportError if installed version is below minimum required version.
+    This ensures users have the latest features (userinfo, namespace auto-detection, etc.)
+    """
+    try:
+        from packaging import version
+    except ImportError:
+        # If packaging is not available, skip check
+        # (unlikely since it's a common dependency)
+        return
+
+    current = version.parse(__version__)
+    minimum = version.parse(MINIMUM_REQUIRED_VERSION)
+
+    if current < minimum:
+        raise ImportError(
+            f"\n"
+            f"{'=' * 80}\n"
+            f"ERROR: ml-dash version {__version__} is too old!\n"
+            f"{'=' * 80}\n"
+            f"\n"
+            f"This version of ml-dash ({__version__}) is no longer supported.\n"
+            f"Minimum required version: {MINIMUM_REQUIRED_VERSION}\n"
+            f"\n"
+            f"Please upgrade to the latest version:\n"
+            f"\n"
+            f"  pip install --upgrade ml-dash\n"
+            f"\n"
+            f"Or install specific version:\n"
+            f"\n"
+            f"  pip install ml-dash>={MINIMUM_REQUIRED_VERSION}\n"
+            f"\n"
+            f"{'=' * 80}\n"
+        )
+
+
+# Enforce version check on import
+_check_version_compatibility()
 
 __all__ = [
   "Experiment",
@@ -55,4 +101,5 @@ __all__ = [
   "LogBuilder",
   "ParametersBuilder",
   "RUN",
+  "userinfo",
 ]

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/auth/token_storage.py

@@ -292,12 +292,3 @@ def decode_jwt_payload(token: str) -> dict:
     return {}
 
 
-def get_jwt_user():
-  # Load token
-  storage = get_token_storage()
-  token = storage.load("ml-dash-token")
-
-  if token:
-    user = decode_jwt_payload(token)
-    return user
-  return None

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/auto_start.py

@@ -31,19 +31,34 @@ import atexit
 # Token is auto-loaded from storage when first used
 # If not authenticated, operations will fail with AuthenticationError
 # Prefix format: {owner}/{project}/path...
-# Using getpass to get current user as owner for local convenience
 import getpass
 from datetime import datetime
 
-from .auth.token_storage import get_jwt_user
 from .experiment import Experiment
 
-_user = get_jwt_user()
-# Fallback to system username if not authenticated
-_username = _user["username"] if _user else getpass.getuser()
+# Get username for dxp namespace
+# Note: We use userinfo for fresh data (recommended approach)
+# Falls back to system username if not authenticated
+try:
+    from .client import userinfo
+    _username = userinfo.username or getpass.getuser()
+except Exception:
+    # If userinfo fails (e.g., no network), fall back to system user
+    _username = getpass.getuser()
+
 _now = datetime.now()
 
-dxp = Experiment()
+# Create pre-configured singleton experiment in REMOTE mode
+# - dash_url=True: Use default remote server (https://api.dash.ml)
+# - dash_root=None: Remote-only mode (no local storage)
+# - user: Uses authenticated username from userinfo (fresh from server)
+# - Token is auto-loaded from storage when first used
+# - If not authenticated, operations will fail with AuthenticationError
+dxp = Experiment(
+    user=_username,      # Use authenticated username for namespace
+    dash_url=True,       # Use remote API (https://api.dash.ml)
+    dash_root=None,      # Remote-only mode (no local .dash/)
+)
 
 
 # Register cleanup handler to complete experiment on Python exit (if still open)

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/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, create
+    from .cli_commands import upload, download, list as list_cmd, login, logout, profile, api, create, remove
 
     # Authentication commands
     login.add_parser(subparsers)
@@ -37,6 +37,7 @@ def create_parser() -> argparse.ArgumentParser:
 
     # Project commands
     create.add_parser(subparsers)
+    remove.add_parser(subparsers)
 
     # Data commands
     upload.add_parser(subparsers)
@@ -77,6 +78,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     elif args.command == "create":
         from .cli_commands import create
         return create.cmd_create(args)
+    elif args.command == "remove":
+        from .cli_commands import remove
+        return remove.cmd_remove(args)
     elif args.command == "upload":
         from .cli_commands import upload
         return upload.cmd_upload(args)

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/cli_commands/profile.py

@@ -24,9 +24,9 @@ def add_parser(subparsers):
     help="Output as JSON",
   )
   parser.add_argument(
-    "--refresh",
+    "--cached",
     action="store_true",
-    help="Fetch fresh profile from server (not from cached token)",
+    help="Use cached token data (default: fetch fresh from server)",
   )
 
 
@@ -45,27 +45,17 @@ def _fetch_fresh_profile(remote_url: str, token: str) -> dict:
 
     client = RemoteClient(remote_url, api_key=token)
 
-    # Query for full user profile
-    query = """
-    query GetUserProfile {
-      me {
-        id
-        username
-        name
-        email
-      }
-    }
-    """
-
-    result = client.graphql_query(query)
-    me = result.get("me", {})
+    # Use the new get_current_user() method
+    user_data = client.get_current_user()
 
-    if me:
+    if user_data:
       return {
-        "sub": me.get("id"),
-        "username": me.get("username"),
-        "name": me.get("name"),
-        "email": me.get("email"),
+        "sub": user_data.get("id"),
+        "username": user_data.get("username"),
+        "name": user_data.get("name"),
+        "email": user_data.get("email"),
+        "given_name": user_data.get("given_name"),
+        "family_name": user_data.get("family_name"),
       }
   except Exception as e:
     # If API call fails, return None to fall back to token decoding
@@ -131,8 +121,13 @@ def cmd_profile(args) -> int:
       info["authenticated"] = False
       info["error"] = "Token expired. Please run 'ml-dash login' to re-authenticate."
     else:
-      # Fetch fresh profile from server if requested, or fall back to token
-      if args.refresh:
+      # Fetch fresh profile from server by default, use cached token only if --cached flag is set
+      if args.cached:
+        # Use cached token data
+        info["user"] = token_payload
+        info["source"] = "token"
+      else:
+        # Fetch fresh data from server (default behavior)
         fresh_profile = _fetch_fresh_profile(config.remote_url, token)
         if fresh_profile:
           info["user"] = fresh_profile
@@ -141,9 +136,6 @@ def cmd_profile(args) -> int:
           info["user"] = token_payload
           info["source"] = "token"
           info["warning"] = "Could not fetch fresh profile from server, using cached token data"
-      else:
-        info["user"] = token_payload
-        info["source"] = "token"
 
       if expiry_message:
         info["token_status"] = expiry_message
@@ -199,9 +191,9 @@ def cmd_profile(args) -> int:
   if info.get("warning"):
     warning_text = f"\n[yellow]⚠ {info['warning']}[/yellow]"
 
-  # Show tip for refreshing
-  if source == "token":
-    tip_text = "\n[dim]Tip: Use --refresh to fetch fresh data from server[/dim]"
+  # Show tip for using cached data
+  if source == "server":
+    tip_text = "\n[dim]Tip: Use --cached to use cached token data (faster but may be outdated)[/dim]"
   else:
     tip_text = None
 

ml_dash-0.6.11/src/ml_dash/cli_commands/remove.py

@@ -0,0 +1,161 @@
+"""Remove command for ml-dash CLI - delete 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 remove command parser."""
+    parser = subparsers.add_parser(
+        "remove",
+        help="Delete a project",
+        description="""Delete a project from ml-dash.
+
+WARNING: This will delete the project and all its experiments, metrics, files, and logs.
+This action cannot be undone.
+
+Examples:
+  # Delete a project in current user's namespace
+  ml-dash remove -p my-project
+
+  # Delete a project in a specific namespace
+  ml-dash remove -p geyang/old-project
+
+  # Skip confirmation prompt (use with caution!)
+  ml-dash remove -p my-project -y
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "-p", "--prefix",
+        type=str,
+        required=True,
+        help="Project name or namespace/project",
+    )
+    parser.add_argument(
+        "-y", "--yes",
+        action="store_true",
+        help="Skip confirmation prompt",
+    )
+    parser.add_argument(
+        "--dash-url",
+        type=str,
+        help="ML-Dash server URL (default: https://api.dash.ml)",
+    )
+
+
+def cmd_remove(args) -> int:
+    """Execute remove 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 remove -p my-project\n"
+            f"  ml-dash remove -p geyang/old-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 _remove_project(
+        namespace=namespace,
+        project_name=project_name,
+        dash_url=remote_url,
+        skip_confirm=args.yes,
+        console=console,
+    )
+
+
+def _remove_project(
+    namespace: Optional[str],
+    project_name: str,
+    dash_url: str,
+    skip_confirm: bool,
+    console: Console,
+) -> int:
+    """Remove a 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
+
+        full_path = f"{namespace}/{project_name}"
+
+        # Get project ID to verify it exists
+        project_id = client._get_project_id(project_name)
+        if not project_id:
+            console.print(f"[yellow]⚠[/yellow] Project '[bold]{full_path}[/bold]' not found.")
+            return 1
+
+        # Confirmation prompt (unless -y flag is used)
+        if not skip_confirm:
+            console.print(
+                f"\n[red bold]⚠ WARNING ⚠[/red bold]\n\n"
+                f"You are about to delete project: [bold]{full_path}[/bold]\n"
+                f"This will permanently delete:\n"
+                f"  • All experiments in this project\n"
+                f"  • All metrics and logs\n"
+                f"  • All uploaded files\n\n"
+                f"[red]This action CANNOT be undone.[/red]\n"
+            )
+            confirm = console.input("Type the project name to confirm deletion: ")
+            if confirm.strip() != project_name:
+                console.print("\n[yellow]Deletion cancelled.[/yellow]")
+                return 0
+
+        console.print(f"\n[dim]Deleting project '{full_path}'...[/dim]")
+
+        # Delete project using client method
+        result = client.delete_project(project_name)
+
+        # Success message
+        console.print(f"[green]✓[/green] {result.get('message', 'Project deleted successfully!')}")
+        console.print(f"  Name: [bold]{project_name}[/bold]")
+        console.print(f"  Namespace: [bold]{namespace}[/bold]")
+        console.print(f"  Project ID: {project_id}")
+        console.print(f"  Deleted nodes: {result.get('deleted', 0)}")
+        console.print(f"  Deleted experiments: {result.get('experiments', 0)}")
+
+        return 0
+
+    except Exception as e:
+        # Check if it's a 404 not found
+        if hasattr(e, 'response') and hasattr(e.response, 'status_code') and e.response.status_code == 404:
+            console.print(f"[yellow]⚠[/yellow] Project '[bold]{project_name}[/bold]' not found in namespace '[bold]{namespace}[/bold]'")
+            return 1
+
+        # Check if it's a 403 forbidden
+        if hasattr(e, 'response') and hasattr(e.response, 'status_code') and e.response.status_code == 403:
+            console.print(f"[red]Error:[/red] Permission denied. You don't have permission to delete this project.")
+            return 1
+
+        console.print(f"[red]Error deleting project:[/red] {e}")
+        return 1

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/client.py

@@ -6,6 +6,95 @@ from typing import Optional, Dict, Any, List
 import httpx
 
 
+class UserInfo:
+    """
+    Singleton user info object that fetches current user from API server.
+
+    Fetches user info from API server on first access (lazy loading).
+    This queries the API for fresh user data, ensuring up-to-date information.
+
+    Usage:
+        >>> from ml_dash import userinfo
+        >>> if userinfo.username:
+        ...     print(f"Namespace: {userinfo.username}")
+        ...     print(f"Email: {userinfo.email}")
+        ...     print(f"Project: {userinfo.username}/my-project")
+    """
+
+    def __init__(self):
+        self._data = None
+        self._fetched = False
+
+    def _fetch(self):
+        """Fetch user info from API server (lazy loading)."""
+        if self._fetched:
+            return
+
+        self._fetched = True
+        try:
+            client = RemoteClient("https://api.dash.ml")
+            self._data = client.get_current_user()
+        except Exception:
+            self._data = None
+
+    @property
+    def username(self) -> Optional[str]:
+        """Username (namespace) - e.g., 'tom_tao_e4c2c9'"""
+        self._fetch()
+        return self._data.get("username") if self._data else None
+
+    @property
+    def email(self) -> Optional[str]:
+        """User email"""
+        self._fetch()
+        return self._data.get("email") if self._data else None
+
+    @property
+    def name(self) -> Optional[str]:
+        """Full name"""
+        self._fetch()
+        return self._data.get("name") if self._data else None
+
+    @property
+    def given_name(self) -> Optional[str]:
+        """First/given name"""
+        self._fetch()
+        return self._data.get("given_name") if self._data else None
+
+    @property
+    def family_name(self) -> Optional[str]:
+        """Last/family name"""
+        self._fetch()
+        return self._data.get("family_name") if self._data else None
+
+    @property
+    def picture(self) -> Optional[str]:
+        """Profile picture URL"""
+        self._fetch()
+        return self._data.get("picture") if self._data else None
+
+    @property
+    def id(self) -> Optional[str]:
+        """User ID"""
+        self._fetch()
+        return self._data.get("id") if self._data else None
+
+    def __bool__(self) -> bool:
+        """Return True if user is authenticated and data was fetched successfully."""
+        self._fetch()
+        return self._data is not None
+
+    def __repr__(self) -> str:
+        self._fetch()
+        if self._data:
+            return f"UserInfo(username='{self.username}', email='{self.email}')"
+        return "UserInfo(not authenticated)"
+
+
+# Create singleton instance
+userinfo = UserInfo()
+
+
 def _serialize_value(value: Any) -> Any:
     """
     Convert value to JSON-serializable format.
@@ -140,6 +229,44 @@ class RemoteClient:
         except Exception:
             return None
 
+    def get_current_user(self) -> Optional[Dict[str, Any]]:
+        """
+        Get current authenticated user's info from server.
+
+        This queries the API server for fresh user data, ensuring up-to-date information.
+
+        Returns:
+            User info dict with keys: username, email, name, given_name, family_name, picture
+            Returns None if not authenticated or if query fails
+
+        Example:
+            >>> client = RemoteClient("https://api.dash.ml")
+            >>> user = client.get_current_user()
+            >>> print(user["username"])  # e.g., "tom_tao_e4c2c9"
+            >>> print(user["email"])     # e.g., "user@example.com"
+        """
+        try:
+            self._ensure_authenticated()
+
+            # Query server for current user's complete profile
+            query = """
+            query GetCurrentUser {
+              me {
+                id
+                username
+                email
+                name
+                given_name
+                family_name
+                picture
+              }
+            }
+            """
+            result = self.graphql_query(query)
+            return result.get("me")
+        except Exception:
+            return None
+
     def _ensure_authenticated(self):
         """Check if authenticated, raise error if not."""
         if not self.api_key:
@@ -222,6 +349,30 @@ class RemoteClient:
         # Project not found - return None to let server auto-create it
         return None
 
+    def delete_project(self, project_slug: str) -> Dict[str, Any]:
+        """
+        Delete a project and all its experiments, metrics, files, and logs.
+
+        Args:
+            project_slug: Project slug
+
+        Returns:
+            Dict with projectId, deleted count, experiments count, and message
+
+        Raises:
+            httpx.HTTPStatusError: If request fails
+            ValueError: If project not found
+        """
+        # Get project ID first
+        project_id = self._get_project_id(project_slug)
+        if not project_id:
+            raise ValueError(f"Project '{project_slug}' not found in namespace '{self.namespace}'")
+
+        # Delete using project-specific endpoint
+        response = self._client.delete(f"/projects/{project_id}")
+        response.raise_for_status()
+        return response.json()
+
     def _get_experiment_node_id(self, experiment_id: str) -> str:
         """
         Resolve node ID from experiment ID using GraphQL.

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/experiment.py

@@ -259,15 +259,17 @@ class Experiment:
           from rich.console import Console
 
           console = Console()
+          experiment_url = f"https://dash.ml/{self.run.prefix}"
           console.print(
             f"[dim]✓ Experiment started: [bold]{self.run.name}[/bold] (project: {self.run.project})[/dim]\n"
             f"[dim]View your data, statistics, and plots online at:[/dim] "
-            f"[link=https://dash.ml]https://dash.ml[/link]"
+            f"[link={experiment_url}]{experiment_url}[/link]"
           )
         except ImportError:
           # Fallback if rich is not available
+          experiment_url = f"https://dash.ml/{self.run.prefix}"
           print(f"✓ Experiment started: {self.run.name} (project: {self.run.project})")
-          print("View your data at: https://dash.ml")
+          print(f"View your data at: {experiment_url}")
 
       except Exception as e:
         # Check if it's an authentication error
@@ -381,18 +383,20 @@ class Experiment:
           from rich.console import Console
 
           console = Console()
+          experiment_url = f"https://dash.ml/{self.run.prefix}"
           console.print(
             f"[{status_color}]{status_emoji} Experiment {status.lower()}: "
             f"[bold]{self.run.name}[/bold] (project: {self.run.project})[/{status_color}]\n"
             f"[dim]View results, statistics, and plots online at:[/dim] "
-            f"[link=https://dash.ml]https://dash.ml[/link]"
+            f"[link={experiment_url}]{experiment_url}[/link]"
           )
         except ImportError:
           # Fallback if rich is not available
+          experiment_url = f"https://dash.ml/{self.run.prefix}"
           print(
             f"{status_emoji} Experiment {status.lower()}: {self.run.name} (project: {self.run.project})"
           )
-          print("View results at: https://dash.ml")
+          print(f"View results at: {experiment_url}")
 
       except Exception as e:
         # Log error but don't fail the close operation

{ml_dash-0.6.9 → ml_dash-0.6.11}/src/ml_dash/run.py

@@ -223,7 +223,7 @@ class RUN:
         # experiments/vision/resnet/train.py
         from ml_dash import RUN
 
-        RUN.__post_init__(entry=__file__)
+        RUN(entry=__file__)
         # Result: RUN.prefix = "vision/resnet", RUN.name = "resnet"
     """
     # Use provided entry or try to auto-detect from caller