async def go():
nonlocal result
source = reactivex.throw(error)
try:
result = await source
except Exception as ex:
result = ex
def test_retry_observable_retry_count_throws(self):
scheduler1 = TestScheduler()
xs = reactivex.return_value(1).pipe(ops.retry(3))
xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1)
self.assertRaises(RxException, scheduler1.start)
scheduler2 = TestScheduler()
ys = reactivex.throw("ex").pipe(ops.retry(100))
d = ys.subscribe(on_error=lambda ex: _raise("ex"),
scheduler=scheduler2)
def dispose(_, __):
d.dispose()
scheduler2.schedule_absolute(0, dispose)
scheduler2.start()
scheduler3 = TestScheduler()
zs = reactivex.return_value(1).pipe(ops.retry(100))
zs.subscribe(on_completed=lambda: _raise("ex"), scheduler=scheduler3)
with pytest.raises(RxException):
scheduler3.start()
xss = reactivex.create(lambda o: _raise("ex")).pipe(ops.retry(100))
with pytest.raises(Exception):
xss.subscribe()
def start_async_(function_async: Callable[[], "Future[_T]"]) -> Observable[_T]:
try:
future = function_async()
except Exception as ex: # pylint: disable=broad-except
return throw(ex)
return from_future(future)
def test_map_throws(self):
mapper = map(lambda x: x)
with self.assertRaises(RxException):
return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex"))
with self.assertRaises(RxException):
throw("ex").pipe(mapper).subscribe(on_error=lambda ex: _raise(ex))
with self.assertRaises(RxException):
empty().pipe(mapper).subscribe(
lambda x: x, lambda ex: ex, lambda: _raise("ex")
)
def subscribe(observer, scheduler=None):
_raise("ex")
with self.assertRaises(RxException):
create(subscribe).pipe(map(lambda x: x)).subscribe()
def test_throw_observer_throws(self):
scheduler = TestScheduler()
xs = throw("ex")
xs.subscribe(lambda x: None,
lambda ex: _raise("ex"),
lambda: None,
scheduler=scheduler)
self.assertRaises(RxException, scheduler.start)
def subscribe(
observer: abc.ObserverBase[_T],
scheduler: Optional[abc.SchedulerBase] = None
) -> abc.DisposableBase:
try:
result = factory(scheduler or ImmediateScheduler.singleton())
except Exception as ex: # By design. pylint: disable=W0703
return throw(ex).subscribe(observer)
result = from_future(result) if isinstance(result, Future) else result
return result.subscribe(observer, scheduler=scheduler)
def test_repeat_observable_repeat_count_throws(self):
scheduler1 = TestScheduler()
xs = reactivex.return_value(1).pipe(ops.repeat(3))
xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1)
with self.assertRaises(RxException):
scheduler1.start()
scheduler2 = TestScheduler()
ys = reactivex.throw("ex1").pipe(ops.repeat(3))
ys.subscribe(on_error=lambda ex: _raise("ex2"), scheduler=scheduler2)
with self.assertRaises(RxException):
scheduler2.start()
def create():
def mapper(xy):
x, y = xy
return "{}{}".format(x.value, y.value)
return xs.pipe(
ops.join(
ys,
lambda x: reactivex.timer(x.interval),
lambda y: reactivex.timer(y.interval).pipe(
ops.flat_map(
reactivex.throw(ex)
if y.value == "tin" else reactivex.empty())),
),
ops.map(mapper),
)
def subscribe(
observer: abc.ObserverBase[_T],
scheduler: Optional[abc.SchedulerBase] = None
) -> abc.DisposableBase:
disp: abc.DisposableBase = Disposable()
try:
resource = resource_factory()
if resource is not None:
disp = resource
source = observable_factory(resource)
except Exception as exception: # pylint: disable=broad-except
d = reactivex.throw(exception).subscribe(observer,
scheduler=scheduler)
return CompositeDisposable(d, disp)
return CompositeDisposable(
source.subscribe(observer, scheduler=scheduler), disp)
def test_map_with_index_throws(self):
with self.assertRaises(RxException):
mapper = map_indexed(lambda x, index: x)
return return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex"))
with self.assertRaises(RxException):
return (
throw("ex").pipe(mapper).subscribe(lambda x: x, lambda ex: _raise(ex))
)
with self.assertRaises(RxException):
return (
empty()
.pipe(mapper)
.subscribe(lambda x: x, lambda ex: None, lambda: _raise("ex"))
)
with self.assertRaises(RxException):
return create(lambda o, s: _raise("ex")).pipe(mapper).subscribe()
def test_retry_observable_throws(self):
scheduler1 = TestScheduler()
xs = reactivex.return_value(1).pipe(ops.retry())
xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1)
with pytest.raises(RxException):
scheduler1.start()
scheduler2 = TestScheduler()
ys = reactivex.throw("ex").pipe(ops.retry())
d = ys.subscribe(on_error=lambda ex: _raise("ex"),
scheduler=scheduler2)
scheduler2.schedule_absolute(210, lambda sc, st: d.dispose())
scheduler2.start()
scheduler3 = TestScheduler()
zs = reactivex.return_value(1).pipe(ops.retry())
zs.subscribe(on_completed=lambda: _raise("ex"), scheduler=scheduler3)
with pytest.raises(RxException):
scheduler3.start()
def create():
def handler(e, source):
handler_called[0] = True
return o2
return reactivex.throw("ex").pipe(ops.catch(handler))
def test_run_error(self):
with pytest.raises(RxException):
reactivex.throw(RxException()).run()
def create():
return throw(ex).pipe(_.debounce(10))
def create():
return reactivex.throw(ex).pipe(ops.sample(0))
def create():
return reactivex.throw(ex).pipe(ops.timestamp())
def closing():
return reactivex.throw(ex)
def create():
return reactivex.throw(ex).pipe(ops.time_interval())
def timeout_(
duetime: typing.AbsoluteOrRelativeTime,
other: Optional[Union[Observable[_T], "Future[_T]"]] = None,
scheduler: Optional[abc.SchedulerBase] = None,
) -> Callable[[Observable[_T]], Observable[_T]]:
other = other or throw(Exception("Timeout"))
if isinstance(other, Future):
obs = from_future(other)
else:
obs = other
def timeout(source: Observable[_T]) -> Observable[_T]:
"""Returns the source observable sequence or the other observable
sequence if duetime elapses.
Examples:
>>> res = timeout(source)
Args:
source: Source observable to timeout
Returns:
An obserable sequence switching to the other sequence in
case of a timeout.
"""
def subscribe(
observer: abc.ObserverBase[_T],
scheduler_: Optional[abc.SchedulerBase] = None,
) -> abc.DisposableBase:
_scheduler = scheduler or scheduler_ or TimeoutScheduler.singleton(
)
switched = [False]
_id = [0]
original = SingleAssignmentDisposable()
subscription = SerialDisposable()
timer = SerialDisposable()
subscription.disposable = original
def create_timer() -> None:
my_id = _id[0]
def action(scheduler: abc.SchedulerBase, state: Any = None):
switched[0] = _id[0] == my_id
timer_wins = switched[0]
if timer_wins:
subscription.disposable = obs.subscribe(
observer, scheduler=scheduler)
if isinstance(duetime, datetime):
timer.disposable = _scheduler.schedule_absolute(
duetime, action)
else:
timer.disposable = _scheduler.schedule_relative(
duetime, action)
create_timer()
def on_next(value: _T) -> None:
send_wins = not switched[0]
if send_wins:
_id[0] += 1
observer.on_next(value)
create_timer()
def on_error(error: Exception) -> None:
on_error_wins = not switched[0]
if on_error_wins:
_id[0] += 1
observer.on_error(error)
def on_completed() -> None:
on_completed_wins = not switched[0]
if on_completed_wins:
_id[0] += 1
observer.on_completed()
original.disposable = source.subscribe(on_next,
on_error,
on_completed,
scheduler=scheduler_)
return CompositeDisposable(subscription, timer)
return Observable(subscribe)
return timeout
def timeout_with_mapper_(
first_timeout: Optional[Observable[_T]] = None,
timeout_duration_mapper: Optional[Callable[[Any], Observable[Any]]] = None,
other: Optional[Observable[_T]] = None,
) -> Callable[[Observable[_T]], Observable[_T]]:
"""Returns the source observable sequence, switching to the other
observable sequence if a timeout is signaled.
res = timeout_with_mapper(reactivex.timer(500))
res = timeout_with_mapper(reactivex.timer(500), lambda x: reactivex.timer(200))
res = timeout_with_mapper(
reactivex.timer(500),
lambda x: reactivex.timer(200)),
reactivex.return_value(42)
)
Args:
first_timeout -- [Optional] Observable sequence that represents the
timeout for the first element. If not provided, this defaults to
reactivex.never().
timeout_duration_mapper -- [Optional] Selector to retrieve an
observable sequence that represents the timeout between the
current element and the next element.
other -- [Optional] Sequence to return in case of a timeout. If not
provided, this is set to reactivex.throw().
Returns:
The source sequence switching to the other sequence in case
of a timeout.
"""
first_timeout_ = first_timeout or reactivex.never()
other_ = other or reactivex.throw(Exception("Timeout"))
def timeout_with_mapper(source: Observable[_T]) -> Observable[_T]:
def subscribe(
observer: abc.ObserverBase[_T],
scheduler: Optional[abc.SchedulerBase] = None,
) -> abc.DisposableBase:
subscription = SerialDisposable()
timer = SerialDisposable()
original = SingleAssignmentDisposable()
subscription.disposable = original
switched = False
_id = [0]
def set_timer(timeout: Observable[Any]) -> None:
my_id = _id[0]
def timer_wins():
return _id[0] == my_id
d = SingleAssignmentDisposable()
timer.disposable = d
def on_next(x: Any) -> None:
if timer_wins():
subscription.disposable = other_.subscribe(
observer, scheduler=scheduler)
d.dispose()
def on_error(e: Exception) -> None:
if timer_wins():
observer.on_error(e)
def on_completed() -> None:
if timer_wins():
subscription.disposable = other_.subscribe(observer)
d.disposable = timeout.subscribe(on_next,
on_error,
on_completed,
scheduler=scheduler)
set_timer(first_timeout_)
def observer_wins():
res = not switched
if res:
_id[0] += 1
return res
def on_next(x: _T) -> None:
if observer_wins():
observer.on_next(x)
timeout = None
try:
timeout = (timeout_duration_mapper(x)
if timeout_duration_mapper else
reactivex.never())
except Exception as e:
observer.on_error(e)
return
set_timer(timeout)
def on_error(error: Exception) -> None:
if observer_wins():
observer.on_error(error)
def on_completed() -> None:
if observer_wins():
observer.on_completed()
original.disposable = source.subscribe(on_next,
on_error,
on_completed,
scheduler=scheduler)
return CompositeDisposable(subscription, timer)
return Observable(subscribe)
return timeout_with_mapper
def factory():
return throw(ex)
def factory():
return throw("ex")