async def go():
nonlocal result
source = Observable.throw(error)
try:
result = await source
except Exception as ex:
result = ex
async def go():
nonlocal result
source = Observable.throw(error)
try:
result = await source
except Exception as ex:
result = ex
def test_retry_observable_retry_count_throws(self):
scheduler1 = TestScheduler()
xs = Observable.return_value(1).retry(3)
xs.subscribe_(lambda x: _raise('ex'), scheduler=scheduler1)
self.assertRaises(RxException, scheduler1.start)
scheduler2 = TestScheduler()
ys = Observable.throw('ex').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 = Observable.return_value(1).retry(100)
zs.subscribe_(on_completed=lambda: _raise('ex'), scheduler=scheduler3)
with pytest.raises(RxException):
scheduler3.start()
xss = Observable.create(lambda o: _raise('ex')).retry(100)
with pytest.raises(Exception):
xss.subscribe()
def subscribe(observer, scheduler=None):
try:
result = observable_factory(scheduler)
except Exception as ex:
return Observable.throw(ex).subscribe(observer)
result = Observable.from_future(result) if is_future(result) else result
return result.subscribe(observer, scheduler)
def test_map_throws(self):
with self.assertRaises(RxException):
Observable.return_value(1) \
.map(mapper_indexed=lambda x, y: x) \
.subscribe_(lambda x: _raise("ex"))
with self.assertRaises(RxException):
Observable.throw('ex') \
.map(mapper_indexed=lambda x, y: x) \
.subscribe_(on_error=lambda ex: _raise(ex))
with self.assertRaises(RxException):
Observable.empty() \
.map(mapper_indexed=lambda x, y: x) \
.subscribe_(lambda x: x, lambda ex: ex, lambda: _raise('ex'))
def subscribe(observer, scheduler=None):
_raise('ex')
with self.assertRaises(RxException):
Observable.create(subscribe) \
.map(lambda x: x) \
.subscribe()
def test_repeat_observable_repeat_count_throws(self):
scheduler1 = TestScheduler()
xs = Observable.return_value(1).repeat(3)
xs.subscribe_(lambda x: _raise('ex'), scheduler=scheduler1)
with self.assertRaises(RxException):
scheduler1.start()
scheduler2 = TestScheduler()
ys = Observable.throw('ex1').repeat(3)
ys.subscribe_(on_error=lambda ex: _raise('ex2'), scheduler=scheduler2)
with self.assertRaises(RxException):
scheduler2.start()
def subscribe(observer, scheduler=None):
disposable = Disposable.empty()
try:
resource = resource_factory()
if resource:
disposable = resource
source = observable_factory(resource)
except Exception as exception:
d = Observable.throw(exception).subscribe(observer, scheduler)
return CompositeDisposable(d, disposable)
return CompositeDisposable(source.subscribe(observer, scheduler),
disposable)
def go():
error = Exception('woops')
source = Observable.throw(error)
future = source.to_future(asyncio.Future)
def done(future):
try:
future.result()
except Exception as ex:
success[1] = str(ex) == str(error)
else:
success[0] = False
future.add_done_callback(done)
def start_async(function_async) -> ObservableBase:
"""Invokes the asynchronous function, surfacing the result through
an observable sequence.
Keyword arguments:
function_async -- Asynchronous function which returns a Future to
run.
Returns an observable sequence exposing the function's result value,
or an exception.
"""
try:
future = function_async()
except Exception as ex:
return Observable.throw(ex)
return Observable.from_future(future)
def start_async(cls, function_async):
"""Invokes the asynchronous function, surfacing the result through an
observable sequence.
Keyword arguments:
:param types.FunctionType function_async: Asynchronous function which
returns a Future to run.
:returns: An observable sequence exposing the function's result value, or an
exception.
:rtype: Observable
"""
try:
future = function_async()
except Exception as ex:
return Observable.throw(ex)
return Observable.from_future(future)
def test_map_with_index_throws(self):
with self.assertRaises(RxException):
return Observable.return_value(1) \
.map(mapper_indexed=lambda x, index: x) \
.subscribe_(lambda x: _raise('ex'))
with self.assertRaises(RxException):
return Observable.throw('ex') \
.map(mapper_indexed=lambda x, index: x) \
.subscribe_(lambda x: x, lambda ex: _raise(ex))
with self.assertRaises(RxException):
return Observable.empty() \
.map(lambda x, index: x) \
.subscribe_(lambda x: x, lambda ex: _, lambda : _raise('ex'))
with self.assertRaises(RxException):
return Observable.create(lambda o: _raise('ex')) \
.map(mapper_indexed=lambda x, index: x) \
.subscribe()
def test_retry_observable_throws(self):
scheduler1 = TestScheduler()
xs = Observable.return_value(1).retry()
xs.subscribe_(lambda x: _raise('ex'), scheduler=scheduler1)
with pytest.raises(RxException):
scheduler1.start()
scheduler2 = TestScheduler()
ys = Observable.throw('ex').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 = Observable.return_value(1).retry()
zs.subscribe_(on_completed=lambda: _raise('ex'), scheduler=scheduler3)
with pytest.raises(RxException):
scheduler3.start()
def create():
return Observable.throw(ex).time_interval()
def test_for_each_index_throws(self):
ex = Exception()
xs = Observable.throw(ex)
self.assertRaises(Exception, lambda:xs.to_blocking().for_each(lambda x, i: _raise(ex)))
def timeout(source: ObservableBase,
duetime: Union[int, datetime],
other: ObservableBase = None) -> ObservableBase:
"""Returns the source observable sequence or the other observable
sequence if duetime elapses.
1 - res = source.timeout(5000); # 5 seconds
# As a date and timeout observable
2 - res = source.timeout(datetime(), Observable.return_value(42))
# 5 seconds and timeout observable
3 - res = source.timeout(5000, Observable.return_value(42))
# As a date and timeout observable
Keyword arguments:
duetime -- Absolute (specified as a datetime object) or relative
time (specified as an integer denoting milliseconds) when a
timeout occurs.
other -- Sequence to return in case of a timeout. If not
specified, a timeout error throwing sequence will be used.
Returns the source sequence switching to the other sequence in case
of a timeout.
"""
other = other or Observable.throw(Exception("Timeout"))
other = Observable.from_future(other) if is_future(other) else other
def subscribe(observer, scheduler=None):
scheduler = scheduler or timeout_scheduler
if isinstance(duetime, datetime):
scheduler_method = scheduler.schedule_absolute
else:
scheduler_method = scheduler.schedule_relative
switched = [False]
_id = [0]
original = SingleAssignmentDisposable()
subscription = SerialDisposable()
timer = SerialDisposable()
subscription.disposable = original
def create_timer():
my_id = _id[0]
def action(scheduler, state=None):
switched[0] = (_id[0] == my_id)
timer_wins = switched[0]
if timer_wins:
subscription.disposable = other.subscribe(
observer, scheduler)
timer.disposable = scheduler_method(duetime, action)
create_timer()
def on_next(value):
send_wins = not switched[0]
if send_wins:
_id[0] += 1
observer.on_next(value)
create_timer()
def on_error(error):
on_error_wins = not switched[0]
if on_error_wins:
_id[0] += 1
observer.on_error(error)
def on_completed():
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)
return CompositeDisposable(subscription, timer)
return AnonymousObservable(subscribe)
def test_for_each_index_throws(self):
ex = Exception()
xs = Observable.throw(ex)
self.assertRaises(
Exception, lambda: xs.to_blocking().for_each(lambda x: _raise(ex)))
def on_error(self, error):
self.on_next(Observable.throw(error))
def timeout_with_selector(source,
first_timeout=None,
timeout_duration_mapper=None,
other=None) -> ObservableBase:
"""Returns the source observable sequence, switching to the other
observable sequence if a timeout is signaled.
1 - res = source.timeout_with_selector(rx.Observable.timer(500))
2 - res = source.timeout_with_selector(rx.Observable.timer(500),
lambda x: rx.Observable.timer(200))
3 - res = source.timeout_with_selector(rx.Observable.timer(500),
lambda x: rx.Observable.timer(200)),
rx.Observable.return_value(42))
first_timeout -- [Optional] Observable sequence that represents the
timeout for the first element. If not provided, this defaults to
Observable.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 Observable.throw().
Returns the source sequence switching to the other sequence in case
of a timeout.
"""
first_timeout = first_timeout or Observable.never()
other = other or Observable.throw(Exception('Timeout'))
def subscribe(observer, scheduler=None):
subscription = SerialDisposable()
timer = SerialDisposable()
original = SingleAssignmentDisposable()
subscription.disposable = original
switched = False
_id = [0]
def set_timer(timeout):
my_id = _id[0]
def timer_wins():
return _id[0] == my_id
d = SingleAssignmentDisposable()
timer.disposable = d
def on_next(x):
if timer_wins():
subscription.disposable = other.subscribe(
observer, scheduler)
d.dispose()
def on_error(e):
if timer_wins():
observer.on_error(e)
def on_completed():
if timer_wins():
subscription.disposable = other.subscribe(observer)
d.disposable = timeout.subscribe_(on_next, on_error, on_completed,
scheduler)
set_timer(first_timeout)
def observer_wins():
res = not switched
if res:
_id[0] += 1
return res
def on_next(x):
if observer_wins():
observer.on_next(x)
timeout = None
try:
timeout = timeout_duration_mapper(x)
except Exception as e:
observer.on_error(e)
return
set_timer(timeout)
def on_error(error):
if observer_wins():
observer.on_error(error)
def on_completed():
if observer_wins():
observer.on_completed()
original.disposable = source.subscribe_(on_next, on_error,
on_completed, scheduler)
return CompositeDisposable(subscription, timer)
return AnonymousObservable(subscribe)
def closing():
return Observable.throw(ex)
