ml-dash 0.5.1__py3-none-any.whl → 0.5.3__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/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.
@@ -67,13 +135,14 @@ class Experiment:
         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.
@@ -85,12 +154,12 @@ class Experiment:
             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
@@ -98,7 +167,7 @@ class Experiment:
         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
@@ -171,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
@@ -190,7 +259,7 @@ class Experiment:
                 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
@@ -211,9 +280,9 @@ class Experiment:
         self._is_open = True
         return self
 
-    def close(self, status: str = "COMPLETED"):
+    def _close(self, status: str = "COMPLETED"):
         """
-        Close the experiment and update status.
+        Internal method to close the experiment and update status.
 
         Args:
             status: Status to set - "COMPLETED" (default), "FAILED", or "CANCELLED"
@@ -238,16 +307,52 @@ class Experiment:
 
         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. Sets status to FAILED if exception occurred."""
-        # Determine status based on whether an exception occurred
-        status = "FAILED" if exc_type is not None else "COMPLETED"
-        self.close(status=status)
-        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,
@@ -591,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:
         """
@@ -665,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,
@@ -931,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,186 @@ 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 with desired filename
+        temp_dir = tempfile.mkdtemp()
+        temp_path = os.path.join(temp_dir, file_name)
+        try:
+            # Write JSON content to temp file
+            with open(temp_path, '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 and directory
+            try:
+                os.unlink(temp_path)
+                os.rmdir(temp_dir)
+            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 with desired filename
+        temp_dir = tempfile.mkdtemp()
+        temp_path = os.path.join(temp_dir, file_name)
+
+        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 and directory
+            try:
+                os.unlink(temp_path)
+                os.rmdir(temp_dir)
+            except Exception:
+                pass
+
+    def save_pkl(self, content: Any, file_name: str) -> Dict[str, Any]:
+        """
+        Save Python object to a pickle file.
+
+        Args:
+            content: Python object to pickle (must be pickle-serializable)
+            file_name: Name of the file to create (should end with .pkl or .pickle)
+
+        Returns:
+            File metadata dict with id, path, filename, checksum, etc.
+
+        Raises:
+            RuntimeError: If experiment is not open or write-protected
+            ValueError: If content cannot be pickled
+
+        Examples:
+            data = {"model": "resnet50", "weights": np.array([1, 2, 3])}
+            result = experiment.file(prefix="/data").save_pkl(data, "data.pkl")
+
+            # Or save any Python object
+            result = experiment.file(prefix="/models").save_pkl(trained_model, "model.pickle")
+        """
+        import pickle
+        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 with desired filename
+        temp_dir = tempfile.mkdtemp()
+        temp_path = os.path.join(temp_dir, file_name)
+        try:
+            # Write pickled content to temp file
+            with open(temp_path, 'wb') as f:
+                pickle.dump(content, f)
+
+            # 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 and directory
+            try:
+                os.unlink(temp_path)
+                os.rmdir(temp_dir)
+            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-0.5.1.dist-info → ml_dash-0.5.3.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: ml-dash
-Version: 0.5.1
-Summary: ML experiment metricing and data storage
-Keywords: machine-learning,experiment-metricing,mlops,data-storage
+Version: 0.5.3
+Summary: ML experiment tracking and data storage
+Keywords: machine-learning,experiment-tracking,mlops,data-storage
 Author: Ge Yang, Tom Tao
 License: MIT License
          
@@ -97,7 +97,7 @@ pip install ml-dash
 </tr>
 </table>
 
-## Quick Start
+## Getting Started
 
 ### Remote Mode (with API Server)
 
@@ -107,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.3.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=Nx7f0n9zoQ7XqPtiHu_SBEZK0cT2b3F6-EhJBNs3C6k,15824
+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.3.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
+ml_dash-0.5.3.dist-info/METADATA,sha256=AO80zIp9TG2-3S-zZEPQUOwFBowKCddCfQarQem096M,6043
+ml_dash-0.5.3.dist-info/RECORD,,

ml_dash-0.5.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-ml_dash/__init__.py,sha256=5tT0Lmf0SS3J7BOwJGVai8FOjdpjKGBJCEYL5nXnkLA,1384
-ml_dash/client.py,sha256=vhWcS5o2n3o4apEjVeLmu7flCEzxBbBOoLSQNcAx_ew,17267
-ml_dash/experiment.py,sha256=x1jtQD1QroNjNULOxZiGtX5oFLi3ZXDaFbGHWt0yMJU,28652
-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=UTuux2nfclLrrtlkC6TsOvDB_wIbSDvYGg8Gtbvk6mc,30471
-ml_dash-0.5.1.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
-ml_dash-0.5.1.dist-info/METADATA,sha256=TBTqi4lJNoFO2eyztYJZptQypUSVTDVUdbGS0EnQZ2k,6067
-ml_dash-0.5.1.dist-info/RECORD,,