reactivex 4.1.0__py3-none-any.whl → 5.0.0a2__py3-none-any.whl

reactivex/observable/observable.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 
 import asyncio
 import threading
-from typing import Any, Callable, Generator, Optional, TypeVar, Union, cast, overload
+from collections.abc import Callable, Generator
+from typing import Any, TypeVar, cast, overload
 
 from reactivex import abc
 from reactivex.disposable import Disposable
@@ -11,6 +12,19 @@ from reactivex.scheduler import CurrentThreadScheduler
 from reactivex.scheduler.eventloop import AsyncIOScheduler
 
 from ..observer import AutoDetachObserver
+from .mixins import (
+    CombinationMixin,
+    ConditionalMixin,
+    ErrorHandlingMixin,
+    FilteringMixin,
+    MathematicalMixin,
+    MulticastingMixin,
+    TestingMixin,
+    TimeBasedMixin,
+    TransformationMixin,
+    UtilityMixin,
+    WindowingMixin,
+)
 
 _A = TypeVar("_A")
 _B = TypeVar("_B")
@@ -23,13 +37,41 @@ _G = TypeVar("_G")
 _T_out = TypeVar("_T_out", covariant=True)
 
 
-class Observable(abc.ObservableBase[_T_out]):
-    """Observable base class.
-
-    Represents a push-style collection, which you can :func:`pipe <pipe>` into
-    :mod:`operators <reactivex.operators>`."""
-
-    def __init__(self, subscribe: Optional[abc.Subscription[_T_out]] = None) -> None:
+class Observable(
+    abc.ObservableBase[_T_out],
+    TransformationMixin[_T_out],
+    FilteringMixin[_T_out],
+    CombinationMixin[_T_out],
+    MathematicalMixin[_T_out],
+    ConditionalMixin[_T_out],
+    ErrorHandlingMixin[_T_out],
+    UtilityMixin[_T_out],
+    TimeBasedMixin[_T_out],
+    WindowingMixin[_T_out],
+    MulticastingMixin[_T_out],
+    TestingMixin[_T_out],
+):
+    """Observable with method chaining support.
+
+    Represents a push-style collection that supports both functional (pipe-based)
+    and fluent (method chaining) styles. You can :func:`pipe <pipe>` into
+    :mod:`operators <reactivex.operators>` or call operator methods directly.
+
+    The Observable class combines all operator categories through mixins:
+    - TransformationMixin: map, reduce, scan, flat_map, etc.
+    - FilteringMixin: filter, take, skip, distinct, etc.
+    - CombinationMixin: merge, zip, combine_latest, etc.
+    - MathematicalMixin: count, sum, average, min, max
+    - ConditionalMixin: default_if_empty, etc.
+    - ErrorHandlingMixin: catch, retry, on_error_resume_next
+    - UtilityMixin: do_action, delay, timestamp, etc.
+    - TimeBasedMixin: sample, debounce, etc.
+    - WindowingMixin: buffer, group_by, partition, etc.
+    - MulticastingMixin: share, publish, replay, etc.
+    - TestingMixin: all, some, is_empty, contains, etc.
+    """
+
+    def __init__(self, subscribe: abc.Subscription[_T_out] | None = None) -> None:
         """Creates an observable sequence object from the specified
         subscription function.
 
@@ -44,19 +86,17 @@ class Observable(abc.ObservableBase[_T_out]):
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T_out],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         return self._subscribe(observer, scheduler) if self._subscribe else Disposable()
 
     def subscribe(
         self,
-        on_next: Optional[
-            Union[abc.ObserverBase[_T_out], abc.OnNext[_T_out], None]
-        ] = None,
-        on_error: Optional[abc.OnError] = None,
-        on_completed: Optional[abc.OnCompleted] = None,
+        on_next: abc.ObserverBase[_T_out] | abc.OnNext[_T_out] | None | None = None,
+        on_error: abc.OnError | None = None,
+        on_completed: abc.OnCompleted | None = None,
         *,
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         """Subscribe an observer to the observable sequence.
 
@@ -88,7 +128,7 @@ class Observable(abc.ObservableBase[_T_out]):
 
         Returns:
             Disposable object representing an observer's subscription to
-            the observable sequence.
+            the observable sequence. Call :code:`.dispose()` on it to unsubscribe.
         """
         if (
             isinstance(on_next, abc.ObserverBase)
@@ -105,7 +145,7 @@ class Observable(abc.ObservableBase[_T_out]):
         )
 
         def fix_subscriber(
-            subscriber: Union[abc.DisposableBase, Callable[[], None]]
+            subscriber: abc.DisposableBase | Callable[[], None],
         ) -> abc.DisposableBase:
             """Fixes subscriber to make sure it returns a Disposable instead
             of None or a dispose function"""
@@ -118,9 +158,7 @@ class Observable(abc.ObservableBase[_T_out]):
 
             return Disposable(subscriber)
 
-        def set_disposable(
-            _: Optional[abc.SchedulerBase] = None, __: Any = None
-        ) -> None:
+        def set_disposable(_: abc.SchedulerBase | None = None, __: Any = None) -> None:
             try:
                 subscriber = self._subscribe_core(auto_detach_observer, scheduler)
             except Exception as ex:  # By design. pylint: disable=W0703
@@ -229,7 +267,7 @@ class Observable(abc.ObservableBase[_T_out]):
 
         return pipe_(self, *operators)
 
-    def run(self) -> Any:
+    def run(self, scheduler: abc.SchedulerBase | None = None) -> _T_out:
         """Run source synchronously.
 
         Subscribes to the observable source. Then blocks and waits for the
@@ -249,7 +287,7 @@ class Observable(abc.ObservableBase[_T_out]):
         """
         from ..run import run
 
-        return run(self)
+        return run(self, scheduler)
 
     def __await__(self) -> Generator[Any, None, _T_out]:
         """Awaits the given observable.
@@ -259,7 +297,11 @@ class Observable(abc.ObservableBase[_T_out]):
         """
         from ..operators._tofuture import to_future_
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+
         future: asyncio.Future[_T_out] = self.pipe(
             to_future_(scheduler=AsyncIOScheduler(loop=loop))
         )
@@ -281,7 +323,7 @@ class Observable(abc.ObservableBase[_T_out]):
 
         return concat(self, other)
 
-    def __iadd__(self, other: Observable[_T_out]) -> "Observable[_T_out]":
+    def __iadd__(self, other: Observable[_T_out]) -> Observable[_T_out]:
         """Pythonic use of :func:`concat <reactivex.concat>`.
 
         Example:
@@ -297,7 +339,7 @@ class Observable(abc.ObservableBase[_T_out]):
 
         return concat(self, other)
 
-    def __getitem__(self, key: Union[slice, int]) -> Observable[_T_out]:
+    def __getitem__(self, key: slice | int) -> Observable[_T_out]:
         """
         Pythonic version of :func:`slice <reactivex.operators.slice>`.
 
@@ -346,5 +388,10 @@ class Observable(abc.ObservableBase[_T_out]):
 
         return slice_(start, stop, step)(self)
 
+    # All operator methods are provided by mixins:
+    # TransformationMixin, FilteringMixin, CombinationMixin, MathematicalMixin,
+    # ConditionalMixin, ErrorHandlingMixin, UtilityMixin, TimeBasedMixin,
+    # WindowingMixin, MulticastingMixin, TestingMixin
+
 
 __all__ = ["Observable"]

reactivex/observable/onerrorresumenext.py

@@ -1,5 +1,6 @@
 from asyncio import Future
-from typing import Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar, Union
 
 import reactivex
 from reactivex import Observable, abc
@@ -15,8 +16,8 @@ _T = TypeVar("_T")
 
 def on_error_resume_next_(
     *sources: Union[
-        Observable[_T], "Future[_T]", Callable[[Optional[Exception]], Observable[_T]]
-    ]
+        Observable[_T], "Future[_T]", Callable[[Exception | None], Observable[_T]]
+    ],
 ) -> Observable[_T]:
     """Continues an observable sequence that is terminated normally or
     by an exception with the next observable sequence.
@@ -32,7 +33,7 @@ def on_error_resume_next_(
     sources_ = iter(sources)
 
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         scheduler = scheduler or CurrentThreadScheduler.singleton()
 
@@ -40,7 +41,7 @@ def on_error_resume_next_(
         cancelable = SerialDisposable()
 
         def action(
-            scheduler: abc.SchedulerBase, state: Optional[Exception] = None
+            scheduler: abc.SchedulerBase, state: Exception | None = None
         ) -> None:
             try:
                 source = next(sources_)
@@ -57,7 +58,7 @@ def on_error_resume_next_(
             d = SingleAssignmentDisposable()
             subscription.disposable = d
 
-            def on_resume(state: Optional[Exception] = None) -> None:
+            def on_resume(state: Exception | None = None) -> None:
                 scheduler.schedule(action, state)
 
             d.disposable = current.subscribe(

reactivex/observable/range.py

@@ -1,5 +1,5 @@
+from collections.abc import Iterator
 from sys import maxsize
-from typing import Iterator, Optional
 
 from reactivex import Observable, abc
 from reactivex.disposable import MultipleAssignmentDisposable
@@ -8,9 +8,9 @@ from reactivex.scheduler import CurrentThreadScheduler
 
 def range_(
     start: int,
-    stop: Optional[int] = None,
-    step: Optional[int] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    stop: int | None = None,
+    step: int | None = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Observable[int]:
     """Generates an observable sequence of integral numbers within a
     specified range, using the specified scheduler to send out observer
@@ -44,7 +44,7 @@ def range_(
         range_t = range(start, _stop, _step)
 
     def subscribe(
-        observer: abc.ObserverBase[int], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[int], scheduler_: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         nonlocal range_t
 
@@ -52,7 +52,7 @@ def range_(
         sd = MultipleAssignmentDisposable()
 
         def action(
-            scheduler: abc.SchedulerBase, iterator: Optional[Iterator[int]]
+            scheduler: abc.SchedulerBase, iterator: Iterator[int] | None
         ) -> None:
             try:
                 assert iterator

reactivex/observable/repeat.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable
@@ -7,7 +7,7 @@ from reactivex import operators as ops
 _T = TypeVar("_T")
 
 
-def repeat_value_(value: _T, repeat_count: Optional[int] = None) -> Observable[_T]:
+def repeat_value_(value: _T, repeat_count: int | None = None) -> Observable[_T]:
     """Generates an observable sequence that repeats the given element
     the specified number of times.
 

reactivex/observable/returnvalue.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.scheduler import CurrentThreadScheduler
@@ -7,7 +8,7 @@ _T = TypeVar("_T")
 
 
 def return_value_(
-    value: _T, scheduler: Optional[abc.SchedulerBase] = None
+    value: _T, scheduler: abc.SchedulerBase | None = None
 ) -> Observable[_T]:
     """Returns an observable sequence that contains a single element,
     using the specified scheduler to send out observer messages.
@@ -26,7 +27,7 @@ def return_value_(
     """
 
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler_: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         _scheduler = scheduler or scheduler_ or CurrentThreadScheduler.singleton()
 
@@ -40,10 +41,10 @@ def return_value_(
 
 
 def from_callable_(
-    supplier: Callable[[], _T], scheduler: Optional[abc.SchedulerBase] = None
+    supplier: Callable[[], _T], scheduler: abc.SchedulerBase | None = None
 ) -> Observable[_T]:
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler_: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         _scheduler = scheduler or scheduler_ or CurrentThreadScheduler.singleton()
 

reactivex/observable/start.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import Observable, abc, to_async
 
@@ -6,7 +7,7 @@ _T = TypeVar("_T")
 
 
 def start_(
-    func: Callable[[], _T], scheduler: Optional[abc.SchedulerBase] = None
+    func: Callable[[], _T], scheduler: abc.SchedulerBase | None = None
 ) -> Observable[_T]:
     """Invokes the specified function asynchronously on the specified
     scheduler, surfacing the result through an observable sequence.

reactivex/observable/startasync.py

@@ -1,5 +1,6 @@
 from asyncio import Future
-from typing import Callable, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import Observable, from_future, throw
 

reactivex/observable/throw.py

@@ -1,16 +1,16 @@
-from typing import Any, Optional, Union
+from typing import Any
 
 from reactivex import Observable, abc
 from reactivex.scheduler import ImmediateScheduler
 
 
 def throw_(
-    exception: Union[str, Exception], scheduler: Optional[abc.SchedulerBase] = None
+    exception: str | Exception, scheduler: abc.SchedulerBase | None = None
 ) -> Observable[Any]:
     exception_ = exception if isinstance(exception, Exception) else Exception(exception)
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         _scheduler = scheduler or ImmediateScheduler.singleton()
 

reactivex/observable/timer.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import MultipleAssignmentDisposable
@@ -8,10 +8,10 @@ from reactivex.scheduler.periodicscheduler import PeriodicScheduler
 
 
 def observable_timer_date(
-    duetime: typing.AbsoluteTime, scheduler: Optional[abc.SchedulerBase] = None
+    duetime: typing.AbsoluteTime, scheduler: abc.SchedulerBase | None = None
 ) -> Observable[int]:
     def subscribe(
-        observer: abc.ObserverBase[int], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[int], scheduler_: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         _scheduler: abc.SchedulerBase = (
             scheduler or scheduler_ or TimeoutScheduler.singleton()
@@ -29,10 +29,10 @@ def observable_timer_date(
 def observable_timer_duetime_and_period(
     duetime: typing.AbsoluteOrRelativeTime,
     period: typing.AbsoluteOrRelativeTime,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Observable[int]:
     def subscribe(
-        observer: abc.ObserverBase[int], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[int], scheduler_: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
         nonlocal duetime
@@ -66,10 +66,10 @@ def observable_timer_duetime_and_period(
 
 
 def observable_timer_timespan(
-    duetime: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
+    duetime: typing.RelativeTime, scheduler: abc.SchedulerBase | None = None
 ) -> Observable[int]:
     def subscribe(
-        observer: abc.ObserverBase[int], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[int], scheduler_: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
         d = _scheduler.to_seconds(duetime)
@@ -88,19 +88,19 @@ def observable_timer_timespan(
 def observable_timer_timespan_and_period(
     duetime: typing.RelativeTime,
     period: typing.RelativeTime,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Observable[int]:
     if duetime == period:
 
         def subscribe(
             observer: abc.ObserverBase[int],
-            scheduler_: Optional[abc.SchedulerBase] = None,
+            scheduler_: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             _scheduler: abc.SchedulerBase = (
                 scheduler or scheduler_ or TimeoutScheduler.singleton()
             )
 
-            def action(count: Optional[int] = None) -> Optional[int]:
+            def action(count: int | None = None) -> int | None:
                 if count is not None:
                     observer.on_next(count)
                     return count + 1
@@ -116,8 +116,8 @@ def observable_timer_timespan_and_period(
 
 def timer_(
     duetime: typing.AbsoluteOrRelativeTime,
-    period: Optional[typing.RelativeTime] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    period: typing.RelativeTime | None = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Observable[int]:
     if isinstance(duetime, datetime):
         if period is None:

reactivex/observable/toasync.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex import operators as ops
@@ -9,7 +10,7 @@ _T = TypeVar("_T")
 
 
 def to_async_(
-    func: Callable[..., _T], scheduler: Optional[abc.SchedulerBase] = None
+    func: Callable[..., _T], scheduler: abc.SchedulerBase | None = None
 ) -> Callable[..., Observable[_T]]:
     """Converts the function into an asynchronous function. Each
     invocation of the resulting asynchronous function causes an

reactivex/observable/using.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable, abc
@@ -8,8 +9,8 @@ _T = TypeVar("_T")
 
 
 def using_(
-    resource_factory: Callable[[], Optional[abc.DisposableBase]],
-    observable_factory: Callable[[Optional[abc.DisposableBase]], Observable[_T]],
+    resource_factory: Callable[[], abc.DisposableBase | None],
+    observable_factory: Callable[[abc.DisposableBase | None], Observable[_T]],
 ) -> Observable[_T]:
     """Constructs an observable sequence that depends on a resource
     object, whose lifetime is tied to the resulting observable
@@ -29,7 +30,7 @@ def using_(
     """
 
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         disp: abc.DisposableBase = Disposable()
 

reactivex/observable/withlatestfrom.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional, Tuple
+from typing import Any
 
 from reactivex import Observable, abc
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
@@ -7,16 +7,15 @@ from reactivex.internal.utils import NotSet
 
 def with_latest_from_(
     parent: Observable[Any], *sources: Observable[Any]
-) -> Observable[Tuple[Any, ...]]:
+) -> Observable[tuple[Any, ...]]:
     NO_VALUE = NotSet()
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         def subscribeall(
             parent: Observable[Any], *children: Observable[Any]
-        ) -> List[SingleAssignmentDisposable]:
-
+        ) -> list[SingleAssignmentDisposable]:
             values = [NO_VALUE for _ in children]
 
             def subscribechild(

reactivex/observable/zip.py

@@ -1,13 +1,13 @@
 from asyncio import Future
 from threading import RLock
-from typing import Any, List, Optional, Tuple
+from typing import Any, cast
 
 from reactivex import Observable, abc, from_future
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
 from reactivex.internal import synchronized
 
 
-def zip_(*args: Observable[Any]) -> Observable[Tuple[Any, ...]]:
+def zip_(*args: Observable[Any]) -> Observable[tuple[Any, ...]]:
     """Merges the specified observable sequences into one observable
     sequence by creating a tuple whenever all of the
     observable sequences have produced an element at a corresponding
@@ -27,10 +27,10 @@ def zip_(*args: Observable[Any]) -> Observable[Tuple[Any, ...]]:
     sources = list(args)
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> CompositeDisposable:
         n = len(sources)
-        queues: List[List[Any]] = [[] for _ in range(n)]
+        queues: list[list[Any]] = [[] for _ in range(n)]
         lock = RLock()
         is_completed = [False] * n
 
@@ -62,12 +62,13 @@ def zip_(*args: Observable[Any]) -> Observable[Tuple[Any, ...]]:
             if len(queues[i]) == 0:
                 observer.on_completed()
 
-        subscriptions: List[Optional[abc.DisposableBase]] = [None] * n
+        subscriptions: list[abc.DisposableBase | None] = [None] * n
 
         def func(i: int) -> None:
             source: Observable[Any] = sources[i]
             if isinstance(source, Future):
-                source = from_future(source)
+                source_ = cast(Future[Any], source)
+                source = from_future(source_)
 
             sad = SingleAssignmentDisposable()
 

reactivex/observer/autodetachobserver.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from reactivex.disposable import SingleAssignmentDisposable
 from reactivex.internal import default_error, noop
@@ -11,9 +11,9 @@ _T_in = TypeVar("_T_in", contravariant=True)
 class AutoDetachObserver(abc.ObserverBase[_T_in]):
     def __init__(
         self,
-        on_next: Optional[typing.OnNext[_T_in]] = None,
-        on_error: Optional[typing.OnError] = None,
-        on_completed: Optional[typing.OnCompleted] = None,
+        on_next: typing.OnNext[_T_in] | None = None,
+        on_error: typing.OnError | None = None,
+        on_completed: typing.OnCompleted | None = None,
     ) -> None:
         self._on_next = on_next or noop
         self._on_error = on_error or default_error

reactivex/observer/observer.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar
 
 from reactivex import abc
 from reactivex.internal.basic import default_error, noop
@@ -24,9 +25,9 @@ class Observer(abc.ObserverBase[_T_in], abc.DisposableBase):
 
     def __init__(
         self,
-        on_next: Optional[OnNext[_T_in]] = None,
-        on_error: Optional[OnError] = None,
-        on_completed: Optional[OnCompleted] = None,
+        on_next: OnNext[_T_in] | None = None,
+        on_error: OnError | None = None,
+        on_completed: OnCompleted | None = None,
     ) -> None:
         self.is_stopped = False
         self._handler_on_next: OnNext[_T_in] = on_next or noop

reactivex/observer/scheduledobserver.py

@@ -1,5 +1,5 @@
 import threading
-from typing import Any, List, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import SerialDisposable
@@ -21,7 +21,7 @@ class ScheduledObserver(Observer[_T_in]):
         self.lock = threading.RLock()
         self.is_acquired = False
         self.has_faulted = False
-        self.queue: List[typing.Action] = []
+        self.queue: list[typing.Action] = []
         self.disposable = SerialDisposable()
 
         # Note to self: list append is thread safe