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

reactivex/operators/_all.py

@@ -1,21 +1,38 @@
-from typing import Callable, 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")
 
 
-def all_(predicate: Predicate[_T]) -> Callable[[Observable[_T]], Observable[bool]]:
-    def filter(v: _T):
+@curry_flip
+def all_(source: Observable[_T], predicate: Predicate[_T]) -> Observable[bool]:
+    """Determines whether all elements of an observable sequence satisfy a condition.
+
+    Examples:
+        >>> result = source.pipe(all(lambda x: x > 0))
+        >>> result = all(lambda x: x > 0)(source)
+
+    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 all elements in the source sequence pass the test.
+    """
+
+    def filter_fn(v: _T):
         return not predicate(v)
 
     def mapping(b: bool) -> bool:
         return not b
 
-    return compose(
-        ops.filter(filter),
+    return source.pipe(
+        ops.filter(filter_fn),
         ops.some(),
         ops.map(mapping),
     )

reactivex/operators/_amb.py

@@ -1,92 +1,105 @@
 from asyncio import Future
-from typing import Callable, List, Optional, TypeVar, Union
+from typing import TypeVar, Union
 
 from reactivex import Observable, abc, from_future
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def amb_(
-    right_source: Union[Observable[_T], "Future[_T]"]
-) -> Callable[[Observable[_T]], Observable[_T]]:
-
+    left_source: Observable[_T],
+    right_source: Union[Observable[_T], "Future[_T]"],
+) -> Observable[_T]:
+    """Propagates the observable sequence that reacts first.
+
+    Examples:
+        >>> result = source.pipe(amb(other_source))
+        >>> result = amb(other_source)(source)
+
+    Args:
+        left_source: The left source observable.
+        right_source: The right source observable or future.
+
+    Returns:
+        An observable sequence that surfaces either of the given sequences,
+        whichever reacted first.
+    """
     if isinstance(right_source, Future):
         obs: Observable[_T] = from_future(right_source)
     else:
         obs = right_source
 
-    def amb(left_source: Observable[_T]) -> Observable[_T]:
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            choice: List[Optional[str]] = [None]
-            left_choice = "L"
-            right_choice = "R"
-            left_subscription = SingleAssignmentDisposable()
-            right_subscription = SingleAssignmentDisposable()
-
-            def choice_left():
-                if not choice[0]:
-                    choice[0] = left_choice
-                    right_subscription.dispose()
-
-            def choice_right():
-                if not choice[0]:
-                    choice[0] = right_choice
-                    left_subscription.dispose()
-
-            def on_next_left(value: _T) -> None:
-                with left_source.lock:
-                    choice_left()
-                if choice[0] == left_choice:
-                    observer.on_next(value)
-
-            def on_error_left(err: Exception) -> None:
-                with left_source.lock:
-                    choice_left()
-                if choice[0] == left_choice:
-                    observer.on_error(err)
-
-            def on_completed_left() -> None:
-                with left_source.lock:
-                    choice_left()
-                if choice[0] == left_choice:
-                    observer.on_completed()
-
-            left_d = left_source.subscribe(
-                on_next_left, on_error_left, on_completed_left, scheduler=scheduler
-            )
-            left_subscription.disposable = left_d
-
-            def send_right(value: _T) -> None:
-                with left_source.lock:
-                    choice_right()
-                if choice[0] == right_choice:
-                    observer.on_next(value)
-
-            def on_error_right(err: Exception) -> None:
-                with left_source.lock:
-                    choice_right()
-                if choice[0] == right_choice:
-                    observer.on_error(err)
-
-            def on_completed_right() -> None:
-                with left_source.lock:
-                    choice_right()
-                if choice[0] == right_choice:
-                    observer.on_completed()
-
-            right_d = obs.subscribe(
-                send_right, on_error_right, on_completed_right, scheduler=scheduler
-            )
-            right_subscription.disposable = right_d
-            return CompositeDisposable(left_subscription, right_subscription)
-
-        return Observable(subscribe)
-
-    return amb
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        choice: list[str | None] = [None]
+        left_choice = "L"
+        right_choice = "R"
+        left_subscription = SingleAssignmentDisposable()
+        right_subscription = SingleAssignmentDisposable()
+
+        def choice_left():
+            if not choice[0]:
+                choice[0] = left_choice
+                right_subscription.dispose()
+
+        def choice_right():
+            if not choice[0]:
+                choice[0] = right_choice
+                left_subscription.dispose()
+
+        def on_next_left(value: _T) -> None:
+            with left_source.lock:
+                choice_left()
+            if choice[0] == left_choice:
+                observer.on_next(value)
+
+        def on_error_left(err: Exception) -> None:
+            with left_source.lock:
+                choice_left()
+            if choice[0] == left_choice:
+                observer.on_error(err)
+
+        def on_completed_left() -> None:
+            with left_source.lock:
+                choice_left()
+            if choice[0] == left_choice:
+                observer.on_completed()
+
+        left_d = left_source.subscribe(
+            on_next_left, on_error_left, on_completed_left, scheduler=scheduler
+        )
+        left_subscription.disposable = left_d
+
+        def send_right(value: _T) -> None:
+            with left_source.lock:
+                choice_right()
+            if choice[0] == right_choice:
+                observer.on_next(value)
+
+        def on_error_right(err: Exception) -> None:
+            with left_source.lock:
+                choice_right()
+            if choice[0] == right_choice:
+                observer.on_error(err)
+
+        def on_completed_right() -> None:
+            with left_source.lock:
+                choice_right()
+            if choice[0] == right_choice:
+                observer.on_completed()
+
+        right_d = obs.subscribe(
+            send_right, on_error_right, on_completed_right, scheduler=scheduler
+        )
+        right_subscription.disposable = right_d
+        return CompositeDisposable(left_subscription, right_subscription)
+
+    return Observable(subscribe)
 
 
 __all__ = ["amb_"]

reactivex/operators/_asobservable.py

@@ -1,31 +1,34 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def as_observable_() -> Callable[[Observable[_T]], Observable[_T]]:
-    def as_observable(source: Observable[_T]) -> Observable[_T]:
-        """Hides the identity of an observable sequence.
+@curry_flip
+def as_observable_(source: Observable[_T]) -> Observable[_T]:
+    """Hides the identity of an observable sequence.
 
-        Args:
-            source: Observable source to hide identity from.
+    Examples:
+        >>> res = source.pipe(as_observable())
+        >>> res = as_observable()(source)
 
-        Returns:
-            An observable sequence that hides the identity of the
-            source sequence.
-        """
+    Args:
+        source: Observable source to hide identity from.
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            return source.subscribe(observer, scheduler=scheduler)
+    Returns:
+        An observable sequence that hides the identity of the
+        source sequence.
+    """
 
-        return Observable(subscribe)
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        return source.subscribe(observer, scheduler=scheduler)
 
-    return as_observable
+    return Observable(subscribe)
 
 
 __all__ = ["as_observable_"]

reactivex/operators/_average.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
-from typing import Any, Callable, Optional, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 from reactivex import Observable, operators, typing
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
@@ -12,51 +13,53 @@ class AverageValue:
     count: int
 
 
+@curry_flip
 def average_(
-    key_mapper: Optional[typing.Mapper[_T, float]] = None,
-) -> Callable[[Observable[_T]], Observable[float]]:
-    def average(source: Observable[Any]) -> Observable[float]:
-        """Partially applied average operator.
-
-        Computes the average of an observable sequence of values that
-        are in the sequence or obtained by invoking a transform
-        function on each element of the input sequence if present.
-
-        Examples:
-            >>> res = average(source)
-
-        Args:
-            source: Source observable to average.
-
-        Returns:
-            An observable sequence containing a single element with the
-            average of the sequence of values.
-        """
-
-        key_mapper_: typing.Mapper[_T, float] = key_mapper or (
-            lambda x: float(cast(Any, x))
-        )
-
-        def accumulator(prev: AverageValue, cur: float) -> AverageValue:
-            return AverageValue(sum=prev.sum + cur, count=prev.count + 1)
-
-        def mapper(s: AverageValue) -> float:
-            if s.count == 0:
-                raise Exception("The input sequence was empty")
-
-            return s.sum / float(s.count)
-
-        seed = AverageValue(sum=0, count=0)
-
-        ret = source.pipe(
-            operators.map(key_mapper_),
-            operators.scan(accumulator, seed),
-            operators.last(),
-            operators.map(mapper),
-        )
-        return ret
-
-    return average
+    source: Observable[_T],
+    key_mapper: typing.Mapper[_T, float] | None = None,
+) -> Observable[float]:
+    """Computes the average of an observable sequence of values.
+
+    Computes the average of an observable sequence of values that
+    are in the sequence or obtained by invoking a transform
+    function on each element of the input sequence if present.
+
+    Examples:
+        >>> result = source.pipe(average())
+        >>> result = average()(source)
+        >>> result = source.pipe(average(lambda x: x.value))
+
+    Args:
+        source: Source observable to average.
+        key_mapper: Optional mapper to extract numeric values.
+
+    Returns:
+        An observable sequence containing a single element with the
+        average of the sequence of values.
+    """
+
+    key_mapper_: typing.Mapper[_T, float] = key_mapper or (
+        lambda x: float(cast(Any, x))
+    )
+
+    def accumulator(prev: AverageValue, cur: float) -> AverageValue:
+        return AverageValue(sum=prev.sum + cur, count=prev.count + 1)
+
+    def mapper(s: AverageValue) -> float:
+        if s.count == 0:
+            raise Exception("The input sequence was empty")
+
+        return s.sum / float(s.count)
+
+    seed = AverageValue(sum=0, count=0)
+
+    ret = source.pipe(
+        operators.map(key_mapper_),
+        operators.scan(accumulator, seed),
+        operators.last(),
+        operators.map(mapper),
+    )
+    return ret
 
 
 __all__ = ["average_"]

reactivex/operators/_buffer.py

@@ -1,80 +1,126 @@
-from typing import Any, Callable, List, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
-from reactivex import Observable, compose
+from reactivex import Observable
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def buffer_(
+    source: Observable[_T],
     boundaries: Observable[Any],
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
-    return compose(
+) -> Observable[list[_T]]:
+    """Buffers elements from the source based on boundary notifications.
+
+    Examples:
+        >>> res = source.pipe(buffer(boundaries))
+        >>> res = buffer(boundaries)(source)
+
+    Args:
+        source: Source observable to buffer.
+        boundaries: Observable that triggers buffer emissions.
+
+    Returns:
+        Observable of lists of buffered elements.
+    """
+    return source.pipe(
         ops.window(boundaries),
         ops.flat_map(ops.to_list()),
     )
 
 
+@curry_flip
 def buffer_when_(
-    closing_mapper: Callable[[], Observable[Any]]
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
-    return compose(
+    source: Observable[_T],
+    closing_mapper: Callable[[], Observable[Any]],
+) -> Observable[list[_T]]:
+    """Buffers elements using a closing mapper function.
+
+    Examples:
+        >>> res = source.pipe(buffer_when(lambda: timer(1.0)))
+        >>> res = buffer_when(lambda: timer(1.0))(source)
+
+    Args:
+        source: Source observable to buffer.
+        closing_mapper: Function that returns an observable signaling buffer close.
+
+    Returns:
+        Observable of lists of buffered elements.
+    """
+    return source.pipe(
         ops.window_when(closing_mapper),
         ops.flat_map(ops.to_list()),
     )
 
 
+@curry_flip
 def buffer_toggle_(
-    openings: Observable[Any], closing_mapper: Callable[[Any], Observable[Any]]
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
-    return compose(
+    source: Observable[_T],
+    openings: Observable[Any],
+    closing_mapper: Callable[[Any], Observable[Any]],
+) -> Observable[list[_T]]:
+    """Buffers elements using opening/closing observables.
+
+    Examples:
+        >>> res = source.pipe(buffer_toggle(opens, lambda x: timer(x)))
+        >>> res = buffer_toggle(opens, lambda x: timer(x))(source)
+
+    Args:
+        source: Source observable to buffer.
+        openings: Observable that triggers buffer opening.
+        closing_mapper: Function to create closing observable.
+
+    Returns:
+        Observable of lists of buffered elements.
+    """
+    return source.pipe(
         ops.window_toggle(openings, closing_mapper),
         ops.flat_map(ops.to_list()),
     )
 
 
+@curry_flip
 def buffer_with_count_(
-    count: int, skip: Optional[int] = None
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
+    source: Observable[_T],
+    count: int,
+    skip: int | None = None,
+) -> Observable[list[_T]]:
     """Projects each element of an observable sequence into zero or more
     buffers which are produced based on element count information.
 
     Examples:
-        >>> res = buffer_with_count(10)(xs)
-        >>> res = buffer_with_count(10, 1)(xs)
+        >>> res = source.pipe(buffer_with_count(10))
+        >>> res = buffer_with_count(10)(source)
+        >>> res = source.pipe(buffer_with_count(10, 1))
 
     Args:
+        source: Source observable to buffer.
         count: Length of each buffer.
         skip: [Optional] Number of elements to skip between
             creation of consecutive buffers. If not provided, defaults to
             the count.
 
     Returns:
-        A function that takes an observable source and returns an
-        observable sequence of buffers.
+        An observable sequence of buffers.
     """
+    skip_ = skip if skip is not None else count
 
-    def buffer_with_count(source: Observable[_T]) -> Observable[List[_T]]:
-        nonlocal skip
-
-        if skip is None:
-            skip = count
-
-        def mapper(value: Observable[_T]) -> Observable[List[_T]]:
-            return value.pipe(
-                ops.to_list(),
-            )
-
-        def predicate(value: List[_T]) -> bool:
-            return len(value) > 0
-
-        return source.pipe(
-            ops.window_with_count(count, skip),
-            ops.flat_map(mapper),
-            ops.filter(predicate),
+    def mapper(value: Observable[_T]) -> Observable[list[_T]]:
+        return value.pipe(
+            ops.to_list(),
         )
 
-    return buffer_with_count
+    def predicate(value: list[_T]) -> bool:
+        return len(value) > 0
+
+    return source.pipe(
+        ops.window_with_count(count, skip_),
+        ops.flat_map(mapper),
+        ops.filter(predicate),
+    )
 
 
 __all__ = ["buffer_", "buffer_with_count_", "buffer_when_", "buffer_toggle_"]

reactivex/operators/_bufferwithtime.py

@@ -1,23 +1,43 @@
-from typing import Callable, List, Optional, TypeVar
+from typing import TypeVar
 
-from reactivex import Observable, abc, compose
+from reactivex import Observable, abc, compose, typing
 from reactivex import operators as ops
-from reactivex import typing
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def buffer_with_time_(
+    source: Observable[_T],
     timespan: typing.RelativeTime,
-    timeshift: Optional[typing.RelativeTime] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
+    timeshift: typing.RelativeTime | None = None,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[list[_T]]:
+    """Buffers elements based on timing information.
+
+    Examples:
+        >>> source.pipe(buffer_with_time(1.0))
+        >>> source.pipe(buffer_with_time(1.0, 0.5))
+        >>> buffer_with_time(1.0)(source)
+
+    Args:
+        source: Source observable to buffer.
+        timespan: Length of each buffer.
+        timeshift: Interval between creation of consecutive buffers.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence of buffers.
+    """
     if not timeshift:
         timeshift = timespan
 
-    return compose(
-        ops.window_with_time(timespan, timeshift, scheduler),
-        ops.flat_map(ops.to_list()),
+    return source.pipe(
+        compose(
+            ops.window_with_time(timespan, timeshift, scheduler),
+            ops.flat_map(ops.to_list()),
+        )
     )
 
 

reactivex/operators/_bufferwithtimeorcount.py

@@ -1,20 +1,39 @@
-from typing import Callable, List, Optional, TypeVar
+from typing import TypeVar
 
-from reactivex import Observable, abc, compose
+from reactivex import Observable, abc, compose, typing
 from reactivex import operators as ops
-from reactivex import typing
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def buffer_with_time_or_count_(
+    source: Observable[_T],
     timespan: typing.RelativeTime,
     count: int,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
-    return compose(
-        ops.window_with_time_or_count(timespan, count, scheduler),
-        ops.flat_map(ops.to_iterable()),
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[list[_T]]:
+    """Buffers elements based on timing and count information.
+
+    Examples:
+        >>> source.pipe(buffer_with_time_or_count(1.0, 10))
+        >>> buffer_with_time_or_count(1.0, 10)(source)
+
+    Args:
+        source: Source observable to buffer.
+        timespan: Maximum time length of each buffer.
+        count: Maximum element count of each buffer.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence of buffers.
+    """
+    return source.pipe(
+        compose(
+            ops.window_with_time_or_count(timespan, count, scheduler),
+            ops.flat_map(ops.to_iterable()),
+        )
     )