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

bear_utils/config/settings_manager.py

@@ -1,206 +1,140 @@
+"""Settings Manager Module for Bear Utils."""
+
 import atexit
-from argparse import Namespace
+from collections.abc import Generator
 from contextlib import contextmanager
 from pathlib import Path
-from shelve import Shelf
-from typing import Any
+from typing import Any, Self
 
-from singleton_base.singleton_base_new import SingletonBase
+from tinydb import Query, TinyDB
 
 
 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)
+    path: Path = Path.home() / ".config" / "bear_utils"
+    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
+    """A class to manage settings using TinyDB and an in-memory cache."""
 
-    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)
+    __slots__ = ("cache", "db", "file_path", "settings_name")
+
+    def __init__(self, settings_name: str) -> None:
+        """Initialize the SettingsManager with a specific settings name."""
+        self.settings_name = settings_name
+        self.cache: dict[str, Any] = {}
+        self.file_path: Path = get_bear_config_path() / f"{settings_name}.json"
+        self.db: TinyDB = TinyDB(self.file_path, indent=4, ensure_ascii=False)
 
         atexit.register(self.close)
-        self._load_existing_settings()
+        self._load_cache()
 
-    def __getattr__(self, key: str):
+    def __getattr__(self, key: str) -> Any:
         """Handle dot notation access for settings."""
+        if key in self.__slots__:
+            raise AttributeError(f"'{key}' not initialized")
         if key.startswith("_"):
             raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{key}'")
         return self.get(key)
 
-    def __setattr__(self, key: str, value):
+    def __setattr__(self, key: str, value: Any) -> None:
         """Handle dot notation assignment for settings."""
-        if not hasattr(self, "_initialized"):
+        if key in self.__slots__:
             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)
+        self.set(key=key, value=value)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a setting value."""
+        if key in self.cache:
+            return self.cache[key]
+        if result := self.db.search(Query().key == key):
+            value = result[0]["value"]
+            self.cache[key] = value
+            return value
+        return default
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a setting value."""
+        self.db.upsert({"key": key, "value": value}, Query().key == key)
+        self.cache[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()
+        """Check if a setting exists."""
+        return key in self.cache or self.db.contains(Query().key == key)
+
+    def _load_cache(self) -> None:
+        """Load all settings into cache."""
+        for record in self.db.all():
+            self.cache[record["key"]] = record["value"]
+
+    def open(self) -> None:
+        """Reopen the settings file after it's been closed/destroyed."""
+        self.db = TinyDB(self.file_path, indent=4, ensure_ascii=False)
+        self.cache = {}
+        self._load_cache()
+
+    def close(self) -> None:
+        """Close the database."""
+        if hasattr(self, "db"):
+            self.db.close()
+        if hasattr(self, "cache"):
+            self.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():
+        """Delete the settings file."""
+        if self.file_path.exists():
             self.close()
-            file_path.unlink()
-            self.settings_cache.clear()
-            object.__setattr__(self, "shelf", None)
+            self.file_path.unlink()
+            self.cache.clear()
             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())
+        return list(self.cache.keys())
 
-    def items(self):
+    def items(self) -> list[tuple[str, Any]]:
         """Get all setting key-value pairs."""
-        for key in self.keys():
-            yield key, self.settings_cache.get(key)
+        return list(self.cache.items())
 
-    def values(self):
+    def values(self) -> list[Any]:
         """Get all setting values."""
-        for key in self.keys():
-            yield self.settings_cache.get(key)
+        return list(self.cache.values())
 
-    def __repr__(self):
-        """String representation of the SettingsManager."""
-        return f"<SettingsManager settings_name='{self.settings_name}'>"
+    def __len__(self):
+        return len(self.cache)
 
-    def __str__(self):
-        """String representation of the SettingsManager."""
-        return f"SettingsManager for '{self.settings_name}' with {len(self.keys())} settings."
+    def __enter__(self) -> Self:
+        return self
 
-    def __len__(self):
-        """Get the number of settings."""
-        return len(self.keys())
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"<SettingsManager settings_name='{self.settings_name}'>"
 
+    def __str__(self) -> str:
+        return f"SettingsManager for '{self.settings_name}' with {len(self.keys())} settings."
 
-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)
+_settings_managers: dict[str, SettingsManager] = {}
 
 
 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)
+    """Get or create a SettingsManager instance."""
+    if settings_name not in _settings_managers:
+        _settings_managers[settings_name] = SettingsManager(settings_name=settings_name)
+    return _settings_managers[settings_name]
 
 
 @contextmanager
-def settings(settings_name: str):
+def settings(settings_name: str) -> Generator[SettingsManager]:
     """Context manager for SettingsManager."""
     sm: SettingsManager = get_settings_manager(settings_name)
     try:
@@ -209,24 +143,13 @@ def settings(settings_name: str):
         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))
+if __name__ == "__main__":
+    # Example usage of the SettingsManager
+    with settings(settings_name="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}")
+        print(sm.file_path)

bear_utils/constants/__init__.py

@@ -1,4 +1,5 @@
-from os import getenv
+"""Constants Module for Bear Utils."""
+
 from pathlib import Path
 
 VIDEO_EXTS = [".mp4", ".mov", ".avi", ".mkv"]

bear_utils/constants/_exceptions.py

@@ -1,3 +1,8 @@
-class UserCancelled(Exception):
+"""Custom exceptions for the application."""
+
+
+class UserCancelledError(Exception):
+    """Exception raised when a user cancels an operation."""
+
     def __init__(self, message: str = "User cancelled the operation"):
         super().__init__(message)

bear_utils/constants/date_related.py

@@ -1,3 +1,5 @@
+"""A module containing constants related to date and time formatting."""
+
 from bear_epoch_time.constants.date_related import (
     DATE_FORMAT,
     DATE_TIME_FORMAT,

bear_utils/constants/logger_protocol.py

@@ -0,0 +1,28 @@
+"""A protocol for logging classes for general use."""
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class LoggerProtocol(Protocol):
+    """A protocol for logging classes."""
+
+    def debug(self, message: object, *args, **kwargs) -> None:
+        """Log a debug message."""
+        ...
+
+    def info(self, message: object, *args, **kwargs) -> None:
+        """Log an info message."""
+        ...
+
+    def warning(self, message: object, *args, **kwargs) -> None:
+        """Log a warning message."""
+        ...
+
+    def error(self, message: object, *args, **kwargs) -> None:
+        """Log an error message."""
+        ...
+
+    def verbose(self, message: object, *args, **kwargs) -> None:
+        """Log a verbose message."""
+        ...

bear_utils/constants/time_related.py

@@ -1,3 +1,5 @@
+"""A module containing constants related to time calculations."""
+
 from typing import Literal
 
 MINUTES_IN_HOUR: Literal[60] = 60

bear_utils/database/__init__.py

@@ -1,3 +1,5 @@
+"""Database Manager Module for managing database connections and operations."""
+
 from ._db_manager import DatabaseManager, SingletonDB
 
 __all__ = [

bear_utils/database/_db_manager.py

@@ -1,3 +1,5 @@
+"""Database Manager Module for managing database connections and operations."""
+
 import atexit
 from collections.abc import Generator
 from contextlib import contextmanager
@@ -10,7 +12,7 @@ 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
+from bear_utils.constants._lazy_typing import TableType
 
 
 class DatabaseManager:
@@ -45,8 +47,7 @@ class DatabaseManager:
     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
+            return session.query(table_obj).all()
 
     def count_records(self, table_obj: type[TableType]) -> int:
         """Count the number of records in a table."""
@@ -54,20 +55,20 @@ class DatabaseManager:
             count: int = session.query(table_obj).count()
         return count
 
-    def get_records_by_var(self, table_obj: type[TableType], variable: str, value) -> list[TableType]:
+    def get_records_by_var(self, table_obj: type[TableType], variable: str, value: str) -> 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:
+    def count_records_by_var(self, table_obj: type[TableType], variable: str, value: str) -> 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]:
+    def open_session(self) -> Generator[Session, Any]:
         """Provide a transactional scope around a series of operations."""
         session: Session = self.session()
         try:
@@ -81,15 +82,15 @@ class DatabaseManager:
         """Get a new session."""
         return self.session()
 
-    def close_session(self):
+    def close_session(self) -> None:
         """Close the session."""
         self.session.remove()
 
-    def create_tables(self):
+    def create_tables(self) -> None:
         """Create all tables defined by Base"""
         self.metadata.create_all(self.engine)
 
-    def close_all(self):
+    def close_all(self) -> None:
         """Close all sessions and connections."""
         self.session.close()
         self.engine.dispose()
@@ -98,7 +99,5 @@ class DatabaseManager:
 class SingletonDB(DatabaseManager, SingletonBase):
     """Singleton class for DatabaseManager, uses SingletonBase to inject singleton pattern."""
 
-    ...
-
 
 __all__ = ["DatabaseManager", "SingletonDB"]

bear_utils/events/__init__.py

@@ -1,3 +1,5 @@
+"""A module for event handling in Bear Utils."""
+
 from .events_class import Events
 from .events_module import clear_all, clear_handlers_for_event, dispatch_event, event_handler, set_handler
 
@@ -10,7 +12,7 @@ __all__ = [
     "clear_handlers_for_event",
     "dispatch_event",
     "event_handler",
+    "publish",
     "set_handler",
     "subscribe",
-    "publish",
 ]

bear_utils/events/events_class.py

@@ -1,11 +1,15 @@
+"""A module for event handling in Bear Utils."""
+
 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
+from .events_module import (
+    clear_all as _clear_all,
+    clear_handlers_for_event as _clear_handlers_for_event,
+    dispatch_event as _dispatch_event,
+    event_handler as _event_handler,
+    set_handler as _set_handler,
+)
 
 Callback = Callable[..., Any]
 
@@ -18,8 +22,8 @@ class Events:
     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."""
-
+        Can be used as a decorator when ``func`` is omitted.
+        """
         if func is None:
             return _event_handler(event_name)
         _set_handler(event_name, func)
@@ -27,22 +31,18 @@ class Events:
 
     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

bear_utils/events/events_module.py

@@ -1,24 +1,28 @@
+"""Event handling module for Bear Utils."""
+
 import asyncio
-import weakref
 from collections import defaultdict
 from collections.abc import Callable
 from functools import wraps
 from types import MethodType
-from typing import Any, TypeAlias
+from typing import Any
+import weakref
 from weakref import WeakMethod, ref
 
-from ..extras._async_helpers import is_async_function
+from bear_utils.extras._async_helpers import is_async_function
 
-Callback: TypeAlias = Callable[..., Any]
+Callback = Callable[..., Any]
 
 _event_registry: dict[str, weakref.WeakSet[Callback]] = defaultdict(weakref.WeakSet)
 
 
 def clear_handlers_for_event(event_name: str) -> None:
+    """Remove all handlers associated with a specific event."""
     _event_registry.pop(event_name, None)
 
 
 def clear_all() -> None:
+    """Remove all registered event handlers."""
     _event_registry.clear()
 
 
@@ -34,6 +38,7 @@ def _make_callback(name: str) -> Callable[[Any], None]:
 
 
 def set_handler(name: str, func: Callback) -> None:
+    """Register a function as a handler for a specific event."""
     if isinstance(func, MethodType):
         _event_registry[name].add(WeakMethod(func, _make_callback(name)))
     else:
@@ -41,12 +46,13 @@ def set_handler(name: str, func: Callback) -> None:
 
 
 def dispatch_event(name: str, *args, **kwargs) -> Any | None:
-    results = list()
+    """Dispatch an event to all registered handlers."""
+    results: list[Any] = []
     for func in _event_registry.get(name, []):
         if is_async_function(func):
-            result = asyncio.run(func(*args, **kwargs))
+            result: Any = asyncio.run(func(*args, **kwargs))
         else:
-            result = func(*args, **kwargs)
+            result: Any = func(*args, **kwargs)
             results.append(result)
     if not results:
         return None
@@ -54,9 +60,12 @@ def dispatch_event(name: str, *args, **kwargs) -> Any | None:
 
 
 def event_handler(event_name: str) -> Callable[[Callback], Callback]:
+    """Decorator to register a callback as an event handler for a specific event."""
+
     def decorator(callback: Callback) -> Callback:
         @wraps(callback)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args, **kwargs) -> Any:
+            """Wrapper to register the callback and call it."""
             return callback(*args, **kwargs)
 
         set_handler(event_name, wrapper)

bear_utils/extras/__init__.py

@@ -1,3 +1,5 @@
+"""A module for various utilities in Bear Utils extras."""
+
 from singleton_base import SingletonBase
 
 from ._tools import ClipboardManager, clear_clipboard, copy_to_clipboard, fmt_header, paste_from_clipboard
@@ -6,15 +8,15 @@ from .wrappers.add_methods import add_comparison_methods
 
 __all__ = [
     "OS",
+    "ClipboardManager",
+    "SingletonBase",
+    "add_comparison_methods",
+    "clear_clipboard",
+    "copy_to_clipboard",
+    "fmt_header",
     "get_platform",
     "is_linux",
     "is_macos",
     "is_windows",
-    "ClipboardManager",
-    "copy_to_clipboard",
     "paste_from_clipboard",
-    "clear_clipboard",
-    "fmt_header",
-    "add_comparison_methods",
-    "SingletonBase",
 ]

bear_utils/extras/_async_helpers.py

@@ -1,10 +1,9 @@
-import inspect
 from collections.abc import Callable
+import inspect
 
 
 def is_async_function(func: Callable) -> bool:
-    """
-    Check if a function is asynchronous.
+    """Check if a function is asynchronous.
 
     Args:
         func (Callable): The function/method to check.