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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ml-dash
-Version: 0.6.2
+Version: 0.6.2rc1
 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.0rc27
+Requires-Dist: params-proto>=3.0.0rc12
 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.auto_start import dxp
+from ml_dash import dxp
 
 # Start experiment (uploads to https://api.dash.ml by default)
 with dxp.run:
-    dxp.log("Training started", level="info")
+    dxp.log().info("Training started")
     dxp.params.set(learning_rate=0.001, batch_size=32)
 
     for epoch in range(10):
         loss = train_one_epoch()
-        dxp.metrics("train").log(loss=loss, epoch=epoch)
+        dxp.metrics("loss").append(value=loss, epoch=epoch)
 ```
 
 #### Option B: Create Your Own Experiment
@@ -140,11 +140,12 @@ with dxp.run:
 from ml_dash import Experiment
 
 with Experiment(
-  prefix="alice/my-project/my-experiment",
-  dash_url="https://api.dash.ml",  # token auto-loaded
+    name="my-experiment",
+    project="my-project",
+    remote="https://api.dash.ml"  # token auto-loaded
 ).run as experiment:
-  experiment.log("Hello!", level="info")
-  experiment.params.set(lr=0.001)
+    experiment.log().info("Hello!")
+    experiment.params.set(lr=0.001)
 ```
 
 #### Option C: Local Mode (No Authentication Required)
@@ -153,10 +154,11 @@ with Experiment(
 from ml_dash import Experiment
 
 with Experiment(
-  project="my-project", prefix="my-experiment", dash_root=".dash"
+    name="my-experiment",
+    project="my-project",
+    local_path=".ml-dash"
 ).run as experiment:
-  experiment.log("Running locally", level="info")
-
+    experiment.log().info("Running locally")
 ```
 
 See [docs/getting-started.md](docs/getting-started.md) for more examples.

{ml_dash-0.6.2 → ml_dash-0.6.2rc1}/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.auto_start import dxp
+from ml_dash import dxp
 
 # Start experiment (uploads to https://api.dash.ml by default)
 with dxp.run:
-    dxp.log("Training started", level="info")
+    dxp.log().info("Training started")
     dxp.params.set(learning_rate=0.001, batch_size=32)
 
     for epoch in range(10):
         loss = train_one_epoch()
-        dxp.metrics("train").log(loss=loss, epoch=epoch)
+        dxp.metrics("loss").append(value=loss, epoch=epoch)
 ```
 
 #### Option B: Create Your Own Experiment
@@ -72,11 +72,12 @@ with dxp.run:
 from ml_dash import Experiment
 
 with Experiment(
-  prefix="alice/my-project/my-experiment",
-  dash_url="https://api.dash.ml",  # token auto-loaded
+    name="my-experiment",
+    project="my-project",
+    remote="https://api.dash.ml"  # token auto-loaded
 ).run as experiment:
-  experiment.log("Hello!", level="info")
-  experiment.params.set(lr=0.001)
+    experiment.log().info("Hello!")
+    experiment.params.set(lr=0.001)
 ```
 
 #### Option C: Local Mode (No Authentication Required)
@@ -85,10 +86,11 @@ with Experiment(
 from ml_dash import Experiment
 
 with Experiment(
-  project="my-project", prefix="my-experiment", dash_root=".dash"
+    name="my-experiment",
+    project="my-project",
+    local_path=".ml-dash"
 ).run as experiment:
-  experiment.log("Running locally", level="info")
-
+    experiment.log().info("Running locally")
 ```
 
 See [docs/getting-started.md](docs/getting-started.md) for more examples.

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

@@ -1,6 +1,6 @@
 [project]
 name = "ml-dash"
-version = "0.6.2"
+version = "0.6.2rc1"
 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.0rc27",
+    "params-proto>=3.0.0rc12",
 ]
 
 [project.scripts]

ml_dash-0.6.2rc1/src/ml_dash/__init__.py

@@ -0,0 +1,87 @@
+"""
+ML-Dash Python SDK
+
+A simple and flexible SDK for ML experiment metricing and data storage.
+
+Usage:
+
+    # Quickest - dxp (pre-configured remote singleton)
+    # Requires: ml-dash login
+    from ml_dash import dxp
+
+    with dxp.run:
+        dxp.params.set(lr=0.001)
+        dxp.log().info("Training started")
+    # Auto-completes on exit from with block
+
+    # Local mode - explicit configuration
+    from ml_dash import Experiment
+
+    with Experiment(
+        name="my-experiment",
+        project="my-project",
+        local_path=".ml-dash"
+    ) as experiment:
+        experiment.log("Training started")
+        experiment.params.set(lr=0.001)
+        experiment.metrics("loss").append(step=0, value=0.5)
+
+    # Remote mode - explicit configuration
+    with Experiment(
+        name="my-experiment",
+        project="my-project",
+        remote="https://api.dash.ml",
+        api_key="your-jwt-token"
+    ) as experiment:
+        experiment.log("Training started")
+
+    # Decorator style
+    from ml_dash import ml_dash_experiment
+
+    @ml_dash_experiment(
+        name="my-experiment",
+        project="my-project"
+    )
+    def train_model(experiment):
+        experiment.log("Training started")
+"""
+
+from .experiment import Experiment, ml_dash_experiment, OperationMode, RunManager
+from .client import RemoteClient
+from .storage import LocalStorage
+from .log import LogLevel, LogBuilder
+from .params import ParametersBuilder
+from .run import RUN
+from .auto_start import dxp
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Experiment",
+    "ml_dash_experiment",
+    "OperationMode",
+    "RunManager",
+    "RemoteClient",
+    "LocalStorage",
+    "LogLevel",
+    "LogBuilder",
+    "ParametersBuilder",
+    "RUN",
+    "dxp",
+]
+
+# Hidden for now - rdxp (remote auto-start singleton)
+# Will be exposed in a future release
+#
+# # Lazy-load rdxp to avoid auto-connecting to server on package import
+# _rdxp = None
+#
+# def __getattr__(name):
+#     """Lazy-load rdxp only when accessed."""
+#     if name == "rdxp":
+#         global _rdxp
+#         if _rdxp is None:
+#             from .remote_auto_start import rdxp as _loaded_rdxp
+#             _rdxp = _loaded_rdxp
+#         return _rdxp
+#     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

ml_dash-0.6.2rc1/src/ml_dash/auth/token_storage.py

@@ -0,0 +1,262 @@
+"""Token storage backends for ml-dash authentication."""
+
+import json
+from abc import ABC, abstractmethod
+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 ~/.ml-dash)
+
+    Returns:
+        TokenStorage instance
+    """
+    if config_dir is None:
+        config_dir = Path.home() / ".ml-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)

{ml_dash-0.6.2 → ml_dash-0.6.2rc1}/src/ml_dash/auto_start.py

@@ -9,56 +9,43 @@ Usage:
     # First, authenticate
     # $ ml-dash login
 
-    from ml_dash.auto_start import dxp
+    from ml_dash import dxp
 
     # Use with statement (recommended)
     with dxp.run:
-        dxp.log("Hello from dxp!", level="info")
+        dxp.log().info("Hello from dxp!")
         dxp.params.set(lr=0.001)
-        dxp.metrics("train").log(loss=0.5, step=0)
+        dxp.metrics("loss").append(step=0, value=0.5)
     # Automatically completes on exit from with block
 
     # Or start/complete manually
     dxp.run.start()
-    dxp.log("Training...", level="info")
+    dxp.log().info("Training...")
     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(
-  prefix=f"{_username}/scratch/{_now:%Y-%m-%d/%H%M%S}",
-  dash_url="https://api.dash.ml",
+    name="dxp",
+    project="scratch",
+    remote="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.2 → ml_dash-0.6.2rc1}/src/ml_dash/cli.py

@@ -9,11 +9,7 @@ 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\n\n"
-            "View your experiments, statistics, and plots online at:\n"
-            "  https://dash.ml\n"
-        ),
+        description="ML-Dash: ML experiment tracking and data storage CLI",
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
 
@@ -25,15 +21,11 @@ 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
 
     # 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)
@@ -68,9 +60,6 @@ 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)
@@ -80,9 +69,6 @@ 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()