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

reactivex/subject/asyncsubject.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar, cast
+from typing import TypeVar, cast
 
 from .. import abc
 from ..disposable import Disposable
@@ -25,7 +25,7 @@ class AsyncSubject(Subject[_T]):
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         with self.lock:
             self.check_disposed()

reactivex/subject/behaviorsubject.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar, cast
+from typing import TypeVar, cast
 
 from .. import abc
 from ..disposable import Disposable
@@ -31,7 +31,7 @@ class BehaviorSubject(Subject[_T]):
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         with self.lock:
             self.check_disposed()

reactivex/subject/innersubscription.py

@@ -1,5 +1,5 @@
 import threading
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from .. import abc
 
@@ -11,7 +11,7 @@ _T = TypeVar("_T")
 
 class InnerSubscription(abc.DisposableBase):
     def __init__(
-        self, subject: "Subject[_T]", observer: Optional[abc.ObserverBase[_T]] = None
+        self, subject: "Subject[_T]", observer: abc.ObserverBase[_T] | None = None
     ):
         self.subject = subject
         self.observer = observer

reactivex/subject/replaysubject.py

@@ -1,7 +1,7 @@
 import sys
 from collections import deque
 from datetime import datetime, timedelta
-from typing import Any, Deque, NamedTuple, Optional, TypeVar, cast
+from typing import Any, NamedTuple, TypeVar, cast
 
 from reactivex.observer.scheduledobserver import ScheduledObserver
 from reactivex.scheduler import CurrentThreadScheduler
@@ -37,9 +37,9 @@ class ReplaySubject(Subject[_T]):
 
     def __init__(
         self,
-        buffer_size: Optional[int] = None,
-        window: Optional[typing.RelativeTime] = None,
-        scheduler: Optional[abc.SchedulerBase] = None,
+        buffer_size: int | None = None,
+        window: typing.RelativeTime | None = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> None:
         """Initializes a new instance of the ReplaySubject class with
         the specified buffer size, window and scheduler.
@@ -54,15 +54,15 @@ class ReplaySubject(Subject[_T]):
         super().__init__()
         self.buffer_size = sys.maxsize if buffer_size is None else buffer_size
         self.scheduler = scheduler or CurrentThreadScheduler.singleton()
-        self.window = (
+        self._window = (
             timedelta.max if window is None else self.scheduler.to_timedelta(window)
         )
-        self.queue: Deque[QueueItem] = deque()
+        self.queue: deque[QueueItem] = deque()
 
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         so = ScheduledObserver(self.scheduler, observer)
         subscription = RemovableDisposable(self, so)
@@ -87,7 +87,7 @@ class ReplaySubject(Subject[_T]):
         while len(self.queue) > self.buffer_size:
             self.queue.popleft()
 
-        while self.queue and (now - self.queue[0].interval) > self.window:
+        while self.queue and (now - self.queue[0].interval) > self._window:
             self.queue.popleft()
 
     def _on_next_core(self, value: _T) -> None:

reactivex/subject/subject.py

@@ -1,5 +1,5 @@
 import threading
-from typing import List, Optional, TypeVar
+from typing import TypeVar
 
 from .. import abc
 from ..disposable import Disposable
@@ -21,8 +21,8 @@ class Subject(Observable[_T], Observer[_T], abc.SubjectBase[_T]):
         super().__init__()
 
         self.is_disposed = False
-        self.observers: List[abc.ObserverBase[_T]] = []
-        self.exception: Optional[Exception] = None
+        self.observers: list[abc.ObserverBase[_T]] = []
+        self.exception: Exception | None = None
 
         self.lock = threading.RLock()
 
@@ -33,7 +33,7 @@ class Subject(Observable[_T], Observer[_T], abc.SubjectBase[_T]):
     def _subscribe_core(
         self,
         observer: abc.ObserverBase[_T],
-        scheduler: Optional[abc.SchedulerBase] = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         with self.lock:
             self.check_disposed()

reactivex/testing/coldobservable.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Notification, Observable, abc
 from reactivex.disposable import CompositeDisposable, Disposable
@@ -12,18 +12,18 @@ _T = TypeVar("_T")
 
 class ColdObservable(Observable[_T]):
     def __init__(
-        self, scheduler: VirtualTimeScheduler, messages: List[Recorded[_T]]
+        self, scheduler: VirtualTimeScheduler, messages: list[Recorded[_T]]
     ) -> None:
         super().__init__()
 
         self.scheduler = scheduler
         self.messages = messages
-        self.subscriptions: List[Subscription] = []
+        self.subscriptions: list[Subscription] = []
 
     def _subscribe_core(
         self,
-        observer: Optional[abc.ObserverBase[_T]] = None,
-        scheduler: Optional[abc.SchedulerBase] = None,
+        observer: abc.ObserverBase[_T] | None = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         self.subscriptions.append(Subscription(self.scheduler.clock))
         index = len(self.subscriptions) - 1

reactivex/testing/hotobservable.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import Disposable
@@ -13,14 +13,14 @@ _T = TypeVar("_T")
 
 class HotObservable(Observable[_T]):
     def __init__(
-        self, scheduler: VirtualTimeScheduler, messages: List[Recorded[_T]]
+        self, scheduler: VirtualTimeScheduler, messages: list[Recorded[_T]]
     ) -> None:
         super().__init__()
 
         self.scheduler = scheduler
         self.messages = messages
-        self.subscriptions: List[Subscription] = []
-        self.observers: List[abc.ObserverBase[_T]] = []
+        self.subscriptions: list[Subscription] = []
+        self.observers: list[abc.ObserverBase[_T]] = []
 
         observable = self
 
@@ -43,8 +43,8 @@ class HotObservable(Observable[_T]):
 
     def _subscribe_core(
         self,
-        observer: Optional[abc.ObserverBase[_T]] = None,
-        scheduler: Optional[abc.SchedulerBase] = None,
+        observer: abc.ObserverBase[_T] | None = None,
+        scheduler: abc.SchedulerBase | None = None,
     ) -> abc.DisposableBase:
         if observer:
             self.observers.append(observer)

reactivex/testing/marbles.py

@@ -1,5 +1,6 @@
+from collections.abc import Generator
 from contextlib import contextmanager
-from typing import Any, Dict, Generator, List, NamedTuple, Optional, Tuple, Union
+from typing import Any, NamedTuple, cast
 from warnings import warn
 
 import reactivex
@@ -18,19 +19,19 @@ new_thread_scheduler = NewThreadScheduler()
 
 class MarblesContext(NamedTuple):
     start: Callable[
-        [Union[Observable[Any], Callable[[], Observable[Any]]]], List[Recorded[Any]]
+        [Observable[Any] | Callable[[], Observable[Any]]], list[Recorded[Any]]
     ]
     cold: Callable[
-        [str, Optional[Dict[Union[str, float], Any]], Optional[Exception]],
+        [str, dict[str | float, Any] | None, Exception | None],
         Observable[Any],
     ]
     hot: Callable[
-        [str, Optional[Dict[Union[str, float], Any]], Optional[Exception]],
+        [str, dict[str | float, Any] | None, Exception | None],
         Observable[Any],
     ]
     exp: Callable[
-        [str, Optional[Dict[Union[str, float], Any]], Optional[Exception]],
-        List[Recorded[Any]],
+        [str, dict[str | float, Any] | None, Exception | None],
+        list[Recorded[Any]],
     ]
 
 
@@ -97,13 +98,13 @@ def marbles_testing(
             )
 
     def test_start(
-        create: Union[Observable[Any], Callable[[], Observable[Any]]],
-    ) -> List[Recorded[Any]]:
+        create: Observable[Any] | Callable[[], Observable[Any]],
+    ) -> list[Recorded[Any]]:
         nonlocal start_called
         check()
 
         if isinstance(create, Observable):
-            create_ = create
+            create_ = cast(Observable[Any], create)
 
             def default_create() -> Observable[Any]:
                 return create_
@@ -123,9 +124,9 @@ def marbles_testing(
 
     def test_expected(
         string: str,
-        lookup: Optional[Dict[Union[str, float], Any]] = None,
-        error: Optional[Exception] = None,
-    ) -> List[Recorded[Any]]:
+        lookup: dict[str | float, Any] | None = None,
+        error: Exception | None = None,
+    ) -> list[Recorded[Any]]:
         messages = parse(
             string,
             timespan=timespan,
@@ -137,8 +138,8 @@ def marbles_testing(
 
     def test_cold(
         string: str,
-        lookup: Optional[Dict[Union[str, float], Any]] = None,
-        error: Optional[Exception] = None,
+        lookup: dict[str | float, Any] | None = None,
+        error: Exception | None = None,
     ) -> Observable[Any]:
         check()
         return reactivex.from_marbles(
@@ -150,8 +151,8 @@ def marbles_testing(
 
     def test_hot(
         string: str,
-        lookup: Optional[Dict[Union[str, float], Any]] = None,
-        error: Optional[Exception] = None,
+        lookup: dict[str | float, Any] | None = None,
+        error: Exception | None = None,
     ) -> Observable[Any]:
         check()
         hot_obs: Observable[Any] = reactivex.hot(
@@ -171,17 +172,17 @@ def marbles_testing(
 
 
 def messages_to_records(
-    messages: List[Tuple[typing.RelativeTime, Notification[Any]]],
-) -> List[Recorded[Any]]:
+    messages: list[tuple[typing.RelativeTime, Notification[Any]]],
+) -> list[Recorded[Any]]:
     """
     Helper function to convert messages returned by parse() to a list of
     Recorded.
     """
-    records: List[Recorded[Any]] = []
+    records: list[Recorded[Any]] = []
 
     for message in messages:
         time, notification = message
-        if isinstance(time, (int, float)):
+        if isinstance(time, (int | float)):
             time_ = int(time)
         else:
             time_ = time.microseconds // 1000

reactivex/testing/mockdisposable.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from reactivex import abc, typing
 from reactivex.scheduler import VirtualTimeScheduler
 
@@ -7,7 +5,7 @@ from reactivex.scheduler import VirtualTimeScheduler
 class MockDisposable(abc.DisposableBase):
     def __init__(self, scheduler: VirtualTimeScheduler):
         self.scheduler = scheduler
-        self.disposes: List[typing.AbsoluteTime] = []
+        self.disposes: list[typing.AbsoluteTime] = []
         self.disposes.append(self.scheduler.clock)
 
     def dispose(self) -> None:

reactivex/testing/mockobserver.py

@@ -1,4 +1,4 @@
-from typing import List, TypeVar
+from typing import TypeVar
 
 from reactivex import abc
 from reactivex.notification import OnCompleted, OnError, OnNext
@@ -12,7 +12,7 @@ _T = TypeVar("_T")
 class MockObserver(abc.ObserverBase[_T]):
     def __init__(self, scheduler: VirtualTimeScheduler) -> None:
         self.scheduler = scheduler
-        self.messages: List[Recorded[_T]] = []
+        self.messages: list[Recorded[_T]] = []
 
     def on_next(self, value: _T) -> None:
         self.messages.append(Recorded(self.scheduler.clock, OnNext(value)))

reactivex/testing/reactivetest.py

@@ -1,6 +1,6 @@
 import math
 import types
-from typing import Any, Generic, TypeVar, Union
+from typing import Any, Generic, TypeVar
 
 from reactivex import typing
 from reactivex.notification import OnCompleted, OnError, OnNext
@@ -68,7 +68,7 @@ class ReactiveTest:
 
     @staticmethod
     def on_error(
-        ticks: int, error: Union[Exception, str, types.FunctionType]
+        ticks: int, error: Exception | str | types.FunctionType
     ) -> Recorded[Any]:
         if isinstance(error, types.FunctionType):
             return Recorded(ticks, OnErrorPredicate(error))

reactivex/testing/recorded.py

@@ -38,4 +38,4 @@ class Recorded(Generic[_T]):
         return str(self)
 
     def __str__(self) -> str:
-        return "%s@%s" % (self.value, self.time)
+        return f"{self.value}@{self.time}"

reactivex/testing/subscription.py

@@ -1,9 +1,9 @@
 import sys
-from typing import Any, Optional
+from typing import Any
 
 
 class Subscription:
-    def __init__(self, start: int, end: Optional[int] = None):
+    def __init__(self, start: int, end: int | None = None):
         self.subscribe = start
         self.unsubscribe = end or sys.maxsize
 
@@ -22,4 +22,4 @@ class Subscription:
         unsubscribe = (
             "Infinite" if self.unsubscribe == sys.maxsize else self.unsubscribe
         )
-        return "(%s, %s)" % (self.subscribe, unsubscribe)
+        return f"({self.subscribe}, {unsubscribe})"

reactivex/testing/testscheduler.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, List, Optional, TypeVar, Union, cast
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 import reactivex
 from reactivex import Observable, abc, typing
@@ -46,10 +47,10 @@ class TestScheduler(VirtualTimeScheduler):
 
     def start(
         self,
-        create: Optional[Callable[[], Observable[_T]]] = None,
-        created: Optional[float] = None,
-        subscribed: Optional[float] = None,
-        disposed: Optional[float] = None,
+        create: Callable[[], Observable[_T]] | None = None,
+        created: float | None = None,
+        subscribed: float | None = None,
+        disposed: float | None = None,
     ) -> MockObserver[_T]:
         """Starts the test scheduler and uses the specified virtual
         times to invoke the factory function, subscribe to the
@@ -76,8 +77,8 @@ class TestScheduler(VirtualTimeScheduler):
         disposed = disposed or ReactiveTest.disposed
 
         observer = self.create_observer()
-        subscription: Optional[abc.DisposableBase] = None
-        source: Optional[abc.ObservableBase[_T]] = None
+        subscription: abc.DisposableBase | None = None
+        source: abc.ObservableBase[_T] | None = None
 
         def action_create(
             scheduler: abc.SchedulerBase, state: Any = None
@@ -114,7 +115,7 @@ class TestScheduler(VirtualTimeScheduler):
         return observer
 
     def create_hot_observable(
-        self, *args: Union[Recorded[_T], List[Recorded[_T]]]
+        self, *args: Recorded[_T] | list[Recorded[_T]]
     ) -> HotObservable[_T]:
         """Creates a hot observable using the specified timestamped
         notification messages either as a list or by multiple arguments.
@@ -127,14 +128,14 @@ class TestScheduler(VirtualTimeScheduler):
         of subscriptions and notifications.
         """
 
-        if args and isinstance(args[0], List):
+        if args and isinstance(args[0], list):
             messages = args[0]
         else:
-            messages = cast(List[Recorded[_T]], list(args))
+            messages = cast(list[Recorded[_T]], list(args))
         return HotObservable(self, messages)
 
     def create_cold_observable(
-        self, *args: Union[Recorded[_T], List[Recorded[_T]]]
+        self, *args: Recorded[_T] | list[Recorded[_T]]
     ) -> ColdObservable[_T]:
         """Creates a cold observable using the specified timestamped
         notification messages either as an array or arguments.
@@ -152,7 +153,7 @@ class TestScheduler(VirtualTimeScheduler):
         if args and isinstance(args[0], list):
             messages = args[0]
         else:
-            messages = cast(List[Recorded[_T]], list(args))
+            messages = cast(list[Recorded[_T]], list(args))
         return ColdObservable(self, messages)
 
     def create_observer(self) -> MockObserver[Any]:

reactivex/typing.py

@@ -1,5 +1,8 @@
+from collections.abc import Callable
 from threading import Thread
-from typing import Callable, TypeVar, Union
+from typing import TypeAlias, TypeVar
+
+from typing_extensions import TypeAliasType
 
 from .abc.observable import Subscription
 from .abc.observer import OnCompleted, OnError, OnNext
@@ -19,20 +22,28 @@ _TState = TypeVar("_TState")
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
 
-Action = Callable[[], None]
-
-Mapper = Callable[[_T1], _T2]
-MapperIndexed = Callable[[_T1, int], _T2]
-Predicate = Callable[[_T1], bool]
-PredicateIndexed = Callable[[_T1, int], bool]
-Comparer = Callable[[_T1, _T1], bool]
-SubComparer = Callable[[_T1, _T1], int]
-Accumulator = Callable[[_TState, _T1], _TState]
+# Non-generic type aliases
+Action: TypeAlias = Callable[[], None]
+Startable: TypeAlias = StartableBase | Thread
+StartableTarget: TypeAlias = Callable[..., None]
+StartableFactory: TypeAlias = Callable[[StartableTarget], Startable]
 
-
-Startable = Union[StartableBase, Thread]
-StartableTarget = Callable[..., None]
-StartableFactory = Callable[[StartableTarget], Startable]
+# Generic type aliases
+Mapper = TypeAliasType("Mapper", Callable[[_T1], _T2], type_params=(_T1, _T2))
+MapperIndexed = TypeAliasType(
+    "MapperIndexed", Callable[[_T1, int], _T2], type_params=(_T1, _T2)
+)
+Predicate = TypeAliasType("Predicate", Callable[[_T1], bool], type_params=(_T1,))
+PredicateIndexed = TypeAliasType(
+    "PredicateIndexed", Callable[[_T1, int], bool], type_params=(_T1,)
+)
+Comparer = TypeAliasType("Comparer", Callable[[_T1, _T1], bool], type_params=(_T1,))
+SubComparer = TypeAliasType(
+    "SubComparer", Callable[[_T1, _T1], int], type_params=(_T1,)
+)
+Accumulator = TypeAliasType(
+    "Accumulator", Callable[[_TState, _T1], _TState], type_params=(_TState, _T1)
+)
 
 __all__ = [
     "Accumulator",

{reactivex-4.1.0.dist-info → reactivex-5.0.0a2.dist-info}/METADATA

@@ -1,20 +1,19 @@
 Metadata-Version: 2.4
 Name: reactivex
-Version: 4.1.0
+Version: 5.0.0a2
 Summary: ReactiveX (Rx) for Python
-License: MIT
+Project-URL: Homepage, http://reactivex.io
+Project-URL: Repository, https://github.com/ReactiveX/RxPY
+Project-URL: Documentation, https://rxpy.readthedocs.io/en/latest/
+Author-email: Dag Brattli <dag@brattli.net>
+License-Expression: MIT
 License-File: LICENSE
-Author: Dag Brattli
-Author-email: dag@brattli.net
-Requires-Python: >=3.8,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Other Environment
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -22,10 +21,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: typing-extensions (>=4.1.1,<5.0.0)
-Project-URL: Documentation, https://rxpy.readthedocs.io/en/latest/
-Project-URL: Homepage, http://reactivex.io
-Project-URL: Repository, https://github.com/ReactiveX/RxPY
+Requires-Python: <4.0,>=3.10
+Requires-Dist: typing-extensions<5,>=4.15.0
 Description-Content-Type: text/x-rst
 
 ===============================
@@ -89,6 +86,43 @@ Schedulers.
     composed.subscribe(lambda value: print("Received {0}".format(value)))
 
 
+Fluent and Functional Syntax
+-----------------------------
+
+RxPY supports both **fluent** (method chaining) and **functional** (pipe-based) syntax,
+giving you the flexibility to choose the style that works best for your codebase:
+
+**Fluent style** - Method chaining for a more Pythonic feel:
+
+.. code:: python
+
+    import reactivex as rx
+
+    result = (rx.of(1, 2, 3, 4, 5)
+        .map(lambda x: x * 2)
+        .filter(lambda x: x > 5)
+        .reduce(lambda acc, x: acc + x, 0)
+    )
+    result.subscribe(print)  # Output: 24
+
+**Functional style** - Pipe-based for functional composition:
+
+.. code:: python
+
+    import reactivex as rx
+    from reactivex import operators as ops
+
+    result = rx.of(1, 2, 3, 4, 5).pipe(
+        ops.map(lambda x: x * 2),
+        ops.filter(lambda x: x > 5),
+        ops.reduce(lambda acc, x: acc + x, 0)
+    )
+    result.subscribe(print)  # Output: 24
+
+Both styles are **fully supported** and can even be mixed in the same pipeline.
+Choose the style that best fits your team's preferences and coding standards.
+
+
 Learning ReactiveX
 ------------------
 
@@ -136,8 +170,12 @@ need to be written with an ``_`` in Python:
 
 .. code:: python
 
+    # Functional style
     group = source.pipe(ops.group_by(lambda i: i % 3))
 
+    # Or fluent style
+    group = source.group_by(lambda i: i % 3)
+
 With ReactiveX for Python you should use `named keyword arguments
 <https://docs.python.org/3/glossary.html>`_ instead of positional arguments when an
 operator has multiple optional arguments. RxPY will not try to detect which arguments
@@ -146,35 +184,30 @@ you are giving to the operator (or not).
 Development
 -----------
 
-This project is managed using `Poetry <https://python-poetry.org/>`_. Code is formatted
-using `Black <https://github.com/psf/black>`_, `isort
-<https://github.com/PyCQA/isort>`_. Code is statically type checked using `pyright
-<https://github.com/microsoft/pyright>`_ and `mypy <http://mypy-lang.org/>`_.
+This project is managed using `uv <https://docs.astral.sh/uv/>`_. Code is formatted
+using `Ruff <https://github.com/astral-sh/ruff>`_. Code is statically type checked
+using `pyright <https://github.com/microsoft/pyright>`_.
 
-If you want to take advantage of the default VSCode integration, then
-first configure Poetry to make its virtual environment in the
-repository:
+After cloning the repository, install dependencies:
 
 .. code:: console
 
-    poetry config virtualenvs.in-project true
+    uv sync
 
-After cloning the repository, activate the tooling:
+Run unit tests:
 
 .. code:: console
 
-    poetry install
-    poetry run pre-commit install
+    uv run pytest
 
-Run unit tests:
+Run type checking:
 
 .. code:: console
 
-    poetry run pytest
+    uv run pyright
 
 Run code checks (manually):
 
 .. code:: console
 
-    poetry run pre-commit run --all-files
-
+    uv run pre-commit run --all-files