def subscribe(observer, scheduler=None): choice = [None] left_choice = 'L' right_choice = 'R', left_subscription = SingleAssignmentDisposable() right_subscription = SingleAssignmentDisposable() def choice_left(): if not choice[0]: choice[0] = left_choice right_subscription.dispose() def choice_right(): if not choice[0]: choice[0] = right_choice left_subscription.dispose() def on_next_left(value): with left_source.lock: choice_left() if choice[0] == left_choice: observer.on_next(value) def on_error_left(err): with left_source.lock: choice_left() if choice[0] == left_choice: observer.on_error(err) def on_completed_left(): with left_source.lock: choice_left() if choice[0] == left_choice: observer.on_completed() lelf_d = left_source.subscribe_(on_next_left, on_error_left, on_completed_left, scheduler) left_subscription.disposable = lelf_d def send_right(value): with left_source.lock: choice_right() if choice[0] == right_choice: observer.on_next(value) def on_error_right(err): with left_source.lock: choice_right() if choice[0] == right_choice: observer.on_error(err) def on_completed_right(): with left_source.lock: choice_right() if choice[0] == right_choice: observer.on_completed() right_d = right_source.subscribe_(send_right, on_error_right, on_completed_right, scheduler) right_subscription.disposable = right_d return CompositeDisposable(left_subscription, right_subscription)
def subscribe(observer): choice = None left_choice = 'L' right_choice = 'R', left_subscription = SingleAssignmentDisposable() right_subscription = SingleAssignmentDisposable() def choiceL(): nonlocal choice if not choice: choice = left_choice right_subscription.dispose() def choiceR(): nonlocal choice if not choice: choice = right_choice left_subscription.dispose() def on_left_next(left): choiceL() if choice == left_choice: observer.on_next(left) def on_left_error(err): choiceL() if choice == left_choice: observer.on_error(err) def on_left_completed(): choiceL() if choice == left_choice: observer.on_completed() left_subscription.disposable = left_source.subscribe( on_left_next, on_left_error, on_left_completed) def on_right_next(right): choiceR() if choice == right_choice: observer.on_next(right) def on_right_error(err): choiceR() if choice == right_choice: observer.on_error(err) def on_right_completed(): choiceR() if choice == right_choice: observer.on_completed() right_subscription.disposable = right_source.subscribe( on_right_next, on_right_error, on_right_completed) return CompositeDisposable(left_subscription, right_subscription)
def _schedule_relative_threadsafe(self, duetime, action, state=None): scheduler = self seconds = self.to_relative(duetime) / 1000.0 if seconds == 0: return scheduler.schedule(action, state) disposable = SingleAssignmentDisposable() def interval(): disposable.disposable = self.invoke_action(action, state) # the operations on the list used here are atomic, so there is no # need to protect its access with a lock handle = [] def stage2(): handle.append(self.loop.call_later(seconds, interval)) handle.append(self.loop.call_soon_threadsafe(stage2)) def dispose(): future = Future() def cancel_handle(): try: handle.pop().cancel() handle.pop().cancel() except Exception: pass future.set_result(0) self.loop.call_soon_threadsafe(cancel_handle) future.result() return CompositeDisposable(disposable, Disposable.create(dispose))
def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed at duetime. Keyword arguments: duetime -- {timedelta} Relative time after which to execute the action. action -- {Function} Action to be executed. Returns {Disposable} The disposable object used to cancel the scheduled action (best effort).""" scheduler = self seconds = self.to_relative(duetime) / 1000.0 if seconds == 0: return scheduler.schedule(action, state) disposable = SingleAssignmentDisposable() def interval(): disposable.disposable = self.invoke_action(action, state) handle = [self.loop.call_later(seconds, interval)] def dispose(): # nonlocal handle handle[0].cancel() return CompositeDisposable(disposable, Disposable.create(dispose))
def subscribe(observer): is_open = [False] def on_next(left): if is_open[0]: observer.on_next(left) def on_completed(): if is_open[0]: observer.on_completed() disposables = CompositeDisposable( source.subscribe(on_next, observer.on_error, on_completed)) right_subscription = SingleAssignmentDisposable() disposables.add(right_subscription) def on_next2(x): is_open[0] = True right_subscription.dispose() def on_completed2(): right_subscription.dispose() right_subscription.disposable = other.subscribe( on_next2, observer.on_error, on_completed2) return disposables
def action(this, state): if len(q) > 0: work = q.pop(0) else: is_acquired[0] = False return m1 = SingleAssignmentDisposable() d.add(m1) def on_next(x): observer.on_next(x) result = None try: result = selector(x) except Exception as ex: observer.on_error(ex) q.append(result) active_count[0] += 1 ensure_active() def on_complete(): d.remove(m1) active_count[0] -= 1 if active_count[0] == 0: observer.on_completed() m1.disposable = work.subscribe(on_next, observer.on_error, on_complete) this()
def on_next(inner_source): d = SingleAssignmentDisposable() with self.lock: latest[0] += 1 _id = latest[0] has_latest[0] = True inner_subscription.disposable = d # Check if Future or Observable inner_source = Observable.from_future(inner_source) def on_next(x): if latest[0] == _id: observer.on_next(x) def on_error(e): if latest[0] == _id: observer.on_error(e) def on_completed(): if latest[0] == _id: has_latest[0] = False if is_stopped[0]: observer.on_completed() d.disposable = inner_source.subscribe(on_next, on_error, on_completed)
def _wxtimer_schedule(self, time, action, state, periodic=False): scheduler = self msecs = self.to_relative(time) disposable = SingleAssignmentDisposable() periodic_state = [state] def interval(): if periodic: periodic_state[0] = action(periodic_state[0]) else: disposable.disposable = action(scheduler, state) log.debug("timeout: %s", msecs) if msecs == 0: msecs = 1 # wx.Timer doesn't support zero. timer = self._timer_class(interval) timer.Start( msecs, self.wx.TIMER_CONTINUOUS if periodic else self.wx.TIMER_ONE_SHOT) self._timers.add(timer) def dispose(): timer.Stop() self._timers.remove(timer) return CompositeDisposable(disposable, Disposable.create(dispose))
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)
def on_next(inner_source): nonlocal latest, has_latest d = SingleAssignmentDisposable() latest += 1 _id = latest has_latest = True inner_subscription.disposable = d def on_next(x): if latest == _id: observer.on_next(x) def on_error(e): if latest == _id: observer.on_error(e) def on_completed(): nonlocal has_latest if latest == _id: has_latest = False if is_stopped: observer.on_completed() d.disposable = inner_source.subscribe(on_next, on_error, on_completed)
def subscribe(observer): m = SingleAssignmentDisposable() group = CompositeDisposable() is_stopped = False group.add(m) def on_next(inner_source): inner_subscription = SingleAssignmentDisposable() group.add(inner_subscription) def on_complete(): nonlocal group group.remove(inner_subscription) if is_stopped and group.length == 1: observer.on_completed() disposable = inner_source.subscribe(observer.on_next, observer.on_error, on_complete) inner_subscription.disposable = disposable def on_complete(): nonlocal is_stopped is_stopped = True if group.length == 1: observer.on_completed() m.disposable = sources.subscribe(on_next, observer.on_error, on_complete) return group
def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed after duetime. Keyword arguments: duetime -- {timedelta} Relative time after which to execute the action. action -- {Function} Action to be executed. Returns {Disposable} The disposable object used to cancel the scheduled action (best effort).""" from twisted.internet.task import deferLater scheduler = self seconds = self.to_relative(duetime) / 1000.0 disposable = SingleAssignmentDisposable() def interval(): disposable.disposable = action(scheduler, state) log.debug("timeout: %s", seconds) handle = deferLater(self.reactor, seconds, interval).addErrback(lambda _: None) def dispose(): if not handle.called: handle.cancel() return CompositeDisposable(disposable, Disposable.create(dispose))
def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed after duetime. Keyword arguments: duetime -- {timedelta} Relative time after which to execute the action. action -- {Function} Action to be executed. Returns {Disposable} The disposable object used to cancel the scheduled action (best effort).""" scheduler = self msecs = self.to_relative(duetime) if msecs == 0: return scheduler.schedule(action, state) disposable = SingleAssignmentDisposable() def interval(): disposable.disposable = action(scheduler, state) log.debug("timeout: %s", msecs) alarm = self.master.after(msecs, interval) def dispose(): # nonlocal alarm self.master.after_cancel(alarm) return CompositeDisposable(disposable, Disposable(dispose))
def on_next(x): nonlocal value, has_value, _id throttle = None try: throttle = throttle_duration_selector(x) except Exception as e: observer.on_error(e) return has_value = True value = x _id += 1 current_id = _id d = SingleAssignmentDisposable() cancelable.disposable = d def on_next(x): nonlocal has_value if has_value and _id == current_id: observer.on_next(value) has_value = False d.dispose() def on_completed(): nonlocal has_value if has_value and _id == current_id: observer.on_next(value) has_value = False d.dispose() d.disposable = throttle.subscribe(on_next, observer.on_error, on_completed)
def subscribe(observer): m = SingleAssignmentDisposable() group = CompositeDisposable() is_stopped = [False] group.add(m) def on_next(inner_source): inner_subscription = SingleAssignmentDisposable() group.add(inner_subscription) inner_source = Observable.from_future(inner_source) def on_complete(): group.remove(inner_subscription) if is_stopped[0] and group.length == 1: observer.on_completed() disposable = inner_source.subscribe( observer.on_next, observer.on_error, on_complete) inner_subscription.disposable = disposable def on_complete(): is_stopped[0] = True if group.length == 1: observer.on_completed() m.disposable = sources.subscribe(on_next, observer.on_error, on_complete) return group
def _gtk_schedule(self, time, action, state, periodic=False): # Do not import GLib into global scope because Qt and GLib # don't like each other there from gi.repository import GLib scheduler = self msecs = self.to_relative(time) disposable = SingleAssignmentDisposable() periodic_state = [state] stopped = [False] def timer_handler(_): if stopped[0]: return False if periodic: periodic_state[0] = action(periodic_state[0]) else: disposable.disposable = action(scheduler, state) return periodic GLib.timeout_add(msecs, timer_handler, None) def dispose(): stopped[0] = True return CompositeDisposable(disposable, Disposable.create(dispose))
def on_next_right(value): with self.lock: _id = right_id[0] right_id[0] += 1 right_map[_id] = value md = SingleAssignmentDisposable() group.add(md) def expire(): del right_map[_id] group.remove(md) try: duration = right_duration_selector(value) except Exception as e: for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) return def on_error(e): with self.lock: for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) md.disposable = duration.take(1).subscribe(nothing, on_error, expire) with self.lock: for left_value in left_map.values(): left_value.on_next(value)
def subscribe(observer): has_current = [False] is_stopped = [False] m = SingleAssignmentDisposable() g = CompositeDisposable() g.add(m) def on_next(inner_source): if not has_current[0]: has_current[0] = True inner_source = Observable.from_future(inner_source) inner_subscription = SingleAssignmentDisposable() g.add(inner_subscription) def on_completed_inner(): g.remove(inner_subscription) has_current[0] = False if is_stopped[0] and len(g) == 1: observer.on_completed() inner_subscription.disposable = inner_source.subscribe( observer.on_next, observer.on_error, on_completed_inner) def on_completed(): is_stopped[0] = True if not has_current[0] and len(g) == 1: observer.on_completed() m.disposable = sources.subscribe(on_next, observer.on_error, on_completed) return g
def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed after duetime. Keyword arguments: duetime -- {timedelta} Relative time after which to execute the action. action -- {Function} Action to be executed. Returns {Disposable} The disposable object used to cancel the scheduled action (best effort).""" scheduler = self seconds = scheduler.to_relative(duetime) / 1000.0 if not seconds: return scheduler.schedule(action, state) disposable = SingleAssignmentDisposable() def interval(): disposable.disposable = self.invoke_action(action, state) log.debug("timeout: %s", seconds) handle = self.loop.call_later(seconds, interval) def dispose(): self.loop.remove_timeout(handle) return CompositeDisposable(disposable, Disposable.create(dispose))
def action(action1, state=None): current = None def on_error(exn): nonlocal last_exception last_exception = exn action1() if is_disposed: return try: current = next(e) except StopIteration: if last_exception: observer.on_error(last_exception) else: observer.on_completed() except Exception as ex: observer.on_error(ex) else: d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = current.subscribe(observer.on_next, on_error, observer.on_completed)
def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed after duetime. Keyword arguments: duetime -- {timedelta} Relative time after which to execute the action. action -- {Function} Action to be executed. Returns {Disposable} The disposable object used to cancel the scheduled action (best effort).""" scheduler = self seconds = self.to_relative(duetime) / 1000.0 disposable = SingleAssignmentDisposable() def interval(): disposable.disposable = action(scheduler, state) log.debug("timeout: %s", seconds) handle = [self.reactor.callLater(seconds, interval)] def dispose(): handle[0].cancel() return CompositeDisposable(disposable, Disposable(dispose))
def subscribe(observer, scheduler=None): group = CompositeDisposable() is_stopped = [False] m = SingleAssignmentDisposable() group.add(m) def on_next(inner_source): inner_subscription = SingleAssignmentDisposable() group.add(inner_subscription) inner_source = Observable.from_future(inner_source) if is_future( inner_source) else inner_source @synchronized(source.lock) def on_completed(): group.remove(inner_subscription) if is_stopped[0] and len(group) == 1: observer.on_completed() on_next = synchronized(source.lock)(observer.on_next) on_error = synchronized(source.lock)(observer.on_error) disposable = inner_source.subscribe_(on_next, on_error, on_completed, scheduler) inner_subscription.disposable = disposable def on_completed(): is_stopped[0] = True if len(group) == 1: observer.on_completed() m.disposable = source.subscribe_(on_next, observer.on_error, on_completed, scheduler) return group
def _qtimer_schedule(self, time, action, state, periodic=False): scheduler = self msecs = self.to_relative(time) disposable = SingleAssignmentDisposable() periodic_state = [state] def interval(): if periodic: periodic_state[0] = action(periodic_state[0]) else: disposable.disposable = action(scheduler, state) log.debug("timeout: %s", msecs) timer = self.qtcore.QTimer() timer.setSingleShot(not periodic) timer.timeout.connect(interval) timer.setInterval(msecs) timer.start() self._timers.add(timer) def dispose(): timer.stop() self._timers.remove(timer) return CompositeDisposable(disposable, Disposable.create(dispose))
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 on_next(notification): log.debug("observable_delay_timespan:subscribe:on_next()") should_run = False with self.lock: if notification.value.kind == 'E': del queue[:] queue.append(notification) exception[0] = notification.value.exception should_run = not running[0] else: queue.append(Timestamp(value=notification.value, timestamp=notification.timestamp + duetime)) should_run = not active[0] active[0] = True if should_run: if exception[0]: log.error("*** Exception: %s", exception[0]) observer.on_error(exception[0]) else: d = SingleAssignmentDisposable() cancelable.disposable = d def action(this): if exception[0]: log.error("observable_delay_timespan:subscribe:on_next:action(), exception: %s", exception[0]) return with self.lock: running[0] = True while True: result = None if len(queue) and queue[0].timestamp <= scheduler.now(): result = queue.pop(0).value if result: result.accept(observer) if not result: break should_recurse = False recurse_duetime = 0 if len(queue) : should_recurse = True diff = queue[0].timestamp - scheduler.now() zero = timedelta(0) if isinstance(diff, timedelta) else 0 recurse_duetime = max(zero, diff) else: active[0] = False ex = exception[0] running[0] = False if ex: observer.on_error(ex) elif should_recurse: this(recurse_duetime) d.disposable = scheduler.schedule_recursive_with_relative(duetime, action)
def on_next(x): throttle = None try: throttle = throttle_duration_mapper(x) except Exception as e: observer.on_error(e) return has_value[0] = True value[0] = x _id[0] += 1 current_id = _id[0] d = SingleAssignmentDisposable() cancelable.disposable = d def on_next(x): if has_value[0] and _id[0] == current_id: observer.on_next(value[0]) has_value[0] = False d.dispose() def on_completed(): if has_value[0] and _id[0] == current_id: observer.on_next(value[0]) has_value[0] = False d.dispose() d.disposable = throttle.subscribe_(on_next, observer.on_error, on_completed, scheduler)
def action(scheduler, state): if queue: work = queue.pop(0) else: is_acquired[0] = False return sad = SingleAssignmentDisposable() d.add(sad) def on_next(value): observer.on_next(value) result = None try: result = mapper(value) except Exception as ex: observer.on_error(ex) return queue.append(result) active_count[0] += 1 ensure_active() def on_complete(): d.remove(sad) active_count[0] -= 1 if active_count[0] == 0: observer.on_completed() sad.disposable = work.subscribe_(on_next, observer.on_error, on_complete, scheduler) m.disposable = scheduler.schedule(action)
def subscribe_all(parent, *children): values = [NO_VALUE for _ in children] def subscribe_child(i, child): subscription = SingleAssignmentDisposable() def on_next(value): with parent.lock: values[i] = value subscription.disposable = child.subscribe( on_next, observer.on_error) return subscription parent_subscription = SingleAssignmentDisposable() def on_next(value): with parent.lock: if NO_VALUE not in values: try: result = result_selector(value, *values) except Exception as error: observer.on_error(error) else: observer.on_next(result) parent_subscription.disposable = parent.subscribe( on_next, observer.on_error, observer.on_completed) return listify_args( parent_subscription, *(subscribe_child(*a) for a in enumerate(children)))
def on_next_right(value): duration = None current_id = right_id[0] right_id[0] += 1 md = SingleAssignmentDisposable() right_map[current_id] = value group.add(md) def expire(): if current_id in right_map: del right_map[current_id] if not len(right_map) and right_done[0]: observer.on_completed() return group.remove(md) try: duration = right_duration_selector(value) except Exception as exception: log.error("*** Exception: %s" % exception) observer.on_error(exception) return md.disposable = duration.take(1).subscribe(noop, observer.on_error, lambda: expire()) for val in left_map.values(): try: result = result_selector(val, value) except Exception as exception: log.error("*** Exception: %s" % exception) observer.on_error(exception) return observer.on_next(result)
def _gtk_schedule(self, time, action, state, periodic=False): scheduler = self msecs = self.to_relative(time) disposable = SingleAssignmentDisposable() periodic_state = [state] stopped = [False] def timer_handler(_): if stopped[0]: return False if periodic: periodic_state[0] = action(periodic_state[0]) else: disposable.disposable = action(scheduler, state) return periodic GLib.timeout_add(msecs, timer_handler, None) def dispose(): stopped[0] = True return CompositeDisposable(disposable, Disposable.create(dispose))