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

reactivex/operators/_repeat.py

@@ -1,42 +1,45 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable
+from reactivex.internal import curry_flip
 from reactivex.internal.utils import infinite
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def repeat_(
-    repeat_count: Optional[int] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def repeat(source: Observable[_T]) -> Observable[_T]:
-        """Repeats the observable sequence a specified number of times.
-        If the repeat count is not specified, the sequence repeats
-        indefinitely.
-
-        Examples:
-            >>> repeated = source.repeat()
-            >>> repeated = source.repeat(42)
-
-        Args:
-            source: The observable source to repeat.
-
-        Returns:
-            The observable sequence producing the elements of the given
-            sequence repeatedly.
-        """
-
-        if repeat_count is None:
-            gen = infinite()
-        else:
-            gen = range(repeat_count)
-
-        return reactivex.defer(
-            lambda _: reactivex.concat_with_iterable(source for _ in gen)
-        )
-
-    return repeat
+    source: Observable[_T],
+    repeat_count: int | None = None,
+) -> Observable[_T]:
+    """Repeats the observable sequence a specified number of times.
+    If the repeat count is not specified, the sequence repeats
+    indefinitely.
+
+    Examples:
+        >>> result = source.pipe(repeat())
+        >>> result = repeat()(source)
+        >>> result = source.pipe(repeat(42))
+
+    Args:
+        source: The observable source to repeat.
+        repeat_count: Optional number of times to repeat the sequence.
+            If not provided, repeats indefinitely.
+
+    Returns:
+        The observable sequence producing the elements of the given
+        sequence repeatedly.
+    """
+
+    if repeat_count is None:
+        gen = infinite()
+    else:
+        gen = range(repeat_count)
+
+    return reactivex.defer(
+        lambda _: reactivex.concat_with_iterable(source for _ in gen)
+    )
 
 
 __all = ["repeat"]

reactivex/operators/_replay.py

@@ -1,8 +1,8 @@
-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 ConnectableObservable, Observable, abc, typing
 from reactivex import operators as ops
-from reactivex import typing
 from reactivex.subject import ReplaySubject
 from reactivex.typing import Mapper
 
@@ -11,12 +11,12 @@ _TResult = TypeVar("_TResult")
 
 
 def replay_(
-    mapper: Optional[Mapper[Observable[_TSource], Observable[_TResult]]] = None,
-    buffer_size: Optional[int] = None,
-    window: Optional[typing.RelativeTime] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    mapper: Mapper[Observable[_TSource], Observable[_TResult]] | None = None,
+    buffer_size: int | None = None,
+    window: typing.RelativeTime | None = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Callable[
-    [Observable[_TSource]], Union[Observable[_TResult], ConnectableObservable[_TSource]]
+    [Observable[_TSource]], 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
@@ -52,7 +52,7 @@ def replay_(
     if mapper:
 
         def subject_factory(
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> ReplaySubject[_TSource]:
             return ReplaySubject(buffer_size, window, scheduler)
 

reactivex/operators/_retry.py

@@ -1,25 +1,30 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable
+from reactivex.internal import curry_flip
 from reactivex.internal.utils import infinite
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def retry_(
-    retry_count: Optional[int] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    retry_count: int | None = None,
+) -> Observable[_T]:
     """Repeats the source observable sequence the specified number of
     times or until it successfully terminates. If the retry count is
     not specified, it retries indefinitely.
 
     Examples:
-        >>> retried = retry()
-        >>> retried = retry(42)
+        >>> result = source.pipe(retry())
+        >>> result = retry()(source)
+        >>> result = source.pipe(retry(42))
 
     Args:
-        retry_count: [Optional] Number of times to retry the sequence.
+        source: The source observable sequence.
+        retry_count: Optional number of times to retry the sequence.
             If not provided, retry the sequence indefinitely.
 
     Returns:
@@ -32,10 +37,7 @@ def retry_(
     else:
         gen = range(retry_count)
 
-    def retry(source: Observable[_T]) -> Observable[_T]:
-        return reactivex.catch_with_iterable(source for _ in gen)
-
-    return retry
+    return reactivex.catch_with_iterable(source for _ in gen)
 
 
 __all__ = ["retry_"]

reactivex/operators/_sample.py

@@ -1,8 +1,9 @@
-from typing import Any, Callable, Optional, TypeVar, Union, cast
+from typing import Any, TypeVar, cast
 
 import reactivex
 from reactivex import Observable, abc, typing
 from reactivex.disposable import CompositeDisposable
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
@@ -11,8 +12,8 @@ def sample_observable(
     source: Observable[_T], sampler: Observable[Any]
 ) -> Observable[_T]:
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase] = None
-    ):
+        observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None = None
+    ) -> abc.DisposableBase:
         at_end = False
         has_value = False
         value: _T = cast(_T, None)
@@ -50,31 +51,34 @@ def sample_observable(
     return Observable(subscribe)
 
 
+@curry_flip
 def sample_(
-    sampler: Union[typing.RelativeTime, Observable[Any]],
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def sample(source: Observable[_T]) -> Observable[_T]:
-        """Samples the observable sequence at each interval.
-
-        Examples:
-            >>> res = sample(source)
-
-        Args:
-            source: Source sequence to sample.
-
-        Returns:
-            Sampled observable sequence.
-        """
-
-        if isinstance(sampler, abc.ObservableBase):
-            return sample_observable(source, sampler)
-        else:
-            return sample_observable(
-                source, reactivex.interval(sampler, scheduler=scheduler)
-            )
-
-    return sample
+    source: Observable[_T],
+    sampler: typing.RelativeTime | Observable[Any],
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Samples the observable sequence at each interval.
+
+    Examples:
+        >>> res = source.pipe(sample(1.0))
+        >>> res = sample(1.0)(source)
+        >>> res = source.pipe(sample(other_observable))
+
+    Args:
+        source: Source sequence to sample.
+        sampler: Interval or observable to sample at.
+        scheduler: Scheduler to use.
+
+    Returns:
+        Sampled observable sequence.
+    """
+
+    if isinstance(sampler, abc.ObservableBase):
+        return sample_observable(source, sampler)
+    else:
+        return sample_observable(
+            source, reactivex.interval(sampler, scheduler=scheduler)
+        )
 
 
 __all__ = ["sample_"]

reactivex/operators/_scan.py

@@ -1,7 +1,8 @@
-from typing import Callable, Type, TypeVar, Union, cast
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc, defer
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.internal.utils import NotSet
 from reactivex.typing import Accumulator
 
@@ -9,52 +10,53 @@ _T = TypeVar("_T")
 _TState = TypeVar("_TState")
 
 
+@curry_flip
 def scan_(
-    accumulator: Accumulator[_TState, _T], seed: Union[_TState, Type[NotSet]] = NotSet
-) -> Callable[[Observable[_T]], Observable[_TState]]:
+    source: Observable[_T],
+    accumulator: Accumulator[_TState, _T],
+    seed: _TState | type[NotSet] = NotSet,
+) -> Observable[_TState]:
+    """Applies an accumulator function over an observable sequence and
+    returns each intermediate result.
+
+    Examples:
+        >>> result = source.pipe(scan(lambda acc, x: acc + x, 0))
+        >>> result = scan(lambda acc, x: acc + x, 0)(source)
+        >>> result = source.pipe(scan(lambda acc, x: acc + x))
+
+    Args:
+        source: The observable source to scan.
+        accumulator: An accumulator function to invoke on each element.
+        seed: Optional initial accumulator value.
+
+    Returns:
+        An observable sequence containing the accumulated values.
+    """
     has_seed = seed is not NotSet
 
-    def scan(source: Observable[_T]) -> Observable[_TState]:
-        """Partially applied scan operator.
+    def factory(scheduler: abc.SchedulerBase) -> Observable[_TState]:
+        has_accumulation = False
+        accumulation: _TState = cast(_TState, None)
 
-        Applies an accumulator function over an observable sequence and
-        returns each intermediate result.
+        def projection(x: _T) -> _TState:
+            nonlocal has_accumulation
+            nonlocal accumulation
 
-        Examples:
-            >>> scanned = scan(source)
+            if has_accumulation:
+                accumulation = accumulator(accumulation, x)
+            else:
+                accumulation = (
+                    accumulator(cast(_TState, seed), x)
+                    if has_seed
+                    else cast(_TState, x)
+                )
+                has_accumulation = True
 
-        Args:
-            source: The observable source to scan.
+            return accumulation
 
-        Returns:
-            An observable sequence containing the accumulated values.
-        """
+        return source.pipe(ops.map(projection))
 
-        def factory(scheduler: abc.SchedulerBase) -> Observable[_TState]:
-            has_accumulation = False
-            accumulation: _TState = cast(_TState, None)
-
-            def projection(x: _T) -> _TState:
-                nonlocal has_accumulation
-                nonlocal accumulation
-
-                if has_accumulation:
-                    accumulation = accumulator(accumulation, x)
-                else:
-                    accumulation = (
-                        accumulator(cast(_TState, seed), x)
-                        if has_seed
-                        else cast(_TState, x)
-                    )
-                    has_accumulation = True
-
-                return accumulation
-
-            return source.pipe(ops.map(projection))
-
-        return defer(factory)
-
-    return scan
+    return defer(factory)
 
 
 __all__ = ["scan_"]

reactivex/operators/_sequenceequal.py

@@ -1,4 +1,5 @@
-from typing import Callable, Iterable, List, Optional, TypeVar, Union
+from collections.abc import Callable, Iterable
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable, abc, typing
@@ -9,8 +10,8 @@ _T = TypeVar("_T")
 
 
 def sequence_equal_(
-    second: Union[Observable[_T], Iterable[_T]],
-    comparer: Optional[typing.Comparer[_T]] = None,
+    second: Observable[_T] | Iterable[_T],
+    comparer: typing.Comparer[_T] | None = None,
 ) -> Callable[[Observable[_T]], Observable[bool]]:
     comparer_ = comparer or default_comparer
     second_ = (
@@ -43,12 +44,12 @@ def sequence_equal_(
 
         def subscribe(
             observer: abc.ObserverBase[bool],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
+            scheduler: abc.SchedulerBase | None = None,
+        ) -> abc.DisposableBase:
             donel = [False]
             doner = [False]
-            ql: List[_T] = []
-            qr: List[_T] = []
+            ql: list[_T] = []
+            qr: list[_T] = []
 
             def on_next1(x: _T) -> None:
                 if len(qr) > 0:

reactivex/operators/_single.py

@@ -1,25 +1,32 @@
-from typing import Callable, Optional, TypeVar, cast
+from typing import 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.typing import Predicate
 
+from ._singleordefault import single_or_default_async_
+
 _T = TypeVar("_T")
 
 
+@curry_flip
 def single_(
-    predicate: Optional[Predicate[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    predicate: Predicate[_T] | None = None,
+) -> Observable[_T]:
     """Returns the only element of an observable sequence that satisfies the
     condition in the optional predicate, and reports an exception if there
     is not exactly one element in the observable sequence.
 
-    Example:
-        >>> res = single()
-        >>> res = single(lambda x: x == 42)
+    Examples:
+        >>> res = source.pipe(single())
+        >>> res = single()(source)
+        >>> res = source.pipe(single(lambda x: x == 42))
 
     Args:
-        predicate -- [Optional] A predicate function to evaluate for
+        source: The source observable sequence.
+        predicate: [Optional] A predicate function to evaluate for
             elements in the source sequence.
 
     Returns:
@@ -28,12 +35,12 @@ def single_(
     """
 
     if predicate:
-        return compose(ops.filter(predicate), ops.single())
+        return source.pipe(ops.filter(predicate), ops.single())
     else:
-        return cast(
-            Callable[[Observable[_T]], Observable[_T]],
-            ops.single_or_default_async(False),
-        )
+        # single_or_default_async_(False) returns
+        # Callable[[Observable[_T]], Observable[_T]] but the type checker
+        # cannot infer it. This cast is safe - implementation preserves type.
+        return cast(Observable[_T], single_or_default_async_(False)(source))
 
 
 __all__ = ["single_"]

reactivex/operators/_singleordefault.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc, compose
 from reactivex import operators as ops
@@ -9,13 +10,13 @@ _T = TypeVar("_T")
 
 
 def single_or_default_async_(
-    has_default: bool = False, default_value: Optional[_T] = None
+    has_default: bool = False, default_value: _T | None = None
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     def single_or_default_async(source: Observable[_T]) -> Observable[_T]:
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
+            scheduler: abc.SchedulerBase | None = None,
+        ) -> abc.DisposableBase:
             value = cast(_T, default_value)
             seen_value = False
 
@@ -47,7 +48,7 @@ def single_or_default_async_(
 
 
 def single_or_default_(
-    predicate: Optional[Predicate[_T]] = None, default_value: _T = None
+    predicate: Predicate[_T] | None = None, default_value: _T = None
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     """Returns the only element of an observable sequence that matches
     the predicate, or a default value if no such element exists this

reactivex/operators/_skip.py

@@ -1,50 +1,53 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
-from reactivex.internal import ArgumentOutOfRangeException
+from reactivex.internal import ArgumentOutOfRangeException, curry_flip
 
 _T = TypeVar("_T")
 
 
-def skip_(count: int) -> Callable[[Observable[_T]], Observable[_T]]:
-    if count < 0:
-        raise ArgumentOutOfRangeException()
-
-    def skip(source: Observable[_T]) -> Observable[_T]:
-        """The skip operator.
+@curry_flip
+def skip_(source: Observable[_T], count: int) -> Observable[_T]:
+    """Bypasses a specified number of elements in an observable sequence
+    and then returns the remaining elements.
 
-        Bypasses a specified number of elements in an observable sequence
-        and then returns the remaining elements.
+    Examples:
+        >>> result = source.pipe(skip(5))
+        >>> result = skip(5)(source)
 
-        Args:
-            source: The source observable.
+    Args:
+        source: The source observable.
+        count: The number of elements to skip.
 
-        Returns:
-            An observable sequence that contains the elements that occur
-            after the specified index in the input sequence.
-        """
+    Returns:
+        An observable sequence that contains the elements that occur
+        after the specified index in the input sequence.
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            remaining = count
+    Raises:
+        ArgumentOutOfRangeException: If count is negative.
+    """
+    if count < 0:
+        raise ArgumentOutOfRangeException()
 
-            def on_next(value: _T) -> None:
-                nonlocal remaining
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        remaining = count
 
-                if remaining <= 0:
-                    observer.on_next(value)
-                else:
-                    remaining -= 1
+        def on_next(value: _T) -> None:
+            nonlocal remaining
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if remaining <= 0:
+                observer.on_next(value)
+            else:
+                remaining -= 1
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return skip
+    return Observable(subscribe)
 
 
 __all__ = ["skip_"]

reactivex/operators/_skiplast.py

@@ -1,52 +1,56 @@
-from typing import Callable, List, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def skip_last_(count: int) -> Callable[[Observable[_T]], Observable[_T]]:
-    def skip_last(source: Observable[_T]) -> Observable[_T]:
-        """Bypasses a specified number of elements at the end of an
-        observable sequence.
+@curry_flip
+def skip_last_(source: Observable[_T], count: int) -> Observable[_T]:
+    """Bypasses a specified number of elements at the end of an
+    observable sequence.
 
-        This operator accumulates a queue with a length enough to store
-        the first `count` elements. As more elements are received,
-        elements are taken from the front of the queue and produced on
-        the result sequence. This causes elements to be delayed.
+    This operator accumulates a queue with a length enough to store
+    the first `count` elements. As more elements are received,
+    elements are taken from the front of the queue and produced on
+    the result sequence. This causes elements to be delayed.
 
-        Args:
-            count: Number of elements to bypass at the end of the
-            source sequence.
+    Examples:
+        >>> res = source.pipe(skip_last(5))
+        >>> res = skip_last(5)(source)
 
-        Returns:
-            An observable sequence containing the source sequence
-            elements except for the bypassed ones at the end.
-        """
+    Args:
+        source: Source observable.
+        count: Number of elements to bypass at the end of the
+        source sequence.
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            q: List[_T] = []
+    Returns:
+        An observable sequence containing the source sequence
+        elements except for the bypassed ones at the end.
+    """
 
-            def on_next(value: _T) -> None:
-                front = None
-                with source.lock:
-                    q.append(value)
-                    if len(q) > count:
-                        front = q.pop(0)
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        q: list[_T] = []
 
-                if front is not None:
-                    observer.on_next(front)
+        def on_next(value: _T) -> None:
+            front = None
+            with source.lock:
+                q.append(value)
+                if len(q) > count:
+                    front = q.pop(0)
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if front is not None:
+                observer.on_next(front)
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return skip_last
+    return Observable(subscribe)
 
 
 __all__ = ["skip_last_"]