ml-dash 0.6.13__py3-none-any.whl → 0.6.15__py3-none-any.whl

ml_dash/__init__.py

@@ -43,11 +43,11 @@ from .params import ParametersBuilder
 from .run import RUN
 from .storage import LocalStorage
 
-__version__ = "0.6.13"
+__version__ = "0.6.14"
 
 # Required version - MUST match exactly (blocks all older versions)
 # Update this with EVERY release to force users to upgrade
-REQUIRED_VERSION = "0.6.13"
+REQUIRED_VERSION = "0.6.14"
 
 
 def _check_version_compatibility():

ml_dash/buffer.py

@@ -57,6 +57,11 @@ def _serialize_value(value: Any) -> Any:
 class BufferConfig:
     """Configuration for buffering behavior."""
 
+    # Internal constants for queue management (not exposed to users)
+    _MAX_QUEUE_SIZE = 100000  # Maximum items before blocking
+    _WARNING_THRESHOLD = 80000  # Warn at 80% capacity
+    _AGGRESSIVE_FLUSH_THRESHOLD = 50000  # Trigger immediate flush at 50% capacity
+
     def __init__(
         self,
         flush_interval: float = 5.0,
@@ -114,17 +119,20 @@ class BackgroundBufferManager:
         self._experiment = experiment
         self._config = config
 
-        # Resource-specific queues
-        self._log_queue: Queue = Queue()
+        # Resource-specific queues with bounded size to prevent OOM
+        self._log_queue: Queue = Queue(maxsize=config._MAX_QUEUE_SIZE)
         self._metric_queues: Dict[Optional[str], Queue] = {}  # Per-metric queues
         self._track_buffers: Dict[str, Dict[float, Dict[str, Any]]] = {}  # Per-topic: {timestamp: merged_data}
-        self._file_queue: Queue = Queue()
+        self._file_queue: Queue = Queue(maxsize=config._MAX_QUEUE_SIZE)
 
         # Track last flush times per resource type
         self._last_log_flush = time.time()
         self._last_metric_flush: Dict[Optional[str], float] = {}
         self._last_track_flush: Dict[str, float] = {}  # Per-topic flush times
 
+        # Track warnings to avoid spamming
+        self._warned_queues: set = set()
+
         # Background thread control
         self._thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
@@ -184,6 +192,34 @@ class BackgroundBufferManager:
 
         self._thread = None
 
+    def _check_queue_pressure(self, queue: Queue, queue_name: str) -> None:
+        """
+        Check queue size and trigger aggressive flushing if needed.
+
+        This prevents OOM by flushing immediately when queue fills up.
+
+        Args:
+            queue: The queue to check
+            queue_name: Name for warning messages
+        """
+        qsize = queue.qsize()
+
+        # Trigger immediate flush if queue is getting full
+        if qsize >= self._config._AGGRESSIVE_FLUSH_THRESHOLD:
+            self._flush_event.set()
+
+        # Warn once if queue is filling up (80% capacity)
+        if qsize >= self._config._WARNING_THRESHOLD:
+            if queue_name not in self._warned_queues:
+                warnings.warn(
+                    f"[ML-Dash] {queue_name} queue is {qsize}/{self._config._MAX_QUEUE_SIZE} full. "
+                    f"Data is being generated faster than it can be flushed. "
+                    f"Consider reducing logging frequency or the background flush will block to prevent OOM.",
+                    RuntimeWarning,
+                    stacklevel=3
+                )
+                self._warned_queues.add(queue_name)
+
     def buffer_log(
         self,
         message: str,
@@ -192,7 +228,10 @@ class BackgroundBufferManager:
         timestamp: Optional[datetime],
     ) -> None:
         """
-        Add log to buffer (non-blocking).
+        Add log to buffer with automatic backpressure.
+
+        If queue is full, this will block until space is available.
+        This prevents OOM when logs are generated faster than they can be flushed.
 
         Args:
             message: Log message
@@ -200,6 +239,9 @@ class BackgroundBufferManager:
             metadata: Optional metadata
             timestamp: Optional timestamp
         """
+        # Check queue pressure and trigger aggressive flushing if needed
+        self._check_queue_pressure(self._log_queue, "Log")
+
         log_entry = {
             "timestamp": (timestamp or datetime.utcnow()).isoformat() + "Z",
             "level": level,
@@ -209,6 +251,7 @@ class BackgroundBufferManager:
         if metadata:
             log_entry["metadata"] = metadata
 
+        # Will block if queue is full (backpressure to prevent OOM)
         self._log_queue.put(log_entry)
 
     def buffer_metric(
@@ -220,7 +263,10 @@ class BackgroundBufferManager:
         metadata: Optional[Dict[str, Any]],
     ) -> None:
         """
-        Add metric datapoint to buffer (non-blocking).
+        Add metric datapoint to buffer with automatic backpressure.
+
+        If queue is full, this will block until space is available.
+        This prevents OOM when metrics are generated faster than they can be flushed.
 
         Args:
             metric_name: Metric name (can be None for unnamed metrics)
@@ -229,11 +275,18 @@ class BackgroundBufferManager:
             tags: Optional tags
             metadata: Optional metadata
         """
-        # Get or create queue for this metric
+        # Get or create queue for this metric (with bounded size)
         if metric_name not in self._metric_queues:
-            self._metric_queues[metric_name] = Queue()
+            self._metric_queues[metric_name] = Queue(maxsize=self._config._MAX_QUEUE_SIZE)
             self._last_metric_flush[metric_name] = time.time()
 
+        # Check queue pressure and trigger aggressive flushing if needed
+        metric_display = f"'{metric_name}'" if metric_name else "unnamed"
+        self._check_queue_pressure(
+            self._metric_queues[metric_name],
+            f"Metric {metric_display}"
+        )
+
         metric_entry = {
             "data": data,
             "description": description,
@@ -241,6 +294,7 @@ class BackgroundBufferManager:
             "metadata": metadata,
         }
 
+        # Will block if queue is full (backpressure to prevent OOM)
         self._metric_queues[metric_name].put(metric_entry)
 
     def buffer_track(
@@ -286,7 +340,9 @@ class BackgroundBufferManager:
         size_bytes: int,
     ) -> None:
         """
-        Add file upload to queue (non-blocking).
+        Add file upload to queue with automatic backpressure.
+
+        If queue is full, this will block until space is available.
 
         Args:
             file_path: Local file path
@@ -299,6 +355,9 @@ class BackgroundBufferManager:
             content_type: MIME type
             size_bytes: File size in bytes
         """
+        # Check queue pressure and trigger aggressive flushing if needed
+        self._check_queue_pressure(self._file_queue, "File")
+
         file_entry = {
             "file_path": file_path,
             "prefix": prefix,
@@ -311,6 +370,7 @@ class BackgroundBufferManager:
             "size_bytes": size_bytes,
         }
 
+        # Will block if queue is full (backpressure to prevent OOM)
         self._file_queue.put(file_entry)
 
     def flush_all(self) -> None:
@@ -425,13 +485,73 @@ class BackgroundBufferManager:
             if triggered:
                 self._flush_event.clear()
 
-        # Final flush on shutdown
-        self._flush_logs()
+        # Final flush on shutdown - loop until all queues are empty
+        # This ensures no data is lost when shutting down with large queues
+        # Show progress bar for large flushes
+        initial_counts = {
+            'logs': self._log_queue.qsize(),
+            'metrics': {name: q.qsize() for name, q in self._metric_queues.items()},
+            'tracks': {topic: len(entries) for topic, entries in self._track_buffers.items()},
+            'files': self._file_queue.qsize(),
+        }
+
+        total_items = (
+            initial_counts['logs'] +
+            sum(initial_counts['metrics'].values()) +
+            sum(initial_counts['tracks'].values()) +
+            initial_counts['files']
+        )
+
+        # Show progress bar if there are many items to flush
+        show_progress = total_items > 200
+        items_flushed = 0
+
+        def update_progress():
+            nonlocal items_flushed
+            if show_progress:
+                progress = items_flushed / total_items
+                bar_length = 40
+                filled = int(bar_length * progress)
+                bar = '█' * filled + '░' * (bar_length - filled)
+                percent = progress * 100
+                print(f'\r[ML-Dash] Flushing: |{bar}| {percent:.1f}% ({items_flushed}/{total_items})', end='', flush=True)
+
+        # Flush logs
+        log_batch_size = self._config.log_batch_size
+        while not self._log_queue.empty():
+            before = self._log_queue.qsize()
+            self._flush_logs()
+            after = self._log_queue.qsize()
+            items_flushed += before - after
+            update_progress()
+
+        # Flush metrics
+        metric_batch_size = self._config.metric_batch_size
         for metric_name in list(self._metric_queues.keys()):
-            self._flush_metric(metric_name)
+            while not self._metric_queues[metric_name].empty():
+                before = self._metric_queues[metric_name].qsize()
+                self._flush_metric(metric_name)
+                after = self._metric_queues[metric_name].qsize()
+                items_flushed += before - after
+                update_progress()
+
+        # Flush tracks
         for topic in list(self._track_buffers.keys()):
+            track_count = len(self._track_buffers.get(topic, {}))
             self._flush_track(topic)
-        self._flush_files()
+            items_flushed += track_count
+            update_progress()
+
+        # Flush files
+        while not self._file_queue.empty():
+            before = self._file_queue.qsize()
+            self._flush_files()
+            after = self._file_queue.qsize()
+            items_flushed += before - after
+            update_progress()
+
+        if show_progress:
+            print()  # New line after progress bar
 
     def _flush_logs(self) -> None:
         """Batch flush logs using client.create_log_entries()."""
@@ -458,12 +578,10 @@ class BackgroundBufferManager:
                     logs=batch,
                 )
             except Exception as e:
-                warnings.warn(
-                    f"Failed to flush {len(batch)} logs to remote server: {e}. "
-                    f"Training will continue.",
-                    RuntimeWarning,
-                    stacklevel=3,
-                )
+                raise RuntimeError(
+                    f"Failed to flush {len(batch)} logs to remote server: {e}\n"
+                    f"Data loss occurred. Check your network connection and server status."
+                ) from e
 
         if self._experiment.run._storage:
             # Local storage writes one at a time (no batch API)
@@ -479,11 +597,10 @@ class BackgroundBufferManager:
                         timestamp=log_entry["timestamp"],
                     )
                 except Exception as e:
-                    warnings.warn(
-                        f"Failed to write log to local storage: {e}",
-                        RuntimeWarning,
-                        stacklevel=3,
-                    )
+                    raise RuntimeError(
+                        f"Failed to write log to local storage: {e}\n"
+                        f"Check disk space and file permissions."
+                    ) from e
 
         self._last_log_flush = time.time()
 
@@ -535,12 +652,10 @@ class BackgroundBufferManager:
                 )
             except Exception as e:
                 metric_display = f"'{metric_name}'" if metric_name else "unnamed metric"
-                warnings.warn(
-                    f"Failed to flush {len(batch)} points to {metric_display} on remote server: {e}. "
-                    f"Training will continue.",
-                    RuntimeWarning,
-                    stacklevel=3,
-                )
+                raise RuntimeError(
+                    f"Failed to flush {len(batch)} points to {metric_display} on remote server: {e}\n"
+                    f"Data loss occurred. Check your network connection and server status."
+                ) from e
 
         if self._experiment.run._storage:
             try:
@@ -556,11 +671,10 @@ class BackgroundBufferManager:
                 )
             except Exception as e:
                 metric_display = f"'{metric_name}'" if metric_name else "unnamed metric"
-                warnings.warn(
-                    f"Failed to flush {len(batch)} points to {metric_display} in local storage: {e}",
-                    RuntimeWarning,
-                    stacklevel=3,
-                )
+                raise RuntimeError(
+                    f"Failed to flush {len(batch)} points to {metric_display} in local storage: {e}\n"
+                    f"Check disk space and file permissions."
+                ) from e
 
         self._last_metric_flush[metric_name] = time.time()
 
@@ -597,12 +711,10 @@ class BackgroundBufferManager:
                     entries=batch,
                 )
             except Exception as e:
-                warnings.warn(
-                    f"Failed to flush {len(batch)} entries to track '{topic}' on remote server: {e}. "
-                    f"Training will continue.",
-                    RuntimeWarning,
-                    stacklevel=3,
-                )
+                raise RuntimeError(
+                    f"Failed to flush {len(batch)} entries to track '{topic}' on remote server: {e}\n"
+                    f"Data loss occurred. Check your network connection and server status."
+                ) from e
 
         # Write to local storage
         if self._experiment.run._storage:
@@ -615,11 +727,10 @@ class BackgroundBufferManager:
                     entries=batch,
                 )
             except Exception as e:
-                warnings.warn(
-                    f"Failed to flush {len(batch)} entries to track '{topic}' in local storage: {e}",
-                    RuntimeWarning,
-                    stacklevel=3,
-                )
+                raise RuntimeError(
+                    f"Failed to flush {len(batch)} entries to track '{topic}' in local storage: {e}\n"
+                    f"Check disk space and file permissions."
+                ) from e
 
         self._last_track_flush[topic] = time.time()
 
@@ -663,12 +774,10 @@ class BackgroundBufferManager:
                     if total_files > 1:
                         print(f"[ML-Dash]   [{completed}/{total_files}] Uploaded {file_entry['filename']}", flush=True)
                 except Exception as e:
-                    completed += 1
-                    warnings.warn(
-                        f"Failed to upload file {file_entry['filename']}: {e}",
-                        RuntimeWarning,
-                        stacklevel=3,
-                    )
+                    raise RuntimeError(
+                        f"Failed to upload file {file_entry['filename']}: {e}\n"
+                        f"File upload failed. Check network connection and file permissions."
+                    ) from e
 
     def _upload_single_file(self, file_entry: Dict[str, Any]) -> None:
         """

ml_dash/cli_commands/upload.py

@@ -306,7 +306,8 @@ def discover_experiments(
       with open(exp_json, "r") as f:
         metadata = json.load(f)
         prefix = metadata.get("prefix")
-    except:
+    except (FileNotFoundError, json.JSONDecodeError, KeyError) as e:
+      # Metadata file missing or invalid - will use path-based prefix
       pass
 
     # Extract project and experiment names from PREFIX (not path)

ml_dash/client.py

@@ -226,8 +226,13 @@ class RemoteClient:
             result = self.graphql_query(query)
             username = result.get("me", {}).get("username")
             return username
-        except Exception:
-            return None
+        except Exception as e:
+            # Re-raise authentication errors
+            from .auth.exceptions import AuthenticationError
+            if isinstance(e, AuthenticationError):
+                raise
+            # For other errors, raise a clear exception
+            raise RuntimeError(f"Failed to fetch namespace from server: {e}") from e
 
     def get_current_user(self) -> Optional[Dict[str, Any]]:
         """
@@ -264,8 +269,13 @@ class RemoteClient:
             """
             result = self.graphql_query(query)
             return result.get("me")
-        except Exception:
-            return None
+        except Exception as e:
+            # Re-raise authentication errors
+            from .auth.exceptions import AuthenticationError
+            if isinstance(e, AuthenticationError):
+                raise
+            # For other errors, raise a clear exception
+            raise RuntimeError(f"Failed to fetch current user from server: {e}") from e
 
     def _ensure_authenticated(self):
         """Check if authenticated, raise error if not."""

ml_dash/experiment.py

@@ -399,8 +399,11 @@ class Experiment:
           print(f"View results at: {experiment_url}")
 
       except Exception as e:
-        # Log error but don't fail the close operation
-        print(f"Warning: Failed to update experiment status: {e}")
+        # Raise on status update failure
+        raise RuntimeError(
+          f"Failed to update experiment status to COMPLETED: {e}\n"
+          f"Experiment may not be marked as completed on the server."
+        ) from e
 
     self._is_open = False
 
@@ -554,15 +557,10 @@ class Experiment:
             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
+          raise RuntimeError(
+            f"Failed to write log to remote server: {e}\n"
+            f"Data loss occurred. Check your network connection and server status."
+          ) from e
 
       if self.run._storage:
         # Local mode: write to file immediately
@@ -577,11 +575,10 @@ class Experiment:
             timestamp=log_entry["timestamp"],
           )
         except Exception as e:
-          import warnings
-
-          warnings.warn(
-            f"Failed to write log to local storage: {e}", RuntimeWarning, stacklevel=4
-          )
+          raise RuntimeError(
+            f"Failed to write log to local storage: {e}\n"
+            f"Check disk space and file permissions."
+          ) from e
 
   def _print_log(
     self, message: str, level: str, metadata: Optional[Dict[str, Any]]
@@ -1072,17 +1069,11 @@ class Experiment:
             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
+          raise RuntimeError(
+            f"Failed to log {metric_display} to remote server: {e}\n"
+            f"Data loss occurred. Check your network connection and server status."
+          ) from e
 
       if self.run._storage:
         # Local mode: append to local storage
@@ -1098,14 +1089,11 @@ class Experiment:
             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,
-          )
+          raise RuntimeError(
+            f"Failed to log {metric_display} to local storage: {e}\n"
+            f"Check disk space and file permissions."
+          ) from e
 
       return result
 
@@ -1141,15 +1129,10 @@ class Experiment:
             entries=[{"timestamp": timestamp, **data}],
           )
         except Exception as e:
-          # Log warning but don't crash training
-          import warnings
-
-          warnings.warn(
-            f"Failed to log track '{topic}' to remote server: {e}. "
-            f"Training will continue.",
-            RuntimeWarning,
-            stacklevel=3,
-          )
+          raise RuntimeError(
+            f"Failed to log track '{topic}' to remote server: {e}\n"
+            f"Data loss occurred. Check your network connection and server status."
+          ) from e
 
       if self.run._storage:
         # Local mode: append to local storage
@@ -1162,13 +1145,10 @@ class Experiment:
             entries=[{"timestamp": timestamp, **data}],
           )
         except Exception as e:
-          import warnings
-
-          warnings.warn(
-            f"Failed to log track '{topic}' to local storage: {e}",
-            RuntimeWarning,
-            stacklevel=3,
-          )
+          raise RuntimeError(
+            f"Failed to log track '{topic}' to local storage: {e}\n"
+            f"Check disk space and file permissions."
+          ) from e
 
   def _append_batch_to_metric(
     self,
@@ -1205,17 +1185,11 @@ class Experiment:
           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
+        raise RuntimeError(
+          f"Failed to log batch to {metric_display} on remote server: {e}\n"
+          f"Data loss occurred. Check your network connection and server status."
+        ) from e
 
     if self.run._storage:
       # Local mode: append batch to local storage
@@ -1231,14 +1205,11 @@ class Experiment:
           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,
-        )
+        raise RuntimeError(
+          f"Failed to log batch to {metric_display} in local storage: {e}\n"
+          f"Check disk space and file permissions."
+        ) from e
 
     return result
 

ml_dash/metric.py

@@ -69,9 +69,11 @@ class BufferManager:
                 value = float('nan')
             try:
                 self._buffers[prefix][key].append(float(value))
-            except (TypeError, ValueError):
-                # Skip non-numeric values silently
-                continue
+            except (TypeError, ValueError) as e:
+                raise ValueError(
+                    f"Cannot buffer non-numeric value for '{key}': {value!r} (type: {type(value).__name__})\n"
+                    f"Metrics must be numeric (int, float). Use exp.log() for non-numeric values."
+                ) from e
 
     def _compute_stats(self, values: List[float], aggs: tuple) -> Dict[str, float]:
         """
@@ -248,9 +250,11 @@ class SummaryCache:
                 value = float('nan')
             try:
                 self._buffer[key].append(float(value))
-            except (TypeError, ValueError):
-                # Skip non-numeric values silently
-                continue
+            except (TypeError, ValueError) as e:
+                raise ValueError(
+                    f"Cannot store non-numeric value for '{key}': {value!r} (type: {type(value).__name__})\n"
+                    f"SummaryCache only accepts numeric values. Use exp.log() for non-numeric data."
+                ) from e
 
     def set(self, **kwargs) -> None:
         """

{ml_dash-0.6.13.dist-info → ml_dash-0.6.15.dist-info}/METADATA

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

{ml_dash-0.6.13.dist-info → ml_dash-0.6.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ml_dash/__init__.py,sha256=S-Q1EK0mKvV0WAOB-QjQF7NjLvYntB3_LIAbzKA45LA,3060
+ml_dash/__init__.py,sha256=0N78Rs6EH_pFB-OoRXx42ZXm1ghbvp2xd54it41CPXM,3060
 ml_dash/auth/__init__.py,sha256=3lwM-Y8UBHPU1gFW2JNpmXlPVTnkGudWLKNFFKulQfo,1200
 ml_dash/auth/constants.py,sha256=ku4QzQUMNjvyJwjy7AUdywMAZd59jXSxNHZxDiagUWU,280
 ml_dash/auth/device_flow.py,sha256=DQOdPNlZCuU1umZOA_A6WXdRM3zWphnyo9IntToBl_A,7921
@@ -6,7 +6,7 @@ ml_dash/auth/device_secret.py,sha256=qUsz6M9S1GEIukvmz57eJEp57srSx74O4MU9mZEeDlE
 ml_dash/auth/exceptions.py,sha256=IeBwUzoaTyFtPwd4quFOIel49inIzuabe_ChEeEXEWI,725
 ml_dash/auth/token_storage.py,sha256=9YQXGrn41UVyc1wUvZYbTYLzxSt5NGOyNFNjeX28bjA,7976
 ml_dash/auto_start.py,sha256=mYNjLGI2kyylIfOX5wGOR74gb9UlXg1n5OUQu7aw5SE,2412
-ml_dash/buffer.py,sha256=R3QaD55s1an3tJvzyXfrEuBxeJsN4o4QNdE__BoIr9w,26437
+ml_dash/buffer.py,sha256=m2vTcS08DL8C797Mw_f7myk_tpivow4z4FOQgb1KR4c,31633
 ml_dash/cli.py,sha256=Vd0taM5MQrhvxqL2KQhklZ00wxZLdWl6Qw1IPkjPNuw,2897
 ml_dash/cli_commands/__init__.py,sha256=bjAmV7MsW-bhtW_4SnLJ0Cfkt9h82vMDC8ebW1Ke8KE,38
 ml_dash/cli_commands/api.py,sha256=NekZEJGWNpIfB6YrsrOw7kw7rZKjVudwgJWPZIy6ANQ,4535
@@ -17,13 +17,13 @@ ml_dash/cli_commands/login.py,sha256=zX-urtUrfzg2qOGtKNYQgj6UloN9kzj4zEO6h_xwuNs
 ml_dash/cli_commands/logout.py,sha256=lTUUNyRXqvo61qNkCd4KBrPUujDAHnNqsHkU6bHie0U,1332
 ml_dash/cli_commands/profile.py,sha256=PoRO1XA4bnOINptj4AO0SyNDBADeryPJBfgC74327e4,5997
 ml_dash/cli_commands/remove.py,sha256=AtDlUWkNeGcnZWN0Wbg6XoyYhFHkCFMPdxsGA33v38c,5325
-ml_dash/cli_commands/upload.py,sha256=o5D1be3V_wrzoVI3QHrKzyw2fG6ocD33MSZjzRsS60w,49659
-ml_dash/client.py,sha256=sQokhvofq56JxpmUBVUsfjjn5qKqyUXM9F3uxsUbUbA,66608
+ml_dash/cli_commands/upload.py,sha256=oZVU8m9Ey8N151KmUiQD_qQLEBBN4oqu5NcqUNOUJWY,49786
+ml_dash/client.py,sha256=ZWO1uzV-GLz-3R2ML90XPCV200e_ch7L-4iG07jkC84,67213
 ml_dash/config.py,sha256=oz2xvoBh2X_xUXWr92cPD5nFxXMT5LxVNypv5B5O0fA,3116
-ml_dash/experiment.py,sha256=JqNYsoAOsvqIRMVl6gHFodlZ79b0X2rUFGz6NRixKic,43726
+ml_dash/experiment.py,sha256=eSzrh49jP5dPx6rlEZZHLDMn2CxoA9uE_PSG3CpQQfA,43366
 ml_dash/files.py,sha256=tGJCTxPfd9vmfvIEqstZjzLvqmHzMZffPXHz0jU9bYU,54441
 ml_dash/log.py,sha256=E-DLg0vejVLLEyShJ_r0LneDMI0XU7XTH5iKWYJe9jI,5298
-ml_dash/metric.py,sha256=ghD1jnuv6dbjV1Jlo7q0mx9UEzpdto2Y1-oDWrSfg04,25809
+ml_dash/metric.py,sha256=hwdZIkHbt_wbJQPiO1LK3UJwusbAC7J-TR0gKeAnjHc,26206
 ml_dash/params.py,sha256=pPFvknJAJX5uhckzjO1r-HNnKbQFFKDISFmOXNET5eY,9046
 ml_dash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ml_dash/remote_auto_start.py,sha256=5fvQDHv1CWEKFb6WAa5_uyEInwV_SvotXjOO_6i6ZKE,1687
@@ -31,7 +31,7 @@ ml_dash/run.py,sha256=yAKZ9HtU4cidtbWMAY1IiDPVWwluVlicD5hsmVT89U0,11361
 ml_dash/snowflake.py,sha256=14rEpRU5YltsmmmZW0EMUy_hdv5S5ME9gWVtmdmwfiU,4917
 ml_dash/storage.py,sha256=x1W-dK6wQY36-LVOJ4kA8Dn07ObNQuIErQWJ3b0PoGY,44910
 ml_dash/track.py,sha256=Dfg1ZnmKZ_FlE5ZfG8Qld_wN4RIMs3nrOxrxwf3thiY,8164
-ml_dash-0.6.13.dist-info/WHEEL,sha256=z-mOpxbJHqy3cq6SvUThBZdaLGFZzdZPtgWLcP2NKjQ,79
-ml_dash-0.6.13.dist-info/entry_points.txt,sha256=dYs2EHX1uRNO7AQGNnVaJJpgiy0Z9q7tiy4fHSyaf3Q,46
-ml_dash-0.6.13.dist-info/METADATA,sha256=bKRP7yW8ULvNc5kqdeO0USgqCOWhXuV3EuhViNKOZIU,9536
-ml_dash-0.6.13.dist-info/RECORD,,
+ml_dash-0.6.15.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+ml_dash-0.6.15.dist-info/entry_points.txt,sha256=dYs2EHX1uRNO7AQGNnVaJJpgiy0Z9q7tiy4fHSyaf3Q,46
+ml_dash-0.6.15.dist-info/METADATA,sha256=h5lcu5MX1urb8ZSPaZDPprXM6CUdvemGfGgVhqJJ4hA,9536
+ml_dash-0.6.15.dist-info/RECORD,,

{ml_dash-0.6.13.dist-info → ml_dash-0.6.15.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.15
+Generator: uv 0.9.28
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any