ml-dash 0.6.2rc1__py3-none-any.whl → 0.6.3__py3-none-any.whl

ml_dash/__init__.py

@@ -3,85 +3,57 @@ 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
+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)
 
-    with dxp.run:
-        dxp.params.set(lr=0.001)
-        dxp.log().info("Training started")
-    # Auto-completes on exit from with block
+Usage:
 
-    # Local mode - explicit configuration
     from ml_dash import Experiment
 
+    # Local mode - explicit configuration
     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")
+        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(
-        name="my-experiment",
-        project="my-project"
-    )
-    def train_model(experiment):
-        experiment.log("Training started")
+    @ml_dash_experiment(prefix="ge/my-project/experiments/exp1")
+    def train_model(exp):
+        exp.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 .experiment import Experiment, OperationMode, RunManager, ml_dash_experiment
+from .log import LogBuilder, LogLevel
 from .params import ParametersBuilder
 from .run import RUN
-from .auto_start import dxp
+from .storage import LocalStorage
 
-__version__ = "0.1.0"
+__version__ = "0.6.3"
 
 __all__ = [
-    "Experiment",
-    "ml_dash_experiment",
-    "OperationMode",
-    "RunManager",
-    "RemoteClient",
-    "LocalStorage",
-    "LogLevel",
-    "LogBuilder",
-    "ParametersBuilder",
-    "RUN",
-    "dxp",
+  "Experiment",
+  "ml_dash_experiment",
+  "OperationMode",
+  "RunManager",
+  "RemoteClient",
+  "LocalStorage",
+  "LogLevel",
+  "LogBuilder",
+  "ParametersBuilder",
+  "RUN",
 ]
-
-# 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/auth/token_storage.py

@@ -2,6 +2,7 @@
 
 import json
 from abc import ABC, abstractmethod
+from base64 import urlsafe_b64decode
 from pathlib import Path
 from typing import Optional
 
@@ -9,254 +10,294 @@ from .exceptions import StorageError
 
 
 class TokenStorage(ABC):
-    """Abstract base class for token storage backends."""
+  """Abstract base class for token storage backends."""
 
-    @abstractmethod
-    def store(self, key: str, value: str) -> None:
-        """Store a token.
+  @abstractmethod
+  def store(self, key: str, value: str) -> None:
+    """Store a token.
 
-        Args:
-            key: Storage key
-            value: Token string to store
-        """
-        pass
+    Args:
+        key: Storage key
+        value: Token string to store
+    """
+    pass
 
-    @abstractmethod
-    def load(self, key: str) -> Optional[str]:
-        """Load a token.
+  @abstractmethod
+  def load(self, key: str) -> Optional[str]:
+    """Load a token.
 
-        Args:
-            key: Storage key
+    Args:
+        key: Storage key
 
-        Returns:
-            Token string or None if not found
-        """
-        pass
+    Returns:
+        Token string or None if not found
+    """
+    pass
 
-    @abstractmethod
-    def delete(self, key: str) -> None:
-        """Delete a token.
+  @abstractmethod
+  def delete(self, key: str) -> None:
+    """Delete a token.
 
-        Args:
-            key: Storage key
-        """
-        pass
+    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
+  """OS keyring storage backend (macOS Keychain, Windows Credential Manager, Linux Secret Service)."""
 
+  SERVICE_NAME = "ml-dash"
 
-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)
+  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"
+      )
 
-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 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 get_token_storage(config_dir: Optional[Path] = None) -> TokenStorage:
-    """Auto-detect and return appropriate storage backend.
+  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
 
-    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)
+class EncryptedFileStorage(TokenStorage):
+  """Encrypted file storage backend using Fernet symmetric encryption."""
 
-    Returns:
-        TokenStorage instance
+  def __init__(self, config_dir: Path):
+    """Initialize encrypted file storage.
+
+    Args:
+        config_dir: Configuration directory path
     """
-    if config_dir is None:
-        config_dir = Path.home() / ".ml-dash"
+    self.config_dir = Path(config_dir)
+    self.tokens_file = self.config_dir / "tokens.encrypted"
+    self.key_file = self.config_dir / "encryption.key"
 
-    # Try keyring first
     try:
-        return KeyringStorage()
-    except (ImportError, StorageError):
-        pass
+      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 encrypted file storage
     try:
-        return EncryptedFileStorage(config_dir)
-    except (ImportError, StorageError):
-        pass
+      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)
 
-    # Fallback to plaintext (with warning)
-    return PlaintextFileStorage(config_dir)
+
+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