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

reactivex/operators/_takelastbuffer.py

@@ -1,55 +1,56 @@
-from typing import Callable, List, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def take_last_buffer_(count: int) -> Callable[[Observable[_T]], Observable[List[_T]]]:
-    def take_last_buffer(source: Observable[_T]) -> Observable[List[_T]]:
-        """Returns an array with the specified number of contiguous
-        elements from the end of an observable sequence.
+@curry_flip
+def take_last_buffer_(source: Observable[_T], count: int) -> Observable[list[_T]]:
+    """Returns an array with the specified number of contiguous
+    elements from the end of an observable sequence.
 
-        Example:
-            >>> res = take_last(source)
+    Example:
+        >>> res = source.pipe(take_last_buffer(5))
+        >>> res = take_last_buffer(5)(source)
 
-        This operator accumulates a buffer with a length enough to
-        store elements count elements. Upon completion of the source
-        sequence, this buffer is drained on the result sequence. This
-        causes the elements to be delayed.
+    This operator accumulates a buffer with a length enough to
+    store elements count elements. Upon completion of the source
+    sequence, this buffer is drained on the result sequence. This
+    causes the elements to be delayed.
 
-        Args:
-            source: Source observable to take elements from.
+    Args:
+        source: Source observable to take elements from.
+        count: Number of elements to take from the end.
 
-        Returns:
-            An observable sequence containing a single list with the
-            specified number of elements from the end of the source
-            sequence.
-        """
+    Returns:
+        An observable sequence containing a single list with the
+        specified number of elements from the end of the source
+        sequence.
+    """
 
-        def subscribe(
-            observer: abc.ObserverBase[List[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            q: List[_T] = []
+    def subscribe(
+        observer: abc.ObserverBase[list[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        q: list[_T] = []
 
-            def on_next(x: _T) -> None:
-                with source.lock:
-                    q.append(x)
-                    if len(q) > count:
-                        q.pop(0)
+        def on_next(x: _T) -> None:
+            with source.lock:
+                q.append(x)
+                if len(q) > count:
+                    q.pop(0)
 
-            def on_completed() -> None:
-                observer.on_next(q)
-                observer.on_completed()
+        def on_completed() -> None:
+            observer.on_next(q)
+            observer.on_completed()
 
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
 
-        return Observable(subscribe)
-
-    return take_last_buffer
+    return Observable(subscribe)
 
 
 __all__ = ["take_last_buffer_"]

reactivex/operators/_takelastwithtime.py

@@ -1,68 +1,72 @@
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def take_last_with_time_(
-    duration: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def take_last_with_time(source: Observable[_T]) -> Observable[_T]:
-        """Returns elements within the specified duration from the end
-        of the observable source sequence.
-
-        Example:
-            >>> res = take_last_with_time(source)
-
-        This operator accumulates a queue with a length enough to store
-        elements received during the initial duration window. As more
-        elements are received, elements older than the specified
-        duration are taken from the queue and produced on the result
-        sequence. This causes elements to be delayed with duration.
-
-        Args:
-            duration: Duration for taking elements from the end of the
+    source: Observable[_T],
+    duration: typing.RelativeTime,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Returns elements within the specified duration from the end
+    of the observable source sequence.
+
+    Examples:
+        >>> source.pipe(take_last_with_time(5.0))
+        >>> take_last_with_time(5.0)(source)
+
+    This operator accumulates a queue with a length enough to store
+    elements received during the initial duration window. As more
+    elements are received, elements older than the specified
+    duration are taken from the queue and produced on the result
+    sequence. This causes elements to be delayed with duration.
+
+    Args:
+        source: Source observable to take elements from.
+        duration: Duration for taking elements from the end of the
             sequence.
-
-        Returns:
-            An observable sequence with the elements taken during the
-            specified duration from the end of the source sequence.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            nonlocal duration
-
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-            duration = _scheduler.to_timedelta(duration)
-            q: List[Dict[str, Any]] = []
-
-            def on_next(x: _T) -> None:
-                now = _scheduler.now
-                q.append({"interval": now, "value": x})
-                while q and now - q[0]["interval"] >= duration:
-                    q.pop(0)
-
-            def on_completed():
-                now = _scheduler.now
-                while q:
-                    _next = q.pop(0)
-                    if now - _next["interval"] <= duration:
-                        observer.on_next(_next["value"])
-
-                observer.on_completed()
-
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler_
-            )
-
-        return Observable(subscribe)
-
-    return take_last_with_time
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence with the elements taken during the
+        specified duration from the end of the source sequence.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        nonlocal duration
+
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+        duration = _scheduler.to_timedelta(duration)
+        q: list[dict[str, Any]] = []
+
+        def on_next(x: _T) -> None:
+            now = _scheduler.now
+            q.append({"interval": now, "value": x})
+            while q and now - q[0]["interval"] >= duration:
+                q.pop(0)
+
+        def on_completed():
+            now = _scheduler.now
+            while q:
+                _next = q.pop(0)
+                if now - _next["interval"] <= duration:
+                    observer.on_next(_next["value"])
+
+            observer.on_completed()
+
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler_
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["take_last_with_time_"]

reactivex/operators/_takeuntil.py

@@ -1,51 +1,52 @@
 from asyncio import Future
-from typing import Callable, Optional, TypeVar, Union
+from typing import TypeVar
 
 from reactivex import Observable, abc, from_future
 from reactivex.disposable import CompositeDisposable
-from reactivex.internal import noop
+from reactivex.internal import curry_flip, noop
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def take_until_(
-    other: Union[Observable[_T], "Future[_T]"]
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    other: Observable[_T] | Future[_T],
+) -> Observable[_T]:
+    """Returns the values from the source observable sequence until
+    the other observable sequence produces a value.
+
+    Examples:
+        >>> source.pipe(take_until(other))
+        >>> take_until(other)(source)
+
+    Args:
+        source: The source observable sequence.
+        other: Observable or Future that terminates propagation.
+
+    Returns:
+        An observable sequence containing the elements of the source
+        sequence up to the point the other sequence interrupted
+        further propagation.
+    """
     if isinstance(other, Future):
         obs: Observable[_T] = from_future(other)
     else:
         obs = other
 
-    def take_until(source: Observable[_T]) -> Observable[_T]:
-        """Returns the values from the source observable sequence until
-        the other observable sequence produces a value.
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        def on_completed(_: _T) -> None:
+            observer.on_completed()
 
-        Args:
-            source: The source observable sequence.
+        return CompositeDisposable(
+            source.subscribe(observer, scheduler=scheduler),
+            obs.subscribe(on_completed, observer.on_error, noop, scheduler=scheduler),
+        )
 
-        Returns:
-            An observable sequence containing the elements of the source
-            sequence up to the point the other sequence interrupted
-            further propagation.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            def on_completed(_: _T) -> None:
-                observer.on_completed()
-
-            return CompositeDisposable(
-                source.subscribe(observer, scheduler=scheduler),
-                obs.subscribe(
-                    on_completed, observer.on_error, noop, scheduler=scheduler
-                ),
-            )
-
-        return Observable(subscribe)
-
-    return take_until
+    return Observable(subscribe)
 
 
 __all__ = ["take_until_"]

reactivex/operators/_takeuntilwithtime.py

@@ -1,53 +1,56 @@
 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
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def take_until_with_time_(
+    source: Observable[_T],
     end_time: typing.AbsoluteOrRelativeTime,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def take_until_with_time(source: Observable[_T]) -> Observable[_T]:
-        """Takes elements for the specified duration until the specified end
-        time, using the specified scheduler to run timers.
-
-        Examples:
-            >>> res = take_until_with_time(source)
-
-        Args:
-            source: Source observale to take elements from.
-
-        Returns:
-            An observable sequence with the elements taken
-            until the specified end time.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-
-            def action(scheduler: abc.SchedulerBase, state: Any = None):
-                observer.on_completed()
-
-            if isinstance(end_time, datetime):
-                task = _scheduler.schedule_absolute(end_time, action)
-            else:
-                task = _scheduler.schedule_relative(end_time, action)
-
-            return CompositeDisposable(
-                task, source.subscribe(observer, scheduler=scheduler_)
-            )
-
-        return Observable(subscribe)
-
-    return take_until_with_time
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Takes elements for the specified duration until the specified end
+    time, using the specified scheduler to run timers.
+
+    Examples:
+        >>> source.pipe(take_until_with_time(dt))
+        >>> take_until_with_time(5.0)(source)
+
+    Args:
+        source: Source observable to take elements from.
+        end_time: Absolute or relative time when to complete.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence with the elements taken
+        until the specified end time.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+
+        def action(scheduler: abc.SchedulerBase, state: Any = None):
+            observer.on_completed()
+
+        if isinstance(end_time, datetime):
+            task = _scheduler.schedule_absolute(end_time, action)
+        else:
+            task = _scheduler.schedule_relative(end_time, action)
+
+        return CompositeDisposable(
+            task, source.subscribe(observer, scheduler=scheduler_)
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["take_until_with_time_"]

reactivex/operators/_takewhile.py

@@ -1,121 +1,129 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 from reactivex.typing import Predicate, PredicateIndexed
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def take_while_(
-    predicate: Predicate[_T], inclusive: bool = False
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def take_while(source: Observable[_T]) -> Observable[_T]:
-        """Returns elements from an observable sequence as long as a
-        specified condition is true.
-
-        Example:
-            >>> take_while(source)
-
-        Args:
-            source: The source observable to take from.
-
-        Returns:
-            An observable sequence that contains the elements from the
-            input sequence that occur before the element at which the
-            test no longer passes.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            running = True
-
-            def on_next(value: _T):
-                nonlocal running
-
-                with source.lock:
-                    if not running:
-                        return
-
-                    try:
-                        running = predicate(value)
-                    except Exception as exn:
-                        observer.on_error(exn)
-                        return
-
-                if running:
+    source: Observable[_T],
+    predicate: Predicate[_T],
+    inclusive: bool = False,
+) -> Observable[_T]:
+    """Returns elements from an observable sequence as long as a
+    specified condition is true.
+
+    Examples:
+        >>> result = source.pipe(take_while(lambda x: x < 10))
+        >>> result = take_while(lambda x: x < 10)(source)
+        >>> result = source.pipe(take_while(lambda x: x < 10, inclusive=True))
+
+    Args:
+        source: The source observable to take from.
+        predicate: A function to test each element for a condition.
+        inclusive: Include the element that fails the predicate.
+
+    Returns:
+        An observable sequence that contains the elements from the
+        input sequence that occur before the element at which the
+        test no longer passes.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        running = True
+
+        def on_next(value: _T):
+            nonlocal running
+
+            with source.lock:
+                if not running:
+                    return
+
+                try:
+                    running = predicate(value)
+                except Exception as exn:
+                    observer.on_error(exn)
+                    return
+
+            if running:
+                observer.on_next(value)
+            else:
+                if inclusive:
                     observer.on_next(value)
-                else:
-                    if inclusive:
-                        observer.on_next(value)
-                    observer.on_completed()
-
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+                observer.on_completed()
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return take_while
+    return Observable(subscribe)
 
 
+@curry_flip
 def take_while_indexed_(
-    predicate: PredicateIndexed[_T], inclusive: bool = False
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def take_while_indexed(source: Observable[_T]) -> Observable[_T]:
-        """Returns elements from an observable sequence as long as a
-        specified condition is true. The element's index is used in the
-        logic of the predicate function.
-
-        Example:
-            >>> take_while(source)
-
-        Args:
-            source: Source observable to take from.
-
-        Returns:
-            An observable sequence that contains the elements from the
-            input sequence that occur before the element at which the
-            test no longer passes.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            running = True
-            i = 0
-
-            def on_next(value: Any) -> None:
-                nonlocal running, i
-
-                with source.lock:
-                    if not running:
-                        return
-
-                    try:
-                        running = predicate(value, i)
-                    except Exception as exn:
-                        observer.on_error(exn)
-                        return
-                    else:
-                        i += 1
-
-                if running:
-                    observer.on_next(value)
+    source: Observable[_T],
+    predicate: PredicateIndexed[_T],
+    inclusive: bool = False,
+) -> Observable[_T]:
+    """Returns elements from an observable sequence as long as a
+    specified condition is true. The element's index is used in the
+    logic of the predicate function.
+
+    Examples:
+        >>> result = source.pipe(take_while_indexed(lambda x, i: i < 10))
+        >>> result = take_while_indexed(lambda x, i: i < 10)(source)
+
+    Args:
+        source: Source observable to take from.
+        predicate: A function to test each element with its index.
+        inclusive: Include the element that fails the predicate.
+
+    Returns:
+        An observable sequence that contains the elements from the
+        input sequence that occur before the element at which the
+        test no longer passes.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        running = True
+        i = 0
+
+        def on_next(value: Any) -> None:
+            nonlocal running, i
+
+            with source.lock:
+                if not running:
+                    return
+
+                try:
+                    running = predicate(value, i)
+                except Exception as exn:
+                    observer.on_error(exn)
+                    return
                 else:
-                    if inclusive:
-                        observer.on_next(value)
-                    observer.on_completed()
+                    i += 1
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if running:
+                observer.on_next(value)
+            else:
+                if inclusive:
+                    observer.on_next(value)
+                observer.on_completed()
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return take_while_indexed
+    return Observable(subscribe)
 
 
 __all__ = ["take_while_", "take_while_indexed_"]