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

reactivex/operators/_windowwithcount.py

@@ -1,9 +1,9 @@
 import logging
-from typing import Callable, List, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import Observable, abc
 from reactivex.disposable import RefCountDisposable, SingleAssignmentDisposable
-from reactivex.internal import ArgumentOutOfRangeException, add_ref
+from reactivex.internal import ArgumentOutOfRangeException, add_ref, curry_flip
 from reactivex.subject import Subject
 
 log = logging.getLogger("Rx")
@@ -11,17 +11,22 @@ log = logging.getLogger("Rx")
 _T = TypeVar("_T")
 
 
+@curry_flip
 def window_with_count_(
-    count: int, skip: Optional[int] = None
-) -> Callable[[Observable[_T]], Observable[Observable[_T]]]:
+    source: Observable[_T],
+    count: int,
+    skip: int | None = None,
+) -> Observable[Observable[_T]]:
     """Projects each element of an observable sequence into zero or more
     windows which are produced based on element count information.
 
     Examples:
-        >>> window_with_count(10)
-        >>> window_with_count(10, 1)
+        >>> source.pipe(window_with_count(10))
+        >>> source.pipe(window_with_count(10, 1))
+        >>> window_with_count(10)(source)
 
     Args:
+        source: Source observable to window.
         count: Length of each window.
         skip: [Optional] Number of elements to skip between creation of
             consecutive windows. If not specified, defaults to the
@@ -39,54 +44,51 @@ def window_with_count_(
     if skip_ <= 0:
         raise ArgumentOutOfRangeException()
 
-    def window_with_count(source: Observable[_T]) -> Observable[Observable[_T]]:
-        def subscribe(
-            observer: abc.ObserverBase[Observable[_T]],
-            scheduler: Optional[abc.SchedulerBase] = None,
-        ):
-            m = SingleAssignmentDisposable()
-            refCountDisposable = RefCountDisposable(m)
-            n = [0]
-            q: List[Subject[_T]] = []
-
-            def create_window():
-                s: Subject[_T] = Subject()
-                q.append(s)
-                observer.on_next(add_ref(s, refCountDisposable))
-
-            create_window()
-
-            def on_next(x: _T) -> None:
-                for item in q:
-                    item.on_next(x)
-
-                c = n[0] - count + 1
-                if c >= 0 and c % skip_ == 0:
-                    s = q.pop(0)
-                    s.on_completed()
-
-                n[0] += 1
-                if (n[0] % skip_) == 0:
-                    create_window()
-
-            def on_error(exception: Exception) -> None:
-                while q:
-                    q.pop(0).on_error(exception)
-                observer.on_error(exception)
-
-            def on_completed() -> None:
-                while q:
-                    q.pop(0).on_completed()
-                observer.on_completed()
-
-            m.disposable = source.subscribe(
-                on_next, on_error, on_completed, scheduler=scheduler
-            )
-            return refCountDisposable
-
-        return Observable(subscribe)
-
-    return window_with_count
+    def subscribe(
+        observer: abc.ObserverBase[Observable[_T]],
+        scheduler: abc.SchedulerBase | None = None,
+    ):
+        m = SingleAssignmentDisposable()
+        refCountDisposable = RefCountDisposable(m)
+        n = [0]
+        q: list[Subject[_T]] = []
+
+        def create_window():
+            s: Subject[_T] = Subject()
+            q.append(s)
+            observer.on_next(add_ref(s, refCountDisposable))
+
+        create_window()
+
+        def on_next(x: _T) -> None:
+            for item in q:
+                item.on_next(x)
+
+            c = n[0] - count + 1
+            if c >= 0 and c % skip_ == 0:
+                s = q.pop(0)
+                s.on_completed()
+
+            n[0] += 1
+            if (n[0] % skip_) == 0:
+                create_window()
+
+        def on_error(exception: Exception) -> None:
+            while q:
+                q.pop(0).on_error(exception)
+            observer.on_error(exception)
+
+        def on_completed() -> None:
+            while q:
+                q.pop(0).on_completed()
+            observer.on_completed()
+
+        m.disposable = source.subscribe(
+            on_next, on_error, on_completed, scheduler=scheduler
+        )
+        return refCountDisposable
+
+    return Observable(subscribe)
 
 
 __all__ = ["window_with_count_"]

reactivex/operators/_windowwithtime.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Any, Callable, List, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import (
@@ -8,18 +8,37 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
-from reactivex.internal import DELTA_ZERO, add_ref, synchronized
+from reactivex.internal import DELTA_ZERO, add_ref, curry_flip, synchronized
 from reactivex.scheduler import TimeoutScheduler
 from reactivex.subject import Subject
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def window_with_time_(
+    source: Observable[_T],
     timespan: typing.RelativeTime,
-    timeshift: Optional[typing.RelativeTime] = None,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[Observable[_T]]]:
+    timeshift: typing.RelativeTime | None = None,
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[Observable[_T]]:
+    """Projects each element of an observable sequence into zero or more
+    windows which are produced based on timing information.
+
+    Examples:
+        >>> res = source.pipe(window_with_time(1.0))
+        >>> res = source.pipe(window_with_time(1.0, 0.5))
+        >>> res = window_with_time(1.0)(source)
+
+    Args:
+        source: Source observable to window.
+        timespan: Length of each window.
+        timeshift: Interval between creation of consecutive windows.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence of windows.
+    """
     if timeshift is None:
         timeshift = timespan
 
@@ -28,94 +47,91 @@ def window_with_time_(
     if not isinstance(timeshift, timedelta):
         timeshift = timedelta(seconds=timeshift)
 
-    def window_with_time(source: Observable[_T]) -> Observable[Observable[_T]]:
-        def subscribe(
-            observer: abc.ObserverBase[Observable[_T]],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ):
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-
-            timer_d = SerialDisposable()
-            next_shift = [timeshift]
-            next_span = [timespan]
-            total_time = [DELTA_ZERO]
-            queue: List[Subject[_T]] = []
-
-            group_disposable = CompositeDisposable(timer_d)
-            ref_count_disposable = RefCountDisposable(group_disposable)
-
-            def create_timer():
-                m = SingleAssignmentDisposable()
-                timer_d.disposable = m
-                is_span = False
-                is_shift = False
-
-                if next_span[0] == next_shift[0]:
-                    is_span = True
-                    is_shift = True
-                elif next_span[0] < next_shift[0]:
-                    is_span = True
-                else:
-                    is_shift = True
-
-                new_total_time = next_span[0] if is_span else next_shift[0]
-
-                ts = new_total_time - total_time[0]
-                total_time[0] = new_total_time
-                if is_span:
-                    next_span[0] += timeshift
-
-                if is_shift:
-                    next_shift[0] += timeshift
+    def subscribe(
+        observer: abc.ObserverBase[Observable[_T]],
+        scheduler_: abc.SchedulerBase | None = None,
+    ):
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+
+        timer_d = SerialDisposable()
+        next_shift = [timeshift]
+        next_span = [timespan]
+        total_time = [DELTA_ZERO]
+        queue: list[Subject[_T]] = []
+
+        group_disposable = CompositeDisposable(timer_d)
+        ref_count_disposable = RefCountDisposable(group_disposable)
+
+        def create_timer():
+            m = SingleAssignmentDisposable()
+            timer_d.disposable = m
+            is_span = False
+            is_shift = False
+
+            if next_span[0] == next_shift[0]:
+                is_span = True
+                is_shift = True
+            elif next_span[0] < next_shift[0]:
+                is_span = True
+            else:
+                is_shift = True
+
+            new_total_time = next_span[0] if is_span else next_shift[0]
+
+            ts = new_total_time - total_time[0]
+            total_time[0] = new_total_time
+            if is_span:
+                next_span[0] += timeshift
+
+            if is_shift:
+                next_shift[0] += timeshift
 
-                @synchronized(source.lock)
-                def action(scheduler: abc.SchedulerBase, state: Any = None):
-                    s: Optional[Subject[_T]] = None
-
-                    if is_shift:
-                        s = Subject()
-                        queue.append(s)
-                        observer.on_next(add_ref(s, ref_count_disposable))
+            @synchronized(source.lock)
+            def action(scheduler: abc.SchedulerBase, state: Any = None):
+                s: Subject[_T] | None = None
 
-                    if is_span:
-                        s = queue.pop(0)
-                        s.on_completed()
+                if is_shift:
+                    s = Subject()
+                    queue.append(s)
+                    observer.on_next(add_ref(s, ref_count_disposable))
 
-                    create_timer()
+                if is_span:
+                    s = queue.pop(0)
+                    s.on_completed()
 
-                m.disposable = _scheduler.schedule_relative(ts, action)
+                create_timer()
 
-            queue.append(Subject())
-            observer.on_next(add_ref(queue[0], ref_count_disposable))
-            create_timer()
+            m.disposable = _scheduler.schedule_relative(ts, action)
 
-            def on_next(x: _T) -> None:
-                with source.lock:
-                    for s in queue:
-                        s.on_next(x)
+        queue.append(Subject())
+        observer.on_next(add_ref(queue[0], ref_count_disposable))
+        create_timer()
 
-            @synchronized(source.lock)
-            def on_error(e: Exception) -> None:
+        def on_next(x: _T) -> None:
+            with source.lock:
                 for s in queue:
-                    s.on_error(e)
+                    s.on_next(x)
 
-                observer.on_error(e)
+        @synchronized(source.lock)
+        def on_error(e: Exception) -> None:
+            for s in queue:
+                s.on_error(e)
 
-            @synchronized(source.lock)
-            def on_completed() -> None:
-                for s in queue:
-                    s.on_completed()
+            observer.on_error(e)
 
-                observer.on_completed()
+        @synchronized(source.lock)
+        def on_completed() -> None:
+            for s in queue:
+                s.on_completed()
 
-            group_disposable.add(
-                source.subscribe(on_next, on_error, on_completed, scheduler=scheduler_)
-            )
-            return ref_count_disposable
+            observer.on_completed()
 
-        return Observable(subscribe)
+        group_disposable.add(
+            source.subscribe(on_next, on_error, on_completed, scheduler=scheduler_)
+        )
+        return ref_count_disposable
 
-    return window_with_time
+    return Observable(subscribe)
 
 
 __all__ = ["window_with_time_"]

reactivex/operators/_windowwithtimeorcount.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import Observable, abc, typing
 from reactivex.disposable import (
@@ -7,90 +7,106 @@ from reactivex.disposable import (
     SerialDisposable,
     SingleAssignmentDisposable,
 )
-from reactivex.internal import add_ref
+from reactivex.internal import add_ref, curry_flip
 from reactivex.scheduler import TimeoutScheduler
 from reactivex.subject import Subject
 
 _T = TypeVar("_T")
 
 
+@curry_flip
 def window_with_time_or_count_(
+    source: Observable[_T],
     timespan: typing.RelativeTime,
     count: int,
-    scheduler: Optional[abc.SchedulerBase] = None,
-) -> Callable[[Observable[_T]], Observable[Observable[_T]]]:
-    def window_with_time_or_count(source: Observable[_T]) -> Observable[Observable[_T]]:
-        def subscribe(
-            observer: abc.ObserverBase[Observable[_T]],
-            scheduler_: Optional[abc.SchedulerBase] = None,
-        ) -> abc.DisposableBase:
-            _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
-
-            n: int = 0
-            s: Subject[_T] = Subject()
-            timer_d = SerialDisposable()
-            window_id = 0
-            group_disposable = CompositeDisposable(timer_d)
-            ref_count_disposable = RefCountDisposable(group_disposable)
-
-            def create_timer(_id: int):
+    scheduler: abc.SchedulerBase | None = None,
+) -> Observable[Observable[_T]]:
+    """Projects each element of an observable sequence into zero or more
+    windows which are produced based on timing information and element count.
+
+    Examples:
+        >>> res = source.pipe(window_with_time_or_count(1.0, 10))
+        >>> res = window_with_time_or_count(1.0, 10)(source)
+
+    Args:
+        source: Source observable to window.
+        timespan: Maximum time length of a window.
+        count: Maximum element count of a window.
+        scheduler: Scheduler to use for timing.
+
+    Returns:
+        An observable sequence of windows.
+    """
+
+    def subscribe(
+        observer: abc.ObserverBase[Observable[_T]],
+        scheduler_: abc.SchedulerBase | None = None,
+    ) -> abc.DisposableBase:
+        _scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton()
+
+        n: int = 0
+        s: Subject[_T] = Subject()
+        timer_d = SerialDisposable()
+        window_id = 0
+        group_disposable = CompositeDisposable(timer_d)
+        ref_count_disposable = RefCountDisposable(group_disposable)
+
+        def create_timer(_id: int):
+            nonlocal n, s, window_id
+            m = SingleAssignmentDisposable()
+            timer_d.disposable = m
+
+            def action(scheduler: abc.SchedulerBase, state: Any = None):
                 nonlocal n, s, window_id
-                m = SingleAssignmentDisposable()
-                timer_d.disposable = m
+                if _id != window_id:
+                    return
 
-                def action(scheduler: abc.SchedulerBase, state: Any = None):
-                    nonlocal n, s, window_id
-                    if _id != window_id:
-                        return
-
-                    n = 0
-                    window_id += 1
-                    new_id = window_id
-                    s.on_completed()
-                    s = Subject()
-                    observer.on_next(add_ref(s, ref_count_disposable))
-                    create_timer(new_id)
-
-                m.disposable = _scheduler.schedule_relative(timespan, action)
+                n = 0
+                window_id += 1
+                new_id = window_id
+                s.on_completed()
+                s = Subject()
+                observer.on_next(add_ref(s, ref_count_disposable))
+                create_timer(new_id)
+
+            m.disposable = _scheduler.schedule_relative(timespan, action)
+
+        observer.on_next(add_ref(s, ref_count_disposable))
+        create_timer(0)
+
+        def on_next(x: _T) -> None:
+            nonlocal n, s, window_id
+            new_window = False
+            new_id = 0
+
+            s.on_next(x)
+            n += 1
+            if n == count:
+                new_window = True
+                n = 0
+                window_id += 1
+                new_id = window_id
+                s.on_completed()
+                s = Subject()
+                observer.on_next(add_ref(s, ref_count_disposable))
 
-            observer.on_next(add_ref(s, ref_count_disposable))
-            create_timer(0)
+            if new_window:
+                create_timer(new_id)
 
-            def on_next(x: _T) -> None:
-                nonlocal n, s, window_id
-                new_window = False
-                new_id = 0
-
-                s.on_next(x)
-                n += 1
-                if n == count:
-                    new_window = True
-                    n = 0
-                    window_id += 1
-                    new_id = window_id
-                    s.on_completed()
-                    s = Subject()
-                    observer.on_next(add_ref(s, ref_count_disposable))
-
-                if new_window:
-                    create_timer(new_id)
-
-            def on_error(e: Exception) -> None:
-                s.on_error(e)
-                observer.on_error(e)
-
-            def on_completed() -> None:
-                s.on_completed()
-                observer.on_completed()
+        def on_error(e: Exception) -> None:
+            s.on_error(e)
+            observer.on_error(e)
 
-            group_disposable.add(
-                source.subscribe(on_next, on_error, on_completed, scheduler=scheduler_)
-            )
-            return ref_count_disposable
+        def on_completed() -> None:
+            s.on_completed()
+            observer.on_completed()
 
-        return Observable(subscribe)
+        group_disposable.add(
+            source.subscribe(on_next, on_error, on_completed, scheduler=scheduler_)
+        )
+        return ref_count_disposable
 
-    return window_with_time_or_count
+    return Observable(subscribe)
 
 
 __all__ = ["window_with_time_or_count_"]

reactivex/operators/_withlatestfrom.py

@@ -1,12 +1,15 @@
-from typing import Any, Callable
+from typing import Any
 
 import reactivex
 from reactivex import Observable
+from reactivex.internal import curry_flip
 
 
+@curry_flip
 def with_latest_from_(
+    source: Observable[Any],
     *sources: Observable[Any],
-) -> Callable[[Observable[Any]], Observable[Any]]:
+) -> Observable[Any]:
     """With latest from operator.
 
     Merges the specified observable sequences into one observable
@@ -15,18 +18,19 @@ def with_latest_from_(
     passed either as seperate arguments or as a list.
 
     Examples:
-        >>> op = with_latest_from(obs1)
-        >>> op = with_latest_from(obs1, obs2, obs3)
+        >>> res = source.pipe(with_latest_from(obs1))
+        >>> res = source.pipe(with_latest_from(obs1, obs2, obs3))
+        >>> res = with_latest_from(obs1)(source)
+
+    Args:
+        source: Source observable.
+        *sources: Additional observables to combine with.
 
     Returns:
         An observable sequence containing the result of combining
     elements of the sources into a tuple.
     """
-
-    def with_latest_from(source: Observable[Any]) -> Observable[Any]:
-        return reactivex.with_latest_from(source, *sources)
-
-    return with_latest_from
+    return reactivex.with_latest_from(source, *sources)
 
 
 __all__ = ["with_latest_from_"]