refactor: add autorun_class and side_effect_runner_class to improve extensibility

Author: sassanh

CHANGELOG.md

@@ -4,6 +4,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
 
 ## Version 0.22.2
 

demo.py

@@ -22,7 +22,7 @@
     FinishAction,
     ReducerResult,
 )
-from redux.main import CreateStoreOptions
+from redux.main import StoreOptions
 
 
 class CountAction(BaseAction): ...
@@ -124,7 +124,7 @@ def main() -> None:
     # Initialization <
     store = Store(
         reducer,
-        CreateStoreOptions(auto_init=True, threads=2),
+        StoreOptions(auto_init=True, side_effect_threads=2),
     )
 
     def event_handler(event: SleepEvent) -> None:

redux/__init__.py

@@ -12,7 +12,6 @@
     CombineReducerRegisterAction,
     CombineReducerUnregisterAction,
     CompleteReducerResult,
-    CreateStoreOptions,
     Dispatch,
     DispatchParameters,
     EventSubscriber,
@@ -23,6 +22,7 @@
     ReducerResult,
     ReducerType,
     Scheduler,
+    StoreOptions,
     ViewDecorator,
     ViewOptions,
     ViewReturnType,
@@ -44,7 +44,6 @@
     'CombineReducerRegisterAction',
     'CombineReducerUnregisterAction',
     'CompleteReducerResult',
-    'CreateStoreOptions',
     'Dispatch',
     'DispatchParameters',
     'EventSubscriber',
@@ -56,6 +55,7 @@
     'ReducerType',
     'Scheduler',
     'Store',
+    'StoreOptions',
     'ViewDecorator',
     'ViewOptions',
     'ViewReturnType',

redux/autorun.py

@@ -140,8 +140,9 @@ def __init__(  # noqa: C901, PLR0912
             Callable[[ReturnType], Any] | weakref.ref[Callable[[ReturnType], Any]]
         ] = set()
 
-        if self._check(store._state) and self._options.initial_call:  # noqa: SLF001
-            self._call()
+        if self.check(store._state) and self._options.initial_call:  # noqa: SLF001
+            self._should_be_called = False
+            self.call()
 
         if self._options.reactive:
             self._unsubscribe = store._subscribe(self._react)  # noqa: SLF001
@@ -153,8 +154,9 @@ def _react(
         state: State,
     ) -> None:
         """React to state changes in the store."""
-        if self._options.reactive and self._check(state):
-            self._call()
+        if self._options.reactive and self.check(state):
+            self._should_be_called = False
+            self.call()
 
     def unsubscribe(
         self: Autorun[
@@ -216,7 +218,7 @@ def _task_callback(
             ),
         )
 
-    def _check(
+    def check(
         self: Autorun[
             State,
             Action,
@@ -228,6 +230,7 @@ def _check(
         ],
         state: State | None,
     ) -> bool:
+        """Check if the autorun should be called based on the current state."""
         if state is None:
             return False
         try:
@@ -248,7 +251,7 @@ def _check(
         self._last_comparator_result = comparator_result
         return self._should_be_called
 
-    def _call(
+    def call(
         self: Autorun[
             State,
             Action,
@@ -261,7 +264,7 @@ def _call(
         *args: Args.args,
         **kwargs: Args.kwargs,
     ) -> None:
-        self._should_be_called = False
+        """Call the wrapped function with the current state of the store."""
         func = self._func() if isinstance(self._func, weakref.ref) else self._func
         if func and self._last_selector_result is not None:
             value: ReturnType = func(
@@ -313,9 +316,10 @@ def __call__(
     ) -> ReturnType:
         """Call the wrapped function with the current state of the store."""
         state = self._store._state  # noqa: SLF001
-        self._check(state)
+        self.check(state)
         if self._should_be_called or args or kwargs or not self._options.memoization:
-            self._call(*args, **kwargs)
+            self._should_be_called = False
+            self.call(*args, **kwargs)
         return cast('ReturnType', self._latest_value)
 
     def __repr__(

redux/basic_types.py

@@ -23,6 +23,8 @@
 if TYPE_CHECKING:
     from asyncio import Task
 
+    from redux.autorun import Autorun
+    from redux.side_effect_runner import SideEffectRunner
 
 T = TypeVar('T')
 
@@ -113,15 +115,31 @@ class EventMiddleware(Protocol, Generic[Event]):
     def __call__(self: EventMiddleware, event: Event) -> Event | None: ...
 
 
-class CreateStoreOptions(Immutable, Generic[Action, Event]):
+def default_autorun() -> type[Autorun]:
+    from redux.autorun import Autorun
+
+    return Autorun
+
+
+def default_side_effect_runner() -> type[SideEffectRunner]:
+    from redux.side_effect_runner import SideEffectRunner
+
+    return SideEffectRunner
+
+
+class StoreOptions(Immutable, Generic[Action, Event]):
     auto_init: bool = False
-    threads: int = 5
+    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)
     task_creator: TaskCreator | None = None
     on_finish: Callable[[], Any] | None = None
     grace_time_in_seconds: float = 1
+    autorun_class: type[Autorun] = field(default_factory=default_autorun)
+    side_effect_runner_class: type[SideEffectRunner] = field(
+        default_factory=default_side_effect_runner,
+    )
 
 
 # Autorun

redux/combine_reducers.py

@@ -6,7 +6,7 @@
 import operator
 import uuid
 from dataclasses import fields
-from typing import TYPE_CHECKING, Any, TypeVar, cast
+from typing import TYPE_CHECKING, TypeVar
 
 from immutable import make_immutable
 
@@ -104,7 +104,7 @@ def combined_reducer(
                 del fields_copy[key]
                 del annotations_copy[key]
                 state_class = make_immutable(state_type.__name__, annotations_copy)
-                cast('Any', state_class).__dataclass_fields__ = fields_copy
+                state_class.__dataclass_fields__ = fields_copy
 
                 state = state_class(
                     _id=state._id,  # noqa: SLF001

redux/main.py

@@ -18,7 +18,6 @@
     overload,
 )
 
-from redux.autorun import Autorun
 from redux.basic_types import (
     Action,
     ActionMiddleware,
@@ -32,7 +31,6 @@
     BaseAction,
     BaseEvent,
     ComparatorOutput,
-    CreateStoreOptions,
     DispatchParameters,
     Event,
     EventHandler,
@@ -45,6 +43,7 @@
     SelectorOutput,
     SnapshotAtom,
     State,
+    StoreOptions,
     StrictEvent,
     SubscribeEventCleanup,
     UnknownAutorunDecorator,
@@ -59,7 +58,6 @@
     is_state_reducer_result,
 )
 from redux.serialization_mixin import SerializationMixin
-from redux.side_effect_runner import SideEffectRunnerThread
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable
@@ -69,12 +67,12 @@ class Store(Generic[State, Action, Event], SerializationMixin):
     """Redux store for managing state and side effects."""
 
     def __init__(
-        self: Store,
+        self,
         reducer: ReducerType[State, Action, Event],
-        options: CreateStoreOptions[Action, Event] | None = None,
+        options: StoreOptions[Action, Event] | None = None,
     ) -> None:
         """Create a new store."""
-        self.store_options = options or CreateStoreOptions()
+        self.store_options = options or StoreOptions()
         self.reducer = reducer
         self._create_task = self.store_options.task_creator
 
@@ -97,11 +95,11 @@ def __init__(
             tuple[EventHandler[Event], Event] | None
         ]()
         self._workers = [
-            SideEffectRunnerThread(
+            self.store_options.side_effect_runner_class(
                 task_queue=self._event_handlers_queue,
                 create_task=self._create_task,
             )
-            for _ in range(self.store_options.threads)
+            for _ in range(self.store_options.side_effect_threads)
         ]
         for worker in self._workers:
             worker.start()
@@ -169,7 +167,7 @@ def run(self: Store[State, Action, Event]) -> None:
     def clean_up(self: Store[State, Action, Event]) -> None:
         """Clean up the store."""
         self.wait_for_event_handlers()
-        for _ in range(self.store_options.threads):
+        for _ in range(self.store_options.side_effect_threads):
             self._event_handlers_queue.put_nowait(None)
         self.wait_for_event_handlers()
         for worker in self._workers:
@@ -347,7 +345,7 @@ def autorun_decorator(
                 AwaitableOrNot[ReturnType],
             ],
         ) -> AutorunReturnType[AwaitableOrNot[ReturnType], Args]:
-            return Autorun(
+            return self.store_options.autorun_class(
                 store=self,
                 selector=selector,
                 comparator=comparator,
@@ -403,7 +401,7 @@ def view_decorator(
             ],
         ) -> ViewReturnType[AwaitableOrNot[ReturnType], Args]:
             _options = options or ViewOptions()
-            return Autorun(
+            return self.store_options.autorun_class(
                 store=self,
                 selector=selector,
                 comparator=None,

redux/side_effect_runner.py

@@ -17,11 +17,11 @@
     from collections.abc import Callable
 
 
-class SideEffectRunnerThread(threading.Thread, Generic[Event]):
+class SideEffectRunner(threading.Thread, Generic[Event]):
     """Thread for running side effects."""
 
     def __init__(
-        self: SideEffectRunnerThread,
+        self: SideEffectRunner,
         *,
         task_queue: queue.Queue[tuple[EventHandler[Event], Event] | None],
         create_task: TaskCreator | None,
@@ -34,7 +34,7 @@ def __init__(
         self._handles: set[Handle] = set()
         self.create_task = create_task
 
-    def run(self: SideEffectRunnerThread[Event]) -> None:
+    def run(self: SideEffectRunner[Event]) -> None:
         """Run the side effect runner thread."""
         while True:
             task = self.task_queue.get()

tests/results/test_todo/todo/store-000.jsonc

@@ -1,12 +1,18 @@
 // store-000
 {
-  "_type": "ToDoState",
+  "_type": "TodoState",
   "items": [
     {
-      "_type": "ToDoItem",
+      "_type": "TodoItem",
       "content": "Initial Item",
       "id": "e3e70682c2094cac629f6fbed82c07cd",
       "timestamp": 1672531200.0
+    },
+    {
+      "_type": "TodoItem",
+      "content": "New Item",
+      "id": "f728b4fa42485e3a0a5d2f346baa9455",
+      "timestamp": 1672531200.0
     }
   ]
 }

tests/results/test_todo/todo/store-001.jsonc

@@ -1,15 +1,15 @@
 // store-001
 {
-  "_type": "ToDoState",
+  "_type": "TodoState",
   "items": [
     {
-      "_type": "ToDoItem",
+      "_type": "TodoItem",
       "content": "Initial Item",
       "id": "e3e70682c2094cac629f6fbed82c07cd",
       "timestamp": 1672531200.0
     },
     {
-      "_type": "ToDoItem",
+      "_type": "TodoItem",
       "content": "New Item",
       "id": "f728b4fa42485e3a0a5d2f346baa9455",
       "timestamp": 1672531200.0