ez-a-sync 0.32.16__cp311-cp311-macosx_11_0_arm64.whl → 0.32.18__cp311-cp311-macosx_11_0_arm64.whl

a_sync/a_sync/function.pxd

@@ -20,5 +20,9 @@ cdef class _ASyncFunction(_ModifiedMixin):
     cdef object __modified_fn
     cdef object __async_wrap
     cdef object __sync_wrap
+    cdef object get_fn(self)
+    cpdef bint is_async_def(self)
+    cpdef bint is_sync_default(self)
+    cdef inline bint _run_sync(self, dict kwargs)
 
-cdef void _validate_wrapped_fn(object fn)
+cdef void _validate_wrapped_fn(object fn)

a_sync/a_sync/function.pyx

@@ -203,29 +203,6 @@ cdef inline void _validate_argspec(fn: Callable):
                 f"{fn} must not have any arguments with the following names: {VIABLE_FLAGS}"
             )
 
-cdef inline bint _run_sync(object function, dict kwargs):
-    """
-    Determines whether to run the function synchronously or asynchronously.
-
-    This method checks for a flag in the kwargs and defers to it if present.
-    If no flag is specified, it defers to the default execution mode.
-
-    Args:
-        kwargs: The keyword arguments passed to the function.
-
-    Returns:
-        True if the function should run synchronously, otherwise False.
-
-    See Also:
-        - :func:`_kwargs.get_flag_name`
-    """
-    cdef str flag = get_flag_name(kwargs)
-    if flag:
-        # If a flag was specified in the kwargs, we will defer to it.
-        return is_sync(flag, kwargs, pop_flag=True)
-    else:
-        # No flag specified in the kwargs, we will defer to 'default'.
-        return function._sync_default
     
 cdef class _ASyncFunction(_ModifiedMixin):
     """
@@ -317,10 +294,11 @@ cdef class _ASyncFunction(_ModifiedMixin):
             - :attr:`default`
             - :meth:`_run_sync`
         """
+        fn = self.get_fn()
         _logger_debug(
-            "calling %s fn: %s with args: %s kwargs: %s", self, self.fn, args, kwargs
+            "calling %s fn: %s with args: %s kwargs: %s", self, fn, args, kwargs
         )
-        return self.fn(*args, **kwargs)
+        return fn(*args, **kwargs)
 
     def __repr__(self) -> str:
         return "<{} {}.{} at {}>".format(
@@ -341,9 +319,12 @@ cdef class _ASyncFunction(_ModifiedMixin):
             - :meth:`_async_wrap`
             - :meth:`_sync_wrap`
         """
+        return self.get_fn()
+
+    cdef object get_fn(self):
         fn = self._fn
         if fn is None:
-            fn = self._async_wrap if self._async_def else self._sync_wrap
+            fn = self._async_wrap if self.is_async_def() else self._sync_wrap
             self._fn = fn
         return fn
 
@@ -707,51 +688,6 @@ cdef class _ASyncFunction(_ModifiedMixin):
                 **function_kwargs,
             ).sum(pop=True, sync=False)
 
-    @property
-    def _sync_default(self) -> bint:
-        """
-        Determines the default execution mode (sync or async) for the function.
-
-        If the user did not specify a default, this method defers to the function's
-        definition (sync vs async def).
-
-        Returns:
-            True if the default is sync, False if async.
-
-        See Also:
-            - :attr:`default`
-        """
-        if self.__sync_default_cached:
-            return self.__sync_default
-
-        cdef str default = self.get_default()
-        cdef bint sync_default = (
-            True
-            if default == "sync"
-            else False if default == "async" else not self._async_def
-        )
-        self.__sync_default = sync_default
-        self.__sync_default_cached = True
-        return sync_default
-
-    @property
-    def _async_def(self) -> bint:
-        """
-        Checks if the wrapped function is an asynchronous function.
-
-        Returns:
-            True if the function is asynchronous, otherwise False.
-
-        See Also:
-            - :func:`asyncio.iscoroutinefunction`
-        """
-        if self.__async_def_cached:
-            return self.__async_def
-        cdef bint async_def
-        async_def = self.__async_def = iscoroutinefunction(self.__wrapped__)
-        self.__async_def_cached = True
-        return async_def
-
     @property
     def _asyncified(self) -> CoroFn[P, T]:
         """
@@ -768,7 +704,7 @@ cdef class _ASyncFunction(_ModifiedMixin):
         """
         asyncified = self.__asyncified
         if asyncified is None:
-            if self._async_def:
+            if self.is_async_def():
                 raise TypeError(
                     f"Can only be applied to sync functions, not {self.__wrapped__}"
                 )
@@ -793,10 +729,17 @@ cdef class _ASyncFunction(_ModifiedMixin):
         """
         modified_fn = self.__modified_fn
         if modified_fn is None:
-            if self._async_def:
-                modified_fn = self.__modified_fn = self.modifiers.apply_async_modifiers(self.__wrapped__)
+            
+            # recursively unwrap ASync objects to get to the original wrapped callable
+            wrapped = self.__wrapped__
+            while isinstance(wrapped, _ASyncFunction):
+                wrapped = wrapped.__wrapped__
+                
+            if self.is_async_def():
+                modified_fn = self.__modified_fn = self.modifiers.apply_async_modifiers(wrapped)
             else:
-                modified_fn = self.__modified_fn = self.modifiers.apply_sync_modifiers(self.__wrapped__)
+                modified_fn = self.__modified_fn = self.modifiers.apply_sync_modifiers(wrapped)
+                
         return modified_fn
 
     @property
@@ -825,7 +768,7 @@ cdef class _ASyncFunction(_ModifiedMixin):
                 # we dont want this so profiler outputs are more useful
 
                 # Must take place before coro is created, we're popping a kwarg.
-                should_await = _run_sync(self, kwargs)
+                should_await = self._run_sync(kwargs)
                 coro = modified_fn(*args, **kwargs)
                 if should_await:
                     return await_helper(coro)
@@ -858,7 +801,7 @@ cdef class _ASyncFunction(_ModifiedMixin):
 
             @wraps(modified_fn)
             def sync_wrap(*args: P.args, **kwargs: P.kwargs) -> MaybeAwaitable[T]:  # type: ignore [name-defined]
-                if _run_sync(self, kwargs):
+                if self._run_sync(kwargs):
                     return modified_fn(*args, **kwargs)
                 return asyncified(*args, **kwargs)
             
@@ -866,6 +809,79 @@ cdef class _ASyncFunction(_ModifiedMixin):
 
         return sync_wrap
 
+    cpdef bint is_async_def(self):
+        """
+        Checks if the wrapped function is an asynchronous function.
+
+        Returns:
+            True if the function is asynchronous, otherwise False.
+
+        See Also:
+            - :func:`asyncio.iscoroutinefunction`
+        """
+        if self.__async_def_cached:
+            return self.__async_def
+        cdef bint async_def
+
+        # recursively unwrap ASync callables to get the original wrapped fn
+        wrapped = self.__wrapped__
+        while isinstance(wrapped, _ASyncFunction):
+            wrapped = wrapped.__wrapped__
+            
+        async_def = self.__async_def = iscoroutinefunction(wrapped)
+        self.__async_def_cached = True
+        return async_def
+
+    cpdef bint is_sync_default(self):
+        """
+        Determines the default execution mode (sync or async) for the function.
+
+        If the user did not specify a default, this method defers to the function's
+        definition (sync vs async def).
+
+        Returns:
+            True if the default is sync, False if async.
+
+        See Also:
+            - :attr:`default`
+        """
+        if self.__sync_default_cached:
+            return self.__sync_default
+
+        cdef str default = self.get_default()
+        cdef bint sync_default = (
+            True
+            if default == "sync"
+            else False if default == "async" else not self.is_async_def()
+        )
+        self.__sync_default = sync_default
+        self.__sync_default_cached = True
+        return sync_default
+
+    cdef inline bint _run_sync(self, dict kwargs):
+        """
+        Determines whether to run the function synchronously or asynchronously.
+    
+        This method checks for a flag in the kwargs and defers to it if present.
+        If no flag is specified, it defers to the default execution mode.
+    
+        Args:
+            kwargs: The keyword arguments passed to the function.
+    
+        Returns:
+            True if the function should run synchronously, otherwise False.
+    
+        See Also:
+            - :func:`_kwargs.get_flag_name`
+        """
+        cdef str flag = get_flag_name(kwargs)
+        if flag:
+            # If a flag was specified in the kwargs, we will defer to it.
+            return is_sync(flag, kwargs, pop_flag=True)
+        else:
+            # No flag specified in the kwargs, we will defer to 'default'.
+            return self.is_sync_default()
+
 
 class ASyncFunction(_ASyncFunction, Generic[P, T]):
 
@@ -1157,7 +1173,7 @@ class ASyncFunctionSyncDefault(ASyncFunction[P, T]):
         # TODO write specific docs for this overload
         ...
 
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
+    def __call__(_ASyncFunction self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
         """Calls the wrapped function, defaulting to synchronous execution.
 
         This method overrides the base :meth:`ASyncFunction.__call__` to provide a synchronous
@@ -1176,7 +1192,7 @@ class ASyncFunctionSyncDefault(ASyncFunction[P, T]):
         See Also:
             - :meth:`ASyncFunction.__call__`
         """
-        return self.fn(*args, **kwargs)
+        return self.get_fn()(*args, **kwargs)
 
     __docstring_append__ = ":class:`~a_sync.a_sync.function.ASyncFunctionSyncDefault`, you can optionally pass `sync=False` or `asynchronous=True` to force it to return a coroutine. Without either kwarg, it will run synchronously."
 
@@ -1232,7 +1248,7 @@ class ASyncFunctionAsyncDefault(ASyncFunction[P, T]):
 
     @overload
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, T]: ...
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
+    def __call__(_ASyncFunction self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
         """Calls the wrapped function, defaulting to asynchronous execution.
 
         This method overrides the base :meth:`ASyncFunction.__call__` to provide an asynchronous
@@ -1251,7 +1267,7 @@ class ASyncFunctionAsyncDefault(ASyncFunction[P, T]):
         See Also:
             - :meth:`ASyncFunction.__call__`
         """
-        return self.fn(*args, **kwargs)
+        return self.get_fn()(*args, **kwargs)
 
     __docstring_append__ = ":class:`~a_sync.a_sync.function.ASyncFunctionAsyncDefault`, you can optionally pass `sync=True` or `asynchronous=False` to force it to run synchronously and return a value. Without either kwarg, it will return a coroutine for you to await."