ez-a-sync 0.23.4__tar.gz → 0.23.6__tar.gz

{ez_a_sync-0.23.4 → ez_a_sync-0.23.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ez-a-sync
-Version: 0.23.4
+Version: 0.23.6
 Summary: A library that makes it easy to define objects that can be used for both sync and async use cases.
 Home-page: https://github.com/BobTheBuidler/a-sync
 Author: BobTheBuidler

{ez_a_sync-0.23.4 → ez_a_sync-0.23.6}/a_sync/a_sync/function.py

@@ -808,13 +808,21 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
             - :meth:`_await`
         """
 
-        @functools.wraps(self._modified_fn)
+        modified_fn = self._modified_fn
+        await_helper = self._await
+
+        @functools.wraps(modified_fn)
         def async_wrap(*args: P.args, **kwargs: P.kwargs) -> MaybeAwaitable[T]:  # type: ignore [name-defined]
-            should_await = self._run_sync(
-                kwargs
-            )  # Must take place before coro is created, we're popping a kwarg.
-            coro = self._modified_fn(*args, **kwargs)
-            return self._await(coro) if should_await else coro
+            # sourcery skip: assign-if-exp
+            # we dont want this so profiler outputs are more useful
+
+            # Must take place before coro is created, we're popping a kwarg.
+            should_await = self._run_sync(kwargs)
+            coro = modified_fn(*args, **kwargs)
+            if should_await:
+                return await_helper(coro)
+            else:
+                return coro
 
         return async_wrap
 
@@ -833,11 +841,14 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
             - :meth:`_asyncified`
         """
 
-        @functools.wraps(self._modified_fn)
+        modified_fn = self._modified_fn
+        asyncified = self._asyncified
+
+        @functools.wraps(modified_fn)
         def sync_wrap(*args: P.args, **kwargs: P.kwargs) -> MaybeAwaitable[T]:  # type: ignore [name-defined]
             if self._run_sync(kwargs):
-                return self._modified_fn(*args, **kwargs)
-            return self._asyncified(*args, **kwargs)
+                return modified_fn(*args, **kwargs)
+            return asyncified(*args, **kwargs)
 
         return sync_wrap
 

{ez_a_sync-0.23.4 → ez_a_sync-0.23.6}/a_sync/a_sync/method.py

@@ -9,6 +9,7 @@ asynchronously based on various conditions and configurations.
 # mypy: disable-error-code=valid-type
 # mypy: disable-error-code=misc
 import functools
+import heapq
 import logging
 import weakref
 from inspect import isawaitable
@@ -156,8 +157,7 @@ class ASyncMethodDescriptor(ASyncDescriptor[I, P, T]):
                 )
             instance.__dict__[self.field_name] = bound
             logger.debug("new bound method: %s", bound)
-        # Handler for popping unused bound methods from bound method cache
-        bound._cache_handle = self._get_cache_handle(instance)
+        self._update_cache_handle(instance, bound)
         return bound
 
     def __set__(self, instance, value):
@@ -211,24 +211,23 @@ class ASyncMethodDescriptor(ASyncDescriptor[I, P, T]):
         """
         return asyncio.iscoroutinefunction(self.__wrapped__)
 
-    def _get_cache_handle(self, instance: I) -> asyncio.TimerHandle:
+    def _update_cache_handle(self, instance, bound: "ASyncBoundMethod") -> None:
         """
-        Get a cache handle for the instance.
+        Update the TTL for the cache handle for the instance.
 
         Args:
             instance: The instance to create a cache handle for.
-
-        Returns:
-            A timer handle for cache management.
-
-        Examples:
-            >>> descriptor = ASyncMethodDescriptor(my_function)
-            >>> cache_handle = descriptor._get_cache_handle(instance)
+            bound: The bound method we are caching.
         """
-        # NOTE: use `instance.__dict__.pop` instead of `delattr` so we don't create a strong ref to `instance`
-        return asyncio.get_event_loop().call_later(
-            300, instance.__dict__.pop, self.field_name
-        )
+        # Handler for popping unused bound methods from bound method cache
+        loop = asyncio.get_event_loop()
+        if handle := bound._cache_handle:
+            handle._when = loop.time() + 300
+        else:
+            # NOTE: use `instance.__dict__.pop` instead of `delattr` so we don't create a strong ref to `instance`
+            bound._cache_handle = loop.call_at(
+                loop.time() + 300, instance.__dict__.pop, self.field_name
+            )
 
 
 @final
@@ -314,8 +313,7 @@ class ASyncMethodDescriptorSyncDefault(ASyncMethodDescriptor[I, P, T]):
             )
             instance.__dict__[self.field_name] = bound
             logger.debug("new bound method: %s", bound)
-        # Handler for popping unused bound methods from bound method cache
-        bound._cache_handle = self._get_cache_handle(instance)
+        self._update_cache_handle(instance, bound)
         return bound
 
 
@@ -399,8 +397,7 @@ class ASyncMethodDescriptorAsyncDefault(ASyncMethodDescriptor[I, P, T]):
             )
             instance.__dict__[self.field_name] = bound
             logger.debug("new bound method: %s", bound)
-        # Handler for popping unused bound methods from bound method cache
-        bound._cache_handle = self._get_cache_handle(instance)
+        self._update_cache_handle(instance, bound)
         return bound
 
 
@@ -435,7 +432,7 @@ class ASyncBoundMethod(ASyncFunction[P, T], Generic[I, P, T]):
 
     # NOTE: this is created by the Descriptor
 
-    _cache_handle: asyncio.TimerHandle
+    _cache_handle: asyncio.TimerHandle = None
     """An asyncio handle used to pop the bound method from `instance.__dict__` 5 minutes after its last use."""
 
     __weakself__: "weakref.ref[I]"
@@ -795,22 +792,6 @@ class ASyncBoundMethodSyncDefault(ASyncBoundMethod[I, P, T]):
         - :class:`ASyncMethodDescriptorSyncDefault`
     """
 
-    def __get__(
-        self, instance: Optional[I], owner: Type[I]
-    ) -> ASyncFunctionSyncDefault[P, T]:
-        """
-        Get the bound method or descriptor.
-
-        Args:
-            instance: The instance to bind the method to, or None.
-            owner: The owner class.
-
-        Examples:
-            >>> descriptor = ASyncMethodDescriptorSyncDefault(my_function)
-            >>> bound_method = descriptor.__get__(instance, MyClass)
-        """
-        return ASyncBoundMethod.__get__(self, instance, owner)
-
     @overload
     def __call__(self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs) -> T: ...
     @overload
@@ -827,19 +808,19 @@ class ASyncBoundMethodSyncDefault(ASyncBoundMethod[I, P, T]):
     ) -> Coroutine[Any, Any, T]: ...
     @overload
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ...
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        """
-        Call the bound method with synchronous default behavior.
 
-        Args:
-            *args: Positional arguments.
-            **kwargs: Keyword arguments.
+    __call__ = ASyncBoundMethod.__call__
+    """
+    Call the bound method with synchronous default behavior.
 
-        Examples:
-            >>> bound_method = ASyncBoundMethodSyncDefault(instance, my_function, True)
-            >>> bound_method(arg1, arg2, kwarg1=value1)
-        """
-        return ASyncBoundMethod.__call__(self, *args, **kwargs)
+    Args:
+        *args: Positional arguments.
+        **kwargs: Keyword arguments.
+
+    Examples:
+        >>> bound_method = ASyncBoundMethodSyncDefault(instance, my_function, True)
+        >>> bound_method(arg1, arg2, kwarg1=value1)
+    """
 
 
 class ASyncBoundMethodAsyncDefault(ASyncBoundMethod[I, P, T]):
@@ -869,20 +850,6 @@ class ASyncBoundMethodAsyncDefault(ASyncBoundMethod[I, P, T]):
         - :class:`ASyncMethodDescriptorAsyncDefault`
     """
 
-    def __get__(self, instance: I, owner: Type[I]) -> ASyncFunctionAsyncDefault[P, T]:
-        """
-        Get the bound method or descriptor.
-
-        Args:
-            instance: The instance to bind the method to.
-            owner: The owner class.
-
-        Examples:
-            >>> descriptor = ASyncMethodDescriptorAsyncDefault(my_function)
-            >>> bound_method = descriptor.__get__(instance, MyClass)
-        """
-        return ASyncBoundMethod.__get__(self, instance, owner)
-
     @overload
     def __call__(self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs) -> T: ...
     @overload
@@ -899,16 +866,16 @@ class ASyncBoundMethodAsyncDefault(ASyncBoundMethod[I, P, T]):
     ) -> Coroutine[Any, Any, T]: ...
     @overload
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, T]: ...
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, T]:
-        """
-        Call the bound method with asynchronous default behavior.
 
-        Args:
-            *args: Positional arguments.
-            **kwargs: Keyword arguments.
+    __call__ = ASyncBoundMethod.__call__
+    """
+    Call the bound method with asynchronous default behavior.
 
-        Examples:
-            >>> bound_method = ASyncBoundMethodAsyncDefault(instance, my_function, True)
-            >>> await bound_method(arg1, arg2, kwarg1=value1)
-        """
-        return ASyncBoundMethod.__call__(self, *args, **kwargs)
+    Args:
+        *args: Positional arguments.
+        **kwargs: Keyword arguments.
+
+    Examples:
+        >>> bound_method = ASyncBoundMethodAsyncDefault(instance, my_function, True)
+        >>> await bound_method(arg1, arg2, kwarg1=value1)
+    """

{ez_a_sync-0.23.4 → ez_a_sync-0.23.6}/a_sync/a_sync/property.py

@@ -210,17 +210,17 @@ class ASyncPropertyDescriptorSyncDefault(property[I, T]):
     def __get__(self, instance: None, owner: Type[I]) -> Self: ...
     @overload
     def __get__(self, instance: I, owner: Type[I]) -> T: ...
-    def __get__(self, instance: Optional[I], owner: Type[I]) -> Union[Self, T]:
-        """Retrieves the property value, either synchronously or asynchronously.
 
-        Args:
-            instance: The instance from which the property is accessed.
-            owner: The owner class of the property.
+    __get__ = _ASyncPropertyDescriptorBase.__get__
+    """Retrieves the property value, either synchronously or asynchronously.
 
-        Returns:
-            The property value, either as an awaitable or directly.
-        """
-        return _ASyncPropertyDescriptorBase.__get__(self, instance, owner)
+    Args:
+        instance: The instance from which the property is accessed.
+        owner: The owner class of the property.
+
+    Returns:
+        The property value, either as an awaitable or directly.
+    """
 
 
 @final
@@ -474,17 +474,17 @@ class ASyncCachedPropertyDescriptorSyncDefault(cached_property[I, T]):
     def __get__(self, instance: None, owner: Type[I]) -> Self: ...
     @overload
     def __get__(self, instance: I, owner: Type[I]) -> T: ...
-    def __get__(self, instance: Optional[I], owner: Type[I]) -> Union[Self, T]:
-        """Retrieves the cached property value, either synchronously or asynchronously.
 
-        Args:
-            instance: The instance from which the property is accessed.
-            owner: The owner class of the property.
+    __get__ = _ASyncPropertyDescriptorBase.__get__
+    """Retrieves the cached property value, either synchronously or asynchronously.
 
-        Returns:
-            The cached property value, either as an awaitable or directly.
-        """
-        return _ASyncPropertyDescriptorBase.__get__(self, instance, owner)
+    Args:
+        instance: The instance from which the property is accessed.
+        owner: The owner class of the property.
+
+    Returns:
+        The cached property value, either as an awaitable or directly.
+    """
 
 
 @final
@@ -667,7 +667,9 @@ class HiddenMethod(ASyncBoundMethodAsyncDefault[I, Tuple[()], T]):
 
     def __await__(self) -> Generator[Any, None, T]:
         """Returns an awaitable for the method."""
-        return self(sync=False).__await__()
+        # NOTE: self(sync=False).__await__() would be cleaner but requires way more compute for no real gain
+        logger.debug("awaiting %s", self)
+        return self.fn(self.__self__, sync=False).__await__()
 
 
 @final
@@ -728,7 +730,7 @@ class HiddenMethodDescriptor(ASyncMethodDescriptorAsyncDefault[I, Tuple[()], T])
             )
             instance.__dict__[self.field_name] = bound
             logger.debug("new hidden method: %s", bound)
-        bound._cache_handle = self._get_cache_handle(instance)
+        self._update_cache_handle(instance, bound)
         return bound
 
 

{ez_a_sync-0.23.4 → ez_a_sync-0.23.6}/ez_a_sync.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ez-a-sync
-Version: 0.23.4
+Version: 0.23.6
 Summary: A library that makes it easy to define objects that can be used for both sync and async use cases.
 Home-page: https://github.com/BobTheBuidler/a-sync
 Author: BobTheBuidler