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

reactivex/internal/curry.py

@@ -0,0 +1,59 @@
+"""Simplified curry_flip decorator for RxPY operators.
+
+Adapted from Expression library (https://github.com/dbrattli/Expression)
+Simplified to always curry_flip with 1 argument as that's the only case
+needed for RxPY operators.
+"""
+
+import functools
+from collections.abc import Callable
+from typing import Concatenate, TypeVar
+
+from typing_extensions import ParamSpec
+
+_P = ParamSpec("_P")
+_A = TypeVar("_A")
+_B = TypeVar("_B")
+
+
+def curry_flip(
+    fun: Callable[Concatenate[_A, _P], _B],
+) -> Callable[_P, Callable[[_A], _B]]:
+    """A flipped curry decorator for single-argument currying.
+
+    Makes a function curried, but flips the curried argument to become
+    the last argument. This is perfect for RxPY operators where the source
+    Observable should be the last argument to enable piping.
+
+    This is a simplified version that always curries exactly 1 argument,
+    as that's all RxPY operators need.
+
+    Args:
+        fun: The function to curry-flip. Must take at least one argument.
+
+    Returns:
+        A curried function where the first argument becomes the last.
+
+    Example:
+        >>> @curry_flip
+        ... def take(count: int, source: Observable[int]) -> Observable[int]:
+        ...     # implementation
+        ...     pass
+        >>>
+        >>> # Now can be used in pipe:
+        >>> result = source.pipe(take(5))
+        >>> # Or called directly:
+        >>> result = take(5)(source)
+    """
+
+    @functools.wraps(fun)
+    def _wrap_args(*args: _P.args, **kwargs: _P.kwargs) -> Callable[[_A], _B]:
+        def _wrap_curried(curry_arg: _A) -> _B:
+            return fun(curry_arg, *args, **kwargs)
+
+        return _wrap_curried
+
+    return _wrap_args
+
+
+__all__ = ["curry_flip"]

reactivex/internal/exceptions.py

@@ -1,36 +1,31 @@
 # Rx Exceptions
 
 
-from typing import Optional
-
-
 class SequenceContainsNoElementsError(Exception):
-    def __init__(self, msg: Optional[str] = None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or "Sequence contains no elements")
 
 
 class ArgumentOutOfRangeException(ValueError):
-    def __init__(self, msg: Optional[str] = None):
-        super(ArgumentOutOfRangeException, self).__init__(
-            msg or "Argument out of range"
-        )
+    def __init__(self, msg: str | None = None):
+        super().__init__(msg or "Argument out of range")
 
 
 class DisposedException(Exception):
-    def __init__(self, msg: Optional[str] = None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or "Object has been disposed")
 
 
 class ReEntracyException(Exception):
-    def __init__(self, msg: Optional[str] = None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or "Re-entrancy detected")
 
 
 class CompletedException(Exception):
-    def __init__(self, msg: Optional[str] = None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or "Observer completed")
 
 
 class WouldBlockException(Exception):
-    def __init__(self, msg: Optional[str] = None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or "Would block")

reactivex/internal/priorityqueue.py

@@ -1,6 +1,6 @@
 import heapq
 from sys import maxsize
-from typing import Generic, List, Tuple, TypeVar
+from typing import Generic, TypeVar
 
 _T1 = TypeVar("_T1")
 
@@ -11,7 +11,7 @@ class PriorityQueue(Generic[_T1]):
     MIN_COUNT = ~maxsize
 
     def __init__(self) -> None:
-        self.items: List[Tuple[_T1, int]] = []
+        self.items: list[tuple[_T1, int]] = []
         self.count = PriorityQueue.MIN_COUNT  # Monotonic increasing for sort stability
 
     def __len__(self) -> int:

reactivex/internal/utils.py

@@ -1,6 +1,7 @@
+from collections.abc import Callable, Iterable
 from functools import update_wrapper
 from types import FunctionType
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from typing_extensions import ParamSpec
 
@@ -19,7 +20,7 @@ def add_ref(xs: "Observable[_T]", r: RefCountDisposable) -> "Observable[_T]":
     from reactivex import Observable
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         return CompositeDisposable(r.disposable, xs.subscribe(observer))
 

reactivex/notification.py

@@ -1,5 +1,6 @@
 from abc import abstractmethod
-from typing import Any, Callable, Generic, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar, cast
 
 from reactivex import abc, typing
 from reactivex.scheduler import ImmediateScheduler
@@ -21,9 +22,9 @@ class Notification(Generic[_T]):
 
     def accept(
         self,
-        on_next: Union[typing.OnNext[_T], abc.ObserverBase[_T]],
-        on_error: Optional[typing.OnError] = None,
-        on_completed: Optional[typing.OnCompleted] = None,
+        on_next: typing.OnNext[_T] | abc.ObserverBase[_T],
+        on_error: typing.OnError | None = None,
+        on_completed: typing.OnCompleted | None = None,
     ) -> None:
         """Invokes the delegate corresponding to the notification or an
         observer and returns the produced result.
@@ -43,7 +44,7 @@ class Notification(Generic[_T]):
             Result produced by the observation."""
 
         if isinstance(on_next, abc.ObserverBase):
-            return self._accept_observer(on_next)
+            return self._accept_observer(cast(abc.ObserverBase[_T], on_next))
 
         return self._accept(on_next, on_error, on_completed)
 
@@ -51,8 +52,8 @@ class Notification(Generic[_T]):
     def _accept(
         self,
         on_next: typing.OnNext[_T],
-        on_error: Optional[typing.OnError],
-        on_completed: Optional[typing.OnCompleted],
+        on_error: typing.OnError | None,
+        on_completed: typing.OnCompleted | None,
     ) -> None:
         raise NotImplementedError
 
@@ -61,7 +62,7 @@ class Notification(Generic[_T]):
         raise NotImplementedError
 
     def to_observable(
-        self, scheduler: Optional[abc.SchedulerBase] = None
+        self, scheduler: abc.SchedulerBase | None = None
     ) -> abc.ObservableBase[_T]:
         """Returns an observable sequence with a single notification,
         using the specified scheduler, else the immediate scheduler.
@@ -79,7 +80,7 @@ class Notification(Generic[_T]):
 
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             def action(scheduler: abc.SchedulerBase, state: Any) -> None:
                 self._accept_observer(observer)
@@ -108,7 +109,7 @@ class OnNext(Notification[_T]):
     def __init__(self, value: _T) -> None:
         """Constructs a notification of a new value."""
 
-        super(OnNext, self).__init__()
+        super().__init__()
         self.value: _T = value
         self.has_value: bool = True
         self.kind: str = "N"
@@ -116,8 +117,8 @@ class OnNext(Notification[_T]):
     def _accept(
         self,
         on_next: typing.OnNext[_T],
-        on_error: Optional[typing.OnError] = None,
-        on_completed: Optional[typing.OnCompleted] = None,
+        on_error: typing.OnError | None = None,
+        on_completed: typing.OnCompleted | None = None,
     ) -> None:
         return on_next(self.value)
 
@@ -128,16 +129,16 @@ class OnNext(Notification[_T]):
         val: Any = self.value
         if isinstance(val, int):
             val = float(val)
-        return "OnNext(%s)" % str(val)
+        return f"OnNext({str(val)})"
 
 
 class OnError(Notification[_T]):
     """Represents an OnError notification to an observer."""
 
-    def __init__(self, error: Union[Exception, str]) -> None:
+    def __init__(self, error: Exception | str) -> None:
         """Constructs a notification of an exception."""
 
-        super(OnError, self).__init__()
+        super().__init__()
         self.exception: Exception = (
             error if isinstance(error, Exception) else Exception(error)
         )
@@ -146,8 +147,8 @@ class OnError(Notification[_T]):
     def _accept(
         self,
         on_next: typing.OnNext[_T],
-        on_error: Optional[typing.OnError],
-        on_completed: Optional[typing.OnCompleted],
+        on_error: typing.OnError | None,
+        on_completed: typing.OnCompleted | None,
     ) -> None:
         return on_error(self.exception) if on_error else None
 
@@ -155,7 +156,7 @@ class OnError(Notification[_T]):
         return observer.on_error(self.exception)
 
     def __str__(self) -> str:
-        return "OnError(%s)" % str(self.exception)
+        return f"OnError({str(self.exception)})"
 
 
 class OnCompleted(Notification[_T]):
@@ -164,14 +165,14 @@ class OnCompleted(Notification[_T]):
     def __init__(self) -> None:
         """Constructs a notification of the end of a sequence."""
 
-        super(OnCompleted, self).__init__()
+        super().__init__()
         self.kind = "C"
 
     def _accept(
         self,
         on_next: typing.OnNext[_T],
-        on_error: Optional[typing.OnError],
-        on_completed: Optional[typing.OnCompleted],
+        on_error: typing.OnError | None,
+        on_completed: typing.OnCompleted | None,
     ) -> None:
         return on_completed() if on_completed else None
 

reactivex/observable/case.py

@@ -1,5 +1,6 @@
 from asyncio import Future
-from typing import Callable, Mapping, Optional, TypeVar, Union
+from collections.abc import Callable, Mapping
+from typing import TypeVar, Union
 
 from reactivex import Observable, abc, defer, empty, from_future
 
@@ -10,19 +11,17 @@ _T = TypeVar("_T")
 def case_(
     mapper: Callable[[], _Key],
     sources: Mapping[_Key, Observable[_T]],
-    default_source: Optional[Union[Observable[_T], "Future[_T]"]] = None,
+    default_source: Union[Observable[_T], "Future[_T]"] | None = None,
 ) -> Observable[_T]:
-
-    default_source_: Union[Observable[_T], "Future[_T]"] = default_source or empty()
+    default_source_: Observable[_T] | Future[_T] = default_source or empty()
 
     def factory(_: abc.SchedulerBase) -> Observable[_T]:
         try:
-            result: Union[Observable[_T], "Future[_T]"] = sources[mapper()]
+            result: Observable[_T] | Future[_T] = sources[mapper()]
         except KeyError:
             result = default_source_
 
         if isinstance(result, Future):
-
             result_: Observable[_T] = from_future(result)
         else:
             result_ = result

reactivex/observable/catch.py

@@ -1,4 +1,5 @@
-from typing import Any, Iterable, Optional, TypeVar
+from collections.abc import Iterable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import (
@@ -32,7 +33,7 @@ def catch_with_iterable_(sources: Iterable[Observable[_T]]) -> Observable[_T]:
     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()
 

reactivex/observable/combinelatest.py

@@ -1,10 +1,10 @@
-from typing import Any, List, Optional, Tuple
+from typing import Any
 
 from reactivex import Observable, abc
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
 
 
-def combine_latest_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
+def combine_latest_(*sources: Observable[Any]) -> Observable[tuple[Any, ...]]:
     """Merges the specified observable sequences into one observable
     sequence by creating a tuple whenever any of the
     observable sequences produces an element.
@@ -20,9 +20,8 @@ def combine_latest_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
     parent = sources[0]
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> CompositeDisposable:
-
         n = len(sources)
         has_value = [False] * n
         has_value_all = [False]
@@ -46,7 +45,7 @@ def combine_latest_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
             if all(is_done):
                 observer.on_completed()
 
-        subscriptions: List[Optional[SingleAssignmentDisposable]] = [None] * n
+        subscriptions: list[SingleAssignmentDisposable | None] = [None] * n
 
         def func(i: int) -> None:
             subscriptions[i] = SingleAssignmentDisposable()

reactivex/observable/concat.py

@@ -1,4 +1,5 @@
-from typing import Any, Iterable, Optional, TypeVar
+from collections.abc import Iterable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import (
@@ -14,7 +15,7 @@ _T = TypeVar("_T")
 
 def concat_with_iterable_(sources: Iterable[Observable[_T]]) -> 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 CurrentThreadScheduler.singleton()
 

reactivex/observable/connectableobservable.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc
 from reactivex.disposable import CompositeDisposable, Disposable
@@ -15,7 +15,7 @@ class ConnectableObservable(Observable[_T]):
     def __init__(self, source: abc.ObservableBase[_T], subject: abc.SubjectBase[_T]):
         self.subject = subject
         self.has_subscription = False
-        self.subscription: Optional[abc.DisposableBase] = None
+        self.subscription: abc.DisposableBase | None = None
         self.source = source
 
         super().__init__()
@@ -23,13 +23,13 @@ class ConnectableObservable(Observable[_T]):
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         return self.subject.subscribe(observer, scheduler=scheduler)
 
     def connect(
-        self, scheduler: Optional[abc.SchedulerBase] = None
-    ) -> Optional[abc.DisposableBase]:
+        self, scheduler: abc.SchedulerBase | None = None
+    ) -> abc.DisposableBase | None:
         """Connects the observable."""
 
         if not self.has_subscription:
@@ -52,7 +52,7 @@ class ConnectableObservable(Observable[_T]):
         subscribers.
         """
 
-        connectable_subscription: List[Optional[abc.DisposableBase]] = [None]
+        connectable_subscription: list[abc.DisposableBase | None] = [None]
         count = [0]
         source = self
         is_connected = [False]
@@ -63,7 +63,7 @@ class ConnectableObservable(Observable[_T]):
 
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             count[0] += 1
             should_connect = count[0] == subscriber_count and not is_connected[0]

reactivex/observable/defer.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
 
 from reactivex import Observable, abc, from_future, throw
 from reactivex.scheduler import ImmediateScheduler
@@ -8,7 +9,7 @@ _T = TypeVar("_T")
 
 
 def defer_(
-    factory: Callable[[abc.SchedulerBase], Union[Observable[_T], "Future[_T]"]]
+    factory: Callable[[abc.SchedulerBase], Union[Observable[_T], "Future[_T]"]],
 ) -> Observable[_T]:
     """Returns an observable sequence that invokes the specified factory
     function whenever a new observer subscribes.
@@ -27,7 +28,7 @@ def defer_(
     """
 
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         try:
             result = factory(scheduler or ImmediateScheduler.singleton())

reactivex/observable/empty.py

@@ -1,14 +1,13 @@
-from typing import Any, Optional
+from typing import Any
 
 from reactivex import Observable, abc
 from reactivex.scheduler import ImmediateScheduler
 
 
-def empty_(scheduler: Optional[abc.SchedulerBase] = None) -> Observable[Any]:
+def empty_(scheduler: abc.SchedulerBase | None = None) -> Observable[Any]:
     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 scheduler_ or ImmediateScheduler.singleton()
 
         def action(_: abc.SchedulerBase, __: Any) -> None:

reactivex/observable/forkjoin.py

@@ -1,10 +1,10 @@
-from typing import Any, List, Optional, Tuple, cast
+from typing import Any, cast
 
 from reactivex import Observable, abc
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
 
 
-def fork_join_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
+def fork_join_(*sources: Observable[Any]) -> Observable[tuple[Any, ...]]:
     """Wait for observables to complete and then combine last values
     they emitted into a tuple. Whenever any of that observables completes
     without emitting any value, result sequence will complete at that moment as well.
@@ -20,8 +20,8 @@ def fork_join_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
     parent = sources[0]
 
     def subscribe(
-        observer: abc.ObserverBase[Tuple[Any, ...]],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        observer: abc.ObserverBase[tuple[Any, ...]],
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         n = len(sources)
         values = [None] * n
@@ -42,7 +42,7 @@ def fork_join_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
                 else:
                     observer.on_completed()
 
-        subscriptions: List[SingleAssignmentDisposable] = [
+        subscriptions: list[SingleAssignmentDisposable] = [
             cast(SingleAssignmentDisposable, None)
         ] * n
 

reactivex/observable/fromcallback.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional
+from collections.abc import Callable
+from typing import Any
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import Disposable
@@ -6,7 +7,7 @@ from reactivex.disposable import Disposable
 
 def from_callback_(
     func: Callable[..., Callable[..., None]],
-    mapper: Optional[typing.Mapper[Any, Any]] = None,
+    mapper: typing.Mapper[Any, Any] | None = None,
 ) -> Callable[[], Observable[Any]]:
     """Converts a callback function to an observable sequence.
 
@@ -27,7 +28,7 @@ def from_callback_(
 
         def subscribe(
             observer: abc.ObserverBase[Any],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             def handler(*args: Any) -> None:
                 results = list(args)

reactivex/observable/fromfuture.py

@@ -1,6 +1,6 @@
 import asyncio
 from asyncio import Future
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 from reactivex import Observable, abc
 from reactivex.disposable import Disposable
@@ -21,7 +21,7 @@ def from_future_(future: "Future[_T]") -> Observable[_T]:
     """
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         def done(future: "Future[_T]") -> None:
             try:

reactivex/observable/fromiterable.py

@@ -1,4 +1,5 @@
-from typing import Any, Iterable, Optional, TypeVar
+from collections.abc import Iterable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import CompositeDisposable, Disposable
@@ -8,7 +9,7 @@ _T = TypeVar("_T")
 
 
 def from_iterable_(
-    iterable: Iterable[_T], scheduler: Optional[abc.SchedulerBase] = None
+    iterable: Iterable[_T], scheduler: abc.SchedulerBase | None = None
 ) -> Observable[_T]:
     """Converts an iterable to an observable sequence.
 
@@ -25,7 +26,7 @@ def from_iterable_(
     """
 
     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()
         iterator = iter(iterable)

reactivex/observable/generate.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import MultipleAssignmentDisposable
@@ -14,7 +14,7 @@ def generate_(
 ) -> Observable[_TState]:
     def subscribe(
         observer: abc.ObserverBase[_TState],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         scheduler = scheduler or CurrentThreadScheduler.singleton()
         first = True

reactivex/observable/generatewithrelativetime.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 from reactivex import Observable, abc
 from reactivex.disposable import MultipleAssignmentDisposable
@@ -38,7 +39,7 @@ def generate_with_relative_time_(
 
     def subscribe(
         observer: abc.ObserverBase[_TState],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         scheduler = scheduler or TimeoutScheduler.singleton()
         mad = MultipleAssignmentDisposable()
@@ -46,7 +47,7 @@ def generate_with_relative_time_(
         has_result = False
         result: _TState = cast(_TState, None)
         first = True
-        time: Optional[RelativeTime] = None
+        time: RelativeTime | None = None
 
         def action(scheduler: abc.SchedulerBase, _: Any) -> None:
             nonlocal state

reactivex/observable/groupedobservable.py

@@ -1,4 +1,4 @@
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from reactivex import abc
 from reactivex.disposable import CompositeDisposable, Disposable, RefCountDisposable
@@ -14,14 +14,14 @@ class GroupedObservable(Generic[_TKey, _T], Observable[_T]):
         self,
         key: _TKey,
         underlying_observable: Observable[_T],
-        merged_disposable: Optional[RefCountDisposable] = None,
+        merged_disposable: RefCountDisposable | None = None,
     ):
         super().__init__()
         self.key = key
 
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             return CompositeDisposable(
                 merged_disposable.disposable if merged_disposable else Disposable(),
@@ -35,6 +35,6 @@ class GroupedObservable(Generic[_TKey, _T], Observable[_T]):
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         return self.underlying_observable.subscribe(observer, scheduler=scheduler)

reactivex/observable/ifthen.py

@@ -1,5 +1,6 @@
 from asyncio import Future
-from typing import Callable, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar, Union
 
 import reactivex
 from reactivex import Observable, abc
@@ -33,7 +34,7 @@ def if_then_(
         else_source.
     """
 
-    else_source_: Union[Observable[_T], "Future[_T]"] = else_source or reactivex.empty()
+    else_source_: Observable[_T] | Future[_T] = else_source or reactivex.empty()
 
     then_source = (
         reactivex.from_future(then_source)