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

reactivex/operators/_takewithtime.py

@@ -1,53 +1,58 @@
-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_with_time_(
-    duration: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def take_with_time(source: Observable[_T]) -> Observable[_T]:
-        """Takes elements for the specified duration from the start of
-        the observable source sequence.
-
-        Example:
-            >>> res = take_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:
-            source: Source observable to take elements from.
-
-        Returns:
-            An observable sequence with the elements taken during the
-            specified duration from the start of the source sequence.
-        """
-
-        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()
-
-            disp = _scheduler.schedule_relative(duration, action)
-            return CompositeDisposable(
-                disp, source.subscribe(observer, scheduler=scheduler_)
-            )
-
-        return Observable(subscribe)
-
-    return take_with_time
+    source: Observable[_T],
+    duration: typing.RelativeTime,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Takes elements for the specified duration from the start of
+    the observable source sequence.
+
+    Examples:
+        >>> source.pipe(take_with_time(5.0))
+        >>> take_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 start of
+            the sequence.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence with the elements taken during the
+        specified duration from the start of the source sequence.
+    """
+
+    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()
+
+        disp = _scheduler.schedule_relative(duration, action)
+        return CompositeDisposable(
+            disp, source.subscribe(observer, scheduler=scheduler_)
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["take_with_time_"]

reactivex/operators/_throttlefirst.py

@@ -1,57 +1,64 @@
 from datetime import datetime
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc, typing
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def throttle_first_(
-    window_duration: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def throttle_first(source: Observable[_T]) -> Observable[_T]:
-        """Returns an observable that emits only the first item emitted
-        by the source Observable during sequential time windows of a
-        specified duration.
-
-        Args:
-            source: Source observable to throttle.
-
-        Returns:
-            An Observable that performs the throttle operation.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-
-            duration = _scheduler.to_timedelta(window_duration or 0.0)
-            if duration <= _scheduler.to_timedelta(0):
-                raise ValueError("window_duration cannot be less or equal zero.")
-            last_on_next: Optional[datetime] = None
-
-            def on_next(x: _T) -> None:
-                nonlocal last_on_next
-                emit = False
-                now = _scheduler.now
-
-                with source.lock:
-                    if not last_on_next or now - last_on_next >= duration:
-                        last_on_next = now
-                        emit = True
-                if emit:
-                    observer.on_next(x)
-
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=_scheduler
-            )
-
-        return Observable(subscribe)
-
-    return throttle_first
+    source: Observable[_T],
+    window_duration: typing.RelativeTime,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Returns an observable that emits only the first item emitted
+    by the source Observable during sequential time windows of a
+    specified duration.
+
+    Examples:
+        >>> result = source.pipe(throttle_first(1.0))
+        >>> result = throttle_first(1.0)(source)
+
+    Args:
+        source: Source observable to throttle.
+        window_duration: Duration of windows during which to throttle.
+        scheduler: Optional scheduler to use for timing.
+
+    Returns:
+        An Observable that performs the throttle operation.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+
+        duration = _scheduler.to_timedelta(window_duration or 0.0)
+        if duration <= _scheduler.to_timedelta(0):
+            raise ValueError("window_duration cannot be less or equal zero.")
+        last_on_next: datetime | None = None
+
+        def on_next(x: _T) -> None:
+            nonlocal last_on_next
+            emit = False
+            now = _scheduler.now
+
+            with source.lock:
+                if not last_on_next or now - last_on_next >= duration:
+                    last_on_next = now
+                    emit = True
+            if emit:
+                observer.on_next(x)
+
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=_scheduler
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["throttle_first_"]

reactivex/operators/_timeinterval.py

@@ -1,9 +1,10 @@
 from dataclasses import dataclass
 from datetime import timedelta
-from typing import Callable, Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from reactivex import Observable, abc
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
@@ -15,39 +16,42 @@ class TimeInterval(Generic[_T]):
     interval: timedelta
 
 
+@curry_flip
 def time_interval_(
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[TimeInterval[_T]]]:
-    def time_interval(source: Observable[_T]) -> Observable[TimeInterval[_T]]:
-        """Records the time interval between consecutive values in an
-        observable sequence.
-
-            >>> res = time_interval(source)
-
-        Return:
-            An observable sequence with time interval information on
-            values.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[TimeInterval[_T]],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-            last = _scheduler.now
-
-            def mapper(value: _T) -> TimeInterval[_T]:
-                nonlocal last
-
-                now = _scheduler.now
-                span = now - last
-                last = now
-                return TimeInterval(value=value, interval=span)
-
-            return source.pipe(ops.map(mapper)).subscribe(
-                observer, scheduler=_scheduler
-            )
-
-        return Observable(subscribe)
-
-    return time_interval
+    source: Observable[_T],
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[TimeInterval[_T]]:
+    """Records the time interval between consecutive values in an
+    observable sequence.
+
+    Examples:
+        >>> res = source.pipe(time_interval())
+        >>> res = time_interval()(source)
+
+    Args:
+        source: The source observable sequence.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence with time interval information on
+        values.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[TimeInterval[_T]],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+        last = _scheduler.now
+
+        def mapper(value: _T) -> TimeInterval[_T]:
+            nonlocal last
+
+            now = _scheduler.now
+            span = now - last
+            last = now
+            return TimeInterval(value=value, interval=span)
+
+        return source.pipe(ops.map(mapper)).subscribe(observer, scheduler=_scheduler)
+
+    return Observable(subscribe)

reactivex/operators/_timeout.py

@@ -1,6 +1,6 @@
 from asyncio import Future
 from datetime import datetime
-from typing import Any, Callable, Optional, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from reactivex import Observable, abc, from_future, throw, typing
 from reactivex.disposable import (
@@ -8,94 +8,96 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def timeout_(
+    source: Observable[_T],
     duetime: typing.AbsoluteOrRelativeTime,
-    other: Optional[Union[Observable[_T], "Future[_T]"]] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-
+    other: Union[Observable[_T], "Future[_T]"] | None = None,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Returns the source observable sequence or the other observable
+    sequence if duetime elapses.
+
+    Examples:
+        >>> source.pipe(timeout(5.0))
+        >>> timeout(5.0)(source)
+
+    Args:
+        source: Source observable to timeout.
+        duetime: Timeout duration.
+        other: Observable to switch to on timeout.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence switching to the other sequence in
+        case of a timeout.
+    """
     other = other or throw(Exception("Timeout"))
     if isinstance(other, Future):
         obs = from_future(other)
     else:
         obs = other
 
-    def timeout(source: Observable[_T]) -> Observable[_T]:
-        """Returns the source observable sequence or the other observable
-        sequence if duetime elapses.
-
-        Examples:
-            >>> res = timeout(source)
-
-        Args:
-            source: Source observable to timeout
-
-        Returns:
-            An observable sequence switching to the other sequence in
-            case of a timeout.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-
-            switched = [False]
-            _id = [0]
-
-            original = SingleAssignmentDisposable()
-            subscription = SerialDisposable()
-            timer = SerialDisposable()
-            subscription.disposable = original
-
-            def create_timer() -> None:
-                my_id = _id[0]
-
-                def action(scheduler: abc.SchedulerBase, state: Any = None):
-                    switched[0] = _id[0] == my_id
-                    timer_wins = switched[0]
-                    if timer_wins:
-                        subscription.disposable = obs.subscribe(
-                            observer, scheduler=scheduler
-                        )
-
-                if isinstance(duetime, datetime):
-                    timer.disposable = _scheduler.schedule_absolute(duetime, action)
-                else:
-                    timer.disposable = _scheduler.schedule_relative(duetime, action)
-
-            create_timer()
-
-            def on_next(value: _T) -> None:
-                send_wins = not switched[0]
-                if send_wins:
-                    _id[0] += 1
-                    observer.on_next(value)
-                    create_timer()
-
-            def on_error(error: Exception) -> None:
-                on_error_wins = not switched[0]
-                if on_error_wins:
-                    _id[0] += 1
-                    observer.on_error(error)
-
-            def on_completed() -> None:
-                on_completed_wins = not switched[0]
-                if on_completed_wins:
-                    _id[0] += 1
-                    observer.on_completed()
-
-            original.disposable = source.subscribe(
-                on_next, on_error, on_completed, scheduler=scheduler_
-            )
-            return CompositeDisposable(subscription, timer)
-
-        return Observable(subscribe)
-
-    return timeout
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+
+        switched = [False]
+        _id = [0]
+
+        original = SingleAssignmentDisposable()
+        subscription = SerialDisposable()
+        timer = SerialDisposable()
+        subscription.disposable = original
+
+        def create_timer() -> None:
+            my_id = _id[0]
+
+            def action(scheduler: abc.SchedulerBase, state: Any = None):
+                switched[0] = _id[0] == my_id
+                timer_wins = switched[0]
+                if timer_wins:
+                    subscription.disposable = obs.subscribe(
+                        observer, scheduler=scheduler
+                    )
+
+            if isinstance(duetime, datetime):
+                timer.disposable = _scheduler.schedule_absolute(duetime, action)
+            else:
+                timer.disposable = _scheduler.schedule_relative(duetime, action)
+
+        create_timer()
+
+        def on_next(value: _T) -> None:
+            send_wins = not switched[0]
+            if send_wins:
+                _id[0] += 1
+                observer.on_next(value)
+                create_timer()
+
+        def on_error(error: Exception) -> None:
+            on_error_wins = not switched[0]
+            if on_error_wins:
+                _id[0] += 1
+                observer.on_error(error)
+
+        def on_completed() -> None:
+            on_completed_wins = not switched[0]
+            if on_completed_wins:
+                _id[0] += 1
+                observer.on_completed()
+
+        original.disposable = source.subscribe(
+            on_next, on_error, on_completed, scheduler=scheduler_
+        )
+        return CompositeDisposable(subscription, timer)
+
+    return Observable(subscribe)

reactivex/operators/_timeoutwithmapper.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 import reactivex
 from reactivex import Observable, abc
@@ -12,9 +13,9 @@ _T = TypeVar("_T")
 
 
 def timeout_with_mapper_(
-    first_timeout: Optional[Observable[_T]] = None,
-    timeout_duration_mapper: Optional[Callable[[Any], Observable[Any]]] = None,
-    other: Optional[Observable[_T]] = None,
+    first_timeout: Observable[_T] | None = None,
+    timeout_duration_mapper: Callable[[Any], Observable[Any]] | None = None,
+    other: Observable[_T] | None = None,
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     """Returns the source observable sequence, switching to the other
     observable sequence if a timeout is signaled.
@@ -48,7 +49,7 @@ def timeout_with_mapper_(
     def timeout_with_mapper(source: Observable[_T]) -> Observable[_T]:
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             subscription = SerialDisposable()
             timer = SerialDisposable()

reactivex/operators/_timestamp.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Callable, Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from reactivex import Observable, abc, defer, operators
+from reactivex.internal import curry_flip
 from reactivex.scheduler import TimeoutScheduler
 
 _T = TypeVar("_T")
@@ -14,36 +15,37 @@ class Timestamp(Generic[_T]):
     timestamp: datetime
 
 
+@curry_flip
 def timestamp_(
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[Timestamp[_T]]]:
-    def timestamp(source: Observable[_T]) -> Observable[Timestamp[_T]]:
-        """Records the timestamp for each value in an observable sequence.
+    source: Observable[_T],
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[Timestamp[_T]]:
+    """Records the timestamp for each value in an observable sequence.
 
-        Examples:
-            >>> timestamp(source)
+    Examples:
+        >>> result = source.pipe(timestamp())
+        >>> result = timestamp()(source)
 
-        Produces objects with attributes `value` and `timestamp`, where
-        value is the original value.
+    Produces objects with attributes `value` and `timestamp`, where
+    value is the original value.
 
-        Args:
-            source: Observable source to timestamp.
+    Args:
+        source: Observable source to timestamp.
+        scheduler: Optional scheduler to use for timestamping.
 
-        Returns:
-            An observable sequence with timestamp information on values.
-        """
+    Returns:
+        An observable sequence with timestamp information on values.
+    """
 
-        def factory(scheduler_: Optional[abc.SchedulerBase] = None):
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+    def factory(scheduler_: abc.SchedulerBase | None = None):
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
 
-            def mapper(value: _T) -> Timestamp[_T]:
-                return Timestamp(value=value, timestamp=_scheduler.now)
+        def mapper(value: _T) -> Timestamp[_T]:
+            return Timestamp(value=value, timestamp=_scheduler.now)
 
-            return source.pipe(operators.map(mapper))
+        return source.pipe(operators.map(mapper))
 
-        return defer(factory)
-
-    return timestamp
+    return defer(factory)
 
 
 __all__ = ["timestamp_"]