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

reactivex/operators/_todict.py

@@ -1,6 +1,7 @@
-from typing import Callable, Dict, Optional, TypeVar, cast
+from typing import TypeVar, cast
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 from reactivex.typing import Mapper
 
 _T = TypeVar("_T")
@@ -8,57 +9,64 @@ _TKey = TypeVar("_TKey")
 _TValue = TypeVar("_TValue")
 
 
+@curry_flip
 def to_dict_(
-    key_mapper: Mapper[_T, _TKey], element_mapper: Optional[Mapper[_T, _TValue]] = None
-) -> Callable[[Observable[_T]], Observable[Dict[_TKey, _TValue]]]:
-    def to_dict(source: Observable[_T]) -> Observable[Dict[_TKey, _TValue]]:
-        """Converts the observable sequence to a Map if it exists.
-
-        Args:
-            source: Source observable to convert.
-
-        Returns:
-            An observable sequence with a single value of a dictionary
-            containing the values from the observable sequence.
-        """
-
-        def subscribe(
-            observer: abc.ObserverBase[Dict[_TKey, _TValue]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            m: Dict[_TKey, _TValue] = dict()
-
-            def on_next(x: _T) -> None:
+    source: Observable[_T],
+    key_mapper: Mapper[_T, _TKey],
+    element_mapper: Mapper[_T, _TValue] | None = None,
+) -> Observable[dict[_TKey, _TValue]]:
+    """Converts the observable sequence to a dictionary.
+
+    Examples:
+        >>> result = source.pipe(to_dict(lambda x: x.id))
+        >>> result = to_dict(lambda x: x.id)(source)
+        >>> result = source.pipe(to_dict(lambda x: x.id, lambda x: x.name))
+
+    Args:
+        source: Source observable to convert.
+        key_mapper: Function to extract the key from each element.
+        element_mapper: Optional function to extract the value from each element.
+
+    Returns:
+        An observable sequence with a single value of a dictionary
+        containing the values from the observable sequence.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[dict[_TKey, _TValue]],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        m: dict[_TKey, _TValue] = dict()
+
+        def on_next(x: _T) -> None:
+            try:
+                key = key_mapper(x)
+            except Exception as ex:  # pylint: disable=broad-except
+                observer.on_error(ex)
+                return
+
+            if element_mapper:
                 try:
-                    key = key_mapper(x)
+                    element = element_mapper(x)
                 except Exception as ex:  # pylint: disable=broad-except
                     observer.on_error(ex)
                     return
+            else:
+                element = cast(_TValue, x)
 
-                if element_mapper:
-                    try:
-                        element = element_mapper(x)
-                    except Exception as ex:  # pylint: disable=broad-except
-                        observer.on_error(ex)
-                        return
-                else:
-                    element = cast(_TValue, x)
+            m[key] = element
 
-                m[key] = element
+        def on_completed() -> None:
+            nonlocal m
+            observer.on_next(m)
+            m = dict()
+            observer.on_completed()
 
-            def on_completed() -> None:
-                nonlocal m
-                observer.on_next(m)
-                m = dict()
-                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 to_dict
+    return Observable(subscribe)
 
 
 __all__ = ["to_dict_"]

reactivex/operators/_tofuture.py

@@ -1,6 +1,7 @@
 import asyncio
 from asyncio import Future
-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.exceptions import SequenceContainsNoElementsError
@@ -9,15 +10,10 @@ _T = TypeVar("_T")
 
 
 def to_future_(
-    future_ctor: Optional[Callable[[], "Future[_T]"]] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], "Future[_T]"]:
-    future_ctor_: Callable[[], "Future[_T]"] = (
-        future_ctor or asyncio.get_event_loop().create_future
-    )
-    future: "Future[_T]" = future_ctor_()
-
-    def to_future(source: Observable[_T]) -> "Future[_T]":
+    future_ctor: Callable[[], Future[_T]] | None = None,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Callable[[Observable[_T]], Future[_T]]:
+    def to_future(source: Observable[_T]) -> Future[_T]:
         """Converts an existing observable sequence to a Future.
 
         If the observable emits a single item, then this item is set as the
@@ -33,25 +29,38 @@ def to_future_(
         Returns:
             A future with the last value from the observable sequence.
         """
+        if future_ctor is not None:
+            future_ctor_ = future_ctor
+        else:
+            try:
+                future_ctor_ = asyncio.get_running_loop().create_future
+            except RuntimeError:
+
+                def create_future() -> Future[_T]:
+                    return Future()  # Explicitly using Future[_T]
+
+                future_ctor_ = create_future  # If no running loop
+
+        future: Future[_T] = future_ctor_()
 
         has_value = False
-        last_value = cast(_T, None)
+        last_value: _T | None = None
 
-        def on_next(value: _T):
+        def on_next(value: _T) -> None:
             nonlocal last_value
             nonlocal has_value
             last_value = value
             has_value = True
 
-        def on_error(err: Exception):
+        def on_error(err: Exception) -> None:
             if not future.cancelled():
                 future.set_exception(err)
 
-        def on_completed():
+        def on_completed() -> None:
             nonlocal last_value
             if not future.cancelled():
                 if has_value:
-                    future.set_result(last_value)
+                    future.set_result(cast(_T, last_value))
                 else:
                     future.set_exception(SequenceContainsNoElementsError())
             last_value = None

reactivex/operators/_toiterable.py

@@ -1,44 +1,50 @@
-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 to_iterable_() -> Callable[[Observable[_T]], Observable[List[_T]]]:
-    def to_iterable(source: Observable[_T]) -> Observable[List[_T]]:
-        """Creates an iterable from an observable sequence.
+@curry_flip
+def to_iterable_(source: Observable[_T]) -> Observable[list[_T]]:
+    """Creates an iterable from an observable sequence.
 
-        Returns:
-            An observable sequence containing a single element with an
-            iterable containing all the elements of the source
-            sequence.
-        """
+    Examples:
+        >>> res = source.pipe(to_iterable())
+        >>> res = to_iterable()(source)
 
-        def subscribe(
-            observer: abc.ObserverBase[List[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            nonlocal source
+    Args:
+        source: Source observable.
 
-            queue: List[_T] = []
+    Returns:
+        An observable sequence containing a single element with an
+        iterable containing all the elements of the source
+        sequence.
+    """
 
-            def on_next(item: _T):
-                queue.append(item)
+    def subscribe(
+        observer: abc.ObserverBase[list[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        nonlocal source
 
-            def on_completed():
-                nonlocal queue
-                observer.on_next(queue)
-                queue = []
-                observer.on_completed()
+        queue: list[_T] = []
 
-            return source.subscribe(
-                on_next, observer.on_error, on_completed, scheduler=scheduler
-            )
+        def on_next(item: _T):
+            queue.append(item)
 
-        return Observable(subscribe)
+        def on_completed():
+            nonlocal queue
+            observer.on_next(queue)
+            queue = []
+            observer.on_completed()
 
-    return to_iterable
+        return source.subscribe(
+            on_next, observer.on_error, on_completed, scheduler=scheduler
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["to_iterable_"]

reactivex/operators/_tomarbles.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional
+from typing import Any
 
 from reactivex import Observable, abc
 from reactivex.scheduler import NewThreadScheduler
@@ -8,7 +8,7 @@ new_thread_scheduler = NewThreadScheduler()
 
 
 def to_marbles(
-    timespan: RelativeTime = 0.1, scheduler: Optional[abc.SchedulerBase] = None
+    timespan: RelativeTime = 0.1, scheduler: abc.SchedulerBase | None = None
 ):
     def to_marbles(source: Observable[Any]) -> Observable[str]:
         """Convert an observable sequence into a marble diagram string.
@@ -25,11 +25,11 @@ def to_marbles(
 
         def subscribe(
             observer: abc.ObserverBase[str],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ):
             scheduler = scheduler or new_thread_scheduler
 
-            result: List[str] = []
+            result: list[str] = []
             last = scheduler.now
 
             def add_timespan():
@@ -70,7 +70,7 @@ def stringify(value: Any) -> str:
     """Utility for stringifying an event."""
     string = str(value)
     if len(string) > 1:
-        string = "(%s)" % string
+        string = f"({string})"
 
     return string
 

reactivex/operators/_toset.py

@@ -1,37 +1,47 @@
-from typing import Callable, Optional, Set, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 
 
-def to_set_() -> Callable[[Observable[_T]], Observable[Set[_T]]]:
+@curry_flip
+def to_set_(source: Observable[_T]) -> Observable[set[_T]]:
     """Converts the observable sequence to a set.
 
     Returns an observable sequence with a single value of a set
     containing the values from the observable sequence.
-    """
 
-    def to_set(source: Observable[_T]) -> Observable[Set[_T]]:
-        def subscribe(
-            observer: abc.ObserverBase[Set[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            s: Set[_T] = set()
+    Examples:
+        >>> res = source.pipe(to_set())
+        >>> res = to_set()(source)
+
+    Args:
+        source: Source observable.
+
+    Returns:
+        An observable sequence with a single value of a set
+        containing the values from the observable sequence.
+    """
 
-            def on_completed() -> None:
-                nonlocal s
-                observer.on_next(s)
-                s = set()
-                observer.on_completed()
+    def subscribe(
+        observer: abc.ObserverBase[set[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        s: set[_T] = set()
 
-            return source.subscribe(
-                s.add, observer.on_error, on_completed, scheduler=scheduler
-            )
+        def on_completed() -> None:
+            nonlocal s
+            observer.on_next(s)
+            s = set()
+            observer.on_completed()
 
-        return Observable(subscribe)
+        return source.subscribe(
+            s.add, observer.on_error, on_completed, scheduler=scheduler
+        )
 
-    return to_set
+    return Observable(subscribe)
 
 
 __all__ = ["to_set_"]

reactivex/operators/_whiledo.py

@@ -1,6 +1,7 @@
 import itertools
 from asyncio import Future
-from typing import Callable, TypeVar, Union
+from collections.abc import Callable
+from typing import TypeVar, Union
 
 import reactivex
 from reactivex import Observable

reactivex/operators/_window.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Any, Callable, Optional, Tuple, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, empty
 from reactivex import operators as ops
@@ -9,7 +10,7 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
-from reactivex.internal import add_ref, noop
+from reactivex.internal import add_ref, curry_flip, noop
 from reactivex.subject import Subject
 
 log = logging.getLogger("Rx")
@@ -17,161 +18,161 @@ log = logging.getLogger("Rx")
 _T = TypeVar("_T")
 
 
+@curry_flip
 def window_toggle_(
-    openings: Observable[Any], closing_mapper: Callable[[Any], Observable[Any]]
-) -> Callable[[Observable[_T]], Observable[Observable[_T]]]:
+    source: Observable[_T],
+    openings: Observable[Any],
+    closing_mapper: Callable[[Any], Observable[Any]],
+) -> Observable[Observable[_T]]:
     """Projects each element of an observable sequence into zero or
     more windows.
 
     Args:
         source: Source observable to project into windows.
+        openings: Observable that triggers window opening.
+        closing_mapper: Function to create closing observable.
 
     Returns:
         An observable sequence of windows.
     """
 
-    def window_toggle(source: Observable[_T]) -> Observable[Observable[_T]]:
-        def mapper(args: Tuple[Any, Observable[_T]]):
-            _, window = args
-            return window
-
-        return openings.pipe(
-            ops.group_join(
-                source,
-                closing_mapper,
-                lambda _: empty(),
-            ),
-            ops.map(mapper),
-        )
+    def mapper(args: tuple[Any, Observable[_T]]):
+        _, window = args
+        return window
 
-    return window_toggle
+    return openings.pipe(
+        ops.group_join(
+            source,
+            closing_mapper,
+            lambda _: empty(),
+        ),
+        ops.map(mapper),
+    )
 
 
+@curry_flip
 def window_(
+    source: Observable[_T],
     boundaries: Observable[Any],
-) -> Callable[[Observable[_T]], Observable[Observable[_T]]]:
+) -> Observable[Observable[_T]]:
     """Projects each element of an observable sequence into zero or
     more windows.
 
     Args:
         source: Source observable to project into windows.
+        boundaries: Observable that triggers window boundaries.
 
     Returns:
         An observable sequence of windows.
     """
 
-    def window(source: Observable[_T]) -> Observable[Observable[_T]]:
-        def subscribe(
-            observer: abc.ObserverBase[Observable[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            window_subject: Subject[_T] = Subject()
-            d = CompositeDisposable()
-            r = RefCountDisposable(d)
+    def subscribe(
+        observer: abc.ObserverBase[Observable[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        window_subject: Subject[_T] = Subject()
+        d = CompositeDisposable()
+        r = RefCountDisposable(d)
 
-            observer.on_next(add_ref(window_subject, r))
+        observer.on_next(add_ref(window_subject, r))
 
-            def on_next_window(x: _T) -> None:
-                window_subject.on_next(x)
+        def on_next_window(x: _T) -> None:
+            window_subject.on_next(x)
 
-            def on_error(err: Exception) -> None:
-                window_subject.on_error(err)
-                observer.on_error(err)
+        def on_error(err: Exception) -> None:
+            window_subject.on_error(err)
+            observer.on_error(err)
 
-            def on_completed() -> None:
-                window_subject.on_completed()
-                observer.on_completed()
+        def on_completed() -> None:
+            window_subject.on_completed()
+            observer.on_completed()
 
-            d.add(
-                source.subscribe(
-                    on_next_window, on_error, on_completed, scheduler=scheduler
-                )
+        d.add(
+            source.subscribe(
+                on_next_window, on_error, on_completed, scheduler=scheduler
             )
+        )
 
-            def on_next_observer(w: Observable[_T]):
-                nonlocal window_subject
-                window_subject.on_completed()
-                window_subject = Subject()
-                observer.on_next(add_ref(window_subject, r))
+        def on_next_observer(w: Observable[_T]):
+            nonlocal window_subject
+            window_subject.on_completed()
+            window_subject = Subject()
+            observer.on_next(add_ref(window_subject, r))
 
-            d.add(
-                boundaries.subscribe(
-                    on_next_observer, on_error, on_completed, scheduler=scheduler
-                )
+        d.add(
+            boundaries.subscribe(
+                on_next_observer, on_error, on_completed, scheduler=scheduler
             )
-            return r
-
-        return Observable(subscribe)
+        )
+        return r
 
-    return window
+    return Observable(subscribe)
 
 
+@curry_flip
 def window_when_(
-    closing_mapper: Callable[[], Observable[Any]]
-) -> Callable[[Observable[_T]], Observable[Observable[_T]]]:
+    source: Observable[_T],
+    closing_mapper: Callable[[], Observable[Any]],
+) -> Observable[Observable[_T]]:
     """Projects each element of an observable sequence into zero or
     more windows.
 
     Args:
         source: Source observable to project into windows.
+        closing_mapper: Function that returns an observable signaling window close.
 
     Returns:
         An observable sequence of windows.
     """
 
-    def window_when(source: Observable[_T]) -> Observable[Observable[_T]]:
-        def subscribe(
-            observer: abc.ObserverBase[Observable[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            m = SerialDisposable()
-            d = CompositeDisposable(m)
-            r = RefCountDisposable(d)
-            window: Subject[_T] = Subject()
+    def subscribe(
+        observer: abc.ObserverBase[Observable[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        m = SerialDisposable()
+        d = CompositeDisposable(m)
+        r = RefCountDisposable(d)
+        window: Subject[_T] = Subject()
 
-            observer.on_next(add_ref(window, r))
+        observer.on_next(add_ref(window, r))
 
-            def on_next(value: _T) -> None:
-                window.on_next(value)
+        def on_next(value: _T) -> None:
+            window.on_next(value)
 
-            def on_error(error: Exception) -> None:
-                window.on_error(error)
-                observer.on_error(error)
+        def on_error(error: Exception) -> None:
+            window.on_error(error)
+            observer.on_error(error)
 
-            def on_completed() -> None:
-                window.on_completed()
-                observer.on_completed()
-
-            d.add(
-                source.subscribe(on_next, on_error, on_completed, scheduler=scheduler)
-            )
+        def on_completed() -> None:
+            window.on_completed()
+            observer.on_completed()
 
-            def create_window_on_completed():
-                try:
-                    window_close = closing_mapper()
-                except Exception as exception:
-                    observer.on_error(exception)
-                    return
+        d.add(source.subscribe(on_next, on_error, on_completed, scheduler=scheduler))
 
-                def on_completed():
-                    nonlocal window
-                    window.on_completed()
-                    window = Subject()
-                    observer.on_next(add_ref(window, r))
-                    create_window_on_completed()
+        def create_window_on_completed():
+            try:
+                window_close = closing_mapper()
+            except Exception as exception:
+                observer.on_error(exception)
+                return
 
-                m1 = SingleAssignmentDisposable()
-                m.disposable = m1
-                m1.disposable = window_close.pipe(ops.take(1)).subscribe(
-                    noop, on_error, on_completed, scheduler=scheduler
-                )
-
-            create_window_on_completed()
-            return r
+            def on_completed():
+                nonlocal window
+                window.on_completed()
+                window = Subject()
+                observer.on_next(add_ref(window, r))
+                create_window_on_completed()
+
+            m1 = SingleAssignmentDisposable()
+            m.disposable = m1
+            m1.disposable = window_close.pipe(ops.take(1)).subscribe(
+                noop, on_error, on_completed, scheduler=scheduler
+            )
 
-        return Observable(subscribe)
+        create_window_on_completed()
+        return r
 
-    return window_when
+    return Observable(subscribe)
 
 
 __all__ = ["window_", "window_when_", "window_toggle_"]