ml-dash 0.6.3__tar.gz → 0.6.4__tar.gz

{ml_dash-0.6.3 → ml_dash-0.6.4}/PKG-INFO

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

{ml_dash-0.6.3 → ml_dash-0.6.4}/pyproject.toml

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

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/__init__.py

@@ -43,7 +43,7 @@ from .params import ParametersBuilder
 from .run import RUN
 from .storage import LocalStorage
 
-__version__ = "0.6.3"
+__version__ = "0.6.4"
 
 __all__ = [
   "Experiment",

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/cli_commands/api.py

@@ -56,6 +56,12 @@ Notes:
     type=str,
     help="ML-Dash server URL (default: https://api.dash.ml)",
   )
+  parser.add_argument(
+    "--namespace",
+    type=str,
+    required=True,
+    help="Namespace to use for queries (required)",
+  )
 
 
 def extract_path(data, path: str):
@@ -131,9 +137,12 @@ def cmd_api(args) -> int:
   # Get remote URL
   remote_url = args.dash_url or config.remote_url or "https://api.dash.ml"
 
+  # Get namespace
+  namespace = args.namespace
+
   try:
     # Initialize client
-    client = RemoteClient(base_url=remote_url)
+    client = RemoteClient(base_url=remote_url, namespace=namespace)
 
     # Determine query type and build query
     if args.mutation:

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/cli_commands/download.py

@@ -240,7 +240,9 @@ class ExperimentDownloader:
     """Get thread-local remote client for safe concurrent access."""
     if not hasattr(self._thread_local, "client"):
       self._thread_local.client = RemoteClient(
-        base_url=self.remote.base_url, api_key=self.remote.api_key
+        base_url=self.remote.base_url,
+        namespace=self.remote.namespace,
+        api_key=self.remote.api_key
       )
     return self._thread_local.client
 
@@ -630,8 +632,23 @@ def cmd_download(args: argparse.Namespace) -> int:
     console.print("[red]Error:[/red] --dash-url is required (or set in config)")
     return 1
 
+  # Extract namespace from project argument
+  namespace = None
+  if args.project:
+    # Parse namespace from project filter (format: "owner/project" or "owner/project/exp")
+    project_parts = args.project.strip("/").split("/")
+    if len(project_parts) >= 2:  # Has at least "owner/project"
+      namespace = project_parts[0]
+
+  if not namespace:
+    console.print(
+      "[red]Error:[/red] --project must be in format 'namespace/project' or 'namespace/project/exp'"
+    )
+    console.print("Example: ml-dash download --project alice/my-project")
+    return 1
+
   # Initialize clients (RemoteClient will auto-load token if api_key is None)
-  remote_client = RemoteClient(base_url=remote_url, api_key=api_key)
+  remote_client = RemoteClient(base_url=remote_url, namespace=namespace, api_key=api_key)
   local_storage = LocalStorage(root_path=Path(args.path))
 
   # Load or create state

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/cli_commands/list.py

@@ -260,9 +260,26 @@ def cmd_list(args: argparse.Namespace) -> int:
     # Get API key (command line > config > auto-loaded from storage)
     api_key = args.api_key or config.api_key
 
+    # Extract namespace from project argument
+    namespace = None
+    if args.project:
+        # Parse namespace from project filter (format: "namespace/project")
+        project_parts = args.project.strip("/").split("/")
+        # For simple patterns without '/', treat as project-only pattern
+        if '/' in args.project and len(project_parts) >= 2:
+            namespace = project_parts[0]
+
+    if not namespace:
+        console.print(
+            "[red]Error:[/red] --project must be in format 'namespace/project'"
+        )
+        console.print("Example: ml-dash list --project alice/my-project")
+        console.print("Or use glob patterns: ml-dash list --project alice/proj-*")
+        return 1
+
     # Create remote client
     try:
-        remote_client = RemoteClient(base_url=remote_url, api_key=api_key)
+        remote_client = RemoteClient(base_url=remote_url, namespace=namespace, api_key=api_key)
     except Exception as e:
         console.print(f"[red]Error connecting to remote:[/red] {e}")
         return 1

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/cli_commands/upload.py

@@ -632,7 +632,9 @@ class ExperimentUploader:
       # Create a new client for this thread
       # Use graphql_base_url (without /api) since RemoteClient.__init__ will add /api
       self._thread_local.client = RemoteClient(
-        base_url=self.remote.graphql_base_url, api_key=self.remote.api_key
+        base_url=self.remote.graphql_base_url,
+        namespace=self.remote.namespace,
+        api_key=self.remote.api_key
       )
     return self._thread_local.client
 
@@ -1231,8 +1233,27 @@ def cmd_upload(args: argparse.Namespace) -> int:
     f"[green]{len(valid_experiments)} experiment(s) ready to upload[/green]"
   )
 
+  # Extract namespace from target or first experiment
+  namespace = None
+  if args.target:
+    # Parse namespace from target prefix (format: "owner/project/...")
+    target_parts = args.target.strip("/").split("/")
+    if len(target_parts) >= 1:
+      namespace = target_parts[0]
+  if not namespace and valid_experiments:
+    # Parse namespace from first experiment's prefix
+    first_prefix = valid_experiments[0].prefix
+    if first_prefix:
+      prefix_parts = first_prefix.strip("/").split("/")
+      if len(prefix_parts) >= 1:
+        namespace = prefix_parts[0]
+
+  if not namespace:
+    console.print("[red]Error:[/red] Could not determine namespace from experiments or target")
+    return 1
+
   # Initialize remote client and local storage
-  remote_client = RemoteClient(base_url=remote_url, api_key=api_key)
+  remote_client = RemoteClient(base_url=remote_url, namespace=namespace, api_key=api_key)
   local_storage = LocalStorage(root_path=local_path)
 
   # Upload experiments with progress tracking

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/client.py

@@ -9,12 +9,13 @@ import httpx
 class RemoteClient:
     """Client for communicating with ML-Dash server."""
 
-    def __init__(self, base_url: str, api_key: Optional[str] = None):
+    def __init__(self, base_url: str, namespace: str, api_key: Optional[str] = None):
         """
         Initialize remote client.
 
         Args:
             base_url: Base URL of ML-Dash server (e.g., "http://localhost:3000")
+            namespace: Namespace slug (e.g., "my-namespace")
             api_key: JWT token for authentication (optional - auto-loads from storage if not provided)
 
         Note:
@@ -27,6 +28,9 @@ class RemoteClient:
         # Add /api prefix to base URL for REST API calls
         self.base_url = base_url.rstrip("/") + "/api"
 
+        # Store namespace
+        self.namespace = namespace
+
         # If no api_key provided, try to load from storage
         if not api_key:
             from .auth.token_storage import get_token_storage
@@ -37,6 +41,7 @@ class RemoteClient:
         self.api_key = api_key
         self._rest_client = None
         self._gql_client = None
+        self._id_cache: Dict[str, str] = {}  # Cache for slug -> ID mappings
 
     def _ensure_authenticated(self):
         """Check if authenticated, raise error if not."""
@@ -77,6 +82,80 @@ class RemoteClient:
             )
         return self._gql_client
 
+    def _get_project_id(self, project_slug: str) -> str:
+        """
+        Resolve project ID from slug using GraphQL.
+
+        Args:
+            project_slug: Project slug
+
+        Returns:
+            Project ID (Snowflake ID)
+
+        Raises:
+            ValueError: If project not found
+        """
+        cache_key = f"project:{self.namespace}:{project_slug}"
+        if cache_key in self._id_cache:
+            return self._id_cache[cache_key]
+
+        query = """
+        query GetProject($namespace: String!) {
+          namespace(slug: $namespace) {
+            projects {
+              id
+              slug
+            }
+          }
+        }
+        """
+        result = self.graphql_query(query, {
+            "namespace": self.namespace
+        })
+
+        projects = result.get("namespace", {}).get("projects", [])
+        for project in projects:
+            if project["slug"] == project_slug:
+                project_id = project["id"]
+                self._id_cache[cache_key] = project_id
+                return project_id
+
+        raise ValueError(f"Project '{project_slug}' not found in namespace '{self.namespace}'")
+
+    def _get_experiment_node_id(self, experiment_id: str) -> str:
+        """
+        Resolve node ID from experiment ID using GraphQL.
+
+        Args:
+            experiment_id: Experiment ID
+
+        Returns:
+            Node ID
+
+        Raises:
+            ValueError: If experiment node not found
+        """
+        cache_key = f"exp_node:{experiment_id}"
+        if cache_key in self._id_cache:
+            return self._id_cache[cache_key]
+
+        query = """
+        query GetExperimentNode($experimentId: ID!) {
+          experimentNode(experimentId: $experimentId) {
+            id
+          }
+        }
+        """
+        result = self.graphql_query(query, {"experimentId": experiment_id})
+
+        node = result.get("experimentNode")
+        if not node:
+            raise ValueError(f"No node found for experiment ID '{experiment_id}'")
+
+        node_id = node["id"]
+        self._id_cache[cache_key] = node_id
+        return node_id
+
     def create_or_update_experiment(
         self,
         project: str,
@@ -89,26 +168,33 @@ class RemoteClient:
         metadata: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         """
-        Create or update an experiment.
+        Create or update an experiment using unified node API.
 
         Args:
-            project: Project name
-            name: Experiment name (last segment of prefix)
+            project: Project slug
+            name: Experiment name
             description: Optional description
             tags: Optional list of tags
             bindrs: Optional list of bindrs
-            prefix: Full prefix path sent to backend for folder hierarchy creation
+            prefix: Full prefix path (ignored in new API - use folders instead)
             write_protected: If True, experiment becomes immutable
             metadata: Optional metadata dict
 
         Returns:
-            Response dict with experiment, project, and namespace data
+            Response dict with experiment, node, and project data
 
         Raises:
             httpx.HTTPStatusError: If request fails
+            ValueError: If project not found
         """
+        # Resolve project ID from slug
+        project_id = self._get_project_id(project)
+
+        # Build payload for unified node API
         payload = {
+            "type": "EXPERIMENT",
             "name": name,
+            "projectId": project_id,
         }
 
         if description is not None:
@@ -121,15 +207,22 @@ class RemoteClient:
             payload["writeProtected"] = write_protected
         if metadata is not None:
             payload["metadata"] = metadata
-        if prefix is not None:
-            payload["prefix"] = prefix
 
+        # Call unified node creation API
         response = self._client.post(
-            f"/projects/{project}/experiments",
+            f"/namespaces/{self.namespace}/nodes",
             json=payload,
         )
         response.raise_for_status()
-        return response.json()
+        result = response.json()
+
+        # Cache the experiment node ID mapping
+        if "experiment" in result and "node" in result:
+            exp_id = result["experiment"]["id"]
+            node_id = result["node"]["id"]
+            self._id_cache[f"exp_node:{exp_id}"] = node_id
+
+        return result
 
     def update_experiment_status(
         self,
@@ -137,24 +230,27 @@ class RemoteClient:
         status: str,
     ) -> Dict[str, Any]:
         """
-        Update experiment status.
+        Update experiment status using unified node API.
 
         Args:
             experiment_id: Experiment ID
             status: Status value - "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED"
 
         Returns:
-            Response dict with updated experiment data
+            Response dict with updated node data
 
         Raises:
             httpx.HTTPStatusError: If request fails
+            ValueError: If experiment node not found
         """
-        payload = {
-            "status": status,
-        }
+        # Resolve node ID from experiment ID
+        node_id = self._get_experiment_node_id(experiment_id)
+
+        # Update node with new status
+        payload = {"status": status}
 
         response = self._client.patch(
-            f"/experiments/{experiment_id}/status",
+            f"/nodes/{node_id}",
             json=payload,
         )
         response.raise_for_status()
@@ -263,15 +359,17 @@ class RemoteClient:
         metadata: Optional[Dict[str, Any]],
         checksum: str,
         content_type: str,
-        size_bytes: int
+        size_bytes: int,
+        project_id: Optional[str] = None,
+        parent_id: str = "ROOT"
     ) -> Dict[str, Any]:
         """
-        Upload a file to an experiment.
+        Upload a file to an experiment using unified node API.
 
         Args:
             experiment_id: Experiment ID (Snowflake ID)
             file_path: Local file path
-            prefix: Logical path prefix
+            prefix: Logical path prefix (DEPRECATED - use parent_id for folder structure)
             filename: Original filename
             description: Optional description
             tags: Optional tags
@@ -279,23 +377,43 @@ class RemoteClient:
             checksum: SHA256 checksum
             content_type: MIME type
             size_bytes: File size in bytes
+            project_id: Project ID (optional - will be resolved from experiment if not provided)
+            parent_id: Parent node ID (folder) or "ROOT" for root level
 
         Returns:
-            File metadata dict
+            Response dict with node and physicalFile data
 
         Raises:
             httpx.HTTPStatusError: If request fails
         """
+        # If project_id not provided, need to resolve it from experiment
+        # For now, assuming we have it or it will be queried separately
+        if project_id is None:
+            # Query experiment to get project ID
+            query = """
+            query GetExperimentProject($experimentId: ID!) {
+              experimentById(id: $experimentId) {
+                projectId
+              }
+            }
+            """
+            result = self.graphql_query(query, {"experimentId": experiment_id})
+            project_id = result.get("experimentById", {}).get("projectId")
+            if not project_id:
+                raise ValueError(f"Could not resolve project ID for experiment {experiment_id}")
+
         # Prepare multipart form data
-        # Read file content first (httpx needs content, not file handle)
         with open(file_path, "rb") as f:
             file_content = f.read()
 
         files = {"file": (filename, file_content, content_type)}
         data = {
-            "prefix": prefix,
+            "type": "FILE",
+            "projectId": project_id,
+            "experimentId": experiment_id,
+            "parentId": parent_id,
+            "name": filename,
             "checksum": checksum,
-            "sizeBytes": str(size_bytes),
         }
         if description:
             data["description"] = description
@@ -305,15 +423,53 @@ class RemoteClient:
             import json
             data["metadata"] = json.dumps(metadata)
 
-        # httpx will automatically set multipart/form-data content-type
+        # Call unified node creation API
         response = self._client.post(
-            f"/experiments/{experiment_id}/files",
+            f"/namespaces/{self.namespace}/nodes",
             files=files,
             data=data
         )
 
         response.raise_for_status()
-        return response.json()
+        result = response.json()
+
+        # Transform unified node response to expected file metadata format
+        # The server returns {node: {...}, physicalFile: {...}}
+        # We need to flatten it to match the expected format
+        node = result.get("node", {})
+        physical_file = result.get("physicalFile", {})
+
+        # Convert BigInt IDs and sizeBytes from string back to appropriate types
+        # Node ID should remain as string for consistency
+        node_id = node.get("id")
+        if isinstance(node_id, (int, float)):
+            # If it was deserialized as a number, convert to string to preserve full precision
+            node_id = str(int(node_id))
+
+        size_bytes = physical_file.get("sizeBytes")
+        if isinstance(size_bytes, str):
+            size_bytes = int(size_bytes)
+
+        # Use experimentId from node, not the parameter (which might be a path string)
+        experiment_id_from_node = node.get("experimentId")
+        if isinstance(experiment_id_from_node, (int, float)):
+            experiment_id_from_node = str(int(experiment_id_from_node))
+
+        return {
+            "id": node_id,
+            "experimentId": experiment_id_from_node or experiment_id,
+            "path": prefix,  # Use prefix as path for backward compatibility
+            "filename": filename,
+            "description": node.get("description"),
+            "tags": node.get("tags", []),
+            "contentType": physical_file.get("contentType"),
+            "sizeBytes": size_bytes,
+            "checksum": physical_file.get("checksum"),
+            "metadata": node.get("metadata"),
+            "uploadedAt": node.get("createdAt"),
+            "updatedAt": node.get("updatedAt"),
+            "deletedAt": node.get("deletedAt"),
+        }
 
     def list_files(
         self,
@@ -322,48 +478,72 @@ class RemoteClient:
         tags: Optional[List[str]] = None
     ) -> List[Dict[str, Any]]:
         """
-        List files in an experiment.
+        List files in an experiment using GraphQL.
 
         Args:
             experiment_id: Experiment ID (Snowflake ID)
-            prefix: Optional prefix filter
+            prefix: Optional prefix filter (DEPRECATED - filtering not supported in new API)
             tags: Optional tags filter
 
         Returns:
-            List of file metadata dicts
+            List of file node dicts
 
         Raises:
             httpx.HTTPStatusError: If request fails
         """
-        params = {}
-        if prefix:
-            params["prefix"] = prefix
+        query = """
+        query ListExperimentFiles($experimentId: ID!) {
+          experimentById(id: $experimentId) {
+            files {
+              id
+              name
+              description
+              tags
+              metadata
+              createdAt
+              pPath
+              physicalFile {
+                id
+                filename
+                contentType
+                sizeBytes
+                checksum
+                s3Url
+              }
+            }
+          }
+        }
+        """
+        result = self.graphql_query(query, {"experimentId": experiment_id})
+        files = result.get("experimentById", {}).get("files", [])
+
+        # Apply client-side filtering if tags specified
         if tags:
-            params["tags"] = ",".join(tags)
+            filtered_files = []
+            for file in files:
+                file_tags = file.get("tags", [])
+                if any(tag in file_tags for tag in tags):
+                    filtered_files.append(file)
+            return filtered_files
 
-        response = self._client.get(
-            f"/experiments/{experiment_id}/files",
-            params=params
-        )
-        response.raise_for_status()
-        result = response.json()
-        return result.get("files", [])
+        return files
 
     def get_file(self, experiment_id: str, file_id: str) -> Dict[str, Any]:
         """
-        Get file metadata.
+        Get file metadata using unified node API.
 
         Args:
-            experiment_id: Experiment ID (Snowflake ID)
-            file_id: File ID (Snowflake ID)
+            experiment_id: Experiment ID (DEPRECATED - not used in new API)
+            file_id: File node ID (Snowflake ID)
 
         Returns:
-            File metadata dict
+            Node metadata dict
 
         Raises:
             httpx.HTTPStatusError: If request fails
         """
-        response = self._client.get(f"/experiments/{experiment_id}/files/{file_id}")
+        # file_id is actually the node ID in the new system
+        response = self._client.get(f"/nodes/{file_id}")
         response.raise_for_status()
         return response.json()
 
@@ -374,11 +554,11 @@ class RemoteClient:
         dest_path: Optional[str] = None
     ) -> str:
         """
-        Download a file from a experiment.
+        Download a file using unified node API.
 
         Args:
-            experiment_id: Experiment ID (Snowflake ID)
-            file_id: File ID (Snowflake ID)
+            experiment_id: Experiment ID (DEPRECATED - not used in new API)
+            file_id: File node ID (Snowflake ID)
             dest_path: Optional destination path (defaults to original filename)
 
         Returns:
@@ -390,40 +570,39 @@ class RemoteClient:
         """
         # Get file metadata first to get filename and checksum
         file_metadata = self.get_file(experiment_id, file_id)
-        filename = file_metadata["filename"]
-        expected_checksum = file_metadata["checksum"]
+        filename = file_metadata.get("name") or file_metadata.get("physicalFile", {}).get("filename")
+        expected_checksum = file_metadata.get("physicalFile", {}).get("checksum")
 
         # Determine destination path
         if dest_path is None:
             dest_path = filename
 
-        # Download file
-        response = self._client.get(
-            f"/experiments/{experiment_id}/files/{file_id}/download"
-        )
+        # Download file using node API
+        response = self._client.get(f"/nodes/{file_id}/download")
         response.raise_for_status()
 
         # Write to file
         with open(dest_path, "wb") as f:
             f.write(response.content)
 
-        # Verify checksum
-        from .files import verify_checksum
-        if not verify_checksum(dest_path, expected_checksum):
-            # Delete corrupted file
-            import os
-            os.remove(dest_path)
-            raise ValueError(f"Checksum verification failed for file {file_id}")
+        # Verify checksum if available
+        if expected_checksum:
+            from .files import verify_checksum
+            if not verify_checksum(dest_path, expected_checksum):
+                # Delete corrupted file
+                import os
+                os.remove(dest_path)
+                raise ValueError(f"Checksum verification failed for file {file_id}")
 
         return dest_path
 
     def delete_file(self, experiment_id: str, file_id: str) -> Dict[str, Any]:
         """
-        Delete a file (soft delete).
+        Delete a file using unified node API (soft delete).
 
         Args:
-            experiment_id: Experiment ID (Snowflake ID)
-            file_id: File ID (Snowflake ID)
+            experiment_id: Experiment ID (DEPRECATED - not used in new API)
+            file_id: File node ID (Snowflake ID)
 
         Returns:
             Dict with id and deletedAt
@@ -431,7 +610,7 @@ class RemoteClient:
         Raises:
             httpx.HTTPStatusError: If request fails
         """
-        response = self._client.delete(f"/experiments/{experiment_id}/files/{file_id}")
+        response = self._client.delete(f"/nodes/{file_id}")
         response.raise_for_status()
         return response.json()
 
@@ -444,17 +623,17 @@ class RemoteClient:
         metadata: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
-        Update file metadata.
+        Update file metadata using unified node API.
 
         Args:
-            experiment_id: Experiment ID (Snowflake ID)
-            file_id: File ID (Snowflake ID)
+            experiment_id: Experiment ID (DEPRECATED - not used in new API)
+            file_id: File node ID (Snowflake ID)
             description: Optional description
             tags: Optional tags
             metadata: Optional metadata
 
         Returns:
-            Updated file metadata dict
+            Updated node metadata dict
 
         Raises:
             httpx.HTTPStatusError: If request fails
@@ -468,7 +647,7 @@ class RemoteClient:
             payload["metadata"] = metadata
 
         response = self._client.patch(
-            f"/experiments/{experiment_id}/files/{file_id}",
+            f"/nodes/{file_id}",
             json=payload
         )
         response.raise_for_status()
@@ -905,11 +1084,11 @@ class RemoteClient:
         self, experiment_id: str, file_id: str, dest_path: str
     ) -> str:
         """
-        Download a file with streaming for large files.
+        Download a file with streaming for large files using unified node API.
 
         Args:
-            experiment_id: Experiment ID (Snowflake ID)
-            file_id: File ID (Snowflake ID)
+            experiment_id: Experiment ID (DEPRECATED - not used in new API)
+            file_id: File node ID (Snowflake ID)
             dest_path: Destination path to save file
 
         Returns:
@@ -921,22 +1100,23 @@ class RemoteClient:
         """
         # Get metadata first for checksum
         file_metadata = self.get_file(experiment_id, file_id)
-        expected_checksum = file_metadata["checksum"]
+        expected_checksum = file_metadata.get("physicalFile", {}).get("checksum")
 
-        # Stream download
-        with self._client.stream("GET", f"/experiments/{experiment_id}/files/{file_id}/download") as response:
+        # Stream download using node API
+        with self._client.stream("GET", f"/nodes/{file_id}/download") as response:
             response.raise_for_status()
 
             with open(dest_path, "wb") as f:
                 for chunk in response.iter_bytes(chunk_size=8192):
                     f.write(chunk)
 
-        # Verify checksum
-        from .files import verify_checksum
-        if not verify_checksum(dest_path, expected_checksum):
-            import os
-            os.remove(dest_path)
-            raise ValueError(f"Checksum verification failed for file {file_id}")
+        # Verify checksum if available
+        if expected_checksum:
+            from .files import verify_checksum
+            if not verify_checksum(dest_path, expected_checksum):
+                import os
+                os.remove(dest_path)
+                raise ValueError(f"Checksum verification failed for file {file_id}")
 
         return dest_path
 

{ml_dash-0.6.3 → ml_dash-0.6.4}/src/ml_dash/experiment.py

@@ -350,7 +350,7 @@ class Experiment:
       # RemoteClient will auto-load token from ~/.dash/token.enc
       # Use RUN.api_url if dash_url=True (boolean), otherwise use the provided URL
       api_url = RUN.api_url if dash_url is True else dash_url
-      self._client = RemoteClient(base_url=api_url)
+      self._client = RemoteClient(base_url=api_url, namespace=self.owner)
 
     if self.mode in (OperationMode.LOCAL, OperationMode.HYBRID):
       self._storage = LocalStorage(root_path=Path(dash_root))
@@ -703,22 +703,40 @@ class Experiment:
     # Write immediately (no buffering)
     if self._client:
       # Remote mode: send to API (wrapped in array for batch API)
-      self._client.create_log_entries(
-        experiment_id=self._experiment_id,
-        logs=[log_entry],  # Single log in array
-      )
+      try:
+        self._client.create_log_entries(
+          experiment_id=self._experiment_id,
+          logs=[log_entry],  # Single log in array
+        )
+      except Exception as e:
+        # Log warning but don't crash training
+        import warnings
+        warnings.warn(
+          f"Failed to write log to remote server: {e}. Training will continue.",
+          RuntimeWarning,
+          stacklevel=4
+        )
+        # Fall through to local storage if available
 
     if self._storage:
       # Local mode: write to file immediately
-      self._storage.write_log(
-        owner=self.owner,
-        project=self.project,
-        prefix=self._folder_path,
-        message=log_entry["message"],
-        level=log_entry["level"],
-        metadata=log_entry.get("metadata"),
-        timestamp=log_entry["timestamp"],
-      )
+      try:
+        self._storage.write_log(
+          owner=self.owner,
+          project=self.project,
+          prefix=self._folder_path,
+          message=log_entry["message"],
+          level=log_entry["level"],
+          metadata=log_entry.get("metadata"),
+          timestamp=log_entry["timestamp"],
+        )
+      except Exception as e:
+        import warnings
+        warnings.warn(
+          f"Failed to write log to local storage: {e}",
+          RuntimeWarning,
+          stacklevel=4
+        )
 
   def _print_log(
     self, message: str, level: str, metadata: Optional[Dict[str, Any]]
@@ -1139,7 +1157,7 @@ class Experiment:
     description: Optional[str],
     tags: Optional[List[str]],
     metadata: Optional[Dict[str, Any]],
-  ) -> Dict[str, Any]:
+  ) -> Optional[Dict[str, Any]]:
     """
     Internal method to append a single data point to a metric.
 
@@ -1151,33 +1169,54 @@ class Experiment:
         metadata: Optional metadata
 
     Returns:
-        Dict with metricId, index, bufferedDataPoints, chunkSize
+        Dict with metricId, index, bufferedDataPoints, chunkSize or None if all backends fail
     """
     result = None
 
     if self._client:
       # Remote mode: append via API
-      result = self._client.append_to_metric(
-        experiment_id=self._experiment_id,
-        metric_name=name,
-        data=data,
-        description=description,
-        tags=tags,
-        metadata=metadata,
-      )
+      try:
+        result = self._client.append_to_metric(
+          experiment_id=self._experiment_id,
+          metric_name=name,
+          data=data,
+          description=description,
+          tags=tags,
+          metadata=metadata,
+        )
+      except Exception as e:
+        # Log warning but don't crash training
+        import warnings
+        metric_display = f"'{name}'" if name else "unnamed metric"
+        warnings.warn(
+          f"Failed to log {metric_display} to remote server: {e}. "
+          f"Training will continue.",
+          RuntimeWarning,
+          stacklevel=3
+        )
+        # Fall through to local storage if available
 
     if self._storage:
       # Local mode: append to local storage
-      result = self._storage.append_to_metric(
-        owner=self.owner,
-        project=self.project,
-        prefix=self._folder_path,
-        metric_name=name,
-        data=data,
-        description=description,
-        tags=tags,
-        metadata=metadata,
-      )
+      try:
+        result = self._storage.append_to_metric(
+          owner=self.owner,
+          project=self.project,
+          prefix=self._folder_path,
+          metric_name=name,
+          data=data,
+          description=description,
+          tags=tags,
+          metadata=metadata,
+        )
+      except Exception as e:
+        import warnings
+        metric_display = f"'{name}'" if name else "unnamed metric"
+        warnings.warn(
+          f"Failed to log {metric_display} to local storage: {e}",
+          RuntimeWarning,
+          stacklevel=3
+        )
 
     return result
 
@@ -1188,7 +1227,7 @@ class Experiment:
     description: Optional[str],
     tags: Optional[List[str]],
     metadata: Optional[Dict[str, Any]],
-  ) -> Dict[str, Any]:
+  ) -> Optional[Dict[str, Any]]:
     """
     Internal method to append multiple data points to a metric.
 
@@ -1200,33 +1239,54 @@ class Experiment:
         metadata: Optional metadata
 
     Returns:
-        Dict with metricId, startIndex, endIndex, count
+        Dict with metricId, startIndex, endIndex, count or None if all backends fail
     """
     result = None
 
     if self._client:
       # Remote mode: append batch via API
-      result = self._client.append_batch_to_metric(
-        experiment_id=self._experiment_id,
-        metric_name=name,
-        data_points=data_points,
-        description=description,
-        tags=tags,
-        metadata=metadata,
-      )
+      try:
+        result = self._client.append_batch_to_metric(
+          experiment_id=self._experiment_id,
+          metric_name=name,
+          data_points=data_points,
+          description=description,
+          tags=tags,
+          metadata=metadata,
+        )
+      except Exception as e:
+        # Log warning but don't crash training
+        import warnings
+        metric_display = f"'{name}'" if name else "unnamed metric"
+        warnings.warn(
+          f"Failed to log batch to {metric_display} on remote server: {e}. "
+          f"Training will continue.",
+          RuntimeWarning,
+          stacklevel=3
+        )
+        # Fall through to local storage if available
 
     if self._storage:
       # Local mode: append batch to local storage
-      result = self._storage.append_batch_to_metric(
-        owner=self.owner,
-        project=self.project,
-        prefix=self._folder_path,
-        metric_name=name,
-        data_points=data_points,
-        description=description,
-        tags=tags,
-        metadata=metadata,
-      )
+      try:
+        result = self._storage.append_batch_to_metric(
+          owner=self.owner,
+          project=self.project,
+          prefix=self._folder_path,
+          metric_name=name,
+          data_points=data_points,
+          description=description,
+          tags=tags,
+          metadata=metadata,
+        )
+      except Exception as e:
+        import warnings
+        metric_display = f"'{name}'" if name else "unnamed metric"
+        warnings.warn(
+          f"Failed to log batch to {metric_display} in local storage: {e}",
+          RuntimeWarning,
+          stacklevel=3
+        )
 
     return result