py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/lazy_import.py

@@ -0,0 +1,240 @@
+"""Lazy import utilities for WL Commands."""
+
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class LazyImport(Generic[T]):
+    """Lazy import wrapper that defers import until first access."""
+
+    def __init__(self, module_name: str, attribute_name: str | None = None):
+        """
+        Initialize a lazy import.
+
+        Args:
+            module_name: The name of the module to import
+            attribute_name: Optional attribute name to import from the module
+        """
+        self.module_name = module_name
+        self.attribute_name = attribute_name
+        self._module: Any | None = None
+        self._attribute: T | None = None
+
+    def _import(self) -> T:
+        """
+        Perform the actual import.
+
+        Returns:
+            The imported module or attribute
+
+        Raises:
+            ImportError: If the module cannot be imported
+            AttributeError: If the attribute cannot be found in the module
+        """
+        if self._attribute is None:
+            if self.attribute_name:
+                # Import specific attribute from module
+                module = __import__(self.module_name, fromlist=[self.attribute_name])
+                self._module = module
+                # This will raise AttributeError if the attribute doesn't exist
+                self._attribute = getattr(module, self.attribute_name)
+            else:
+                # Import entire module
+                self._module = __import__(self.module_name)
+                # When importing entire module, we cast it to T since T represents the module type
+                self._attribute = self._module  # type: ignore[assignment]
+        return self._attribute  # type: ignore[return-value]
+
+    def __get__(self, instance: Any | None, owner: type | None = None) -> T:
+        """
+        Get the imported module or attribute.
+
+        Args:
+            instance: The instance accessing the attribute
+            owner: The owner class
+
+        Returns:
+            The imported module or attribute
+        """
+        return self._import()
+
+    def __getattr__(self, name: str) -> Any:
+        """
+        Get attribute from the imported module.
+
+        Args:
+            name: The attribute name to get
+
+        Returns:
+            The attribute value
+        """
+        module = self._import()
+        return getattr(module, name)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        Allow calling the lazy import as a function if it's callable.
+
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+
+        Returns:
+            The result of calling the imported object
+        """
+        obj = self._import()
+        if callable(obj):
+            return obj(*args, **kwargs)
+        raise TypeError(
+            f"{self.module_name}.{self.attribute_name if self.attribute_name else ''} is not callable"
+        )
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the lazy import.
+
+        Returns:
+            A string representation
+        """
+        if self._attribute is None:
+            if self.attribute_name:
+                return f"LazyImport({self.module_name}, {self.attribute_name})"
+            else:
+                return f"LazyImport({self.module_name})"
+        return repr(self._attribute)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the lazy import.
+
+        Returns:
+            A string representation
+        """
+        return repr(self)
+
+    def __bool__(self) -> bool:
+        """
+        Boolean representation of the lazy import.
+
+        Returns:
+            True if the imported object is truthy
+        """
+        return bool(self._import())
+
+    def __dir__(self) -> list[str]:
+        """
+        Directory of attributes for the lazy import.
+
+        Returns:
+            List of attribute names
+        """
+        obj = self._import()
+        return dir(obj)
+
+    def __getattribute__(self, name: str) -> Any:
+        """
+        Get attribute from the lazy import or the imported object.
+
+        Args:
+            name: The attribute name to get
+
+        Returns:
+            The attribute value
+        """
+        # Handle special attributes
+        if name in [
+            "module_name",
+            "attribute_name",
+            "_module",
+            "_attribute",
+            "_import",
+        ]:
+            return super().__getattribute__(name)
+
+        # For other attributes, trigger import and delegate to the imported object
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            # If attribute not found in LazyImport, try the imported object
+            obj = self._import()
+            return getattr(obj, name)
+
+    def __instancecheck__(self, instance: Any) -> bool:
+        """
+        Instance check for the lazy import.
+
+        Args:
+            instance: The instance to check
+
+        Returns:
+            True if the instance is an instance of the imported type
+        """
+        return isinstance(instance, self._import())  # type: ignore[arg-type]
+
+    def __subclasscheck__(self, subclass: type) -> bool:
+        """
+        Subclass check for the lazy import.
+
+        Args:
+            subclass: The subclass to check
+
+        Returns:
+            True if the subclass is a subclass of the imported type
+        """
+        return issubclass(subclass, self._import())  # type: ignore[arg-type]
+
+
+def lazy_import(module_name: str, attribute_name: str | None = None) -> LazyImport:
+    """
+    Create a lazy import for a module or attribute.
+
+    Args:
+        module_name: The name of the module to import
+        attribute_name: Optional attribute name to import from the module
+
+    Returns:
+        A LazyImport instance that will import when first accessed
+    """
+    return LazyImport(module_name, attribute_name)
+
+
+def lazy_imports(**imports: str) -> Callable:
+    """
+    Decorator to lazy import multiple modules or attributes.
+
+    Usage:
+        @lazy_imports(
+            os='os',
+            Path='pathlib.Path',
+            json_loads='json.loads'
+        )
+        class MyClass:
+            def method(self):
+                return self.os.path.exists('file.txt')
+
+    Args:
+        **imports: Dictionary of attribute names to import specifications
+
+    Returns:
+        A decorator that adds lazy imports as class attributes
+    """
+
+    def decorator(cls: type) -> type:
+        for attr_name, import_spec in imports.items():
+            if "." in import_spec:
+                # Handle attribute imports like 'module.attribute'
+                parts = import_spec.rsplit(".", 1)
+                if len(parts) == 2:
+                    module_name, attr = parts
+                    setattr(cls, attr_name, LazyImport(module_name, attr))
+                else:
+                    # Handle module imports
+                    setattr(cls, attr_name, LazyImport(import_spec))
+            else:
+                # Handle module imports
+                setattr(cls, attr_name, LazyImport(import_spec))
+        return cls
+
+    return decorator

wl_cli/utils/log_levels.py

@@ -0,0 +1,35 @@
+"""
+Log level definitions for WL Commands.
+"""
+
+from typing import ClassVar
+
+
+class LogLevel:
+    """Log levels."""
+
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
+
+    _level_names: ClassVar[dict[int, str]] = {
+        DEBUG: "DEBUG",
+        INFO: "INFO",
+        WARNING: "WARNING",
+        ERROR: "ERROR",
+        CRITICAL: "CRITICAL",
+    }
+
+    @classmethod
+    def get_name(cls, level: int) -> str:
+        """Get the name of a log level from its value.
+
+        Args:
+            level: The numeric log level value.
+
+        Returns:
+            The name of the log level, or "INFO" if unknown.
+        """
+        return cls._level_names.get(level, "INFO")

wl_cli/utils/log_rotators.py

@@ -0,0 +1,74 @@
+"""
+Log rotation utilities for WL Commands.
+"""
+
+import os
+import time
+
+
+class LogRotator:
+    """Enhanced log rotator that supports size-based and time-based rotation."""
+
+    def __init__(
+        self,
+        filename: str,
+        max_size: int = 10 * 1024 * 1024,  # 10MB default
+        max_backups: int = 5,  # Keep up to 5 backup files
+        rotate_days: int = 7,  # Rotate after 7 days
+    ) -> None:
+        """
+        Initialize log rotator.
+
+        Args:
+            filename (str): Log file name.
+            max_size (int): Maximum file size in bytes before rotation.
+            max_backups (int): Maximum number of backup files to keep.
+            rotate_days (int): Number of days before rotating the log file.
+        """
+        self.filename = filename
+        self.max_size = max_size
+        self.max_backups = max_backups
+        self.rotate_days = rotate_days
+
+    def should_rotate(self) -> bool:
+        """Check if log file should be rotated based on size or time."""
+        try:
+            if not os.path.exists(self.filename):
+                return False
+
+            # Check size-based rotation
+            if os.path.getsize(self.filename) >= self.max_size:
+                return True
+
+            # Check time-based rotation
+            file_mtime = os.path.getmtime(self.filename)
+            if time.time() - file_mtime >= self.rotate_days * 24 * 60 * 60:
+                return True
+
+            return False
+        except OSError:
+            return False
+
+    def do_rotate(self) -> None:
+        """Perform log rotation with multiple backup files."""
+        try:
+            if not os.path.exists(self.filename):
+                return
+
+            # Rotate existing backups
+            for i in range(self.max_backups - 1, 0, -1):
+                old_backup = f"{self.filename}.{i}"
+                new_backup = f"{self.filename}.{i + 1}"
+                if os.path.exists(old_backup):
+                    if os.path.exists(new_backup):
+                        os.remove(new_backup)
+                    os.rename(old_backup, new_backup)
+
+            # Rotate current log file to .1
+            first_backup = f"{self.filename}.1"
+            if os.path.exists(first_backup):
+                os.remove(first_backup)
+            os.rename(self.filename, first_backup)
+        except OSError:
+            # Ignore rotation errors
+            pass