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

reactivex/operators/_multicast.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import ConnectableObservable, Observable, abc
 from reactivex import operators as ops
@@ -9,14 +10,13 @@ _TResult = TypeVar("_TResult")
 
 
 def multicast_(
-    subject: Optional[abc.SubjectBase[_TSource]] = None,
+    subject: abc.SubjectBase[_TSource] | None = None,
     *,
-    subject_factory: Optional[
-        Callable[[Optional[abc.SchedulerBase]], abc.SubjectBase[_TSource]]
-    ] = None,
-    mapper: Optional[Callable[[Observable[_TSource]], Observable[_TResult]]] = None,
+    subject_factory: Callable[[abc.SchedulerBase | None], abc.SubjectBase[_TSource]]
+    | None = None,
+    mapper: Callable[[Observable[_TSource]], Observable[_TResult]] | None = None,
 ) -> Callable[
-    [Observable[_TSource]], Union[Observable[_TResult], ConnectableObservable[_TSource]]
+    [Observable[_TSource]], Observable[_TResult] | ConnectableObservable[_TSource]
 ]:
     """Multicasts the source sequence notifications through an
     instantiated subject into all uses of the sequence within a mapper
@@ -50,12 +50,12 @@ def multicast_(
 
     def multicast(
         source: Observable[_TSource],
-    ) -> Union[Observable[_TResult], ConnectableObservable[_TSource]]:
+    ) -> Observable[_TResult] | ConnectableObservable[_TSource]:
         if subject_factory:
 
             def subscribe(
                 observer: abc.ObserverBase[_TResult],
-                scheduler: Optional[abc.SchedulerBase] = None,
+                scheduler: abc.SchedulerBase | None = None,
             ) -> abc.DisposableBase:
                 assert subject_factory
                 connectable = source.pipe(

reactivex/operators/_observeon.py

@@ -1,43 +1,47 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 from reactivex.observer import ObserveOnObserver
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def observe_on_(
+    source: Observable[_T],
     scheduler: abc.SchedulerBase,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def observe_on(source: Observable[_T]) -> Observable[_T]:
-        """Wraps the source sequence in order to run its observer
-        callbacks on the specified scheduler.
-
-        This only invokes observer callbacks on a scheduler. In case
-        the subscription and/or unsubscription actions have
-        side-effects that require to be run on a scheduler, use
-        subscribe_on.
-
-        Args:
-            source: Source observable.
-
-
-        Returns:
-            Returns the source sequence whose observations happen on
-            the specified scheduler.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            subscribe_scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            return source.subscribe(
-                ObserveOnObserver(scheduler, observer), scheduler=subscribe_scheduler
-            )
-
-        return Observable(subscribe)
-
-    return observe_on
+) -> Observable[_T]:
+    """Wraps the source sequence in order to run its observer
+    callbacks on the specified scheduler.
+
+    This only invokes observer callbacks on a scheduler. In case
+    the subscription and/or unsubscription actions have
+    side-effects that require to be run on a scheduler, use
+    subscribe_on.
+
+    Examples:
+        >>> res = source.pipe(observe_on(scheduler))
+        >>> res = observe_on(scheduler)(source)
+
+    Args:
+        source: Source observable.
+        scheduler: Scheduler to observe on.
+
+    Returns:
+        Returns the source sequence whose observations happen on
+        the specified scheduler.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        subscribe_scheduler: abc.SchedulerBase | None = None,
+    ):
+        return source.subscribe(
+            ObserveOnObserver(scheduler, observer), scheduler=subscribe_scheduler
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["observe_on_"]

reactivex/operators/_onerrorresumenext.py

@@ -1,4 +1,5 @@
-from typing import Callable, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable

reactivex/operators/_pairwise.py

@@ -1,53 +1,57 @@
-from typing import Callable, Optional, Tuple, TypeVar, cast
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def pairwise_() -> Callable[[Observable[_T]], Observable[Tuple[_T, _T]]]:
-    def pairwise(source: Observable[_T]) -> Observable[Tuple[_T, _T]]:
-        """Partially applied pairwise operator.
+@curry_flip
+def pairwise_(source: Observable[_T]) -> Observable[tuple[_T, _T]]:
+    """Returns a new observable that triggers on the second and
+    subsequent triggerings of the input observable. The Nth
+    triggering of the input observable passes the arguments from
+    the N-1th and Nth triggering as a pair. The argument passed to
+    the N-1th triggering is held in hidden internal state until the
+    Nth triggering occurs.
 
-        Returns a new observable that triggers on the second and
-        subsequent triggerings of the input observable. The Nth
-        triggering of the input observable passes the arguments from
-        the N-1th and Nth triggering as a pair. The argument passed to
-        the N-1th triggering is held in hidden internal state until the
-        Nth triggering occurs.
+    Examples:
+        >>> res = source.pipe(pairwise())
+        >>> res = pairwise()(source)
 
-        Returns:
-            An observable that triggers on successive pairs of
-            observations from the input observable as an array.
-        """
+    Args:
+        source: The source observable sequence.
 
-        def subscribe(
-            observer: abc.ObserverBase[Tuple[_T, _T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            has_previous = False
-            previous: _T = cast(_T, None)
+    Returns:
+        An observable that triggers on successive pairs of
+        observations from the input observable as an array.
+    """
 
-            def on_next(x: _T) -> None:
-                nonlocal has_previous, previous
-                pair = None
+    def subscribe(
+        observer: abc.ObserverBase[tuple[_T, _T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        has_previous = False
+        previous: _T = cast(_T, None)
 
-                with source.lock:
-                    if has_previous:
-                        pair = (previous, x)
-                    else:
-                        has_previous = True
+        def on_next(x: _T) -> None:
+            nonlocal has_previous, previous
+            pair = None
 
-                    previous = x
+            with source.lock:
+                if has_previous:
+                    pair = (previous, x)
+                else:
+                    has_previous = True
 
-                if pair:
-                    observer.on_next(pair)
+                previous = x
 
-            return source.subscribe(on_next, observer.on_error, observer.on_completed)
+            if pair:
+                observer.on_next(pair)
 
-        return Observable(subscribe)
+        return source.subscribe(on_next, observer.on_error, observer.on_completed)
 
-    return pairwise
+    return Observable(subscribe)
 
 
 __all__ = ["pairwise_"]

reactivex/operators/_partition.py

@@ -1,88 +1,95 @@
-from typing import Callable, List, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.typing import Predicate, PredicateIndexed
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def partition_(
+    source: Observable[_T],
     predicate: Predicate[_T],
-) -> Callable[[Observable[_T]], List[Observable[_T]]]:
-    def partition(source: Observable[_T]) -> List[Observable[_T]]:
-        """The partially applied `partition` operator.
-
-        Returns two observables which partition the observations of the
-        source by the given function. The first will trigger
-        observations for those values for which the predicate returns
-        true. The second will trigger observations for those values
-        where the predicate returns false. The predicate is executed
-        once for each subscribed observer. Both also propagate all
-        error observations arising from the source and each completes
-        when the source completes.
-
-        Args:
-            source: Source observable to partition.
-
-        Returns:
-            A list of observables. The first triggers when the
-            predicate returns True, and the second triggers when the
-            predicate returns False.
-        """
-
-        def not_predicate(x: _T) -> bool:
-            return not predicate(x)
-
-        published = source.pipe(
-            ops.publish(),
-            ops.ref_count(),
-        )
-        return [
-            published.pipe(ops.filter(predicate)),
-            published.pipe(ops.filter(not_predicate)),
-        ]
-
-    return partition
-
-
+) -> list[Observable[_T]]:
+    """Returns two observables which partition the observations of the
+    source by the given function.
+
+    The first will trigger observations for those values for which the
+    predicate returns true. The second will trigger observations for
+    those values where the predicate returns false. The predicate is
+    executed once for each subscribed observer. Both also propagate all
+    error observations arising from the source and each completes
+    when the source completes.
+
+    Examples:
+        >>> res = source.pipe(partition(lambda x: x > 5))
+        >>> res = partition(lambda x: x > 5)(source)
+
+    Args:
+        source: Source observable to partition.
+        predicate: Function to test each element.
+
+    Returns:
+        A list of observables. The first triggers when the
+        predicate returns True, and the second triggers when the
+        predicate returns False.
+    """
+
+    def not_predicate(x: _T) -> bool:
+        return not predicate(x)
+
+    published = source.pipe(
+        ops.publish(),
+        ops.ref_count(),
+    )
+    return [
+        published.pipe(ops.filter(predicate)),
+        published.pipe(ops.filter(not_predicate)),
+    ]
+
+
+@curry_flip
 def partition_indexed_(
+    source: Observable[_T],
     predicate_indexed: PredicateIndexed[_T],
-) -> Callable[[Observable[_T]], List[Observable[_T]]]:
-    def partition_indexed(source: Observable[_T]) -> List[Observable[_T]]:
-        """The partially applied indexed partition operator.
-
-        Returns two observables which partition the observations of the
-        source by the given function. The first will trigger
-        observations for those values for which the predicate returns
-        true. The second will trigger observations for those values
-        where the predicate returns false. The predicate is executed
-        once for each subscribed observer. Both also propagate all
-        error observations arising from the source and each completes
-        when the source completes.
-
-        Args:
-            source: Source observable to partition.
-
-        Returns:
-            A list of observables. The first triggers when the
-            predicate returns True, and the second triggers when the
-            predicate returns False.
-        """
-
-        def not_predicate_indexed(x: _T, i: int) -> bool:
-            return not predicate_indexed(x, i)
-
-        published = source.pipe(
-            ops.publish(),
-            ops.ref_count(),
-        )
-        return [
-            published.pipe(ops.filter_indexed(predicate_indexed)),
-            published.pipe(ops.filter_indexed(not_predicate_indexed)),
-        ]
-
-    return partition_indexed
+) -> list[Observable[_T]]:
+    """Returns two observables which partition the observations of the
+    source by the given indexed function.
+
+    The first will trigger observations for those values for which the
+    predicate returns true. The second will trigger observations for
+    those values where the predicate returns false. The predicate is
+    executed once for each subscribed observer. Both also propagate all
+    error observations arising from the source and each completes
+    when the source completes.
+
+    Examples:
+        >>> res = source.pipe(partition_indexed(lambda x, i: i % 2 == 0))
+        >>> res = partition_indexed(lambda x, i: i % 2 == 0)(source)
+
+    Args:
+        source: Source observable to partition.
+        predicate_indexed: Function to test each element with its index.
+
+    Returns:
+        A list of observables. The first triggers when the
+        predicate returns True, and the second triggers when the
+        predicate returns False.
+    """
+
+    def not_predicate_indexed(x: _T, i: int) -> bool:
+        return not predicate_indexed(x, i)
+
+    published = source.pipe(
+        ops.publish(),
+        ops.ref_count(),
+    )
+    return [
+        published.pipe(ops.filter_indexed(predicate_indexed)),
+        published.pipe(ops.filter_indexed(not_predicate_indexed)),
+    ]
 
 
 __all__ = ["partition_", "partition_indexed_"]

reactivex/operators/_pluck.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable
 from reactivex import operators as ops
@@ -9,7 +10,7 @@ _TValue = TypeVar("_TValue")
 
 def pluck_(
     key: _TKey,
-) -> Callable[[Observable[Dict[_TKey, _TValue]]], Observable[_TValue]]:
+) -> Callable[[Observable[dict[_TKey, _TValue]]], Observable[_TValue]]:
     """Retrieves the value of a specified key using dict-like access (as in
     element[key]) from all elements in the Observable sequence.
 
@@ -21,7 +22,7 @@ def pluck_(
     To pluck an attribute of each element, use pluck_attr.
     """
 
-    def mapper(x: Dict[_TKey, _TValue]) -> _TValue:
+    def mapper(x: dict[_TKey, _TValue]) -> _TValue:
         return x[key]
 
     return ops.map(mapper)

reactivex/operators/_publish.py

@@ -1,7 +1,8 @@
-from typing import Callable, Optional, TypeVar, Union
+from typing import TypeVar
 
 from reactivex import ConnectableObservable, Observable, abc, compose
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.subject import Subject
 from reactivex.typing import Mapper
 
@@ -9,25 +10,26 @@ _TSource = TypeVar("_TSource")
 _TResult = TypeVar("_TResult")
 
 
+@curry_flip
 def publish_(
-    mapper: Optional[Mapper[Observable[_TSource], Observable[_TResult]]] = None,
-) -> Callable[
-    [Observable[_TSource]], Union[Observable[_TResult], ConnectableObservable[_TSource]]
-]:
+    source: Observable[_TSource],
+    mapper: Mapper[Observable[_TSource], Observable[_TResult]] | None = None,
+) -> Observable[_TResult] | ConnectableObservable[_TSource]:
     """Returns an observable sequence that is the result of invoking the
     mapper on a connectable observable sequence that shares a single
     subscription to the underlying sequence. This operator is a
     specialization of Multicast using a regular Subject.
 
-    Example:
-        >>> res = publish()
-        >>> res = publish(lambda x: x)
+    Examples:
+        >>> source.pipe(publish())
+        >>> source.pipe(publish(lambda x: x))
+        >>> publish()(source)
 
-    mapper: [Optional] Selector function which can use the
-        multicasted source sequence as many times as needed, without causing
-        multiple subscriptions to the source sequence. Subscribers to the
-        given source will receive all notifications of the source from the
-        time of the subscription on.
+    Args:
+        source: Source observable to publish.
+        mapper: [Optional] Selector function which can use the
+            multicasted source sequence as many times as needed, without
+            causing multiple subscriptions to the source sequence.
 
     Returns:
         An observable sequence that contains the elements of a sequence
@@ -37,17 +39,18 @@ def publish_(
 
     if mapper:
 
-        def factory(scheduler: Optional[abc.SchedulerBase] = None) -> Subject[_TSource]:
+        def factory(scheduler: abc.SchedulerBase | None = None) -> Subject[_TSource]:
             return Subject()
 
-        return ops.multicast(subject_factory=factory, mapper=mapper)
+        return source.pipe(ops.multicast(subject_factory=factory, mapper=mapper))
 
     subject: Subject[_TSource] = Subject()
-    return ops.multicast(subject=subject)
+    return source.pipe(ops.multicast(subject=subject))
 
 
-def share_() -> Callable[[Observable[_TSource]], Observable[_TSource]]:
-    """Share a single subscription among multple observers.
+@curry_flip
+def share_(source: Observable[_TSource]) -> Observable[_TSource]:
+    """Share a single subscription among multiple observers.
 
     Returns a new Observable that multicasts (shares) the original
     Observable. As long as there is at least one Subscriber this
@@ -56,10 +59,22 @@ def share_() -> Callable[[Observable[_TSource]], Observable[_TSource]]:
     Observable.
 
     This is an alias for a composed publish() and ref_count().
+
+    Examples:
+        >>> source.pipe(share())
+        >>> share()(source)
+
+    Args:
+        source: Source observable to share.
+
+    Returns:
+        An observable that shares a single subscription.
     """
-    return compose(
-        ops.publish(),
-        ops.ref_count(),
+    return source.pipe(
+        compose(
+            ops.publish(),
+            ops.ref_count(),
+        )
     )
 
 

reactivex/operators/_publishvalue.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import ConnectableObservable, Observable, abc
 from reactivex import operators as ops
@@ -11,15 +12,15 @@ _T2 = TypeVar("_T2")
 
 def publish_value_(
     initial_value: _T1,
-    mapper: Optional[Mapper[Observable[_T1], Observable[_T2]]] = None,
-) -> Union[
-    Callable[[Observable[_T1]], ConnectableObservable[_T1]],
-    Callable[[Observable[_T1]], Observable[_T2]],
-]:
+    mapper: Mapper[Observable[_T1], Observable[_T2]] | None = None,
+) -> (
+    Callable[[Observable[_T1]], ConnectableObservable[_T1]]
+    | Callable[[Observable[_T1]], Observable[_T2]]
+):
     if mapper:
 
         def subject_factory(
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> BehaviorSubject[_T1]:
             return BehaviorSubject(initial_value)
 

reactivex/operators/_reduce.py

@@ -1,7 +1,8 @@
-from typing import Any, Callable, Type, TypeVar, Union, cast
+from typing import Any, TypeVar, cast
 
-from reactivex import Observable, compose
+from reactivex import Observable
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.internal.utils import NotSet
 from reactivex.typing import Accumulator
 
@@ -9,9 +10,12 @@ _T = TypeVar("_T")
 _TState = TypeVar("_TState")
 
 
+@curry_flip
 def reduce_(
-    accumulator: Accumulator[_TState, _T], seed: Union[_TState, Type[NotSet]] = NotSet
-) -> Callable[[Observable[_T]], Observable[Any]]:
+    source: Observable[_T],
+    accumulator: Accumulator[_TState, _T],
+    seed: _TState | type[NotSet] = NotSet,
+) -> Observable[Any]:
     """Applies an accumulator function over an observable sequence,
     returning the result of the aggregation as a single element in the
     result sequence. The specified seed value is used as the initial
@@ -21,28 +25,28 @@ def reduce_(
     `scan()`.
 
     Examples:
-        >>> res = reduce(lambda acc, x: acc + x)
-        >>> res = reduce(lambda acc, x: acc + x, 0)
+        >>> result = source.pipe(reduce(lambda acc, x: acc + x))
+        >>> result = reduce(lambda acc, x: acc + x)(source)
+        >>> result = source.pipe(reduce(lambda acc, x: acc + x, 0))
 
     Args:
-        accumulator: An accumulator function to be
-            invoked on each element.
+        source: The source observable.
+        accumulator: An accumulator function to be invoked on each element.
         seed: Optional initial accumulator value.
 
     Returns:
-        An operator function that takes an observable source and returns
-        an observable sequence containing a single element with the
+        An observable sequence containing a single element with the
         final accumulator value.
     """
     if seed is not NotSet:
         seed_: _TState = cast(_TState, seed)
         scanner = ops.scan(accumulator, seed=seed_)
-        return compose(
+        return source.pipe(
             scanner,
             ops.last_or_default(default_value=seed_),
         )
 
-    return compose(
+    return source.pipe(
         ops.scan(cast(Accumulator[_T, _T], accumulator)),
         ops.last(),
     )