class O(Observer):
def __init__(self, parent, sourceObserver):
self.parent = parent
self.sourceObserver = sourceObserver
self.subscription = SingleAssignmentDisposable()
def setdisposable(self, value):
self.subscription.disposable = value
disposable = property(None, setdisposable)
def onNext(self, value):
with self.parent.gate:
self.parent.observer.onCompleted()
self.parent.dispose()
def onError(self, exception):
with self.parent.gate:
self.parent.observer.onError(exception)
self.parent.dispose()
def onCompleted(self):
with self.parent.gate:
self.sourceObserver.open = True
self.subscription.dispose()
def on_next(inner_source: Union[Observable, Future]):
nonlocal source
d = SingleAssignmentDisposable()
with source.lock:
latest[0] += 1
_id = latest[0]
has_latest[0] = True
inner_subscription.disposable = d
# Check if Future or Observable
if is_future(inner_source):
obs = from_future(cast(Future, inner_source))
else:
obs = cast(Observable, inner_source)
def on_next(x: Any) -> None:
if latest[0] == _id:
observer.on_next(x)
def on_error(e: Exception) -> None:
if latest[0] == _id:
observer.on_error(e)
def on_completed() -> None:
if latest[0] == _id:
has_latest[0] = False
if is_stopped[0]:
observer.on_completed()
d.disposable = obs.subscribe_(on_next,
on_error,
on_completed,
scheduler=scheduler)
class AutoDetachObserver(typing.Observer):
def __init__(self,
on_next: Optional[typing.OnNext] = None,
on_error: Optional[typing.OnError] = None,
on_completed: Optional[typing.OnCompleted] = None
) -> Any:
self._on_next = on_next or noop
self._on_error = on_error or default_error
self._on_completed = on_completed or noop
self._subscription = SingleAssignmentDisposable()
self.is_stopped = False
def on_next(self, value: Any) -> None:
if self.is_stopped:
return
try:
self._on_next(value)
except Exception:
self.dispose()
raise
def on_error(self, error) -> None:
if self.is_stopped:
return
self.is_stopped = True
try:
self._on_error(error)
finally:
self.dispose()
def on_completed(self) -> None:
if self.is_stopped:
return
self.is_stopped = True
try:
self._on_completed()
finally:
self.dispose()
def set_disposable(self, value: typing.Disposable):
self._subscription.disposable = value
subscription = property(fset=set_disposable)
def dispose(self) -> None:
self.is_stopped = True
self._subscription.dispose()
def fail(self, exn: Exception) -> bool:
if self.is_stopped:
return False
self.is_stopped = True
self._on_error(exn)
return True
class ScheduledItem(Generic[typing.TState]): # pylint: disable=unsubscriptable-object
def __init__(self, scheduler: SchedulerBase,
state: Optional[typing.TState],
action: typing.ScheduledAction, duetime: typing.AbsoluteTime):
self.scheduler = scheduler
self.state = state
self.action = action
self.duetime = duetime
self.disposable = SingleAssignmentDisposable()
def invoke(self) -> None:
ret = self.scheduler.invoke_action(self.action, self.state)
self.disposable.disposable = ret
def cancel(self) -> None:
"""Cancels the work item by disposing the resource returned by
invoke_core as soon as possible."""
self.disposable.dispose()
def is_cancelled(self) -> bool:
return self.disposable.is_disposed
def __lt__(self, other):
return self.duetime < other.duetime
def __gt__(self, other):
return self.duetime > other.duetime
def __eq__(self, other):
return self.duetime == other.duetime
def run(self):
self.scheduler = self.parent.scheduler
self.cancelTimer = SerialDisposable()
self.gate = RLock()
self.active = False # as soon as a value arrived
self.running = False # on relative: True, on absolute: True after absolute time
self.queue = deque()
self.hasCompleted = False
self.completeAt = 0
self.hasFailed = False
self.exception = None
self.delay = 0
self.startTime = self.scheduler.now()
if self.parent.isAbsolute:
self.ready = False
self.cancelTimer.disposable = self.scheduler.scheduleWithAbsolute(
self.parent.dueTime, self.start)
else:
self.ready = True
self.delay = Scheduler.normalize(self.parent.dueTime)
self.sourceSubscription = SingleAssignmentDisposable()
self.sourceSubscription.disposable = self.parent.source.subscribeSafe(
self)
return CompositeDisposable(self.sourceSubscription,
self.cancelTimer)
def on_next_right(value):
nonlocal right_id
duration = None
current_id = right_id
right_id += 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:
observer.on_completed()
return group.remove(md)
try:
duration = right_duration_mapper(value)
except Exception as exception:
observer.on_error(exception)
return
md.disposable = duration.pipe(take(1)).subscribe_(
noop, observer.on_error, lambda: expire(), scheduler)
for val in left_map.values():
result = (val, value)
observer.on_next(result)
def __init__(self, observer, disposable = None):
super(AutoDetachObserver, self).__init__()
self.observer = observer
self.m = SingleAssignmentDisposable()
if disposable != None:
self.m.disposable = disposable
def subscribe(observer, scheduler=None):
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()
subs = source.subscribe_(on_next, observer.on_error, on_completed,
scheduler)
subscriptions = CompositeDisposable(subs)
right_subscription = SingleAssignmentDisposable()
subscriptions.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, scheduler)
return subscriptions
def subscribe(observer, scheduler=None):
d1 = SingleAssignmentDisposable()
subscription = SerialDisposable()
subscription.disposable = d1
def on_error(exception):
try:
result = handler(exception, source)
except Exception as ex: # By design. pylint: disable=W0703
observer.on_error(ex)
return
result = rx.from_future(result) if is_future(result) else result
d = SingleAssignmentDisposable()
subscription.disposable = d
d.disposable = result.subscribe(observer, scheduler=scheduler)
d1.disposable = source.subscribe_(
observer.on_next,
on_error,
observer.on_completed,
scheduler
)
return subscription
def schedulePeriodicWithState(self, state, period, action):
failed = False
failureLock = RLock
d = SingleAssignmentDisposable()
def scheduled(_state):
with failureLock:
nonlocal failed
if failed:
return None
try:
return action(_state)
except Exception as e:
failed = True
if not self.handler(e):
raise e
d.dispose()
return None
d.disposable = self._scheduler.schedulePeriodicWithState(
state, period, scheduled)
return d
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 = 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)
subscription = inner_source.subscribe_(on_next, on_error,
on_completed, scheduler)
inner_subscription.disposable = subscription
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 on_next(inner_source: Observable):
nonlocal source
d = SingleAssignmentDisposable()
with source.lock:
latest[0] += 1
_id = latest[0]
has_latest[0] = True
inner_subscription.disposable = d
# Check if Future or Observable
inner_source = from_future(inner_source) if is_future(inner_source) else inner_source
def on_next(x: Any) -> None:
if latest[0] == _id:
observer.on_next(x)
def on_error(e: Exception) -> None:
if latest[0] == _id:
observer.on_error(e)
def on_completed() -> None:
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, scheduler=scheduler)
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_mapper(value)
except Exception as exception:
observer.on_error(exception)
return
md.disposable = duration.pipe(take(1)).subscribe_(noop, observer.on_error, lambda: expire(), scheduler)
for val in left_map.values():
result = (val, value)
observer.on_next(result)
def schedulePeriodicWithState(self, state, period, action):
failed = False
failureLock = RLock
d = SingleAssignmentDisposable()
def scheduled(_state):
with failureLock:
nonlocal failed
if failed:
return None
try:
return action(_state)
except Exception as e:
failed = True
if not self.handler(e):
raise e
d.dispose()
return None
d.disposable = self._scheduler.schedulePeriodicWithState(
state,
period,
scheduled
)
return d
def onNext(self, value):
resourceId = 0
with self.parent.gate:
self.parent.rightID += 1
resourceId = self.parent.rightID
self.parent.rightMap[resourceId] = value
# AddRef was originally WindowObservable but this is just an alias for AddRef
md = SingleAssignmentDisposable()
self.parent.group.add(md)
try:
duration = self.parent.parent.rightDurationSelector(value)
except Exception as e:
self.parent.observer.onError(e)
self.parent.dispose()
return
else:
md.disposable = duration.subscribeSafe(self.Delta(self, resourceId, md))
with self.parent.gate:
for leftValue in self.parent.leftMap.values():
try:
result = self.parent.parent.resultSelector(leftValue, value)
except Exception as e:
self.parent.observer.onError(e)
self.parent.dispose()
return
else:
self.parent.observer.onNext(result)
def run(self):
srcs = list(self.parent.sources)
N = len(srcs)
self.queues = [None] * N
self.isDone = [False] * N
self.subscriptions = [None] * N
self.gate = RLock()
for i in range(0, N):
self.queues[i] = deque()
# Loop twice because subscribing could already yield
# a value before all queues are initialized
for i in range(0, N):
d = SingleAssignmentDisposable()
self.subscriptions[i] = d
o = self.O(self, i)
d.disposable = srcs[i].subscribeSafe(o)
c = CompositeDisposable(self.subscriptions)
def dispose():
for q in self.queues:
q.clear()
c.add(Disposable.create(dispose))
return c
def subscribe(observer, scheduler=None):
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()
subs = source.subscribe_(on_next, observer.on_error, on_completed, scheduler)
subscriptions = CompositeDisposable(subs)
right_subscription = SingleAssignmentDisposable()
subscriptions.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, scheduler)
return subscriptions
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, scheduler=scheduler)
return subscription
parent_subscription = SingleAssignmentDisposable()
def on_next(value):
with parent.lock:
if NO_VALUE not in values:
result = (value,) + tuple(values)
observer.on_next(result)
disp = parent.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler)
parent_subscription.disposable = disp
children_subscription = [subscribe_child(i, child) for i, child in enumerate(children)]
return [parent_subscription] + children_subscription
def run(self):
self.scheduler = self.parent.scheduler
self.cancelTimer = SerialDisposable()
self.gate = RLock()
self.evt = Semaphore(0)
self.stopped = False
self.stop = Event()
self.queue = deque()
self.hasCompleted = False
self.completeAt = 0
self.hasFailed = False
self.exception = None
self.delay = 0
self.startTime = self.scheduler.now()
if self.parent.isAbsolute:
self.cancelTimer.disposable = self.scheduler.scheduleAbsolute(
self.parent.dueTime, self.start)
else:
self.delay = Scheduler.normalize(self.parent.dueTime)
self.scheduleDrain()
self.sourceSubscription = SingleAssignmentDisposable()
self.sourceSubscription.disposable = self.parent.source.subscribeSafe(
self)
return CompositeDisposable(self.sourceSubscription,
self.cancelTimer)
def send_right(value):
with left.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_mapper(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(error):
with left.lock:
for left_value in left_map.values():
left_value.on_error(error)
observer.on_error(error)
md.disposable = duration.pipe(ops.take(1)).subscribe_(
nothing, on_error, expire, scheduler)
with left.lock:
for left_value in left_map.values():
left_value.on_next(value)
class Sink(rx.linq.sink.Sink):
def __init__(self, parent, observer, cancel):
super(SampleWithObservable.Sink, self).__init__(observer, cancel)
self.parent = parent
def run(self):
self.gate = RLock()
self.atEnd = False
self.hasValue = False
self.value = None
self.sourceSubscription = SingleAssignmentDisposable()
self.sourceSubscription.disposable = self.parent.source.subscribeSafe(self)
samplerSubscription = self.parent.sampler.subscribeSafe(self.SamplerObserver(self))
return CompositeDisposable(self.sourceSubscription, samplerSubscription)
def onNext(self, value):
with self.gate:
self.hasValue = True
self.value = value
def onError(self, exception):
with self.gate:
self.observer.onError(exception)
self.dispose()
def onCompleted(self):
with self.gate:
self.atEnd = True
self.sourceSubscription.dispose()
class SamplerObserver(Observer):
def __init__(self, parent):
self.parent = parent
def onNext(self, value):
with self.parent.gate:
if self.parent.hasValue:
self.parent.hasValue = False
self.parent.observer.onNext(self.parent.value)
if self.parent.atEnd:
self.parent.observer.onCompleted()
self.parent.dispose()
def onError(self, exception):
with self.parent.gate:
self.parent.observer.onError(exception)
self.parent.dispose()
def onCompleted(self):
with self.parent.gate:
if self.parent.hasValue:
self.parent.hasValue = False
self.parent.observer.onNext(self.parent.value)
if self.parent.atEnd:
self.parent.observer.onCompleted()
self.parent.dispose()
class ScheduledItem(Generic[typing.TState]): # pylint: disable=unsubscriptable-object
def __init__(self, scheduler: SchedulerBase, state: Optional[typing.TState], action: typing.ScheduledAction,
duetime: typing.AbsoluteTime):
self.scheduler = scheduler
self.state = state
self.action = action
self.duetime = duetime
self.disposable = SingleAssignmentDisposable()
def invoke(self) -> None:
ret = self.scheduler.invoke_action(self.action, self.state)
self.disposable.disposable = ret
def cancel(self) -> None:
"""Cancels the work item by disposing the resource returned by
invoke_core as soon as possible."""
self.disposable.dispose()
def is_cancelled(self) -> bool:
return self.disposable.is_disposed
def __lt__(self, other):
return self.duetime < other.duetime
def __gt__(self, other):
return self.duetime > other.duetime
def __eq__(self, other):
return self.duetime == other.duetime
def send_right(value):
with left.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_mapper(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(error):
with left.lock:
for left_value in left_map.values():
left_value.on_error(error)
observer.on_error(error)
md.disposable = duration.pipe(ops.take(1)).subscribe_(nothing, on_error, expire, scheduler)
with left.lock:
for left_value in left_map.values():
left_value.on_next(value)
def set_timer(timeout: Observable) -> None:
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=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 __init__(self, on_next=None, on_error=None, on_completed=None):
self._on_next = on_next or noop
self._on_error = on_error or default_error
self._on_completed = on_completed or noop
self._subscription = SingleAssignmentDisposable()
self.is_stopped = False
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 = 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)
subscription = inner_source.subscribe_(on_next, on_error, on_completed, scheduler)
inner_subscription.disposable = subscription
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 onNext(self, value):
s = Subject()
resourceId = 0
with self.parent.gate:
self.parent.leftID += 1
resourceId = self.parent.leftID
self.parent.leftMap[resourceId] = s
# AddRef was originally WindowObservable but this is just an alias for AddRef
window = AddRef(s, self.parent.refCount)
md = SingleAssignmentDisposable()
self.parent.group.add(md)
try:
duration = self.parent.parent.leftDurationSelector(value)
except Exception as e:
self.onError(e)
return
else:
md.disposable = duration.subscribeSafe(self.Delta(self, resourceId, s, md))
try:
result = self.parent.parent.resultSelector(value, window)
except Exception as e:
self.onError(e)
return
else:
with self.parent.gate:
self.parent.observer.onNext(result)
for rightValue in self.parent.rightMap.values():
s.onNext(rightValue)
def onNext(self, value):
resourceId = 0
with self.parent.gate:
self.parent.leftID += 1
resourceId = self.parent.leftID
self.parent.leftMap[resourceId] = value
# AddRef was originally WindowObservable but this is just an alias for AddRef
md = SingleAssignmentDisposable()
self.parent.group.add(md)
try:
duration = self.parent.parent.leftDurationSelector(value)
except Exception as e:
self.parent.observer.onError(e)
self.parent.dispose()
return
else:
md.disposable = duration.subscribeSafe(
self.Delta(self, resourceId, md))
with self.parent.gate:
for rightValue in self.parent.rightMap.values():
try:
result = self.parent.parent.resultSelector(
value, rightValue)
except Exception as e:
self.parent.observer.onError(e)
self.parent.dispose()
return
else:
self.parent.observer.onNext(result)
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 __init__(self):
self.queue = Queue()
self.gate = Semaphore(0)
self.subscription = SingleAssignmentDisposable()
self.error = None
self.done = False
self.disposed = False
def schedule_periodic(self,
period: typing.RelativeTime,
action: typing.ScheduledPeriodicAction,
state: Optional[typing.TState] = None
) -> typing.Disposable:
"""Schedules a periodic piece of work.
Args:
period: Period in seconds or timedelta for running the
work periodically.
action: Action to be executed.
state: [Optional] Initial state passed to the action upon
the first iteration.
Returns:
The disposable object used to cancel the scheduled
recurring action (best effort).
"""
d = SingleAssignmentDisposable()
failed = False
def periodic_action(periodic_state) -> Optional[typing.TState]:
nonlocal failed
if not failed:
try:
return action(periodic_state)
except Exception as ex:
failed = True
if not self._handler(ex):
raise
d.dispose()
return None
d.disposable = self._scheduler.schedule_periodic(period, periodic_action, state=state)
return d
def createTimer(self):
m = SingleAssignmentDisposable()
self.timerDisposable.disposable = m
isSpan = False
isShift = False
if self.nextSpan == self.nextShift:
isSpan = True
isShift = True
elif self.nextShift < self.nextShift:
isSpan = True
else:
isShift = True
newTotalTime = self.nextSpan if isSpan else self.nextShift
ts = newTotalTime - self.totalTime
self.totalTime = newTotalTime
if isSpan:
self.nextSpan += self.parent.timeShift
if isShift:
self.nextShift += self.parent.timeShift
m.disposable = self.parent.scheduler.scheduleWithRelativeAndState(
Struct(isSpan=isSpan, isShift=isShift),
ts,
self.tick
)
def run(self):
srcs = list(self.parent.sources)
N = len(srcs)
self.queues = [None] * N
self.isDone = [False] * N
self.subscriptions = [None] * N
self.gate = RLock()
for i in range(0, N):
self.queues[i] = deque()
# Loop twice because subscribing could already yield
# a value before all queues are initialized
for i in range(0, N):
d = SingleAssignmentDisposable()
self.subscriptions[i] = d
o = self.O(self, i)
d.disposable = srcs[i].subscribeSafe(o)
c = CompositeDisposable(self.subscriptions)
def dispose():
for q in self.queues:
q.clear()
c.add(Disposable.create(dispose))
return c
def on_next(x):
throttle = None
try:
throttle = throttle_duration_mapper(x)
except Exception as e: # pylint: disable=broad-except
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: Any) -> None:
if has_value[0] and _id[0] == current_id:
observer.on_next(value[0])
has_value[0] = False
d.dispose()
def on_completed() -> None:
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=scheduler)
def createTimer(self):
m = SingleAssignmentDisposable()
self.timerDisposable.disposable = m
isSpan = False
isShift = False
if self.nextSpan == self.nextShift:
isSpan = True
isShift = True
elif self.nextShift < self.nextShift:
isSpan = True
else:
isShift = True
newTotalTime = self.nextSpan if isSpan else self.nextShift
ts = newTotalTime - self.totalTime
self.totalTime = newTotalTime
if isSpan:
self.nextSpan += self.parent.timeShift
if isShift:
self.nextShift += self.parent.timeShift
m.disposable = self.parent.scheduler.scheduleWithRelativeAndState(
Struct(isSpan=isSpan, isShift=isShift), ts, self.tick)
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 onNext(self, value):
key = None
try:
key = self.parent.keySelector(value)
except Exception as e:
self.onError(e)
return
fireNewMapEntry = False
writer = None
try:
if key == None:
with self.nullGate:
if self.null == None:
self.null = Subject()
fireNewMapEntry = True
writer = self.null
else:
if key in self.map:
writer = self.map[key]
else:
writer = Subject()
self.map[key] = writer
fireNewMapEntry = True
except Exception as e:
self.onError(e)
return
if fireNewMapEntry:
group = GroupObservable(key, writer, self.parent.refCountDisposable)
duration = None
durationGroup = GroupObservable(key, writer)
try:
duration = self.parent.durationSelector(durationGroup)
except Exception as e:
self.onError(e)
return
with self.observerGate:
self.observer.onNext(group)
md = SingleAssignmentDisposable()
self.parent.groupDisposable.add(md)
md.disposable = duration.subscribeSafe(self.Delta(self, key, writer, md))
element = None
try:
element = self.parent.elementSelector(value)
except Exception as e:
self.onError(e)
else:
with self.writerGate:
writer.onNext(element)
def run(self):
self.subscription = SerialDisposable()
d = SingleAssignmentDisposable()
self.subscription.disposable = d
d.disposable = self.parent.source.subscribeSafe(self)
return self.subscription
def run(self):
self.subscription = SingleAssignmentDisposable()
self.loopDisposable = SingleAssignmentDisposable()
self.subscription.disposable = self.parent.source.subscribeSafe(
self)
return CompositeDisposable(self.subscription, self.loopDisposable)
def __init__(self, scheduler: SchedulerBase,
state: Optional[typing.TState],
action: typing.ScheduledAction, duetime: typing.AbsoluteTime):
self.scheduler = scheduler
self.state = state
self.action = action
self.duetime = duetime
self.disposable = SingleAssignmentDisposable()
def run(self):
self.subscription = SerialDisposable()
d = SingleAssignmentDisposable()
self.subscription.disposable = d
d.disposable = self.parent.source.subscribeSafe(self)
return self.subscription
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, scheduler=scheduler)
return subscription
def run(self):
self.subscription = SingleAssignmentDisposable()
self.loop = SingleAssignmentDisposable()
self.startTime = self.parent.scheduler.now()
self.subscription.disposable = self.parent.source.subscribeSafe(
self)
return CompositeDisposable(self.subscription, self.loop)
def createTimer(self, wId):
m = SingleAssignmentDisposable()
self.timerDisposable.disposable = m
m.disposable = self.parent.scheduler.scheduleWithRelativeAndState(
wId,
self.parent.timeSpan,
self.tick
)
class AutoDetachObserver(Observer):
def __init__(self, on_next=None, on_error=None, on_completed=None):
self._on_next = on_next or noop
self._on_error = on_error or default_error
self._on_completed = on_completed or noop
self._subscription = SingleAssignmentDisposable()
self.is_stopped = False
def on_next(self, value: Any) -> None:
if self.is_stopped:
return
try:
self._on_next(value)
except Exception:
self.dispose()
raise
def on_error(self, error) -> None:
if self.is_stopped:
return
self.is_stopped = True
try:
self._on_error(error)
finally:
self.dispose()
def on_completed(self) -> None:
if self.is_stopped:
return
self.is_stopped = True
try:
self._on_completed()
finally:
self.dispose()
def set_disposable(self, value):
self._subscription.disposable = value
subscription = property(fset=set_disposable)
def dispose(self) -> None:
self.is_stopped = True
self._subscription.dispose()
def fail(self, exn: Exception) -> bool:
if self.is_stopped:
return False
self.is_stopped = True
self._on_error(exn)
return True
def __init__(self,
on_next: Optional[typing.OnNext] = None,
on_error: Optional[typing.OnError] = None,
on_completed: Optional[typing.OnCompleted] = None) -> None:
self._on_next = on_next or noop
self._on_error = on_error or default_error
self._on_completed = on_completed or noop
self._subscription = SingleAssignmentDisposable()
self.is_stopped = False
def run(self):
self.gate = RLock()
self.isStopped = False
self.group = CompositeDisposable()
self.sourceSubscription = SingleAssignmentDisposable()
self.group.add(self.sourceSubscription)
self.sourceSubscription.disposable = self.parent.sources.subscribeSafe(self)
return self.group
def subscribe(observer, _=None):
m = SingleAssignmentDisposable()
d = SerialDisposable()
d.disposable = m
def action(scheduler, state):
d.disposable = ScheduledDisposable(scheduler, source.subscribe(observer))
m.disposable = scheduler.schedule(action)
return d
def onNext(self, value):
observerId = 0
with self.gate:
self.latest += 1
observerId = self.latest
self.hasLatest = True
d = SingleAssignmentDisposable()
self.innerSubscription.disposable = d
d.disposable = value.subscribeSafe(self.IdObserver(self, observerId, d))
def func(i):
source = sources[i]
sad = SingleAssignmentDisposable()
source = from_future(source) if is_future(source) else source
def on_next(x):
queues[i].append(x)
next(i)
sad.disposable = source.subscribe_(on_next, observer.on_error, lambda: done(i), scheduler)
subscriptions[i] = sad
def onNext(self, value):
try:
delay = self.parent.delaySelector(value)
except Exception as e:
with self.gate:
self.observer.onError(e)
self.dispose()
else:
d = SingleAssignmentDisposable()
self.delays.add(d)
d.disposable = delay.subscribeSafe(self.Delta(self, value, d))
def on_error(exception):
try:
result = handler(exception, source)
except Exception as ex: # By design. pylint: disable=W0703
observer.on_error(ex)
return
result = rx.from_future(result) if is_future(result) else result
d = SingleAssignmentDisposable()
subscription.disposable = d
d.disposable = result.subscribe(observer, scheduler=scheduler)
def subscribe(observer):
m = SingleAssignmentDisposable()
d = SerialDisposable()
d.disposable = m
def action():
d.disposable = SchedulerDisposable(scheduler, self.subscribeSafe(observer))
m.disposable = scheduler.schedule(action)
return d
def func(i):
subscriptions[i] = SingleAssignmentDisposable()
def on_next(x):
with parent.lock:
values[i] = x
_next(i)
def on_completed():
with parent.lock:
done(i)
subscriptions[i].disposable = sources[i].subscribe_(on_next, observer.on_error, on_completed, scheduler)
def on_next(x: Any) -> None:
has_value[0] = True
value[0] = x
_id[0] += 1
current_id = _id[0]
d = SingleAssignmentDisposable()
cancelable.disposable = d
def action(scheduler, state=None) -> None:
if has_value[0] and _id[0] == current_id:
observer.on_next(value[0])
has_value[0] = False
d.disposable = _scheduler.schedule_relative(duetime, action)
