bear-utils 0.8.12__tar.gz → 0.8.14__tar.gz

{bear_utils-0.8.12 → bear_utils-0.8.14}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.8.12
+current_version = 0.8.14
 
 [bumpversion:file:pyproject.toml]
 

{bear_utils-0.8.12 → bear_utils-0.8.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.12
+Version: 0.8.14
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
 Author-email: chaz <bright.lid5647@fastmail.com>
 Requires-Python: >=3.12
@@ -22,7 +22,7 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: uvicorn>=0.35.0
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.8.12
+# Bear Utils v# Bear Utils v0.8.14
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.8.12 → bear_utils-0.8.14}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.12
+# Bear Utils v# Bear Utils v0.8.14
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.8.12 → bear_utils-0.8.14}/config/pytest.ini

@@ -6,6 +6,13 @@ addopts =
   --cov-config config/coverage.ini
 testpaths =
   tests
+filterwarnings =
+  ignore::DeprecationWarning
+  ignore::PendingDeprecationWarning
+  ignore::FutureWarning
+  ignore::ImportWarning
+  ignore::ResourceWarning
+  ignore::UserWarning
 
 # action:message_regex:warning_class:module_regex:line
 filterwarnings =

{bear_utils-0.8.12 → bear_utils-0.8.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.12"
+version = "0.8.14"
 description = "Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things."
 authors = [{ name = "chaz", email = "bright.lid5647@fastmail.com" }]
 readme = "README.md"
@@ -61,6 +61,12 @@ addopts = "-v"
 markers = [
     "visual: marks tests as visual verification tests (deselect with '-m \"not visual\"')"
 ]
+filterwarnings = [
+    "ignore::PendingDeprecationWarning",
+    "ignore::ImportWarning",
+    "ignore::ResourceWarning",
+    "ignore::UserWarning",
+]
 
 [tool.pyright]
 include = ["src"]

{bear_utils-0.8.12 → bear_utils-0.8.14}/src/bear_utils/config/settings_manager.py

@@ -3,33 +3,44 @@
 import atexit
 from collections.abc import Generator
 from contextlib import contextmanager
+import hashlib
 from pathlib import Path
 from typing import Any, Self
 
 from tinydb import Query, TinyDB
 
+DEFAULT_PATH: Path = Path.home() / ".config" / "bear_utils"
 
-def get_config_folder() -> Path:
+
+def get_config_folder(path: str | Path | None = None) -> Path:
     """Get the path to the bear configuration directory."""
-    config_path: Path = Path.home() / ".bear_utils"
+    config_path: Path = Path(path) if isinstance(path, str) else path or DEFAULT_PATH
     config_path.mkdir(parents=True, exist_ok=True)
     return config_path
 
 
+def get_file_hash(file_path: Path) -> str:
+    """Return the blake2 hash of the file at the given path."""
+    hasher = hashlib.blake2b()
+    with file_path.open("rb") as file:
+        while chunk := file.read(8192):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+
 class SettingsManager:
     """A class to manage settings using TinyDB and an in-memory cache."""
 
-    __slots__ = ("cache", "db", "file_path", "settings_name")
+    __slots__ = ("cache", "db", "file_hash", "file_path", "settings_name")
 
     def __init__(self, settings_name: str, folder_path: str | Path | None = None) -> None:
         """Initialize the SettingsManager with a specific settings name."""
         self.settings_name: str = settings_name
         self.cache: dict[str, Any] = {}
         file_name: str = f"{settings_name}.json"
-        self.file_path: Path = Path(folder_path) / file_name if folder_path else get_config_folder() / file_name
-
+        self.file_path: Path = get_config_folder(folder_path) / file_name
         self.db: TinyDB = TinyDB(self.file_path, indent=4, ensure_ascii=False)
-
+        self.file_hash: str = get_file_hash(self.file_path) if self.file_path.exists() else ""
         atexit.register(self.close)
         self._load_cache()
 
@@ -48,8 +59,19 @@ class SettingsManager:
             return
         self.set(key=key, value=value)
 
+    def invalidate_cache(self) -> None:
+        """Invalidate the in-memory cache."""
+        self.cache.clear()
+        self._load_cache()
+
     def get(self, key: str, default: Any = None) -> Any:
         """Get a setting value."""
+        file_hash = get_file_hash(self.file_path)
+
+        if file_hash != self.file_hash:
+            self.invalidate_cache()
+            self.file_hash = file_hash
+
         if key in self.cache:
             return self.cache[key]
         if result := self.db.search(Query().key == key):

{bear_utils-0.8.12 → bear_utils-0.8.14}/src/bear_utils/logger_manager/_common.py

@@ -1,7 +1,6 @@
-from enum import Enum
 import inspect
 from types import TracebackType
-from typing import Required, TypedDict
+from typing import Literal, Required, TypedDict
 
 
 class ExecValues(TypedDict, total=True):
@@ -10,12 +9,6 @@ class ExecValues(TypedDict, total=True):
     exc_traceback: Required[TracebackType]
 
 
-VERBOSE_FORMAT = "%(asctime)s |%(levelname)s| {%(module)s|%(funcName)s|%(lineno)d} %(message)s"
-VERBOSE_CONSOLE_FORMAT = "%(asctime)s <[{}]{}[/{}]> %(message)s"
-SIMPLE_FORMAT = "%(message)s"
-FIVE_MEGABYTES = 1024 * 1024 * 5
-
-
 class StackLevelTracker:
     STACK_LEVEL_OFFSET = 1
 
@@ -47,18 +40,24 @@ class StackLevelTracker:
         return self.end_depth - (self.start_depth + self.STACK_LEVEL_OFFSET)
 
 
-class LogLevel(Enum):
-    """Enumeration for log levels."""
-
-    VERBOSE = "VERBOSE"
-    DEBUG = "DEBUG"
-    INFO = "INFO"
-    WARNING = "WARNING"
-    ERROR = "ERROR"
-
+VERBOSE_FORMAT = "%(asctime)s |%(levelname)s| {%(module)s|%(funcName)s|%(lineno)d} %(message)s"
+VERBOSE_CONSOLE_FORMAT = "%(asctime)s <[{}]{}[/{}]> %(message)s"
+SIMPLE_FORMAT = "%(message)s"
+FIVE_MEGABYTES = 1024 * 1024 * 5
 
-VERBOSE = LogLevel.VERBOSE
-DEBUG = LogLevel.DEBUG
-INFO = LogLevel.INFO
-WARNING = LogLevel.WARNING
-ERROR = LogLevel.ERROR
+VERBOSE: Literal[5] = 5
+SUCCESS: Literal[15] = 15
+FAILURE: Literal[45] = 45
+
+
+__all__ = [
+    "FAILURE",
+    "FIVE_MEGABYTES",
+    "SIMPLE_FORMAT",
+    "SUCCESS",
+    "VERBOSE",
+    "VERBOSE_CONSOLE_FORMAT",
+    "VERBOSE_FORMAT",
+    "ExecValues",
+    "StackLevelTracker",
+]

bear_utils-0.8.14/src/bear_utils/logger_manager/_log_level.py

@@ -0,0 +1,126 @@
+from functools import cached_property
+from typing import Any, Literal, overload
+
+from pydantic import BaseModel, Field, field_validator
+
+from bear_utils.extras.wrappers.add_methods import add_comparison_methods
+
+FAILURE: Literal[45] = 45
+ERROR: Literal[40] = 40
+WARNING: Literal[30] = 30
+WARN: Literal[30] = WARNING
+INFO: Literal[20] = 20
+SUCCESS: Literal[15] = 15
+DEBUG: Literal[10] = 10
+VERBOSE: Literal[5] = 5
+NOTSET: Literal[0] = 0
+
+
+level_to_name = {
+    FAILURE: "FAILURE",
+    ERROR: "ERROR",
+    WARNING: "WARNING",
+    INFO: "INFO",
+    SUCCESS: "SUCCESS",
+    DEBUG: "DEBUG",
+    VERBOSE: "VERBOSE",
+    NOTSET: "NOTSET",
+}
+
+name_to_level = {
+    "FAILURE": FAILURE,
+    "ERROR": ERROR,
+    "WARN": WARNING,
+    "WARNING": WARNING,
+    "INFO": INFO,
+    "SUCCESS": SUCCESS,
+    "DEBUG": DEBUG,
+    "VERBOSE": VERBOSE,
+    "NOTSET": NOTSET,
+}
+
+
+@add_comparison_methods("value")
+class LogLevel(BaseModel):
+    """Model to represent a logging level."""
+
+    name: str = Field(default="NOTSET", description="Name of the logging level")
+    value: int = Field(default=NOTSET, description="Numeric value of the logging level")
+
+    @field_validator("value")
+    @classmethod
+    def validate_value(cls, value: int) -> int:
+        if value not in level_to_name:
+            raise ValueError(f"Invalid logging level value: {value!r}. Valid values are: {list(level_to_name.keys())}")
+        return value
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, name: str) -> str:
+        if name not in name_to_level:
+            raise ValueError(f"Invalid logging level name: {name!r}. Valid names are: {list(name_to_level.keys())}")
+        return name
+
+
+class LogLevels(BaseModel):
+    """Model to represent a collection of logging levels."""
+
+    notset: LogLevel = Field(default=LogLevel(name="NOTSET", value=NOTSET))
+    verbose: LogLevel = Field(default=LogLevel(name="VERBOSE", value=VERBOSE))
+    debug: LogLevel = Field(default=LogLevel(name="DEBUG", value=DEBUG))
+    info: LogLevel = Field(default=LogLevel(name="INFO", value=INFO))
+    success: LogLevel = Field(default=LogLevel(name="SUCCESS", value=SUCCESS))
+    warning: LogLevel = Field(default=LogLevel(name="WARNING", value=WARNING))
+    error: LogLevel = Field(default=LogLevel(name="ERROR", value=ERROR))
+    failure: LogLevel = Field(default=LogLevel(name="FAILURE", value=FAILURE))
+
+    model_config = {"arbitrary_types_allowed": True, "extra": "forbid"}
+
+    @cached_property
+    def keys(self) -> list[str]:
+        """Get the names of all logging levels."""
+        return [key.upper() for key in LogLevels.model_fields]
+
+    @cached_property
+    def levels(self):  # noqa: ANN202
+        item_dict: dict[str, Any] = {
+            level_name.lower(): getattr(self, level_name.lower()).value for level_name in self.keys
+        }
+        return item_dict.items()
+
+    def get_int(self, name: str) -> int:
+        """Get the integer value of a logging level by name."""
+        if not hasattr(self, name):
+            raise ValueError(f"Invalid logging level name: {name!r}. Valid names are: {self.keys}")
+        return getattr(self, name).value
+
+    @overload
+    def get(self, v: LogLevel) -> LogLevel: ...
+
+    @overload
+    def get(self, v: str) -> LogLevel: ...
+
+    @overload
+    def get(self, v: int) -> LogLevel: ...
+
+    def get(self, v: int | str | LogLevel) -> LogLevel:
+        """Get a logging level by name or value."""
+        if isinstance(v, LogLevel):
+            return v
+        if isinstance(v, str) and v.lower() in self.keys:
+            return getattr(self, v.lower())
+        if isinstance(v, int):
+            for level_name, level_value in self.levels:
+                if level_value == v:
+                    return getattr(self, level_name.lower())
+        return self.notset  # Default to NOTSET if no match found
+
+    def get_name(self, value: int) -> str:
+        """Get the name of a logging level by its integer value."""
+        for level_name, level_value in self.levels:
+            if level_value == value:
+                return level_name
+        raise ValueError(f"Invalid logging level value: {value!r}. Valid values are: {self.keys}")
+
+
+log_levels = LogLevels()

{bear_utils-0.8.12 → bear_utils-0.8.14}/src/bear_utils/logger_manager/_styles.py

@@ -1,11 +1,16 @@
-from logging import DEBUG, ERROR, INFO, WARNING
-from typing import Literal, NotRequired, Required, TypedDict
+from typing import NotRequired, Required, TypedDict
 
 from rich.theme import Theme
 
-VERBOSE: Literal[5] = 5
-SUCCESS: Literal[15] = 15
-FAILURE: Literal[45] = 45
+from bear_utils.logger_manager._log_level import (
+    DEBUG,
+    ERROR,
+    FAILURE,
+    INFO,
+    SUCCESS,
+    VERBOSE,
+    WARNING,
+)
 
 
 class LoggerExtraInfo(TypedDict):

{bear_utils-0.8.12 → bear_utils-0.8.14}/src/bear_utils/logger_manager/loggers/_level_sin.py

@@ -18,6 +18,7 @@ level_to_name = {
     DEBUG: "DEBUG",
     NOTSET: "NOTSET",
 }
+
 name_to_level = {
     "ERROR": ERROR,
     "WARN": WARNING,

bear_utils-0.8.14/src/bear_utils/logger_manager/loggers/basic_logger/__init__.py

@@ -0,0 +1,5 @@
+"""A basic logger to have around just in case the user doesn't already have one."""
+
+from .logger import BasicLogger
+
+__all__ = ["BasicLogger"]

bear_utils-0.8.14/src/bear_utils/logger_manager/loggers/basic_logger/logger.py

@@ -0,0 +1,80 @@
+"""Basic logger using the Rich library."""
+
+from collections.abc import Callable
+
+from rich import inspect
+from rich.console import Console
+from rich.theme import Theme
+
+THEME: dict[str, str] = {
+    "info": "dim green",
+    "debug": "bold blue",
+    "warning": "bold yellow",
+    "error": "bold red",
+    "exception": "bold red",
+    "success": "bold green",
+    "failure": "bold red underline",
+    "verbose": "bold blue",
+}
+
+
+class BasicLogger:
+    """A basic logger that uses the Rich library to print messages to the console."""
+
+    def __init__(self) -> None:
+        """Initialize the BasicLogger with a Rich Console instance."""
+        self.console = Console(theme=Theme(THEME))
+        for level in THEME:
+            method = self.replacement_method(level)
+            setattr(self, level, method)
+
+    def replacement_method(self, level: str) -> Callable:
+        """Create a method that logs messages at the specified level."""
+
+        def method(msg: object, **kwargs) -> None:
+            """Log a message at the specified level with the given style.
+
+            Args:
+                msg (object): The message to log.
+                **kwargs: Additional keyword arguments for formatting.
+            """
+            self.log(level, msg, **kwargs)
+
+        return method
+
+    def log(self, level: str, msg: object, **kwargs) -> None:
+        """Log a message at the specified level.
+
+        Args:
+            level (str): The logging level (e.g., 'info', 'debug', 'warning', etc.).
+            msg (object): The message to log.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        self.console.print(msg, style=level, **kwargs)
+
+    def print(self, msg: object, **kwargs) -> None:
+        """Print a message to the console with the specified style.
+
+        Args:
+            msg (object): The message to print.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        self.console.print(msg, **kwargs)
+
+    def inspect(self, obj: object, **kwargs) -> None:
+        """Inspect an object and print its details to the console.
+
+        Args:
+            obj (object): The object to inspect.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        inspect(obj, console=self.console, **kwargs)
+
+    def print_json(self, data: object, **kwargs) -> None:
+        """Print a JSON object to the console.
+
+        Args:
+            data (object): The JSON data to print.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        self.console.print_json(data=data, **kwargs)

bear_utils-0.8.14/src/bear_utils/logger_manager/loggers/basic_logger/logger.pyi

@@ -0,0 +1,19 @@
+from collections.abc import Callable
+
+from rich.console import Console
+
+class BasicLogger:
+    def __init__(self, console: Console | None = None) -> None: ...
+    def info(self, msg: object, **kwargs) -> None: ...
+    def debug(self, msg: object, **kwargs) -> None: ...
+    def warning(self, msg: object, **kwargs) -> None: ...
+    def error(self, msg: object, **kwargs) -> None: ...
+    def exception(self, msg: object, **kwargs) -> None: ...
+    def success(self, msg: object, **kwargs) -> None: ...
+    def failure(self, msg: object, **kwargs) -> None: ...
+    def verbose(self, msg: object, **kwargs) -> None: ...
+    def print(self, msg: object, style: str | None = None, **kwargs) -> None: ...
+    def log(self, level: str, msg: object, **kwargs) -> None: ...
+    def inspect(self, obj: object, **kwargs) -> None: ...
+    def print_json(self, data: object, **kwargs) -> None: ...
+    def replacement_method(self, level: str) -> Callable: ...

{bear_utils-0.8.12 → bear_utils-0.8.14}/src/bear_utils/logger_manager/loggers/fastapi_logger.py

@@ -6,23 +6,42 @@ import threading
 from typing import TYPE_CHECKING
 
 from fastapi import FastAPI
-from httpx import Client
+from httpx import AsyncClient
 from pydantic import BaseModel
 import uvicorn
 
 from bear_utils.constants import SERVER_OK
-from bear_utils.logger_manager._common import DEBUG, ERROR, INFO, VERBOSE, WARNING, LogLevel
+from bear_utils.logger_manager._log_level import LogLevel, log_levels
 from bear_utils.time import EpochTimestamp
 
 if TYPE_CHECKING:
     from httpx import Response
 
 
+VERBOSE: LogLevel = log_levels.get("VERBOSE")
+DEBUG: LogLevel = log_levels.get("DEBUG")
+INFO: LogLevel = log_levels.get("INFO")
+WARNING: LogLevel = log_levels.get("WARNING")
+ERROR: LogLevel = log_levels.get("ERROR")
+
+
+def get_level(level: str) -> int:
+    """Get the numeric value for a given level string."""
+    return log_levels.get_int(level)
+
+
+def get_name(level: int) -> str:
+    """Get the name of a logging level by its integer value."""
+    return log_levels.get_name(level)
+
+
 class LogRequest(BaseModel):
     """Request model for logging messages."""
 
     level: str
     message: str
+    args: list[str] = []
+    kwargs: dict[str, str] = {}
 
 
 class LocalLoggingServer:
@@ -33,44 +52,51 @@ class LocalLoggingServer:
         host: str = "localhost",
         port: int = 8080,
         log_file: str = "server.log",
-        min_level: LogLevel = VERBOSE,
+        min_level: LogLevel | int | str = DEBUG,
     ) -> None:
         """Initialize the logging server."""
         self.host: str = host
         self.port: int = port
         self.log_file: str = log_file
-        self.min_level: LogLevel = min_level
+        self.min_level: LogLevel = log_levels.get(min_level)
         self.app = FastAPI()
         self.server_thread = None
         self._running = False
         self._setup_routes()
+        self.buffer: list[str] = []
 
     def _setup_routes(self) -> None:
         """Set up the FastAPI routes for logging and health check."""
 
         @self.app.post("/log")
         async def log_message(request: LogRequest) -> dict[str, str]:
-            self.write_log(request.level, request.message)
+            self.write_log(request.level, request.message, *request.args, **request.kwargs)
             return {"status": "success"}
 
         @self.app.get("/health")
         async def health_check() -> dict[str, str]:
             return {"status": "healthy"}
 
-    def write_log(self, level: str, message: str) -> None:
+    def write_log(self, level: str, message: str, *args: str, end: str = "\n", **kwargs: str) -> None:
         """Write a log entry to the file - same logic as original logger."""
+        timestamp: str = EpochTimestamp.now().to_string()
         try:
-            log_level = LogLevel(level)
-            if log_level.value >= self.min_level.value:
-                timestamp = EpochTimestamp.now().to_string()
-                log_entry = f"[{timestamp}] {level}: {message}\n"
-                print(log_entry, file=sys.stderr)
+            level_t: LogLevel = log_levels.get(level)
+            if level_t.value >= self.min_level.value:
+                log_entry: str = f"[{timestamp}] {level}: {message}"
+                self.buffer.append(log_entry)
+                if args:
+                    self.buffer.append(f"{end}".join(str(arg) for arg in args))
+                if kwargs:
+                    for key, value in kwargs.items():
+                        self.buffer.append(f"{key}={value}{end}")
                 with open(self.log_file, "a", encoding="utf-8") as f:
-                    f.write(log_entry)
+                    f.writelines(self.buffer)
+                print(f"{end}".join(self.buffer), file=sys.stderr)
         except Exception:
-            # Fallback to stderr like original
-            timestamp = EpochTimestamp.now().to_string()
             print(f"[{timestamp}] {level}: {message}", file=sys.stderr)
+        finally:
+            self.buffer.clear()
 
     def start(self) -> None:
         """Start the logging server in a separate thread."""
@@ -98,61 +124,64 @@ class LocalLoggingServer:
 class ServerLogger:
     """Logger that calls HTTP endpoints but behaves like SimpleLogger."""
 
-    def __init__(self, server_url: str = "http://localhost:8080", min_level: LogLevel = INFO) -> None:
+    def __init__(self, server_url: str = "http://localhost:8080", min_level: LogLevel | int | str = INFO) -> None:
         """Initialize the ServerLogger."""
         self.server_url: str = server_url.rstrip("/")
-        self.min_level: LogLevel = min_level
-        self.client = Client(timeout=5.0)
+        self.min_level: LogLevel = log_levels.get(min_level)
+        self.client: AsyncClient = AsyncClient(timeout=5.0)
+        self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
 
-    def _log(self, level: LogLevel, msg: object, *args, **kwargs) -> None:
+    async def _log(self, lvl: LogLevel, msg: object, *args, **kwargs) -> None:
         """Same interface as SimpleLogger._log but calls HTTP endpoint."""
-        if isinstance(level, LogLevel) and level.value >= self.min_level.value:
+        if lvl.value >= self.min_level.value:
             try:
-                response: Response = self.client.post(
+                response: Response = await self.client.post(
                     url=f"{self.server_url}/log",
                     json={
-                        "level": level.value,
+                        "level": lvl.value,
                         "message": msg,
+                        "args": args,
+                        "kwargs": kwargs,
                     },
                 )
                 if response.status_code != SERVER_OK:
-                    self._fallback_log(level, msg, *args, **kwargs)
+                    self._fallback_log(lvl, msg, *args, **kwargs)
             except Exception:
-                self._fallback_log(level, msg, *args, **kwargs)
+                self._fallback_log(lvl, msg, *args, **kwargs)
 
-    def _fallback_log(self, level: LogLevel, msg: object, *args, **kwargs) -> None:
+    def _fallback_log(self, lvl: LogLevel, msg: object, *args, **kwargs) -> None:
         """Fallback - same as original SimpleLogger._log."""
         timestamp: str = EpochTimestamp.now().to_string()
-        print(f"[{timestamp}] {level.value}: {msg}", file=sys.stderr)
+        print(f"[{timestamp}] {lvl.value}: {msg}", file=sys.stderr)
         if args:
             print(" ".join(str(arg) for arg in args), file=sys.stderr)
         if kwargs:
             for key, value in kwargs.items():
                 print(f"{key}={value}", file=sys.stderr)
 
-    def verbose(self, msg: object, *args, **kwargs) -> None:
+    async def verbose(self, msg: object, *args, **kwargs) -> None:
         """Log a verbose message."""
-        self._log(VERBOSE, msg, *args, **kwargs)
+        await self._log(VERBOSE, msg, *args, **kwargs)
 
-    def debug(self, msg: object, *args, **kwargs) -> None:
+    async def debug(self, msg: object, *args, **kwargs) -> None:
         """Log a debug message."""
-        self._log(DEBUG, msg, *args, **kwargs)
+        await self._log(DEBUG, msg, *args, **kwargs)
 
-    def info(self, msg: object, *args, **kwargs) -> None:
+    async def info(self, msg: object, *args, **kwargs) -> None:
         """Log an info message."""
-        self._log(INFO, msg, *args, **kwargs)
+        await self._log(INFO, msg, *args, **kwargs)
 
-    def warning(self, msg: object, *args, **kwargs) -> None:
+    async def warning(self, msg: object, *args, **kwargs) -> None:
         """Log a warning message."""
-        self._log(WARNING, msg, *args, **kwargs)
+        await self._log(WARNING, msg, *args, **kwargs)
 
-    def error(self, msg: object, *args, **kwargs) -> None:
+    async def error(self, msg: object, *args, **kwargs) -> None:
         """Log an error message."""
-        self._log(ERROR, msg, *args, **kwargs)
+        await self._log(ERROR, msg, *args, **kwargs)
 
-    def close(self) -> None:
+    async def close(self) -> None:
         """Close the HTTP client."""
-        self.client.close()
+        await self.client.aclose()
 
 
 if __name__ == "__main__":