def subscribe_and_wait(observable: Observable, on_error: Optional[typing.OnError] = None, on_completed: Optional[typing.OnCompleted] = None, on_next: Optional[typing.OnNext] = None, scheduler: Optional[typing.Scheduler] = None): disposed = threading.Event() def _on_next(value): if on_next: on_next(value) def _on_error(error): if on_error: on_error(error) disposed.set() def _on_completed(): if on_completed: on_completed() disposed.set() observable.subscribe(on_next=_on_next, on_error=_on_error, on_completed=_on_completed, scheduler=scheduler) disposed.wait()
def wait_for(self, observable: rx.Observable): # Error if not on this loop if (self != self.loop_service.get_loop()): raise Exception( "Loop.wait_for can only be called from the thread that the loop is running on." ) # Completed status completed = False # Observable value value = None # Callback for when our task is completed def callback(v): nonlocal completed nonlocal value completed = True value = v self.run(lambda: None) # Subscribe to the observable observable.subscribe(callback) # Keep doing things until we are done while not completed and self.is_alive(): self.do_next() # Did it complete? if (not completed): raise Exception( "Loop.wait_for was canceled as the loop has been stopped.") # Done, get the value return value
def _buffer_until_complete(source: rx.Observable): def do_boundary(): boundary.on_next(0) boundary.on_completed() boundary = subject.Subject() source.subscribe(on_completed=do_boundary) return operators.buffer(boundary)(source)
def observable_to_list(observable: Observable) -> list: res = [] def on_next(_list): nonlocal res res += [_list] def on_error(e): raise e observable.subscribe(on_next=on_next, on_error=on_error) return res
def __init__(self, userid: str, is_attending: bool, attend_notifier: Observable, absence_due_second: int = 3): self.userid = userid self.is_attending = is_attending self.schedule_obj = None if is_attending: self.detect_attendance(userid) self.absence_due_second = absence_due_second self.subject = Subject() attend_notifier.subscribe(self.detect_attendance)
def __init__(self, observable: Observable, scheduler: VirtualTimeScheduler = TestScheduler()) -> None: super().__init__() self.completed = threading.Event() self.messages = [] def on_next(value) -> None: self.messages.append(Recorded(scheduler.clock, OnNext(value))) def on_error(error) -> None: self.messages.append(Recorded(scheduler.clock, OnError(error))) self.completed.set() def on_completed() -> None: self.messages.append(Recorded(scheduler.clock, OnCompleted())) self.completed.set() observable.subscribe( on_next=on_next, on_error=on_error, on_completed=on_completed )
async def test_heartbeat( test: BaseHealthWatchdogTests, health_obs: Observable, source: Observable, factory: Callable[[str], Any], ): """ :param health_obs: Observable[BasicHealthModel], the observable of the heartbeat events :param source: Observable[SourceType], the observable that should trigger heartbeat events :param factory: Callable[[str], SourceType], a factory function that returns an object of the source observable sequence type """ health = None def assign(v): nonlocal health health = v health_obs.subscribe(assign) source.on_next(factory("test_id")) test.scheduler.advance_by(0) test.assertEqual(health.health_status, ttm.HealthStatus.HEALTHY) test.assertEqual(health.id_, "test_id") # it should not be dead yet test.scheduler.advance_by(HealthWatchdog.LIVELINESS / 2) test.assertEqual(health.health_status, ttm.HealthStatus.HEALTHY) test.assertEqual(health.id_, "test_id") # # it should be dead now because the time between states has reached the threshold test.scheduler.advance_by(HealthWatchdog.LIVELINESS / 2) test.assertEqual(health.health_status, ttm.HealthStatus.DEAD) test.assertEqual(health.id_, "test_id") # # it should become alive again when a new state is emitted source.on_next(factory("test_id")) test.assertEqual(health.health_status, ttm.HealthStatus.HEALTHY) test.assertEqual(health.id_, "test_id")
def _disposable_and_async_gen_from_obs(obs: Observable): """ Compatability layer for legacy Observable to async generator This should be removed and subscription resolvers changed to return async generators after removal of flask & gevent based dagit. """ queue: Queue = Queue() disposable = obs.subscribe(on_next=queue.put_nowait) async def async_gen(): while True: i = await queue.get() yield i return disposable, async_gen()
def _init_room(self, topic: str, source: rx.Observable): """ :param source: rx.Observable[Mapping[str, Any]]. The mapping values must be json serializable. """ records = cast(Dict[str, Any], {}) self.room_records[topic] = records def on_next(new_records: Mapping[str, Any]): records.update(new_records) async def emit_task(): for v in new_records.values(): await self.sio.emit(topic, v, to=topic) self.logger.debug(f'emitted message to room "{topic}"') self.loop.create_task(emit_task()) self._subscriptions.append(source.subscribe(on_next))
def _save_event(source: Observable, dic, key_mapper: Callable[[Any], str]): def on_next(data): dic[key_mapper(data)] = data source.subscribe(on_next)