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

reactivex/operators/_catch.py

@@ -1,9 +1,11 @@
 from asyncio import Future
-from typing import Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar, Union
 
 import reactivex
 from reactivex import Observable, abc
 from reactivex.disposable import SerialDisposable, SingleAssignmentDisposable
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
@@ -13,7 +15,7 @@ def catch_handler(
     handler: Callable[[Exception, Observable[_T]], Union[Observable[_T], "Future[_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:
         d1 = SingleAssignmentDisposable()
         subscription = SerialDisposable()
@@ -42,37 +44,36 @@ def catch_handler(
     return Observable(subscribe)
 
 
+@curry_flip
 def catch_(
-    handler: Union[
-        Observable[_T], Callable[[Exception, Observable[_T]], Observable[_T]]
-    ]
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def catch(source: Observable[_T]) -> Observable[_T]:
-        """Continues an observable sequence that is terminated by an
-        exception with the next observable sequence.
-
-        Examples:
-            >>> op = catch(ys)
-            >>> op = catch(lambda ex, src: ys(ex))
-
-        Args:
-            handler: Second observable sequence used to produce
-                results when an error occurred in the first sequence, or an
-                exception handler function that returns an observable sequence
-                given the error and source observable that occurred in the
-                first sequence.
-
-        Returns:
-            An observable sequence containing the first sequence's
-            elements, followed by the elements of the handler sequence
-            in case an exception occurred.
-        """
-        if callable(handler):
-            return catch_handler(source, handler)
-        else:
-            return reactivex.catch(source, handler)
-
-    return catch
+    source: Observable[_T],
+    handler: Observable[_T] | Callable[[Exception, Observable[_T]], Observable[_T]],
+) -> Observable[_T]:
+    """Continues an observable sequence that is terminated by an
+    exception with the next observable sequence.
+
+    Examples:
+        >>> res = source.pipe(catch(ys))
+        >>> res = catch(ys)(source)
+        >>> res = source.pipe(catch(lambda ex, src: ys(ex)))
+
+    Args:
+        source: The source observable sequence.
+        handler: Second observable sequence used to produce
+            results when an error occurred in the first sequence, or an
+            exception handler function that returns an observable sequence
+            given the error and source observable that occurred in the
+            first sequence.
+
+    Returns:
+        An observable sequence containing the first sequence's
+        elements, followed by the elements of the handler sequence
+        in case an exception occurred.
+    """
+    if callable(handler):
+        return catch_handler(source, handler)
+    else:
+        return reactivex.catch(source, handler)
 
 
 __all__ = ["catch_"]

reactivex/operators/_combinelatest.py

@@ -1,30 +1,38 @@
-from typing import Any, Callable
+from typing import Any, cast
 
 import reactivex
 from reactivex import Observable
+from reactivex.internal import curry_flip
 
 
+@curry_flip
 def combine_latest_(
+    source: Observable[Any],
     *others: Observable[Any],
-) -> Callable[[Observable[Any]], Observable[Any]]:
-    def combine_latest(source: Observable[Any]) -> Observable[Any]:
-        """Merges the specified observable sequences into one
-        observable sequence by creating a tuple whenever any
-        of the observable sequences produces an element.
-
-        Examples:
-            >>> obs = combine_latest(source)
-
-        Returns:
-            An observable sequence containing the result of combining
-            elements of the sources into a tuple.
-        """
-
-        sources = (source,) + others
-
-        return reactivex.combine_latest(*sources)
-
-    return combine_latest
+) -> 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.
+
+    Examples:
+        >>> result = source.pipe(combine_latest(other1, other2))
+        >>> result = combine_latest(other1, other2)(source)
+
+    Args:
+        source: The source observable sequence.
+        others: Additional observable sequences to combine.
+
+    Returns:
+        An observable sequence containing the result of combining
+        elements of the sources into a tuple.
+    """
+
+    sources: tuple[Observable[Any], ...] = (source, *others)
+
+    ret: Observable[tuple[Any, ...]] = cast(
+        Observable[tuple[Any, ...]], reactivex.combine_latest(*sources)
+    )
+    return ret
 
 
 __all__ = ["combine_latest_"]

reactivex/operators/_concat.py

@@ -1,26 +1,29 @@
-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 concat_(*sources: Observable[_T]) -> Callable[[Observable[_T]], Observable[_T]]:
-    def concat(source: Observable[_T]) -> Observable[_T]:
-        """Concatenates all the observable sequences.
+@curry_flip
+def concat_(source: Observable[_T], *sources: Observable[_T]) -> Observable[_T]:
+    """Concatenates all the observable sequences.
 
-        Examples:
-            >>> op = concat(xs, ys, zs)
+    Examples:
+        >>> result = source.pipe(concat(xs, ys, zs))
+        >>> result = concat(xs, ys, zs)(source)
 
-        Returns:
-            An operator function that takes one or more observable sources and
-            returns an observable sequence that contains the elements of
-            each given sequence, in sequential order.
-        """
-        return reactivex.concat(source, *sources)
+    Args:
+        source: The source observable sequence.
+        sources: Additional observable sequences to concatenate.
 
-    return concat
+    Returns:
+        An observable sequence that contains the elements of
+        each given sequence, in sequential order.
+    """
+    return reactivex.concat(source, *sources)
 
 
 __all__ = ["concat_"]

reactivex/operators/_contains.py

@@ -1,22 +1,41 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
-from reactivex import Observable, compose
+from reactivex import Observable, typing
 from reactivex import operators as ops
-from reactivex import typing
+from reactivex.internal import curry_flip
 from reactivex.internal.basic import default_comparer
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def contains_(
-    value: _T, comparer: Optional[typing.Comparer[_T]] = None
-) -> Callable[[Observable[_T]], Observable[bool]]:
+    source: Observable[_T],
+    value: _T,
+    comparer: typing.Comparer[_T] | None = None,
+) -> Observable[bool]:
+    """Determines whether an observable sequence contains a specified element.
+
+    Examples:
+        >>> result = source.pipe(contains(42))
+        >>> result = contains(42)(source)
+        >>> result = source.pipe(contains(42, custom_comparer))
+
+    Args:
+        source: The source observable sequence.
+        value: The value to locate in the source sequence.
+        comparer: Optional equality comparer to compare elements.
+
+    Returns:
+        An observable sequence containing a single element determining
+        whether the source sequence contains the specified value.
+    """
     comparer_ = comparer or default_comparer
 
     def predicate(v: _T) -> bool:
         return comparer_(v, value)
 
-    return compose(
+    return source.pipe(
         ops.filter(predicate),
         ops.some(),
     )

reactivex/operators/_count.py

@@ -1,18 +1,35 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
-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
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def count_(
-    predicate: Optional[Predicate[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[int]]:
-
+    source: Observable[_T],
+    predicate: Predicate[_T] | None = None,
+) -> Observable[int]:
+    """Returns an observable sequence containing a single element with the
+    number of elements in the source sequence.
+
+    Examples:
+        >>> result = source.pipe(count())
+        >>> result = count()(source)
+        >>> result = source.pipe(count(lambda x: x > 5))
+
+    Args:
+        source: The source observable.
+        predicate: Optional predicate to filter elements before counting.
+
+    Returns:
+        An observable sequence containing a single element with the count.
+    """
     if predicate:
-        return compose(
+        return source.pipe(
             ops.filter(predicate),
             ops.count(),
         )
@@ -20,8 +37,7 @@ def count_(
     def reducer(n: int, _: _T) -> int:
         return n + 1
 
-    counter = ops.reduce(reducer, seed=0)
-    return counter
+    return source.pipe(ops.reduce(reducer, seed=0))
 
 
 __all__ = ["count_"]

reactivex/operators/_debounce.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, List, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import (
@@ -6,169 +7,171 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def debounce_(
-    duetime: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase]
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def debounce(source: Observable[_T]) -> Observable[_T]:
-        """Ignores values from an observable sequence which are followed by
-        another value before duetime.
-
-        Example:
-            >>> res = debounce(source)
-
-        Args:
-            source: Source observable to debounce.
-
-        Returns:
-            An operator function that takes the source observable and
-            returns the debounced observable sequence.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-            cancelable = SerialDisposable()
-            has_value = [False]
-            value: List[_T] = [cast(_T, None)]
-            _id: List[int] = [0]
-
-            def on_next(x: _T) -> None:
-                has_value[0] = True
-                value[0] = x
-                _id[0] += 1
-                current_id = _id[0]
-                d = SingleAssignmentDisposable()
-                cancelable.disposable = d
-
-                def action(scheduler: abc.SchedulerBase, state: Any = None) -> None:
-                    if has_value[0] and _id[0] == current_id:
-                        observer.on_next(value[0])
-                    has_value[0] = False
-
-                d.disposable = _scheduler.schedule_relative(duetime, action)
-
-            def on_error(exception: Exception) -> None:
-                cancelable.dispose()
-                observer.on_error(exception)
+    source: Observable[_T],
+    duetime: typing.RelativeTime,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Ignores values from an observable sequence which are followed by
+    another value before duetime.
+
+    Examples:
+        >>> res = source.pipe(debounce(0.5))
+        >>> res = debounce(0.5)(source)
+
+    Args:
+        source: Source observable to debounce.
+        duetime: Duration to wait before emitting.
+        scheduler: Scheduler to use.
+
+    Returns:
+        The debounced observable sequence.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+        cancelable = SerialDisposable()
+        has_value = [False]
+        value: list[_T] = [cast(_T, None)]
+        _id: list[int] = [0]
+
+        def on_next(x: _T) -> None:
+            has_value[0] = True
+            value[0] = x
+            _id[0] += 1
+            current_id = _id[0]
+            d = SingleAssignmentDisposable()
+            cancelable.disposable = d
+
+            def action(scheduler: abc.SchedulerBase, state: Any = None) -> None:
+                if has_value[0] and _id[0] == current_id:
+                    observer.on_next(value[0])
                 has_value[0] = False
-                _id[0] += 1
 
-            def on_completed() -> None:
-                cancelable.dispose()
-                if has_value[0]:
-                    observer.on_next(value[0])
+            d.disposable = _scheduler.schedule_relative(duetime, action)
 
-                observer.on_completed()
-                has_value[0] = False
-                _id[0] += 1
+        def on_error(exception: Exception) -> None:
+            cancelable.dispose()
+            observer.on_error(exception)
+            has_value[0] = False
+            _id[0] += 1
 
-            subscription = source.subscribe(
-                on_next, on_error, on_completed, scheduler=scheduler_
-            )
-            return CompositeDisposable(subscription, cancelable)
+        def on_completed() -> None:
+            cancelable.dispose()
+            if has_value[0]:
+                observer.on_next(value[0])
+
+            observer.on_completed()
+            has_value[0] = False
+            _id[0] += 1
 
-        return Observable(subscribe)
+        subscription = source.subscribe(
+            on_next, on_error, on_completed, scheduler=scheduler_
+        )
+        return CompositeDisposable(subscription, cancelable)
 
-    return debounce
+    return Observable(subscribe)
 
 
+@curry_flip
 def throttle_with_mapper_(
-    throttle_duration_mapper: Callable[[Any], Observable[Any]]
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def throttle_with_mapper(source: Observable[_T]) -> Observable[_T]:
-        """Partially applied throttle_with_mapper operator.
-
-        Ignores values from an observable sequence which are followed by
-        another value within a computed throttle duration.
-
-        Example:
-            >>> obs = throttle_with_mapper(source)
-
-        Args:
-            source: The observable source to throttle.
-
-        Returns:
-            The throttled observable sequence.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            cancelable = SerialDisposable()
-            has_value: bool = False
-            value: _T = cast(_T, None)
-            _id = [0]
-
-            def on_next(x: _T) -> None:
-                nonlocal value, has_value
-
-                throttle = None
-                try:
-                    throttle = throttle_duration_mapper(x)
-                except Exception as e:  # pylint: disable=broad-except
-                    observer.on_error(e)
-                    return
-
-                has_value = True
-                value = x
-                _id[0] += 1
-                current_id = _id[0]
-                d = SingleAssignmentDisposable()
-                cancelable.disposable = d
-
-                def on_next(x: Any) -> None:
-                    nonlocal has_value
-                    if has_value and _id[0] == current_id:
-                        observer.on_next(value)
-
-                    has_value = False
-                    d.dispose()
-
-                def on_completed() -> None:
-                    nonlocal has_value
-                    if has_value and _id[0] == current_id:
-                        observer.on_next(value)
-
-                    has_value = False
-                    d.dispose()
-
-                d.disposable = throttle.subscribe(
-                    on_next, observer.on_error, on_completed, scheduler=scheduler
-                )
-
-            def on_error(e: Exception) -> None:
-                nonlocal has_value
-                cancelable.dispose()
+    source: Observable[_T],
+    throttle_duration_mapper: Callable[[Any], Observable[Any]],
+) -> Observable[_T]:
+    """Ignores values from an observable sequence which are followed by
+    another value within a computed throttle duration.
+
+    Examples:
+        >>> res = source.pipe(throttle_with_mapper(lambda x: timer(x)))
+        >>> res = throttle_with_mapper(lambda x: timer(x))(source)
+
+    Args:
+        source: The observable source to throttle.
+        throttle_duration_mapper: Function to compute throttle duration.
+
+    Returns:
+        The throttled observable sequence.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        cancelable = SerialDisposable()
+        has_value: bool = False
+        value: _T = cast(_T, None)
+        _id = [0]
+
+        def on_next(x: _T) -> None:
+            nonlocal value, has_value
+
+            throttle = None
+            try:
+                throttle = throttle_duration_mapper(x)
+            except Exception as e:  # pylint: disable=broad-except
                 observer.on_error(e)
+                return
+
+            has_value = True
+            value = x
+            _id[0] += 1
+            current_id = _id[0]
+            d = SingleAssignmentDisposable()
+            cancelable.disposable = d
+
+            def on_next(x: Any) -> None:
+                nonlocal has_value
+                if has_value and _id[0] == current_id:
+                    observer.on_next(value)
+
                 has_value = False
-                _id[0] += 1
+                d.dispose()
 
             def on_completed() -> None:
                 nonlocal has_value
-                cancelable.dispose()
-                if has_value:
+                if has_value and _id[0] == current_id:
                     observer.on_next(value)
 
-                observer.on_completed()
                 has_value = False
-                _id[0] += 1
+                d.dispose()
 
-            subscription = source.subscribe(
-                on_next, on_error, on_completed, scheduler=scheduler
+            d.disposable = throttle.subscribe(
+                on_next, observer.on_error, on_completed, scheduler=scheduler
             )
-            return CompositeDisposable(subscription, cancelable)
-
-        return Observable(subscribe)
 
-    return throttle_with_mapper
+        def on_error(e: Exception) -> None:
+            nonlocal has_value
+            cancelable.dispose()
+            observer.on_error(e)
+            has_value = False
+            _id[0] += 1
+
+        def on_completed() -> None:
+            nonlocal has_value
+            cancelable.dispose()
+            if has_value:
+                observer.on_next(value)
+
+            observer.on_completed()
+            has_value = False
+            _id[0] += 1
+
+        subscription = source.subscribe(
+            on_next, on_error, on_completed, scheduler=scheduler
+        )
+        return CompositeDisposable(subscription, cancelable)
+
+    return Observable(subscribe)
 
 
 __all__ = ["debounce_", "throttle_with_mapper_"]