class AutoDetachObserver(ObserverBase):
def __init__(self, observer):
super(AutoDetachObserver, self).__init__()
self._observer = observer
self._subscription = SingleAssignmentDisposable()
def _on_next_core(self, value):
try:
self._observer.on_next(value)
except Exception:
self.dispose()
raise
def _on_error_core(self, error):
try:
self._observer.on_error(error)
finally:
self.dispose()
def _on_completed_core(self):
try:
self._observer.on_completed()
finally:
self.dispose()
def set_disposable(self, value):
self._subscription.disposable = value
subscription = property(fset=set_disposable)
def dispose(self):
super().dispose()
self._subscription.dispose()
class AutoDetachObserver(AbstractObserver):
def __init__(self, observer):
super(AutoDetachObserver, self).__init__(self._next, self._error, self._completed)
self.observer = observer
self.m = SingleAssignmentDisposable()
def _next(self, value):
try:
self.observer.on_next(value)
except Exception:
self.dispose()
raise
def _error(self, exn):
try:
self.observer.on_error(exn)
finally:
self.dispose()
def _completed(self):
try:
self.observer.on_completed()
finally:
self.dispose()
def set_disposable(self, value):
self.m.disposable = value
disposable = property(fset=set_disposable)
def dispose(self):
super(AutoDetachObserver, self).dispose()
self.m.dispose()
class ScheduledItem(object):
def __init__(self, scheduler, state, action, duetime, comparer=None):
self.scheduler = scheduler
self.state = state
self.action = action
self.duetime = duetime
self.comparer = comparer or default_sub_comparer
self.disposable = SingleAssignmentDisposable()
def invoke(self):
self.disposable.disposable = self.invoke_core()
def compare_to(self, other):
return self.comparer(self.duetime, other.duetime)
def cancel(self):
"""Cancels the work item by disposing the resource returned by
invoke_core as soon as possible."""
self.disposable.dispose()
def is_cancelled(self):
return self.disposable.is_disposed
def invoke_core(self):
return self.action(self.scheduler, self.state)
def __lt__(self, other):
return self.compare_to(other) < 0
def __gt__(self, other):
return self.compare_to(other) > 0
def __eq__(self, other):
return self.compare_to(other) == 0
class ScheduledItem(object):
def __init__(self, scheduler, state, action, duetime, comparer=None):
self.scheduler = scheduler
self.state = state
self.action = action
self.duetime = duetime
self.comparer = comparer or default_sub_comparer
self.disposable = SingleAssignmentDisposable()
def invoke(self):
self.disposable.disposable = self.invoke_core()
def compare_to(self, other):
return self.comparer(self.duetime, other.duetime)
def cancel(self):
"""Cancels the work item by disposing the resource returned by
invoke_core as soon as possible."""
self.disposable.dispose()
def is_cancelled(self):
return self.disposable.is_disposed
def invoke_core(self):
return self.action(self.scheduler, self.state)
def __lt__(self, other):
return self.compare_to(other) < 0
def __gt__(self, other):
return self.compare_to(other) > 0
def __eq__(self, other):
return self.compare_to(other) == 0
class ScheduledItem(object):
def __init__(self, scheduler, state, action, duetime):
self.scheduler = scheduler
self.state = state
self.action = action
self.duetime = duetime
self.disposable = SingleAssignmentDisposable()
def invoke(self):
ret = self.scheduler.invoke_action(self.action, self.state)
self.disposable.disposable = ret
def cancel(self):
"""Cancels the work item by disposing the resource returned by
invoke_core as soon as possible."""
self.disposable.dispose()
def is_cancelled(self):
return self.disposable.is_disposed
def __lt__(self, other):
return self.duetime < other.duetime
def __gt__(self, other):
return self.duetime > other.duetime
def __eq__(self, other):
return self.duetime == other.duetime
class AutoDetachObserver(AbstractObserver):
def __init__(self, observer):
super(AutoDetachObserver, self).__init__()
self.observer = observer
self.m = SingleAssignmentDisposable()
def next(self, value):
try:
self.observer.on_next(value)
except Exception as ex:
traceback.print_exc(file=sys.stdout)
self.dispose()
def error(self, exn):
try:
self.observer.on_error(exn)
finally:
self.dispose()
def completed(self):
try:
self.observer.on_completed()
finally:
self.dispose()
def set_disposable(self, value):
self.m.disposable = value
disposable = property(fset=set_disposable)
def dispose(self):
super(AutoDetachObserver, self).dispose()
self.m.dispose()
class AutoDetachObserver(AbstractObserver):
def __init__(self, observer):
super(AutoDetachObserver, self).__init__(self._next, self._error,
self._completed)
self.observer = observer
self.m = SingleAssignmentDisposable()
def _next(self, value):
try:
self.observer.on_next(value)
except Exception as ex:
self.dispose()
raise ex
def _error(self, exn):
try:
self.observer.on_error(exn)
finally:
self.dispose()
def _completed(self):
try:
self.observer.on_completed()
finally:
self.dispose()
def set_disposable(self, value):
self.m.disposable = value
disposable = property(fset=set_disposable)
def dispose(self):
super(AutoDetachObserver, self).dispose()
self.m.dispose()
class SingleStream(Observer, Observable):
"""The SingleStream.
A disposable observer that can be subscribed/chained with a single
observer. It's subscription property may be assigned an upstream
subscription that will be disposed together with the stream itself.
"""
def __init__(self) -> None:
self._observer = NoopObserver() # type: Observer
self._subscription = SingleAssignmentDisposable()
super().__init__()
def on_next(self, value: Any) -> None:
self._observer.on_next(value)
def on_error(self, error: Exception) -> None:
try:
self._observer.on_error(error)
finally:
self.dispose()
def on_completed(self) -> None:
try:
self._observer.on_completed()
finally:
self.dispose()
def subscribe(self,
observer: Observer = None,
scheduler: Scheduler = None) -> Disposable:
self._observer = observer
return Disposable.create(self.dispose)
def chain(self,
observer: Observer = None,
scheduler: Scheduler = None) -> "SingleStream":
self._observer = observer
return self
def set_subscription(self, value: Disposable):
"""Sets a subscription that will be disposed togeter with the
stream."""
self._subscription.disposable = value
subscription = property(fset=set_subscription,
doc="Sets the subscription.")
def dispose(self) -> None:
self._observer = NoopObserver()
self._subscription.dispose()
def test_futuredisposable_disposeafterset():
d = SingleAssignmentDisposable()
disposed = [False]
def action():
disposed[0] = True
dd = Disposable.create(action)
d.disposable = dd
assert dd == d.disposable
assert not disposed[0]
d.dispose()
assert disposed[0]
d.dispose()
assert disposed[0]
def test_futuredisposable_disposeafterset():
d = SingleAssignmentDisposable()
disposed = [False]
def action():
disposed[0] = True
dd = Disposable.create(action)
d.disposable = dd
assert dd == d.disposable
assert not disposed[0]
d.dispose()
assert disposed[0]
d.dispose()
assert disposed[0]
def test_futuredisposable_disposeafterset():
d = SingleAssignmentDisposable()
disposed = False
def action():
nonlocal disposed
disposed = True
dd = Disposable(action)
d.disposable = dd
assert dd == d.disposable
assert not disposed
d.dispose()
assert disposed
d.dispose()
assert disposed
def test_futuredisposable_disposebeforeset():
disposed = [False]
def dispose():
disposed[0] = True
d = SingleAssignmentDisposable()
dd = Disposable.create(dispose)
assert not disposed[0]
d.dispose()
assert not disposed[0]
d.disposable = dd
assert d.disposable == None
assert disposed[0]
d.dispose()
assert disposed[0]
def test_futuredisposable_disposeafterset():
d = SingleAssignmentDisposable()
disposed = False
def action():
nonlocal disposed
disposed = True
dd = Disposable(action)
d.disposable = dd
assert dd == d.disposable
assert not disposed
d.dispose()
assert disposed
d.dispose()
assert disposed
class JoinObserver(ObserverBase):
def __init__(self, source, on_error):
super(JoinObserver, self).__init__()
self.source = source
self.on_error = on_error
self.queue = []
self.active_plans = []
self.subscription = SingleAssignmentDisposable()
self.is_disposed = False
def _on_next_core(self, notification):
if not self.is_disposed:
if notification.kind == 'E':
self.on_error(notification.exception)
return
self.queue.append(notification)
active_plans = self.active_plans[:]
for plan in active_plans:
plan.match()
def _on_error_core(self, error):
return NotImplemented
def _on_completed_core(self):
return NotImplemented
def add_active_plan(self, active_plan):
self.active_plans.append(active_plan)
def subscribe(self):
self.subscription.disposable = self.source.materialize().subscribe(
self)
def remove_active_plan(self, active_plan):
self.active_plans.remove(active_plan)
if not self.active_plans:
self.dispose()
def dispose(self):
super(JoinObserver, self).dispose()
if not self.is_disposed:
self.is_disposed = True
self.subscription.dispose()
def test_futuredisposable_disposebeforeset():
disposed = [False]
def dispose():
disposed[0] = True
d = SingleAssignmentDisposable()
dd = Disposable.create(dispose)
assert not disposed[0]
d.dispose()
assert not disposed[0]
d.disposable = dd
assert d.disposable == None
assert disposed[0]
d.dispose()
assert disposed[0]
class JoinObserver(ObserverBase):
def __init__(self, source, on_error):
super(JoinObserver, self).__init__()
self.source = source
self.on_error = on_error
self.queue = []
self.active_plans = []
self.subscription = SingleAssignmentDisposable()
self.is_disposed = False
def _on_next_core(self, notification):
if not self.is_disposed:
if notification.kind == 'E':
self.on_error(notification.exception)
return
self.queue.append(notification)
active_plans = self.active_plans[:]
for plan in active_plans:
plan.match()
def _on_error_core(self, error):
return NotImplemented
def _on_completed_core(self):
return NotImplemented
def add_active_plan(self, active_plan):
self.active_plans.append(active_plan)
def subscribe(self):
self.subscription.disposable = self.source.materialize().subscribe(self)
def remove_active_plan(self, active_plan):
self.active_plans.remove(active_plan)
if not len(self.active_plans):
self.dispose()
def dispose(self):
super(JoinObserver, self).dispose()
if not self.is_disposed:
self.is_disposed = True
self.subscription.dispose()
def test_futuredisposable_disposebeforeset():
disposed = False
def dispose():
nonlocal disposed
disposed = True
d = SingleAssignmentDisposable()
dd = Disposable(dispose)
assert not disposed
d.dispose()
assert not disposed
d.disposable = dd
assert d.disposable == None
assert disposed
d.dispose()
assert disposed
def test_futuredisposable_disposebeforeset():
disposed = False
def dispose():
nonlocal disposed
disposed = True
d = SingleAssignmentDisposable()
dd = Disposable(dispose)
assert not disposed
d.dispose()
assert not disposed
d.disposable = dd
assert d.disposable == None
assert disposed
d.dispose()
assert disposed
