def test_new_thread_schedule_action(self):
scheduler = NewThreadScheduler()
ran = False
def action(scheduler, state):
nonlocal ran
ran = True
scheduler.schedule(action)
sleep(0.1)
assert ran is True
def test_new_thread_schedule_action_cancel(self):
ran = False
scheduler = NewThreadScheduler()
def action(scheduler, state):
nonlocal ran
ran = True
d = scheduler.schedule_relative(timedelta(milliseconds=1), action)
d.dispose()
sleep(0.2)
assert ran is False
def test_new_thread_schedule_periodic_cancel(self):
scheduler = NewThreadScheduler()
period = 0.1
counter = 4
def action(state: int):
nonlocal counter
if state:
counter -= 1
return state - 1
disp = scheduler.schedule_periodic(period, action, counter)
sleep(0.4)
disp.dispose()
assert 0 <= counter < 4
def test_new_thread_schedule_action_due(self):
scheduler = NewThreadScheduler()
starttime = default_now()
endtime = None
def action(scheduler, state):
nonlocal endtime
endtime = default_now()
scheduler.schedule_relative(timedelta(milliseconds=200), action)
sleep(0.4)
assert endtime is not None
diff = endtime - starttime
assert diff > timedelta(milliseconds=180)
def test_new_thread_now_units(self):
scheduler = NewThreadScheduler()
diff = scheduler.now
sleep(1.1)
diff = scheduler.now - diff
assert timedelta(milliseconds=1000) < diff < timedelta(
milliseconds=1300)
def test_new_thread_schedule_periodic(self):
scheduler = NewThreadScheduler()
gate = threading.Semaphore(0)
period = 0.05
counter = 3
def action(state: int):
nonlocal counter
if state:
counter -= 1
return state - 1
if counter == 0:
gate.release()
scheduler.schedule_periodic(period, action, counter)
gate.acquire()
assert counter == 0
from contextlib import contextmanager
from typing import Any, Dict, Generator, List, NamedTuple, Optional, Tuple, Union
from warnings import warn
import reactivex
from reactivex import Observable, typing
from reactivex.notification import Notification, OnError, OnNext
from reactivex.observable.marbles import parse
from reactivex.scheduler import NewThreadScheduler
from reactivex.typing import Callable, RelativeTime
from .reactivetest import ReactiveTest
from .recorded import Recorded
from .testscheduler import TestScheduler
new_thread_scheduler = NewThreadScheduler()
class MarblesContext(NamedTuple):
start: Callable[[Union[Observable[Any], Callable[[], Observable[Any]]]],
List[Recorded[Any]]]
cold: Callable[
[str, Optional[Dict[Union[str, float],
Any]], Optional[Exception]], Observable[Any], ]
hot: Callable[
[str, Optional[Dict[Union[str, float],
Any]], Optional[Exception]], Observable[Any], ]
exp: Callable[
[str, Optional[Dict[Union[str, float],
Any]], Optional[Exception]], List[Recorded[Any]], ]
def test_new_thread_now(self):
scheduler = NewThreadScheduler()
diff = scheduler.now - default_now()
assert abs(diff) < timedelta(milliseconds=5)
import threading
from typing import Optional, TypeVar, cast
from reactivex.internal.exceptions import SequenceContainsNoElementsError
from reactivex.scheduler import NewThreadScheduler
from .observable import Observable
scheduler = NewThreadScheduler()
_T = TypeVar("_T")
def run(source: Observable[_T]) -> _T:
"""Run source synchronously.
Subscribes to the observable source. Then blocks and waits for the
observable source to either complete or error. Returns the
last value emitted, or throws exception if any error occured.
Examples:
>>> result = run(source)
Args:
source: Observable source to run.
Raises:
SequenceContainsNoElementsError: if observable completes
(on_completed) without any values being emitted.
Exception: raises exception if any error (on_error) occured.