bear-utils 0.9.7__tar.gz → 0.9.9__tar.gz

{bear_utils-0.9.7 → bear_utils-0.9.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.9.7
+Version: 0.9.9
 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

bear_utils-0.9.9/src/bear_utils/_internal/_version.py

@@ -0,0 +1 @@
+__version__ = "0.9.9"

{bear_utils-0.9.7 → bear_utils-0.9.9}/src/bear_utils/events/events_class.py

@@ -15,14 +15,25 @@ Callback = Callable[..., Any]
 
 
 class Events:
-    """Simple wrapper exposing :mod:`events_module` functionality as methods."""
+    """Simple wrapper exposing :mod:`events_module` functionality as methods.
 
-    # Method names mirror functions from ``events_module`` for familiarity
+    Method names mirror functions from ``events_module`` for familiarity
+    """
 
-    def event_handler(self, event_name: str, func: Callback | None = None):
+    def event_handler(
+        self, event_name: str, func: Callback | None = None
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]] | Callable[..., Any]:
         """Register ``func`` as a handler for ``event_name``.
 
         Can be used as a decorator when ``func`` is omitted.
+
+        Args:
+            event_name (str): The name of the event to handle.
+            func (Callable, optional): The function to register as a handler. If omitted, returns
+                a decorator that can be used to register a handler function.
+
+        Returns:
+            Callable: If ``func`` is provided, returns the function itself. If ``func`` is None, returns a decorator that can be used to register a handler function.
         """
         if func is None:
             return _event_handler(event_name)

{bear_utils-0.9.7 → bear_utils-0.9.9}/src/bear_utils/events/events_module.py

@@ -1,6 +1,5 @@
 """Event handling module for Bear Utils."""
 
-import asyncio
 from collections import defaultdict
 from collections.abc import Callable
 from functools import wraps
@@ -9,7 +8,7 @@ from typing import Any
 import weakref
 from weakref import WeakMethod, ref
 
-from bear_utils.extras._async_helpers import is_async_function
+from bear_utils.extras._async_helpers import AsyncResponseModel, create_async_task, is_async_function
 
 Callback = Callable[..., Any]
 
@@ -45,18 +44,20 @@ def set_handler(name: str, func: Callback) -> None:
         _event_registry[name].add(ref(func, _make_callback(name)))
 
 
-def dispatch_event(name: str, *args, **kwargs) -> Any | None:
+def dispatch_event(name: str, single: bool = False, *args, **kwargs) -> list[Any]:
     """Dispatch an event to all registered handlers."""
     results: list[Any] = []
     for func in _event_registry.get(name, []):
         if is_async_function(func):
-            result: Any = asyncio.run(func(*args, **kwargs))  # FIXME: This will crash if called from an async context
+            task: AsyncResponseModel = create_async_task(func(*args, **kwargs))
+            result = task.get_conditional_result(timeout=1)
+            results.append(result)
         else:
             result: Any = func(*args, **kwargs)
             results.append(result)
-    if not results:
-        return None
-    return results[0] if len(results) == 1 else results
+    if single and len(results) == 1:
+        return results[0]
+    return results
 
 
 def event_handler(event_name: str) -> Callable[[Callback], Callback]:

{bear_utils-0.9.7 → bear_utils-0.9.9}/src/bear_utils/extras/_async_helpers.py

@@ -3,37 +3,65 @@ from asyncio import AbstractEventLoop, Task
 from collections.abc import Callable
 from contextlib import suppress
 import inspect
+import time
+from typing import Any
 
 from pydantic import BaseModel, Field
 
 
+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)
+
+
 class AsyncResponseModel(BaseModel):
     """A model to handle asynchronous operations with a function and its arguments."""
 
     loop: AbstractEventLoop | None = Field(default=None, description="The event loop to run the function in.")
     task: Task | None = Field(default=None, description="The task created for the asynchronous function.")
     before_loop: bool = Field(default=False, description="If the function was called from a running loop.")
+    result: Any = Field(default=None, description="The result of the completed task.")
 
     model_config = {"arbitrary_types_allowed": True}
 
+    @property
+    def done(self) -> bool:
+        """Check if the task is completed."""
+        return self.task is not None and self.task.done()
+
+    def get_result(self) -> Any:
+        """Get the result of the completed task."""
+        if not self.task:
+            raise ValueError("No task available")
+        if not self.task.done():
+            raise ValueError("Task not completed yet")
+        if self.result is None:
+            self.result = self.task.result()
+        return self.result
+
+    def get_conditional_result(self, timeout: float = 10.0) -> Any:
+        if self.loop and self.task and not self.before_loop:
+            self.loop.run_until_complete(self.task)
+        start_time: float = time.monotonic()
+        while not self.done:
+            if time.monotonic() - start_time > timeout:
+                raise TimeoutError("Task timed out")
+            time.sleep(0.1)
+        return self.get_result()
+
     def conditional_run(self) -> None:
         """Run the event loop until the task is complete if not in a running loop."""
         if self.loop and self.task and not self.before_loop:
             self.loop.run_until_complete(self.task)
 
 
-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.
 

bear_utils-0.9.7/src/bear_utils/_internal/_version.py

@@ -1 +0,0 @@
-__version__ = "0.9.7"