def subscribe(observer): subscription = SerialDisposable() cancelable = SerialDisposable() enum = iter(sources) is_disposed = [] def action(action1, state=None): if is_disposed: return def on_completed(): cancelable.disposable = scheduler.schedule(action) try: current = next(enum) except StopIteration: observer.on_completed() except Exception as ex: observer.on_error(ex) else: d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = current.subscribe(observer.on_next, observer.on_error, on_completed) cancelable.disposable = scheduler.schedule(action) def dispose(): is_disposed.append(True) return CompositeDisposable(subscription, cancelable, Disposable.create(dispose))
def subscribe(observer): subscription = SerialDisposable() cancelable = SerialDisposable() 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 = Observable.from_future(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) cancelable.disposable = scheduler.schedule(action) return CompositeDisposable(subscription, cancelable)
def subscribe(observer, scheduler=None): scheduler = 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) 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 subscribe(observer): switched = False _id = 0 original = SingleAssignmentDisposable() subscription = SerialDisposable() timer = SerialDisposable() subscription.disposable = original def create_timer(): my_id = _id def action(scheduler, state=None): nonlocal switched switched = (_id == my_id) timer_wins = switched if timer_wins: subscription.disposable = other.subscribe(observer) timer.disposable = scheduler_method(duetime, action) create_timer() def on_next(x): nonlocal _id on_next_wins = not switched if on_next_wins: _id += 1 observer.on_next(x) create_timer() def on_error(e): nonlocal _id on_error_wins = not switched if on_error_wins: _id += 1 observer.on_error(e) def on_completed(): nonlocal _id on_completed_wins = not switched if on_completed_wins: _id += 1 observer.on_completed() original.disposable = source.subscribe(on_next, on_error, on_completed) return CompositeDisposable(subscription, timer)
def test_mutabledisposable_replaceafterdispose(): disp1 = False disp2 = False m = SerialDisposable() m.dispose() def action1(): nonlocal disp1 disp1 = True d1 = Disposable(action1) m.disposable = d1 assert m.disposable == None assert disp1 def action2(): nonlocal disp2 disp2 = True d2 = Disposable(action2) m.disposable = d2 m.disposable == None assert disp2
def test_mutabledisposable_replacebeforedispose(): disp1 = False disp2 = False m = SerialDisposable() def action1(): nonlocal disp1 disp1 = True d1 = Disposable(action1) m.disposable = d1 assert d1 == m.disposable assert not disp1 def action2(): nonlocal disp2 disp2 = True d2 = Disposable(action2) m.disposable = d2 assert d2 == m.disposable assert disp1 assert not disp2
def subscribe(observer, scheduler=None): d1 = SingleAssignmentDisposable() subscription = SerialDisposable() subscription.disposable = d1 def on_error(exception): try: result = handler(exception) except Exception as ex: # By design. pylint: disable=W0703 observer.on_error(ex) return result = Observable.from_future(result) if is_future(result) else result d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = result.subscribe(observer, scheduler) d1.disposable = source.subscribe_( observer.on_next, on_error, observer.on_completed, scheduler ) return subscription
def test_select_disposeinsideselector(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 1), on_next(200, 2), on_next(500, 3), on_next(600, 4)) results = scheduler.create_observer() d = SerialDisposable() invoked = 0 def projection(x, *args, **kw): nonlocal invoked invoked += 1 if scheduler.clock > 400: #print("*** Dispose ****") d.dispose() return x d.disposable = xs.select(projection).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(ReactiveTest.disposed, action) scheduler.start() results.messages.assert_equal(on_next(100, 1), on_next(200, 2)) xs.subscriptions.assert_equal(ReactiveTest.subscribe(0, 500)) assert invoked == 3
def subscribe(observer): enum = iter(sources) is_disposed = [False] subscription = SerialDisposable() def action(action1, state=None): if is_disposed[0]: return try: current = next(enum) except StopIteration: observer.on_completed() except Exception as ex: observer.on_error(ex) else: d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = current.subscribe( observer.on_next, observer.on_error, lambda: action1() ) cancelable = immediate_scheduler.schedule_recursive(action) def dispose(): is_disposed[0] = True return CompositeDisposable(subscription, cancelable, Disposable.create(dispose))
def test_map_with_index_dispose_inside_mapper(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 4), on_next(200, 3), on_next(500, 2), on_next(600, 1)) invoked = [0] results = scheduler.create_observer() d = SerialDisposable() def projection(x, index): invoked[0] += 1 if scheduler.clock > 400: d.dispose() return x + index * 10 d.disposable = xs.map(mapper_indexed=projection).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(disposed, action) scheduler.start() assert results.messages == [on_next(100, 4), on_next(200, 13)] assert xs.subscriptions == [subscribe(0, 500)] assert invoked[0] == 3
def test_select_with_index_dispose_inside_selector(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 4), on_next(200, 3), on_next(500, 2), on_next(600, 1)) invoked = 0 results = scheduler.create_observer() d = SerialDisposable() def projection(x, index): nonlocal invoked invoked += 1 if scheduler.clock > 400: d.dispose() return x + index * 10 d.disposable = xs.select(projection).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(disposed, action) scheduler.start() results.messages.assert_equal(on_next(100, 4), on_next(200, 13)) xs.subscriptions.assert_equal(subscribe(0, 500)) assert invoked == 3
def test_map_disposeinsidemapper(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 1), on_next(200, 2), on_next(500, 3), on_next(600, 4)) results = scheduler.create_observer() d = SerialDisposable() invoked = [0] def projection(x, *args, **kw): invoked[0] += 1 if scheduler.clock > 400: #print("*** Dispose ****") d.dispose() return x d.disposable = xs.map(projection).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(ReactiveTest.disposed, action) scheduler.start() assert results.messages == [on_next(100, 1), on_next(200, 2)] assert xs.subscriptions == [ReactiveTest.subscribe(0, 500)] assert invoked[0] == 3
def subscribe(observer): n = [0] s = [None] timer_d = SerialDisposable() window_id = [0] group_disposable = CompositeDisposable(timer_d) ref_count_disposable = RefCountDisposable(group_disposable) 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) s[0] = Subject() observer.on_next(add_ref(s[0], ref_count_disposable)) create_timer(0) def on_next(x): new_window = False new_id = 0 s[0].on_next(x) n[0] += 1 if n[0] == count: new_window = True 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)) if new_window: create_timer(new_id) def on_error(e): s[0].on_error(e) observer.on_error(e) def on_completed(): s[0].on_completed() observer.on_completed() group_disposable.add( source.subscribe(on_next, on_error, on_completed)) return ref_count_disposable
def __init__(self, scheduler, observer): super(ScheduledObserver, self).__init__() self.scheduler = scheduler self.observer = observer self.is_acquired = False self.has_faulted = False self.queue = [] self.disposable = SerialDisposable()
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 subscribe(observer, scheduler=None): cancelable = SerialDisposable() has_value = [False] value = [None] _id = [0] 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 on_error(e): cancelable.dispose() observer.on_error(e) has_value[0] = False _id[0] += 1 def on_completed(): cancelable.dispose() if has_value[0]: observer.on_next(value[0]) observer.on_completed() has_value[0] = False _id[0] += 1 subscription = source.subscribe_(on_next, on_error, on_completed) return CompositeDisposable(subscription, cancelable)
def subscribe(observer, scheduler=None): scheduler = scheduler or immediate_scheduler queue = [] m = SerialDisposable() d = CompositeDisposable(m) active_count = [0] is_acquired = [False] def ensure_active(): is_owner = False if queue: is_owner = not is_acquired[0] is_acquired[0] = True 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) if is_owner: m.disposable = scheduler.schedule(action) queue.append(source) active_count[0] += 1 ensure_active() return d
def __init__(self, scheduler, observer): super(ScheduledObserver, self).__init__(self._next, self._error, self._completed) self.scheduler = scheduler self.observer = observer self.lock = Lock() self.is_acquired = False self.has_faulted = False self.queue = [] self.disposable = SerialDisposable()
def __init__(self, scheduler, observer): super().__init__() self.scheduler = scheduler self.observer = observer self.lock = threading.RLock() self.is_acquired = False self.has_faulted = False self.queue = [] self.disposable = SerialDisposable()
def subscribe(observer): q = [] m = SerialDisposable() d = CompositeDisposable(m) active_count = [0] is_acquired = [False] def ensure_active(): is_owner = False if len(q) > 0: is_owner = not is_acquired[0] is_acquired[0] = True if is_owner: 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() m.disposable = scheduler.schedule_recursive(action) q.append(source) active_count[0] += 1 ensure_active() return d
def __init__(self, scheduler, period, action, state=None): """ Keyword arguments: state -- Initial state passed to the action upon the first iteration. period -- Period for running the work periodically. action -- Action to be executed, potentially updating the state.""" self._scheduler = scheduler self._state = state self._period = period self._action = action self._cancel = SerialDisposable()
def subscribe(observer): delays = CompositeDisposable() at_end = False def done(): if (at_end and delays.length == 0): observer.on_completed() subscription = SerialDisposable() def start(): def on_next(x): try: delay = selector(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) def on_completed(): nonlocal at_end at_end = True subscription.dispose() done() subscription.disposable = source.subscribe( on_next, observer.on_error, on_completed) if not sub_delay: start() else: subscription.disposable( sub_delay.subscribe(lambda _: start(), observer.on_error, lambda: start())) return CompositeDisposable(subscription, delays)
def subscribe(observer, scheduler=None): delays = CompositeDisposable() at_end = [False] def done(): if (at_end[0] and delays.length == 0): observer.on_completed() subscription = SerialDisposable() def start(): 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 on_completed(): at_end[0] = True subscription.dispose() done() subscription.disposable = source.subscribe_( on_next, observer.on_error, on_completed, scheduler) if not sub_delay: start() else: subscription.disposable( sub_delay.subscribe_(lambda _: start(), observer.on_error, start)) return CompositeDisposable(subscription, delays)
def test_mutabledisposable_dispose(): disp = [False] m = SerialDisposable() def action(): disp[0] = True d = Disposable.create(action) m.disposable = d assert d == m.disposable assert not disp[0] m.dispose() assert disp[0] assert m.disposable == None
def subscribe(observer, scheduler=None): scheduler = scheduler or current_thread_scheduler subscription = SerialDisposable() cancelable = SerialDisposable() is_disposed = False 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: observer.on_error(ex) else: d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = current.subscribe_(observer.on_next, observer.on_error, on_completed, scheduler) cancelable.disposable = scheduler.schedule(action) def dispose(): nonlocal is_disposed is_disposed = True return CompositeDisposable(subscription, cancelable, Disposable.create(dispose))
def subscribe(observer, scheduler=None): scheduler = scheduler or current_thread_scheduler subscription = SerialDisposable() cancelable = SerialDisposable() last_exception = [None] is_disposed = [] e = iter(sources) 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(e) except StopIteration: if last_exception[0]: observer.on_error(last_exception[0]) 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, scheduler) cancelable.disposable = scheduler.schedule(action) def dispose(): is_disposed.append(True) return CompositeDisposable(subscription, cancelable, Disposable.create(dispose))
def test_mutabledisposable_dispose(): disp = False m = SerialDisposable() def action(): nonlocal disp disp = True d = Disposable(action) m.disposable = d assert d == m.disposable assert not disp m.dispose() assert disp assert m.disposable == None
def test_filter_dispose_in_predicate(self): scheduler = TestScheduler() invoked = [0] ys = [None] xs = scheduler.create_hot_observable(on_next(110, 1), on_next(180, 2), on_next(230, 3), on_next(270, 4), on_next(340, 5), on_next(380, 6), on_next(390, 7), on_next(450, 8), on_next(470, 9), on_next(560, 10), on_next(580, 11), on_completed(600), on_next(610, 12), on_error(620, 'ex'), on_completed(630)) results = scheduler.create_observer() d = SerialDisposable() def action(scheduler, state): def predicate(x): invoked[0] += 1 if x == 8: d.dispose() return is_prime(x) ys[0] = xs.filter(predicate) return ys[0] scheduler.schedule_absolute(created, action) def action1(scheduler, state): d.disposable = ys[0].subscribe(results) scheduler.schedule_absolute(subscribed, action1) def action2(scheduler, state): d.dispose() scheduler.schedule_absolute(disposed, action2) scheduler.start() assert results.messages == [ on_next(230, 3), on_next(340, 5), on_next(390, 7) ] assert xs.subscriptions == [subscribe(200, 450)] assert (invoked[0] == 6)
def subscribe(observer, scheduler=None): has_latest = [False] inner_subscription = SerialDisposable() is_stopped = [False] latest = [0] def on_next(inner_source): nonlocal sources d = SingleAssignmentDisposable() with sources.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) if is_future( inner_source) else 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 on_completed(): is_stopped[0] = True if not has_latest[0]: observer.on_completed() subscription = sources.subscribe_(on_next, observer.on_error, on_completed) return CompositeDisposable(subscription, inner_subscription)
def subscribe(observer): cancelable = SerialDisposable() has_value = False value = None _id = 0 def on_next(x): nonlocal _id, value, has_value, cancelable has_value = True value = x _id += 1 current_id = _id d = SingleAssignmentDisposable() cancelable.disposable = d def action(scheduler, state=None): nonlocal has_value if has_value and _id == current_id: observer.on_next(value) has_value = False d.disposable = scheduler.schedule_relative(duetime, action) def on_error(exception): nonlocal _id, has_value, cancelable cancelable.dispose() observer.on_error(exception) has_value = False _id += 1 def on_completed(): nonlocal cancelable, has_value, _id cancelable.dispose() if has_value: observer.on_next(value) observer.on_completed() has_value = False _id += 1 subscription = source.subscribe(on_next, on_error, on_completed) return CompositeDisposable(subscription, cancelable)