bear-utils 0.7.21__py3-none-any.whl → 0.7.23__py3-none-any.whl

bear_utils/cli/shell/__init__.py

@@ -0,0 +1 @@
+"""Shell utilities for bear_utils CLI."""

bear_utils/cli/shell/_base_command.py

@@ -1,21 +1,20 @@
-from asyncio.subprocess import Process
-from subprocess import CompletedProcess
-from typing import ClassVar, Generic, Self, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, LiteralString, Self, cast
 
-T = TypeVar("T", bound=str)
+if TYPE_CHECKING:
+    from subprocess import CompletedProcess
 
 
-class BaseShellCommand(Generic[T]):
+class BaseShellCommand[T: str]:
     """Base class for typed shell commands compatible with session systems"""
 
     command_name: ClassVar[str] = ""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         self.sub_command: str = kwargs.get("sub_command", "")
         self.args = args
-        self.kwargs = kwargs
+        self.kwargs: dict[str, Any] = kwargs
         self.suffix = kwargs.get("suffix", "")
-        self.result = None
+        self.result: CompletedProcess[str] | None = None
 
     def __str__(self) -> str:
         """String representation of the command"""
@@ -28,8 +27,7 @@ class BaseShellCommand(Generic[T]):
 
     @classmethod
     def adhoc(cls, name: T, *args, **kwargs) -> "BaseShellCommand[T]":
-        """
-        Create an ad-hoc command class for a specific command
+        """Create an ad-hoc command class for a specific command
 
         Args:
             name (str): The name of the command to create
@@ -37,33 +35,35 @@ class BaseShellCommand(Generic[T]):
         Returns:
             BaseShellCommand: An instance of the ad-hoc command class.
         """
-        AdHocCommand = type(
+        return type(
             f"AdHoc{name.title()}Command",
             (cls,),
             {"command_name": name},
-        )
-        return AdHocCommand(*args, **kwargs)
+        )(*args, **kwargs)
 
     @classmethod
     def sub(cls, s: str, *args, **kwargs) -> Self:
         """Set a sub-command for the shell command"""
-        return cls(sub_command=s, *args, **kwargs)
+        return cls(s, *args, **kwargs)
 
     @property
     def cmd(self) -> str:
         """Return the full command as a string"""
-        cmd_parts = [self.command_name, self.sub_command] + list(self.args)
-        joined = " ".join(cmd_parts).strip()
+        cmd_parts = [self.command_name, self.sub_command, *self.args]
+        cmd_parts = [part for part in cmd_parts if part]
+        joined: LiteralString = " ".join(cmd_parts).strip()
         if self.suffix:
             return f"{joined} {self.suffix}"
         return joined
 
     def do(self, **kwargs) -> Self:
         """Run the command using subprocess"""
-        from ._base_shell import shell_session
+        from ._base_shell import shell_session  # noqa: PLC0415
 
         with shell_session(**kwargs) as session:
-            self.result: CompletedProcess[str] | Process = session.add(self.cmd).run()
+            result = session.add(self.cmd).run()
+        if result is not None:
+            self.result = cast("CompletedProcess[str]", result)
         return self
 
     def get(self) -> str:

bear_utils/cli/shell/_base_shell.py

@@ -1,7 +1,4 @@
 import asyncio
-import os
-import shlex
-import subprocess
 from asyncio.streams import StreamReader
 from asyncio.subprocess import Process
 from collections import deque
@@ -9,10 +6,16 @@ from collections.abc import AsyncGenerator, Callable, Generator
 from contextlib import asynccontextmanager, contextmanager
 from io import StringIO
 from logging import INFO
+import os
 from pathlib import Path
+import shlex
+import subprocess
 from subprocess import CompletedProcess
 from typing import Self, override
 
+from bear_utils.constants.logger_protocol import LoggerProtocol
+from bear_utils.logging import VERBOSE, BaseLogger, SubConsoleLogger
+
 from ._base_command import BaseShellCommand
 from ._common import DEFAULT_SHELL
 
@@ -32,11 +35,13 @@ EXIT_CODES: dict[int, str] = {
 
 
 class FancyCompletedProcess(CompletedProcess[str]):
-    def __init__(self, args, returncode, stdout=None, stderr=None):
+    def __init__(self, args: list[str], returncode: int, stdout: str | None = None, stderr: str | None = None) -> None:
+        """Initialize with custom attributes for better readability"""
         super().__init__(args=args, returncode=returncode, stdout=stdout, stderr=stderr)
 
-    def __repr__(self):
-        args = [
+    def __repr__(self) -> str:
+        """Custom representation for better readability"""
+        args: list[str] = [
             f"args={self.args!r}",
             f"returncode={self.returncode!r}",
             f"exit_message={self.exit_message!r}",
@@ -54,8 +59,8 @@ class FancyCompletedProcess(CompletedProcess[str]):
 class CommandList(deque[CompletedProcess[str]]):
     """A list to hold previous commands with their timestamps and results"""
 
-    def __init__(self, maxlen=10, *args, **kwargs):
-        super().__init__(maxlen=maxlen, *args, **kwargs)
+    def __init__(self, maxlen: int = 10, *args, **kwargs) -> None:
+        super().__init__(maxlen=maxlen, *args, **kwargs)  # noqa:  B026
 
     def add(self, command: CompletedProcess[str]) -> None:
         """Add a command to the list"""
@@ -75,10 +80,10 @@ class SimpleShellSession:
 
     def __init__(
         self,
-        env=None,
-        cwd=None,
+        env: dict | None = None,
+        cwd: Path | str | None = None,
         shell: str = DEFAULT_SHELL,
-        logger=None,
+        logger: LoggerProtocol | BaseLogger | None = None,
         verbose: bool = False,
         use_shell: bool = True,
     ) -> None:
@@ -90,12 +95,12 @@ class SimpleShellSession:
         self.result: CompletedProcess[str] | None = None
         self.verbose: bool = verbose
         self.use_shell: bool = use_shell
-        self.logger = self.set_logger(logger)
+        self.logger: LoggerProtocol | BaseLogger | SubConsoleLogger[BaseLogger] = self.set_logger(logger)
 
-    def set_logger(self, passed_logger=None):
+    def set_logger(
+        self, passed_logger: LoggerProtocol | BaseLogger | None = None
+    ) -> LoggerProtocol | BaseLogger | SubConsoleLogger[BaseLogger]:
         """Set the logger for the session, defaulting to a base logger if none is provided"""
-        from ...logging.loggers import VERBOSE, BaseLogger, SubConsoleLogger
-
         if passed_logger is not None:
             return passed_logger
 
@@ -110,7 +115,7 @@ class SimpleShellSession:
             logger.set_sub_level(INFO)
         return logger
 
-    def add_to_env(self, env: dict[str, str], key: str | None = None, value=None) -> Self:
+    def add_to_env(self, env: dict[str, str], key: str | None = None, value: str | None = None) -> Self:
         """Populate the environment for the session"""
         _env = {}
         if isinstance(env, str) and key is not None and value is not None:
@@ -149,6 +154,7 @@ class SimpleShellSession:
 
         if self.use_shell:
             self.result = subprocess.run(
+                check=False,
                 args=command,
                 shell=True,
                 cwd=self.cwd,
@@ -159,6 +165,7 @@ class SimpleShellSession:
         else:
             command_args: list[str] = shlex.split(command)
             self.result = subprocess.run(
+                check=False,
                 args=command_args,
                 shell=False,
                 cwd=self.cwd,
@@ -279,7 +286,7 @@ class SimpleShellSession:
         """Enter the context manager"""
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
+    def __exit__(self, exc_type: object, exc_value: object, traceback: object) -> None:
         """Exit the context manager"""
         self.reset()
         self.reset_buffer()
@@ -290,10 +297,10 @@ class AsyncShellSession(SimpleShellSession):
 
     def __init__(
         self,
-        env=None,
-        cwd=None,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
         shell: str = DEFAULT_SHELL,
-        logger=None,
+        logger: LoggerProtocol | BaseLogger | None = None,
         verbose: bool = False,
         use_shell: bool = True,
     ) -> None:
@@ -326,7 +333,6 @@ class AsyncShellSession(SimpleShellSession):
                 env=self.env,
                 **kwargs,
             )
-
         return self.process
 
     @override
@@ -338,12 +344,12 @@ class AsyncShellSession(SimpleShellSession):
         if self.has_history and cmd is not None:
             raise ValueError("Use `amp` to chain commands, not `run`")
         if self.has_history and cmd is None:
-            command = self.cmd
+            command: str = self.cmd
         elif self.empty_history and cmd is not None:
             self.cmd_buffer.write(f"{cmd}")
             if args:
                 self.cmd_buffer.write(" ".join(map(str, args)))
-            command = self.cmd
+            command: str = self.cmd
         else:
             raise ValueError("Unexpected state")
         process: Process = await self._run(command, **kwargs)
@@ -359,23 +365,20 @@ class AsyncShellSession(SimpleShellSession):
         return_code: int = await self.process.wait()
 
         self.result = FancyCompletedProcess(
-            args=self.cmd,
+            args=self.cmd,  # type: ignore  FIXME: should be a list[str] not str?
             returncode=return_code,
             stdout=stdout.decode() if stdout else "",
             stderr=stderr.decode() if stderr else "",
         )
-
         if return_code != 0:
             self.logger.error(f"Command failed with return code {return_code} {stderr.strip()}")
-
         for callback in self._callbacks:
             callback(self.result)
-
         await self.after_process()
         return self.result
 
     @staticmethod
-    async def read_stream(stream: StreamReader) -> AsyncGenerator[str, None]:
+    async def read_stream(stream: StreamReader) -> AsyncGenerator[str]:
         while True:
             try:
                 line: bytes = await stream.readline()
@@ -385,7 +388,7 @@ class AsyncShellSession(SimpleShellSession):
             except Exception:
                 break
 
-    async def stream_stdout(self) -> AsyncGenerator[str, None]:
+    async def stream_stdout(self) -> AsyncGenerator[str]:
         """Stream output line by line as it comes"""
         if self.process is None:
             raise ValueError("No process has been started yet")
@@ -395,7 +398,7 @@ class AsyncShellSession(SimpleShellSession):
         async for line in self.read_stream(self.process.stdout):
             yield line
 
-    async def stream_stderr(self) -> AsyncGenerator[str, None]:
+    async def stream_stderr(self) -> AsyncGenerator[str]:
         """Stream error output line by line as it comes"""
         if self.process is None:
             raise ValueError("No process has been started yet")
@@ -404,13 +407,13 @@ class AsyncShellSession(SimpleShellSession):
         async for line in self.read_stream(self.process.stderr):
             yield line
 
-    async def after_process(self):
+    async def after_process(self) -> None:
         """Run after process completion, can be overridden for custom behavior"""
         self.process = None
         self._callbacks.clear()
         self.reset_buffer()
 
-    def on_completion(self, callback):
+    def on_completion(self, callback: Callable[[CompletedProcess[str]], None]) -> None:
         """Add callback for when process completes"""
         self._callbacks.append(callback)
 
@@ -421,7 +424,7 @@ class AsyncShellSession(SimpleShellSession):
 
 
 @contextmanager
-def shell_session(shell: str = DEFAULT_SHELL, **kwargs) -> Generator[SimpleShellSession, None, None]:
+def shell_session(shell: str = DEFAULT_SHELL, **kwargs) -> Generator[SimpleShellSession]:
     """Context manager for simple shell sessions"""
     session = SimpleShellSession(shell=shell, **kwargs)
     try:
@@ -431,7 +434,7 @@ def shell_session(shell: str = DEFAULT_SHELL, **kwargs) -> Generator[SimpleShell
 
 
 @asynccontextmanager
-async def async_shell_session(shell: str = DEFAULT_SHELL, **kwargs) -> AsyncGenerator[AsyncShellSession, None]:
+async def async_shell_session(shell: str = DEFAULT_SHELL, **kwargs) -> AsyncGenerator[AsyncShellSession]:
     """Asynchronous context manager for shell sessions"""
     session = AsyncShellSession(shell=shell, **kwargs)
     try:

bear_utils/config/__init__.py

@@ -1,11 +1,13 @@
+"""Config and settings management utilities for Bear Utils."""
+
 from .config_manager import ConfigManager
 from .dir_manager import DirectoryManager
 from .settings_manager import SettingsManager, get_settings_manager, settings
 
 __all__ = [
     "ConfigManager",
+    "DirectoryManager",
     "SettingsManager",
-    "settings",
     "get_settings_manager",
-    "DirectoryManager",
+    "settings",
 ]

bear_utils/config/config_manager.py

@@ -1,21 +1,38 @@
+"""Config Manager Module for Bear Utils."""
+
+from collections.abc import Callable
+from functools import cached_property
 import os
-from functools import lru_cache
 from pathlib import Path
-from typing import Any, Generic, TypeVar
+import tomllib
+from typing import Any
+
+from pydantic import BaseModel, ValidationError, field_validator
+
 
-from pydantic import BaseModel
+def nullable_string_validator(field_name: str) -> Callable[..., str | None]:
+    """Create a validator that converts 'null' strings to None."""
 
-ConfigType = TypeVar("ConfigType", bound=BaseModel)
+    @field_validator(field_name)
+    @classmethod
+    def _validate(cls: object, v: str | None) -> str | None:  # noqa: ARG001
+        if isinstance(v, str) and v.lower() in ("null", "none", ""):
+            return None
+        return v
 
-# TODO: Get around to potentially using this, right now it is just masturbation
+    return _validate
 
 
-class ConfigManager(Generic[ConfigType]):
+class ConfigManager[ConfigType: BaseModel]:
+    """A generic configuration manager with environment-based overrides."""
+
     def __init__(self, config_model: type[ConfigType], config_path: Path | None = None, env: str = "dev") -> None:
-        self._model = config_model
-        self._config_path = config_path or Path("config")
-        self._env = env
+        """Initialize the ConfigManager with a Pydantic model and configuration path."""
+        self._model: type[ConfigType] = config_model
+        self._config_path: Path = config_path or Path("config")
+        self._env: str = env
         self._config: ConfigType | None = None
+        self._config_path.mkdir(parents=True, exist_ok=True)
 
     def _get_env_overrides(self) -> dict[str, Any]:
         """Convert environment variables to nested dictionary structure."""
@@ -26,67 +43,187 @@ class ConfigManager(Generic[ConfigType]):
                 continue
 
             # Convert APP_DATABASE_HOST to ['database', 'host']
-            parts = key.lower().replace("app_", "").split("_")
+            parts: list[str] = key.lower().replace("app_", "").split("_")
 
-            # Build nested dictionary
-            current = env_config
+            current: dict[str, Any] = env_config
             for part in parts[:-1]:
                 current = current.setdefault(part, {})
-            current[parts[-1]] = value
 
+            final_value: Any = self._convert_env_value(value)
+            current[parts[-1]] = final_value
         return env_config
 
-    @lru_cache
+    def _convert_env_value(self, value: str) -> Any:
+        """Convert string environment variables to appropriate types."""
+        if value.lower() in ("true", "false"):
+            return value.lower() == "true"
+
+        if value.isdigit():
+            return int(value)
+
+        try:
+            if "." in value:
+                return float(value)
+        except ValueError:
+            pass
+
+        if "," in value:
+            return [item.strip() for item in value.split(",")]
+
+        return value
+
+    def _load_toml_file(self, file_path: Path) -> dict[str, Any]:
+        """Load a TOML file and return its contents."""
+        try:
+            with open(file_path, "rb") as f:
+                return tomllib.load(f)
+        except (FileNotFoundError, tomllib.TOMLDecodeError):
+            return {}
+
+    @cached_property
     def load(self) -> ConfigType:
+        """Load configuration from files and environment variables."""
         # Load order (later overrides earlier):
-        # 1. default.yaml
-        # 2. {env}.yaml
-        # 3. local.yaml (gitignored)
+        # 1. default.toml
+        # 2. {env}.toml
+        # 3. local.toml (gitignored)
         # 4. environment variables
         config_data: dict[str, Any] = {}
 
-        # for config_file in [
-        #     self._config_path / "default.yaml",
-        #     self._config_path / f"{self._env}.yaml",
-        #     self._config_path / "local.yaml",
-        # ]:
-        #     if config_file.exists():
-        #         with open(config_file) as f:
-        #             config_data.update(yaml.safe_load(f))
-
-        config_data.update(self._get_env_overrides())
-
-        return self._model.model_validate(config_data)
+        # TODO: Update this so it looks for it in more than one place
+        config_files: list[Path] = [
+            self._config_path / "default.toml",
+            self._config_path / f"{self._env}.toml",
+            self._config_path / "local.toml",
+        ]
+
+        for config_file in config_files:
+            if config_file.exists():
+                file_data = self._load_toml_file(config_file)
+                config_data = self._deep_merge(config_data, file_data)
+
+        env_overrides: dict[str, Any] = self._get_env_overrides()
+        config_data = self._deep_merge(config_data, env_overrides)
+
+        try:
+            return self._model.model_validate(config_data)
+        except ValidationError as e:
+            raise ValueError(f"Configuration validation failed: {e}") from e
+
+    def _deep_merge(self, base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+        """Deep merge two dictionaries."""
+        result: dict[str, Any] = base.copy()
+        for key, value in override.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._deep_merge(result[key], value)
+            else:
+                result[key] = value
+        return result
 
     @property
     def config(self) -> ConfigType:
+        """Get the loaded configuration."""
         if self._config is None:
-            self._config = self.load()
+            self._config = self.load
         return self._config
 
-
-# Example usage:
-# class DatabaseConfig(BaseModel):
-#     host: str
-#     port: int
-#     username: str
-#     password: str
-#     database: str
-
-
-# class AppConfig(BaseModel):
-#     database: DatabaseConfig
-#     environment: str
-#     debug: bool = False
-#     logging_mode: str = "console"
-#     log_level: str = "INFO"
-
-
-# config_manager = ConfigManager[AppConfig](
-#     config_model=AppConfig,
-#     config_path=Path("config"),
-#     env="development",
-# )
-
-# Access config
-# db_config = config_manager.config.database
+    def reload(self) -> ConfigType:
+        """Force reload the configuration."""
+        if "config" in self.__dict__:
+            del self.__dict__["config"]
+        return self.config
+
+    def create_default_config(self) -> None:
+        """Create a default.toml file with example values."""
+        default_path = self._config_path / "default.toml"
+        if default_path.exists():
+            return
+
+        try:
+            default_instance: ConfigType = self._model()
+            toml_content: str = self._model_to_toml(default_instance)
+            default_path.write_text(toml_content)
+        except Exception as e:
+            print(f"Could not create default config: {e}")
+
+    def _model_to_toml(self, instance: ConfigType) -> str:
+        """Convert a Pydantic model to TOML format."""
+        lines: list[str] = ["# Default configuration"]
+
+        def _dict_to_toml(data: dict[str, Any], prefix: str = "") -> None:
+            for key, value in data.items():
+                full_key: str = f"{prefix}.{key}" if prefix else key
+
+                if isinstance(value, dict):
+                    lines.append(f"\n[{full_key}]")
+                    for sub_key, sub_value in value.items():
+                        lines.append(f"{sub_key} = {self._format_toml_value(sub_value)}")
+                elif not prefix:
+                    lines.append(f"{key} = {self._format_toml_value(value)}")
+
+        _dict_to_toml(instance.model_dump())
+        return "\n".join(lines)
+
+    def _format_toml_value(self, value: Any) -> str:
+        """Format a value for TOML output."""
+        if isinstance(value, str):
+            return f'"{value}"'
+        if isinstance(value, bool):
+            return str(value).lower()
+        if isinstance(value, list):
+            formatted_items = [self._format_toml_value(item) for item in value]
+            return f"[{', '.join(formatted_items)}]"
+        if value is None:
+            return '"null"'
+        return str(value)
+
+
+if __name__ == "__main__":
+    # Example usage and models
+    class DatabaseConfig(BaseModel):
+        """Configuration for an example database connection."""
+
+        host: str = "localhost"
+        port: int = 5432
+        username: str = "app"
+        password: str = "secret"  # noqa: S105 This is just an example
+        database: str = "myapp"
+
+    class LoggingConfig(BaseModel):
+        """Configuration for an example logging setup."""
+
+        level: str = "INFO"
+        format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        file: str | None = None
+
+        _validate_file = nullable_string_validator("file")
+
+    class AppConfig(BaseModel):
+        """Example application configuration model."""
+
+        database: DatabaseConfig = DatabaseConfig()
+        logging: LoggingConfig = LoggingConfig()
+        environment: str = "development"
+        debug: bool = False
+        api_key: str = "your-api-key-here"
+        allowed_hosts: list[str] = ["localhost", "127.0.0.1"]
+
+    def get_config_manager(env: str = "dev") -> ConfigManager[AppConfig]:
+        """Get a configured ConfigManager instance."""
+        return ConfigManager[AppConfig](
+            config_model=AppConfig,
+            config_path=Path("config"),
+            env=env,
+        )
+
+    config_manager: ConfigManager[AppConfig] = get_config_manager("development")
+    config_manager.create_default_config()
+    config: AppConfig = config_manager.config
+
+    print(f"Database host: {config.database.host}")
+    print(f"Debug mode: {config.debug}")
+    print(f"Environment: {config.environment}")
+
+    # Test environment variable override
+    # Set: APP_DATABASE_HOST=production-db.example.com
+    # Set: APP_DEBUG=true

bear_utils/config/dir_manager.py

@@ -1,12 +1,17 @@
+"""Directory Manager Module for Bear Utils."""
+
 from dataclasses import dataclass
 from pathlib import Path
+from typing import ClassVar
 
 
 @dataclass
 class DirectoryManager:
-    _base_path: Path = Path.home() / ".config" / "bear_utils"
-    _settings_path: Path = _base_path / "settings"
-    _temp_path: Path = _base_path / "temp"
+    """A class to manage directories for bear_utils."""
+
+    _base_path: ClassVar[Path] = Path.home() / ".config" / "bear_utils"
+    _settings_path: ClassVar[Path] = _base_path / "settings"
+    _temp_path: ClassVar[Path] = _base_path / "temp"
 
     def setup(self) -> None:
         """Ensure the base, settings, and temp directories exist."""