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

reactivex/operators/_skiplastwithtime.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.scheduler import TimeoutScheduler
@@ -7,7 +8,7 @@ _T = TypeVar("_T")
 
 
 def skip_last_with_time_(
-    duration: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
+    duration: typing.RelativeTime, scheduler: abc.SchedulerBase | None = None
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     """Skips elements for the specified duration from the end of the
     observable source sequence.
@@ -34,7 +35,7 @@ def skip_last_with_time_(
     def skip_last_with_time(source: Observable[_T]) -> Observable[_T]:
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
+            scheduler_: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             nonlocal duration
 
@@ -42,7 +43,7 @@ def skip_last_with_time_(
                 scheduler or scheduler_ or TimeoutScheduler.singleton()
             )
             duration = _scheduler.to_timedelta(duration)
-            q: List[Dict[str, Any]] = []
+            q: list[dict[str, Any]] = []
 
             def on_next(x: _T) -> None:
                 now = _scheduler.now

reactivex/operators/_skipuntil.py

@@ -1,26 +1,34 @@
 from asyncio import Future
-from typing import Any, Callable, Optional, TypeVar, Union
+from typing import Any, 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 skip_until_(
-    other: Union[Observable[Any], "Future[Any]"]
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    other: Union[Observable[Any], "Future[Any]"],
+) -> Observable[_T]:
     """Returns the values from the source observable sequence only after
     the other observable sequence produces a value.
 
+    Examples:
+        >>> source.pipe(skip_until(other))
+        >>> skip_until(other)(source)
+
     Args:
+        source: Source observable to skip elements from.
         other: The observable sequence that triggers propagation of
             elements of the source sequence.
 
     Returns:
         An observable sequence containing the elements of the source
-    sequence starting from the point the other sequence triggered
-    propagation.
+        sequence starting from the point the other sequence triggered
+        propagation.
     """
 
     if isinstance(other, Future):
@@ -28,45 +36,42 @@ def skip_until_(
     else:
         obs = other
 
-    def skip_until(source: Observable[_T]) -> Observable[_T]:
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            is_open = [False]
-
-            def on_next(left: _T) -> None:
-                if is_open[0]:
-                    observer.on_next(left)
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        is_open = [False]
 
-            def on_completed() -> None:
-                if is_open[0]:
-                    observer.on_completed()
+        def on_next(left: _T) -> None:
+            if is_open[0]:
+                observer.on_next(left)
 
-            subs = source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
-            subscriptions = CompositeDisposable(subs)
+        def on_completed() -> None:
+            if is_open[0]:
+                observer.on_completed()
 
-            right_subscription = SingleAssignmentDisposable()
-            subscriptions.add(right_subscription)
+        subs = source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
+        subscriptions = CompositeDisposable(subs)
 
-            def on_next2(x: Any) -> None:
-                is_open[0] = True
-                right_subscription.dispose()
+        right_subscription = SingleAssignmentDisposable()
+        subscriptions.add(right_subscription)
 
-            def on_completed2():
-                right_subscription.dispose()
+        def on_next2(x: Any) -> None:
+            is_open[0] = True
+            right_subscription.dispose()
 
-            right_subscription.disposable = obs.subscribe(
-                on_next2, observer.on_error, on_completed2, scheduler=scheduler
-            )
+        def on_completed2():
+            right_subscription.dispose()
 
-            return subscriptions
+        right_subscription.disposable = obs.subscribe(
+            on_next2, observer.on_error, on_completed2, scheduler=scheduler
+        )
 
-        return Observable(subscribe)
+        return subscriptions
 
-    return skip_until
+    return Observable(subscribe)
 
 
 __all__ = ["skip_until_"]

reactivex/operators/_skipuntilwithtime.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from datetime import datetime
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import CompositeDisposable
@@ -10,7 +11,7 @@ _T = TypeVar("_T")
 
 def skip_until_with_time_(
     start_time: typing.AbsoluteOrRelativeTime,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     def skip_until_with_time(source: Observable[_T]) -> Observable[_T]:
         """Skips elements from the observable source sequence until the
@@ -41,7 +42,7 @@ def skip_until_with_time_(
 
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
+            scheduler_: abc.SchedulerBase | None = None,
         ):
             _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
 

reactivex/operators/_skipwhile.py

@@ -1,74 +1,95 @@
-from typing import Callable, Optional, Tuple, TypeVar
+from typing import TypeVar
 
-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
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def skip_while_(
+    source: Observable[_T],
     predicate: typing.Predicate[_T],
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def skip_while(source: Observable[_T]) -> Observable[_T]:
-        """Bypasses elements in an observable sequence as long as a
-        specified condition is true and then returns the remaining
-        elements. The element's index is used in the logic of the
-        predicate function.
+) -> Observable[_T]:
+    """Bypasses elements in an observable sequence as long as a
+    specified condition is true and then returns the remaining
+    elements.
 
-        Example:
-            >>> skip_while(source)
+    Examples:
+        >>> res = source.pipe(skip_while(lambda x: x < 3))
+        >>> res = skip_while(lambda x: x < 3)(source)
 
-        Args:
-            source: The source observable to skip elements from.
+    Args:
+        source: The source observable to skip elements from.
+        predicate: A function to test each element for a condition.
 
-        Returns:
-            An observable sequence that contains the elements from the
-            input sequence starting at the first element in the linear
-            series that does not pass the test specified by predicate.
-        """
+    Returns:
+        An observable sequence that contains the elements from the
+        input sequence starting at the first element in the linear
+        series that does not pass the test specified by predicate.
+    """
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            running = False
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        running = False
 
-            def on_next(value: _T):
-                nonlocal running
+        def on_next(value: _T):
+            nonlocal running
 
-                if not running:
-                    try:
-                        running = not predicate(value)
-                    except Exception as exn:
-                        observer.on_error(exn)
-                        return
+            if not running:
+                try:
+                    running = not predicate(value)
+                except Exception as exn:
+                    observer.on_error(exn)
+                    return
 
-                if running:
-                    observer.on_next(value)
+            if running:
+                observer.on_next(value)
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-        return Observable(subscribe)
-
-    return skip_while
+    return Observable(subscribe)
 
 
+@curry_flip
 def skip_while_indexed_(
+    source: Observable[_T],
     predicate: typing.PredicateIndexed[_T],
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def indexer(x: _T, i: int) -> Tuple[_T, int]:
+) -> Observable[_T]:
+    """Bypasses elements in an observable sequence as long as a
+    specified condition is true and then returns the remaining
+    elements. The element's index is used in the logic of the
+    predicate function.
+
+    Examples:
+        >>> res = source.pipe(skip_while_indexed(lambda x, i: i < 3))
+        >>> res = skip_while_indexed(lambda x, i: i < 3)(source)
+
+    Args:
+        source: The source observable to skip elements from.
+        predicate: A function to test each element and its index for a condition.
+
+    Returns:
+        An observable sequence that contains the elements from the
+        input sequence starting at the first element that does not
+        pass the test specified by predicate.
+    """
+
+    def indexer(x: _T, i: int) -> tuple[_T, int]:
         return (x, i)
 
-    def skipper(x: Tuple[_T, int]) -> bool:
+    def skipper(x: tuple[_T, int]) -> bool:
         return predicate(*x)
 
-    def mapper(x: Tuple[_T, int]) -> _T:
+    def mapper(x: tuple[_T, int]) -> _T:
         return x[0]
 
-    return compose(
+    return source.pipe(
         ops.map_indexed(indexer),
         ops.skip_while(skipper),
         ops.map(mapper),

reactivex/operators/_skipwithtime.py

@@ -1,66 +1,70 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import CompositeDisposable
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def skip_with_time_(
-    duration: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def skip_with_time(source: Observable[_T]) -> Observable[_T]:
-        """Skips elements for the specified duration from the start of
-        the observable source sequence.
-
-        Args:
-            >>> res = skip_with_time(5.0)
-
-        Specifying a zero value for duration doesn't guarantee no
-        elements will be dropped from the start of the source sequence.
-        This is a side-effect of the asynchrony introduced by the
-        scheduler, where the action that causes callbacks from the
-        source sequence to be forwarded may not execute immediately,
-        despite the zero due time.
-
-        Errors produced by the source sequence are always forwarded to
-        the result sequence, even if the error occurs before the
-        duration.
-
-        Args:
-            duration: Duration for skipping elements from the start of
+    source: Observable[_T],
+    duration: typing.RelativeTime,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Skips elements for the specified duration from the start of
+    the observable source sequence.
+
+    Examples:
+        >>> source.pipe(skip_with_time(5.0))
+        >>> skip_with_time(5.0)(source)
+
+    Specifying a zero value for duration doesn't guarantee no
+    elements will be dropped from the start of the source sequence.
+    This is a side-effect of the asynchrony introduced by the
+    scheduler, where the action that causes callbacks from the
+    source sequence to be forwarded may not execute immediately,
+    despite the zero due time.
+
+    Errors produced by the source sequence are always forwarded to
+    the result sequence, even if the error occurs before the
+    duration.
+
+    Args:
+        source: Source observable to skip elements from.
+        duration: Duration for skipping elements from the start of
             the sequence.
+        scheduler: Scheduler to use for timing.
 
-        Returns:
-            An observable sequence with the elements skipped during the
-            specified duration from the start of the source sequence.
-        """
+    Returns:
+        An observable sequence with the elements skipped during the
+        specified duration from the start of the source sequence.
+    """
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ):
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-            open = [False]
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler_: abc.SchedulerBase | None = None,
+    ):
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+        open = [False]
 
-            def action(scheduler: abc.SchedulerBase, state: Any) -> None:
-                open[0] = True
+        def action(scheduler: abc.SchedulerBase, state: Any) -> None:
+            open[0] = True
 
-            t = _scheduler.schedule_relative(duration, action)
+        t = _scheduler.schedule_relative(duration, action)
 
-            def on_next(x: _T):
-                if open[0]:
-                    observer.on_next(x)
+        def on_next(x: _T):
+            if open[0]:
+                observer.on_next(x)
 
-            d = source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler_
-            )
-            return CompositeDisposable(t, d)
+        d = source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler_
+        )
+        return CompositeDisposable(t, d)
 
-        return Observable(subscribe)
-
-    return skip_with_time
+    return Observable(subscribe)
 
 
 __all__ = ["skip_with_time_"]

reactivex/operators/_slice.py

@@ -1,75 +1,80 @@
 from sys import maxsize
-from typing import Any, Callable, List, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
 # pylint: disable=redefined-builtin
+@curry_flip
 def slice_(
-    start: Optional[int] = None, stop: Optional[int] = None, step: Optional[int] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    start: int | None = None,
+    stop: int | None = None,
+    step: int | None = None,
+) -> Observable[_T]:
+    """Slices the given observable.
+
+    It is basically a wrapper around the operators
+    :func:`skip <reactivex.operators.skip>`,
+    :func:`skip_last <reactivex.operators.skip_last>`,
+    :func:`take <reactivex.operators.take>`,
+    :func:`take_last <reactivex.operators.take_last>` and
+    :func:`filter <reactivex.operators.filter>`.
+
+    The following diagram helps you remember how slices works with streams.
+
+    Positive numbers are relative to the start of the events, while negative
+    numbers are relative to the end (close) of the stream.
+
+    .. code::
+
+        r---e---a---c---t---i---v---e---!
+        0   1   2   3   4   5   6   7   8
+       -8  -7  -6  -5  -4  -3  -2  -1   0
+
+    Examples:
+        >>> result = source.pipe(slice(1, 10))
+        >>> result = slice(1, 10)(source)
+        >>> result = source.pipe(slice(1, -2))
+        >>> result = source.pipe(slice(1, -1, 2))
+
+    Args:
+        source: Observable to slice
+        start: Start index
+        stop: Stop index
+        step: Step size
+
+    Returns:
+        A sliced observable sequence.
+    """
     _start: int = 0 if start is None else start
     _stop: int = maxsize if stop is None else stop
     _step: int = 1 if step is None else step
 
-    pipeline: List[Callable[[Observable[Any]], Observable[Any]]] = []
+    pipeline: list[Any] = []
 
-    def slice(source: Observable[_T]) -> Observable[_T]:
-        """The partially applied slice operator.
+    if _stop >= 0:
+        pipeline.append(ops.take(_stop))
 
-        Slices the given observable. It is basically a wrapper around the operators
-        :func:`skip <reactivex.operators.skip>`,
-        :func:`skip_last <reactivex.operators.skip_last>`,
-        :func:`take <reactivex.operators.take>`,
-        :func:`take_last <reactivex.operators.take_last>` and
-        :func:`filter <reactivex.operators.filter>`.
+    if _start > 0:
+        pipeline.append(ops.skip(_start))
+    elif _start < 0:
+        pipeline.append(ops.take_last(-_start))
 
-        The following diagram helps you remember how slices works with streams.
+    if _stop < 0:
+        pipeline.append(ops.skip_last(-_stop))
 
-        Positive numbers are relative to the start of the events, while negative
-        numbers are relative to the end (close) of the stream.
+    if _step > 1:
+        pipeline.append(ops.filter_indexed(lambda x, i: i % _step == 0))
+    elif _step < 0:
+        # Reversing events is not supported
+        raise TypeError("Negative step not supported.")
 
-        .. code::
-
-            r---e---a---c---t---i---v---e---!
-            0   1   2   3   4   5   6   7   8
-           -8  -7  -6  -5  -4  -3  -2  -1   0
-
-        Examples:
-            >>> result = source.slice(1, 10)
-            >>> result = source.slice(1, -2)
-            >>> result = source.slice(1, -1, 2)
-
-        Args:
-            source: Observable to slice
-
-        Returns:
-            A sliced observable sequence.
-        """
-
-        if _stop >= 0:
-            pipeline.append(ops.take(_stop))
-
-        if _start > 0:
-            pipeline.append(ops.skip(_start))
-        elif _start < 0:
-            pipeline.append(ops.take_last(-_start))
-
-        if _stop < 0:
-            pipeline.append(ops.skip_last(-_stop))
-
-        if _step > 1:
-            pipeline.append(ops.filter_indexed(lambda x, i: i % _step == 0))
-        elif _step < 0:
-            # Reversing events is not supported
-            raise TypeError("Negative step not supported.")
-
-        return source.pipe(*pipeline)
-
-    return slice
+    return source.pipe(*pipeline)
 
 
 __all__ = ["slice_"]