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

reactivex/__init__.py

@@ -1,13 +1,9 @@
 # pylint: disable=too-many-lines,redefined-outer-name,redefined-builtin
 
 from asyncio import Future
+from collections.abc import Callable, Iterable, Mapping
 from typing import (
     Any,
-    Callable,
-    Iterable,
-    Mapping,
-    Optional,
-    Tuple,
     TypeVar,
     Union,
     overload,
@@ -68,7 +64,7 @@ def amb(*sources: Observable[_T]) -> Observable[_T]:
 def case(
     mapper: Callable[[], _TKey],
     sources: Mapping[_TKey, Observable[_T]],
-    default_source: Optional[Union[Observable[_T], "Future[_T]"]] = None,
+    default_source: Observable[_T] | Future[_T] | None = None,
 ) -> Observable[_T]:
     """Uses mapper to determine which source in sources to use.
 
@@ -185,19 +181,19 @@ def create(subscribe: typing.Subscription[_T]) -> Observable[_T]:
 @overload
 def combine_latest(
     __a: Observable[_A], __b: Observable[_B]
-) -> Observable[Tuple[_A, _B]]: ...
+) -> Observable[tuple[_A, _B]]: ...
 
 
 @overload
 def combine_latest(
     __a: Observable[_A], __b: Observable[_B], __c: Observable[_C]
-) -> Observable[Tuple[_A, _B, _C]]: ...
+) -> Observable[tuple[_A, _B, _C]]: ...
 
 
 @overload
 def combine_latest(
     __a: Observable[_A], __b: Observable[_B], __c: Observable[_C], __d: Observable[_D]
-) -> Observable[Tuple[_A, _B, _C, _D]]: ...
+) -> Observable[tuple[_A, _B, _C, _D]]: ...
 
 
 def combine_latest(*__sources: Observable[Any]) -> Observable[Any]:
@@ -317,7 +313,7 @@ def defer(
     return defer_(factory)
 
 
-def empty(scheduler: Optional[abc.SchedulerBase] = None) -> Observable[Any]:
+def empty(scheduler: abc.SchedulerBase | None = None) -> Observable[Any]:
     """Returns an empty observable sequence.
 
     .. marble::
@@ -381,19 +377,19 @@ def for_in(
 @overload
 def fork_join(
     __a: Observable[_A], __b: Observable[_B]
-) -> Observable[Tuple[_A, _B]]: ...
+) -> Observable[tuple[_A, _B]]: ...
 
 
 @overload
 def fork_join(
     __a: Observable[_A], __b: Observable[_B], __c: Observable[_C]
-) -> Observable[Tuple[_A, _B, _C]]: ...
+) -> Observable[tuple[_A, _B, _C]]: ...
 
 
 @overload
 def fork_join(
     __a: Observable[_A], __b: Observable[_B], __c: Observable[_C], __d: Observable[_D]
-) -> Observable[Tuple[_A, _B, _C, _D]]: ...
+) -> Observable[tuple[_A, _B, _C, _D]]: ...
 
 
 @overload
@@ -403,7 +399,7 @@ def fork_join(
     __c: Observable[_C],
     __d: Observable[_D],
     __e: Observable[_E],
-) -> Observable[Tuple[_A, _B, _C, _D, _E]]: ...
+) -> Observable[tuple[_A, _B, _C, _D, _E]]: ...
 
 
 def fork_join(*sources: Observable[Any]) -> Observable[Any]:
@@ -437,7 +433,7 @@ def fork_join(*sources: Observable[Any]) -> Observable[Any]:
 
 
 def from_callable(
-    supplier: Callable[[], _T], scheduler: Optional[abc.SchedulerBase] = None
+    supplier: Callable[[], _T], scheduler: abc.SchedulerBase | None = None
 ) -> Observable[_T]:
     """Returns an observable sequence that contains a single element generated
     by the given supplier, using the specified scheduler to send out observer
@@ -472,7 +468,7 @@ def from_callable(
 
 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.
 
@@ -516,7 +512,7 @@ def from_future(future: "Future[_T]") -> Observable[_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.
 
@@ -555,9 +551,9 @@ from_list = alias(
 def from_marbles(
     string: str,
     timespan: typing.RelativeTime = 0.1,
-    scheduler: Optional[abc.SchedulerBase] = None,
-    lookup: Optional[Mapping[Union[str, float], Any]] = None,
-    error: Optional[Exception] = None,
+    scheduler: abc.SchedulerBase | None = None,
+    lookup: Mapping[str | float, Any] | None = None,
+    error: Exception | None = None,
 ) -> Observable[Any]:
     """Convert a marble diagram string to a cold observable sequence, using
     an optional scheduler to enumerate the events.
@@ -701,9 +697,9 @@ def hot(
     string: str,
     timespan: typing.RelativeTime = 0.1,
     duetime: typing.AbsoluteOrRelativeTime = 0.0,
-    scheduler: Optional[abc.SchedulerBase] = None,
-    lookup: Optional[Mapping[Union[str, float], Any]] = None,
-    error: Optional[Exception] = None,
+    scheduler: abc.SchedulerBase | None = None,
+    lookup: Mapping[str | float, Any] | None = None,
+    error: Exception | None = None,
 ) -> Observable[Any]:
     """Convert a marble diagram string to a hot observable sequence, using
     an optional scheduler to enumerate the events.
@@ -812,7 +808,7 @@ def if_then(
 
 
 def interval(
-    period: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
+    period: typing.RelativeTime, scheduler: abc.SchedulerBase | None = None
 ) -> Observable[int]:
     """Returns an observable sequence that produces a value after each period.
 
@@ -914,7 +910,7 @@ def of(*args: _T) -> Observable[_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
@@ -947,9 +943,9 @@ def on_error_resume_next(
 
 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
@@ -986,7 +982,7 @@ def range(
 
 
 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.
@@ -1016,7 +1012,7 @@ def return_value(
 just = alias("just", "Alias for :func:`reactivex.return_value`.", return_value)
 
 
-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.
 
@@ -1045,7 +1041,7 @@ def repeat_value(value: _T, repeat_count: Optional[int] = None) -> Observable[_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.
@@ -1105,7 +1101,7 @@ def start_async(function_async: Callable[[], "Future[_T]"]) -> Observable[_T]:
 
 
 def throw(
-    exception: Union[str, Exception], scheduler: Optional[abc.SchedulerBase] = None
+    exception: str | Exception, scheduler: abc.SchedulerBase | None = None
 ) -> Observable[Any]:
     """Returns an observable sequence that terminates with an exception,
     using the specified scheduler to send out the single OnError message.
@@ -1136,8 +1132,8 @@ def throw(
 
 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]:
     """Returns an observable sequence that produces a value after
     duetime has elapsed and then after each period.
@@ -1175,7 +1171,7 @@ def timer(
 
 
 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
@@ -1208,8 +1204,8 @@ def to_async(
 
 
 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
@@ -1232,7 +1228,7 @@ def using(
     return using_(resource_factory, observable_factory)
 
 
-def with_latest_from(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
+def with_latest_from(*sources: Observable[Any]) -> Observable[tuple[Any, ...]]:
     """Merges the specified observable sequences into one observable
     sequence by creating a :class:`tuple` only when the first
     observable sequence produces an element.
@@ -1261,7 +1257,7 @@ def with_latest_from(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
     return with_latest_from_(*sources)
 
 
-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 :class:`tuple` whenever all of the
     observable sequences have produced an element at a corresponding

reactivex/_version.py

@@ -1 +1 @@
-__version__ = "4.1.0"
+__version__ = "5.0.0a2"

reactivex/abc/disposable.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from types import TracebackType
-from typing import Optional, Type
 
 
 class DisposableBase(ABC):
@@ -23,9 +22,9 @@ class DisposableBase(ABC):
 
     def __exit__(
         self,
-        exctype: Optional[Type[BaseException]],
-        excinst: Optional[BaseException],
-        exctb: Optional[TracebackType],
+        exctype: type[BaseException] | None,
+        excinst: BaseException | None,
+        exctb: TracebackType | None,
     ) -> None:
         """Context management protocol."""
         self.dispose()

reactivex/abc/observable.py

@@ -1,5 +1,8 @@
 from abc import ABC, abstractmethod
-from typing import Callable, Generic, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+from typing_extensions import TypeAliasType
 
 from .disposable import DisposableBase
 from .observer import ObserverBase, OnCompleted, OnError, OnNext
@@ -18,11 +21,11 @@ class ObservableBase(Generic[_T_out], ABC):
     @abstractmethod
     def subscribe(
         self,
-        on_next: Optional[Union[OnNext[_T_out], ObserverBase[_T_out]]] = None,
-        on_error: Optional[OnError] = None,
-        on_completed: Optional[OnCompleted] = None,
+        on_next: OnNext[_T_out] | ObserverBase[_T_out] | None = None,
+        on_error: OnError | None = None,
+        on_completed: OnCompleted | None = None,
         *,
-        scheduler: Optional[SchedulerBase] = None,
+        scheduler: SchedulerBase | None = None,
     ) -> DisposableBase:
         """Subscribe an observer to the observable sequence.
 
@@ -40,6 +43,10 @@ class ObservableBase(Generic[_T_out], ABC):
         raise NotImplementedError
 
 
-Subscription = Callable[[ObserverBase[_T_out], Optional[SchedulerBase]], DisposableBase]
+Subscription = TypeAliasType(
+    "Subscription",
+    Callable[[ObserverBase[_T_out], SchedulerBase | None], DisposableBase],
+    type_params=(_T_out,),
+)
 
 __all__ = ["ObservableBase", "Subscription"]

reactivex/abc/observer.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import Callable, Generic, TypeVar
+from collections.abc import Callable
+from typing import Generic, TypeVar
 
 _T = TypeVar("_T")
 _T_in = TypeVar("_T_in", contravariant=True)

reactivex/abc/periodicscheduler.py

@@ -1,15 +1,16 @@
 from abc import ABC, abstractmethod
-from typing import Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar
 
 from .disposable import DisposableBase
 from .scheduler import RelativeTime, ScheduledAction
 
 _TState = TypeVar("_TState")  # Can be anything
 
-ScheduledPeriodicAction = Callable[[Optional[_TState]], Optional[_TState]]
-ScheduledSingleOrPeriodicAction = Union[
-    ScheduledAction[_TState], ScheduledPeriodicAction[_TState]
-]
+ScheduledPeriodicAction = Callable[[_TState | None], _TState | None]
+ScheduledSingleOrPeriodicAction = (
+    ScheduledAction[_TState] | ScheduledPeriodicAction[_TState]
+)
 
 
 class PeriodicSchedulerBase(ABC):
@@ -22,7 +23,7 @@ class PeriodicSchedulerBase(ABC):
         self,
         period: RelativeTime,
         action: ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> DisposableBase:
         """Schedules a periodic piece of work.
 

reactivex/abc/scheduler.py

@@ -1,17 +1,18 @@
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from datetime import datetime, timedelta
-from typing import Callable, Optional, TypeVar, Union
+from typing import TypeVar
 
 from .disposable import DisposableBase
 
 _TState = TypeVar("_TState")  # Can be anything
 
-AbsoluteTime = Union[datetime, float]
-RelativeTime = Union[timedelta, float]
-AbsoluteOrRelativeTime = Union[datetime, timedelta, float]
+AbsoluteTime = datetime | float
+RelativeTime = timedelta | float
+AbsoluteOrRelativeTime = datetime | timedelta | float
 ScheduledAction = Callable[
-    ["SchedulerBase", Optional[_TState]],
-    Optional[DisposableBase],
+    ["SchedulerBase", _TState | None],
+    DisposableBase | None,
 ]
 
 
@@ -35,7 +36,7 @@ class SchedulerBase(ABC):
 
     @abstractmethod
     def schedule(
-        self, action: ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: ScheduledAction[_TState], state: _TState | None = None
     ) -> DisposableBase:
         """Schedules an action to be executed.
 
@@ -55,7 +56,7 @@ class SchedulerBase(ABC):
         self,
         duetime: RelativeTime,
         action: ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -76,7 +77,7 @@ class SchedulerBase(ABC):
         self,
         duetime: AbsoluteTime,
         action: ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/abc/subject.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import Optional, TypeVar, Union
+from typing import TypeVar
 
 from .disposable import DisposableBase
 from .observable import ObservableBase
@@ -21,11 +21,11 @@ class SubjectBase(ObserverBase[_T], ObservableBase[_T]):
     @abstractmethod
     def subscribe(
         self,
-        on_next: Optional[Union[OnNext[_T], ObserverBase[_T]]] = None,
-        on_error: Optional[OnError] = None,
-        on_completed: Optional[OnCompleted] = None,
+        on_next: OnNext[_T] | ObserverBase[_T] | None = None,
+        on_error: OnError | None = None,
+        on_completed: OnCompleted | None = None,
         *,
-        scheduler: Optional[SchedulerBase] = None,
+        scheduler: SchedulerBase | None = None,
     ) -> DisposableBase:
         """Subscribe an observer to the observable sequence.
 

reactivex/disposable/compositedisposable.py

@@ -1,5 +1,5 @@
 from threading import RLock
-from typing import Any, List
+from typing import Any
 
 from reactivex import abc
 
@@ -10,13 +10,13 @@ class CompositeDisposable(abc.DisposableBase):
 
     def __init__(self, *args: Any):
         if args and isinstance(args[0], list):
-            self.disposable: List[abc.DisposableBase] = args[0]
+            self.disposable: list[abc.DisposableBase] = args[0]
         else:
             self.disposable = list(args)
 
         self.is_disposed = False
         self.lock = RLock()
-        super(CompositeDisposable, self).__init__()
+        super().__init__()
 
     def add(self, item: abc.DisposableBase) -> None:
         """Adds a disposable to the CompositeDisposable or disposes the
@@ -92,7 +92,7 @@ class CompositeDisposable(abc.DisposableBase):
 
         return item in self.disposable
 
-    def to_list(self) -> List[abc.DisposableBase]:
+    def to_list(self) -> list[abc.DisposableBase]:
         return self.disposable[:]
 
     def __len__(self) -> int:

reactivex/disposable/disposable.py

@@ -1,5 +1,4 @@
 from threading import RLock
-from typing import Optional
 
 from reactivex import typing
 from reactivex.abc import DisposableBase
@@ -10,7 +9,7 @@ from reactivex.typing import Action
 class Disposable(DisposableBase):
     """Main disposable class"""
 
-    def __init__(self, action: Optional[typing.Action] = None) -> None:
+    def __init__(self, action: typing.Action | None = None) -> None:
         """Creates a disposable object that invokes the specified
         action when disposed.
 

reactivex/disposable/multipleassignmentdisposable.py

@@ -1,5 +1,4 @@
 from threading import RLock
-from typing import Optional
 
 from reactivex.abc import DisposableBase
 
@@ -9,13 +8,13 @@ class MultipleAssignmentDisposable(DisposableBase):
     resource can be replaced by another disposable resource."""
 
     def __init__(self) -> None:
-        self.current: Optional[DisposableBase] = None
+        self.current: DisposableBase | None = None
         self.is_disposed = False
         self.lock = RLock()
 
         super().__init__()
 
-    def get_disposable(self) -> Optional[DisposableBase]:
+    def get_disposable(self) -> DisposableBase | None:
         return self.current
 
     def set_disposable(self, value: DisposableBase) -> None:

reactivex/disposable/refcountdisposable.py

@@ -1,5 +1,4 @@
 from threading import RLock
-from typing import Optional
 
 from reactivex.abc import DisposableBase
 
@@ -13,7 +12,7 @@ class RefCountDisposable(DisposableBase):
 
     class InnerDisposable(DisposableBase):
         def __init__(self, parent: "RefCountDisposable") -> None:
-            self.parent: Optional[RefCountDisposable] = parent
+            self.parent: RefCountDisposable | None = parent
             self.is_disposed = False
             self.lock = RLock()
 

reactivex/disposable/serialdisposable.py

@@ -1,5 +1,4 @@
 from threading import RLock
-from typing import Optional
 
 from reactivex import abc
 
@@ -11,13 +10,13 @@ class SerialDisposable(abc.DisposableBase):
     """
 
     def __init__(self) -> None:
-        self.current: Optional[abc.DisposableBase] = None
+        self.current: abc.DisposableBase | None = None
         self.is_disposed = False
         self.lock = RLock()
 
         super().__init__()
 
-    def get_disposable(self) -> Optional[abc.DisposableBase]:
+    def get_disposable(self) -> abc.DisposableBase | None:
         return self.current
 
     def set_disposable(self, value: abc.DisposableBase) -> None:
@@ -26,7 +25,7 @@ class SerialDisposable(abc.DisposableBase):
         disposable object. Assigning this property disposes the previous
         disposable object."""
 
-        old: Optional[abc.DisposableBase] = None
+        old: abc.DisposableBase | None = None
 
         with self.lock:
             should_dispose = self.is_disposed
@@ -46,7 +45,7 @@ class SerialDisposable(abc.DisposableBase):
         """Disposes the underlying disposable as well as all future
         replacements."""
 
-        old: Optional[abc.DisposableBase] = None
+        old: abc.DisposableBase | None = None
 
         with self.lock:
             if not self.is_disposed:

reactivex/disposable/singleassignmentdisposable.py

@@ -1,5 +1,4 @@
 from threading import RLock
-from typing import Optional
 
 from reactivex.abc import DisposableBase
 
@@ -17,12 +16,12 @@ class SingleAssignmentDisposable(DisposableBase):
         class.
         """
         self.is_disposed: bool = False
-        self.current: Optional[DisposableBase] = None
+        self.current: DisposableBase | None = None
         self.lock = RLock()
 
         super().__init__()
 
-    def get_disposable(self) -> Optional[DisposableBase]:
+    def get_disposable(self) -> DisposableBase | None:
         return self.current
 
     def set_disposable(self, value: DisposableBase) -> None:
@@ -41,7 +40,7 @@ class SingleAssignmentDisposable(DisposableBase):
 
     def dispose(self) -> None:
         """Sets the status to disposed"""
-        old: Optional[DisposableBase] = None
+        old: DisposableBase | None = None
 
         with self.lock:
             if not self.is_disposed:

reactivex/internal/__init__.py

@@ -1,6 +1,7 @@
 from .basic import default_comparer, default_error, noop
 from .concurrency import default_thread_factory, synchronized
 from .constants import DELTA_ZERO, UTC_ZERO
+from .curry import curry_flip
 from .exceptions import (
     ArgumentOutOfRangeException,
     DisposedException,
@@ -13,6 +14,7 @@ __all__ = [
     "add_ref",
     "alias",
     "ArgumentOutOfRangeException",
+    "curry_flip",
     "DisposedException",
     "default_comparer",
     "default_error",

reactivex/internal/basic.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timezone
-from typing import Any, NoReturn, TypeVar, Union
+from typing import Any, NoReturn, TypeVar
 
 _T = TypeVar("_T")
 
@@ -29,7 +29,7 @@ def default_key_serializer(x: Any) -> str:
     return str(x)
 
 
-def default_error(err: Union[Exception, str]) -> NoReturn:
+def default_error(err: Exception | str) -> NoReturn:
     if isinstance(err, BaseException):
         raise err
 

reactivex/internal/concurrency.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from threading import RLock, Thread
-from typing import Any, Callable, TypeVar
+from typing import Any, TypeVar
 
 from typing_extensions import ParamSpec