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))
