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

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

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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.17"
+version = "0.8.19"
 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.19/src/bear_utils/extras/_async_helpers.py

@@ -0,0 +1,33 @@
+import asyncio
+from asyncio import AbstractEventLoop, get_event_loop
+from collections.abc import Callable
+import inspect
+
+
+def is_async_function(func: Callable) -> bool:
+    """Check if a function is asynchronous.
+
+    Args:
+        func (Callable): The function/method to check.
+
+    Returns:
+        bool: True if the function is asynchronous, False otherwise.
+    """
+    return inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func) or inspect.isasyncgen(func)
+
+
+def in_async_loop() -> bool:
+    """Check if the current context is already in an async loop."""
+    try:
+        return get_event_loop().is_running()
+    except RuntimeError:
+        return False
+
+
+def gimmie_async_loop() -> AbstractEventLoop:
+    """Get the current event loop, creating one if it doesn't exist."""
+    if in_async_loop():
+        return asyncio.get_event_loop()
+    loop: AbstractEventLoop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    return loop

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

@@ -11,7 +11,7 @@ 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.extras._async_helpers import AbstractEventLoop, gimmie_async_loop, in_async_loop, is_async_function
 from bear_utils.logger_manager import (
     AsyncLoggerProtocol,
     LoggerProtocol,
@@ -204,47 +204,43 @@ class FunctionResponse(BaseModel):
         self.add(content=content, error=error, returncode=returncode or 1, **kwargs)
         return self
 
-    async def _add_item(self, item: str, target_list: list[str]) -> None:
+    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)
 
-    async def _add_to_list(self, items: str | list[str], target_list: list[str], name: str | None = None) -> None:
+    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:
-                    await self._add_item(f"{name}: {item}" if name else item, target_list)
+                    self._add_item(f"{name}: {item}" if name else item, target_list)
             elif isinstance(items, str):
-                await self._add_item(f"{name}: {items}" if name else items, target_list)
+                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
 
-    async def _add_content(self, content: str | list[str], name: str | None = None) -> None:
+    def _add_content(self, content: str | list[str], name: str | None = None) -> None:
         """Append content to the existing content."""
-        await self._add_to_list(content, self.content, name)
+        self._add_to_list(content, self.content, name)
 
-    async def _add_error(self, error: str | list[str], name: str | None = None) -> None:
+    def _add_error(self, error: str | list[str], name: str | None = None) -> None:
         """Append error to the existing error."""
-        await self._add_to_list(error, self.error, name)
+        self._add_to_list(error, self.error, name)
 
-    async def _handle_function_response(self, func_response: FunctionResponse) -> None:
+    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)
-        await self._add_error(error=func_response.error, name=func_response.name)
-        await self._add_content(content=func_response.content, name=func_response.name)
+        self._add_error(error=func_response.error, name=func_response.name)
+        self._add_content(content=func_response.content, name=func_response.name)
 
-    async def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
+    def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
         """Handle a CompletedProcess object and update the FunctionResponse."""
-        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._add_content(content=result.stdout.strip() if result.stdout else "")
+        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,
@@ -254,33 +250,30 @@ class FunctionResponse(BaseModel):
         extra: dict[str, Any] | None = None,
     ) -> Self:
         """Append additional content to the existing content."""
-        coroutines: list[asyncio._CoroutineLike] = []
         try:
-            match content:
-                case FunctionResponse():
-                    coroutines.append(self._handle_function_response(func_response=content))
-                    self.number_of_tasks += 1
-                case CompletedProcess():
-                    coroutines.append(self._handle_completed_process(result=content))
-                    self.number_of_tasks += 1
-                case str() | list() if content:
-                    coroutines.append(self._add_content(content=content))
-                    self.number_of_tasks += 1
-            if isinstance(error, (str | list)):
-                coroutines.append(self._add_error(error=error))
+            if isinstance(content, FunctionResponse | CompletedProcess | str | list) and isinstance(
+                error, (str | list)
+            ):
+                match content:
+                    case FunctionResponse():
+                        self._handle_function_response(func_response=content)
+                    case CompletedProcess():
+                        self._handle_completed_process(result=content)
+                    case str() | list() if content:
+                        self._add_content(content=content)
+                if isinstance(error, (str | list)):
+                    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))
+                self._log_handling(content=content, error=error, logger=self.logger)
         except Exception as e:
             raise ValueError(f"Failed to add content: {e!s}") from e
         return self
 
-    async def _log_handling(
+    def _log_handling(
         self,
         content: list[str] | str | FunctionResponse | CompletedProcess | None,
         error: str | list[str] | None,
@@ -288,21 +281,44 @@ class FunctionResponse(BaseModel):
     ) -> None:
         """Log the content and error messages if they exist."""
 
-        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:
-                    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)):
-            await _log_messages(content, logger.info)
+        async def loop_logging(messages: list[str], func: Callable) -> None:
+            for msg in messages:
+                if is_async_function(func):
+                    await func(f"{self.name}: {msg}" if self.name else msg)
+                else:
+                    func(f"{self.name}: {msg}" if self.name else msg)
+
+        async def _log_messages(
+            content: str | list[str], error: str | list[str], info_func: Callable, error_func: Callable
+        ) -> None:
+            if isinstance(content, str):
+                content = [content]
+            if isinstance(error, str):
+                error = [error]
+
+            await loop_logging(messages=content, func=info_func)
+            await loop_logging(messages=error, func=error_func)
+
+        if isinstance(content, (FunctionResponse | CompletedProcess | None)):
+            content = []
+        if not isinstance(error, (list | str)):
+            error = []
+
+        if not content and not error:
+            return
 
-        if error and isinstance(error, (str | list)):
-            await _log_messages(error, logger.error)
+        before_loop: bool = in_async_loop()
+        loop: AbstractEventLoop = gimmie_async_loop()
+        task = loop.create_task(
+            _log_messages(
+                content=content,
+                error=error,
+                info_func=logger.info,
+                error_func=logger.error,
+            )
+        )
+        if task is not None and loop is not None and not before_loop:
+            loop.run_until_complete(task)
 
     @overload
     def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
@@ -361,17 +377,37 @@ def fail(
     return FunctionResponse().fail(content=content, error=error, returncode=returncode, **kwargs)
 
 
+async def testing_already_in_loop() -> None:
+    """Test function to check if already in an event loop."""
+    # from rich import inspect
+
+    response = FunctionResponse(name="example_function", logger=SimpleLogger())
+    try:
+        response.add(content=["Test content", "test 1234"], error="Test error", log_output=True)
+        response.done(to_dict=True)
+    except RuntimeError as e:
+        print(f"Already in an event loop: {e}")
+    else:
+        print("Successfully added content and error without issues.")
+    # inspect(response)
+
+
+def testing_not_in_loop() -> None:
+    """Test function to check if not in an event loop."""
+    response = FunctionResponse(name="example_function", logger=SimpleLogger())
+    try:
+        response.add(content=["Test content", "test 1234"], error="Test error", log_output=True)
+        response.done(to_dict=True)
+    except RuntimeError as e:
+        print(f"Not in an event loop: {e}")
+    else:
+        print("Successfully added content and error without issues.")
+
+
 if __name__ == "__main__":
     # Example usage
-    from rich import inspect
 
     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)
-    print(response.done(to_dict=True))
-    print(response.done(to_dict=False))
+    asyncio.run(testing_already_in_loop())
+    testing_not_in_loop()

bear_utils-0.8.17/src/bear_utils/extras/_async_helpers.py

@@ -1,14 +0,0 @@
-from collections.abc import Callable
-import inspect
-
-
-def is_async_function(func: Callable) -> bool:
-    """Check if a function is asynchronous.
-
-    Args:
-        func (Callable): The function/method to check.
-
-    Returns:
-        bool: True if the function is asynchronous, False otherwise.
-    """
-    return inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func) or inspect.isasyncgen(func)