bear-utils 0.7.11__py3-none-any.whl

bear_utils/config/config_manager.py

@@ -0,0 +1,92 @@
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel
+
+ConfigType = TypeVar("ConfigType", bound=BaseModel)
+
+# TODO: Get around to potentially using this, right now it is just masturbation
+
+
+class ConfigManager(Generic[ConfigType]):
+    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
+        self._config: ConfigType | None = None
+
+    def _get_env_overrides(self) -> dict[str, Any]:
+        """Convert environment variables to nested dictionary structure."""
+        env_config: dict[str, Any] = {}
+
+        for key, value in os.environ.items():
+            if not key.startswith("APP_"):
+                continue
+
+            # Convert APP_DATABASE_HOST to ['database', 'host']
+            parts = key.lower().replace("app_", "").split("_")
+
+            # Build nested dictionary
+            current = env_config
+            for part in parts[:-1]:
+                current = current.setdefault(part, {})
+            current[parts[-1]] = value
+
+        return env_config
+
+    @lru_cache
+    def load(self) -> ConfigType:
+        # Load order (later overrides earlier):
+        # 1. default.yaml
+        # 2. {env}.yaml
+        # 3. local.yaml (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)
+
+    @property
+    def config(self) -> ConfigType:
+        if self._config is None:
+            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

bear_utils/config/dir_manager.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class DirectoryManager:
+    _base_path: Path = Path.home() / ".config" / "bear_utils"
+    _settings_path: Path = _base_path / "settings"
+    _temp_path: Path = _base_path / "temp"
+
+    def setup(self) -> None:
+        """Ensure the base, settings, and temp directories exist."""
+        self._base_path.mkdir(parents=True, exist_ok=True)
+        self._settings_path.mkdir(parents=True, exist_ok=True)
+        self._temp_path.mkdir(parents=True, exist_ok=True)
+
+    def clear_temp(self) -> None:
+        """Clear the temporary directory."""
+        if self.temp_path.exists():
+            for item in self.temp_path.iterdir():
+                if item.is_file() or item.is_symlink():
+                    item.unlink()
+                elif item.is_dir():
+                    item.rmdir()
+
+    @property
+    def base_path(self) -> Path:
+        """Get the base path for bear_utils."""
+        return self._base_path
+
+    @property
+    def settings_path(self) -> Path:
+        """Get the path to the settings directory."""
+        return self._settings_path
+
+    @property
+    def temp_path(self) -> Path:
+        """Get the path to the temporary directory."""
+        return self._temp_path
+
+
+def get_base_path() -> Path:
+    """Get the base path for bear_utils."""
+    return DirectoryManager().base_path
+
+
+def get_settings_path() -> Path:
+    """Get the path to the settings directory."""
+    return DirectoryManager().settings_path
+
+
+def get_temp_path() -> Path:
+    """Get the path to the temporary directory."""
+    return DirectoryManager().temp_path
+
+
+def setup_directories() -> None:
+    """Set up the necessary directories for bear_utils."""
+    DirectoryManager().setup()
+
+
+def clear_temp_directory() -> None:
+    """Clear the temporary directory."""
+    DirectoryManager().clear_temp()

bear_utils/config/settings_manager.py

@@ -0,0 +1,232 @@
+import atexit
+from argparse import Namespace
+from contextlib import contextmanager
+from pathlib import Path
+from shelve import Shelf
+from typing import Any
+
+from singleton_base.singleton_base_new import SingletonBase
+
+
+def get_bear_config_path() -> Path:
+    """Get the path to the bear configuration path"""
+    path = Path.home() / ".config" / "bear_utils"
+    if not path.exists():
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_config_file_path(filename: str) -> Path:
+    """Get the path to a specific configuration file in the bear configuration path"""
+    config_path = get_bear_config_path()
+    return config_path / filename
+
+
+class SettingsCache(Namespace):
+    """A Namespace to hold settings in memory."""
+
+    def __init__(self):
+        super().__init__()
+
+    def clear(self):
+        """Clear the settings cache."""
+        self.__dict__.clear()
+
+    def set(self, key: str, value):
+        """Set a value in the settings cache."""
+        setattr(self, key, value)
+
+    def get(self, key: str, default=None):
+        """Get a value from the settings cache."""
+        return getattr(self, key, default)
+
+    def has(self, key: str) -> bool:
+        """Check if a key exists in the settings cache."""
+        return hasattr(self, key)
+
+
+class SettingsManager:
+    settings_name: str
+    shelf: Shelf
+    settings_cache: SettingsCache
+
+    def __init__(self, settings_name: str):
+        object.__setattr__(self, "settings_name", settings_name)
+        object.__setattr__(self, "settings_cache", SettingsCache())
+        object.__setattr__(self, "shelf", self._open())
+        object.__setattr__(self, "_initialized", True)
+
+        atexit.register(self.close)
+        self._load_existing_settings()
+
+    def __getattr__(self, key: str):
+        """Handle dot notation access for settings."""
+        if key.startswith("_"):
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{key}'")
+        return self.get(key)
+
+    def __setattr__(self, key: str, value):
+        """Handle dot notation assignment for settings."""
+        if not hasattr(self, "_initialized"):
+            object.__setattr__(self, key, value)
+            return
+
+        if key in ["settings_name", "settings_cache", "shelf"] or key.startswith("_"):
+            raise AttributeError(f"Cannot modify '{key}' after initialization")
+
+        self.set(key, value)
+
+    def get(self, key: str, default=None):
+        """Get a setting value by key with optional default."""
+        try:
+            if self.settings_cache.has(key):
+                return self.settings_cache.get(key, default)
+            elif self._shelf_has(key):
+                return self.shelf[key]
+            else:
+                return default
+        except Exception as e:
+            return default
+
+    def set(self, key: str, value):
+        """Set a setting value by key."""
+        self.shelf[key] = value
+        self.settings_cache.set(key, value)
+
+    def has(self, key: str) -> bool:
+        """Check if a setting exists by key."""
+        return self.settings_cache.has(key) or self._shelf_has(key)
+
+    def _shelf_has(self, key: str) -> bool:
+        """Check if a setting exists by key."""
+        return key in self.shelf
+
+    def open(self):
+        object.__setattr__(self, "shelf", self._open())
+        self._load_existing_settings()
+
+    def _open(self) -> Shelf:
+        """Open the settings file."""
+        import shelve
+
+        try:
+            shelf: Shelf[Any] = shelve.open(get_config_file_path(self.settings_name))
+            return shelf
+        except Exception as e:
+            raise RuntimeError(f"Warning: Could not open settings file '{self.settings_name}': {e}")
+
+    def _load_existing_settings(self):
+        """Load existing settings from shelf into namespace."""
+        for key in self.shelf:
+            if not self.settings_cache.has(key):
+                self.settings_cache.set(key, self.shelf[key])
+
+    def close(self):
+        """Close the settings file."""
+        if self.shelf is not None:
+            self.shelf.close()
+        if self.settings_cache is not None:
+            self.settings_cache.clear()
+
+    def destroy_settings(self) -> bool:
+        """Delete the settings file, a bit nuclear and will require calling open() again."""
+        file_path = get_config_file_path(self.settings_name)
+        if file_path.exists():
+            self.close()
+            file_path.unlink()
+            self.settings_cache.clear()
+            object.__setattr__(self, "shelf", None)
+            return True
+        return False
+
+    def __del__(self):
+        """Destructor to ensure the shelf is closed."""
+        self.close()
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+    def __contains__(self, key: str) -> bool:
+        """Check if a setting exists."""
+        return self.has(key)
+
+    def keys(self) -> list[str]:
+        """Get all setting keys."""
+        return list(vars(self.settings_cache).keys())
+
+    def items(self):
+        """Get all setting key-value pairs."""
+        for key in self.keys():
+            yield key, self.settings_cache.get(key)
+
+    def values(self):
+        """Get all setting values."""
+        for key in self.keys():
+            yield self.settings_cache.get(key)
+
+    def __repr__(self):
+        """String representation of the SettingsManager."""
+        return f"<SettingsManager settings_name='{self.settings_name}'>"
+
+    def __str__(self):
+        """String representation of the SettingsManager."""
+        return f"SettingsManager for '{self.settings_name}' with {len(self.keys())} settings."
+
+    def __len__(self):
+        """Get the number of settings."""
+        return len(self.keys())
+
+
+class SettingsSupervisor(SingletonBase):
+    def __init__(self):
+        self._settings_managers = {}
+
+    def _get_instance(self, settings_name: str) -> SettingsManager:
+        """Get or create a SettingsManager instance."""
+        if settings_name in self._settings_managers:
+            return self._settings_managers[settings_name]
+        return SettingsManager(settings_name)
+
+
+def get_settings_manager(settings_name: str) -> SettingsManager:
+    """Get the SettingsManager instance for a given settings name."""
+    supervisor: SettingsSupervisor = SettingsSupervisor.get_instance(init=True)
+    return supervisor._get_instance(settings_name)
+
+
+@contextmanager
+def settings(settings_name: str):
+    """Context manager for SettingsManager."""
+    sm: SettingsManager = get_settings_manager(settings_name)
+    try:
+        yield sm
+    finally:
+        sm.close()
+
+
+__all__: list[str] = ["SettingsManager", "settings", "get_settings_manager"]
+
+# if __name__ == "__main__":
+#     with settings("example_settings") as sm:
+#         sm.sample_setting = "This is a sample setting"
+#         print(sm.sample_setting)
+#         print(sm.keys())
+#         for key, value in sm.items():
+#             print("This is items()")
+#             print(f"Key: {key}, Value: {value}")
+#         for value in sm.values():
+#             print("This is values()")
+#             print(value)
+#         print(len(sm))
+#         print(sm)
+#         if sm.destroy_settings():
+#             print("Settings destroyed successfully.")
+#         sm.open()
+#         print(sm.keys())
+#         sm.test = "Test setting"
+#         print(len(sm))

bear_utils/constants/__init__.py

@@ -0,0 +1,16 @@
+from os import getenv
+from pathlib import Path
+
+VIDEO_EXTS = [".mp4", ".mov", ".avi", ".mkv"]
+"""Extensions for video files."""
+IMAGE_EXTS = [".jpg", ".jpeg", ".png", ".gif"]
+"""Extensions for image files."""
+FILE_EXTS = IMAGE_EXTS + VIDEO_EXTS
+"""Extensions for both image and video files."""
+
+PATH_TO_DOWNLOADS = Path.home() / "Downloads"
+"""Path to the Downloads folder."""
+PATH_TO_PICTURES = Path.home() / "Pictures"
+"""Path to the Pictures folder."""
+GLOBAL_VENV = Path.home() / ".global_venv"
+"""Path to the global virtual environment."""

bear_utils/constants/_exceptions.py

@@ -0,0 +1,3 @@
+class UserCancelled(Exception):
+    def __init__(self, message: str = "User cancelled the operation"):
+        super().__init__(message)

bear_utils/constants/_lazy_typing.py

@@ -0,0 +1,15 @@
+from typing import Literal, TypeVar
+
+from sqlalchemy.ext.declarative import DeclarativeMeta
+
+LitInt = Literal["int"]
+LitFloat = Literal["float"]
+LitStr = Literal["str"]
+LitBool = Literal["bool"]
+
+OptInt = int | None
+OptFloat = float | None
+OptStr = str | None
+OptBool = bool | None
+
+TableType = TypeVar("TableType", bound=DeclarativeMeta)

bear_utils/constants/date_related.py

@@ -0,0 +1,36 @@
+from typing import LiteralString
+
+from pytz import UTC, timezone
+from pytz.tzinfo import BaseTzInfo, DstTzInfo, StaticTzInfo
+
+TimeZoneType = BaseTzInfo | DstTzInfo | StaticTzInfo
+
+DATE_FORMAT = "%m-%d-%Y"
+"""Date format"""
+
+TIME_FORMAT = "%I:%M %p"
+"""Time format with 12 hour format"""
+
+TIME_FORMAT_WITH_SECONDS: LiteralString = "%I:%M:%S %p"
+"""Time format with 12 hour format and seconds"""
+
+DATE_TIME_FORMAT: LiteralString = f"{DATE_FORMAT} {TIME_FORMAT}"
+"""Datetime format with 12 hour format"""
+
+DT_FORMAT_WITH_SECONDS: LiteralString = f"{DATE_FORMAT} {TIME_FORMAT_WITH_SECONDS}"
+"""Datetime format with 12 hour format and seconds"""
+
+DT_FORMAT_WITH_TZ: LiteralString = f"{DATE_TIME_FORMAT} %Z"
+"""Datetime format with 12 hour format and timezone"""
+
+DT_FORMAT_WITH_TZ_AND_SECONDS: LiteralString = f"{DT_FORMAT_WITH_SECONDS} %Z"
+"""Datetime format with 12 hour format, seconds, and timezone"""
+
+PT_TIME_ZONE: TimeZoneType = timezone("America/Los_Angeles")
+"""Default timezone, a Pacific Time Zone using a pytz timezone object"""
+
+UTC_TIME_ZONE: TimeZoneType = UTC
+"""UTC timezone, a UTC timezone using a pytz timezone object"""
+
+CEST_TIME_ZONE: TimeZoneType = timezone("Europe/Berlin")  # Central European Summer Time, I GUESS!
+"""Central European Summer Time timezone, a CEST timezone using a pytz timezone object"""

bear_utils/constants/time_related.py

@@ -0,0 +1,22 @@
+from typing import Literal
+
+MINUTES_IN_HOUR: Literal[60] = 60
+"""60 minutes in an hour"""
+
+HOURS_IN_DAY: Literal[24] = 24
+"""24 hours in a day"""
+
+DAYS_IN_MONTH: Literal[30] = 30
+"""30 days in a month, approximation for a month"""
+
+SECONDS_IN_MINUTE: Literal[60] = 60
+"""60 seconds in a minute"""
+
+SECONDS_IN_HOUR: Literal[3600] = SECONDS_IN_MINUTE * MINUTES_IN_HOUR
+"""60 * 60 = 3600 seconds in an hour"""
+
+SECONDS_IN_DAY: Literal[86400] = SECONDS_IN_HOUR * HOURS_IN_DAY
+"""24 * 60 * 60 = 86400 seconds in a day"""
+
+SECONDS_IN_MONTH: Literal[2592000] = SECONDS_IN_DAY * DAYS_IN_MONTH
+"""30 * 24 * 60 * 60 = 2592000 seconds in a month"""

bear_utils/database/__init__.py

@@ -0,0 +1,6 @@
+from ._db_manager import DatabaseManager, SingletonDB
+
+__all__ = [
+    "DatabaseManager",
+    "SingletonDB",
+]

bear_utils/database/_db_manager.py

@@ -0,0 +1,104 @@
+import atexit
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, ClassVar
+
+from singleton_base import SingletonBase
+from sqlalchemy import Engine, MetaData, create_engine
+from sqlalchemy.ext.declarative import DeclarativeMeta
+from sqlalchemy.orm import declarative_base, scoped_session, sessionmaker
+from sqlalchemy.orm.session import Session
+
+from ..constants._lazy_typing import TableType
+
+
+class DatabaseManager:
+    _base: ClassVar[DeclarativeMeta | None] = None
+
+    @classmethod
+    def set_base(cls, base: DeclarativeMeta) -> None:
+        """Set the base class for the database manager."""
+        cls._base = base
+
+    @classmethod
+    def get_base(cls) -> DeclarativeMeta:
+        """Get the base class for the database manager."""
+        if cls._base is None:
+            cls.set_base(declarative_base())
+        if cls._base is None:
+            raise ValueError("Base class is not set, failed to set base.")
+        return cls._base
+
+    def __init__(self, db_url: str | Path | None = None):
+        if db_url is None or db_url == "":
+            raise ValueError("Database URL cannot be None or empty.")
+        self.db_url: str = str(db_url)
+        self.engine: Engine = create_engine(self.db_url, echo=False)
+        base: DeclarativeMeta = DatabaseManager.get_base()
+        self.metadata: MetaData = base.metadata
+        self.SessionFactory = sessionmaker(bind=self.engine)
+        self.session = scoped_session(self.SessionFactory)
+        atexit.register(self.close_all)
+        self.create_tables()
+
+    def get_all_records(self, table_obj: type[TableType]) -> list[TableType]:
+        """Get all records from a table."""
+        with self.open_session() as session:
+            records = session.query(table_obj).all()
+        return records
+
+    def count_records(self, table_obj: type[TableType]) -> int:
+        """Count the number of records in a table."""
+        with self.open_session() as session:
+            count: int = session.query(table_obj).count()
+        return count
+
+    def get_records_by_var(self, table_obj: type[TableType], variable: str, value) -> list[TableType]:
+        """Get records from a table by a specific variable."""
+        with self.open_session() as session:
+            records: list[TableType] = session.query(table_obj).filter(getattr(table_obj, variable) == value).all()
+        return records
+
+    def count_records_by_var(self, table_obj: type[TableType], variable: str, value) -> int:
+        """Count the number of records in a table by a specific variable."""
+        with self.open_session() as session:
+            count: int = session.query(table_obj).filter(getattr(table_obj, variable) == value).count()
+        return count
+
+    @contextmanager
+    def open_session(self) -> Generator[Session, Any, None]:
+        """Provide a transactional scope around a series of operations."""
+        session: Session = self.session()
+        try:
+            yield session
+            session.commit()
+        except Exception:
+            session.rollback()
+            raise
+
+    def get_session(self) -> Session:
+        """Get a new session."""
+        return self.session()
+
+    def close_session(self):
+        """Close the session."""
+        self.session.remove()
+
+    def create_tables(self):
+        """Create all tables defined by Base"""
+        self.metadata.create_all(self.engine)
+
+    def close_all(self):
+        """Close all sessions and connections."""
+        self.session.close()
+        self.engine.dispose()
+
+
+class SingletonDB(DatabaseManager, SingletonBase):
+    """Singleton class for DatabaseManager, uses SingletonBase to inject singleton pattern."""
+
+    ...
+
+
+__all__ = ["DatabaseManager", "SingletonDB"]

bear_utils/events/__init__.py

@@ -0,0 +1,16 @@
+from .events_class import Events
+from .events_module import clear_all, clear_handlers_for_event, dispatch_event, event_handler, set_handler
+
+subscribe = event_handler
+publish = dispatch_event
+
+__all__ = [
+    "Events",
+    "clear_all",
+    "clear_handlers_for_event",
+    "dispatch_event",
+    "event_handler",
+    "set_handler",
+    "subscribe",
+    "publish",
+]

bear_utils/events/events_class.py

@@ -0,0 +1,52 @@
+from collections.abc import Callable
+from typing import Any
+
+from .events_module import clear_all as _clear_all
+from .events_module import clear_handlers_for_event as _clear_handlers_for_event
+from .events_module import dispatch_event as _dispatch_event
+from .events_module import event_handler as _event_handler
+from .events_module import set_handler as _set_handler
+
+Callback = Callable[..., Any]
+
+
+class Events:
+    """Simple wrapper exposing :mod:`events_module` functionality as methods."""
+
+    # Method names mirror functions from ``events_module`` for familiarity
+
+    def event_handler(self, event_name: str, func: Callback | None = None):
+        """Register ``func`` as a handler for ``event_name``.
+
+        Can be used as a decorator when ``func`` is omitted."""
+
+        if func is None:
+            return _event_handler(event_name)
+        _set_handler(event_name, func)
+        return func
+
+    def dispatch_event(self, event_name: str, *args, **kwargs) -> Any | None:
+        """Dispatch ``event_name`` to all subscribed handlers."""
+
+        return _dispatch_event(event_name, *args, **kwargs)
+
+    def set_handler(self, event_name: str, func: Callback) -> None:
+        """Register ``func`` as a handler for ``event_name``."""
+
+        _set_handler(event_name, func)
+
+    def clear_handlers_for_event(self, event_name: str) -> None:
+        """Remove all handlers associated with ``event_name``."""
+
+        _clear_handlers_for_event(event_name)
+
+    def clear_all(self) -> None:
+        """Remove all registered event handlers."""
+
+        _clear_all()
+
+    subscribe = event_handler
+    publish = dispatch_event
+
+
+__all__ = ["Events"]