ml-dash 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

ml_dash/__init__.py

@@ -38,7 +38,7 @@ Usage:
         experiment.log("Training started")
 """
 
-from .experiment import Experiment, ml_dash_experiment, OperationMode
+from .experiment import Experiment, ml_dash_experiment, OperationMode, RunManager
 from .client import RemoteClient
 from .storage import LocalStorage
 from .log import LogLevel, LogBuilder
@@ -50,6 +50,7 @@ __all__ = [
     "Experiment",
     "ml_dash_experiment",
     "OperationMode",
+    "RunManager",
     "RemoteClient",
     "LocalStorage",
     "LogLevel",

ml_dash/auto_start.py

@@ -0,0 +1,42 @@
+"""
+Auto-start module for ML-Dash SDK.
+
+Provides a pre-configured, auto-started experiment singleton named 'dxp'.
+
+Usage:
+    from ml_dash.auto_start import dxp
+
+    # Ready to use immediately - no need to open/start
+    dxp.log("Hello from dxp!")
+    dxp.params.set(lr=0.001)
+    dxp.metrics("loss").append(step=0, value=0.5)
+
+    # Automatically closed on Python exit
+"""
+
+import atexit
+from .experiment import Experiment
+
+# Create pre-configured singleton experiment
+dxp = Experiment(
+    name="dxp",
+    project="scratch",
+    local_path=".ml-dash"
+)
+
+# Auto-start the experiment on import
+dxp.run.start()
+
+# Register cleanup handler to complete experiment on Python exit
+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
+
+atexit.register(_cleanup)
+
+__all__ = ["dxp"]

ml_dash/client.py

@@ -35,6 +35,7 @@ class RemoteClient:
         name: str,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        bindrs: Optional[List[str]] = None,
         folder: Optional[str] = None,
         write_protected: bool = False,
         metadata: Optional[Dict[str, Any]] = None,
@@ -47,6 +48,7 @@ class RemoteClient:
             name: Experiment name
             description: Optional description
             tags: Optional list of tags
+            bindrs: Optional list of bindrs
             folder: Optional folder path
             write_protected: If True, experiment becomes immutable
             metadata: Optional metadata dict
@@ -65,6 +67,8 @@ class RemoteClient:
             payload["description"] = description
         if tags is not None:
             payload["tags"] = tags
+        if bindrs is not None:
+            payload["bindrs"] = bindrs
         if folder is not None:
             payload["folder"] = folder
         if write_protected:
@@ -79,6 +83,35 @@ class RemoteClient:
         response.raise_for_status()
         return response.json()
 
+    def update_experiment_status(
+        self,
+        experiment_id: str,
+        status: str,
+    ) -> Dict[str, Any]:
+        """
+        Update experiment status.
+
+        Args:
+            experiment_id: Experiment ID
+            status: Status value - "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED"
+
+        Returns:
+            Response dict with updated experiment data
+
+        Raises:
+            httpx.HTTPStatusError: If request fails
+        """
+        payload = {
+            "status": status,
+        }
+
+        response = self._client.patch(
+            f"/experiments/{experiment_id}/status",
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
     def create_log_entries(
         self,
         experiment_id: str,

ml_dash/experiment.py

@@ -27,6 +27,74 @@ class OperationMode(Enum):
     HYBRID = "hybrid"  # Future: sync local to remote
 
 
+class RunManager:
+    """
+    Lifecycle manager for experiments.
+
+    Supports three usage patterns:
+    1. Method calls: experiment.run.start(), experiment.run.complete()
+    2. Context manager: with Experiment(...).run as exp:
+    3. Decorator: @exp.run or @Experiment(...).run
+    """
+
+    def __init__(self, experiment: "Experiment"):
+        """
+        Initialize RunManager.
+
+        Args:
+            experiment: Parent Experiment instance
+        """
+        self._experiment = experiment
+
+    def start(self) -> "Experiment":
+        """
+        Start the experiment (sets status to RUNNING).
+
+        Returns:
+            The experiment instance for chaining
+        """
+        return self._experiment._open()
+
+    def complete(self) -> None:
+        """Mark experiment as completed (status: COMPLETED)."""
+        self._experiment._close(status="COMPLETED")
+
+    def fail(self) -> None:
+        """Mark experiment as failed (status: FAILED)."""
+        self._experiment._close(status="FAILED")
+
+    def cancel(self) -> None:
+        """Mark experiment as cancelled (status: CANCELLED)."""
+        self._experiment._close(status="CANCELLED")
+
+    def __enter__(self) -> "Experiment":
+        """Context manager entry - starts the experiment."""
+        return self.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - completes or fails the experiment."""
+        if exc_type is not None:
+            self.fail()
+        else:
+            self.complete()
+        return False
+
+    def __call__(self, func: Callable) -> Callable:
+        """
+        Decorator support for wrapping functions with experiment lifecycle.
+
+        Usage:
+            @exp.run
+            def train(exp):
+                exp.log("Training...")
+        """
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with self as exp:
+                return func(exp, *args, **kwargs)
+        return wrapper
+
+
 class Experiment:
     """
     ML-Dash experiment for metricing experiments.
@@ -65,14 +133,16 @@ class Experiment:
         *,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        bindrs: Optional[List[str]] = None,
         folder: Optional[str] = None,
-        write_protected: bool = False,
         metadata: Optional[Dict[str, Any]] = None,
         # Mode configuration
         remote: Optional[str] = None,
         api_key: Optional[str] = None,
         user_name: Optional[str] = None,
         local_path: Optional[str] = None,
+        # Internal parameters
+        _write_protected: bool = False,
     ):
         """
         Initialize an ML-Dash experiment.
@@ -82,20 +152,22 @@ class Experiment:
             project: Project name
             description: Optional experiment description
             tags: Optional list of tags
+            bindrs: Optional list of bindrs
             folder: Optional folder path (e.g., "/experiments/baseline")
-            write_protected: If True, experiment becomes immutable after creation
             metadata: Optional metadata dict
             remote: Remote API URL (e.g., "http://localhost:3000")
             api_key: JWT token for authentication (if not provided, will be generated from user_name)
             user_name: Username for authentication (generates API key if api_key not provided)
             local_path: Local storage root path (for local mode)
+            _write_protected: Internal parameter - if True, experiment becomes immutable after creation
         """
         self.name = name
         self.project = project
         self.description = description
         self.tags = tags
+        self.bindrs = bindrs
         self.folder = folder
-        self.write_protected = write_protected
+        self._write_protected = _write_protected
         self.metadata = metadata
 
         # Generate API key from username if not provided
@@ -168,9 +240,9 @@ class Experiment:
 
         return token
 
-    def open(self) -> "Experiment":
+    def _open(self) -> "Experiment":
         """
-        Open the experiment (create or update on server/filesystem).
+        Internal method to open the experiment (create or update on server/filesystem).
 
         Returns:
             self for chaining
@@ -185,8 +257,9 @@ class Experiment:
                 name=self.name,
                 description=self.description,
                 tags=self.tags,
+                bindrs=self.bindrs,
                 folder=self.folder,
-                write_protected=self.write_protected,
+                write_protected=self._write_protected,
                 metadata=self.metadata,
             )
             self._experiment_data = response
@@ -199,6 +272,7 @@ class Experiment:
                 name=self.name,
                 description=self.description,
                 tags=self.tags,
+                bindrs=self.bindrs,
                 folder=self.folder,
                 metadata=self.metadata,
             )
@@ -206,8 +280,13 @@ class Experiment:
         self._is_open = True
         return self
 
-    def close(self):
-        """Close the experiment."""
+    def _close(self, status: str = "COMPLETED"):
+        """
+        Internal method to close the experiment and update status.
+
+        Args:
+            status: Status to set - "COMPLETED" (default), "FAILED", or "CANCELLED"
+        """
         if not self._is_open:
             return
 
@@ -215,16 +294,65 @@ class Experiment:
         if self._storage:
             self._storage.flush()
 
+        # Update experiment status in remote mode
+        if self._client and self._experiment_id:
+            try:
+                self._client.update_experiment_status(
+                    experiment_id=self._experiment_id,
+                    status=status
+                )
+            except Exception as e:
+                # Log error but don't fail the close operation
+                print(f"Warning: Failed to update experiment status: {e}")
+
         self._is_open = False
 
-    def __enter__(self) -> "Experiment":
-        """Context manager entry."""
-        return self.open()
+    @property
+    def run(self) -> RunManager:
+        """
+        Get the RunManager for lifecycle operations.
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        self.close()
-        return False
+        Usage:
+            # Method calls
+            experiment.run.start()
+            experiment.run.complete()
+
+            # Context manager
+            with Experiment(...).run as exp:
+                exp.log("Training...")
+
+            # Decorator
+            @experiment.run
+            def train(exp):
+                exp.log("Training...")
+
+        Returns:
+            RunManager instance
+        """
+        return RunManager(self)
+
+    @property
+    def params(self) -> ParametersBuilder:
+        """
+        Get a ParametersBuilder for parameter operations.
+
+        Usage:
+            # Set parameters
+            experiment.params.set(lr=0.001, batch_size=32)
+
+            # Get parameters
+            params = experiment.params.get()
+
+        Returns:
+            ParametersBuilder instance
+
+        Raises:
+            RuntimeError: If experiment is not open
+        """
+        if not self._is_open:
+            raise RuntimeError("Experiment not open. Use experiment.run.start() or context manager.")
+
+        return ParametersBuilder(self)
 
     def log(
         self,
@@ -568,31 +696,6 @@ class Experiment:
 
         return result
 
-    def parameters(self) -> ParametersBuilder:
-        """
-        Get a ParametersBuilder for fluent parameter operations.
-
-        Returns:
-            ParametersBuilder instance for chaining
-
-        Raises:
-            RuntimeError: If experiment is not open
-
-        Examples:
-            # Set parameters
-            experiment.parameters().set(
-                model={"lr": 0.001, "batch_size": 32},
-                optimizer="adam"
-            )
-
-            # Get parameters
-            params = experiment.parameters().get()  # Flattened
-            params = experiment.parameters().get(flatten=False)  # Nested
-        """
-        if not self._is_open:
-            raise RuntimeError("Experiment not open. Use experiment.open() or context manager.")
-
-        return ParametersBuilder(self)
 
     def _write_params(self, flattened_params: Dict[str, Any]) -> None:
         """
@@ -642,48 +745,49 @@ class Experiment:
 
         return params
 
-    def metric(self, name: str, description: Optional[str] = None,
-              tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None) -> 'MetricBuilder':
+    @property
+    def metrics(self) -> 'MetricsManager':
         """
-        Get a MetricBuilder for fluent metric operations.
+        Get a MetricsManager for metric operations.
 
-        Args:
-            name: Metric name (unique within experiment)
-            description: Optional metric description
-            tags: Optional tags for categorization
-            metadata: Optional structured metadata
+        Supports two usage patterns:
+        1. Named: experiment.metrics("loss").append(value=0.5, step=1)
+        2. Unnamed: experiment.metrics.append(name="loss", value=0.5, step=1)
 
         Returns:
-            MetricBuilder instance for chaining
+            MetricsManager instance
 
         Raises:
             RuntimeError: If experiment is not open
 
         Examples:
-            # Append single data point
-            experiment.metric(name="train_loss").append(value=0.5, step=100)
+            # Named metric
+            experiment.metrics("train_loss").append(value=0.5, step=100)
+
+            # Unnamed (name in append call)
+            experiment.metrics.append(name="train_loss", value=0.5, step=100)
 
             # Append batch
-            experiment.metric(name="metrics").append_batch([
+            experiment.metrics("metrics").append_batch([
                 {"loss": 0.5, "acc": 0.8, "step": 1},
                 {"loss": 0.4, "acc": 0.85, "step": 2}
             ])
 
             # Read data
-            data = experiment.metric(name="train_loss").read(start_index=0, limit=100)
+            data = experiment.metrics("train_loss").read(start_index=0, limit=100)
 
             # Get statistics
-            stats = experiment.metric(name="train_loss").stats()
+            stats = experiment.metrics("train_loss").stats()
         """
-        from .metric import MetricBuilder
+        from .metric import MetricsManager
 
         if not self._is_open:
             raise RuntimeError(
-                "Cannot use metric on closed experiment. "
-                "Use 'with Experiment(...) as experiment:' or call experiment.open() first."
+                "Cannot use metrics on closed experiment. "
+                "Use 'with Experiment(...).run as experiment:' or call experiment.run.start() first."
             )
 
-        return MetricBuilder(self, name, description, tags, metadata)
+        return MetricsManager(self)
 
     def _append_to_metric(
         self,
@@ -908,7 +1012,7 @@ def ml_dash_experiment(
     def decorator(func: Callable) -> Callable:
         @functools.wraps(func)
         def wrapper(*args, **func_kwargs):
-            with Experiment(name=name, project=project, **kwargs) as experiment:
+            with Experiment(name=name, project=project, **kwargs).run as experiment:
                 # Inject experiment into function kwargs
                 func_kwargs['experiment'] = experiment
                 return func(*args, **func_kwargs)

ml_dash/files.py

@@ -44,6 +44,7 @@ class FileBuilder:
                 - prefix: Logical path prefix (default: "/")
                 - description: Optional description
                 - tags: Optional list of tags
+                - bindrs: Optional list of bindrs
                 - metadata: Optional metadata dict
                 - file_id: File ID for download/delete/update operations
                 - dest_path: Destination path for download
@@ -53,6 +54,7 @@ class FileBuilder:
         self._prefix = kwargs.get('prefix', '/')
         self._description = kwargs.get('description')
         self._tags = kwargs.get('tags', [])
+        self._bindrs = kwargs.get('bindrs', [])
         self._metadata = kwargs.get('metadata')
         self._file_id = kwargs.get('file_id')
         self._dest_path = kwargs.get('dest_path')
@@ -76,7 +78,7 @@ class FileBuilder:
         if not self._experiment._is_open:
             raise RuntimeError("Experiment not open. Use experiment.open() or context manager.")
 
-        if self._experiment.write_protected:
+        if self._experiment._write_protected:
             raise RuntimeError("Experiment is write-protected and cannot be modified.")
 
         if not self._file_path:
@@ -189,7 +191,7 @@ class FileBuilder:
         if not self._experiment._is_open:
             raise RuntimeError("Experiment not open. Use experiment.open() or context manager.")
 
-        if self._experiment.write_protected:
+        if self._experiment._write_protected:
             raise RuntimeError("Experiment is write-protected and cannot be modified.")
 
         if not self._file_id:
@@ -219,7 +221,7 @@ class FileBuilder:
         if not self._experiment._is_open:
             raise RuntimeError("Experiment not open. Use experiment.open() or context manager.")
 
-        if self._experiment.write_protected:
+        if self._experiment._write_protected:
             raise RuntimeError("Experiment is write-protected and cannot be modified.")
 
         if not self._file_id:
@@ -232,6 +234,124 @@ class FileBuilder:
             metadata=self._metadata
         )
 
+    def save_json(self, content: Any, file_name: str) -> Dict[str, Any]:
+        """
+        Save JSON content to a file.
+
+        Args:
+            content: Content to save as JSON (dict, list, or any JSON-serializable object)
+            file_name: Name of the file to create
+
+        Returns:
+            File metadata dict with id, path, filename, checksum, etc.
+
+        Raises:
+            RuntimeError: If experiment is not open or write-protected
+            ValueError: If content is not JSON-serializable
+
+        Examples:
+            config = {"model": "resnet50", "lr": 0.001}
+            result = experiment.file(prefix="/configs").save_json(config, "config.json")
+        """
+        import json
+        import tempfile
+        import os
+
+        if not self._experiment._is_open:
+            raise RuntimeError("Experiment not open. Use experiment.run.start() or context manager.")
+
+        if self._experiment._write_protected:
+            raise RuntimeError("Experiment is write-protected and cannot be modified.")
+
+        # Create temporary file
+        temp_fd, temp_path = tempfile.mkstemp(suffix='.json', text=True)
+        try:
+            # Write JSON content to temp file
+            with os.fdopen(temp_fd, 'w') as f:
+                json.dump(content, f, indent=2)
+
+            # Save using existing save() method
+            original_file_path = self._file_path
+            self._file_path = temp_path
+
+            # Upload and get result
+            result = self.save()
+
+            # Restore original file_path
+            self._file_path = original_file_path
+
+            return result
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(temp_path)
+            except Exception:
+                pass
+
+    def save_torch(self, model: Any, file_name: str) -> Dict[str, Any]:
+        """
+        Save PyTorch model to a file.
+
+        Args:
+            model: PyTorch model or state dict to save
+            file_name: Name of the file to create (should end with .pt or .pth)
+
+        Returns:
+            File metadata dict with id, path, filename, checksum, etc.
+
+        Raises:
+            RuntimeError: If experiment is not open or write-protected
+            ImportError: If torch is not installed
+            ValueError: If model cannot be saved
+
+        Examples:
+            import torch
+            model = torch.nn.Linear(10, 5)
+            result = experiment.file(prefix="/models").save_torch(model, "model.pt")
+
+            # Or save state dict
+            result = experiment.file(prefix="/models").save_torch(model.state_dict(), "model.pth")
+        """
+        import tempfile
+        import os
+
+        try:
+            import torch
+        except ImportError:
+            raise ImportError("PyTorch is not installed. Install it with: pip install torch")
+
+        if not self._experiment._is_open:
+            raise RuntimeError("Experiment not open. Use experiment.run.start() or context manager.")
+
+        if self._experiment._write_protected:
+            raise RuntimeError("Experiment is write-protected and cannot be modified.")
+
+        # Create temporary file
+        temp_fd, temp_path = tempfile.mkstemp(suffix='.pt')
+        os.close(temp_fd)  # Close the file descriptor
+
+        try:
+            # Save model to temp file
+            torch.save(model, temp_path)
+
+            # Save using existing save() method
+            original_file_path = self._file_path
+            self._file_path = temp_path
+
+            # Upload and get result
+            result = self.save()
+
+            # Restore original file_path
+            self._file_path = original_file_path
+
+            return result
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(temp_path)
+            except Exception:
+                pass
+
 
 def compute_sha256(file_path: str) -> str:
     """

ml_dash/metric.py

@@ -11,6 +11,99 @@ if TYPE_CHECKING:
     from .experiment import Experiment
 
 
+class MetricsManager:
+    """
+    Manager for metric operations that supports both named and unnamed usage.
+
+    Supports two usage patterns:
+    1. Named: experiment.metrics("loss").append(value=0.5, step=1)
+    2. Unnamed: experiment.metrics.append(name="loss", value=0.5, step=1)
+
+    Usage:
+        # With explicit metric name
+        experiment.metrics("train_loss").append(value=0.5, step=100)
+
+        # Without specifying name upfront (name in append call)
+        experiment.metrics.append(name="train_loss", value=0.5, step=100)
+    """
+
+    def __init__(self, experiment: 'Experiment'):
+        """
+        Initialize MetricsManager.
+
+        Args:
+            experiment: Parent Experiment instance
+        """
+        self._experiment = experiment
+
+    def __call__(self, name: str, description: Optional[str] = None,
+                 tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None) -> 'MetricBuilder':
+        """
+        Get a MetricBuilder for a specific metric name.
+
+        Args:
+            name: Metric name (unique within experiment)
+            description: Optional metric description
+            tags: Optional tags for categorization
+            metadata: Optional structured metadata
+
+        Returns:
+            MetricBuilder instance for the named metric
+
+        Examples:
+            experiment.metrics("loss").append(value=0.5, step=1)
+        """
+        return MetricBuilder(self._experiment, name, description, tags, metadata)
+
+    def append(self, name: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """
+        Append a data point to a metric (name specified in call).
+
+        Args:
+            name: Metric name
+            data: Data dict (alternative to kwargs)
+            **kwargs: Data as keyword arguments
+
+        Returns:
+            Response dict with metric metadata
+
+        Examples:
+            experiment.metrics.append(name="loss", value=0.5, step=1)
+            experiment.metrics.append(name="loss", data={"value": 0.5, "step": 1})
+        """
+        if data is None:
+            data = kwargs
+        return self._experiment._append_to_metric(name, data, None, None, None)
+
+    def append_batch(self, name: str, data_points: List[Dict[str, Any]],
+                     description: Optional[str] = None,
+                     tags: Optional[List[str]] = None,
+                     metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Append multiple data points to a metric.
+
+        Args:
+            name: Metric name
+            data_points: List of data point dicts
+            description: Optional metric description
+            tags: Optional tags for categorization
+            metadata: Optional structured metadata
+
+        Returns:
+            Response dict with metric metadata
+
+        Examples:
+            experiment.metrics.append_batch(
+                name="loss",
+                data_points=[
+                    {"value": 0.5, "step": 1},
+                    {"value": 0.4, "step": 2}
+                ]
+            )
+        """
+        return self._experiment._append_batch_to_metric(name, data_points, description, tags, metadata)
+
+
 class MetricBuilder:
     """
     Builder for metric operations.

ml_dash/params.py

@@ -62,9 +62,9 @@ class ParametersBuilder:
             experiment.parameters().set(**{"model.lr": 0.001, "model.batch_size": 32})
         """
         if not self._experiment._is_open:
-            raise RuntimeError("Experiment not open. Use experiment.open() or context manager.")
+            raise RuntimeError("Experiment not open. Use experiment.run.start() or context manager.")
 
-        if self._experiment.write_protected:
+        if self._experiment._write_protected:
             raise RuntimeError("Experiment is write-protected and cannot be modified.")
 
         # Flatten the kwargs

ml_dash/storage.py

@@ -43,6 +43,7 @@ class LocalStorage:
         name: str,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        bindrs: Optional[List[str]] = None,
         folder: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
     ) -> Path:
@@ -54,6 +55,7 @@ class LocalStorage:
             name: Experiment name
             description: Optional description
             tags: Optional tags
+            bindrs: Optional bindrs
             folder: Optional folder path (used for organization)
             metadata: Optional metadata
 
@@ -79,6 +81,7 @@ class LocalStorage:
             "project": project,
             "description": description,
             "tags": tags or [],
+            "bindrs": bindrs or [],
             "folder": folder,
             "metadata": metadata,
             "created_at": datetime.utcnow().isoformat() + "Z",
@@ -99,6 +102,8 @@ class LocalStorage:
                 existing["description"] = description
             if tags is not None:
                 existing["tags"] = tags
+            if bindrs is not None:
+                existing["bindrs"] = bindrs
             if folder is not None:
                 existing["folder"] = folder
             if metadata is not None:
@@ -288,7 +293,7 @@ class LocalStorage:
         """
         Write file to local storage.
 
-        Copies file to: files/<file_id>/<filename>
+        Copies file to: files/<prefix>/<file_id>/<filename>
         Updates .files_metadata.json with file metadata
 
         Args:
@@ -317,8 +322,14 @@ class LocalStorage:
         # Generate Snowflake ID for file
         file_id = generate_snowflake_id()
 
-        # Create file directory
-        file_dir = files_dir / file_id
+        # Normalize prefix (remove leading slashes to avoid absolute paths)
+        normalized_prefix = prefix.lstrip("/") if prefix else ""
+
+        # Create prefix directory, then file directory
+        prefix_dir = files_dir / normalized_prefix if normalized_prefix else files_dir
+        prefix_dir.mkdir(parents=True, exist_ok=True)
+
+        file_dir = prefix_dir / file_id
         file_dir.mkdir(parents=True, exist_ok=True)
 
         # Copy file
@@ -363,7 +374,11 @@ class LocalStorage:
         if existing_index is not None:
             # Overwrite: remove old file and update metadata
             old_file = files_metadata["files"][existing_index]
-            old_file_dir = files_dir / old_file["id"]
+            old_prefix = old_file["path"].lstrip("/") if old_file["path"] else ""
+            if old_prefix:
+                old_file_dir = files_dir / old_prefix / old_file["id"]
+            else:
+                old_file_dir = files_dir / old_file["id"]
             if old_file_dir.exists():
                 shutil.rmtree(old_file_dir)
             files_metadata["files"][existing_index] = file_metadata
@@ -470,7 +485,11 @@ class LocalStorage:
             raise FileNotFoundError(f"File {file_id} not found")
 
         # Get source file
-        source_file = files_dir / file_id / file_metadata["filename"]
+        file_prefix = file_metadata["path"].lstrip("/") if file_metadata["path"] else ""
+        if file_prefix:
+            source_file = files_dir / file_prefix / file_id / file_metadata["filename"]
+        else:
+            source_file = files_dir / file_id / file_metadata["filename"]
         if not source_file.exists():
             raise FileNotFoundError(f"File {file_id} not found on disk")
 

{ml_dash-0.5.0.dist-info → ml_dash-0.5.2.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: ml-dash
-Version: 0.5.0
-Summary: ML experiment metricing and data storage
-Keywords: machine-learning,experiment-metricing,mlops,data-storage
+Version: 0.5.2
+Summary: ML experiment tracking and data storage
+Keywords: machine-learning,experiment-tracking,mlops,data-storage
 Author: Ge Yang, Tom Tao
 License: MIT License
          
@@ -67,6 +67,9 @@ A simple and flexible SDK for ML experiment metricing and data storage.
 - **Dual Operation Modes**: Remote (API server) or local (filesystem)
 - **Auto-creation**: Automatically creates namespace, project, and folder hierarchy
 - **Upsert Behavior**: Updates existing experiments or creates new ones
+- **Experiment Lifecycle**: Automatic status tracking (RUNNING, COMPLETED, FAILED, CANCELLED)
+- **Organized File Storage**: Prefix-based file organization with unique snowflake IDs
+- **Rich Metadata**: Tags, bindrs, descriptions, and custom metadata support
 - **Simple API**: Minimal configuration, maximum flexibility
 
 ## Installation
@@ -94,7 +97,7 @@ pip install ml-dash
 </tr>
 </table>
 
-## Quick Start
+## Getting Started
 
 ### Remote Mode (with API Server)
 
@@ -104,7 +107,7 @@ from ml_dash import Experiment
 with Experiment(
     name="my-experiment",
     project="my-project",
-    remote="https://cu3thurmv3.us-east-1.awsapprunner.com",
+    remote="https://api.dash.ml",
     api_key="your-jwt-token"
 ) as experiment:
     print(f"Experiment ID: {experiment.id}")

ml_dash-0.5.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+ml_dash/__init__.py,sha256=o_LrWVJBY_VkUGhSBs5wdb_NqEsHD1AK9HGsjZGxHxQ,1414
+ml_dash/auto_start.py,sha256=c3XcXFpZdvjtWauEoK5043Gw9k0L_5IDq4fdiB2ha88,959
+ml_dash/client.py,sha256=vhWcS5o2n3o4apEjVeLmu7flCEzxBbBOoLSQNcAx_ew,17267
+ml_dash/experiment.py,sha256=zdGB3oZsFNFyg9olRazWk7dTO7tfy-vTa4neFq5i2CY,30552
+ml_dash/files.py,sha256=FZGHqf5VZ6Hgrpbng-AwTZyw04-Zof252YSjF6nRWX8,13667
+ml_dash/log.py,sha256=0yXaNnFwYeBI3tRLHX3kkqWRpg0MbSGwmgjnOfsElCk,5350
+ml_dash/metric.py,sha256=LMb6-T08VAl6UBAv6FlZee6LleVLjFaBNc19b17NlfI,9662
+ml_dash/params.py,sha256=xaByDSVar4D1pZqxTANkMPeZTL5-V7ewJe5TXfPLhMQ,5980
+ml_dash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ml_dash/storage.py,sha256=UTuux2nfclLrrtlkC6TsOvDB_wIbSDvYGg8Gtbvk6mc,30471
+ml_dash-0.5.2.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
+ml_dash-0.5.2.dist-info/METADATA,sha256=ZbZgasRMgq0iQ5VqPGbySV-pm9HJJlDNU8g4Zs6nFiM,6043
+ml_dash-0.5.2.dist-info/RECORD,,

ml_dash-0.5.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-ml_dash/__init__.py,sha256=5tT0Lmf0SS3J7BOwJGVai8FOjdpjKGBJCEYL5nXnkLA,1384
-ml_dash/client.py,sha256=1T85L-YOCVRakzZlKCKaW6-kSDpo8gx_pdG8wvvi9Tc,16391
-ml_dash/experiment.py,sha256=MKQsEs1MQ07xbPHvWRvatyvLOXuiDKxJx7QWPfpmygM,27658
-ml_dash/files.py,sha256=WKWbcug6XADwZruYQio1EdSstmfTsty9-2-t2KPWz38,9719
-ml_dash/log.py,sha256=0yXaNnFwYeBI3tRLHX3kkqWRpg0MbSGwmgjnOfsElCk,5350
-ml_dash/metric.py,sha256=PcEd6_HTLDpf-kBIDeQq2LlTRAS7xDx6EvSBpin5iuY,6456
-ml_dash/params.py,sha256=W-JkY1Mz7KdmvDjQ0HFV2QnpBov7Gf4dl70fuBnXTdo,5974
-ml_dash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ml_dash/storage.py,sha256=iVGPgRJnsUzxfTh12QCUKyPC-SiK4QNDWHsUBLxP0I0,29538
-ml_dash-0.5.0.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
-ml_dash-0.5.0.dist-info/METADATA,sha256=j1GGNmDvmp8REzN8AIsdiLRimiZqPz7OuEpAhf71Kys,5809
-ml_dash-0.5.0.dist-info/RECORD,,