bear-utils 0.8.16__tar.gz → 0.8.17__tar.gz

{bear_utils-0.8.16 → bear_utils-0.8.17}/.bumpversion.cfg

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

{bear_utils-0.8.16 → bear_utils-0.8.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.16
+Version: 0.8.17
 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.16
+# Bear Utils v# Bear Utils v0.8.17
 
 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.16 → bear_utils-0.8.17}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.16
+# Bear Utils v# Bear Utils v0.8.17
 
 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.16 → bear_utils-0.8.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.16"
+version = "0.8.17"
 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"

{bear_utils-0.8.16 → bear_utils-0.8.17}/src/bear_utils/extras/responses/function_response.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from collections.abc import Callable
 import json
 from subprocess import CompletedProcess
@@ -10,9 +11,10 @@ from typing import Any, Literal, Self, overload
 
 from pydantic import BaseModel, Field, field_validator
 
+from bear_utils.extras._async_helpers import is_async_function
 from bear_utils.logger_manager import (
-    AsyncLoggerProtocol,  # noqa: TC001
-    LoggerProtocol,  # noqa: TC001
+    AsyncLoggerProtocol,
+    LoggerProtocol,
 )
 
 SUCCESS: list[str] = ["name", "success"]
@@ -202,43 +204,47 @@ class FunctionResponse(BaseModel):
         self.add(content=content, error=error, returncode=returncode or 1, **kwargs)
         return self
 
-    def _add_item(self, item: str, target_list: list[str]) -> None:
+    async def _add_item(self, item: str, target_list: list[str]) -> None:
         """Append an item to the target list if not empty."""
         if item != "":
             target_list.append(item)
 
-    def _add_to_list(self, items: str | list[str], target_list: list[str], name: str | None = None) -> None:
+    async def _add_to_list(self, items: str | list[str], target_list: list[str], name: str | None = None) -> None:
         """Append items to the target list with optional name prefix."""
         try:
             if isinstance(items, list):
                 for item in items:
-                    self._add_item(f"{name}: {item}" if name else item, target_list)
+                    await self._add_item(f"{name}: {item}" if name else item, target_list)
             elif isinstance(items, str):
-                self._add_item(f"{name}: {items}" if name else items, target_list)
+                await self._add_item(f"{name}: {items}" if name else items, target_list)
         except Exception as e:
             raise ValueError(f"Failed to add items: {e!s}") from e
 
-    def _add_content(self, content: str | list[str], name: str | None = None) -> None:
+    async def _add_content(self, content: str | list[str], name: str | None = None) -> None:
         """Append content to the existing content."""
-        self._add_to_list(content, self.content, name)
+        await self._add_to_list(content, self.content, name)
 
-    def _add_error(self, error: str | list[str], name: str | None = None) -> None:
+    async def _add_error(self, error: str | list[str], name: str | None = None) -> None:
         """Append error to the existing error."""
-        self._add_to_list(error, self.error, name)
+        await self._add_to_list(error, self.error, name)
 
-    def _handle_function_response(self, func_response: FunctionResponse) -> None:
+    async def _handle_function_response(self, func_response: FunctionResponse) -> None:
         """Handle a FunctionResponse object and update the current response."""
         if func_response.extra:
             self.extra.update(func_response.extra)
-        self._add_error(error=func_response.error, name=func_response.name)
-        self._add_content(content=func_response.content, name=func_response.name)
+        await self._add_error(error=func_response.error, name=func_response.name)
+        await self._add_content(content=func_response.content, name=func_response.name)
 
-    def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
+    async def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
         """Handle a CompletedProcess object and update the FunctionResponse."""
-        self._add_content(content=result.stdout.strip() if result.stdout else "")
-        self._add_error(error=result.stderr.strip() if result.stderr else "")
+        await self._add_content(content=result.stdout.strip() if result.stdout else "")
+        await self._add_error(error=result.stderr.strip() if result.stderr else "")
         self.returncode = result.returncode
 
+    @staticmethod
+    async def _run_coroutines(coroutines: list[asyncio._CoroutineLike]) -> None:
+        await asyncio.gather(*coroutines)
+
     def add(
         self,
         content: list[str] | str | FunctionResponse | CompletedProcess | None = None,
@@ -247,62 +253,56 @@ class FunctionResponse(BaseModel):
         log_output: bool = False,
         extra: dict[str, Any] | None = None,
     ) -> Self:
-        """Append additional content to the existing content.
-
-        Args:
-            content (list[str] | str | FunctionResponse | CompletedProcess): The content to add.
-            error (str | list[str] | None): The error message(s) to add.
-            returncode (int | None): The return code of the function call.
-            log_output (bool): Whether to log the output using the logger.
-            **kwargs: Additional metadata to include in the response.
-
-        Returns:
-            Self: The updated FunctionResponse instance.
-        """
+        """Append additional content to the existing content."""
+        coroutines: list[asyncio._CoroutineLike] = []
         try:
             match content:
                 case FunctionResponse():
-                    self._handle_function_response(func_response=content)
+                    coroutines.append(self._handle_function_response(func_response=content))
                     self.number_of_tasks += 1
                 case CompletedProcess():
-                    self._handle_completed_process(result=content)
+                    coroutines.append(self._handle_completed_process(result=content))
                     self.number_of_tasks += 1
                 case str() | list() if content:
-                    self._add_content(content=content)
+                    coroutines.append(self._add_content(content=content))
                     self.number_of_tasks += 1
-                case None:
-                    content = None
-                case _:
-                    content = None
-            self._add_error(error=error) if isinstance(error, (str | list)) else None
-            self.returncode = returncode if returncode is not None else self.returncode
-            self.extra.update(extra) if isinstance(extra, dict) else None
-            if log_output and self.logger is not None and (content is not None or error is not None):
-                self._log_handling(content=content, error=error, logger=self.logger)
+            if isinstance(error, (str | list)):
+                coroutines.append(self._add_error(error=error))
+            if returncode is not None:
+                self.returncode = returncode
+            if isinstance(extra, dict):
+                self.extra.update(extra)
+            if log_output and self.logger and (content or error):
+                coroutines.append(self._log_handling(content=content, error=error, logger=self.logger))
+            if coroutines:
+                asyncio.run(self._run_coroutines(coroutines))
         except Exception as e:
             raise ValueError(f"Failed to add content: {e!s}") from e
         return self
 
-    def _log_handling(
+    async def _log_handling(
         self,
         content: list[str] | str | FunctionResponse | CompletedProcess | None,
         error: str | list[str] | None,
-        logger: LoggerProtocol,
+        logger: LoggerProtocol | AsyncLoggerProtocol,
     ) -> None:
         """Log the content and error messages if they exist."""
 
-        def _log_messages(messages: str | list[str], log_func: Callable) -> None:
+        async def _log_messages(messages: str | list[str], log_func: Callable) -> None:
             if isinstance(messages, str):
                 messages = [messages]
             if isinstance(messages, list):
                 for msg in messages:
-                    log_func(f"{self.name}: {msg}" if self.name else msg)
+                    if is_async_function(log_func):
+                        await log_func(f"{self.name}: {msg}" if self.name else msg)
+                    else:
+                        log_func(f"{self.name}: {msg}" if self.name else msg)
 
         if content and isinstance(content, (str | list)):
-            _log_messages(content, logger.info)
+            await _log_messages(content, logger.info)
 
         if error and isinstance(error, (str | list)):
-            _log_messages(error, logger.error)
+            await _log_messages(error, logger.error)
 
     @overload
     def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
@@ -365,8 +365,11 @@ if __name__ == "__main__":
     # Example usage
     from rich import inspect
 
-    response = FunctionResponse(name="example_function", returncode=0, content=["Task completed successfully."])
-    response.task_id = 124
+    from bear_utils.logger_manager import SimpleLogger
+
+    response = FunctionResponse(name="example_function", logger=SimpleLogger())
+
+    response.add(content="This is a test content.", error="This is an error message.", log_output=True)
 
     inspect(response)
     print(response)