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

reactivex/operators/_flatmap.py

@@ -1,8 +1,9 @@
 from asyncio import Future
-from typing import Any, Callable, Optional, TypeVar, Union, cast
+from typing import Any, TypeVar, Union, cast
 
 from reactivex import Observable, from_, from_future
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.internal.basic import identity
 from reactivex.typing import Mapper, MapperIndexed
 
@@ -12,19 +13,21 @@ _T2 = TypeVar("_T2")
 
 def _flat_map_internal(
     source: Observable[_T1],
-    mapper: Optional[Mapper[_T1, Any]] = None,
-    mapper_indexed: Optional[MapperIndexed[_T1, Any]] = None,
+    mapper: Mapper[_T1, Any] | None = None,
+    mapper_indexed: MapperIndexed[_T1, Any] | None = None,
 ) -> Observable[Any]:
     def projection(x: _T1, i: int) -> Observable[Any]:
         mapper_result: Any = (
             mapper(x)
             if mapper
-            else mapper_indexed(x, i) if mapper_indexed else identity
+            else mapper_indexed(x, i)
+            if mapper_indexed
+            else identity
         )
         if isinstance(mapper_result, Future):
             result: Observable[Any] = from_future(cast("Future[Any]", mapper_result))
         elif isinstance(mapper_result, Observable):
-            result = mapper_result
+            result = cast(Observable[Any], mapper_result)
         else:
             result = from_(mapper_result)
         return result
@@ -35,95 +38,98 @@ def _flat_map_internal(
     )
 
 
+@curry_flip
 def flat_map_(
-    mapper: Optional[Mapper[_T1, Observable[_T2]]] = None
-) -> Callable[[Observable[_T1]], Observable[_T2]]:
-    def flat_map(source: Observable[_T1]) -> Observable[_T2]:
-        """One of the Following:
-        Projects each element of an observable sequence to an observable
-        sequence and merges the resulting observable sequences into one
-        observable sequence.
-
-        Example:
-            >>> flat_map(source)
-
-        Args:
-            source: Source observable to flat map.
-
-        Returns:
-            An operator function that takes a source observable and returns
-            an observable sequence whose elements are the result of invoking
-            the one-to-many transform function on each element of the
-            input sequence .
-        """
-
-        if callable(mapper):
-            ret = _flat_map_internal(source, mapper=mapper)
-        else:
-            ret = _flat_map_internal(source, mapper=lambda _: mapper)
+    source: Observable[_T1],
+    mapper: Mapper[_T1, Observable[_T2]] | None = None,
+) -> Observable[_T2]:
+    """Projects each element of an observable sequence to an observable
+    sequence and merges the resulting observable sequences into one
+    observable sequence.
+
+    Examples:
+        >>> source.pipe(flat_map(lambda x: of(x * 2)))
+        >>> flat_map(lambda x: of(x * 2))(source)
+
+    Args:
+        source: Source observable to flat map.
+        mapper: Transform function to apply to each element.
 
-        return ret
+    Returns:
+        An observable sequence whose elements are the result of invoking
+        the one-to-many transform function on each element of the
+        input sequence.
+    """
 
-    return flat_map
+    if callable(mapper):
+        ret = _flat_map_internal(source, mapper=mapper)
+    else:
+        ret = _flat_map_internal(source, mapper=lambda _: mapper)
 
+    return ret
 
+
+@curry_flip
 def flat_map_indexed_(
-    mapper_indexed: Optional[Any] = None,
-) -> Callable[[Observable[Any]], Observable[Any]]:
-    def flat_map_indexed(source: Observable[Any]) -> Observable[Any]:
-        """One of the Following:
-        Projects each element of an observable sequence to an observable
-        sequence and merges the resulting observable sequences into one
-        observable sequence.
-
-        Example:
-            >>> flat_map_indexed(source)
-
-        Args:
-            source: Source observable to flat map.
-
-        Returns:
-            An observable sequence whose elements are the result of invoking
-            the one-to-many transform function on each element of the input
-            sequence.
-        """
-
-        if callable(mapper_indexed):
-            ret = _flat_map_internal(source, mapper_indexed=mapper_indexed)
-        else:
-            ret = _flat_map_internal(source, mapper=lambda _: mapper_indexed)
-        return ret
+    source: Observable[Any],
+    mapper_indexed: Any | None = None,
+) -> Observable[Any]:
+    """Projects each element of an observable sequence to an observable
+    sequence and merges the resulting observable sequences into one
+    observable sequence.
 
-    return flat_map_indexed
+    Examples:
+        >>> source.pipe(flat_map_indexed(lambda x, i: of(x * i)))
+        >>> flat_map_indexed(lambda x, i: of(x * i))(source)
 
+    Args:
+        source: Source observable to flat map.
+        mapper_indexed: Transform function with index to apply to each element.
 
+    Returns:
+        An observable sequence whose elements are the result of invoking
+        the one-to-many transform function on each element of the input
+        sequence.
+    """
+
+    if callable(mapper_indexed):
+        ret = _flat_map_internal(source, mapper_indexed=mapper_indexed)
+    else:
+        ret = _flat_map_internal(source, mapper=lambda _: mapper_indexed)
+    return ret
+
+
+@curry_flip
 def flat_map_latest_(
-    mapper: Mapper[_T1, Union[Observable[_T2], "Future[_T2]"]]
-) -> Callable[[Observable[_T1]], Observable[_T2]]:
-    def flat_map_latest(source: Observable[_T1]) -> Observable[_T2]:
-        """Projects each element of an observable sequence into a new
-        sequence of observable sequences by incorporating the element's
-        index and then transforms an observable sequence of observable
-        sequences into an observable sequence producing values only
-        from the most recent observable sequence.
-
-        Args:
-            source: Source observable to flat map latest.
-
-        Returns:
-            An observable sequence whose elements are the result of
-            invoking the transform function on each element of source
-            producing an observable of Observable sequences and that at
-            any point in time produces the elements of the most recent
-            inner observable sequence that has been received.
-        """
-
-        return source.pipe(
-            ops.map(mapper),
-            ops.switch_latest(),
-        )
+    source: Observable[_T1],
+    mapper: Mapper[_T1, Union[Observable[_T2], "Future[_T2]"]],
+) -> Observable[_T2]:
+    """Projects each element of an observable sequence into a new
+    sequence of observable sequences by incorporating the element's
+    index and then transforms an observable sequence of observable
+    sequences into an observable sequence producing values only
+    from the most recent observable sequence.
+
+    Examples:
+        >>> source.pipe(flat_map_latest(lambda x: of(x * 2)))
+        >>> flat_map_latest(lambda x: of(x * 2))(source)
+
+    Args:
+        source: Source observable to flat map latest.
+        mapper: Transform function to apply to each element.
+
+    Returns:
+        An observable sequence whose elements are the result of
+        invoking the transform function on each element of source
+        producing an observable of Observable sequences and that at
+        any point in time produces the elements of the most recent
+        inner observable sequence that has been received.
+    """
 
-    return flat_map_latest
+    return source.pipe(
+        ops.map(mapper),
+        ops.switch_latest(),
+    )
 
 
 __all__ = ["flat_map_", "flat_map_latest_", "flat_map_indexed_"]

reactivex/operators/_forkjoin.py

@@ -1,28 +1,33 @@
-from typing import Any, Callable, Tuple
+from typing import Any, cast
 
 import reactivex
 from reactivex import Observable
+from reactivex.internal import curry_flip
 
 
+@curry_flip
 def fork_join_(
+    source: Observable[Any],
     *args: Observable[Any],
-) -> Callable[[Observable[Any]], Observable[Tuple[Any, ...]]]:
-    def fork_join(source: Observable[Any]) -> Observable[Tuple[Any, ...]]:
-        """Wait for observables to complete and then combine last values
-        they emitted into a tuple. Whenever any of that observables
-        completes without emitting any value, result sequence will
-        complete at that moment as well.
-
-        Examples:
-            >>> obs = fork_join(source)
-
-        Returns:
-            An observable sequence containing the result of combining
-            last element from each source in given sequence.
-        """
-        return reactivex.fork_join(source, *args)
-
-    return fork_join
+) -> Observable[tuple[Any, ...]]:
+    """Wait for observables to complete and then combine last values
+    they emitted into a tuple. Whenever any of that observables
+    completes without emitting any value, result sequence will
+    complete at that moment as well.
+
+    Examples:
+        >>> source.pipe(fork_join(obs1, obs2))
+        >>> fork_join(obs1, obs2)(source)
+
+    Args:
+        source: Source observable.
+        *args: Additional observables to fork_join with.
+
+    Returns:
+        An observable sequence containing the result of combining
+        last element from each source in given sequence.
+    """
+    return cast(Observable[tuple[Any, ...]], reactivex.fork_join(source, *args))
 
 
 __all__ = ["fork_join_"]

reactivex/operators/_groupby.py

@@ -1,6 +1,8 @@
-from typing import Any, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import GroupedObservable, Observable, typing
+from reactivex.internal import curry_flip
 from reactivex.subject import Subject
 
 _T = TypeVar("_T")
@@ -10,11 +12,30 @@ _TValue = TypeVar("_TValue")
 # pylint: disable=import-outside-toplevel
 
 
+@curry_flip
 def group_by_(
+    source: Observable[_T],
     key_mapper: typing.Mapper[_T, _TKey],
-    element_mapper: Optional[typing.Mapper[_T, _TValue]] = None,
-    subject_mapper: Optional[Callable[[], Subject[_TValue]]] = None,
-) -> Callable[[Observable[_T]], Observable[GroupedObservable[_TKey, _TValue]]]:
+    element_mapper: typing.Mapper[_T, _TValue] | None = None,
+    subject_mapper: Callable[[], Subject[_TValue]] | None = None,
+) -> Observable[GroupedObservable[_TKey, _TValue]]:
+    """Groups the elements of an observable sequence according to a
+    specified key mapper function.
+
+    Examples:
+        >>> res = source.pipe(group_by(lambda x: x.id))
+        >>> res = group_by(lambda x: x.id)(source)
+
+    Args:
+        source: Source observable to group.
+        key_mapper: A function to extract the key for each element.
+        element_mapper: Optional function to map elements to values.
+        subject_mapper: Optional function that returns a subject used to initiate
+            a grouped observable.
+
+    Returns:
+        An observable sequence of grouped observables.
+    """
     from reactivex import operators as ops
 
     def duration_mapper(_: GroupedObservable[Any, Any]) -> Observable[Any]:
@@ -22,8 +43,8 @@ def group_by_(
 
         return reactivex.never()
 
-    return ops.group_by_until(
-        key_mapper, element_mapper, duration_mapper, subject_mapper
+    return source.pipe(
+        ops.group_by_until(key_mapper, element_mapper, duration_mapper, subject_mapper)
     )
 
 

reactivex/operators/_groupbyuntil.py

@@ -1,5 +1,6 @@
 from collections import OrderedDict
-from typing import Any, Callable, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 from reactivex import GroupedObservable, Observable, abc
 from reactivex import operators as ops
@@ -19,9 +20,9 @@ _TValue = TypeVar("_TValue")
 
 def group_by_until_(
     key_mapper: Mapper[_T, _TKey],
-    element_mapper: Optional[Mapper[_T, _TValue]],
+    element_mapper: Mapper[_T, _TValue] | None,
     duration_mapper: Callable[[GroupedObservable[_TKey, _TValue]], Observable[Any]],
-    subject_mapper: Optional[Callable[[], Subject[_TValue]]] = None,
+    subject_mapper: Callable[[], Subject[_TValue]] | None = None,
 ) -> Callable[[Observable[_T]], Observable[GroupedObservable[_TKey, _TValue]]]:
     """Groups the elements of an observable sequence according to a
     specified key mapper function. A duration mapper function is used
@@ -57,7 +58,9 @@ def group_by_until_(
 
     element_mapper_ = element_mapper or cast(Mapper[_T, _TValue], identity)
 
-    default_subject_mapper: Callable[[], Subject[_TValue]] = lambda: Subject()
+    def default_subject_mapper() -> Subject[_TValue]:
+        return Subject()
+
     subject_mapper_ = subject_mapper or default_subject_mapper
 
     def group_by_until(
@@ -65,7 +68,7 @@ def group_by_until_(
     ) -> Observable[GroupedObservable[_TKey, _TValue]]:
         def subscribe(
             observer: abc.ObserverBase[GroupedObservable[_TKey, _TValue]],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             writers: OrderedDict[_TKey, Subject[_TValue]] = OrderedDict()
             group_disposable = CompositeDisposable()

reactivex/operators/_groupjoin.py

@@ -1,6 +1,7 @@
 import logging
 from collections import OrderedDict
-from typing import Any, Callable, Optional, Tuple, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex import operators as ops
@@ -22,7 +23,7 @@ def group_join_(
     right: Observable[_TRight],
     left_duration_mapper: Callable[[_TLeft], Observable[Any]],
     right_duration_mapper: Callable[[_TRight], Observable[Any]],
-) -> Callable[[Observable[_TLeft]], Observable[Tuple[_TLeft, Observable[_TRight]]]]:
+) -> Callable[[Observable[_TLeft]], Observable[tuple[_TLeft, Observable[_TRight]]]]:
     """Correlates the elements of two sequences based on overlapping
     durations, and groups the results.
 
@@ -45,10 +46,10 @@ def group_join_(
 
     def group_join(
         left: Observable[_TLeft],
-    ) -> Observable[Tuple[_TLeft, Observable[_TRight]]]:
+    ) -> Observable[tuple[_TLeft, Observable[_TRight]]]:
         def subscribe(
-            observer: abc.ObserverBase[Tuple[_TLeft, Observable[_TRight]]],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            observer: abc.ObserverBase[tuple[_TLeft, Observable[_TRight]]],
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             group = CompositeDisposable()
             rcd = RefCountDisposable(group)
@@ -68,7 +69,7 @@ def group_join_(
                 try:
                     result = (value, add_ref(subject, rcd))
                 except Exception as e:
-                    log.error("*** Exception: %s" % e)
+                    log.error(f"*** Exception: {e}")
                     for left_value in left_map.values():
                         left_value.on_error(e)
 

reactivex/operators/_ignoreelements.py

@@ -1,32 +1,37 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
-from reactivex.internal import noop
+from reactivex.internal import curry_flip, noop
 
 _T = TypeVar("_T")
 
 
-def ignore_elements_() -> Callable[[Observable[_T]], Observable[_T]]:
+@curry_flip
+def ignore_elements_(source: Observable[_T]) -> Observable[_T]:
     """Ignores all elements in an observable sequence leaving only the
     termination messages.
 
+    Examples:
+        >>> res = source.pipe(ignore_elements())
+        >>> res = ignore_elements()(source)
+
+    Args:
+        source: The source observable sequence.
+
     Returns:
-        An empty observable {Observable} sequence that signals
+        An empty observable sequence that signals
         termination, successful or exceptional, of the source sequence.
     """
 
-    def ignore_elements(source: Observable[_T]) -> Observable[_T]:
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            return source.subscribe(
-                noop, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
-
-        return Observable(subscribe)
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        return source.subscribe(
+            noop, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return ignore_elements
+    return Observable(subscribe)
 
 
 __all__ = ["ignore_elements_"]

reactivex/operators/_isempty.py

@@ -1,12 +1,23 @@
-from typing import Any, Callable
+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
 
+_T = TypeVar("_T")
 
-def is_empty_() -> Callable[[Observable[Any]], Observable[bool]]:
+
+@curry_flip
+def is_empty_(source: Observable[_T]) -> Observable[bool]:
     """Determines whether an observable sequence is empty.
 
+    Examples:
+        >>> res = source.pipe(is_empty())
+        >>> res = is_empty()(source)
+
+    Args:
+        source: The source observable sequence.
+
     Returns:
         An observable sequence containing a single element
         determining whether the source sequence is empty.
@@ -15,7 +26,7 @@ def is_empty_() -> Callable[[Observable[Any]], Observable[bool]]:
     def mapper(b: bool) -> bool:
         return not b
 
-    return compose(
+    return source.pipe(
         ops.some(),
         ops.map(mapper),
     )

reactivex/operators/_join.py

@@ -1,5 +1,6 @@
 from collections import OrderedDict
-from typing import Any, Callable, Optional, Tuple, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
@@ -14,8 +15,8 @@ def join_(
     right: Observable[_T2],
     left_duration_mapper: Callable[[Any], Observable[Any]],
     right_duration_mapper: Callable[[Any], Observable[Any]],
-) -> Callable[[Observable[_T1]], Observable[Tuple[_T1, _T2]]]:
-    def join(source: Observable[_T1]) -> Observable[Tuple[_T1, _T2]]:
+) -> Callable[[Observable[_T1]], Observable[tuple[_T1, _T2]]]:
+    def join(source: Observable[_T1]) -> Observable[tuple[_T1, _T2]]:
         """Correlates the elements of two sequences based on
         overlapping durations.
 
@@ -31,8 +32,8 @@ def join_(
         left = source
 
         def subscribe(
-            observer: abc.ObserverBase[Tuple[_T1, _T2]],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            observer: abc.ObserverBase[tuple[_T1, _T2]],
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             group = CompositeDisposable()
             left_done = False

reactivex/operators/_last.py

@@ -1,6 +1,7 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, operators
+from reactivex.internal import curry_flip
 from reactivex.typing import Predicate
 
 from ._lastordefault import last_or_default_async
@@ -8,37 +9,41 @@ from ._lastordefault import last_or_default_async
 _T = TypeVar("_T")
 
 
+@curry_flip
 def last_(
-    predicate: Optional[Predicate[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[Any]]:
-    def last(source: Observable[_T]) -> Observable[Any]:
-        """Partially applied last operator.
-
-        Returns the last element of an observable sequence that
-        satisfies the condition in the predicate if specified, else
-        the last element.
-
-        Examples:
-            >>> res = last(source)
-
-        Args:
-            source: Source observable to get last item from.
-
-        Returns:
-            An observable sequence containing the last element in the
-            observable sequence that satisfies the condition in the
-            predicate.
-        """
-
-        if predicate:
-            return source.pipe(
-                operators.filter(predicate),
-                operators.last(),
-            )
-
-        return last_or_default_async(source, False)
-
-    return last
+    source: Observable[_T],
+    predicate: Predicate[_T] | None = None,
+) -> Observable[_T]:
+    """Returns the last element of an observable sequence that
+    satisfies the condition in the predicate if specified, else
+    the last element.
+
+    Examples:
+        >>> res = source.pipe(last())
+        >>> res = last()(source)
+        >>> res = source.pipe(last(lambda x: x > 3))
+
+    Args:
+        source: Source observable to get last item from.
+        predicate: [Optional] A predicate function to evaluate for
+            elements in the source sequence.
+
+    Returns:
+        An observable sequence containing the last element in the
+        observable sequence that satisfies the condition in the
+        predicate.
+    """
+    from typing import cast
+
+    if predicate:
+        return source.pipe(
+            operators.filter(predicate),
+            operators.last(),
+        )
+
+    # last_or_default_async returns Observable[_T | None], but when
+    # has_default=False it never emits None. Safe cast to Observable[_T].
+    return cast(Observable[_T], last_or_default_async(source, False))
 
 
 __all__ = ["last_"]

reactivex/operators/_lastordefault.py

@@ -1,8 +1,8 @@
-from typing import Any, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
-from reactivex import Observable, abc
+from reactivex import Observable, abc, typing
 from reactivex import operators as ops
-from reactivex import typing
 from reactivex.internal.exceptions import SequenceContainsNoElementsError
 
 _T = TypeVar("_T")
@@ -11,11 +11,11 @@ _T = TypeVar("_T")
 def last_or_default_async(
     source: Observable[_T],
     has_default: bool = False,
-    default_value: Optional[_T] = None,
-) -> Observable[Optional[_T]]:
+    default_value: _T | None = None,
+) -> Observable[_T | None]:
     def subscribe(
-        observer: abc.ObserverBase[Optional[_T]],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        observer: abc.ObserverBase[_T | None],
+        scheduler: abc.SchedulerBase | None = None,
     ):
         value = [default_value]
         seen_value = [False]
@@ -39,7 +39,7 @@ def last_or_default_async(
 
 
 def last_or_default(
-    default_value: Optional[_T] = None, predicate: Optional[typing.Predicate[_T]] = None
+    default_value: _T | None = None, predicate: typing.Predicate[_T] | None = None
 ) -> Callable[[Observable[_T]], Observable[Any]]:
     def last_or_default(source: Observable[Any]) -> Observable[Any]:
         """Return last or default element.