chore(lint): update ruff to 0.10.0 and fix linting issues, make store.subscribe private

Author: sassanh

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## Upcoming
+
+- chore(lint): update `ruff` to `0.10.0` and fix linting issues, make `store.subscribe` private
+
 ## Version 0.20.1
 
 - fix: avoid using `asdict` in combine-reducers's reducer as it can get too costly for large dataclasses and may even run into errors

demo.py

@@ -136,7 +136,7 @@ def event_handler(event: SleepEvent) -> None:
     # -----
 
     # Subscription <
-    store.subscribe(lambda state: print('Subscription state:', state))
+    store._subscribe(lambda state: print('Subscription state:', state))  # noqa: SLF001
     # >
 
     # -----

pyproject.toml

@@ -14,7 +14,7 @@ dependencies = ["python-immutable >= 1.1.1", "python-strtobool >= 1.0.0"]
 dev-dependencies = [
   "poethepoet >= 0.24.4",
   "pyright >= 1.1.396",
-  "ruff >= 0.9.10",
+  "ruff >= 0.10.0",
   "pytest >= 8.1.1",
   "pytest-cov >= 4.1.0",
   "pytest-timeout >= 2.3.1",

redux/autorun.py

@@ -102,7 +102,7 @@ def __init__(
 
         self._last_selector_result: SelectorOutput | None = None
         self._last_comparator_result: ComparatorOutput = cast(
-            ComparatorOutput,
+            'ComparatorOutput',
             object(),
         )
         if iscoroutinefunction(func):
@@ -118,7 +118,7 @@ def __init__(
             self._call()
 
         if self._options.reactive:
-            self._unsubscribe = store.subscribe(
+            self._unsubscribe = store._subscribe(  # noqa: SLF001
                 lambda state: self._call() if self._check(state) else None,
             )
         else:
@@ -190,7 +190,7 @@ def _check(
         except AttributeError:
             return False
         if self._comparator is None:
-            comparator_result = cast(ComparatorOutput, selector_result)
+            comparator_result = cast('ComparatorOutput', selector_result)
         else:
             try:
                 comparator_result = self._comparator(state)
@@ -228,7 +228,7 @@ def _call(
             if iscoroutine(value) and create_task:
                 if self._options.auto_await:
                     future = Future()
-                    self._latest_value = cast(ReturnType, future)
+                    self._latest_value = cast('ReturnType', future)
                     create_task(
                         value,
                         callback=functools.partial(
@@ -244,7 +244,7 @@ def _call(
                     ):
                         self._latest_value.close()
                     self._latest_value = cast(
-                        ReturnType,
+                        'ReturnType',
                         AwaitableWrapper(value),
                     )
             else:
@@ -268,7 +268,7 @@ def __call__(
         self._check(state)
         if self._should_be_called or args or kwargs or not self._options.memoization:
             self._call(*args, **kwargs)
-        return cast(ReturnType, self._latest_value)
+        return cast('ReturnType', self._latest_value)
 
     def __repr__(
         self: Autorun[
@@ -298,7 +298,7 @@ def value(
             Args,
         ],
     ) -> ReturnType:
-        return cast(ReturnType, self._latest_value)
+        return cast('ReturnType', self._latest_value)
 
     def subscribe(
         self: Autorun[

redux/basic_types.py

@@ -39,7 +39,7 @@ class BaseEvent(Immutable): ...
 State = TypeVar('State', bound=Immutable | None, infer_variance=True)
 Action = TypeVar('Action', bound=BaseAction | None, infer_variance=True)
 Event = TypeVar('Event', bound=BaseEvent | None, infer_variance=True)
-Event2 = TypeVar('Event2', bound=BaseEvent, infer_variance=True)
+StrictEvent = TypeVar('StrictEvent', bound=BaseEvent, infer_variance=True)
 SelectorOutput = TypeVar('SelectorOutput', infer_variance=True)
 ComparatorOutput = TypeVar('ComparatorOutput', infer_variance=True)
 ReturnType = TypeVar('ReturnType', infer_variance=True)
@@ -168,10 +168,7 @@ def unsubscribe(self: AutorunReturnType) -> None: ...
     __name__: str
 
 
-class AutorunDecorator(
-    Protocol,
-    Generic[SelectorOutput, ReturnType],
-):
+class AutorunDecorator(Protocol, Generic[SelectorOutput, ReturnType]):
     @overload
     def __call__(
         self: AutorunDecorator,
@@ -340,3 +337,11 @@ class CombineReducerUnregisterAction(CombineReducerAction):
     | dict[str, 'SnapshotAtom']
     | list['SnapshotAtom']
 )
+
+
+class SubscribeEventCleanup(Immutable, Generic[StrictEvent]):
+    unsubscribe: Callable[[], None]
+    handler: EventHandler[StrictEvent]
+
+    def __call__(self: SubscribeEventCleanup) -> None:
+        self.unsubscribe()

redux/combine_reducers.py

@@ -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
+                cast('Any', state_class).__dataclass_fields__ = fields_copy
 
                 state = state_class(
                     _id=state._id,  # noqa: SLF001

redux/main.py

@@ -7,7 +7,6 @@
 import queue
 import weakref
 from collections import defaultdict
-from collections.abc import Callable
 from threading import Lock, Thread
 from typing import (
     TYPE_CHECKING,
@@ -35,7 +34,6 @@
     CreateStoreOptions,
     DispatchParameters,
     Event,
-    Event2,
     EventHandler,
     EventMiddleware,
     FinishAction,
@@ -46,6 +44,8 @@
     SelectorOutput,
     SnapshotAtom,
     State,
+    StrictEvent,
+    SubscribeEventCleanup,
     UnknownAutorunDecorator,
     UnknownViewDecorator,
     ViewDecorator,
@@ -61,7 +61,7 @@
 from redux.side_effect_runner import SideEffectRunnerThread
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable
+    from collections.abc import Awaitable, Callable
 
 
 class Store(Generic[State, Action, Event], SerializationMixin):
@@ -112,11 +112,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(cast('Action', InitAction())),
                     interval=False,
                 )
             else:
-                self.dispatch(cast(Action, InitAction()))
+                self.dispatch(cast('Action', InitAction()))
 
         if self.store_options.scheduler:
             self.store_options.scheduler(self.run, interval=True)
@@ -148,7 +148,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([cast('Event', FinishEvent())])
 
     def _run_event_handlers(self: Store[State, Action, Event]) -> None:
         while len(self._events) > 0:
@@ -216,7 +216,7 @@ def _dispatch(
     ) -> None:
         for item in items:
             if isinstance(item, BaseAction):
-                action = cast(Action, item)
+                action = cast('Action', item)
                 for action_middleware in self._action_middlewares:
                     action_ = action_middleware(action)
                     if action_ is None:
@@ -225,7 +225,7 @@ def _dispatch(
                 else:
                     self._actions.append(action)
             if isinstance(item, BaseEvent):
-                event = cast(Event, item)
+                event = cast('Event', item)
                 for event_middleware in self._event_middlewares:
                     event_ = event_middleware(event)
                     if event_ is None:
@@ -237,7 +237,7 @@ def _dispatch(
         if self.store_options.scheduler is None and not self._is_running.locked():
             self.run()
 
-    def subscribe(
+    def _subscribe(
         self: Store[State, Action, Event],
         listener: Callable[[State], Any],
         *,
@@ -256,11 +256,11 @@ def subscribe(
 
     def subscribe_event(
         self: Store[State, Action, Event],
-        event_type: type[Event2],
-        handler: EventHandler[Event2],
+        event_type: type[StrictEvent],
+        handler: EventHandler[StrictEvent],
         *,
         keep_ref: bool = True,
-    ) -> Callable[[], None]:
+    ) -> SubscribeEventCleanup:
         """Subscribe to events."""
         if keep_ref:
             handler_ref = handler
@@ -269,12 +269,12 @@ def subscribe_event(
         else:
             handler_ref = weakref.ref(handler)
 
-        self._event_handlers[cast(Any, event_type)].add(handler_ref)
+        self._event_handlers[cast('Any', event_type)].add(handler_ref)
 
         def unsubscribe() -> None:
-            self._event_handlers[cast(Any, event_type)].discard(handler_ref)
+            self._event_handlers[cast('Any', event_type)].discard(handler_ref)
 
-        return unsubscribe
+        return SubscribeEventCleanup(unsubscribe=unsubscribe, handler=handler)
 
     def _wait_for_store_to_finish(self: Store[State, Action, Event]) -> None:
         """Wait for the store to finish."""
@@ -325,20 +325,20 @@ def autorun(
         """Create a new autorun, reflecting on state changes."""
 
         @overload
-        def decorator(
+        def autorun_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 ReturnType,
             ],
         ) -> AutorunReturnType[ReturnType, Args]: ...
         @overload
-        def decorator(
+        def autorun_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 Awaitable[ReturnType],
             ],
         ) -> AutorunReturnType[Awaitable[ReturnType], Args]: ...
-        def decorator(
+        def autorun_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 AwaitableOrNot[ReturnType],
@@ -348,11 +348,11 @@ def decorator(
                 store=self,
                 selector=selector,
                 comparator=comparator,
-                func=cast(Callable, func),
+                func=cast('Callable', func),
                 options=options or AutorunOptions(),
             )
 
-        return decorator
+        return autorun_decorator
 
     @overload
     def view(
@@ -379,21 +379,21 @@ def view(
         """Create a new view, throttling calls for unchanged selector results."""
 
         @overload
-        def decorator(
+        def view_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 ReturnType,
             ],
         ) -> ViewReturnType[ReturnType, Args]: ...
         @overload
-        def decorator(
+        def view_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 Awaitable[ReturnType],
             ],
         ) -> ViewReturnType[Awaitable[ReturnType], Args]: ...
 
-        def decorator(
+        def view_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 AwaitableOrNot[ReturnType],
@@ -404,7 +404,7 @@ def decorator(
                 store=self,
                 selector=selector,
                 comparator=None,
-                func=cast(Callable, func),
+                func=cast('Callable', func),
                 options=AutorunOptions(
                     default_value=_options.default_value,
                     auto_await=True,
@@ -417,7 +417,7 @@ def decorator(
                 ),
             )
 
-        return decorator
+        return view_decorator
 
     def with_state(
         self: Store[State, Action, Event],
@@ -433,7 +433,7 @@ def with_state(
         `store._state` is also possible.
         """
 
-        def decorator(
+        def with_state_decorator(
             func: Callable[
                 Concatenate[SelectorOutput, Args],
                 ReturnType,
@@ -445,9 +445,11 @@ def wrapper(*args: Args.args, **kwargs: Args.kwargs) -> ReturnType:
                     raise RuntimeError(msg)
                 return func(selector(self._state), *args, **kwargs)
 
+            wrapper.__name__ = f'with_state:{func.__name__}'
+
             return wrapper
 
-        return decorator
+        return with_state_decorator
 
     @property
     def snapshot(self: Store[State, Action, Event]) -> SnapshotAtom: