def __init__(self): self.initRequest = Subject() self.addSegmentConfigRequest = Subject() self.removeSegmentConfigRequest = Subject() self.updateSegmentConfigRequest = Subject() self.generateManipulatorRequest = Subject() self.updateTensionsRequest = Subject() self.computeStateRequest = Subject() segment_config_repo_op = ops.merge( self.initRequest.pipe( ops.map(Repo().publish_init_segments_config) ), self.addSegmentConfigRequest.pipe( ops.map(Repo().add_segment) ), self.removeSegmentConfigRequest.pipe( ops.map(Repo().remove_segment) ), self.updateSegmentConfigRequest.pipe( ops.map(Repo().update_segment_config) ) ) self._segment_configs_stream = Observable().pipe( segment_config_repo_op, ) # TODO self._segment_configs_err_stream = Observable().pipe( segment_config_repo_op, ops.flat_map(lambda x: Observable.just(Repo().get_error())) ) self._tension_inputs_stream = Observable().pipe( ops.merge( self.generateManipulatorRequest.pipe( ops.map(Repo().generate_manipulator) ), self.updateTensionsRequest.pipe( ops.map(Repo().updateTensions) ), ) ) compute_state_result = self.computeStateRequest.pipe( ops.map(Repo().computeTensions) ) self._text_result_stream = compute_state_result.pipe( ops.map(format_manipulator) ) self._graph_stream = compute_state_result.pipe( )
def function(*args): arguments = list(args) def subscribe( observer: typing.Observer, scheduler: Optional[typing.Scheduler] = None ) -> typing.Disposable: def handler(*args): results = list(args) if mapper: try: results = mapper(args) except Exception as err: # pylint: disable=broad-except observer.on_error(err) return observer.on_next(results) else: if isinstance(results, list) and len(results) <= 1: observer.on_next(*results) else: observer.on_next(results) # observer.on_completed() arguments.append(handler) func(*arguments) return Disposable() return Observable(subscribe)
def from_marbles(string: str, timespan: RelativeTime = 0.1, lookup: Dict = None, error: Optional[Exception] = None, scheduler: Optional[Scheduler] = None) -> Observable: disp = CompositeDisposable() messages = parse(string, timespan=timespan, lookup=lookup, error=error, raise_stopped=True) def schedule_msg(message, observer, scheduler): timespan, notification = message def action(scheduler, state=None): notification.accept(observer) disp.add(scheduler.schedule_relative(timespan, action)) def subscribe(observer, scheduler_): _scheduler = scheduler or scheduler_ or new_thread_scheduler for message in messages: # Don't make closures within a loop schedule_msg(message, observer, _scheduler) return disp return Observable(subscribe)
def _subscription_listener(source: Observable) -> Observable: def subscribe(observer, scheduler_=None): _scheduler = scheduler or scheduler_ subscription = source.subscribe(observer, scheduler=scheduler) def dispose(): subscription.dispose() action() return Disposable(dispose) return Observable(subscribe)
def unsafe_subscribe( self, subscriber: MultiCastSubscriber) -> rx.typing.Observable: source = self.source.get_source(info=info) def subscribe(observer, scheduler=None): def on_next(value) -> None: for val in self.func(value): observer.on_next(val) return source.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler) return Observable(subscriber)
def connect(self): def on_connect(conn): self.conn = conn self.opened.on_next(conn) self.opened.on_completed() self.opened.dispose() def on_message_callback(message): self.messages.on_next(message) future = websocket_connect(self._url, on_message_callback=on_message_callback) #connection = rx(from_future=future).subscribe(on_connect) Observable(from_future=future).subscribe(on_connect)
class Rng(Component): """ A random number generator component. Produces uniformly distributed random floats between [0,1) :var output_random_number: A stream of the generated random numbers. """ output_random_number = Observable() def __init__(self): super().__init__() # every second emit a uniformly distributed random float between [0,1) self.output_random_number = rx.timer(0, 1).pipe( ops.map(lambda s: random.random()))
def map(source: Observable) -> Observable: def subscribe(obv: Observer, scheduler: Scheduler = None) -> Disposable: def on_next(value: Any) -> None: try: # print(value) data_list.append(value) result = None current_time = round_seconds( datetime.datetime.fromtimestamp(value.epoch)) # _, _, _, _, min_2, sec_2, _, _, _ = current_time.timetuple() if vars['start_time'] is None: vars['start_time'] = current_time window_begin_time = vars['start_time'] # _, _, _, _, min_1, sec_1, _, _, _ = window_begin_time.timetuple() time_sec_diff = current_time - window_begin_time time_sec_diff = time_sec_diff.seconds # min_diff = min_2 - min_1 # sec_diff = sec_2 - sec_1 # print(time_sec_diff, time, time_sec_diff >= time) if time_sec_diff >= time: result = list(data_list) data_list.clear() vars['start_time'] = None # print(len(data_list)) # result = value except Exception as err: # pylint: disable=broad-except obv.on_error(err) else: obv.on_next(result) return source.subscribe_(on_next, obv.on_error, obv.on_completed, scheduler) return Observable(subscribe)
def unsafe_subscribe( self, subscriber: MultiCastSubscriber) -> rx.typing.Observable: source = self.source.get_source(info=info) def subscribe(observer, scheduler=None): def on_next(x): observer.on_next(x) observer.on_completed() def on_completed(): try: observer.on_next(self.lazy_val()) observer.on_completed() except Exception as exc: observer.on_error(exc) return source.subscribe_(on_next, observer.on_error, on_completed, scheduler) return Observable(subscriber)
def map(source: Observable) -> Observable: def subscribe(obv: Observer, scheduler: Scheduler = None) -> Disposable: def on_next(value: Any) -> None: try: window_que.put(value) result = None if window_que.full(): result = list(window_que.queue) for i in range(skip): window_que.get() # window_que.put() # result = value except Exception as err: # pylint: disable=broad-except obv.on_error(err) else: obv.on_next(result) return source.subscribe_(on_next, obv.on_error, obv.on_completed, scheduler) return Observable(subscribe)
def map(source: Observable) -> Observable: def subscribe(obv: Observer, scheduler: Scheduler = None) -> Disposable: def on_next(value: TickWindow) -> None: try: result = None # if vars['start_time'] is None: # vars['start_time'] = value.epoch # if vars['start_time'] and vars['start_time'] != value.epoch: result = value vars['start_time'] = value.epoch # result = value except Exception as err: # pylint: disable=broad-except obv.on_error(err) else: obv.on_next(result) return source.subscribe_(on_next, obv.on_error, obv.on_completed, scheduler) return Observable(subscribe)
def test_skip_until_has_completed_causes_disposal(self): scheduler = TestScheduler() l_msgs = [ on_next(150, 1), on_next(210, 2), on_next(220, 3), on_next(230, 4), on_next(240, 5), on_completed(250) ] disposed = [False] l = scheduler.create_hot_observable(l_msgs) def subscribe(observer): disposed[0] = True r = Observable(subscribe) def create(): return l.skip_until(r) results = scheduler.start(create) results.messages.assert_equal() assert (disposed[0])
def hot(string: str, timespan: RelativeTime = 0.1, duetime: AbsoluteOrRelativeTime = 0.0, lookup: Dict = None, error: Optional[Exception] = None, scheduler: Optional[Scheduler] = None) -> Observable: _scheduler = scheduler or new_thread_scheduler if isinstance(duetime, datetime): duetime = duetime - _scheduler.now messages = parse( string, timespan=timespan, time_shift=duetime, lookup=lookup, error=error, raise_stopped=True, ) lock = threading.RLock() is_stopped = False observers = [] def subscribe(observer, scheduler=None): # should a hot observable already completed or on error # re-push on_completed/on_error at subscription time? if not is_stopped: with lock: observers.append(observer) def dispose(): with lock: try: observers.remove(observer) except ValueError: pass return Disposable(dispose) def create_action(notification): def action(scheduler, state=None): nonlocal is_stopped with lock: for observer in observers: notification.accept(observer) if notification.kind in ('C', 'E'): is_stopped = True return action for message in messages: timespan, notification = message action = create_action(notification) # Don't make closures within a loop _scheduler.schedule_relative(timespan, action) return Observable(subscribe)
def test_for_each_argument_checking(self): some = Observable.just(42).to_blocking() self.assertRaises(TypeError, lambda: Observable(None).to_blocking().for_each(lambda x: x)) self.assertRaises(TypeError, lambda: some.for_each(lambda: None))