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

reactivex/operators/_zip.py

@@ -1,83 +1,87 @@
-from typing import Any, Callable, Iterable, Optional, Tuple, TypeVar
+from collections.abc import Iterable
+from typing import Any, TypeVar
 
 import reactivex
 from reactivex import Observable, abc
+from reactivex.internal import curry_flip
 
 _T = TypeVar("_T")
 _TOther = TypeVar("_TOther")
 
 
+@curry_flip
 def zip_(
+    source: Observable[Any],
     *args: Observable[Any],
-) -> Callable[[Observable[Any]], Observable[Tuple[Any, ...]]]:
-    def _zip(source: Observable[Any]) -> Observable[Tuple[Any, ...]]:
-        """Merges the specified observable sequences into one observable
-        sequence by creating a tuple whenever all of the
-        observable sequences have produced an element at a corresponding
-        index.
+) -> Observable[tuple[Any, ...]]:
+    """Merges the specified observable sequences into one observable
+    sequence by creating a tuple whenever all of the
+    observable sequences have produced an element at a corresponding
+    index.
 
-        Example:
-            >>> res = zip(source)
+    Example:
+        >>> res = source.pipe(zip(obs1, obs2))
+        >>> res = zip(obs1, obs2)(source)
 
-        Args:
-            source: Source observable to zip.
+    Args:
+        source: Source observable to zip.
+        *args: Additional observables to zip with.
 
-        Returns:
-            An observable sequence containing the result of combining
-            elements of the sources as a tuple.
-        """
-        return reactivex.zip(source, *args)
-
-    return _zip
+    Returns:
+        An observable sequence containing the result of combining
+        elements of the sources as a tuple.
+    """
+    return reactivex.zip(source, *args)
 
 
+@curry_flip
 def zip_with_iterable_(
+    source: Observable[_T],
     seq: Iterable[_TOther],
-) -> Callable[[Observable[_T]], Observable[Tuple[_T, _TOther]]]:
-    def zip_with_iterable(source: Observable[_T]) -> Observable[Tuple[_T, _TOther]]:
-        """Merges the specified observable sequence and list into one
-        observable sequence by creating a tuple whenever all of
-        the observable sequences have produced an element at a
-        corresponding index.
-
-        Example
-            >>> res = zip(source)
-
-        Args:
-            source: Source observable to zip.
-
-        Returns:
-            An observable sequence containing the result of combining
-            elements of the sources as a tuple.
-        """
-
-        first = source
-        second = iter(seq)
-
-        def subscribe(
-            observer: abc.ObserverBase[Tuple[_T, _TOther]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            index = 0
-
-            def on_next(left: _T) -> None:
-                nonlocal index
-
-                try:
-                    right = next(second)
-                except StopIteration:
-                    observer.on_completed()
-                else:
-                    result = (left, right)
-                    observer.on_next(result)
-
-            return first.subscribe(
-                on_next, observer.on_error, observer.on_completed, scheduler=scheduler
-            )
-
-        return Observable(subscribe)
-
-    return zip_with_iterable
+) -> Observable[tuple[_T, _TOther]]:
+    """Merges the specified observable sequence and list into one
+    observable sequence by creating a tuple whenever all of
+    the observable sequences have produced an element at a
+    corresponding index.
+
+    Example
+        >>> res = source.pipe(zip_with_iterable([1, 2, 3]))
+        >>> res = zip_with_iterable([1, 2, 3])(source)
+
+    Args:
+        source: Source observable to zip.
+        seq: Iterable sequence to zip with.
+
+    Returns:
+        An observable sequence containing the result of combining
+        elements of the sources as a tuple.
+    """
+
+    first = source
+    second = iter(seq)
+
+    def subscribe(
+        observer: abc.ObserverBase[tuple[_T, _TOther]],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        index = 0
+
+        def on_next(left: _T) -> None:
+            nonlocal index
+
+            try:
+                right = next(second)
+            except StopIteration:
+                observer.on_completed()
+            else:
+                result = (left, right)
+                observer.on_next(result)
+
+        return first.subscribe(
+            on_next, observer.on_error, observer.on_completed, scheduler=scheduler
+        )
+
+    return Observable(subscribe)
 
 
 __all__ = ["zip_", "zip_with_iterable_"]

reactivex/operators/connectable/_refcount.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from reactivex import ConnectableObservable, Observable, abc
 from reactivex.disposable import Disposable
@@ -12,13 +13,13 @@ def ref_count_() -> Callable[[ConnectableObservable[_T]], Observable[_T]]:
     observable sequence.
     """
 
-    connectable_subscription: Optional[abc.DisposableBase] = None
+    connectable_subscription: abc.DisposableBase | None = None
     count = 0
 
     def ref_count(source: ConnectableObservable[_T]) -> Observable[_T]:
         def subscribe(
             observer: abc.ObserverBase[_T],
-            scheduler: Optional[abc.SchedulerBase] = None,
+            scheduler: abc.SchedulerBase | None = None,
         ) -> abc.DisposableBase:
             nonlocal connectable_subscription, count
 

reactivex/pipe.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from functools import reduce
-from typing import Any, Callable, TypeVar, overload
+from typing import Any, TypeVar, overload
 
 _A = TypeVar("_A")
 _B = TypeVar("_B")

reactivex/run.py

@@ -1,17 +1,18 @@
 import threading
-from typing import Optional, TypeVar, cast
+from typing import TypeVar, cast
 
+from reactivex import abc
 from reactivex.internal.exceptions import SequenceContainsNoElementsError
 from reactivex.scheduler import NewThreadScheduler
 
 from .observable import Observable
 
-scheduler = NewThreadScheduler()
+_default_scheduler = NewThreadScheduler()
 
 _T = TypeVar("_T")
 
 
-def run(source: Observable[_T]) -> _T:
+def run(source: Observable[_T], scheduler: abc.SchedulerBase | None = None) -> _T:
     """Run source synchronously.
 
     Subscribes to the observable source. Then blocks and waits for the
@@ -23,6 +24,8 @@ def run(source: Observable[_T]) -> _T:
 
     Args:
         source: Observable source to run.
+        scheduler: Optional scheduler to use for subscription. If not
+            specified, defaults to a NewThreadScheduler.
 
     Raises:
         SequenceContainsNoElementsError: if observable completes
@@ -32,7 +35,8 @@ def run(source: Observable[_T]) -> _T:
     Returns:
         The last element emitted from the observable.
     """
-    exception: Optional[Exception] = None
+    scheduler = scheduler or _default_scheduler
+    exception: Exception | None = None
     latch = threading.Event()
     has_result = False
     result: _T = cast(_T, None)

reactivex/scheduler/catchscheduler.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from datetime import datetime
-from typing import Callable, Optional, TypeVar, cast
+from typing import TypeVar, cast
 
 from reactivex import abc, typing
 from reactivex.abc.scheduler import SchedulerBase
@@ -28,8 +29,8 @@ class CatchScheduler(PeriodicScheduler):
         super().__init__()
         self._scheduler: abc.SchedulerBase = scheduler
         self._handler: Callable[[Exception], bool] = handler
-        self._recursive_original: Optional[abc.SchedulerBase] = None
-        self._recursive_wrapper: Optional["CatchScheduler"] = None
+        self._recursive_original: abc.SchedulerBase | None = None
+        self._recursive_wrapper: CatchScheduler | None = None
 
     @property
     def now(self) -> datetime:
@@ -44,7 +45,7 @@ class CatchScheduler(PeriodicScheduler):
         return self._scheduler.now
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -64,7 +65,7 @@ class CatchScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -85,7 +86,7 @@ class CatchScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -106,7 +107,7 @@ class CatchScheduler(PeriodicScheduler):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work.
 
@@ -129,7 +130,7 @@ class CatchScheduler(PeriodicScheduler):
         disp: SingleAssignmentDisposable = SingleAssignmentDisposable()
         failed: bool = False
 
-        def periodic(state: Optional[_TState] = None) -> Optional[_TState]:
+        def periodic(state: _TState | None = None) -> _TState | None:
             nonlocal failed
             if failed:
                 return None
@@ -155,8 +156,8 @@ class CatchScheduler(PeriodicScheduler):
         parent = self
 
         def wrapped_action(
-            self: abc.SchedulerBase, state: Optional[_TState]
-        ) -> Optional[abc.DisposableBase]:
+            self: abc.SchedulerBase, state: _TState | None
+        ) -> abc.DisposableBase | None:
             try:
                 return action(parent._get_recursive_wrapper(self), state)
             except Exception as ex:

reactivex/scheduler/currentthreadscheduler.py

@@ -1,6 +1,6 @@
 import logging
+from collections.abc import MutableMapping
 from threading import Thread, current_thread, local
-from typing import MutableMapping
 from weakref import WeakKeyDictionary
 
 from .trampoline import Trampoline
@@ -37,7 +37,7 @@ class CurrentThreadScheduler(TrampolineScheduler):
         thread = current_thread()
         class_map = CurrentThreadScheduler._global.get(cls)
         if class_map is None:
-            class_map_: MutableMapping[Thread, "CurrentThreadScheduler"] = (
+            class_map_: MutableMapping[Thread, CurrentThreadScheduler] = (
                 WeakKeyDictionary()
             )
             CurrentThreadScheduler._global[cls] = class_map_
@@ -70,7 +70,6 @@ class _Local(local):
 
 
 class CurrentThreadSchedulerSingleton(CurrentThreadScheduler):
-
     _local = _Local()
 
     # pylint: disable=super-init-not-called

reactivex/scheduler/eventloop/asyncioscheduler.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from datetime import datetime
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -9,6 +9,7 @@ from reactivex.disposable import (
     Disposable,
     SingleAssignmentDisposable,
 )
+from reactivex.internal.basic import default_now
 
 from ..periodicscheduler import PeriodicScheduler
 
@@ -26,13 +27,13 @@ class AsyncIOScheduler(PeriodicScheduler):
 
         Args:
             loop: Instance of asyncio event loop to use; typically, you would
-                get this by asyncio.get_event_loop()
+                get this by asyncio.get_running_loop()
         """
         super().__init__()
         self._loop: asyncio.AbstractEventLoop = loop
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -60,7 +61,7 @@ class AsyncIOScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -93,7 +94,7 @@ class AsyncIOScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -120,4 +121,4 @@ class AsyncIOScheduler(PeriodicScheduler):
              The scheduler's current time, as a datetime instance.
         """
 
-        return self.to_datetime(self._loop.time())
+        return default_now()

reactivex/scheduler/eventloop/asynciothreadsafescheduler.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from concurrent.futures import Future
-from typing import List, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -23,7 +23,7 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
     """
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -47,7 +47,7 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
                 handle.cancel()
                 return
 
-            future: "Future[int]" = Future()
+            future: Future[int] = Future()
 
             def cancel_handle() -> None:
                 handle.cancel()
@@ -62,7 +62,7 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -86,7 +86,7 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
 
         # the operations on the list used here are atomic, so there is no
         # need to protect its access with a lock
-        handle: List[asyncio.Handle] = []
+        handle: list[asyncio.Handle] = []
 
         def stage2() -> None:
             handle.append(self._loop.call_later(seconds, interval))
@@ -105,7 +105,7 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
                 do_cancel_handles()
                 return
 
-            future: "Future[int]" = Future()
+            future: Future[int] = Future()
 
             def cancel_handle() -> None:
                 do_cancel_handles()
@@ -120,7 +120,7 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -145,13 +145,11 @@ class AsyncIOThreadSafeScheduler(AsyncIOScheduler):
         """
         if not self._loop.is_running():
             return True
-        current_loop = None
+
         try:
-            # In python 3.7 there asyncio.get_running_loop() is prefered.
-            current_loop = asyncio.get_event_loop()
+            current_loop = asyncio.get_running_loop()
         except RuntimeError:
-            # If there is no loop in current thread at all, and it is not main
-            # thread, we get error like:
-            # RuntimeError: There is no current event loop in thread 'Thread-1'
-            pass
+            # If no running event loop is found, assume we're in a different thread
+            return True
+
         return self._loop == current_loop

reactivex/scheduler/eventloop/eventletscheduler.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -33,7 +33,7 @@ class EventletScheduler(PeriodicScheduler):
         self._eventlet = eventlet
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -62,7 +62,7 @@ class EventletScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -96,7 +96,7 @@ class EventletScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/eventloop/geventscheduler.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -33,7 +33,7 @@ class GEventScheduler(PeriodicScheduler):
         self._gevent = gevent
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -62,7 +62,7 @@ class GEventScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -97,7 +97,7 @@ class GEventScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/eventloop/ioloopscheduler.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -34,7 +34,7 @@ class IOLoopScheduler(PeriodicScheduler):
         self._loop = loop
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -66,7 +66,7 @@ class IOLoopScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -102,7 +102,7 @@ class IOLoopScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/eventloop/twistedscheduler.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -30,7 +30,7 @@ class TwistedScheduler(PeriodicScheduler):
         self._reactor = reactor
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -49,7 +49,7 @@ class TwistedScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -83,7 +83,7 @@ class TwistedScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.