ml-dash 0.6.12__tar.gz → 0.6.14__tar.gz

{ml_dash-0.6.12 → ml_dash-0.6.14}/PKG-INFO

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

{ml_dash-0.6.12 → ml_dash-0.6.14}/pyproject.toml

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

{ml_dash-0.6.12 → ml_dash-0.6.14}/src/ml_dash/__init__.py

@@ -43,18 +43,19 @@ from .params import ParametersBuilder
 from .run import RUN
 from .storage import LocalStorage
 
-__version__ = "0.6.10"
+__version__ = "0.6.14"
 
-# Minimum version required - blocks older versions
-MINIMUM_REQUIRED_VERSION = "0.6.10"
+# Required version - MUST match exactly (blocks all older versions)
+# Update this with EVERY release to force users to upgrade
+REQUIRED_VERSION = "0.6.14"
 
 
 def _check_version_compatibility():
     """
-    Enforce minimum version requirement.
+    Enforce strict version requirement.
 
-    Raises ImportError if installed version is below minimum required version.
-    This ensures users have the latest features (userinfo, namespace auto-detection, etc.)
+    Raises ImportError if installed version doesn't match the required version.
+    This ensures all users are on the latest version with newest features and bug fixes.
     """
     try:
         from packaging import version
@@ -64,25 +65,26 @@ def _check_version_compatibility():
         return
 
     current = version.parse(__version__)
-    minimum = version.parse(MINIMUM_REQUIRED_VERSION)
+    required = version.parse(REQUIRED_VERSION)
 
-    if current < minimum:
+    if current < required:
         raise ImportError(
             f"\n"
             f"{'=' * 80}\n"
-            f"ERROR: ml-dash version {__version__} is too old!\n"
+            f"ERROR: ml-dash version {__version__} is outdated!\n"
             f"{'=' * 80}\n"
             f"\n"
-            f"This version of ml-dash ({__version__}) is no longer supported.\n"
-            f"Minimum required version: {MINIMUM_REQUIRED_VERSION}\n"
+            f"Your installed version ({__version__}) is no longer supported.\n"
+            f"Required version: {REQUIRED_VERSION}\n"
             f"\n"
             f"Please upgrade to the latest version:\n"
             f"\n"
             f"  pip install --upgrade ml-dash\n"
             f"\n"
-            f"Or install specific version:\n"
+            f"Or with uv:\n"
             f"\n"
-            f"  pip install ml-dash>={MINIMUM_REQUIRED_VERSION}\n"
+            f"  uv pip install --upgrade ml-dash\n"
+            f"  uv sync --upgrade-package ml-dash\n"
             f"\n"
             f"{'=' * 80}\n"
         )

{ml_dash-0.6.12 → ml_dash-0.6.14}/src/ml_dash/buffer.py

@@ -458,12 +458,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 +477,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 +532,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 +551,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 +591,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 +607,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 +654,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-0.6.12 → ml_dash-0.6.14}/src/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)
@@ -1217,7 +1218,7 @@ def cmd_upload(args: argparse.Namespace) -> int:
       Exit code (0 for success, 1 for error)
   """
   # Handle track upload if --tracks is specified
-  if args.tracks:
+  if getattr(args, 'tracks', False):
     return cmd_upload_track(args)
 
   # Load config

{ml_dash-0.6.12 → ml_dash-0.6.14}/src/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-0.6.12 → ml_dash-0.6.14}/src/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-0.6.12 → ml_dash-0.6.14}/src/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.12 → ml_dash-0.6.14}/src/ml_dash/run.py

@@ -158,6 +158,16 @@ class RUN:
   now = datetime.now()
   """Timestamp at import time. Does not change during the session."""
 
+  @property
+  def date(self) -> str:
+    """Date string in YYYYMMDD format."""
+    return self.now.strftime("%Y%m%d")
+
+  @property
+  def datetime_str(self) -> str:
+    """DateTime string in YYYYMMDD.HHMMSS format."""
+    return self.now.strftime("%Y%m%d.%H%M%S")
+
   timestamp: str = None
   """Timestamp created at instantiation"""
 
@@ -277,6 +287,61 @@ class RUN:
         # self.name is the last segment
         self.name = parts[-1] if len(parts) > 2 else parts[1]
 
+  def __setattr__(self, name: str, value):
+    """
+    Intercept attribute setting to expand {EXP.attr} templates in prefix.
+
+    When prefix is set, expands any {EXP.name}, {EXP.id}, {EXP.date}, etc. templates
+    using current instance's attributes. Also syncs back to class-level RUN attributes.
+    """
+    # Prevent prefix changes after experiment has started
+    if name == "prefix" and isinstance(value, str):
+      experiment = getattr(self, "_experiment", None)
+      if experiment is not None and getattr(experiment, "_is_open", False):
+        raise RuntimeError(
+          "Cannot change prefix after experiment has been initialized. "
+          "Set prefix before calling experiment.run.start() or entering the context manager."
+        )
+
+    # Expand templates if setting prefix
+    if name == "prefix" and isinstance(value, str):
+      # Check if value contains {EXP. templates
+      if "{EXP." in value:
+        import re
+
+        def replace_match(match):
+          attr_name = match.group(1)
+          # Special handling for id - generate if needed
+          if attr_name == "id" and not getattr(self, "id", None):
+            from ml_dash.snowflake import generate_id
+            object.__setattr__(self, "id", generate_id())
+
+          # Get attribute, raising error if not found
+          try:
+            attr_value = getattr(self, attr_name)
+            if attr_value is None:
+              raise AttributeError(f"Attribute '{attr_name}' is None")
+            return str(attr_value)
+          except AttributeError:
+            raise AttributeError(f"RUN has no attribute '{attr_name}'")
+
+        # Match {EXP.attr_name} pattern
+        pattern = r"\{EXP\.(\w+)\}"
+        value = re.sub(pattern, replace_match, value)
+
+      # Always update _folder_path when prefix changes
+      object.__setattr__(self, "_folder_path", value)
+
+      # Parse and update owner, project, name from new prefix
+      parts = value.strip("/").split("/")
+      if len(parts) >= 2:
+        object.__setattr__(self, "owner", parts[0])
+        object.__setattr__(self, "project", parts[1])
+        object.__setattr__(self, "name", parts[-1] if len(parts) > 2 else parts[1])
+
+    # Use object.__setattr__ to set the value
+    object.__setattr__(self, name, value)
+
   def start(self) -> "Experiment":
     """
     Start the experiment (sets status to RUNNING).