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 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 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 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): 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 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 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 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 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 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 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 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 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 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 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 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 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 createTimer(self, wId): m = SingleAssignmentDisposable() self.timerDisposable.disposable = m m.disposable = self.parent.scheduler.scheduleWithRelativeAndState( wId, self.parent.timeSpan, self.tick )
def run(self): self.gate = RLock() self.group = CompositeDisposable() self.refCount = RefCountDisposable(self.group) leftSubscription = SingleAssignmentDisposable() self.group.add(leftSubscription) self.leftID = 0 self.leftMap = {} rightSubscription = SingleAssignmentDisposable() self.group.add(rightSubscription) self.rightID = 0 self.rightMap = {} leftSubscription.disposable = self.parent.left.subscribeSafe(self.Left(self, leftSubscription)) rightSubscription.disposable = self.parent.right.subscribeSafe(self.Right(self, rightSubscription)) return self.refCount
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 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 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 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): 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 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 subscribe(observer, scheduler_=None): _scheduler = scheduler or scheduler_ or timeout_scheduler if isinstance(duetime, datetime): scheduler_method = _scheduler.schedule_absolute else: scheduler_method = _scheduler.schedule_relative switched = [False] _id = [0] original = SingleAssignmentDisposable() subscription = SerialDisposable() timer = SerialDisposable() subscription.disposable = original def create_timer(): my_id = _id[0] def action(scheduler, state=None): switched[0] = (_id[0] == my_id) timer_wins = switched[0] if timer_wins: subscription.disposable = other.subscribe( observer, scheduler=scheduler) timer.disposable = scheduler_method(duetime, action) create_timer() def on_next(value): send_wins = not switched[0] if send_wins: _id[0] += 1 observer.on_next(value) create_timer() def on_error(error): on_error_wins = not switched[0] if on_error_wins: _id[0] += 1 observer.on_error(error) def on_completed(): on_completed_wins = not switched[0] if on_completed_wins: _id[0] += 1 observer.on_completed() original.disposable = source.subscribe_(on_next, on_error, on_completed, scheduler_) return CompositeDisposable(subscription, timer)
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 run(self): ls = SingleAssignmentDisposable() rs = SingleAssignmentDisposable() d = CompositeDisposable(ls, rs) gate = RLock() lo = Amb.AmbObserver(self) lo.disposable = d lo.target = Amb.DecisionObserver(self, gate, Amb.LEFT, ls, rs, lo) ro = Amb.AmbObserver(self) ro.disposable = d ro.target = Amb.DecisionObserver(self, gate, Amb.RIGHT, rs, ls, ro) self.choice = Amb.NEITHER ls.disposable = self.parent.left.subscribeSafe(lo) rs.disposable = self.parent.right.subscribeSafe(ro) return d
def run(self): self.gate = RLock() self.group = CompositeDisposable() self.refCount = RefCountDisposable(self.group) leftSubscription = SingleAssignmentDisposable() self.group.add(leftSubscription) self.leftDone = False self.leftID = 0 self.leftMap = {} rightSubscription = SingleAssignmentDisposable() self.group.add(rightSubscription) self.rightDone = False self.rightID = 0 self.rightMap = {} leftSubscription.disposable = self.parent.left.subscribeSafe( self.Lambda(self, leftSubscription)) rightSubscription.disposable = self.parent.right.subscribeSafe( self.Roh(self, rightSubscription)) return self.refCount
def subscribe(observer, scheduler_=None): _scheduler = scheduler or scheduler_ or timeout_scheduler if isinstance(duetime, datetime): scheduler_method = _scheduler.schedule_absolute else: scheduler_method = _scheduler.schedule_relative switched = [False] _id = [0] original = SingleAssignmentDisposable() subscription = SerialDisposable() timer = SerialDisposable() subscription.disposable = original def create_timer(): my_id = _id[0] def action(scheduler, state=None): switched[0] = (_id[0] == my_id) timer_wins = switched[0] if timer_wins: subscription.disposable = other.subscribe(observer, scheduler=scheduler) timer.disposable = scheduler_method(duetime, action) create_timer() def on_next(value): send_wins = not switched[0] if send_wins: _id[0] += 1 observer.on_next(value) create_timer() def on_error(error): on_error_wins = not switched[0] if on_error_wins: _id[0] += 1 observer.on_error(error) def on_completed(): on_completed_wins = not switched[0] if on_completed_wins: _id[0] += 1 observer.on_completed() original.disposable = source.subscribe_(on_next, on_error, on_completed, scheduler_) return CompositeDisposable(subscription, timer)
def on_next_left(value): subject = Subject() with left.lock: _id = left_id[0] left_id[0] += 1 left_map[_id] = subject try: result = (value, add_ref(subject, rcd)) except Exception as e: log.error("*** Exception: %s" % e) for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) return observer.on_next(result) for right_value in right_map.values(): subject.on_next(right_value) md = SingleAssignmentDisposable() group.add(md) def expire(): if _id in left_map: del left_map[_id] subject.on_completed() group.remove(md) try: duration = left_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): 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)
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)
def run(self): self.subscription = SerialDisposable() original = SingleAssignmentDisposable() self.subscription.disposable = original self.gate = RLock() self.switched = False timer = self.parent.scheduler.scheduleWithAbsolute( self.parent.dueTime, self.timeout) original.disposable = self.parent.source.subscribeSafe(self) return CompositeDisposable(self.subscription, timer)
def run(self): self.subscription = SerialDisposable() self.timer = SerialDisposable() original = SingleAssignmentDisposable() self.subscription.disposable = original self.gate = RLock() self.currentId = 0 self.switched = False self.createTimer() original.disposable = self.parent.source.subscribeSafe(self) return CompositeDisposable(self.subscription, self.timer)
def onNext(self, value): currentId = 0 with self.gate: self.hasValue = True self.value = value self.resourceId += 1 currentId = self.resourceId d = SingleAssignmentDisposable() self.propagatorDisposable.disposable = d d.disposable = self.parent.scheduler.scheduleWithRelativeAndState( currentId, self.parent.dueTime, self.propagate )
def test_futuredisposable_disposeafterset(): d = SingleAssignmentDisposable() disposed = [False] def action(): disposed[0] = True dd = Disposable(action) d.disposable = dd assert dd == d.disposable assert not disposed[0] d.dispose() assert disposed[0] d.dispose() assert disposed[0]
def subscribe_child(i, child): subscription = SingleAssignmentDisposable() def on_next(value): values[i] = value if NO_VALUE not in values and parent_subscription.disposable is None: disp = parent.subscribe(on_parent_next, observer.on_error, observer.on_completed, scheduler=scheduler) parent_subscription.disposable = disp subscription.disposable = child.subscribe( on_next, observer.on_error, scheduler=scheduler) return subscription
def create_timer(_id): m = SingleAssignmentDisposable() timer_d.disposable = m def action(scheduler, state): if _id != window_id[0]: return n[0] = 0 window_id[0] += 1 new_id = window_id[0] s[0].on_completed() s[0] = Subject() observer.on_next(add_ref(s[0], ref_count_disposable)) create_timer(new_id) m.disposable = _scheduler.schedule_relative(timespan, action)
def create_window_on_completed(): try: window_close = window_closing_mapper() except Exception as exception: observer.on_error(exception) return def on_completed(): window[0].on_completed() window[0] = Subject() observer.on_next(add_ref(window[0], r)) create_window_on_completed() m1 = SingleAssignmentDisposable() m.disposable = m1 m1.disposable = window_close.pipe(ops.take(1)).subscribe_( noop, on_error, on_completed, scheduler)
def test_futuredisposable_disposebeforeset(): disposed = [False] def dispose(): disposed[0] = True d = SingleAssignmentDisposable() dd = Disposable(dispose) assert not disposed[0] d.dispose() assert not disposed[0] d.disposable = dd assert d.disposable == None assert disposed[0] d.dispose() assert disposed[0]
def onError(self, exception): if isinstance(exception, self.parent.exceptionType): result = None try: result = self.parent.handler(exception) except Exception as e: self.observer.onError(e) self.dispose() return d = SingleAssignmentDisposable() self.subscription.disposable = d d.disposable = result.subscribeSafe( CatchException.WrapObserver(self)) else: self.observer.onError(exception) self.dispose()
def observe(self, observer_info: MultiCastObserverInfo) -> rx.typing.Disposable: disposable = SingleAssignmentDisposable() # dispose source if MultiCast sink gets disposed and all inner Flowable sinks # are disposed ref_count_disposable = RefCountDisposable(disposable) disposable.disposable = self.source.observe( observer_info.copy(observer=CollectFlowablesMultiCastObserver( next_observer=observer_info.observer, ref_count_disposable=ref_count_disposable, maintain_order=self.maintain_order, stack=self.stack, subscriber=self.subscriber, ), )) return ref_count_disposable
def _subscribe(i: int): subscriptions[i] = SingleAssignmentDisposable() def on_next(value): with parent.lock: values[i] = value has_value[i] = True 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(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 action(action1, state=None): nonlocal is_disposed if is_disposed: return def on_completed(): cancelable.disposable = scheduler.schedule(action) try: current = next(sources_) except StopIteration: observer.on_completed() except Exception as ex: # pylint: disable=broad-except observer.on_error(ex) else: d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = current.subscribe_(observer.on_next, observer.on_error, on_completed, scheduler)
def run(self): srcs = list(self.parent.sources) N = len(srcs) self.hasValue = [False] * N self.hasValueAll = False self.values = [None] * N self.isDone = [False] * N self.subscriptions = [None] * N self.gate = RLock() for i in range(N): d = SingleAssignmentDisposable() self.subscriptions[i] = d o = self.O(self, i) d.disposable = srcs[i].subscribeSafe(o) return CompositeDisposable(self.subscriptions)
def subscribe(xs): subscription = SingleAssignmentDisposable() group.add(subscription) @synchronized(source.lock) def on_completed(): group.remove(subscription) if queue: s = queue.pop(0) subscribe(s) else: active_count[0] -= 1 if is_stopped[0] and active_count[0] == 0: observer.on_completed() on_next = synchronized(source.lock)(observer.on_next) on_error = synchronized(source.lock)(observer.on_error) subscription.disposable = xs.subscribe_( on_next, on_error, on_completed, scheduler)
def on_next(inner_source): if not has_current[0]: has_current[0] = True inner_source = rx.from_future(inner_source) if is_future( inner_source) else 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, scheduler)
def action(scheduler, state=None): try: source = next(sources) except StopIteration: observer.on_completed() return # Allow source to be a factory method taking an error source = source(state) if callable(source) else source current = rx.from_future(source) if is_future(source) else source d = SingleAssignmentDisposable() subscription.disposable = d def on_resume(state=None): scheduler.schedule(action, state) d.disposable = current.subscribe_(observer.on_next, on_resume, on_resume, scheduler)
def schedule_periodic(self, period, action, state=None): d = SingleAssignmentDisposable() failed = [False] def periodic_action(periodic_state): if failed[0]: return None try: return action(periodic_state) except Exception as ex: failed[0] = True if not self._handler(ex): raise Exception(ex) d.dispose() return None d.disposable = self._scheduler.schedule_periodic( periodic_action, period, state) return d
def observe(self, observer_info: MultiCastObserverInfo) -> rx.typing.Disposable: group = CompositeDisposable() lock = threading.RLock() for inner_source in self.sources: inner_subscription = SingleAssignmentDisposable() group.add(inner_subscription) disposable = inner_source.observe(observer_info.copy( observer=MergeMultiCastObserver( observer=observer_info.observer, lock=lock, inner_subscription=inner_subscription, group=group ) )) inner_subscription.disposable = disposable return group
def on_next(x): try: delay = mapper(x) except Exception as error: observer.on_error(error) return d = SingleAssignmentDisposable() delays.add(d) def on_next(_): observer.on_next(x) delays.remove(d) done() def on_completed(): observer.on_next(x) delays.remove(d) done() d.disposable = delay.subscribe_(on_next, observer.on_error, on_completed, scheduler)
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 action(action1, state=None): def on_error(exn): last_exception[0] = exn cancelable.disposable = scheduler.schedule(action) if is_disposed: return try: current = next(sources) except StopIteration: if last_exception[0]: observer.on_error(last_exception[0]) else: observer.on_completed() except Exception as ex: # pylint: disable=broad-except observer.on_error(ex) else: d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = current.subscribe_(observer.on_next, on_error, observer.on_completed, scheduler)