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 __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 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 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 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 _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 _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 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 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 subscribe2(o): o.on_error('exception') return Disposable.empty()
def action(scheduler, state=None): xx[0] = state return Disposable.empty()
def inner_action(scheduler, state=None): yy[0] = state 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()