def test_groupdisposable_contains():
d1 = Disposable.empty()
d2 = Disposable.empty()
g = CompositeDisposable(d1, d2)
assert g.length == 2
assert g.contains(d1)
assert g.contains(d2)
def test_groupdisposable_contains():
d1 = Disposable.empty()
d2 = Disposable.empty()
g = CompositeDisposable(d1, d2)
assert g.length == 2
assert g.contains(d1)
assert g.contains(d2)
def _subscribe_core(self, observer):
with self.lock:
self.check_disposed()
if not self.is_stopped:
self.observers.append(observer)
return InnerSubscription(self, observer)
if self.exception:
observer.on_error(self.exception)
return Disposable.empty()
observer.on_completed()
return Disposable.empty()
def wrapped_action(self, state):
try:
return action(parent._get_recursive_wrapper(self), state)
except Exception as ex:
if not parent._handler(ex):
raise Exception(ex)
return Disposable.empty()
def wrapped_action(self, state):
try:
return action(parent._get_recursive_wrapper(self), state)
except Exception as ex:
if not parent._handler(ex):
raise Exception(ex)
return Disposable.empty()
def schedule_work(_, state3):
action(state3, inner_action)
if is_added:
group.remove(d)
else:
is_done[0] = True
return Disposable.empty()
def disposable(self):
"""Returns a dependent disposable that when disposed decreases the
refcount on the underlying disposable."""
with self.lock:
if self.is_disposed:
return Disposable.empty()
else:
self.count += 1
return self.InnerDisposable(self)
def disposable(self):
"""Returns a dependent disposable that when disposed decreases the
refcount on the underlying disposable."""
with self.lock:
if self.is_disposed:
return Disposable.empty()
self.count += 1
return self.InnerDisposable(self)
def __init__(self, enable_queue=True, scheduler=None):
super(ControlledSubject, self).__init__(self._subscribe)
self.subject = Subject()
self.enable_queue = enable_queue
self.queue = [] if enable_queue else None
self.requested_count = 0
self.requested_disposable = Disposable.empty()
self.error = None
self.has_failed = False
self.has_completed = False
self.scheduler = scheduler or current_thread_scheduler
def __init__(self, enable_queue=True, scheduler=None):
super(ControlledSubject, self).__init__()
self.subject = Subject()
self.enable_queue = enable_queue
self.queue = [] if enable_queue else None
self.requested_count = 0
self.requested_disposable = Disposable.empty()
self.error = None
self.has_failed = False
self.has_completed = False
self.scheduler = scheduler or current_thread_scheduler
def subscribe(observer):
disposable = Disposable.empty()
try:
resource = resource_factory()
if resource:
disposable = resource
source = observable_factory(resource)
except Exception as exception:
d = Observable.throw_exception(exception).subscribe(observer)
return CompositeDisposable(d, disposable)
return CompositeDisposable(source.subscribe(observer), disposable)
def _subscribe_core(self, observer):
conn = self.source.publish()
subscription = conn.subscribe(observer)
connection = [Disposable.empty()]
def on_next(b):
if b:
connection[0] = conn.connect()
else:
connection[0].dispose()
connection[0] = Disposable.empty()
pausable = self.pauser.distinct_until_changed().subscribe(on_next)
return CompositeDisposable(subscription, connection[0], pausable)
def _subscribe_core(self, observer):
conn = self.source.publish()
subscription = conn.subscribe(observer)
connection = [Disposable.empty()]
def on_next(b):
if b:
connection[0] = conn.connect()
else:
connection[0].dispose()
connection[0] = Disposable.empty()
pausable = self.pauser.distinct_until_changed().subscribe(on_next)
return CompositeDisposable(subscription, connection[0], pausable)
def unsafe_subscribe(self, observer, scheduler, subscribe_scheduler):
# self.scheduler = self.scheduler or scheduler
source = self
em = scheduler.get_execution_model()
inner_subscription = self.InnerSubscription(source=self,
observer=observer,
scheduler=scheduler,
em=em)
with self.lock:
if not self.is_stopped:
# get current buffer index
current_idx = self.buffer.last_idx - 1
self.current_index[inner_subscription] = current_idx
self.inactive_subsriptions.append(inner_subscription)
return Disposable.empty()
if self.exception:
observer.on_error(self.exception)
return Disposable.empty()
observer.on_completed()
return Disposable.empty()
def _subscribe_core(self, observer):
ex = None
with self.lock:
self.check_disposed()
if not self.is_stopped:
self.observers.append(observer)
observer.on_next(self.value)
return InnerSubscription(self, observer)
ex = self.exception
if ex:
observer.on_error(ex)
else:
observer.on_completed()
return Disposable.empty()
def _subscribe_core(self, observer, scheduler=None):
with self.lock:
self.check_disposed()
if not self.is_stopped:
self.observers.append(observer)
return InnerSubscription(self, observer)
ex = self.exception
hv = self.has_value
v = self.value
if ex:
observer.on_error(ex)
elif hv:
observer.on_next(v)
observer.on_completed()
else:
observer.on_completed()
return Disposable.empty()
def _subscribe_core(self, observer):
with self.lock:
self.check_disposed()
if not self.is_stopped:
self.observers.append(observer)
return InnerSubscription(self, observer)
ex = self.exception
hv = self.has_value
v = self.value
if ex:
observer.on_error(ex)
elif hv:
observer.on_next(v)
observer.on_completed()
else:
observer.on_completed()
return Disposable.empty()
def action_subscribe(scheduler, state):
"""Called at subscribe time. Defaults to 200"""
subscription[0] = source[0].subscribe(observer)
return Disposable.empty()
def on_next(b):
if b:
connection[0] = conn.connect()
else:
connection[0].dispose()
connection[0] = Disposable.empty()
def action_create(scheduler, state):
"""Called at create time. Defaults to 100"""
source[0] = create()
return Disposable.empty()
def action(scheduler, state=None):
xx[0] = state
return Disposable.empty()
def action(scheduler, state):
notification.accept(observer)
return Disposable.empty()
def action(scheduler, state=None):
xx[0] = state
return Disposable.empty()
def invoke_action(self, action, state=None):
ret = action(self, state)
if isinstance(ret, Disposable):
return ret
return Disposable.empty()
def subscribe2(o):
o.on_error("exception")
return Disposable.empty()
def test_emptydisposable():
d = Disposable.empty()
assert d
d.dispose()
def subscribe(o):
o.on_error(ex)
o.on_next(100)
o.on_error("foo")
o.on_completed()
return Disposable.empty()
def subscribe1(o):
o.on_next(1)
return Disposable.empty()
def action(scheduler, state):
for observer in observable.observers[:]:
notification.accept(observer)
return Disposable.empty()
def inner_action(scheduler, state=None):
yy[0] = state
return Disposable.empty()
def inner_action(scheduler, y):
yy[0] = y
return Disposable.empty()
def action_dispose(scheduler, state):
"""Called at dispose time. Defaults to 1000"""
subscription[0].dispose()
return Disposable.empty()
def inner_action(scheduler, y):
yy[0] = y
return Disposable.empty()
def action(_, __):
observer.on_next(self.elem)
observer.on_completed()
Disposable.empty()
def subscribe(o, observer=None):
o.on_error(ex)
o.on_next(100)
o.on_error('foo')
o.on_completed()
return Disposable.empty()
def action_dispose(scheduler, state):
"""Called at dispose time. Defaults to 1000"""
subscription[0].dispose()
return Disposable.empty()
def subscribe2(o):
o.on_error('exception')
return Disposable.empty()
def unsafe_subscribe(self, observer: Observer, scheduler: Scheduler,
subscribe_scheduler: Scheduler):
self.observer = observer
return Disposable.empty()
def on_subscribe_completed(self, subscriber: Subscriber, ex):
if ex is not None:
subscriber.observer.on_error(ex)
else:
subscriber.observer.on_completed()
return Disposable.empty()
def action_subscribe(scheduler, state):
"""Called at subscribe time. Defaults to 200"""
subscription[0] = source[0].subscribe(observer, scheduler)
return Disposable.empty()
def invoke_action(self, action, state=None):
ret = action(self, state)
if isinstance(ret, Disposable):
return ret
return Disposable.empty()
def subscribe(o, observer=None):
o.on_next(1)
o.on_next(2)
return Disposable.empty()
def test_emptydisposable():
d = Disposable.empty()
assert d
d.dispose()
def subscribe1(o):
o.on_next(1)
return Disposable.empty()
def on_next(b):
if b:
connection[0] = conn.connect()
else:
connection[0].dispose()
connection[0] = Disposable.empty()
def subscribe3(o):
o.on_completed()
return Disposable.empty()
def action(scheduler, state):
for observer in observable.observers[:]:
notification.accept(observer)
return Disposable.empty()
def subscribe(_):
return Disposable.empty()
def inner_action(scheduler, state=None):
yy[0] = state
return Disposable.empty()
def subscribe3(o):
o.on_completed()
return Disposable.empty()
def subscribe(_):
return Disposable.empty()
