ml-dash 0.6.2rc1__tar.gz → 0.6.4__tar.gz

{ml_dash-0.6.2rc1 → ml_dash-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ml-dash
-Version: 0.6.2rc1
+Version: 0.6.4
 Summary: ML experiment tracking and data storage
 Keywords: machine-learning,experiment-tracking,mlops,data-storage
 Author: Ge Yang, Tom Tao
@@ -43,7 +43,7 @@ Requires-Dist: imageio-ffmpeg>=0.4.9
 Requires-Dist: scikit-image>=0.21.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: cryptography>=42.0.0
-Requires-Dist: params-proto>=3.0.0rc12
+Requires-Dist: params-proto>=3.0.0
 Requires-Dist: keyring>=25.0.0 ; extra == 'auth'
 Requires-Dist: qrcode>=8.0.0 ; extra == 'auth'
 Requires-Dist: pytest>=8.0.0 ; extra == 'dev'
@@ -122,16 +122,16 @@ This opens your browser for secure OAuth2 authentication. Your credentials are s
 #### Option A: Use the Pre-configured Singleton (Easiest)
 
 ```python
-from ml_dash import dxp
+from ml_dash.auto_start import dxp
 
 # Start experiment (uploads to https://api.dash.ml by default)
 with dxp.run:
-    dxp.log().info("Training started")
+    dxp.log("Training started", level="info")
     dxp.params.set(learning_rate=0.001, batch_size=32)
 
     for epoch in range(10):
         loss = train_one_epoch()
-        dxp.metrics("loss").append(value=loss, epoch=epoch)
+        dxp.metrics("train").log(loss=loss, epoch=epoch)
 ```
 
 #### Option B: Create Your Own Experiment
@@ -140,12 +140,11 @@ with dxp.run:
 from ml_dash import Experiment
 
 with Experiment(
-    name="my-experiment",
-    project="my-project",
-    remote="https://api.dash.ml"  # token auto-loaded
+  prefix="alice/my-project/my-experiment",
+  dash_url="https://api.dash.ml",  # token auto-loaded
 ).run as experiment:
-    experiment.log().info("Hello!")
-    experiment.params.set(lr=0.001)
+  experiment.log("Hello!", level="info")
+  experiment.params.set(lr=0.001)
 ```
 
 #### Option C: Local Mode (No Authentication Required)
@@ -154,11 +153,10 @@ with Experiment(
 from ml_dash import Experiment
 
 with Experiment(
-    name="my-experiment",
-    project="my-project",
-    local_path=".ml-dash"
+  project="my-project", prefix="my-experiment", dash_root=".dash"
 ).run as experiment:
-    experiment.log().info("Running locally")
+  experiment.log("Running locally", level="info")
+
 ```
 
 See [docs/getting-started.md](docs/getting-started.md) for more examples.

{ml_dash-0.6.2rc1 → ml_dash-0.6.4}/README.md

@@ -54,16 +54,16 @@ This opens your browser for secure OAuth2 authentication. Your credentials are s
 #### Option A: Use the Pre-configured Singleton (Easiest)
 
 ```python
-from ml_dash import dxp
+from ml_dash.auto_start import dxp
 
 # Start experiment (uploads to https://api.dash.ml by default)
 with dxp.run:
-    dxp.log().info("Training started")
+    dxp.log("Training started", level="info")
     dxp.params.set(learning_rate=0.001, batch_size=32)
 
     for epoch in range(10):
         loss = train_one_epoch()
-        dxp.metrics("loss").append(value=loss, epoch=epoch)
+        dxp.metrics("train").log(loss=loss, epoch=epoch)
 ```
 
 #### Option B: Create Your Own Experiment
@@ -72,12 +72,11 @@ with dxp.run:
 from ml_dash import Experiment
 
 with Experiment(
-    name="my-experiment",
-    project="my-project",
-    remote="https://api.dash.ml"  # token auto-loaded
+  prefix="alice/my-project/my-experiment",
+  dash_url="https://api.dash.ml",  # token auto-loaded
 ).run as experiment:
-    experiment.log().info("Hello!")
-    experiment.params.set(lr=0.001)
+  experiment.log("Hello!", level="info")
+  experiment.params.set(lr=0.001)
 ```
 
 #### Option C: Local Mode (No Authentication Required)
@@ -86,11 +85,10 @@ with Experiment(
 from ml_dash import Experiment
 
 with Experiment(
-    name="my-experiment",
-    project="my-project",
-    local_path=".ml-dash"
+  project="my-project", prefix="my-experiment", dash_root=".dash"
 ).run as experiment:
-    experiment.log().info("Running locally")
+  experiment.log("Running locally", level="info")
+
 ```
 
 See [docs/getting-started.md](docs/getting-started.md) for more examples.

{ml_dash-0.6.2rc1 → ml_dash-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ml-dash"
-version = "0.6.2rc1"
+version = "0.6.4"
 description = "ML experiment tracking and data storage"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -31,7 +31,7 @@ dependencies = [
     "scikit-image>=0.21.0",
     "rich>=13.0.0",
     "cryptography>=42.0.0",
-    "params-proto>=3.0.0rc12",
+    "params-proto>=3.0.0",
 ]
 
 [project.scripts]

ml_dash-0.6.4/src/ml_dash/__init__.py

@@ -0,0 +1,59 @@
+"""
+ML-Dash Python SDK
+
+A simple and flexible SDK for ML experiment metricing and data storage.
+
+Prefix format: {owner}/{project}/path.../[name]
+  - owner: First segment (e.g., your username)
+  - project: Second segment (e.g., project name)
+  - path: Remaining segments form the folder structure
+  - name: Derived from last segment (may be a seed/id)
+
+Usage:
+
+    from ml_dash import Experiment
+
+    # Local mode - explicit configuration
+    with Experiment(
+        prefix="ge/my-project/experiments/exp1",
+        dash_root=".dash"
+    ).run as exp:
+        exp.log("Training started")
+        exp.params.set(lr=0.001)
+        exp.metrics("train").log(loss=0.5, step=0)
+
+    # Default: Remote mode (defaults to https://api.dash.ml)
+    with Experiment(prefix="ge/my-project/experiments/exp1").run as exp:
+        exp.log("Training started")
+        exp.params.set(lr=0.001)
+        exp.metrics("train").log(loss=0.5, step=0)
+
+    # Decorator style
+    from ml_dash import ml_dash_experiment
+
+    @ml_dash_experiment(prefix="ge/my-project/experiments/exp1")
+    def train_model(exp):
+        exp.log("Training started")
+"""
+
+from .client import RemoteClient
+from .experiment import Experiment, OperationMode, RunManager, ml_dash_experiment
+from .log import LogBuilder, LogLevel
+from .params import ParametersBuilder
+from .run import RUN
+from .storage import LocalStorage
+
+__version__ = "0.6.4"
+
+__all__ = [
+  "Experiment",
+  "ml_dash_experiment",
+  "OperationMode",
+  "RunManager",
+  "RemoteClient",
+  "LocalStorage",
+  "LogLevel",
+  "LogBuilder",
+  "ParametersBuilder",
+  "RUN",
+]

ml_dash-0.6.4/src/ml_dash/auth/token_storage.py

@@ -0,0 +1,303 @@
+"""Token storage backends for ml-dash authentication."""
+
+import json
+from abc import ABC, abstractmethod
+from base64 import urlsafe_b64decode
+from pathlib import Path
+from typing import Optional
+
+from .exceptions import StorageError
+
+
+class TokenStorage(ABC):
+  """Abstract base class for token storage backends."""
+
+  @abstractmethod
+  def store(self, key: str, value: str) -> None:
+    """Store a token.
+
+    Args:
+        key: Storage key
+        value: Token string to store
+    """
+    pass
+
+  @abstractmethod
+  def load(self, key: str) -> Optional[str]:
+    """Load a token.
+
+    Args:
+        key: Storage key
+
+    Returns:
+        Token string or None if not found
+    """
+    pass
+
+  @abstractmethod
+  def delete(self, key: str) -> None:
+    """Delete a token.
+
+    Args:
+        key: Storage key
+    """
+    pass
+
+
+class KeyringStorage(TokenStorage):
+  """OS keyring storage backend (macOS Keychain, Windows Credential Manager, Linux Secret Service)."""
+
+  SERVICE_NAME = "ml-dash"
+
+  def __init__(self):
+    """Initialize keyring storage."""
+    try:
+      import keyring
+
+      self.keyring = keyring
+    except ImportError:
+      raise StorageError(
+        "keyring library not installed. Install with: pip install keyring"
+      )
+
+  def store(self, key: str, value: str) -> None:
+    """Store token in OS keyring."""
+    try:
+      self.keyring.set_password(self.SERVICE_NAME, key, value)
+    except Exception as e:
+      raise StorageError(f"Failed to store token in keyring: {e}")
+
+  def load(self, key: str) -> Optional[str]:
+    """Load token from OS keyring."""
+    try:
+      return self.keyring.get_password(self.SERVICE_NAME, key)
+    except Exception as e:
+      raise StorageError(f"Failed to load token from keyring: {e}")
+
+  def delete(self, key: str) -> None:
+    """Delete token from OS keyring."""
+    try:
+      self.keyring.delete_password(self.SERVICE_NAME, key)
+    except Exception:
+      # Silently ignore if key doesn't exist
+      pass
+
+
+class EncryptedFileStorage(TokenStorage):
+  """Encrypted file storage backend using Fernet symmetric encryption."""
+
+  def __init__(self, config_dir: Path):
+    """Initialize encrypted file storage.
+
+    Args:
+        config_dir: Configuration directory path
+    """
+    self.config_dir = Path(config_dir)
+    self.tokens_file = self.config_dir / "tokens.encrypted"
+    self.key_file = self.config_dir / "encryption.key"
+
+    try:
+      from cryptography.fernet import Fernet
+
+      self.Fernet = Fernet
+    except ImportError:
+      raise StorageError(
+        "cryptography library not installed. Install with: pip install cryptography"
+      )
+
+    # Ensure config directory exists
+    self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Generate or load encryption key
+    if not self.key_file.exists():
+      key = self.Fernet.generate_key()
+      self.key_file.write_bytes(key)
+      self.key_file.chmod(0o600)  # User read/write only
+    else:
+      key = self.key_file.read_bytes()
+
+    self.cipher = self.Fernet(key)
+
+  def _load_all(self) -> dict:
+    """Load all tokens from encrypted file."""
+    if not self.tokens_file.exists():
+      return {}
+
+    try:
+      encrypted = self.tokens_file.read_bytes()
+      decrypted = self.cipher.decrypt(encrypted)
+      return json.loads(decrypted)
+    except Exception as e:
+      raise StorageError(f"Failed to decrypt tokens file: {e}")
+
+  def _save_all(self, data: dict) -> None:
+    """Save all tokens to encrypted file."""
+    try:
+      plaintext = json.dumps(data).encode()
+      encrypted = self.cipher.encrypt(plaintext)
+      self.tokens_file.write_bytes(encrypted)
+      self.tokens_file.chmod(0o600)  # User read/write only
+    except Exception as e:
+      raise StorageError(f"Failed to encrypt tokens file: {e}")
+
+  def store(self, key: str, value: str) -> None:
+    """Store token in encrypted file."""
+    all_tokens = self._load_all()
+    all_tokens[key] = value
+    self._save_all(all_tokens)
+
+  def load(self, key: str) -> Optional[str]:
+    """Load token from encrypted file."""
+    all_tokens = self._load_all()
+    return all_tokens.get(key)
+
+  def delete(self, key: str) -> None:
+    """Delete token from encrypted file."""
+    all_tokens = self._load_all()
+    if key in all_tokens:
+      del all_tokens[key]
+      self._save_all(all_tokens)
+
+
+class PlaintextFileStorage(TokenStorage):
+  """Plaintext file storage backend (INSECURE - only for testing/fallback)."""
+
+  _warning_shown = False
+
+  def __init__(self, config_dir: Path):
+    """Initialize plaintext file storage.
+
+    Args:
+        config_dir: Configuration directory path
+    """
+    self.config_dir = Path(config_dir)
+    self.tokens_file = self.config_dir / "tokens.json"
+
+    # Ensure config directory exists
+    self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Show security warning on first use
+    if not PlaintextFileStorage._warning_shown:
+      try:
+        from rich.console import Console
+
+        console = Console()
+        console.print(
+          "\n[bold red]WARNING: Storing tokens in plaintext![/bold red]\n"
+          "[yellow]Your authentication tokens are being stored unencrypted.[/yellow]\n"
+          "[yellow]This is insecure and only recommended for testing.[/yellow]\n\n"
+          "To use secure storage:\n"
+          "  • Install keyring: pip install keyring\n"
+          "  • Or encrypted storage will be used automatically\n"
+        )
+      except ImportError:
+        print("WARNING: Storing tokens in plaintext! This is insecure.")
+
+      PlaintextFileStorage._warning_shown = True
+
+  def _load_all(self) -> dict:
+    """Load all tokens from file."""
+    if not self.tokens_file.exists():
+      return {}
+
+    try:
+      with open(self.tokens_file, "r") as f:
+        return json.load(f)
+    except (json.JSONDecodeError, IOError):
+      return {}
+
+  def _save_all(self, data: dict) -> None:
+    """Save all tokens to file."""
+    with open(self.tokens_file, "w") as f:
+      json.dump(data, f, indent=2)
+    self.tokens_file.chmod(0o600)  # User read/write only
+
+  def store(self, key: str, value: str) -> None:
+    """Store token in plaintext file."""
+    all_tokens = self._load_all()
+    all_tokens[key] = value
+    self._save_all(all_tokens)
+
+  def load(self, key: str) -> Optional[str]:
+    """Load token from plaintext file."""
+    all_tokens = self._load_all()
+    return all_tokens.get(key)
+
+  def delete(self, key: str) -> None:
+    """Delete token from plaintext file."""
+    all_tokens = self._load_all()
+    if key in all_tokens:
+      del all_tokens[key]
+      self._save_all(all_tokens)
+
+
+def get_token_storage(config_dir: Optional[Path] = None) -> TokenStorage:
+  """Auto-detect and return appropriate storage backend.
+
+  Tries backends in order of security:
+  1. KeyringStorage (OS keyring)
+  2. EncryptedFileStorage (encrypted file)
+  3. PlaintextFileStorage (plaintext file with warning)
+
+  Args:
+      config_dir: Configuration directory (defaults to ~/.dash)
+
+  Returns:
+      TokenStorage instance
+  """
+  if config_dir is None:
+    config_dir = Path.home() / ".dash"
+
+  # Try keyring first
+  try:
+    return KeyringStorage()
+  except (ImportError, StorageError):
+    pass
+
+  # Try encrypted file storage
+  try:
+    return EncryptedFileStorage(config_dir)
+  except (ImportError, StorageError):
+    pass
+
+  # Fallback to plaintext (with warning)
+  return PlaintextFileStorage(config_dir)
+
+
+def decode_jwt_payload(token: str) -> dict:
+  """Decode JWT payload without verification (for display only).
+
+  Args:
+      token: JWT token string
+
+  Returns:
+      Decoded payload dict
+  """
+  try:
+    # JWT format: header.payload.signature
+    parts = token.split(".")
+    if len(parts) != 3:
+      return {}
+
+    # Decode payload (second part)
+    payload = parts[1]
+    # Add padding if needed
+    padding = 4 - len(payload) % 4
+    if padding != 4:
+      payload += "=" * padding
+
+    decoded = urlsafe_b64decode(payload)
+    return json.loads(decoded)
+  except Exception:
+    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.2rc1 → ml_dash-0.6.4}/src/ml_dash/auto_start.py

@@ -9,43 +9,56 @@ Usage:
     # First, authenticate
     # $ ml-dash login
 
-    from ml_dash import dxp
+    from ml_dash.auto_start import dxp
 
     # Use with statement (recommended)
     with dxp.run:
-        dxp.log().info("Hello from dxp!")
+        dxp.log("Hello from dxp!", level="info")
         dxp.params.set(lr=0.001)
-        dxp.metrics("loss").append(step=0, value=0.5)
+        dxp.metrics("train").log(loss=0.5, step=0)
     # Automatically completes on exit from with block
 
     # Or start/complete manually
     dxp.run.start()
-    dxp.log().info("Training...")
+    dxp.log("Training...", level="info")
     dxp.run.complete()
 """
 
 import atexit
-from .experiment import Experiment
 
 # Create pre-configured singleton experiment in remote mode
 # Uses default remote server (https://api.dash.ml)
 # 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()
+_now = datetime.now()
+
 dxp = Experiment(
-    name="dxp",
-    project="scratch",
-    remote="https://api.dash.ml",
+  prefix=f"{_username}/scratch/{_now:%Y-%m-%d/%H%M%S}",
+  dash_url="https://api.dash.ml",
 )
 
+
 # Register cleanup handler to complete experiment on Python exit (if still open)
 def _cleanup():
-    """Complete the dxp experiment on exit if still open."""
-    if dxp._is_open:
-        try:
-            dxp.run.complete()
-        except Exception:
-            # Silently ignore errors during cleanup
-            pass
+  """Complete the dxp experiment on exit if still open."""
+  if dxp._is_open:
+    try:
+      dxp.run.complete()
+    except Exception:
+      # Silently ignore errors during cleanup
+      pass
+
 
 atexit.register(_cleanup)
 

{ml_dash-0.6.2rc1 → ml_dash-0.6.4}/src/ml_dash/cli.py

@@ -9,7 +9,11 @@ def create_parser() -> argparse.ArgumentParser:
     """Create the main CLI argument parser."""
     parser = argparse.ArgumentParser(
         prog="ml-dash",
-        description="ML-Dash: ML experiment tracking and data storage CLI",
+        description=(
+            "ML-Dash: ML experiment tracking and data storage CLI\n\n"
+            "View your experiments, statistics, and plots online at:\n"
+            "  https://dash.ml\n"
+        ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
 
@@ -21,11 +25,15 @@ def create_parser() -> argparse.ArgumentParser:
     )
 
     # Import and add command parsers
-    from .cli_commands import upload, download, list as list_cmd, login, logout
+    from .cli_commands import upload, download, list as list_cmd, login, logout, profile, api
 
     # Authentication commands
     login.add_parser(subparsers)
     logout.add_parser(subparsers)
+    profile.add_parser(subparsers)
+
+    # API commands
+    api.add_parser(subparsers)
 
     # Data commands
     upload.add_parser(subparsers)
@@ -60,6 +68,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     elif args.command == "logout":
         from .cli_commands import logout
         return logout.cmd_logout(args)
+    elif args.command == "profile":
+        from .cli_commands import profile
+        return profile.cmd_profile(args)
     elif args.command == "upload":
         from .cli_commands import upload
         return upload.cmd_upload(args)
@@ -69,6 +80,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     elif args.command == "list":
         from .cli_commands import list as list_cmd
         return list_cmd.cmd_list(args)
+    elif args.command == "api":
+        from .cli_commands import api
+        return api.cmd_api(args)
 
     # Unknown command (shouldn't happen due to subparsers)
     parser.print_help()