ml-dash 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ml_dash/components/parameters.py

@@ -1,144 +0,0 @@
-"""Parameter management component for ML-Logger."""
-
-import json
-import time
-from typing import Any, Dict, Optional
-
-from ..backends.base import StorageBackend
-
-
-def deep_merge(base: Dict, updates: Dict) -> Dict:
-    """Deep merge two dictionaries.
-
-    Args:
-        base: Base dictionary
-        updates: Updates to merge in
-
-    Returns:
-        Merged dictionary
-    """
-    result = base.copy()
-    for key, value in updates.items():
-        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
-            result[key] = deep_merge(result[key], value)
-        else:
-            result[key] = value
-    return result
-
-
-class ParameterManager:
-    """Manages experiment parameters.
-
-    Parameters are stored in an append-only JSONL file (parameters.jsonl)
-    with operations: set, extend, update.
-
-    Args:
-        backend: Storage backend
-        prefix: Experiment prefix path
-    """
-
-    def __init__(self, backend: StorageBackend, prefix: str):
-        """Initialize parameter manager.
-
-        Args:
-            backend: Storage backend
-            prefix: Experiment prefix path
-        """
-        self.backend = backend
-        self.prefix = prefix
-        self.params_file = f"{prefix}/parameters.jsonl"
-        self._cache: Optional[Dict[str, Any]] = None
-
-    def set(self, **kwargs) -> None:
-        """Set parameters (replaces existing).
-
-        Args:
-            **kwargs: Parameter key-value pairs
-        """
-        self._append_operation("set", data=kwargs)
-        self._cache = None  # Invalidate cache
-
-    def extend(self, **kwargs) -> None:
-        """Extend parameters (deep merge with existing).
-
-        Args:
-            **kwargs: Parameter key-value pairs to merge
-        """
-        self._append_operation("extend", data=kwargs)
-        self._cache = None  # Invalidate cache
-
-    def update(self, key: str, value: Any) -> None:
-        """Update a single parameter.
-
-        Args:
-            key: Parameter key (can be dot-separated like "model.layers")
-            value: New value
-        """
-        self._append_operation("update", key=key, value=value)
-        self._cache = None  # Invalidate cache
-
-    def read(self) -> Dict[str, Any]:
-        """Read current parameters by replaying operations.
-
-        Returns:
-            Current parameter dictionary
-        """
-        if self._cache is not None:
-            return self._cache.copy()
-
-        params = {}
-
-        if not self.backend.exists(self.params_file):
-            return params
-
-        # Read and replay all operations
-        content = self.backend.read_text(self.params_file)
-        for line in content.strip().split("\n"):
-            if not line:
-                continue
-
-            operation = json.loads(line)
-            op_type = operation.get("operation")
-
-            if op_type == "set":
-                params = operation.get("data", {})
-            elif op_type == "extend":
-                params = deep_merge(params, operation.get("data", {}))
-            elif op_type == "update":
-                key = operation.get("key")
-                value = operation.get("value")
-                if key:
-                    # Support dot-separated keys
-                    keys = key.split(".")
-                    current = params
-                    for k in keys[:-1]:
-                        if k not in current:
-                            current[k] = {}
-                        current = current[k]
-                    current[keys[-1]] = value
-
-        self._cache = params
-        return params.copy()
-
-    def log(self, **kwargs) -> None:
-        """Alias for set() to match API documentation.
-
-        Args:
-            **kwargs: Parameter key-value pairs
-        """
-        self.set(**kwargs)
-
-    def _append_operation(self, operation: str, **kwargs) -> None:
-        """Append an operation to the parameters file.
-
-        Args:
-            operation: Operation type (set, extend, update)
-            **kwargs: Operation-specific data
-        """
-        entry = {
-            "timestamp": time.time(),
-            "operation": operation,
-            **kwargs
-        }
-        line = json.dumps(entry) + "\n"
-        self.backend.append_text(self.params_file, line)

ml_dash/job_logger.py

@@ -1,42 +0,0 @@
-"""JobLogger - Job-based logging wrapper around ML_Logger.
-
-This class provides a simple wrapper around ML_Logger for job-based logging.
-"""
-
-from typing import Optional
-
-from .ml_logger import ML_Logger
-from .backends.base import StorageBackend
-
-
-class JobLogger(ML_Logger):
-    """Job-based logger wrapper.
-
-    This is a simple wrapper around ML_Logger that can be extended
-    with job-specific functionality in the future.
-
-    Args:
-        prefix: Directory prefix for logging
-        backend: Storage backend (optional)
-        job_id: Optional job identifier
-    """
-
-    def __init__(
-        self,
-        prefix: str,
-        backend: Optional[StorageBackend] = None,
-        job_id: Optional[str] = None,
-    ):
-        """Initialize JobLogger.
-
-        Args:
-            prefix: Directory prefix for logging
-            backend: Storage backend (optional)
-            job_id: Optional job identifier
-        """
-        super().__init__(prefix, backend)
-        self.job_id = job_id
-
-    def __repr__(self) -> str:
-        """String representation."""
-        return f"JobLogger(prefix='{self.prefix}', job_id='{self.job_id}', entries={len(self.buffer)})"

ml_dash/ml_logger.py

@@ -1,234 +0,0 @@
-"""ML_Logger - Legacy logging class for backward compatibility.
-
-This class provides a simpler interface for basic logging with filtering capabilities.
-"""
-
-import re
-from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Pattern
-
-from .backends.local_backend import LocalBackend
-from .backends.base import StorageBackend
-
-
-class LogLevel(Enum):
-    """Log level enumeration."""
-    DEBUG = 0
-    INFO = 1
-    WARNING = 2
-    ERROR = 3
-
-
-class ML_Logger:
-    """Legacy logger class with filtering capabilities.
-
-    This class provides a simpler interface for logging with built-in filtering
-    by log level, patterns, and custom filter functions.
-
-    Args:
-        prefix: Directory prefix for logging (e.g., "../data")
-        backend: Storage backend (optional, defaults to LocalBackend)
-    """
-
-    def __init__(
-        self,
-        prefix: str,
-        backend: Optional[StorageBackend] = None,
-    ):
-        """Initialize ML_Logger.
-
-        Args:
-            prefix: Directory prefix for logging
-            backend: Storage backend (optional)
-        """
-        self.prefix = prefix
-        self.backend = backend or LocalBackend(prefix)
-
-        # Buffer for in-memory log storage
-        self.buffer: List[Dict[str, Any]] = []
-
-        # Filtering configuration
-        self._min_level = LogLevel.DEBUG
-        self._include_patterns: List[Pattern] = []
-        self._exclude_patterns: List[Pattern] = []
-        self._custom_filters: List[Callable] = []
-
-    def log(self, message: str, level: str = "INFO", **context) -> None:
-        """Log a message with optional context.
-
-        Args:
-            message: Log message
-            level: Log level (DEBUG, INFO, WARNING, ERROR)
-            **context: Additional context fields
-        """
-        entry = {
-            "message": message,
-            "level": level.upper(),
-            **context
-        }
-
-        # Apply filters
-        if self._should_log(entry):
-            self.buffer.append(entry)
-
-    def info(self, message: str, **context) -> None:
-        """Log an info message.
-
-        Args:
-            message: Log message
-            **context: Additional context
-        """
-        self.log(message, level="INFO", **context)
-
-    def warning(self, message: str, **context) -> None:
-        """Log a warning message.
-
-        Args:
-            message: Log message
-            **context: Additional context
-        """
-        self.log(message, level="WARNING", **context)
-
-    def error(self, message: str, **context) -> None:
-        """Log an error message.
-
-        Args:
-            message: Log message
-            **context: Additional context
-        """
-        self.log(message, level="ERROR", **context)
-
-    def debug(self, message: str, **context) -> None:
-        """Log a debug message.
-
-        Args:
-            message: Log message
-            **context: Additional context
-        """
-        self.log(message, level="DEBUG", **context)
-
-    def set_level(self, level: str) -> None:
-        """Set minimum log level.
-
-        Args:
-            level: Minimum level (DEBUG, INFO, WARNING, ERROR)
-        """
-        self._min_level = LogLevel[level.upper()]
-
-    def add_include_pattern(self, pattern: str) -> None:
-        """Add a pattern to include in logs.
-
-        Args:
-            pattern: Regex pattern to match
-        """
-        self._include_patterns.append(re.compile(pattern))
-
-    def add_exclude_pattern(self, pattern: str) -> None:
-        """Add a pattern to exclude from logs.
-
-        Args:
-            pattern: Regex pattern to match
-        """
-        self._exclude_patterns.append(re.compile(pattern))
-
-    def add_filter(self, filter_func: Callable[[Dict[str, Any]], bool]) -> None:
-        """Add a custom filter function.
-
-        Args:
-            filter_func: Function that takes log entry and returns True to keep it
-        """
-        self._custom_filters.append(filter_func)
-
-    def clear_filters(self) -> None:
-        """Clear all filters."""
-        self._min_level = LogLevel.DEBUG
-        self._include_patterns.clear()
-        self._exclude_patterns.clear()
-        self._custom_filters.clear()
-
-    def get_filtered_logs(
-        self,
-        level: Optional[str] = None,
-        pattern: Optional[str] = None,
-        start_step: Optional[int] = None,
-        end_step: Optional[int] = None,
-    ) -> List[Dict[str, Any]]:
-        """Get filtered logs from buffer.
-
-        Args:
-            level: Filter by log level
-            pattern: Filter by regex pattern
-            start_step: Filter by minimum step
-            end_step: Filter by maximum step
-
-        Returns:
-            List of filtered log entries
-        """
-        filtered = self.buffer.copy()
-
-        if level:
-            filtered = [entry for entry in filtered if entry.get("level") == level.upper()]
-
-        if pattern:
-            regex = re.compile(pattern)
-            filtered = [
-                entry for entry in filtered
-                if regex.search(entry.get("message", ""))
-            ]
-
-        if start_step is not None or end_step is not None:
-            # Assign default step based on index in buffer if not present
-            result = []
-            for i, entry in enumerate(filtered):
-                step = entry.get("step", i)
-                if (start_step is None or step >= start_step) and \
-                   (end_step is None or step <= end_step):
-                    # Add step to entry if it wasn't there
-                    entry_with_step = entry.copy()
-                    if "step" not in entry_with_step:
-                        entry_with_step["step"] = i
-                    result.append(entry_with_step)
-            return result
-
-        return filtered
-
-    def _should_log(self, entry: Dict[str, Any]) -> bool:
-        """Check if an entry should be logged based on filters.
-
-        Args:
-            entry: Log entry to check
-
-        Returns:
-            True if entry should be logged
-        """
-        # Check log level
-        entry_level = LogLevel[entry.get("level", "INFO")]
-        if entry_level.value < self._min_level.value:
-            return False
-
-        message = entry.get("message", "")
-
-        # Check include patterns
-        if self._include_patterns:
-            if not any(pattern.search(message) for pattern in self._include_patterns):
-                return False
-
-        # Check exclude patterns
-        if self._exclude_patterns:
-            if any(pattern.search(message) for pattern in self._exclude_patterns):
-                return False
-
-        # Check custom filters
-        for filter_func in self._custom_filters:
-            if not filter_func(entry):
-                return False
-
-        return True
-
-    def clear_buffer(self) -> None:
-        """Clear the log buffer."""
-        self.buffer.clear()
-
-    def __repr__(self) -> str:
-        """String representation."""
-        return f"ML_Logger(prefix='{self.prefix}', entries={len(self.buffer)})"