ml-dash 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

ml_dash/client.py

@@ -17,8 +17,9 @@ class RemoteClient:
             base_url: Base URL of ML-Dash server (e.g., "http://localhost:3000")
             api_key: JWT token for authentication (optional - auto-loads from storage if not provided)
 
-        Raises:
-            AuthenticationError: If no api_key provided and no token found in storage
+        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.
         """
         # Store original base URL for GraphQL (no /api prefix)
         self.graphql_base_url = base_url.rstrip("/")
@@ -29,38 +30,52 @@ class RemoteClient:
         # If no api_key provided, try to load from storage
         if not api_key:
             from .auth.token_storage import get_token_storage
-            from .auth.exceptions import AuthenticationError
 
             storage = get_token_storage()
             api_key = storage.load("ml-dash-token")
 
-            if not api_key:
-                raise AuthenticationError(
-                    "Not authenticated. Run 'ml-dash login' to authenticate, "
-                    "or provide an explicit api_key parameter."
-                )
-
         self.api_key = api_key
+        self._rest_client = None
+        self._gql_client = None
 
-        # REST API client (with /api prefix)
-        self._client = httpx.Client(
-            base_url=self.base_url,
-            headers={
-                "Authorization": f"Bearer {api_key}",
-                # Note: Don't set Content-Type here as default
-                # It will be set per-request (json or multipart)
-            },
-            timeout=30.0,
-        )
-
-        # GraphQL client (without /api prefix)
-        self._graphql_client = httpx.Client(
-            base_url=self.graphql_base_url,
-            headers={
-                "Authorization": f"Bearer {api_key}",
-            },
-            timeout=30.0,
-        )
+    def _ensure_authenticated(self):
+        """Check if authenticated, raise error if not."""
+        if not self.api_key:
+            from .auth.exceptions import AuthenticationError
+            raise AuthenticationError(
+                "Not authenticated. Run 'ml-dash login' to authenticate, "
+                "or provide an explicit api_key parameter."
+            )
+
+    @property
+    def _client(self):
+        """Lazy REST API client (with /api prefix)."""
+        if self._rest_client is None:
+            self._ensure_authenticated()
+            self._rest_client = httpx.Client(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    # Note: Don't set Content-Type here as default
+                    # It will be set per-request (json or multipart)
+                },
+                timeout=30.0,
+            )
+        return self._rest_client
+
+    @property
+    def _graphql_client(self):
+        """Lazy GraphQL client (without /api prefix)."""
+        if self._gql_client is None:
+            self._ensure_authenticated()
+            self._gql_client = httpx.Client(
+                base_url=self.graphql_base_url,
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                },
+                timeout=30.0,
+            )
+        return self._gql_client
 
     def create_or_update_experiment(
         self,
@@ -69,7 +84,7 @@ class RemoteClient:
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         bindrs: Optional[List[str]] = None,
-        folder: Optional[str] = None,
+        prefix: Optional[str] = None,
         write_protected: bool = False,
         metadata: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
@@ -78,16 +93,16 @@ class RemoteClient:
 
         Args:
             project: Project name
-            name: Experiment name
+            name: Experiment name (last segment of prefix)
             description: Optional description
             tags: Optional list of tags
             bindrs: Optional list of bindrs
-            folder: Optional folder path
+            prefix: Full prefix path sent to backend for folder hierarchy creation
             write_protected: If True, experiment becomes immutable
             metadata: Optional metadata dict
 
         Returns:
-            Response dict with experiment, project, folder, and namespace data
+            Response dict with experiment, project, and namespace data
 
         Raises:
             httpx.HTTPStatusError: If request fails
@@ -102,12 +117,12 @@ class RemoteClient:
             payload["tags"] = tags
         if bindrs is not None:
             payload["bindrs"] = bindrs
-        if folder is not None:
-            payload["folder"] = folder
         if write_protected:
             payload["writeProtected"] = write_protected
         if metadata is not None:
             payload["metadata"] = metadata
+        if prefix is not None:
+            payload["prefix"] = prefix
 
         response = self._client.post(
             f"/projects/{project}/experiments",
@@ -713,6 +728,9 @@ class RemoteClient:
             metadata
             project {
               slug
+              namespace {
+                slug
+              }
             }
             logMetadata {
               totalLogs
@@ -777,6 +795,9 @@ class RemoteClient:
             metadata
             project {
               slug
+              namespace {
+                slug
+              }
             }
             logMetadata {
               totalLogs
@@ -813,6 +834,73 @@ class RemoteClient:
         result = self.graphql_query(query, variables)
         return result.get("experiment")
 
+    def search_experiments_graphql(self, pattern: str) -> List[Dict[str, Any]]:
+        """
+        Search experiments using glob pattern via GraphQL.
+
+        Pattern format: namespace/project/experiment
+        Supports wildcards: *, ?, [0-9], [a-z], etc.
+
+        Args:
+            pattern: Glob pattern (e.g., "tom*/tutorials/*", "*/project-?/exp*")
+
+        Returns:
+            List of experiment dicts matching the pattern
+
+        Raises:
+            httpx.HTTPStatusError: If request fails
+
+        Examples:
+            >>> client.search_experiments_graphql("tom*/tutorials/*")
+            >>> client.search_experiments_graphql("*/my-project/baseline*")
+        """
+        query = """
+        query SearchExperiments($pattern: String!) {
+          searchExperiments(pattern: $pattern) {
+            id
+            name
+            description
+            tags
+            status
+            startedAt
+            endedAt
+            metadata
+            project {
+              id
+              slug
+              name
+              namespace {
+                id
+                slug
+              }
+            }
+            logMetadata {
+              totalLogs
+            }
+            metrics {
+              name
+              metricMetadata {
+                totalDataPoints
+              }
+            }
+            files {
+              id
+              filename
+              path
+              contentType
+              sizeBytes
+              checksum
+              description
+              tags
+              metadata
+            }
+          }
+        }
+        """
+        variables = {"pattern": pattern}
+        result = self.graphql_query(query, variables)
+        return result.get("searchExperiments", [])
+
     def download_file_streaming(
         self, experiment_id: str, file_id: str, dest_path: str
     ) -> str:

ml_dash/config.py

@@ -1,132 +1,132 @@
 """Configuration file management for ML-Dash CLI."""
 
-from pathlib import Path
 import json
-from typing import Optional, Dict, Any
+from pathlib import Path
+from typing import Any, Dict, Optional
 
 
 class Config:
+  """
+  Manages ML-Dash CLI configuration file.
+
+  Configuration is stored in ~/.dash/config.json with structure:
+  {
+      "remote_url": "https://api.dash.ml",
+      "api_key": "token",
+      "default_batch_size": 100
+  }
+  """
+
+  DEFAULT_CONFIG_DIR = Path.home() / ".dash"
+  CONFIG_FILE = "config.json"
+
+  def __init__(self, config_dir: Optional[Path] = None):
     """
-    Manages ML-Dash CLI configuration file.
-
-    Configuration is stored in ~/.ml-dash/config.json with structure:
-    {
-        "remote_url": "https://api.dash.ml",
-        "api_key": "token",
-        "default_batch_size": 100
-    }
-    """
+    Initialize config manager.
 
-    DEFAULT_CONFIG_DIR = Path.home() / ".ml-dash"
-    CONFIG_FILE = "config.json"
-
-    def __init__(self, config_dir: Optional[Path] = None):
-        """
-        Initialize config manager.
-
-        Args:
-            config_dir: Config directory path (defaults to ~/.ml-dash)
-        """
-        self.config_dir = config_dir or self.DEFAULT_CONFIG_DIR
-        self.config_path = self.config_dir / self.CONFIG_FILE
-        self._data = self._load()
-
-    def _load(self) -> Dict[str, Any]:
-        """Load config from file."""
-        if self.config_path.exists():
-            try:
-                with open(self.config_path, "r") as f:
-                    return json.load(f)
-            except (json.JSONDecodeError, IOError):
-                # If config is corrupted, return empty dict
-                return {}
+    Args:
+        config_dir: Config directory path (defaults to ~/.dash)
+    """
+    self.config_dir = config_dir or self.DEFAULT_CONFIG_DIR
+    self.config_path = self.config_dir / self.CONFIG_FILE
+    self._data = self._load()
+
+  def _load(self) -> Dict[str, Any]:
+    """Load config from file."""
+    if self.config_path.exists():
+      try:
+        with open(self.config_path, "r") as f:
+          return json.load(f)
+      except (json.JSONDecodeError, IOError):
+        # If config is corrupted, return empty dict
         return {}
+    return {}
+
+  def save(self):
+    """Save config to file."""
+    self.config_dir.mkdir(parents=True, exist_ok=True)
+    with open(self.config_path, "w") as f:
+      json.dump(self._data, f, indent=2)
+
+  def get(self, key: str, default: Any = None) -> Any:
+    """
+    Get config value.
 
-    def save(self):
-        """Save config to file."""
-        self.config_dir.mkdir(parents=True, exist_ok=True)
-        with open(self.config_path, "w") as f:
-            json.dump(self._data, f, indent=2)
-
-    def get(self, key: str, default: Any = None) -> Any:
-        """
-        Get config value.
-
-        Args:
-            key: Config key
-            default: Default value if key not found
-
-        Returns:
-            Config value or default
-        """
-        return self._data.get(key, default)
-
-    def set(self, key: str, value: Any):
-        """
-        Set config value and save.
-
-        Args:
-            key: Config key
-            value: Config value
-        """
-        self._data[key] = value
-        self.save()
-
-    def delete(self, key: str):
-        """
-        Delete config key and save.
-
-        Args:
-            key: Config key to delete
-        """
-        if key in self._data:
-            del self._data[key]
-            self.save()
-
-    def clear(self):
-        """Clear all config and save."""
-        self._data = {}
-        self.save()
-
-    @property
-    def remote_url(self) -> Optional[str]:
-        """Get default remote URL."""
-        return self.get("remote_url", "https://api.dash.ml")
-
-    @remote_url.setter
-    def remote_url(self, url: str):
-        """Set default remote URL."""
-        self.set("remote_url", url)
-
-    @property
-    def api_key(self) -> Optional[str]:
-        """Get default API key."""
-        return self.get("api_key")
-
-    @api_key.setter
-    def api_key(self, key: str):
-        """Set default API key."""
-        self.set("api_key", key)
-
-    @property
-    def batch_size(self) -> int:
-        """Get default batch size for uploads."""
-        return self.get("default_batch_size", 100)
-
-    @batch_size.setter
-    def batch_size(self, size: int):
-        """Set default batch size."""
-        self.set("default_batch_size", size)
-
-    @property
-    def device_secret(self) -> Optional[str]:
-        """Get device secret for OAuth device flow."""
-        return self.get("device_secret")
-
-    @device_secret.setter
-    def device_secret(self, secret: str):
-        """Set device secret."""
-        self.set("device_secret", secret)
+    Args:
+        key: Config key
+        default: Default value if key not found
+
+    Returns:
+        Config value or default
+    """
+    return self._data.get(key, default)
+
+  def set(self, key: str, value: Any):
+    """
+    Set config value and save.
+
+    Args:
+        key: Config key
+        value: Config value
+    """
+    self._data[key] = value
+    self.save()
+
+  def delete(self, key: str):
+    """
+    Delete config key and save.
+
+    Args:
+        key: Config key to delete
+    """
+    if key in self._data:
+      del self._data[key]
+      self.save()
+
+  def clear(self):
+    """Clear all config and save."""
+    self._data = {}
+    self.save()
+
+  @property
+  def remote_url(self) -> Optional[str]:
+    """Get default remote URL."""
+    return self.get("remote_url", "https://api.dash.ml")
+
+  @remote_url.setter
+  def remote_url(self, url: str):
+    """Set default remote URL."""
+    self.set("remote_url", url)
+
+  @property
+  def api_key(self) -> Optional[str]:
+    """Get default API key."""
+    return self.get("api_key")
+
+  @api_key.setter
+  def api_key(self, key: str):
+    """Set default API key."""
+    self.set("api_key", key)
+
+  @property
+  def batch_size(self) -> int:
+    """Get default batch size for uploads."""
+    return self.get("default_batch_size", 100)
+
+  @batch_size.setter
+  def batch_size(self, size: int):
+    """Set default batch size."""
+    self.set("default_batch_size", size)
+
+  @property
+  def device_secret(self) -> Optional[str]:
+    """Get device secret for OAuth device flow."""
+    return self.get("device_secret")
+
+  @device_secret.setter
+  def device_secret(self, secret: str):
+    """Set device secret."""
+    self.set("device_secret", secret)
 
 
 # Global config instance