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

reactivex/operators/_some.py

@@ -1,59 +1,60 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.typing import Predicate
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def some_(
-    predicate: Optional[Predicate[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[bool]]:
-    def some(source: Observable[_T]) -> Observable[bool]:
-        """Partially applied operator.
-
-        Determines whether some element of an observable sequence satisfies a
-        condition if present, else if some items are in the sequence.
-
-        Example:
-            >>> obs = some(source)
-
-        Args:
-            predicate -- A function to test each element for a condition.
-
-        Returns:
-            An observable sequence containing a single element
-            determining whether some elements in the source sequence
-            pass the test in the specified predicate if given, else if
-            some items are in the sequence.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[bool],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            def on_next(_: _T):
-                observer.on_next(True)
-                observer.on_completed()
-
-            def on_error():
-                observer.on_next(False)
-                observer.on_completed()
-
-            return source.subscribe(
-                on_next, observer.on_error, on_error, scheduler=scheduler
-            )
-
-        if predicate:
-            return source.pipe(
-                ops.filter(predicate),
-                some_(),
-            )
-
-        return Observable(subscribe)
-
-    return some
+    source: Observable[_T],
+    predicate: Predicate[_T] | None = None,
+) -> Observable[bool]:
+    """Determines whether some element of an observable sequence satisfies a
+    condition if present, else if some items are in the sequence.
+
+    Examples:
+        >>> res = source.pipe(some())
+        >>> res = some()(source)
+        >>> res = source.pipe(some(lambda x: x > 3))
+
+    Args:
+        source: The source observable sequence.
+        predicate: A function to test each element for a condition.
+
+    Returns:
+        An observable sequence containing a single element
+        determining whether some elements in the source sequence
+        pass the test in the specified predicate if given, else if
+        some items are in the sequence.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[bool],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        def on_next(_: _T):
+            observer.on_next(True)
+            observer.on_completed()
+
+        def on_error():
+            observer.on_next(False)
+            observer.on_completed()
+
+        return source.subscribe(
+            on_next, observer.on_error, on_error, scheduler=scheduler
+        )
+
+    if predicate:
+        return source.pipe(
+            ops.filter(predicate),
+            ops.some(),
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["some_"]

reactivex/operators/_startswith.py

@@ -1,28 +1,30 @@
-from typing import Callable, TypeVar
+from typing import TypeVar
 
 import reactivex
 from reactivex import Observable
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def start_with_(*args: _T) -> Callable[[Observable[_T]], Observable[_T]]:
-    def start_with(source: Observable[_T]) -> Observable[_T]:
-        """Partially applied start_with operator.
+@curry_flip
+def start_with_(source: Observable[_T], *args: _T) -> Observable[_T]:
+    """Prepends a sequence of values to an observable sequence.
 
-        Prepends a sequence of values to an observable sequence.
+    Example:
+        >>> result = source.pipe(start_with(1, 2, 3))
+        >>> result = start_with(1, 2, 3)(source)
 
-        Example:
-            >>> start_with(source)
+    Args:
+        source: The source observable sequence.
+        args: Values to prepend to the source sequence.
 
-        Returns:
-            The source sequence prepended with the specified values.
-        """
-        start = reactivex.from_iterable(args)
-        sequence = [start, source]
-        return reactivex.concat(*sequence)
-
-    return start_with
+    Returns:
+        The source sequence prepended with the specified values.
+    """
+    start = reactivex.from_iterable(args)
+    sequence = [start, source]
+    return reactivex.concat(*sequence)
 
 
 __all__ = ["start_with_"]

reactivex/operators/_subscribeon.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import (
@@ -6,52 +6,55 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def subscribe_on_(
+    source: Observable[_T],
     scheduler: abc.SchedulerBase,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def subscribe_on(source: Observable[_T]) -> Observable[_T]:
-        """Subscribe on the specified scheduler.
-
-        Wrap the source sequence in order to run its subscription and
-        unsubscription logic on the specified scheduler. This operation
-        is not commonly used; see the remarks section for more
-        information on the distinction between subscribe_on and
-        observe_on.
-
-        This only performs the side-effects of subscription and
-        unsubscription on the specified scheduler. In order to invoke
-        observer callbacks on a scheduler, use observe_on.
-
-        Args:
-            source: The source observable..
-
-        Returns:
-            The source sequence whose subscriptions and
-            un-subscriptions happen on the specified scheduler.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T], _: Optional[abc.SchedulerBase] = None
-        ):
-            m = SingleAssignmentDisposable()
-            d = SerialDisposable()
-            d.disposable = m
-
-            def action(scheduler: abc.SchedulerBase, state: Optional[Any] = None):
-                d.disposable = ScheduledDisposable(
-                    scheduler, source.subscribe(observer)
-                )
-
-            m.disposable = scheduler.schedule(action)
-            return d
-
-        return Observable(subscribe)
-
-    return subscribe_on
+) -> Observable[_T]:
+    """Subscribe on the specified scheduler.
+
+    Wrap the source sequence in order to run its subscription and
+    unsubscription logic on the specified scheduler. This operation
+    is not commonly used; see the remarks section for more
+    information on the distinction between subscribe_on and
+    observe_on.
+
+    This only performs the side-effects of subscription and
+    unsubscription on the specified scheduler. In order to invoke
+    observer callbacks on a scheduler, use observe_on.
+
+    Examples:
+        >>> res = source.pipe(subscribe_on(scheduler))
+        >>> res = subscribe_on(scheduler)(source)
+
+    Args:
+        source: The source observable.
+        scheduler: Scheduler to use for subscription/unsubscription.
+
+    Returns:
+        The source sequence whose subscriptions and
+        un-subscriptions happen on the specified scheduler.
+    """
+
+    def subscribe(observer: abc.ObserverBase[_T], _: abc.SchedulerBase | None = None):
+        m = SingleAssignmentDisposable()
+        d = SerialDisposable()
+        d.disposable = m
+
+        def action(scheduler: abc.SchedulerBase, state: Any | None = None):
+            d.disposable = ScheduledDisposable(
+                scheduler, source.subscribe(observer, scheduler=scheduler)
+            )
+
+        m.disposable = scheduler.schedule(action)
+        return d
+
+    return Observable(subscribe)
 
 
 __all__ = ["subscribe_on_"]

reactivex/operators/_sum.py

@@ -1,20 +1,37 @@
-from typing import Any, Callable, Optional
+from typing import Any
 
-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 Mapper
 
 
+@curry_flip
 def sum_(
-    key_mapper: Optional[Mapper[Any, float]] = None
-) -> Callable[[Observable[Any]], Observable[float]]:
+    source: Observable[Any],
+    key_mapper: Mapper[Any, float] | None = None,
+) -> Observable[float]:
+    """Computes the sum of a sequence of values.
+
+    Examples:
+        >>> result = source.pipe(sum())
+        >>> result = sum()(source)
+        >>> result = source.pipe(sum(lambda x: x.value))
+
+    Args:
+        source: The source observable.
+        key_mapper: Optional mapper to extract numeric values.
+
+    Returns:
+        An observable sequence containing a single element with the sum.
+    """
     if key_mapper:
-        return compose(ops.map(key_mapper), ops.sum())
+        return source.pipe(ops.map(key_mapper), ops.sum())
 
     def accumulator(prev: float, cur: float) -> float:
         return prev + cur
 
-    return ops.reduce(seed=0, accumulator=accumulator)
+    return source.pipe(ops.reduce(seed=0, accumulator=accumulator))
 
 
 __all__ = ["sum_"]

reactivex/operators/_switchlatest.py

@@ -1,5 +1,5 @@
 from asyncio import Future
-from typing import Any, Callable, Optional, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from reactivex import Observable, abc, from_future
 from reactivex.disposable import (
@@ -7,84 +7,86 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def switch_latest_() -> (
-    Callable[[Observable[Union[Observable[_T], "Future[_T]"]]], Observable[_T]]
-):
-    def switch_latest(
-        source: Observable[Union[Observable[_T], "Future[_T]"]]
-    ) -> Observable[_T]:
-        """Partially applied switch_latest operator.
-
-        Transforms an observable sequence of observable sequences into
-        an observable sequence producing values only from the most
-        recent observable sequence.
-
-        Returns:
-            An observable sequence that at any point in time produces
-            the elements of the most recent inner observable sequence
-            that has been received.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            inner_subscription = SerialDisposable()
-            has_latest = [False]
-            is_stopped = [False]
-            latest = [0]
-
-            def on_next(inner_source: Union[Observable[_T], "Future[_T]"]) -> None:
-                nonlocal source
-
-                d = SingleAssignmentDisposable()
-                with source.lock:
-                    latest[0] += 1
-                    _id = latest[0]
-                has_latest[0] = True
-                inner_subscription.disposable = d
-
-                # Check if Future or Observable
-                if isinstance(inner_source, Future):
-                    obs = from_future(inner_source)
-                else:
-                    obs = inner_source
-
-                def on_next(x: Any) -> None:
-                    if latest[0] == _id:
-                        observer.on_next(x)
-
-                def on_error(e: Exception) -> None:
-                    if latest[0] == _id:
-                        observer.on_error(e)
-
-                def on_completed() -> None:
-                    if latest[0] == _id:
-                        has_latest[0] = False
-                        if is_stopped[0]:
-                            observer.on_completed()
-
-                d.disposable = obs.subscribe(
-                    on_next, on_error, on_completed, scheduler=scheduler
-                )
+@curry_flip
+def switch_latest_(
+    source: Observable[Union[Observable[_T], "Future[_T]"]],
+) -> Observable[_T]:
+    """Transforms an observable sequence of observable sequences into
+    an observable sequence producing values only from the most
+    recent observable sequence.
+
+    Examples:
+        >>> res = source.pipe(switch_latest())
+        >>> res = switch_latest()(source)
+
+    Args:
+        source: Source observable of observables.
+
+    Returns:
+        An observable sequence that at any point in time produces
+        the elements of the most recent inner observable sequence
+        that has been received.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        inner_subscription = SerialDisposable()
+        has_latest = [False]
+        is_stopped = [False]
+        latest = [0]
+
+        def on_next(inner_source: Union[Observable[_T], "Future[_T]"]) -> None:
+            nonlocal source
+
+            d = SingleAssignmentDisposable()
+            with source.lock:
+                latest[0] += 1
+                _id = latest[0]
+            has_latest[0] = True
+            inner_subscription.disposable = d
+
+            # Check if Future or Observable
+            if isinstance(inner_source, Future):
+                obs = from_future(inner_source)
+            else:
+                obs = inner_source
+
+            def on_next(x: Any) -> None:
+                if latest[0] == _id:
+                    observer.on_next(x)
+
+            def on_error(e: Exception) -> None:
+                if latest[0] == _id:
+                    observer.on_error(e)
 
             def on_completed() -> None:
-                is_stopped[0] = True
-                if not has_latest[0]:
-                    observer.on_completed()
+                if latest[0] == _id:
+                    has_latest[0] = False
+                    if is_stopped[0]:
+                        observer.on_completed()
 
-            subscription = source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
+            d.disposable = obs.subscribe(
+                on_next, on_error, on_completed, scheduler=scheduler
             )
-            return CompositeDisposable(subscription, inner_subscription)
 
-        return Observable(subscribe)
+        def on_completed() -> None:
+            is_stopped[0] = True
+            if not has_latest[0]:
+                observer.on_completed()
 
-    return switch_latest
+        subscription = source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
+        return CompositeDisposable(subscription, inner_subscription)
+
+    return Observable(subscribe)
 
 
 __all__ = ["switch_latest_"]

reactivex/operators/_take.py

@@ -1,53 +1,57 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc, empty
-from reactivex.internal import ArgumentOutOfRangeException
+from reactivex.internal import ArgumentOutOfRangeException, curry_flip
 
 _T = TypeVar("_T")
 
 
-def take_(count: int) -> Callable[[Observable[_T]], Observable[_T]]:
-    if count < 0:
-        raise ArgumentOutOfRangeException()
-
-    def take(source: Observable[_T]) -> Observable[_T]:
-        """Returns a specified number of contiguous elements from the start of
-        an observable sequence.
+@curry_flip
+def take_(source: Observable[_T], count: int) -> Observable[_T]:
+    """Returns a specified number of contiguous elements from the start of
+    an observable sequence.
 
-        >>> take(source)
+    Example:
+        >>> result = source.pipe(take(5))
+        >>> result = take(5)(source)
 
-        Keyword arguments:
-        count -- The number of elements to return.
+    Args:
+        source: The source observable sequence.
+        count: The number of elements to return.
 
-        Returns an observable sequence that contains the specified number of
+    Returns:
+        An observable sequence that contains the specified number of
         elements from the start of the input sequence.
-        """
 
-        if not count:
-            return empty()
+    Raises:
+        ArgumentOutOfRangeException: If count is negative.
+    """
+    if count < 0:
+        raise ArgumentOutOfRangeException()
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            remaining = count
+    if not count:
+        return empty()
 
-            def on_next(value: _T) -> None:
-                nonlocal remaining
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        remaining = count
 
-                if remaining > 0:
-                    remaining -= 1
-                    observer.on_next(value)
-                    if not remaining:
-                        observer.on_completed()
+        def on_next(value: _T) -> None:
+            nonlocal remaining
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if remaining > 0:
+                remaining -= 1
+                observer.on_next(value)
+                if not remaining:
+                    observer.on_completed()
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return take
+    return Observable(subscribe)
 
 
 __all__ = ["take_"]

reactivex/operators/_takelast.py

@@ -1,55 +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 take_last_(count: int) -> Callable[[Observable[_T]], Observable[_T]]:
-    def take_last(source: Observable[_T]) -> Observable[_T]:
-        """Returns a specified number of contiguous elements from the end of an
-        observable sequence.
+@curry_flip
+def take_last_(source: Observable[_T], count: int) -> Observable[_T]:
+    """Returns a specified number of contiguous elements from the end of an
+    observable sequence.
 
-        Example:
-            >>> res = take_last(source)
+    Examples:
+        >>> res = source.pipe(take_last(5))
+        >>> res = take_last(5)(source)
 
-        This operator accumulates a buffer with a length enough to store
-        elements count elements. Upon completion of the source sequence, this
-        buffer is drained on the result sequence. This causes the elements to be
-        delayed.
+    This operator accumulates a buffer with a length enough to store
+    elements count elements. Upon completion of the source sequence, this
+    buffer is drained on the result sequence. This causes the elements to be
+    delayed.
 
-        Args:
-            source: Number of elements to take from the end of the source
+    Args:
+        source: The source observable sequence.
+        count: Number of elements to take from the end of the source
             sequence.
 
-        Returns:
-            An observable sequence containing the specified number of elements
-            from the end of the source sequence.
-        """
+    Returns:
+        An observable sequence containing the specified number of elements
+        from the end of the source sequence.
+    """
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            q: List[_T] = []
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        q: list[_T] = []
 
-            def on_next(x: _T) -> None:
-                q.append(x)
-                if len(q) > count:
-                    q.pop(0)
+        def on_next(x: _T) -> None:
+            q.append(x)
+            if len(q) > count:
+                q.pop(0)
 
-            def on_completed():
-                while q:
-                    observer.on_next(q.pop(0))
-                observer.on_completed()
+        def on_completed():
+            while q:
+                observer.on_next(q.pop(0))
+            observer.on_completed()
 
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
 
-        return Observable(subscribe)
-
-    return take_last
+    return Observable(subscribe)
 
 
 __all__ = ["take_last_"]