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

reactivex/operators/_expand.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, List, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import (
@@ -6,97 +6,102 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
+from reactivex.internal import curry_flip
 from reactivex.scheduler import ImmediateScheduler
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def expand_(
-    mapper: typing.Mapper[_T, Observable[_T]]
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def expand(source: Observable[_T]) -> Observable[_T]:
-        """Expands an observable sequence by recursively invoking
-        mapper.
-
-        Args:
-            source: Source obserable to expand.
-
-        Returns:
-            An observable sequence containing all the elements produced
-            by the recursive expansion.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            scheduler = scheduler or ImmediateScheduler.singleton()
-
-            queue: List[Observable[_T]] = []
-            m = SerialDisposable()
-            d = CompositeDisposable(m)
-            active_count = 0
-            is_acquired = False
-
-            def ensure_active():
-                nonlocal is_acquired
-
-                is_owner = False
-                if queue:
-                    is_owner = not is_acquired
-                    is_acquired = True
-
-                def action(scheduler: abc.SchedulerBase, state: Any = None):
-                    nonlocal is_acquired, active_count
+    source: Observable[_T],
+    mapper: typing.Mapper[_T, Observable[_T]],
+) -> Observable[_T]:
+    """Expands an observable sequence by recursively invoking
+    mapper.
+
+    Examples:
+        >>> source.pipe(expand(lambda x: of(x * 2)))
+        >>> expand(lambda x: of(x * 2))(source)
+
+    Args:
+        source: Source observable to expand.
+        mapper: Function to recursively map elements.
+
+    Returns:
+        An observable sequence containing all the elements produced
+        by the recursive expansion.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        scheduler = scheduler or ImmediateScheduler.singleton()
+
+        queue: list[Observable[_T]] = []
+        m = SerialDisposable()
+        d = CompositeDisposable(m)
+        active_count = 0
+        is_acquired = False
+
+        def ensure_active():
+            nonlocal is_acquired
+
+            is_owner = False
+            if queue:
+                is_owner = not is_acquired
+                is_acquired = True
+
+            def action(scheduler: abc.SchedulerBase, state: Any = None):
+                nonlocal is_acquired, active_count
 
-                    if queue:
-                        work = queue.pop(0)
-                    else:
-                        is_acquired = False
+                if queue:
+                    work = queue.pop(0)
+                else:
+                    is_acquired = False
+                    return
+
+                sad = SingleAssignmentDisposable()
+                d.add(sad)
+
+                def on_next(value: _T) -> None:
+                    nonlocal active_count
+
+                    observer.on_next(value)
+                    result = None
+                    try:
+                        result = mapper(value)
+                    except Exception as ex:
+                        observer.on_error(ex)
                         return
 
-                    sad = SingleAssignmentDisposable()
-                    d.add(sad)
-
-                    def on_next(value: _T) -> None:
-                        nonlocal active_count
-
-                        observer.on_next(value)
-                        result = None
-                        try:
-                            result = mapper(value)
-                        except Exception as ex:
-                            observer.on_error(ex)
-                            return
-
-                        queue.append(result)
-                        active_count += 1
-                        ensure_active()
-
-                    def on_complete() -> None:
-                        nonlocal active_count
+                    queue.append(result)
+                    active_count += 1
+                    ensure_active()
 
-                        d.remove(sad)
-                        active_count -= 1
-                        if active_count == 0:
-                            observer.on_completed()
+                def on_complete() -> None:
+                    nonlocal active_count
 
-                    sad.disposable = work.subscribe(
-                        on_next, observer.on_error, on_complete, scheduler=scheduler
-                    )
-                    m.disposable = scheduler.schedule(action)
+                    d.remove(sad)
+                    active_count -= 1
+                    if active_count == 0:
+                        observer.on_completed()
 
-                if is_owner:
-                    m.disposable = scheduler.schedule(action)
+                sad.disposable = work.subscribe(
+                    on_next, observer.on_error, on_complete, scheduler=scheduler
+                )
+                m.disposable = scheduler.schedule(action)
 
-            queue.append(source)
-            active_count += 1
-            ensure_active()
-            return d
+            if is_owner:
+                m.disposable = scheduler.schedule(action)
 
-        return Observable(subscribe)
+        queue.append(source)
+        active_count += 1
+        ensure_active()
+        return d
 
-    return expand
+    return Observable(subscribe)
 
 
 __all__ = ["expand_"]

reactivex/operators/_filter.py

@@ -1,98 +1,93 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 from reactivex.typing import Predicate, PredicateIndexed
 
 _T = TypeVar("_T")
 
 
 # pylint: disable=redefined-builtin
-def filter_(predicate: Predicate[_T]) -> Callable[[Observable[_T]], Observable[_T]]:
-    def filter(source: Observable[_T]) -> Observable[_T]:
-        """Partially applied filter operator.
+@curry_flip
+def filter_(source: Observable[_T], predicate: Predicate[_T]) -> Observable[_T]:
+    """Filters the elements of an observable sequence based on a predicate.
 
-        Filters the elements of an observable sequence based on a
-        predicate.
+    Example:
+        >>> result = source.pipe(filter(lambda x: x > 5))
+        >>> result = filter(lambda x: x > 5)(source)
 
-        Example:
-            >>> filter(source)
+    Args:
+        source: Source observable to filter.
+        predicate: A function to test each element for a condition.
 
-        Args:
-            source: Source observable to filter.
+    Returns:
+        A filtered observable sequence.
+    """
 
-        Returns:
-            A filtered observable sequence.
-        """
+    def subscribe(
+        observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None
+    ) -> abc.DisposableBase:
+        def on_next(value: _T):
+            try:
+                should_run = predicate(value)
+            except Exception as ex:  # pylint: disable=broad-except
+                observer.on_error(ex)
+                return
 
-        def subscribe(
-            observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase]
-        ) -> abc.DisposableBase:
-            def on_next(value: _T):
-                try:
-                    should_run = predicate(value)
-                except Exception as ex:  # pylint: disable=broad-except
-                    observer.on_error(ex)
-                    return
-
-                if should_run:
-                    observer.on_next(value)
-
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if should_run:
+                observer.on_next(value)
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return filter
+    return Observable(subscribe)
 
 
+@curry_flip
 def filter_indexed_(
-    predicate_indexed: Optional[PredicateIndexed[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
-    def filter_indexed(source: Observable[_T]) -> Observable[_T]:
-        """Partially applied indexed filter operator.
+    source: Observable[_T],
+    predicate_indexed: PredicateIndexed[_T] | None = None,
+) -> Observable[_T]:
+    """Filters the elements of an observable sequence based on a predicate
+    by incorporating the element's index.
 
-        Filters the elements of an observable sequence based on a
-        predicate by incorporating the element's index.
+    Example:
+        >>> result = source.pipe(filter_indexed(lambda x, i: i % 2 == 0))
+        >>> result = filter_indexed(lambda x, i: i % 2 == 0)(source)
 
-        Example:
-            >>> filter_indexed(source)
+    Args:
+        source: Source observable to filter.
+        predicate_indexed: A function to test each element with its index.
 
-        Args:
-            source: Source observable to filter.
+    Returns:
+        A filtered observable sequence.
+    """
 
-        Returns:
-            A filtered observable sequence.
-        """
+    def subscribe(observer: abc.ObserverBase[_T], scheduler: abc.SchedulerBase | None):
+        count = 0
 
-        def subscribe(
-            observer: abc.ObserverBase[_T], scheduler: Optional[abc.SchedulerBase]
-        ):
-            count = 0
+        def on_next(value: _T):
+            nonlocal count
+            should_run = True
 
-            def on_next(value: _T):
-                nonlocal count
-                should_run = True
-
-                if predicate_indexed:
-                    try:
-                        should_run = predicate_indexed(value, count)
-                    except Exception as ex:  # pylint: disable=broad-except
-                        observer.on_error(ex)
-                        return
-                    else:
-                        count += 1
-
-                if should_run:
-                    observer.on_next(value)
+            if predicate_indexed:
+                try:
+                    should_run = predicate_indexed(value, count)
+                except Exception as ex:  # pylint: disable=broad-except
+                    observer.on_error(ex)
+                    return
+                else:
+                    count += 1
 
-            return source.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
+            if should_run:
+                observer.on_next(value)
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
 
-    return filter_indexed
+    return Observable(subscribe)
 
 
 __all__ = ["filter_", "filter_indexed_"]

reactivex/operators/_finallyaction.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import Disposable
@@ -26,7 +27,7 @@ def finally_action_(
 
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             try:
                 subscription = source.subscribe(observer, scheduler=scheduler)

reactivex/operators/_find.py

@@ -1,46 +1,63 @@
-from typing import Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def find_value_(
-    predicate: Callable[[_T, int, Observable[_T]], bool], yield_index: bool
-) -> Callable[[Observable[_T]], Observable[Union[_T, int, None]]]:
-    def find_value(source: Observable[_T]) -> Observable[Union[_T, int, None]]:
-        def subscribe(
-            observer: abc.ObserverBase[Union[_T, int, None]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            index = 0
-
-            def on_next(x: _T) -> None:
-                nonlocal index
-                should_run = False
-                try:
-                    should_run = predicate(x, index, source)
-                except Exception as ex:  # pylint: disable=broad-except
-                    observer.on_error(ex)
-                    return
-
-                if should_run:
-                    observer.on_next(index if yield_index else x)
-                    observer.on_completed()
-                else:
-                    index += 1
-
-            def on_completed():
-                observer.on_next(-1 if yield_index else None)
+    source: Observable[_T],
+    predicate: Callable[[_T, int, Observable[_T]], bool],
+    yield_index: bool,
+) -> Observable[_T | int | None]:
+    """Searches for an element in an observable sequence.
+
+    Examples:
+        >>> res = source.pipe(find_value(lambda x, i, s: x > 3, False))
+        >>> res = find_value(lambda x, i, s: x > 3, False)(source)
+
+    Args:
+        source: The source observable sequence.
+        predicate: A function to test each element.
+        yield_index: Whether to yield the index or the value.
+
+    Returns:
+        An observable sequence containing the found element or index.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[_T | int | None],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        index = 0
+
+        def on_next(x: _T) -> None:
+            nonlocal index
+            should_run = False
+            try:
+                should_run = predicate(x, index, source)
+            except Exception as ex:  # pylint: disable=broad-except
+                observer.on_error(ex)
+                return
+
+            if should_run:
+                observer.on_next(index if yield_index else x)
                 observer.on_completed()
+            else:
+                index += 1
 
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
+        def on_completed():
+            observer.on_next(-1 if yield_index else None)
+            observer.on_completed()
 
-        return Observable(subscribe)
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
 
-    return find_value
+    return Observable(subscribe)
 
 
 __all__ = ["find_value_"]

reactivex/operators/_first.py

@@ -1,7 +1,8 @@
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar, cast
 
-from reactivex import Observable, compose
+from reactivex import Observable
 from reactivex import operators as ops
+from reactivex.internal import curry_flip
 from reactivex.typing import Predicate
 
 from ._firstordefault import first_or_default_async_
@@ -9,32 +10,38 @@ from ._firstordefault import first_or_default_async_
 _T = TypeVar("_T")
 
 
+@curry_flip
 def first_(
-    predicate: Optional[Predicate[_T]] = None,
-) -> Callable[[Observable[_T]], Observable[_T]]:
+    source: Observable[_T],
+    predicate: Predicate[_T] | None = None,
+) -> Observable[_T]:
     """Returns the first element of an observable sequence that
     satisfies the condition in the predicate if present else the first
     item in the sequence.
 
     Examples:
-        >>> res = res = first()(source)
-        >>> res = res = first(lambda x: x > 3)(source)
+        >>> res = source.pipe(first())
+        >>> res = first()(source)
+        >>> res = source.pipe(first(lambda x: x > 3))
 
     Args:
-        predicate -- [Optional] A predicate function to evaluate for
+        source: The source observable sequence.
+        predicate: [Optional] A predicate function to evaluate for
             elements in the source sequence.
 
     Returns:
-        A function that takes an observable source and returns an
-        observable sequence containing the first element in the
+        An observable sequence containing the first element in the
         observable sequence that satisfies the condition in the predicate if
         provided, else the first item in the sequence.
     """
 
     if predicate:
-        return compose(ops.filter(predicate), ops.first())
+        return source.pipe(ops.filter(predicate), ops.first())
 
-    return first_or_default_async_(False)
+    # first_or_default_async_(False) returns
+    # Callable[[Observable[_T]], Observable[_T]] but the type checker
+    # cannot infer it. This cast is safe - implementation preserves type.
+    return cast(Observable[_T], first_or_default_async_(False)(source))
 
 
 __all__ = ["first_"]

reactivex/operators/_firstordefault.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc, compose
 from reactivex import operators as ops
@@ -9,12 +10,12 @@ _T = TypeVar("_T")
 
 
 def first_or_default_async_(
-    has_default: bool = False, default_value: Optional[_T] = None
+    has_default: bool = False, default_value: _T | None = None
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     def first_or_default_async(source: Observable[_T]) -> Observable[_T]:
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ):
             def on_next(x: _T):
                 observer.on_next(x)
@@ -37,7 +38,7 @@ def first_or_default_async_(
 
 
 def first_or_default_(
-    predicate: Optional[Predicate[_T]] = None, default_value: Optional[_T] = None
+    predicate: Predicate[_T] | None = None, default_value: _T | None = None
 ) -> Callable[[Observable[_T]], Observable[_T]]:
     """Returns the first element of an observable sequence that
     satisfies the condition in the predicate, or a default value if no