refactor: setting auto_await for async autorun functions will make them return None, setting it to False will make them return the awaitable, the awaitable can be awaited multiple times, as it cashes the result if comparator is not changed, it can't be set for sync functions

Author: sassanh

CHANGELOG.md

@@ -5,6 +5,7 @@
 - refactor: remove `WithState` as it wasn't doing anything beyond `functools.wraps`
 - refactor: autorun doesn't inform subscribers when the output value is not changed
 - refactor: add `autorun_class` and `side_effect_runner_class` to improve extensibility
+- refactor: setting `auto_await` for async autorun functions will make them return `None`, setting it to `False` will make them return the awaitable, the awaitable can be `await`ed multiple times, as it cashes the result if comparator is not changed, it can't be set for sync functions
 
 ## Version 0.22.2
 

redux/autorun.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-import functools
 import inspect
 import weakref
 from asyncio import Future, Task, iscoroutine, iscoroutinefunction
@@ -12,19 +11,21 @@
     Any,
     Concatenate,
     Generic,
-    TypeVar,
+    Literal,
     cast,
 )
 
 from redux.basic_types import (
     Action,
     Args,
-    AutorunOptions,
+    AutoAwait,
+    AutorunOptionsType,
     ComparatorOutput,
     Event,
     ReturnType,
     SelectorOutput,
     State,
+    T,
 )
 
 if TYPE_CHECKING:
@@ -33,26 +34,37 @@
     from redux.main import Store
 
 
-T = TypeVar('T')
-
-
 class AwaitableWrapper(Generic[T]):
     """A wrapper for a coroutine to track if it has been awaited."""
 
+    _unawaited = object()
+    value: tuple[Literal[False], None] | tuple[Literal[True], T]
+
     def __init__(self, coro: Coroutine[None, None, T]) -> None:
         """Initialize the AwaitableWrapper with a coroutine."""
         self.coro = coro
-        self.awaited = False
+        self.value = (False, None)
 
     def __await__(self) -> Generator[None, None, T]:
         """Await the coroutine and set the awaited flag to True."""
-        self.awaited = True
-        return self.coro.__await__()
+        return self._wrap().__await__()
+
+    async def _wrap(self) -> T:
+        """Wrap the coroutine and set the awaited flag to True."""
+        if self.value[0] is True:
+            return self.value[1]
+        self.value = (True, await self.coro)
+        return self.value[1]
 
     def close(self) -> None:
         """Close the coroutine if it has not been awaited."""
         self.coro.close()
 
+    @property
+    def awaited(self) -> bool:
+        """Check if the coroutine has been awaited."""
+        return self.value[0] is True
+
     def __repr__(self) -> str:
         """Return a string representation of the AwaitableWrapper."""
         return f'AwaitableWrapper({self.coro}, awaited={self.awaited})'
@@ -71,7 +83,7 @@ class Autorun(
 ):
     """Run a wrapped function in response to specific state changes in the store."""
 
-    def __init__(  # noqa: C901, PLR0912
+    def __init__(  # noqa: C901, PLR0912, PLR0915
         self: Autorun,
         *,
         store: Store[State, Action, Event],
@@ -81,7 +93,7 @@ def __init__(  # noqa: C901, PLR0912
             Concatenate[SelectorOutput, Args],
             ReturnType,
         ],
-        options: AutorunOptions[ReturnType],
+        options: AutorunOptionsType[ReturnType, AutoAwait],
     ) -> None:
         """Initialize the Autorun instance."""
         if hasattr(func, '__name__'):
@@ -121,7 +133,7 @@ def __init__(  # noqa: C901, PLR0912
             self._func = weakref.ref(func, self.unsubscribe)
         self._is_coroutine = (
             asyncio.coroutines._is_coroutine  # pyright: ignore [reportAttributeAccessIssue]  # noqa: SLF001
-            if asyncio.iscoroutinefunction(func)
+            if asyncio.iscoroutinefunction(func) and options.auto_await is False
             else None
         )
         self._options = options
@@ -132,8 +144,16 @@ def __init__(  # noqa: C901, PLR0912
             object(),
         )
         if iscoroutinefunction(func):
-            self._latest_value = Future()
-            self._latest_value.set_result(options.default_value)
+
+            async def default_value_wrapper() -> ReturnType | None:
+                return options.default_value
+
+            create_task = self._store._create_task  # noqa: SLF001
+            default_value = default_value_wrapper()
+
+            if create_task:
+                create_task(default_value)
+            self._latest_value: ReturnType = default_value
         else:
             self._latest_value: ReturnType = options.default_value
         self._subscriptions: set[
@@ -145,11 +165,11 @@ def __init__(  # noqa: C901, PLR0912
             self.call()
 
         if self._options.reactive:
-            self._unsubscribe = store._subscribe(self._react)  # noqa: SLF001
+            self._unsubscribe = store._subscribe(self.react)  # noqa: SLF001
         else:
             self._unsubscribe = None
 
-    def _react(
+    def react(
         self: Autorun,
         state: State,
     ) -> None:
@@ -275,27 +295,17 @@ def call(
             create_task = self._store._create_task  # noqa: SLF001
             previous_value = self._latest_value
             if iscoroutine(value) and create_task:
-                if self._options.auto_await:
-                    future = Future()
-                    self._latest_value = cast('ReturnType', future)
-                    create_task(
-                        value,
-                        callback=functools.partial(
-                            self._task_callback,
-                            future=future,
-                        ),
-                    )
-                else:
+                if self._options.auto_await is False:
                     if (
                         self._latest_value is not None
                         and isinstance(self._latest_value, AwaitableWrapper)
                         and not self._latest_value.awaited
                     ):
                         self._latest_value.close()
-                    self._latest_value = cast(
-                        'ReturnType',
-                        AwaitableWrapper(value),
-                    )
+                    self._latest_value = cast('ReturnType', AwaitableWrapper(value))
+                else:
+                    self._latest_value = cast('ReturnType', None)
+                    create_task(value)
             else:
                 self._latest_value = value
             if self._latest_value is not previous_value:

redux/basic_types.py

@@ -9,11 +9,12 @@
     Any,
     Concatenate,
     Generic,
-    Never,
+    Literal,
     ParamSpec,
     Protocol,
     TypeAlias,
     TypeGuard,
+    cast,
     overload,
 )
 
@@ -144,10 +145,75 @@ class StoreOptions(Immutable, Generic[Action, Event]):
 
 # Autorun
 
+AutoAwait = TypeVar('AutoAwait', bound=Literal[True, False, None], infer_variance=True)
 
-class AutorunOptions(Immutable, Generic[ReturnType]):
+
+class AutorunOptionsType(Immutable, Generic[ReturnType, AutoAwait]):
+    default_value: ReturnType | None = None
+    auto_await: AutoAwait = cast('AutoAwait', val=None)
+    initial_call: bool = True
+    reactive: bool = True
+    memoization: bool = True
+    keep_ref: bool = True
+    subscribers_initial_run: bool = True
+    subscribers_keep_ref: bool = True
+
+    @overload
+    def __init__(
+        self: AutorunOptionsType[ReturnType, Literal[None]],  # type: ignore[reportInvalidTypeVar]
+        *,
+        default_value: ReturnType | None = None,
+        auto_await: Literal[None] | None = None,
+        initial_call: bool = True,
+        reactive: bool = True,
+        memoization: bool = True,
+        keep_ref: bool = True,
+        subscribers_initial_run: bool = True,
+        subscribers_keep_ref: bool = True,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: AutorunOptionsType[ReturnType, Literal[True]],  # type: ignore[reportInvalidTypeVar]
+        *,
+        default_value: ReturnType | None = None,
+        auto_await: Literal[True],
+        initial_call: bool = True,
+        reactive: bool = True,
+        memoization: bool = True,
+        keep_ref: bool = True,
+        subscribers_initial_run: bool = True,
+        subscribers_keep_ref: bool = True,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: AutorunOptionsType[ReturnType, Literal[False]],  # type: ignore[reportInvalidTypeVar]
+        *,
+        default_value: ReturnType | None = None,
+        auto_await: Literal[False],
+        initial_call: bool = True,
+        reactive: bool = True,
+        memoization: bool = True,
+        keep_ref: bool = True,
+        subscribers_initial_run: bool = True,
+        subscribers_keep_ref: bool = True,
+    ) -> None: ...
+    def __init__(  # noqa: PLR0913
+        self: AutorunOptionsType,
+        *,
+        default_value: ReturnType | None = None,
+        auto_await: bool | None = None,
+        initial_call: bool = True,
+        reactive: bool = True,
+        memoization: bool = True,
+        keep_ref: bool = True,
+        subscribers_initial_run: bool = True,
+        subscribers_keep_ref: bool = True,
+    ) -> None: ...
+
+
+class AutorunOptionsImplementation(Immutable, Generic[ReturnType, AutoAwait]):
     default_value: ReturnType | None = None
-    auto_await: bool = True
+    auto_await: AutoAwait = cast('AutoAwait', val=None)
     initial_call: bool = True
     reactive: bool = True
     memoization: bool = True
@@ -156,8 +222,7 @@ class AutorunOptions(Immutable, Generic[ReturnType]):
     subscribers_keep_ref: bool = True
 
 
-AutorunOptionsWithDefault = AutorunOptions[ReturnType]
-AutorunOptionsWithoutDefault = AutorunOptions[Never]
+AutorunOptions = cast('type[AutorunOptionsType]', AutorunOptionsImplementation)
 
 
 class AutorunReturnType(
@@ -186,34 +251,39 @@ def unsubscribe(self: AutorunReturnType) -> None: ...
     __name__: str
 
 
-class AutorunDecorator(Protocol, Generic[SelectorOutput, ReturnType]):
+class AutorunDecorator(Protocol, Generic[ReturnType, SelectorOutput, AutoAwait]):
     @overload
     def __call__(
-        self: AutorunDecorator,
+        self: AutorunDecorator[ReturnType, SelectorOutput, Literal[None]],
+        func: Callable[
+            Concatenate[SelectorOutput, Args],
+            Awaitable[ReturnType],
+        ],
+    ) -> AutorunReturnType[None, Args]: ...
+    @overload
+    def __call__(
+        self: AutorunDecorator[ReturnType, SelectorOutput, Literal[None]],
         func: Callable[
             Concatenate[SelectorOutput, Args],
             ReturnType,
         ],
     ) -> AutorunReturnType[ReturnType, Args]: ...
-
     @overload
     def __call__(
-        self: AutorunDecorator,
+        self: AutorunDecorator[ReturnType, SelectorOutput, Literal[True]],
         func: Callable[
             Concatenate[SelectorOutput, Args],
             Awaitable[ReturnType],
         ],
-    ) -> AutorunReturnType[Awaitable[ReturnType], Args]: ...
-
-
-class UnknownAutorunDecorator(Protocol, Generic[SelectorOutput]):
+    ) -> AutorunReturnType[None, Args]: ...
+    @overload
     def __call__(
-        self: UnknownAutorunDecorator,
+        self: AutorunDecorator[ReturnType, SelectorOutput, Literal[False]],
         func: Callable[
             Concatenate[SelectorOutput, Args],
-            ReturnType,
+            Awaitable[ReturnType],
         ],
-    ) -> AutorunReturnType[ReturnType, Args]: ...
+    ) -> AutorunReturnType[Awaitable[ReturnType], Args]: ...
 
 
 # View
@@ -227,10 +297,6 @@ class ViewOptions(Immutable, Generic[ReturnType]):
     subscribers_keep_ref: bool = True
 
 
-ViewOptionsWithDefault = ViewOptions[ReturnType]
-ViewOptionsWithoutDefault = ViewOptions[Never]
-
-
 class ViewReturnType(
     Protocol,
     Generic[ReturnType, Args],
@@ -257,17 +323,8 @@ def unsubscribe(self: ViewReturnType) -> None: ...
 
 class ViewDecorator(
     Protocol,
-    Generic[SelectorOutput, ReturnType],
+    Generic[ReturnType, SelectorOutput],
 ):
-    @overload
-    def __call__(
-        self: ViewDecorator,
-        func: Callable[
-            Concatenate[SelectorOutput, Args],
-            ReturnType,
-        ],
-    ) -> ViewReturnType[ReturnType, Args]: ...
-
     @overload
     def __call__(
         self: ViewDecorator,
@@ -277,10 +334,9 @@ def __call__(
         ],
     ) -> ViewReturnType[Awaitable[ReturnType], Args]: ...
 
-
-class UnknownViewDecorator(Protocol, Generic[SelectorOutput]):
+    @overload
     def __call__(
-        self: UnknownViewDecorator,
+        self: ViewDecorator,
         func: Callable[
             Concatenate[SelectorOutput, Args],
             ReturnType,