refactor: housekeeping, remove unused callback of task creators, remove unused _task_callback of autoruns, clean up type hints, etc

Author: sassanh

CHANGELOG.md

@@ -6,6 +6,7 @@
 - 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
+- refactor: housekeeping, remove unused callback of task creators, remove unused `_task_callback` of autoruns, clean up type hints, etc
 
 ## Version 0.22.2
 

redux/autorun.py

@@ -5,7 +5,7 @@
 import asyncio
 import inspect
 import weakref
-from asyncio import Future, Task, iscoroutine, iscoroutinefunction
+from asyncio import iscoroutine, iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -217,27 +217,6 @@ def inform_subscribers(
                 subscriber = subscriber_
             subscriber(self._latest_value)
 
-    def _task_callback(
-        self: Autorun[
-            State,
-            Action,
-            Event,
-            SelectorOutput,
-            ComparatorOutput,
-            Args,
-            ReturnType,
-        ],
-        task: Task,
-        *,
-        future: Future,
-    ) -> None:
-        task.add_done_callback(
-            lambda result: (
-                future.set_result(result.result()),
-                self.inform_subscribers(),
-            ),
-        )
-
     def check(
         self: Autorun[
             State,

redux/basic_types.py

@@ -38,6 +38,15 @@ class BaseAction(Immutable): ...
 class BaseEvent(Immutable): ...
 
 
+class InitAction(BaseAction): ...
+
+
+class FinishAction(BaseAction): ...
+
+
+class FinishEvent(BaseEvent): ...
+
+
 # Type variables
 State = TypeVar('State', bound=Immutable | None, infer_variance=True)
 Action = TypeVar('Action', bound=BaseAction | None, infer_variance=True)
@@ -47,7 +56,7 @@ class BaseEvent(Immutable): ...
 ComparatorOutput = TypeVar('ComparatorOutput', infer_variance=True)
 ReturnType = TypeVar('ReturnType', infer_variance=True)
 Comparator = Callable[[State], ComparatorOutput]
-EventHandler = Callable[[Event], Any] | Callable[[], Any]
+EventHandler: TypeAlias = Callable[[Event], Any] | Callable[[], Any]
 Args = ParamSpec('Args')
 Payload = TypeVar('Payload', bound=Any, default=None)
 
@@ -58,8 +67,11 @@ class CompleteReducerResult(Immutable, Generic[State, Action, Event]):
     events: Sequence[Event] | None = None
 
 
-ReducerResult = CompleteReducerResult[State, Action, Event] | State
-ReducerType = Callable[[State | None, Action], ReducerResult[State, Action, Event]]
+ReducerResult: TypeAlias = CompleteReducerResult[State, Action, Event] | State
+ReducerType: TypeAlias = Callable[
+    [State | None, Action],
+    ReducerResult[State, Action, Event],
+]
 
 
 class InitializationActionError(Exception):
@@ -70,15 +82,6 @@ def __init__(self: InitializationActionError, action: BaseAction) -> None:
         )
 
 
-class InitAction(BaseAction): ...
-
-
-class FinishAction(BaseAction): ...
-
-
-class FinishEvent(BaseEvent): ...
-
-
 def is_complete_reducer_result(
     result: ReducerResult[State, Action, Event],
 ) -> TypeGuard[CompleteReducerResult[State, Action, Event]]:
@@ -103,8 +106,6 @@ class TaskCreator(Protocol):
     def __call__(
         self: TaskCreator,
         coro: Coroutine,
-        *,
-        callback: TaskCreatorCallback | None = None,
     ) -> None: ...
 
 
@@ -132,8 +133,12 @@ class StoreOptions(Immutable, Generic[Action, Event]):
     auto_init: bool = False
     side_effect_threads: int = 1
     scheduler: Scheduler | None = None
-    action_middlewares: Sequence[ActionMiddleware[Action]] = field(default_factory=list)
-    event_middlewares: Sequence[EventMiddleware[Event]] = field(default_factory=list)
+    action_middlewares: Sequence[ActionMiddleware[Action | InitAction]] = field(
+        default_factory=list,
+    )
+    event_middlewares: Sequence[EventMiddleware[Event | FinishEvent]] = field(
+        default_factory=list,
+    )
     task_creator: TaskCreator | None = None
     on_finish: Callable[[], Any] | None = None
     grace_time_in_seconds: float = 1
@@ -285,6 +290,15 @@ def __call__(
         ],
     ) -> AutorunReturnType[Awaitable[ReturnType], Args]: ...
 
+    @overload
+    def __call__(
+        self: AutorunDecorator[ReturnType, SelectorOutput, bool],
+        func: Callable[
+            Concatenate[SelectorOutput, Args],
+            ReturnType,
+        ],
+    ) -> AutorunReturnType[ReturnType, Args]: ...
+
 
 # View
 
@@ -367,7 +381,7 @@ def __call__(
     ) -> Callable[[], None]: ...
 
 
-DispatchParameters: TypeAlias = Action | list[Action]
+DispatchParameters: TypeAlias = Action | InitAction | list[Action | InitAction]
 
 
 class Dispatch(Protocol, Generic[State, Action, Event]):

redux/main.py

@@ -7,6 +7,7 @@
 import queue
 import weakref
 from collections import defaultdict
+from collections.abc import Awaitable, Iterable, Sequence
 from functools import wraps
 from threading import Lock, Thread
 from typing import (
@@ -56,15 +57,15 @@
 from redux.serialization_mixin import SerializationMixin
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
+    from collections.abc import Callable
 
 
 class Store(Generic[State, Action, Event], SerializationMixin):
     """Redux store for managing state and side effects."""
 
     def __init__(
         self,
-        reducer: ReducerType[State, Action, Event],
+        reducer: ReducerType[State, Action | InitAction, Event | None],
         options: StoreOptions[Action, Event] | None = None,
     ) -> None:
         """Create a new store."""
@@ -77,18 +78,19 @@ def __init__(
 
         self._state: State | None = None
         self._listeners: set[
-            Callable[[State], Any] | weakref.ref[Callable[[State], Any]]
+            Callable[[State], AwaitableOrNot[None]]
+            | weakref.ref[Callable[[State], AwaitableOrNot[None]]]
         ] = set()
         self._event_handlers: defaultdict[
-            type[Event],
+            type[Event | FinishEvent],
             set[EventHandler | weakref.ref[EventHandler]],
         ] = defaultdict(set)
 
-        self._actions: list[Action] = []
-        self._events: list[Event] = []
+        self._actions: list[Action | InitAction] = []
+        self._events: list[Event | FinishEvent] = []
 
         self._event_handlers_queue = queue.Queue[
-            tuple[EventHandler[Event], Event] | None
+            tuple[EventHandler[Event | FinishEvent], Event | FinishEvent] | None
         ]()
         self._workers = [
             self.store_options.side_effect_runner_class(
@@ -105,11 +107,11 @@ def __init__(
         if self.store_options.auto_init:
             if self.store_options.scheduler:
                 self.store_options.scheduler(
-                    lambda: self.dispatch(cast('Action', InitAction())),
+                    lambda: self.dispatch(InitAction()),
                     interval=False,
                 )
             else:
-                self.dispatch(cast('Action', InitAction()))
+                self.dispatch(InitAction())
 
         if self.store_options.scheduler:
             self.store_options.scheduler(self.run, interval=True)
@@ -139,7 +141,7 @@ def _run_actions(self: Store[State, Action, Event]) -> None:
                     self._call_listeners(self._state)
 
                 if isinstance(action, FinishAction):
-                    self._dispatch([cast('Event', FinishEvent())])
+                    self._dispatch([FinishEvent()])
 
     def _run_event_handlers(self: Store[State, Action, Event]) -> None:
         while len(self._events) > 0:
@@ -199,17 +201,17 @@ def dispatch(
         actions = [
             action
             for actions in parameters
-            for action in (actions if isinstance(actions, list) else [actions])
+            for action in (actions if isinstance(actions, Iterable) else [actions])
         ]
         self._dispatch(actions)
 
     def _dispatch(
         self: Store[State, Action, Event],
-        items: list[Action | Event],
+        items: Sequence[Action | Event | InitAction | FinishEvent | None],
     ) -> None:
         for item in items:
             if isinstance(item, BaseAction):
-                action = cast('Action', item)
+                action = item
                 for action_middleware in self._action_middlewares:
                     action_ = action_middleware(action)
                     if action_ is None:
@@ -218,7 +220,7 @@ def _dispatch(
                 else:
                     self._actions.append(action)
             if isinstance(item, BaseEvent):
-                event = cast('Event', item)
+                event = item
                 for event_middleware in self._event_middlewares:
                     event_ = event_middleware(event)
                     if event_ is None:
@@ -267,10 +269,10 @@ def subscribe_event(
         else:
             handler_ref = weakref.ref(handler)
 
-        self._event_handlers[cast('Any', event_type)].add(handler_ref)
+        self._event_handlers[cast('Event', event_type)].add(handler_ref)
 
         def unsubscribe() -> None:
-            self._event_handlers[cast('Any', event_type)].discard(handler_ref)
+            self._event_handlers[cast('Event', event_type)].discard(handler_ref)
 
         return SubscribeEventCleanup(unsubscribe=unsubscribe, handler=handler)
 
@@ -305,9 +307,9 @@ def autorun(
         def autorun_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
-                ReturnType,
+                AwaitableOrNot[ReturnType],
             ],
-        ) -> AutorunReturnType[ReturnType | None, Args]:
+        ) -> AutorunReturnType[ReturnType, Args]:
             return self.store_options.autorun_class(
                 store=self,
                 selector=selector,

redux/side_effect_runner.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import contextlib
 import inspect
 import threading
@@ -16,6 +15,8 @@
     import queue
     from collections.abc import Callable
 
+    from redux.basic_types import EventHandler, TaskCreator
+
 
 class SideEffectRunner(threading.Thread, Generic[Event]):
     """Thread for running side effects."""
@@ -30,18 +31,16 @@ def __init__(
         super().__init__()
         self.name = 'Side Effect Runner'
         self.task_queue = task_queue
-        self.loop = asyncio.get_event_loop()
         self._handles: set[Handle] = set()
         self.create_task = create_task
 
     def run(self: SideEffectRunner[Event]) -> None:
         """Run the side effect runner thread."""
         while True:
             task = self.task_queue.get()
-            if task is None:
-                self.task_queue.task_done()
-                break
             try:
+                if task is None:
+                    break
                 event_handler_, event = task
                 if isinstance(event_handler_, weakref.ref):
                     event_handler = event_handler_()

redux_pytest/fixtures/event_loop.py

@@ -8,9 +8,7 @@
 import pytest
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Coroutine
-
-    from redux.basic_types import TaskCreatorCallback
+    from collections.abc import Coroutine
 
 
 class LoopThread(threading.Thread):
@@ -24,21 +22,8 @@ def run(self: LoopThread) -> None:
     def stop(self: LoopThread) -> None:
         self.loop.call_soon_threadsafe(self.loop.stop)
 
-    def create_task(
-        self: LoopThread,
-        coro: Coroutine,
-        *,
-        callback: TaskCreatorCallback | None = None,
-    ) -> None:
-        def _(
-            coro: Coroutine,
-            callback: Callable[[asyncio.Task], None] | None = None,
-        ) -> None:
-            task = self.loop.create_task(coro)
-            if callback:
-                task.add_done_callback(callback)
-
-        self.loop.call_soon_threadsafe(_, coro, callback)
+    def create_task(self: LoopThread, coro: Coroutine) -> None:
+        self.loop.call_soon_threadsafe(self.loop.create_task, coro)
 
 
 @pytest.fixture

tests/test_async.py

@@ -129,10 +129,7 @@ async def _(values: tuple[int, int]) -> None:
 
 
 def test_autorun_non_autoawait(store: StoreType) -> None:
-    @store.autorun(
-        lambda state: state.value,
-        options=AutorunOptions(auto_await=False),
-    )
+    @store.autorun(lambda state: state.value, options=AutorunOptions(auto_await=False))
     async def sync_mirror(value: int) -> int:
         store.dispatch(SetMirroredValueAction(value=value))
         return value * 2
@@ -143,10 +140,11 @@ async def sync_mirror(value: int) -> int:
     async def _(values: tuple[int, int]) -> None:
         value, mirrored_value = values
         if mirrored_value != value:
-            assert 'awaited=False' in str(sync_mirror())
-            await sync_mirror()
-            assert 'awaited=True' in str(sync_mirror())
-            await sync_mirror()
+            sync_mirror_returned_value = sync_mirror()
+            assert 'awaited=False' in str(sync_mirror_returned_value)
+            await sync_mirror_returned_value
+            assert 'awaited=True' in str(sync_mirror_returned_value)
+            await sync_mirror_returned_value
         elif value < INCREMENTS:
             store.dispatch(IncrementAction())
         else:

tests/test_autorun.py

@@ -74,7 +74,7 @@ def reducer(
 
 @pytest.fixture
 def store() -> Generator[StoreType, None, None]:
-    store = Store(reducer, options=StoreOptions(auto_init=True))
+    store: StoreType = Store(reducer, options=StoreOptions(auto_init=True))
     yield store
 
     store.dispatch(IncrementAction())

tests/test_views.py

@@ -67,7 +67,7 @@ def reducer(
 
 @pytest.fixture
 def store() -> Generator[StoreType, None, None]:
-    store = Store(reducer, options=StoreOptions(auto_init=True))
+    store: StoreType = Store(reducer, options=StoreOptions(auto_init=True))
     yield store
 
     store.dispatch(IncrementAction())