def __init__(self, context: BlenderContext) -> None: super().__init__(context) self._position = Subject() self._activeInputs = Subject() # noinspection PyTypeChecker self.position = self._position.pipe( ops.distinct_until_changed(), ops.map(lambda v: tuple( p * s for p, s in zip(v, context.window_size.tuple))), ops.map(Point.from_tuple), ops.share()) codes = { MouseButton.LEFT: bge.events.LEFTMOUSE, MouseButton.MIDDLE: bge.events.MIDDLEMOUSE, MouseButton.RIGHT: bge.events.RIGHTMOUSE } def pressed(e: SCA_InputEvent) -> bool: return KX_INPUT_ACTIVE in e.status or KX_INPUT_JUST_ACTIVATED in e.status def value_for(button: MouseButton) -> Observable: code = codes[button] return self._activeInputs.pipe( ops.start_with({}), ops.map(lambda i: code in i and pressed(i[code])), ops.map(lambda v: button if v else 0)) # noinspection PyTypeChecker self.buttons = rx.combine_latest( *[value_for(b) for b in MouseButton]).pipe( ops.map(lambda v: reduce(lambda a, b: a | b, v)), ops.distinct_until_changed(), ops.share())
def parse_config(file_data): return file_data.pipe( ops.map(lambda i: json.loads( i, object_hook=lambda d: namedtuple('x', d.keys())(*d.values()))), ops.share(), )
def model_publisher(scheduler, sources): file_source = sources.file.response.pipe(ops.share()) # kafka driver bootstrap. fixme kafka_source = sources.kafka.response.pipe( ops.do_action(print), ops.replay(), ops.ref_count(), ) kafka_source.subscribe() config, config_read_request, http_request = read_config_from_args( sources.argv.argv, file_source, sources.http.response, scheduler=scheduler) config = config.pipe(ops.first()) kafka_request = config.pipe(ops.map(lambda c: create_model_topics(c)), ) return ModelPublisherSink( file=file.Sink(request=rx.merge(config_read_request)), http=http.Sink(request=http_request), kafka=kafka.Sink(request=kafka_request), )
def rmux_client(sources): response = sources.tcp_client.response.pipe(ops.share()) tcp_connect = rx.just(tcp_client.Connect( host='127.0.0.1', port='8080' )) create_observable = response.pipe( ops.flat_map(lambda connection: rx.just({'what': 'subscribe', 'id':42, 'name': '1234'}).pipe( ops.map(lambda i: json.dumps(i)), frame, ops.map(lambda j: tcp_client.Write(id=connection.id, data=j.encode())) )) ) console = response.pipe( ops.flat_map(lambda connection: connection.observable.pipe( ops.map(lambda i: i.data.decode('utf-8')), unframe, ops.map(lambda i: json.loads(i)), ops.group_by(lambda i: i['id']), ops.flat_map(lambda subscription: subscription.pipe( ops.map(notification), ops.dematerialize(), )) )), ops.map(lambda i: "item: {}\n".format(i)) ) tcp_sink = rx.merge(tcp_connect, create_observable) return Sink( tcp_client=tcp_client.Sink(request=tcp_sink), stdout=stdout.Sink(data=console), )
def start(self) -> rx.Observable: self._frames = rx \ .interval(1 / self._fps, scheduler=rx.scheduler.TimeoutScheduler()) \ .pipe( ops.share(), ) return self._frames
def parse_config(config_data): ''' takes a stream with the content of the configuration file as input and returns a (hot) stream of arguments . ''' config = config_data.pipe( ops.filter(lambda i: i.id == "config"), ops.flat_map(lambda i: i.data), ops.map(lambda i: json.loads( i, object_hook=lambda d: namedtuple('x', d.keys())(*d.values()))), ops.share()) return config
def to_rx(self, *inputs: rx.Observable) -> rx.Observable: """Produces output observable from input observables. Zips together the input observables, puts the resulting observable on the correct scheduler, and then runs `forward`. The output observable is multicast so it can be reused without worrying about recomputation. """ self._check_num_inputs(len(inputs), check_nodes=self._is_used_in_static_graph) observable = _zip_observables(*inputs) observable = observable.pipe( self._forward_to_rx_op(), ops.share(), ) return observable
def __init__(self, endpoint_clients: [typing.ServiceEndpointClient] = None, request_correlator: typing.RequestCorrelator = None): if endpoint_clients is None: self.__endpoint_clients = [] else: self.__endpoint_clients = endpoint_clients if request_correlator is None: self._request_correlator = DefaultRequestCorrelator() else: self._request_correlator = request_correlator self.__events = rx.from_iterable( map(lambda ep: ep.events, self.__endpoint_clients)).pipe(merge_all(), share())
def tweets_for(topics): def observe_tweets(observer, scheduler): class TweetListener(StreamListener): def on_data(self, data): observer.on_next(data) return True def on_error(self, status): observer.on_error(status) # This handles Twitter authetification and the connection to Twitter Streaming API l = TweetListener() auth = OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) stream = Stream(auth, l) stream.filter(track=topics) return create(observe_tweets).pipe(ops.share())
def get_responses(self, request) -> rx.Observable: if self._request_correlator is None: raise Exception( 'Please configure the ServiceBus with a RequestCorrelator using .correlate_requests_with()' ) self._request_correlator.set_request_correlation_ids(request) endpoints = self.__can_handle(request) responses = rx.from_iterable( map(lambda ep: ep.get_responses(request), endpoints)) return responses.pipe( merge_all(), rx.operators.filter( lambda r: self._request_correlator.are_correlated(request, r)), share())
def makinage(aio_scheduler, sources): def on_error(e): raise e config, read_request, http_request = read_config_from_args( sources.argv.argv, sources.file.response, sources.http.response, scheduler=aio_scheduler ) first_config = rx.concat(config.pipe(ops.take(1),), rx.never()) kafka_source = sources.kafka.response.pipe( trace_observable("kafka source1"), ops.replay(), ops.ref_count(), trace_observable("kafka source2"), ) kafka_source.subscribe(on_error=on_error) kafka_request = first_config.pipe( ops.flat_map(lambda i: create_operators( i, config, kafka_source, sources.kafka.feedback.pipe(ops.share()), )), ops.subscribe_on(aio_scheduler), trace_observable("makinage"), ) ''' config.pipe(ops.subscribe_on(aio_scheduler)).subscribe( on_next=print, on_error=print, ) ''' return MakiNageSink( file=file.Sink(request=read_request), http=http.Sink(request=http_request), kafka=kafka.Sink(request=kafka_request), )
def __init__(self, concurrency_per_group, delay_seconds=0, description=None): self.scheduler = ThreadPoolScheduler(concurrency_per_group) self.request_scheduler = ThreadPoolScheduler(10) self._requests = Subject() self._output_subject = Subject() self._output = self._output_subject.pipe(share()) self._description = description self._subscription = self._requests.pipe( observe_on(self.scheduler), group_by(lambda r: r['concurrency_group']), flat_map(lambda concurrency_group: concurrency_group.pipe( map(lambda r: r['request']), merge(max_concurrent=concurrency_per_group), delay(delay_seconds))), take_until_disposed()).subscribe( on_next=lambda request: self._output_subject.on_next(request), on_error=lambda error: logging.exception( 'Error in {} request stream'.format(self)), on_completed=lambda: self.dispose(), scheduler=self.scheduler)
import rx from rx import operators as ops import time # source = rx.interval(1.0).pipe( # ops.publish(), # ops.ref_count() # ) source = rx.interval(1.0).pipe(ops.share()) source.subscribe(lambda s: print("Subscriber 1: {0}".format(s))) # sleep 5 seconds, then add another subscriber time.sleep(5) source.subscribe(lambda s: print("Subscriber 2: {0}".format(s))) input("Press any key to exit\n")
def get_trained_obs(self): return self.dataSetFolderSubject.pipe( async_switch_map(self.handleFolder), ops.do_action(self.set_learner), ops.flat_map_latest(lambda event: self.trainFirstStage), async_switch_map(self.train_stage_1), ops.share())
def to_rx(self, *inputs: rx.Observable) -> rx.Observable: # NOTE If Module is not attached to graph, do not check len(inputs) # TODO Does it make sense for module to be detached from graph? if self._is_used_in_static_graph: self._check_num_inputs(len(inputs), check_nodes=True) return self.produce().pipe(ops.share())
def __init__(self, endpoints: [typing.ServiceEndpoint] = None, endpoint_clients: [typing.ServiceEndpointClient] = None, request_correlator: typing.RequestCorrelator = DefaultRequestCorrelator()): super().__init__(endpoint_clients, request_correlator) if endpoints is None: self.__endpoints = [] else: self.__endpoints = endpoints self.__requests = rx.from_iterable(map(lambda ep: ep.requests, self.__endpoints)).pipe(merge_all(), share()) self.__commands = rx.from_iterable(map(lambda ep: ep.commands, self.__endpoints)).pipe(merge_all(), share())
def create_route_observable(): def on_route_subscribe(observer, scheduler): nonlocal route_observer route_observer = observer return rx.create(on_route_subscribe).pipe(ops.share())
def audio_encoder(sources): # Parse configuration parser = create_arg_parser() parsed_argv = sources.argv.argv.pipe( ops.skip(1), argparse.parse(parser), ops.filter(lambda i: i.key == 'config'), ops.subscribe_on(aio_scheduler), ops.share(), ) # monitor and parse config file monitor_init = parsed_argv.pipe( ops.flat_map(lambda i: rx.from_([ inotify.AddWatch( id='config', path=i.value, flags=aionotify.Flags.MODIFY), inotify.Start(), ]))) config_update = sources.inotify.response.pipe( ops.debounce(5.0, scheduler=aio_scheduler), ops.map(lambda i: True), ops.start_with(True), ) read_request, read_response = rx.combine_latest( parsed_argv, config_update).pipe( ops.starmap( lambda config, _: file.Read(id='config', path=config.value)), file.read(sources.file.response), ) config = read_response.pipe( ops.filter(lambda i: i.id == "config"), ops.flat_map(lambda i: i.data), parse_config, ) # Transcode request handling encode_init = config.pipe( ops.map(lambda i: i.encode), ops.distinct_until_changed(), ops.map(lambda i: encoder.Configure(samplerate=i.samplerate, bitdepth=i.bitdepth)), ) encode_request = sources.httpd.route.pipe( ops.filter(lambda i: i.id == 'flac_transcode'), ops.flat_map(lambda i: i.request), ops.flat_map(lambda i: rx.just(i, encode_scheduler)), ops.map(lambda i: encoder.EncodeMp3( id=i.context, data=i.data, key=i.match_info['key'])), ) encoder_request = rx.merge(encode_init, encode_request) # store encoded file store_requests = sources.encoder.response.pipe( ops.observe_on(s3_scheduler), ops.map(lambda i: s3.UploadObject( key=i.key + '.flac', data=i.data, id=i.id, )), ) # acknowledge http request http_response = sources.s3.response.pipe( ops.map(lambda i: httpd.Response( data='ok'.encode('utf-8'), context=i.id, ))) # http server http_init = config.pipe( ops.take(1), ops.flat_map(lambda i: rx.from_([ httpd.Initialize(request_max_size=0), httpd.AddRoute( methods=['POST'], path='/api/transcode/v1/flac/{key:[a-zA-Z0-9-\._]*}', id='flac_transcode', ), httpd.StartServer(host=i.server.http.host, port=i.server.http.port ), ])), ) http = rx.merge(http_init, http_response) # s3 database s3_init = config.pipe( ops.take(1), ops.map(lambda i: s3.Configure( access_key=i.s3.access_key, secret_key=i.s3.secret_key, bucket=i.s3.bucket, endpoint_url=i.s3.endpoint_url, region_name=i.s3.region_name, )), ) # merge sink requests file_requests = read_request s3_requests = rx.merge(s3_init, store_requests) return Sink( encoder=encoder.Sink(request=encoder_request), s3=s3.Sink(request=s3_requests), file=file.Sink(request=file_requests), httpd=httpd.Sink(control=http), inotify=inotify.Sink(request=monitor_init), )
def create_store(initial_state: Optional[ReduxRootState] = None) -> ReduxRootStore: # pylint: disable=too-many-locals """ Constructs a new store that can handle feature modules. Args: initial_state: optional initial state of the store, will typically be the empty dict Returns: An implementation of the store """ # current reducer reducer: Reducer = identity_reducer def replace_reducer(new_reducer: Reducer) -> None: """ Callback that replaces the current reducer Args: new_reducer: the new reducer """ nonlocal reducer reducer = new_reducer # subject used to dispatch actions actions = Subject() # the shared action observable actions_ = actions.pipe(op.share()) _dispatch = actions.on_next # our current state state = BehaviorSubject(initial_state if initial_state else {}) # shutdown trigger done_ = Subject() # The set of known modules, to avoid cycles and duplicate registration modules: MutableMapping[str, ReduxFeatureModule] = {} # Sequence of added modules module_subject = Subject() # Subscribe to the resolved modules module_ = module_subject.pipe(op.distinct(select_id), op.share()) # Build the reducers reducer_ = module_.pipe( op.filter(has_reducer), op.scan(reduce_reducers, {}), op.map(combine_reducers), op.map(replace_reducer), ) # Build the epic epic_ = module_.pipe( op.map(select_epic), op.filter(bool), op.map(normalize_epic) ) # Root epic that combines all of the incoming epics def root_epic( action_: Observable, state_: Observable ) -> Observable: """ Implementation of the root epic. If listens for new epics to come in and automatically subscribes. Args: action_: the action observable state_: the state observable Returns The observable of resulting actions """ return epic_.pipe( op.flat_map(run_epic(action_, state_)), op.map(_dispatch) ) # notifications about new feature states new_module_ = module_.pipe( op.map(select_id), op.map(create_action(INIT_ACTION)), op.map(_dispatch), ) def _add_feature_module(module: ReduxFeatureModule): """ Registers a new feature module Args: module: the new feature module """ module_id = select_id(module) if not module_id in modules: modules[module_id] = module for dep in select_dependencies(module): _add_feature_module(dep) module_subject.on_next(module) # all state internal_ = merge(root_epic(actions_, state), reducer_, new_module_).pipe( op.ignore_elements() ) def _as_observable() -> Observable: """ Returns the state as an observable Returns: the observable """ return state def _on_completed() -> None: """ Triggers the done event """ done_.on_next(None) merge(actions_, internal_).pipe( op.map(lambda action: reducer(state.value, action)), op.take_until(done_), ).subscribe(state, logger.error) return ReduxRootStore( _as_observable, _dispatch, _add_feature_module, _dispatch, _on_completed )
def produce(self): return rx.interval(1).pipe( ops.do_action(lambda x: print(f"\n{get_time():.1f} Frame {x}\n")), ops.map(lambda _: Tensor((224, 224, 3), "uint8")), ops.share(), )