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

reactivex/operators/_map.py

@@ -1,8 +1,8 @@
-from typing import Callable, Optional, TypeVar, cast
+from typing import TypeVar, cast
 
-from reactivex import Observable, abc, compose
+from reactivex import Observable, abc, typing
 from reactivex import operators as ops
-from reactivex import typing
+from reactivex.internal import curry_flip
 from reactivex.internal.basic import identity
 from reactivex.internal.utils import infinite
 from reactivex.typing import Mapper, MapperIndexed
@@ -11,58 +11,73 @@ _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
 
 
+@curry_flip
 def map_(
-    mapper: Optional[Mapper[_T1, _T2]] = None,
-) -> Callable[[Observable[_T1]], Observable[_T2]]:
+    source: Observable[_T1],
+    mapper: Mapper[_T1, _T2] | None = None,
+) -> Observable[_T2]:
+    """Project each element of an observable sequence into a new form.
+
+    Example:
+        >>> result = source.pipe(map(lambda x: x * 2))
+        >>> result = map(lambda x: x * 2)(source)
+
+    Args:
+        source: The observable source to transform.
+        mapper: A transform function to apply to each element.
+
+    Returns:
+        Returns an observable sequence whose elements are the
+        result of invoking the transform function on each element
+        of the source.
+    """
     _mapper = mapper or cast(Mapper[_T1, _T2], identity)
 
-    def map(source: Observable[_T1]) -> Observable[_T2]:
-        """Partially applied map operator.
+    def subscribe(
+        obv: abc.ObserverBase[_T2], scheduler: abc.SchedulerBase | None = None
+    ) -> abc.DisposableBase:
+        def on_next(value: _T1) -> None:
+            try:
+                result = _mapper(value)
+            except Exception as err:  # pylint: disable=broad-except
+                obv.on_error(err)
+            else:
+                obv.on_next(result)
 
-        Project each element of an observable sequence into a new form
-        by incorporating the element's index.
+        return source.subscribe(
+            on_next, obv.on_error, obv.on_completed, scheduler=scheduler
+        )
 
-        Example:
-            >>> map(source)
+    return Observable(subscribe)
 
-        Args:
-            source: The observable source to transform.
 
-        Returns:
-            Returns an observable sequence whose elements are the
-            result of invoking the transform function on each element
-            of the source.
-        """
-
-        def subscribe(
-            obv: abc.ObserverBase[_T2], scheduler: Optional[abc.SchedulerBase] = None
-        ) -> abc.DisposableBase:
-            def on_next(value: _T1) -> None:
-                try:
-                    result = _mapper(value)
-                except Exception as err:  # pylint: disable=broad-except
-                    obv.on_error(err)
-                else:
-                    obv.on_next(result)
-
-            return source.subscribe(
-                on_next, obv.on_error, obv.on_completed, scheduler=scheduler
-            )
+@curry_flip
+def map_indexed_(
+    source: Observable[_T1],
+    mapper_indexed: MapperIndexed[_T1, _T2] | None = None,
+) -> Observable[_T2]:
+    """Project each element of an observable sequence into a new form by
+    incorporating the element's index.
 
-        return Observable(subscribe)
+    Example:
+        >>> result = source.pipe(map_indexed(lambda x, i: (x, i)))
+        >>> result = map_indexed(lambda x, i: (x, i))(source)
 
-    return map
+    Args:
+        source: The observable source to transform.
+        mapper_indexed: A transform function to apply to each element with its index.
 
+    Returns:
+        An observable sequence whose elements are the result of invoking
+        the transform function on each element with its index.
+    """
 
-def map_indexed_(
-    mapper_indexed: Optional[MapperIndexed[_T1, _T2]] = None,
-) -> Callable[[Observable[_T1]], Observable[_T2]]:
     def _identity(value: _T1, _: int) -> _T2:
         return cast(_T2, value)
 
     _mapper_indexed = mapper_indexed or cast(typing.MapperIndexed[_T1, _T2], _identity)
 
-    return compose(
+    return source.pipe(
         ops.zip_with_iterable(infinite()),
         ops.starmap_indexed(_mapper_indexed),  # type: ignore
     )

reactivex/operators/_materialize.py

@@ -1,48 +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.notification import Notification, OnCompleted, OnError, OnNext
 
 _T = TypeVar("_T")
 
 
-def materialize() -> Callable[[Observable[_T]], Observable[Notification[_T]]]:
-    def materialize(source: Observable[_T]) -> Observable[Notification[_T]]:
-        """Partially applied materialize operator.
+@curry_flip
+def materialize_(source: Observable[_T]) -> Observable[Notification[_T]]:
+    """Materializes the implicit notifications of an observable
+    sequence as explicit notification values.
 
-        Materializes the implicit notifications of an observable
-        sequence as explicit notification values.
+    Examples:
+        >>> res = source.pipe(materialize())
+        >>> res = materialize()(source)
 
-        Args:
-            source: Source observable to materialize.
+    Args:
+        source: Source observable to materialize.
 
-        Returns:
-            An observable sequence containing the materialized
-            notification values from the source sequence.
-        """
+    Returns:
+        An observable sequence containing the materialized
+        notification values from the source sequence.
+    """
 
-        def subscribe(
-            observer: abc.ObserverBase[Notification[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            def on_next(value: _T) -> None:
-                observer.on_next(OnNext(value))
+    def subscribe(
+        observer: abc.ObserverBase[Notification[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        def on_next(value: _T) -> None:
+            observer.on_next(OnNext(value))
 
-            def on_error(error: Exception) -> None:
-                observer.on_next(OnError(error))
-                observer.on_completed()
+        def on_error(error: Exception) -> None:
+            observer.on_next(OnError(error))
+            observer.on_completed()
 
-            def on_completed() -> None:
-                observer.on_next(OnCompleted())
-                observer.on_completed()
+        def on_completed() -> None:
+            observer.on_next(OnCompleted())
+            observer.on_completed()
 
-            return source.subscribe(
-                on_next, on_error, on_completed, scheduler=scheduler
-            )
+        return source.subscribe(on_next, on_error, on_completed, scheduler=scheduler)
 
-        return Observable(subscribe)
+    return Observable(subscribe)
 
-    return materialize
 
-
-__all__ = ["materialize"]
+__all__ = ["materialize_"]

reactivex/operators/_max.py

@@ -1,7 +1,9 @@
-from typing import Callable, Optional, TypeVar, cast
+from collections.abc import Callable
+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.internal.basic import identity
 from reactivex.typing import Comparer
 
@@ -10,25 +12,30 @@ from ._min import first_only
 _T = TypeVar("_T")
 
 
+@curry_flip
 def max_(
-    comparer: Optional[Comparer[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    """Returns the maximum value in an observable sequence according to
+    source: Observable[_T],
+    comparer: Comparer[_T] | None = None,
+) -> Observable[_T]:
+    """Returns the maximum value in an observable sequence.
+
+    Returns the maximum value in an observable sequence according to
     the specified comparer.
 
     Examples:
-        >>> op = max()
-        >>> op = max(lambda x, y:  x.value - y.value)
+        >>> result = source.pipe(max())
+        >>> result = max()(source)
+        >>> result = source.pipe(max(lambda x, y: x.value - y.value))
 
     Args:
-        comparer: [Optional] Comparer used to compare elements.
+        source: The source observable.
+        comparer: Optional comparer used to compare elements.
 
     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
         maximum element in the source sequence.
     """
-    return compose(
+    return source.pipe(
         ops.max_by(cast(Callable[[_T], _T], identity), comparer),
         ops.map(first_only),
     )

reactivex/operators/_maxby.py

@@ -1,4 +1,5 @@
-from typing import Callable, List, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import Observable, typing
 from reactivex.internal.basic import default_sub_comparer
@@ -11,12 +12,11 @@ _TKey = TypeVar("_TKey")
 
 def max_by_(
     key_mapper: typing.Mapper[_T, _TKey],
-    comparer: Optional[typing.SubComparer[_TKey]] = None,
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
-
+    comparer: typing.SubComparer[_TKey] | None = None,
+) -> Callable[[Observable[_T]], Observable[list[_T]]]:
     cmp = comparer or default_sub_comparer
 
-    def max_by(source: Observable[_T]) -> Observable[List[_T]]:
+    def max_by(source: Observable[_T]) -> Observable[list[_T]]:
         """Partially applied max_by operator.
 
         Returns the elements in an observable sequence with the maximum

reactivex/operators/_merge.py

@@ -1,153 +1,156 @@
 from asyncio import Future
-from typing import Callable, List, Optional, TypeVar, Union
+from typing import TypeVar, Union
 
 import reactivex
 from reactivex import Observable, abc, from_future, typing
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
-from reactivex.internal import synchronized
+from reactivex.internal import curry_flip, synchronized
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def merge_(
-    *sources: Observable[_T], max_concurrent: Optional[int] = None
-) -> Callable[[Observable[Observable[_T]]], Observable[_T]]:
-    def merge(source: Observable[Observable[_T]]) -> Observable[_T]:
-        """Merges an observable sequence of observable sequences into
-        an observable sequence, limiting the number of concurrent
-        subscriptions to inner sequences. Or merges two observable
-        sequences into a single observable sequence.
-
-        Examples:
-            >>> res = merge(sources)
-
-        Args:
-            source: Source observable.
-
-        Returns:
-            The observable sequence that merges the elements of the
-            inner sequences.
-        """
-
-        if max_concurrent is None:
-            sources_ = tuple([source]) + sources
-            return reactivex.merge(*sources_)
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            active_count = [0]
-            group = CompositeDisposable()
-            is_stopped = [False]
-            queue: List[Observable[_T]] = []
-
-            def subscribe(xs: Observable[_T]):
-                subscription = SingleAssignmentDisposable()
-                group.add(subscription)
-
-                @synchronized(source.lock)
-                def on_completed():
-                    group.remove(subscription)
-                    if queue:
-                        s = queue.pop(0)
-                        subscribe(s)
-                    else:
-                        active_count[0] -= 1
-                        if is_stopped[0] and active_count[0] == 0:
-                            observer.on_completed()
-
-                on_next = synchronized(source.lock)(observer.on_next)
-                on_error = synchronized(source.lock)(observer.on_error)
-                subscription.disposable = xs.subscribe(
-                    on_next, on_error, on_completed, scheduler=scheduler
-                )
-
-            def on_next(inner_source: Observable[_T]) -> None:
-                assert max_concurrent
-                if active_count[0] < max_concurrent:
-                    active_count[0] += 1
-                    subscribe(inner_source)
-                else:
-                    queue.append(inner_source)
-
+    source: Observable[Observable[_T]],
+    *sources: Observable[_T],
+    max_concurrent: int | None = None,
+) -> Observable[_T]:
+    """Merges an observable sequence of observable sequences into
+    an observable sequence, limiting the number of concurrent
+    subscriptions to inner sequences. Or merges two observable
+    sequences into a single observable sequence.
+
+    Examples:
+        >>> res = source.pipe(merge(max_concurrent=2))
+        >>> res = merge()(source)
+
+    Args:
+        source: Source observable.
+        *sources: Additional observables to merge.
+        max_concurrent: Maximum number of concurrent subscriptions.
+
+    Returns:
+        The observable sequence that merges the elements of the
+        inner sequences.
+    """
+
+    if max_concurrent is None:
+        sources_ = tuple([source]) + sources
+        return reactivex.merge(*sources_)
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        active_count = [0]
+        group = CompositeDisposable()
+        is_stopped = [False]
+        queue: list[Observable[_T]] = []
+
+        def subscribe(xs: Observable[_T]):
+            subscription = SingleAssignmentDisposable()
+            group.add(subscription)
+
+            @synchronized(source.lock)
             def on_completed():
-                is_stopped[0] = True
-                if active_count[0] == 0:
-                    observer.on_completed()
+                group.remove(subscription)
+                if queue:
+                    s = queue.pop(0)
+                    subscribe(s)
+                else:
+                    active_count[0] -= 1
+                    if is_stopped[0] and active_count[0] == 0:
+                        observer.on_completed()
 
-            group.add(
-                source.subscribe(
-                    on_next, observer.on_error, on_completed, scheduler=scheduler
-                )
+            on_next = synchronized(source.lock)(observer.on_next)
+            on_error = synchronized(source.lock)(observer.on_error)
+            subscription.disposable = xs.subscribe(
+                on_next, on_error, on_completed, scheduler=scheduler
             )
-            return group
-
-        return Observable(subscribe)
-
-    return merge
-
-
-def merge_all_() -> Callable[[Observable[Observable[_T]]], Observable[_T]]:
-    def merge_all(source: Observable[Observable[_T]]) -> Observable[_T]:
-        """Partially applied merge_all operator.
-
-        Merges an observable sequence of observable sequences into an
-        observable sequence.
-
-        Args:
-            source: Source observable to merge.
 
-        Returns:
-            The observable sequence that merges the elements of the inner
-            sequences.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            group = CompositeDisposable()
-            is_stopped = [False]
-            m = SingleAssignmentDisposable()
-            group.add(m)
-
-            def on_next(inner_source: Union[Observable[_T], "Future[_T]"]):
-                inner_subscription = SingleAssignmentDisposable()
-                group.add(inner_subscription)
-
-                inner_source = (
-                    from_future(inner_source)
-                    if isinstance(inner_source, Future)
-                    else inner_source
-                )
-
-                @synchronized(source.lock)
-                def on_completed():
-                    group.remove(inner_subscription)
-                    if is_stopped[0] and len(group) == 1:
-                        observer.on_completed()
-
-                on_next: typing.OnNext[_T] = synchronized(source.lock)(observer.on_next)
-                on_error = synchronized(source.lock)(observer.on_error)
-                subscription = inner_source.subscribe(
-                    on_next, on_error, on_completed, scheduler=scheduler
-                )
-                inner_subscription.disposable = subscription
+        def on_next(inner_source: Observable[_T]) -> None:
+            assert max_concurrent
+            if active_count[0] < max_concurrent:
+                active_count[0] += 1
+                subscribe(inner_source)
+            else:
+                queue.append(inner_source)
+
+        def on_completed():
+            is_stopped[0] = True
+            if active_count[0] == 0:
+                observer.on_completed()
+
+        group.add(
+            source.subscribe(
+                on_next, observer.on_error, on_completed, scheduler=scheduler
+            )
+        )
+        return group
+
+    return Observable(subscribe)
+
+
+@curry_flip
+def merge_all_(source: Observable[Observable[_T]]) -> Observable[_T]:
+    """Merges an observable sequence of observable sequences into an
+    observable sequence.
+
+    Examples:
+        >>> res = source.pipe(merge_all())
+        >>> res = merge_all()(source)
+
+    Args:
+        source: Source observable to merge.
+
+    Returns:
+        The observable sequence that merges the elements of the inner
+        sequences.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        group = CompositeDisposable()
+        is_stopped = [False]
+        m = SingleAssignmentDisposable()
+        group.add(m)
+
+        def on_next(inner_source: Union[Observable[_T], "Future[_T]"]):
+            inner_subscription = SingleAssignmentDisposable()
+            group.add(inner_subscription)
+
+            inner_source = (
+                from_future(inner_source)
+                if isinstance(inner_source, Future)
+                else inner_source
+            )
 
+            @synchronized(source.lock)
             def on_completed():
-                is_stopped[0] = True
-                if len(group) == 1:
+                group.remove(inner_subscription)
+                if is_stopped[0] and len(group) == 1:
                     observer.on_completed()
 
-            m.disposable = source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
+            on_next: typing.OnNext[_T] = synchronized(source.lock)(observer.on_next)
+            on_error = synchronized(source.lock)(observer.on_error)
+            subscription = inner_source.subscribe(
+                on_next, on_error, on_completed, scheduler=scheduler
             )
-            return group
+            inner_subscription.disposable = subscription
+
+        def on_completed():
+            is_stopped[0] = True
+            if len(group) == 1:
+                observer.on_completed()
 
-        return Observable(subscribe)
+        m.disposable = source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
+        return group
 
-    return merge_all
+    return Observable(subscribe)
 
 
 __all__ = ["merge_", "merge_all_"]

reactivex/operators/_min.py

@@ -1,7 +1,9 @@
-from typing import Callable, List, Optional, TypeVar, cast
+from collections.abc import Callable
+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.internal.basic import identity
 from reactivex.internal.exceptions import SequenceContainsNoElementsError
 from reactivex.typing import Comparer
@@ -9,33 +11,37 @@ from reactivex.typing import Comparer
 _T = TypeVar("_T")
 
 
-def first_only(x: List[_T]) -> _T:
+def first_only(x: list[_T]) -> _T:
     if not x:
         raise SequenceContainsNoElementsError()
 
     return x[0]
 
 
+@curry_flip
 def min_(
-    comparer: Optional[Comparer[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    """The `min` operator.
+    source: Observable[_T],
+    comparer: Comparer[_T] | None = None,
+) -> Observable[_T]:
+    """Returns the minimum element in an observable sequence.
 
     Returns the minimum element in an observable sequence according to
     the optional comparer else a default greater than less than check.
 
     Examples:
-        >>> res = source.min()
-        >>> res = source.min(lambda x, y: x.value - y.value)
+        >>> result = source.pipe(min())
+        >>> result = min()(source)
+        >>> result = source.pipe(min(lambda x, y: x.value - y.value))
 
     Args:
-        comparer: [Optional] Comparer used to compare elements.
+        source: The source observable.
+        comparer: Optional comparer used to compare elements.
 
     Returns:
         An observable sequence containing a single element
         with the minimum element in the source sequence.
     """
-    return compose(
+    return source.pipe(
         ops.min_by(cast(Callable[[_T], _T], identity), comparer),
         ops.map(first_only),
     )

reactivex/operators/_minby.py

@@ -1,4 +1,5 @@
-from typing import Callable, List, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc, typing
 from reactivex.internal.basic import default_sub_comparer
@@ -11,14 +12,14 @@ def extrema_by(
     source: Observable[_T],
     key_mapper: typing.Mapper[_T, _TKey],
     comparer: typing.SubComparer[_TKey],
-) -> Observable[List[_T]]:
+) -> Observable[list[_T]]:
     def subscribe(
-        observer: abc.ObserverBase[List[_T]],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        observer: abc.ObserverBase[list[_T]],
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         has_value = False
         last_key: _TKey = cast(_TKey, None)
-        items: List[_T] = []
+        items: list[_T] = []
 
         def on_next(x: _T) -> None:
             nonlocal has_value, last_key
@@ -60,8 +61,8 @@ def extrema_by(
 
 def min_by_(
     key_mapper: typing.Mapper[_T, _TKey],
-    comparer: Optional[typing.SubComparer[_TKey]] = None,
-) -> Callable[[Observable[_T]], Observable[List[_T]]]:
+    comparer: typing.SubComparer[_TKey] | None = None,
+) -> Callable[[Observable[_T]], Observable[list[_T]]]:
     """The `min_by` operator.
 
     Returns the elements in an observable sequence with the minimum key
@@ -82,7 +83,7 @@ def min_by_(
 
     cmp = comparer or default_sub_comparer
 
-    def min_by(source: Observable[_T]) -> Observable[List[_T]]:
+    def min_by(source: Observable[_T]) -> Observable[list[_T]]:
         return extrema_by(source, key_mapper, lambda x, y: -cmp(x, y))
 
     return min_by