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

reactivex/operators/_do.py

@@ -1,86 +1,86 @@
-from typing import Any, Callable, List, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import CompositeDisposable
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def do_action_(
-    on_next: Optional[typing.OnNext[_T]] = None,
-    on_error: Optional[typing.OnError] = None,
-    on_completed: Optional[typing.OnCompleted] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def do_action(source: Observable[_T]) -> Observable[_T]:
-        """Invokes an action for each element in the observable
-        sequence and invokes an action on graceful or exceptional
-        termination of the observable sequence. This method can be used
-        for debugging, logging, etc. of query behavior by intercepting
-        the message stream to run arbitrary actions for messages on the
-        pipeline.
-
-        Examples:
-            >>> do_action(send)(observable)
-            >>> do_action(on_next, on_error)(observable)
-            >>> do_action(on_next, on_error, on_completed)(observable)
-
-        Args:
-            on_next: [Optional] Action to invoke for each element in
-                the observable sequence.
-            on_error: [Optional] Action to invoke on exceptional
-                termination of the observable sequence.
-            on_completed: [Optional] Action to invoke on graceful
-                termination of the observable sequence.
-
-        Returns:
-            An observable source sequence with the side-effecting
-            behavior applied.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            def _on_next(x: _T) -> None:
-                if not on_next:
-                    observer.on_next(x)
-                else:
-                    try:
-                        on_next(x)
-                    except Exception as e:  # pylint: disable=broad-except
-                        observer.on_error(e)
-
-                    observer.on_next(x)
-
-            def _on_error(exception: Exception) -> None:
-                if not on_error:
-                    observer.on_error(exception)
-                else:
-                    try:
-                        on_error(exception)
-                    except Exception as e:  # pylint: disable=broad-except
-                        observer.on_error(e)
-
-                    observer.on_error(exception)
-
-            def _on_completed() -> None:
-                if not on_completed:
-                    observer.on_completed()
-                else:
-                    try:
-                        on_completed()
-                    except Exception as e:  # pylint: disable=broad-except
-                        observer.on_error(e)
-
-                    observer.on_completed()
-
-            return source.subscribe(
-                _on_next, _on_error, _on_completed, scheduler=scheduler
-            )
-
-        return Observable(subscribe)
-
-    return do_action
+    source: Observable[_T],
+    on_next: typing.OnNext[_T] | None = None,
+    on_error: typing.OnError | None = None,
+    on_completed: typing.OnCompleted | None = None,
+) -> Observable[_T]:
+    """Invokes an action for each element in the observable
+    sequence and invokes an action on graceful or exceptional
+    termination of the observable sequence. This method can be used
+    for debugging, logging, etc. of query behavior by intercepting
+    the message stream to run arbitrary actions for messages on the
+    pipeline.
+
+    Examples:
+        >>> res = source.pipe(do_action(send))
+        >>> res = source.pipe(do_action(on_next, on_error))
+        >>> res = source.pipe(do_action(on_next, on_error, on_completed))
+
+    Args:
+        source: Source observable.
+        on_next: [Optional] Action to invoke for each element in
+            the observable sequence.
+        on_error: [Optional] Action to invoke on exceptional
+            termination of the observable sequence.
+        on_completed: [Optional] Action to invoke on graceful
+            termination of the observable sequence.
+
+    Returns:
+        An observable source sequence with the side-effecting
+        behavior applied.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        def _on_next(x: _T) -> None:
+            if not on_next:
+                observer.on_next(x)
+            else:
+                try:
+                    on_next(x)
+                except Exception as e:  # pylint: disable=broad-except
+                    observer.on_error(e)
+
+                observer.on_next(x)
+
+        def _on_error(exception: Exception) -> None:
+            if not on_error:
+                observer.on_error(exception)
+            else:
+                try:
+                    on_error(exception)
+                except Exception as e:  # pylint: disable=broad-except
+                    observer.on_error(e)
+
+                observer.on_error(exception)
+
+        def _on_completed() -> None:
+            if not on_completed:
+                observer.on_completed()
+            else:
+                try:
+                    on_completed()
+                except Exception as e:  # pylint: disable=broad-except
+                    observer.on_error(e)
+
+                observer.on_completed()
+
+        return source.subscribe(_on_next, _on_error, _on_completed, scheduler=scheduler)
+
+    return Observable(subscribe)
 
 
 def do_(observer: abc.ObserverBase[_T]) -> Callable[[Observable[_T]], Observable[_T]]:
@@ -114,7 +114,7 @@ def do_after_next(
     """
 
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         def on_next(value: _T):
             try:
@@ -139,7 +139,7 @@ def do_on_subscribe(source: Observable[Any], on_subscribe: typing.Action):
     """
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         on_subscribe()
         return source.subscribe(
@@ -167,7 +167,7 @@ def do_on_dispose(source: Observable[Any], on_dispose: typing.Action):
             on_dispose()
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         composite_disposable = CompositeDisposable()
         composite_disposable.add(OnDispose())
@@ -193,7 +193,7 @@ def do_on_terminate(source: Observable[Any], on_terminate: typing.Action):
     """
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         def on_completed():
             try:
@@ -228,7 +228,7 @@ def do_after_terminate(source: Observable[Any], after_terminate: typing.Action):
     """
 
     def subscribe(
-        observer: abc.ObserverBase[Any], scheduler: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[Any], scheduler: abc.SchedulerBase | None = None
     ) -> abc.DisposableBase:
         def on_completed():
             observer.on_completed()
@@ -251,9 +251,11 @@ def do_after_terminate(source: Observable[Any], after_terminate: typing.Action):
     return Observable(subscribe)
 
 
+@curry_flip
 def do_finally(
+    source: Observable[_T],
     finally_action: typing.Action,
-) -> Callable[[Observable[_T]], Observable[_T]]:
+) -> Observable[_T]:
     """Invokes an action after an on_complete(), on_error(), or disposal
     event occurs.
 
@@ -263,13 +265,21 @@ def do_finally(
     Note this operator will strive to execute the finally_action once,
     and prevent any redudant calls
 
+    Examples:
+        >>> res = source.pipe(do_finally(lambda: print("done")))
+        >>> res = do_finally(lambda: print("done"))(source)
+
     Args:
-        finally_action -- Action to invoke after on_complete, on_error,
-        or disposal is called
+        source: Source observable.
+        finally_action: Action to invoke after on_complete, on_error,
+            or disposal is called
+
+    Returns:
+        An observable sequence with the finally action applied.
     """
 
     class OnDispose(abc.DisposableBase):
-        def __init__(self, was_invoked: List[bool]):
+        def __init__(self, was_invoked: list[bool]):
             self.was_invoked = was_invoked
 
         def dispose(self) -> None:
@@ -277,43 +287,40 @@ def do_finally(
                 finally_action()
                 self.was_invoked[0] = True
 
-    def partial(source: Observable[_T]) -> Observable[_T]:
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            was_invoked = [False]
-
-            def on_completed():
-                observer.on_completed()
-                try:
-                    if not was_invoked[0]:
-                        finally_action()
-                        was_invoked[0] = True
-                except Exception as err:  # pylint: disable=broad-except
-                    observer.on_error(err)
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        was_invoked = [False]
 
-            def on_error(exception: Exception):
-                observer.on_error(exception)
-                try:
-                    if not was_invoked[0]:
-                        finally_action()
-                        was_invoked[0] = True
-                except Exception as err:  # pylint: disable=broad-except
-                    observer.on_error(err)
+        def on_completed():
+            observer.on_completed()
+            try:
+                if not was_invoked[0]:
+                    finally_action()
+                    was_invoked[0] = True
+            except Exception as err:  # pylint: disable=broad-except
+                observer.on_error(err)
 
-            composite_disposable = CompositeDisposable()
-            composite_disposable.add(OnDispose(was_invoked))
-            subscription = source.subscribe(
-                observer.on_next, on_error, on_completed, scheduler=scheduler
-            )
-            composite_disposable.add(subscription)
+        def on_error(exception: Exception):
+            observer.on_error(exception)
+            try:
+                if not was_invoked[0]:
+                    finally_action()
+                    was_invoked[0] = True
+            except Exception as err:  # pylint: disable=broad-except
+                observer.on_error(err)
 
-            return composite_disposable
+        composite_disposable = CompositeDisposable()
+        composite_disposable.add(OnDispose(was_invoked))
+        subscription = source.subscribe(
+            observer.on_next, on_error, on_completed, scheduler=scheduler
+        )
+        composite_disposable.add(subscription)
 
-        return Observable(subscribe)
+        return composite_disposable
 
-    return partial
+    return Observable(subscribe)
 
 
 __all__ = [

reactivex/operators/_dowhile.py

@@ -1,4 +1,5 @@
-from typing import Callable, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import Observable
 from reactivex import operators as ops
@@ -7,7 +8,7 @@ _T = TypeVar("_T")
 
 
 def do_while_(
-    condition: Callable[[Observable[_T]], bool]
+    condition: Callable[[Observable[_T]], bool],
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     """Repeats source as long as condition holds emulating a do while
     loop.

reactivex/operators/_elementatordefault.py

@@ -1,51 +1,75 @@
-from typing import Callable, Optional, TypeVar, cast
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 from reactivex.internal.exceptions import ArgumentOutOfRangeException
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def element_at_or_default_(
-    index: int, has_default: bool = False, default_value: Optional[_T] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    index: int,
+    has_default: bool = False,
+    default_value: _T | None = None,
+) -> Observable[_T]:
+    """Returns the element at a specified index in a sequence or a default value
+    if the index is out of range.
+
+    Examples:
+        >>> result = source.pipe(element_at_or_default(5))
+        >>> result = element_at_or_default(5)(source)
+        >>> result = source.pipe(element_at_or_default(5, True, 0))
+
+    Args:
+        source: The source observable sequence.
+        index: The zero-based index of the element to retrieve.
+        has_default: Whether to return a default value if index is out of range.
+        default_value: The default value to return if has_default is True.
+
+    Returns:
+        An observable sequence that produces the element at the specified
+        position in the source sequence, or a default value if the index is
+        out of range.
+
+    Raises:
+        ArgumentOutOfRangeException: If index is negative.
+    """
     if index < 0:
         raise ArgumentOutOfRangeException()
 
-    def element_at_or_default(source: Observable[_T]) -> Observable[_T]:
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            index_ = index
-
-            def on_next(x: _T) -> None:
-                nonlocal index_
-                found = False
-                with source.lock:
-                    if index_:
-                        index_ -= 1
-                    else:
-                        found = True
-
-                if found:
-                    observer.on_next(x)
-                    observer.on_completed()
-
-            def on_completed():
-                if not has_default:
-                    observer.on_error(ArgumentOutOfRangeException())
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        index_ = index
+
+        def on_next(x: _T) -> None:
+            nonlocal index_
+            found = False
+            with source.lock:
+                if index_:
+                    index_ -= 1
                 else:
-                    observer.on_next(cast(_T, default_value))
-                    observer.on_completed()
+                    found = True
+
+            if found:
+                observer.on_next(x)
+                observer.on_completed()
 
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
+        def on_completed():
+            if not has_default:
+                observer.on_error(ArgumentOutOfRangeException())
+            else:
+                observer.on_next(cast(_T, default_value))
+                observer.on_completed()
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
 
-    return element_at_or_default
+    return Observable(subscribe)
 
 
 __all__ = ["element_at_or_default_"]

reactivex/operators/_exclusive.py

@@ -1,74 +1,80 @@
 from asyncio import Future
-from typing import Callable, Optional, TypeVar, Union
+from typing import TypeVar, Union
 
 import reactivex
 from reactivex import Observable, abc
 from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def exclusive_() -> Callable[[Observable[Observable[_T]]], Observable[_T]]:
+@curry_flip
+def exclusive_(source: Observable[Observable[_T]]) -> Observable[_T]:
     """Performs a exclusive waiting for the first to finish before
     subscribing to another observable. Observables that come in between
     subscriptions will be dropped on the floor.
 
+    Examples:
+        >>> res = source.pipe(exclusive())
+        >>> res = exclusive()(source)
+
+    Args:
+        source: Source observable of observables.
+
     Returns:
         An exclusive observable with only the results that
         happen when subscribed.
     """
 
-    def exclusive(source: Observable[Observable[_T]]) -> Observable[_T]:
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            has_current = [False]
-            is_stopped = [False]
-            m = SingleAssignmentDisposable()
-            g = CompositeDisposable()
-
-            g.add(m)
-
-            def on_next(inner_source: Union[Observable[_T], "Future[_T]"]) -> None:
-                if not has_current[0]:
-                    has_current[0] = True
-
-                    inner_source = (
-                        reactivex.from_future(inner_source)
-                        if isinstance(inner_source, Future)
-                        else inner_source
-                    )
-
-                    inner_subscription = SingleAssignmentDisposable()
-                    g.add(inner_subscription)
-
-                    def on_completed_inner():
-                        g.remove(inner_subscription)
-                        has_current[0] = False
-                        if is_stopped[0] and len(g) == 1:
-                            observer.on_completed()
-
-                    inner_subscription.disposable = inner_source.subscribe(
-                        observer.on_next,
-                        observer.on_error,
-                        on_completed_inner,
-                        scheduler=scheduler,
-                    )
-
-            def on_completed() -> None:
-                is_stopped[0] = True
-                if not has_current[0] and len(g) == 1:
-                    observer.on_completed()
-
-            m.disposable = source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
-            return g
-
-        return Observable(subscribe)
-
-    return exclusive
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        has_current = [False]
+        is_stopped = [False]
+        m = SingleAssignmentDisposable()
+        g = CompositeDisposable()
+
+        g.add(m)
+
+        def on_next(inner_source: Union[Observable[_T], "Future[_T]"]) -> None:
+            if not has_current[0]:
+                has_current[0] = True
+
+                inner_source = (
+                    reactivex.from_future(inner_source)
+                    if isinstance(inner_source, Future)
+                    else inner_source
+                )
+
+                inner_subscription = SingleAssignmentDisposable()
+                g.add(inner_subscription)
+
+                def on_completed_inner():
+                    g.remove(inner_subscription)
+                    has_current[0] = False
+                    if is_stopped[0] and len(g) == 1:
+                        observer.on_completed()
+
+                inner_subscription.disposable = inner_source.subscribe(
+                    observer.on_next,
+                    observer.on_error,
+                    on_completed_inner,
+                    scheduler=scheduler,
+                )
+
+        def on_completed() -> None:
+            is_stopped[0] = True
+            if not has_current[0] and len(g) == 1:
+                observer.on_completed()
+
+        m.disposable = source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
+        return g
+
+    return Observable(subscribe)
 
 
 __all__ = ["exclusive_"]