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

reactivex/operators/_defaultifempty.py

@@ -1,52 +1,55 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def default_if_empty_(
-    default_value: Optional[_T] = None,
-) -> Callable[[Observable[_T]], Observable[Optional[_T]]]:
-    def default_if_empty(source: Observable[_T]) -> Observable[Optional[_T]]:
-        """Returns the elements of the specified sequence or the
-        specified value in a singleton sequence if the sequence is
-        empty.
-
-        Examples:
-            >>> obs = default_if_empty(source)
-
-        Args:
-            source: Source observable.
-
-        Returns:
-            An observable sequence that contains the specified default
-            value if the source is empty otherwise, the elements of the
-            source.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[Optional[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            found = [False]
-
-            def on_next(x: _T):
-                found[0] = True
-                observer.on_next(x)
-
-            def on_completed():
-                if not found[0]:
-                    observer.on_next(default_value)
-                observer.on_completed()
-
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
-
-        return Observable(subscribe)
-
-    return default_if_empty
+    source: Observable[_T],
+    default_value: _T | None = None,
+) -> Observable[_T | None]:
+    """Returns the elements of the specified sequence or the
+    specified value in a singleton sequence if the sequence is
+    empty.
+
+    Examples:
+        >>> obs = source.pipe(default_if_empty())
+        >>> obs = default_if_empty()(source)
+        >>> obs = source.pipe(default_if_empty(42))
+
+    Args:
+        source: Source observable.
+        default_value: The value to return if the sequence is empty.
+
+    Returns:
+        An observable sequence that contains the specified default
+        value if the source is empty otherwise, the elements of the
+        source.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T | None],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        found = [False]
+
+        def on_next(x: _T):
+            found[0] = True
+            observer.on_next(x)
+
+        def on_completed():
+            if not found[0]:
+                observer.on_next(default_value)
+            observer.on_completed()
+
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["default_if_empty_"]

reactivex/operators/_delay.py

@@ -1,14 +1,14 @@
 from datetime import datetime
-from typing import Any, Callable, List, Optional, TypeVar
+from typing import Any, TypeVar
 
-from reactivex import Notification, Observable, abc
+from reactivex import Notification, Observable, abc, typing
 from reactivex import operators as ops
-from reactivex import typing
 from reactivex.disposable import (
     CompositeDisposable,
     MultipleAssignmentDisposable,
     SerialDisposable,
 )
+from reactivex.internal import curry_flip
 from reactivex.internal.constants import DELTA_ZERO
 from reactivex.notification import OnError
 from reactivex.scheduler import TimeoutScheduler
@@ -21,10 +21,10 @@ _T = TypeVar("_T")
 def observable_delay_timespan(
     source: Observable[_T],
     duetime: typing.RelativeTime,
-    scheduler: Optional[abc.SchedulerBase] = None,
+    scheduler: abc.SchedulerBase | None = None,
 ) -> Observable[_T]:
     def subscribe(
-        observer: abc.ObserverBase[_T], scheduler_: Optional[abc.SchedulerBase] = None
+        observer: abc.ObserverBase[_T], scheduler_: abc.SchedulerBase | None = None
     ):
         nonlocal duetime
 
@@ -36,10 +36,10 @@ def observable_delay_timespan(
             duetime_ = _scheduler.to_timedelta(duetime)
 
         cancelable = SerialDisposable()
-        exception: Optional[Exception] = None
+        exception: Exception | None = None
         active = [False]
         running = [False]
-        queue: List[Timestamp[Notification[_T]]] = []
+        queue: list[Timestamp[Notification[_T]]] = []
 
         def on_next(notification: Timestamp[Notification[_T]]) -> None:
             nonlocal exception
@@ -116,26 +116,27 @@ def observable_delay_timespan(
     return Observable(subscribe)
 
 
+@curry_flip
 def delay_(
-    duetime: typing.RelativeTime, scheduler: Optional[abc.SchedulerBase] = None
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def delay(source: Observable[_T]) -> Observable[_T]:
-        """Time shifts the observable sequence.
-
-        A partially applied delay operator function.
-
-        Examples:
-            >>> res = delay(source)
+    source: Observable[_T],
+    duetime: typing.RelativeTime,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Time shifts the observable sequence.
 
-        Args:
-            source: The observable sequence to delay.
+    Examples:
+        >>> res = source.pipe(delay(5.0))
+        >>> res = delay(5.0)(source)
 
-        Returns:
-            A time-shifted observable sequence.
-        """
-        return observable_delay_timespan(source, duetime, scheduler)
+    Args:
+        source: The observable sequence to delay.
+        duetime: Time to shift the sequence by.
+        scheduler: Scheduler to use for time operations.
 
-    return delay
+    Returns:
+        A time-shifted observable sequence.
+    """
+    return observable_delay_timespan(source, duetime, scheduler)
 
 
 __all__ = ["delay_"]

reactivex/operators/_delaysubscription.py

@@ -1,38 +1,40 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 import reactivex
-from reactivex import Observable, abc
+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 delay_subscription_(
+    source: Observable[_T],
     duetime: typing.AbsoluteOrRelativeTime,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def delay_subscription(source: Observable[_T]) -> Observable[_T]:
-        """Time shifts the observable sequence by delaying the subscription.
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[_T]:
+    """Time shifts the observable sequence by delaying the subscription.
 
-        Exampeles.
-            >>> res = source.delay_subscription(5)
+    Examples:
+        >>> source.pipe(delay_subscription(5))
+        >>> delay_subscription(5)(source)
 
-        Args:
-            source: Source subscription to delay.
+    Args:
+        source: Source subscription to delay.
+        duetime: Time to delay subscription.
+        scheduler: Scheduler to use for timing.
 
-        Returns:
-            Time-shifted sequence.
-        """
+    Returns:
+        Time-shifted sequence.
+    """
 
-        def mapper(_: Any) -> Observable[_T]:
-            return reactivex.empty()
+    def mapper(_: Any) -> Observable[_T]:
+        return reactivex.empty()
 
-        return source.pipe(
-            ops.delay_with_mapper(reactivex.timer(duetime, scheduler=scheduler), mapper)
-        )
-
-    return delay_subscription
+    return source.pipe(
+        ops.delay_with_mapper(reactivex.timer(duetime, scheduler=scheduler), mapper)
+    )
 
 
 __all__ = ["delay_subscription_"]

reactivex/operators/_delaywithmapper.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import (
@@ -11,12 +12,10 @@ _T = TypeVar("_T")
 
 
 def delay_with_mapper_(
-    subscription_delay: Union[
-        Observable[Any],
-        typing.Mapper[Any, Observable[Any]],
-        None,
-    ] = None,
-    delay_duration_mapper: Optional[typing.Mapper[_T, Observable[Any]]] = None,
+    subscription_delay: Observable[Any]
+    | typing.Mapper[Any, Observable[Any]]
+    | None = None,
+    delay_duration_mapper: typing.Mapper[_T, Observable[Any]] | None = None,
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     def delay_with_mapper(source: Observable[_T]) -> Observable[_T]:
         """Time shifts the observable sequence based on a subscription
@@ -35,18 +34,18 @@ def delay_with_mapper_(
         Returns:
             Time-shifted observable sequence.
         """
-        sub_delay: Optional[Observable[Any]] = None
-        mapper: Optional[typing.Mapper[Any, Observable[Any]]] = None
+        sub_delay: Observable[Any] | None = None
+        mapper: typing.Mapper[Any, Observable[Any]] | None = None
 
         if isinstance(subscription_delay, abc.ObservableBase):
             mapper = delay_duration_mapper
-            sub_delay = subscription_delay
+            sub_delay = cast(Observable[Any], subscription_delay)
         else:
             mapper = subscription_delay
 
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             delays = CompositeDisposable()
             at_end = [False]

reactivex/operators/_dematerialize.py

@@ -1,36 +1,40 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Notification, Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def dematerialize_() -> Callable[[Observable[Notification[_T]]], Observable[_T]]:
-    def dematerialize(source: Observable[Notification[_T]]) -> Observable[_T]:
-        """Partially applied dematerialize operator.
+@curry_flip
+def dematerialize_(source: Observable[Notification[_T]]) -> Observable[_T]:
+    """Dematerializes the explicit notification values of an
+    observable sequence as implicit notifications.
 
-        Dematerializes the explicit notification values of an
-        observable sequence as implicit notifications.
+    Examples:
+        >>> res = source.pipe(dematerialize())
+        >>> res = dematerialize()(source)
 
-        Returns:
-            An observable sequence exhibiting the behavior
-            corresponding to the source sequence's notification values.
-        """
+    Args:
+        source: Source observable with notifications to dematerialize.
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            def on_next(value: Notification[_T]) -> None:
-                return value.accept(observer)
+    Returns:
+        An observable sequence exhibiting the behavior
+        corresponding to the source sequence's notification values.
+    """
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        def on_next(value: Notification[_T]) -> None:
+            return value.accept(observer)
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return dematerialize
+    return Observable(subscribe)
 
 
 __all__ = ["dematerialize_"]

reactivex/operators/_distinct.py

@@ -1,6 +1,7 @@
-from typing import Callable, Generic, List, Optional, TypeVar, cast
+from typing import Generic, TypeVar, cast
 
 from reactivex import Observable, abc, typing
+from reactivex.internal import curry_flip
 from reactivex.internal.basic import default_comparer
 
 _T = TypeVar("_T")
@@ -8,7 +9,7 @@ _TKey = TypeVar("_TKey")
 
 
 def array_index_of_comparer(
-    array: List[_TKey], item: _TKey, comparer: typing.Comparer[_TKey]
+    array: list[_TKey], item: _TKey, comparer: typing.Comparer[_TKey]
 ):
     for i, a in enumerate(array):
         if comparer(a, item):
@@ -19,7 +20,7 @@ def array_index_of_comparer(
 class HashSet(Generic[_TKey]):
     def __init__(self, comparer: typing.Comparer[_TKey]):
         self.comparer = comparer
-        self.set: List[_TKey] = []
+        self.set: list[_TKey] = []
 
     def push(self, value: _TKey):
         ret_value = array_index_of_comparer(self.set, value, self.comparer) == -1
@@ -28,57 +29,60 @@ class HashSet(Generic[_TKey]):
         return ret_value
 
 
+@curry_flip
 def distinct_(
-    key_mapper: Optional[typing.Mapper[_T, _TKey]] = None,
-    comparer: Optional[typing.Comparer[_TKey]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    key_mapper: typing.Mapper[_T, _TKey] | None = None,
+    comparer: typing.Comparer[_TKey] | None = None,
+) -> Observable[_T]:
+    """Returns an observable sequence that contains only distinct elements.
+
+    Returns an observable sequence that contains only distinct
+    elements according to the key_mapper and the comparer. Usage of
+    this operator should be considered carefully due to the
+    maintenance of an internal lookup structure which can grow large.
+
+    Examples:
+        >>> result = source.pipe(distinct())
+        >>> result = distinct()(source)
+        >>> result = source.pipe(distinct(lambda x: x.id))
+
+    Args:
+        source: Source observable to return distinct items from.
+        key_mapper: Optional function to compute a comparison key.
+        comparer: Optional equality comparer for computed keys.
+
+    Returns:
+        An observable sequence only containing the distinct
+        elements, based on a computed key value, from the source
+        sequence.
+    """
     comparer_ = comparer or cast(typing.Comparer[_TKey], default_comparer)
 
-    def distinct(source: Observable[_T]) -> Observable[_T]:
-        """Returns an observable sequence that contains only distinct
-        elements according to the key_mapper and the comparer. Usage of
-        this operator should be considered carefully due to the
-        maintenance of an internal lookup structure which can grow
-        large.
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        hashset = HashSet(comparer_)
 
-        Examples:
-            >>> res = obs = distinct(source)
+        def on_next(x: _T) -> None:
+            key = cast(_TKey, x)
 
-        Args:
-            source: Source observable to return distinct items from.
+            if key_mapper:
+                try:
+                    key = key_mapper(x)
+                except Exception as ex:
+                    observer.on_error(ex)
+                    return
 
-        Returns:
-            An observable sequence only containing the distinct
-            elements, based on a computed key value, from the source
-            sequence.
-        """
+            if hashset.push(key):
+                observer.on_next(x)
 
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            hashset = HashSet(comparer_)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-            def on_next(x: _T) -> None:
-                key = cast(_TKey, x)
-
-                if key_mapper:
-                    try:
-                        key = key_mapper(x)
-                    except Exception as ex:
-                        observer.on_error(ex)
-                        return
-
-                if hashset.push(key):
-                    observer.on_next(x)
-
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
-
-        return Observable(subscribe)
-
-    return distinct
+    return Observable(subscribe)
 
 
 __all__ = ["distinct_"]

reactivex/operators/_distinctuntilchanged.py

@@ -1,6 +1,8 @@
-from typing import Callable, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 from reactivex.internal.basic import default_comparer, identity
 from reactivex.typing import Comparer, Mapper
 
@@ -8,73 +10,74 @@ _T = TypeVar("_T")
 _TKey = TypeVar("_TKey")
 
 
+@curry_flip
 def distinct_until_changed_(
-    key_mapper: Optional[Mapper[_T, _TKey]] = None,
-    comparer: Optional[Comparer[_TKey]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-
+    source: Observable[_T],
+    key_mapper: Mapper[_T, _TKey] | None = None,
+    comparer: Comparer[_TKey] | None = None,
+) -> Observable[_T]:
+    """Returns an observable sequence that contains only distinct
+    contiguous elements according to the key_mapper and the
+    comparer.
+
+    Examples:
+        >>> res = source.pipe(distinct_until_changed())
+        >>> res = distinct_until_changed()(source)
+        >>> res = source.pipe(distinct_until_changed(lambda x: x.id))
+        >>> res = source.pipe(
+        ...     distinct_until_changed(lambda x: x.id, lambda x, y: x == y)
+        ... )
+
+    Args:
+        source: The source observable sequence.
+        key_mapper: [Optional] A function to compute the comparison
+            key for each element. If not provided, it projects the
+            value.
+        comparer: [Optional] Equality comparer for computed key
+            values. If not provided, defaults to an equality
+            comparer function.
+
+    Returns:
+        An observable sequence only containing the distinct
+        contiguous elements, based on a computed key value, from
+        the source sequence.
+    """
     key_mapper_ = key_mapper or cast(Callable[[_T], _TKey], identity)
     comparer_ = comparer or default_comparer
 
-    def distinct_until_changed(source: Observable[_T]) -> Observable[_T]:
-        """Returns an observable sequence that contains only distinct
-        contiguous elements according to the key_mapper and the
-        comparer.
-
-        Examples:
-            >>> op = distinct_until_changed();
-            >>> op = distinct_until_changed(lambda x: x.id)
-            >>> op = distinct_until_changed(lambda x: x.id, lambda x, y: x == y)
-
-        Args:
-            key_mapper: [Optional] A function to compute the comparison
-                key for each element. If not provided, it projects the
-                value.
-            comparer: [Optional] Equality comparer for computed key
-                values. If not provided, defaults to an equality
-                comparer function.
-
-        Returns:
-            An observable sequence only containing the distinct
-            contiguous elements, based on a computed key value, from
-            the source sequence.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            has_current_key = False
-            current_key: _TKey = cast(_TKey, None)
-
-            def on_next(value: _T) -> None:
-                nonlocal has_current_key, current_key
-                comparer_equals = False
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        has_current_key = False
+        current_key: _TKey = cast(_TKey, None)
+
+        def on_next(value: _T) -> None:
+            nonlocal has_current_key, current_key
+            comparer_equals = False
+            try:
+                key = key_mapper_(value)
+            except Exception as exception:  # pylint: disable=broad-except
+                observer.on_error(exception)
+                return
+
+            if has_current_key:
                 try:
-                    key = key_mapper_(value)
+                    comparer_equals = comparer_(current_key, key)
                 except Exception as exception:  # pylint: disable=broad-except
                     observer.on_error(exception)
                     return
 
-                if has_current_key:
-                    try:
-                        comparer_equals = comparer_(current_key, key)
-                    except Exception as exception:  # pylint: disable=broad-except
-                        observer.on_error(exception)
-                        return
-
-                if not has_current_key or not comparer_equals:
-                    has_current_key = True
-                    current_key = key
-                    observer.on_next(value)
-
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if not has_current_key or not comparer_equals:
+                has_current_key = True
+                current_key = key
+                observer.on_next(value)
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return distinct_until_changed
+    return Observable(subscribe)
 
 
 __all__ = ["distinct_until_changed_"]