def _process_request(self, number_of_items):
if self.enable_queue:
#console.log('queue length', self.queue.length)
while len(self.queue) >= number_of_items and number_of_items > 0:
# console.log('number of items', number_of_items)
self.subject.on_next(self.queue.shift())
number_of_items -= 1
if len(self.queue):
return {
"number_of_items": number_of_items,
"return_value": True
}
else:
return {
"number_of_items": number_of_items,
"return_value": False
}
if self.has_failed:
self.subject.on_error(self.error)
self.controlled_disposable.dispose()
self.controlled_disposable = Disposable.empty()
elif self.has_completed:
self.subject.on_completed()
self.controlled_disposable.dispose()
self.controlled_disposable = Disposable.empty()
return {"number_of_items": number_of_items, "return_value": False}
def __init__(self, conn):
super(HttpParser, self).__init__()
self.conn = conn
self.buf = StringIO()
self.requests_in = Subject()
self.responses_out = HttpWriter(conn)
self.keep_alive_timeout_dispose = Disposable.empty()
self.read_timeout_dispose = Disposable.empty()
self.keep_alive_timer_on()
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 __init__(self, enable_queue=True):
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.controlled_disposable = Disposable.empty()
def __init__(self, enable_queue=True):
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.controlled_disposable = Disposable.empty()
def __subscribe(self, observer):
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 _subscribe(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 action2(scheduler1, state3):
if is_added:
group.remove(d)
else:
is_done[0] = True
recursive_action(state3)
return Disposable.empty()
def action(scheduler, state=None):
if is_added:
group.remove(d)
else:
is_done[0] = True
recursive_action(state)
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 action2(scheduler1, state3):
nonlocal is_done
if is_added:
group.remove(d)
else:
is_done = True
recursive_action(state3)
return Disposable.empty()
def fix_subscriber(subscriber):
"""Fix subscriber to check for None or function returned to
decorate as Disposable"""
if subscriber is None:
subscriber = Disposable.empty()
elif type(subscriber) == types.FunctionType:
subscriber = Disposable(subscriber)
return subscriber
def action(scheduler, state=None):
nonlocal is_done
#print "action", scheduler1, state3
if is_added:
group.remove(d)
else:
is_done = True
recursive_action(state)
return Disposable.empty()
def action(scheduler, state=None):
nonlocal is_done
#print "action", scheduler1, state3
if is_added:
group.remove(d)
else:
is_done = True
recursive_action(state)
return Disposable.empty()
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(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(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.subject.distinct_until_changed().subscribe(on_next)
return CompositeDisposable(subscription, connection[0], pausable)
def __subscribe(self, observer):
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(self, observer):
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(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.subject.distinct_until_changed().subscribe(on_next)
return CompositeDisposable(subscription, connection[0], pausable)
def _process_request(self, number_of_items):
if self.enable_queue:
#console.log('queue length', self.queue.length)
while len(self.queue) >= number_of_items and number_of_items > 0:
# console.log('number of items', number_of_items)
self.subject.on_next(self.queue.shift())
number_of_items -= 1
if len(self.queue):
return { "number_of_items": number_of_items, "return_value": True }
else:
return { "number_of_items": number_of_items, "return_value": False }
if self.has_failed:
self.subject.on_error(self.error)
self.controlled_disposable.dispose()
self.controlled_disposable = Disposable.empty()
elif self.has_completed:
self.subject.on_completed()
self.controlled_disposable.dispose()
self.controlled_disposable = Disposable.empty()
return { "number_of_items": number_of_items, "return_value": False }
def request(self, number):
check_disposed(self)
self.dispose_current_request()
r = self._process_request(number)
number = r["number_of_items"]
if not r["return_value"]:
self.requested_count = number
def action():
self.requested_count = 0
self.requested_disposable = Disposable(action)
return self.requested_disposable
else:
return Disposable.empty()
def request(self, number):
check_disposed(self)
self.dispose_current_request()
r = self._process_request(number)
number = r["number_of_items"]
if not r["return_value"]:
self.requested_count = number
def action():
self.requested_count = 0
self.requested_disposable = Disposable(action)
return self.requested_disposable
else:
return Disposable.empty()
def _subscribe(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 _subscribe(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(scheduler, state):
notification.accept(observer)
return Disposable.empty()
def on_next(b):
if b:
connection[0] = conn.connect()
else:
connection[0].dispose()
connection[0] = Disposable.empty()
def subscribe1(o):
o.on_next(1)
return Disposable.empty()
def subscribe3(o):
o.on_completed()
return Disposable.empty()
def inner_action(scheduler, y):
yy[0] = y
return Disposable.empty()
def subscribe3(o):
o.on_completed()
return Disposable.empty()
def subscribe(o):
o.on_completed()
o.on_next(100)
o.on_error("ex")
o.on_completed()
return Disposable.empty()
def subscribe(observer):
return Disposable.empty()
def test_emptydisposable():
d = Disposable.empty()
assert d
d.dispose()
def action_dispose(scheduler, state):
"""Called at dispose time. Defaults to 1000"""
subscription[0].dispose()
return Disposable.empty()
def action_create(scheduler, state):
"""Called at create time. Defaults to 100"""
source[0] = create()
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 invoke_action(self, action, state=None):
action(self, state)
return Disposable.empty()
def inner_action(scheduler, y):
nonlocal yy
yy = y
return Disposable.empty()
def subscribe1(o):
o.on_next(1)
return Disposable.empty()
def inner_action(scheduler, state):
nonlocal yy
yy = state
return Disposable.empty()
def action(scheduler, state=None):
nonlocal xx
xx = state
return Disposable.empty()
def subscribe(o):
o.on_error(ex)
o.on_next(100)
o.on_error('foo')
o.on_completed()
return Disposable.empty()
def inner_action(scheduler, y):
nonlocal yy
yy = y
return Disposable.empty()
def subscribe2(o):
o.on_error('exception')
return Disposable.empty()
def invoke_action(self, action, state=None):
action(self, state)
return Disposable.empty()
def action(scheduler, state=None):
xx[0] = state
return Disposable.empty()
def action(scheduler, state=None):
nonlocal xx
xx = state
return Disposable.empty()
def inner_action(scheduler, state=None):
yy[0] = state
return Disposable.empty()
def inner_action(scheduler, state):
nonlocal yy
yy = state
return Disposable.empty()
def subscribe2(o):
o.on_error('exception')
return Disposable.empty()
def action(scheduler, state):
for observer in observable.observers:
notification.accept(observer)
return Disposable.empty()
def subscribe(_):
return Disposable.empty()
def dispose_current_request(self):
self.requested_disposable.dispose()
self.requested_disposable = Disposable.empty()
