def main(): # Connect to the redis database to store the state # redis_db = redis.StrictRedis(host='localhost', port=6379, db=0, decode_responses=True, encoding='utf-8') redis_db = 'Redis' # for simulation purposes # Defining the UDP source udp_source = Observable.from_(_test_socket_generator()) # Defining the hw controller source channel_source = [] for ch in range(NR_CHANNELS): channel_source.append(Observable.from_(_pull_from_channel(ch)) \ .distinct_until_changed()) # We only want the values that change hwc_source = Observable.merge(channel_source) merged_source = Observable.merge(hwc_source, udp_source) \ .map(lambda s: json.loads(s)) \ .publish() hwc_sink = merged_source.filter(lambda x: x[0].startswith('udp')) \ .subscribe(on_next=lambda x: _write_to_controller(x[2], x[3]), on_error=lambda e: print(e)) udp_sink = merged_source.filter(lambda x: x[0].startswith('hwc')) \ .subscribe(on_next=lambda x: _broadcast_state(x, broadcast_socket), on_error=lambda e: print(e)) db_sink = merged_source.subscribe(on_next=lambda x: _write_to_db(redis_db, x[2], x[3]), on_error=lambda e: print(e)) merged_source.connect()
def ff(row): print('row', row) return row.to_list() # Observable.from_(row).merge().subscribe(lambda g: print('g', g)) Observable.merge(row[:]).subscribe(lambda g: print('g', g)) # return row.flat_map(lambda i: i.flat_map(lambda y:y.flat_map(lambda o:o))) return Observable.merge(row[:]) return row.merge_all()
def test_concurrent_requests(self): set_command = SET(b'A', b'Z') get_command = GET(b'A') results = [] o1 = self.protocol.send_request(get_command, write=self._write) o2 = self.protocol.send_request(set_command, write=self._write) Observable.merge([o1, o2]).subscribe(on_next=lambda r: results.append(r)) self.assertEqual(results[0].value, b'A') self.assertEqual(results[1].value, b'Z')
def audio_encoder(sources): # Parse configuration read_config_file = (sources.argv.argv.skip(1).let( argparse.argparse, parser=Observable.just( argparse.Parser(description="audio encode server")), arguments=Observable.from_([ argparse.ArgumentDef(name='--config', help="Path of the server configuration file") ])).filter(lambda i: i.key == 'config').map( lambda i: file.Read(id='config', path=i.value))) config = sources.file.response.let(parse_config) # Transcode request handling encode_init = (config.map( lambda i: encoder.Initialize(storage_path=i.encode.storage_path))) encode_request = ( sources.httpd.route.filter(lambda i: i.id == 'flac_transcode'). flat_map(lambda i: i.request).map(lambda i: encoder.EncodeMp3( id=i.context, data=i.data, key=i.match_info['key']))) encoder_request = Observable.merge(encode_init, encode_request) # http server http_init = (config.flat_map(lambda i: Observable.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_response = (sources.encoder.response.map(lambda i: httpd.Response( data='ok'.encode('utf-8'), context=i.id, ))) http = Observable.merge(http_init, http_response) # merge sink requests file_requests = read_config_file return Sink( encoder=encoder.Sink(request=encoder_request), file=file.Sink(request=file_requests), httpd=httpd.Sink(control=http), )
def test_route_error(self): actual_sequence = [] def on_chain_item(i): nonlocal actual_sequence actual_sequence.append(i) sink, route_error = make_error_router() origin = ( Observable.from_([ Observable.just(1), Observable.throw(-1) ]) .do_action(lambda i: print) .let(route_error, error_map=lambda e: e.args[0] * 100, ) .do_action(lambda i: print) ) result = Observable.merge(origin, sink) disposable = result.subscribe(on_chain_item) disposable.dispose() expected_sequence = [1, -100] self.assertEqual(actual_sequence, expected_sequence)
def rmux_client(sources): response = sources.tcp_client.response.share() tcp_connect = Observable.just( tcp_client.Connect(host='127.0.0.1', port='8080')) create_observable = ( response.flat_map(lambda connection: Observable.just({ 'what': 'subscribe', 'id': 42, 'name': '1234' }).map(lambda i: json.dumps(i)).let(frame).map( lambda j: tcp_client.Write(id=connection.id, data=j.encode())))) console = (response.flat_map(lambda connection: connection.observable.map( lambda i: i.data.decode('utf-8')).let(unframe).map( lambda i: json.loads(i)).group_by(lambda i: i['id']).flat_map( lambda subscription: subscription.map(notification). dematerialize())).map(lambda i: "item: {}\n".format(i))) tcp_sink = Observable.merge(tcp_connect, create_observable) return Sink( tcp_client=tcp_client.Sink(request=tcp_sink), stdout=stdout.Sink(data=console), )
def subscribe_fields(exe_context, parent_type, source_value, fields): exe_context = SubscriberExecutionContext(exe_context) def on_error(error): exe_context.report_error(error) def map_result(data): if exe_context.errors: result = ExecutionResult(data=data, errors=exe_context.errors) else: result = ExecutionResult(data=data) exe_context.reset() return result observables = [] # assert len(fields) == 1, "Can only subscribe one element at a time." for response_name, field_asts in fields.items(): result = subscribe_field(exe_context, parent_type, source_value, field_asts) if result is Undefined: continue def catch_error(error): exe_context.errors.append(error) return Observable.just(None) # Map observable results observable = result.catch_exception(catch_error).map( lambda data: map_result({response_name: data})) return observable observables.append(observable) return Observable.merge(observables)
def echo_server(source): init = Observable.from_([ { 'what': 'add_route', 'methods': ['GET'], 'path': '/echo/{what}', }, { 'what': 'add_route', 'methods': ['GET'], 'path': '/exit', }, { 'what': 'start_server', 'host': 'localhost', 'port': 8080 } ]) echo = source['http'] \ .map(lambda i: create_response(i)) return { 'http': Observable.merge(init, echo), }
def discover(self, thing_filter, dnssd_find_kwargs=None): """Starts the discovery process that will provide ThingDescriptions that match the optional argument filter of type ThingFilter.""" supported_methods = [ DiscoveryMethod.ANY, DiscoveryMethod.LOCAL, DiscoveryMethod.MULTICAST ] if thing_filter.method not in supported_methods: err = NotImplementedError("Unsupported discovery method") # noinspection PyUnresolvedReferences return Observable.throw(err) if thing_filter.query: err = NotImplementedError( "Queries are not supported yet (please use filter.fragment)") # noinspection PyUnresolvedReferences return Observable.throw(err) observables = [] if thing_filter.method in [DiscoveryMethod.ANY, DiscoveryMethod.LOCAL]: observables.append( self._build_local_discover_observable(thing_filter)) if thing_filter.method in [ DiscoveryMethod.ANY, DiscoveryMethod.MULTICAST ]: observables.append( self._build_dnssd_discover_observable(thing_filter, dnssd_find_kwargs)) # noinspection PyUnresolvedReferences return Observable.merge(*observables)
def test_merge(): print('begin') source = Observable.interval(50).take(50) \ .do_action(lambda i: print(f'{i} @ {datetime.now()}')) \ .publish() \ .auto_connect() consective = source.map(lambda i: f'consective {i}') sample = source.sample(1000).map(lambda i: i + 1000) Observable.merge(consective, sample) \ .subscribe( on_next = print, on_error = print) print('done') input('press any key to quit')
def start(): """Callback when event_bus connection succeeds""" print('connected to event bus') #close the camera and kill the app on sigterm signal.signal(signal.SIGTERM, lambda sig, frame: stop()) signal.signal(signal.SIGINT, lambda sig, frame: stop()) pause_stream = (EVENT_BUS.request_stream .filter(lambda req: req['topic'] == 'faceDetect.pause') .map(lambda req: req['params']) .start_with(False) .distinct_until_changed() .publish()) time.sleep(1) last_result = False def handle_result(res): last_result = res EVENT_BUS.send_message('faceDetect.result', res) img_stream = timer.map(lambda x: get_image(x)).share() result_stream = (img_stream .with_latest_from(pause_stream, lambda x, is_paused: [x, is_paused]) .filter(lambda x: x[1] is not True) .map(lambda x: assoc_result(x[0])) .share()) found_stream = (result_stream .filter(lambda x: x["has-faces?"] is True) .map(lambda x: True)) not_found_stream = (result_stream.scan(lambda acc, x: ([x] + acc)[:FRAME_COUNT_UNTIL_FALSE], []) .filter(lambda buf: all(result["has-faces?"] is False for result in buf)) .map(lambda res: False)) brightness_stream = (img_stream .filter(lambda x, i: i % 15 == 0) .map(lambda x: cv2.cvtColor(x["img-array"], cv2.COLOR_BGR2HSV)) .map(lambda hsv: cv2.mean(hsv)[2] / 255) .subscribe(lambda brightness: EVENT_BUS.send_message('faceDetect.brightness', brightness))) (Observable.merge(found_stream, not_found_stream) .distinct_until_changed() .subscribe(handle_result)) pause_stream.connect() #show/hide the debug window (EVENT_BUS.request_stream .filter(lambda req: req['topic'] == 'faceDetect.showDebug') .subscribe(handle_debug_req)) (EVENT_BUS.request_stream .filter(lambda req: req['topic'] == 'faceDetect.getStatus') .subscribe(lambda req: req['respond'](last_result))) (EVENT_BUS.request_stream .filter(lambda req: req['topic'] == 'faceDetect.getImage') .subscribe(lambda req: result_stream .take(1) .map(lambda result: cv2.imencode('.jpg', result['img-array'])[1]) .map(lambda encoded: b64encode(np.array(encoded).tostring()).decode('ascii')) .subscribe(lambda msg: req['respond'](msg)))) EVENT_BUS.send_message('faceDetect.ready', True, 'magicMirror')
def test_several_concurrent_requests(self): results = [] Observable.merge([ self.protocol.send_request(SET(b'A', b'B'), write=self._write), self.protocol.send_request(SET(b'A', b'C'), write=self._write), self.protocol.send_request(SET(b'A', b'D'), write=self._write), self.protocol.send_request(SET(b'A', b'E'), write=self._write), self.protocol.send_request(GET(b'A'), write=self._write), self.protocol.send_request(SET(b'A', b'F'), write=self._write), self.protocol.send_request(SET(b'A', b'G'), write=self._write), self.protocol.send_request(SET(b'A', b'H'), write=self._write), self.protocol.send_request(SET(b'A', b'I'), write=self._write), self.protocol.send_request(SET(b'A', b'J'), write=self._write), self.protocol.send_request(GET(b'A'), write=self._write), ]).subscribe(on_next=lambda r: results.append(r)) self.assertEqual(results[4].value, b'E') self.assertEqual(results[10].value, b'J')
def main(inputs, starting_floor): floor_C = BehaviorSubject(starting_floor) inputs.floor_changed_S.subscribe(floor_C) calls_C = BehaviorSubject(set()) calls_S = inputs.called_S \ .map(lambda call: call.floor) \ .scan(lambda called_floors, floor: called_floors | set([floor]), set()) calls_S.subscribe(calls_C) selections_C = BehaviorSubject(set()) inputs.floor_selected_S \ .scan(lambda selections, floor: selections | set([floor]), set()) \ .subscribe(selections_C) resume_S = inputs.tick_S \ .with_latest_from(selections_C, lambda _, selections: first(selections)) \ .filter(cmp(not_, is_none)) # TODO (TS 2016-05-16) Don't fire if motor is already moving. motor_started_S = inputs.called_S \ .map(lambda call: call.floor) \ .merge(inputs.floor_selected_S, resume_S) \ .with_latest_from(floor_C, determine_direction) stop_for_call_S = inputs.floor_changed_S \ .with_latest_from(calls_C, arrived_on_called_floor) \ .filter(identity) \ .map(always(None)) stop_for_selection_S = inputs.floor_changed_S \ .with_latest_from(selections_C, arrived_on_selected_floor) \ .filter(identity) \ .map(always(None)) motor_stopped_S = Observable.merge(stop_for_call_S, stop_for_selection_S) motor_C = BehaviorSubject(None) motor_change_S = Observable.merge(motor_started_S, motor_stopped_S) motor_change_S.subscribe(motor_C) return motor_C
def exec(self, func, items): observables = [] with concurrent.futures.ProcessPoolExecutort() as executor: for item in items.values(): _future = executor.submit(func, item) observables.append(Observable.from_future(_future)) all_observables = Observable.merge(observables) all_observables.subscribe(self._on_success, self._on_error, self._on_complete)
def echo_server(source): init = Observable.from_([ httpd.Initialize(), httpd.AddRoute(methods=['GET'], path='/echo/{what}', id='echo'), httpd.StartServer(host='localhost', port=8080), ]) echo = (source.httpd.route.filter(lambda i: i.id == 'echo').flat_map( lambda i: i.request).map(lambda i: httpd.Response( context=i.context, data=i.match_info['what'].encode('utf-8')))) control = Observable.merge(init, echo) return EchoSink(httpd=httpd.Sink(control=control))
def subscribe_fields( exe_context, # type: ExecutionContext parent_type, # type: GraphQLObjectType source_value, # type: Any fields, # type: DefaultOrderedDict only_first_field=True, # type: bool ): # type: (...) -> Observable subscriber_exe_context = SubscriberExecutionContext(exe_context) def on_error(error): subscriber_exe_context.report_error(error) def map_result(data): # type: (Dict[str, Any]) -> ExecutionResult if subscriber_exe_context.errors: result = ExecutionResult(data=data, errors=subscriber_exe_context.errors) else: result = ExecutionResult(data=data) subscriber_exe_context.reset() return result def catch_error(error): subscriber_exe_context.errors.append(error) return Observable.just(None) observables = [] # type: List[Observable] # TODO: Make sure this works with multiple fields (currently untested) # so we can remove the "only_first_field" argument. for response_name, field_asts in fields.items(): result = subscribe_field( subscriber_exe_context, parent_type, source_value, field_asts, [response_name], ) if result is Undefined: continue # Map observable results observable = result.catch_exception(catch_error).map( lambda data: map_result({response_name: data})) if only_first_field: return observable observables.append(observable) return Observable.merge(observables)
def rmux_server(sources): tcp_listen = Observable.just( tcp_server.Listen(host='127.0.0.1', port='8080')) beat = (sources.tcp_server.response.flat_map( lambda connection: connection.observable.map(lambda i: i.data.decode( 'utf-8')).let(unframe).map(lambda i: json.loads(i)). flat_map(lambda subscription: create_observable[subscription['name']]( ).materialize().map(lambda i: materialize_repr(i, subscription['id']))) .map(lambda i: json.dumps(i)).let(frame).map( lambda j: tcp_server.Write(id=connection.id, data=j.encode())))) tcp_sink = Observable.merge(tcp_listen, beat) return Sink(tcp_server=tcp_server.Sink(request=tcp_sink), )
def resolve_todolist_mutation(root, info, id): _id = int(from_global_id(id)[1]) observable = Observable.merge(ChannelGroupObservable('todolist'), ChannelGroupObservable('todo')) return observable.map(lambda event: SubscriptionEvent.from_dict( event)).filter(lambda event: ( (isinstance(event.instance, models.TodoList) and event.instance .id == _id) or (isinstance(event.instance, models.Todo) and event.instance.parent_id == _id) )).map(lambda event: TodoListMutationValueObject( operation=event.operation, todolist=event.instance if isinstance(event.instance, models.TodoList) else None, todo=event.instance if isinstance(event.instance, models.Todo) else None))
def subscribe_fields( exe_context, # type: ExecutionContext parent_type, # type: GraphQLObjectType source_value, # type: Any fields, # type: DefaultOrderedDict ): # type: (...) -> Observable subscriber_exe_context = SubscriberExecutionContext(exe_context) def on_error(error): subscriber_exe_context.report_error(error) def map_result(data): # type: (Dict[str, Any]) -> ExecutionResult if subscriber_exe_context.errors: result = ExecutionResult(data=data, errors=subscriber_exe_context.errors) else: result = ExecutionResult(data=data) subscriber_exe_context.reset() return result observables = [] # type: List[Observable] # assert len(fields) == 1, "Can only subscribe one element at a time." for response_name, field_asts in fields.items(): result = subscribe_field( subscriber_exe_context, parent_type, source_value, field_asts, [response_name], ) if result is Undefined: continue def catch_error(error): subscriber_exe_context.errors.append(error) return Observable.just(None) # Map observable results observable = result.catch_exception(catch_error).map( lambda data: map_result({response_name: data})) return observable observables.append(observable) return Observable.merge(observables)
def bus_context(conf): blinker_ticks = Observable.interval(conf.blink.interval * 1000) montage_ticks = Observable.interval(conf.montage.interval * 1000) event_loop = EventLoopScheduler() buttons = [ Button(Shoot, conf.event.shoot, conf.bounce_time, event_loop), Button(Quit, conf.event.quit, conf.bounce_time, event_loop), Button(Quit, conf.event.reboot, conf.bounce_time, event_loop), Button(Quit, conf.event.shutdown, conf.bounce_time, event_loop) ] commands = (Observable.merge([button.events for button in buttons]).merge( ThreadPoolScheduler(max_workers=conf.workers), blinker_ticks.map(const(Blink())), montage_ticks.map(const(ShowRandomMontage())))) with commands.subscribe(on_next=inject(handle_command, conf)): yield
def main(): mo, clicks = observe_mouse(config.INPUT_CAPTURE_MOUSE) clicks = clicks.map(lambda click: "c") ko, strokes = observe_keyboard(config.INPUT_CAPTURE_KEYBOARD) THREADS.extend((mo, ko)) obs = Observable.merge(clicks, strokes) if config.INPUT_READCH: gcho, ch = observe_getch() THREADS.append(gcho) obs = obs.merge(ch) obs.subscribe(Observable.to_async(run_action), lambda e: print(e)) STATE.done() # Block on semaphore and keep the rest of threads do the thingy QUIT_LOCK.acquire()
def echo_server(source): init = Observable.from_([{ 'what': 'add_route', 'methods': ['GET'], 'path': '/echo/{what}', }, { 'what': 'start_server', 'host': 'localhost', 'port': 8080 }]) echo = source['http'] \ .map(lambda i: { 'what': 'response', 'status': 200, 'context': i['context'], 'data': i['match_info']['what'].encode('utf-8'), }) return { 'http': Observable.merge(init, echo), }
from rx import Observable source1 = Observable.interval(1000).map(lambda i: "Source 1: {0}".format(i)) source2 = Observable.interval(500).map(lambda i: "Source 2: {0}".format(i)) source3 = Observable.interval(300).map(lambda i: "Source 3: {0}".format(i)) Observable.merge(source1, source2, source3) \ .subscribe(lambda s: print(s)) # keep application alive until user presses a key input("Press any key to quit\n")
def deepspeech_server(sources): argv = sources.argv.argv stt = sources.httpd.route stt_response = sources.deepspeech.text.share() ds_logs = sources.deepspeech.log config_data = sources.file.response http_ds_error, route_ds_error = make_error_router() args = argparse.argparse( argv=argv.skip(1).subscribe_on(aio_scheduler), parser=Observable.just( argparse.Parser(description="deepspeech server")), arguments=Observable.from_([ argparse.ArgumentDef(name='--config', help="Path of the server configuration file") ])) config_file = (args.filter(lambda i: i.key == 'config').map( lambda i: file.Read(id='config', path=i.value))) config = parse_config(config_data).subscribe_on(aio_scheduler) logs_config = (config.flat_map(lambda i: Observable.from_(i.log.level).map( lambda i: logging.SetLevel(logger=i.logger, level=i.level)).concat( Observable.just(logging.SetLevelDone())))) logs = Observable.merge(logs_config, ds_logs) log_ready = sources.logging.response.take(1) ds_stt = (stt.flat_map(lambda i: i.request).map( lambda i: deepspeech.SpeechToText(data=i.data, context=i.context))) ds_arg = ( # config is hot, the combine operator allows to keep its last value # until logging is initialized log_ready.combine_latest( config, lambda _, i: i).map(lambda i: deepspeech.Initialize( model=i.deepspeech.model, alphabet=i.deepspeech.alphabet, lm=i.deepspeech.lm, trie=i.deepspeech.trie, features=deepspeech.FeaturesParameters( n_features=i.deepspeech.features.n_features, n_context=i.deepspeech.features.n_context, beam_width=i.deepspeech.features.beam_width, lm_alpha=i.deepspeech.features.lm_alpha, lm_beta=i.deepspeech.features.lm_beta, ) if i.deepspeech.features is not None else None))) ds = ds_stt.merge(ds_arg) http_init = (config.flat_map(lambda i: Observable.from_([ httpd.Initialize(request_max_size=i.server.http.request_max_size), httpd.AddRoute( methods=['POST'], path='/stt', id='stt', ), httpd.StartServer(host=i.server.http.host, port=i.server.http.port), ]))) http_response = (stt_response.let(lambda x: route_ds_error( x, error_map=lambda e: httpd.Response( data="Speech to text error".encode('utf-8'), context=e.args[0].context, status=500))).map(lambda i: httpd.Response( data=i.text.encode('utf-8'), context=i.context, ))) http = Observable.merge(http_init, http_response, http_ds_error) return DeepspeechSink(file=file.Sink(request=config_file), logging=logging.Sink(request=logs), deepspeech=deepspeech.Sink(speech=ds), httpd=httpd.Sink(control=http))
def betfair_source(): return Observable.merge(betfair_access_layer.market_observable, betfair_access_layer.order_observable)
def create(): return Observable.merge(scheduler, e1, e2, e3)
def create(): return Observable.merge(scheduler, n1, n2, n3)
def create(): return Observable.merge(scheduler, o1, o2)
return False else: sys.stderr.write("Error {}\n".format(status)) return True tweet_listener = TweetListener() auth = get_twitter_auth() stream = Stream(auth, tweet_listener) stream.filter(track=topics, locations=locations) return Observable.create(observe_tweets).share() topics = [ 'RDC', 'RDCongo', 'DRC', 'DRCongo', ] coordinates = get_location(get_twitter_client(), 'Congo').get('coordinates') location_tweets = tweet_for(topics=[], locations=[11.94, -13.64, 30.54, 5.19]) hash_tag_tweets = tweet_for(topics=topics) place_id_tweet = tweet_for(topics=topics, locations=coordinates) combine_loc_hash_tag = Observable.merge(hash_tag_tweets) ( combine_loc_hash_tag.subscribe() )
from rx import Observable # https://www.safaribooksonline.com/videos/reactive-python-for/9781491979006/9781491979006-video294990 obs1 = Observable.from_([1, 2, 445, 46, 2, 23, 5]) obs2 = Observable.from_([2, 3, 88, 14, 7, 1, 41]) Observable.merge(obs1, obs2).subscribe(lambda x: print(x)) obs1 = Observable.interval(1000).map(lambda i: "Source 1: {0}".format(i)) obs2 = Observable.interval(500).map(lambda i: "Source 2: {0}".format(i)) obs3 = Observable.interval(300).map(lambda i: "Source 3: {0}".format(i)) Observable.merge(obs1, obs2, obs3) \ .subscribe(lambda x: print(x)) Observable.from_([obs1, obs2, obs3]) \ .merge_all() \ .subscribe(lambda x: print(x)) items = ['"12/123/345/123/3/6', "8/3/1/6/9/05/", "4/3/6/8/9/4/3/67"] Observable.from_(items) \ .map(lambda s: Observable.from_(s.split('/'))) \ .merge_all() \ .subscribe(lambda i: print(i)) Observable.from_(items) \ .flat_map(lambda s: Observable.from_(s.split('/'))) \ .subscribe(lambda i: print(i))
from rx import Observable obs1 = Observable.from_([1, 2, 3]) obs2 = Observable.from_([10, 11, 12]) Observable.merge(obs1, obs2)\ .subscribe(lambda s:print(s))
from rx import Observable obs1 = Observable.from_([1,2,3]) obs2 = Observable.from_([10,11,12]) Observable.merge(obs1, obs2)\ .subscribe(lambda s:print(s))
windows = Observable.interval(500) \ .map(lambda x: ewmh.getActiveWindow()) \ .distinct_until_changed() \ .filter(lambda x: x) active = windows.map(decorateWindow) left = combine_frames(time, active) right = combine_frames(cpu, mem, mail, disks) \ .map(lambda x: "^p(_CENTER){}".format(x)) \ header = Observable.combine_latest( left, right, lambda x, y: "{} ^p(_CENTER){}".format(x, y)) body = Observable.merge( mail_headings.distinct_until_changed().map(lambda x: "^cs()\n"+x), Observable.interval(1000).map(lambda x: "")) bar = Observable.combine_latest( header, body, lambda x, y: "^tw(){}\n{}".format(x, y))\ .distinct_until_changed() \ .subscribe(lambda x: print(x, end="")) while True: sleep(1)
def audio_encoder(sources): http_s3_error, route_s3_error = make_error_router() http_encode_error, route_encode_error = make_error_router() # Parse configuration parsed_argv = (sources.argv.argv.skip(1).let( argparse.argparse, parser=Observable.just( argparse.Parser(description="audio encode server")), arguments=Observable.from_([ argparse.ArgumentDef(name='--config', help="Path of the server configuration file") ])).filter(lambda i: i.key == 'config').subscribe_on( aio_scheduler).share()) # monitor and parse config file monitor_init = (parsed_argv.flat_map(lambda i: Observable.from_([ inotify.AddWatch( id='config', path=i.value, flags=aionotify.Flags.MODIFY), inotify.Start(), ]))) config_update = (sources.inotify.response.debounce(5000).map( lambda i: True).start_with(True)) read_config_file = (Observable.combine_latest( parsed_argv, config_update, lambda config, _: file.Read(id='config', path=config.value))) config = sources.file.response.let(parse_config) # Transcode request handling encode_init = (config.map(lambda i: i.encode).distinct_until_changed().map( lambda i: encoder.Configure(samplerate=i.samplerate, bitdepth=i.bitdepth))) encode_request = ( sources.httpd.route.filter(lambda i: i.id == 'flac_transcode'). flat_map(lambda i: i.request).flat_map(lambda i: Observable.just( i, encode_scheduler)).map(lambda i: encoder.EncodeMp3( id=i.context, data=i.data, key=i.match_info['key']))) encoder_request = Observable.merge(encode_init, encode_request) # store encoded file store_requests = (sources.encoder.response.let( catch_or_flat_map, error_router=route_encode_error, error_map=lambda i: httpd.Response(data='encode error'.encode('utf-8'), context=i.args[0].id, status=500)). observe_on(s3_scheduler).map(lambda i: s3.UploadObject( key=i.key + '.flac', data=i.data, id=i.id, ))) # acknowledge http request http_response = (sources.s3.response.let( catch_or_flat_map, error_router=route_s3_error, error_map=lambda i: httpd.Response(data='upload error'.encode('utf-8'), context=i.args[0].id, status=500)).map( lambda i: httpd.Response( data='ok'.encode('utf-8'), context=i.id, ))) # http server http_init = (config.take(1).flat_map(lambda i: Observable.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 = Observable.merge(http_init, http_response, http_s3_error, http_encode_error) # s3 database s3_init = (config.take(1).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_config_file s3_requests = Observable.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), )
return csv_reader def row_to_dict(row): return { 'id': int(row[0]), 'filename': row[1], 'lines': int(row[2]), 'size': int(row[3]) } files = ['test.csv', 'test2.csv'] source = Observable.merge([ Observable.from_iterable(read_csv(filename)) for filename in files ]).map(row_to_dict) # We want to be able to connect multiple subscribers before we start emitting items published = source.publish() def print_row(row): print( 'File "{filename}" has {lines} lines and its size is {size} kb'.format( **row)) def print_group(group): return group.subscribe(print_row)
def get_merged_root(): merged_root = Observable.merge(betfair_access_layer.market_observable, betfair_access_layer.order_observable) \ .start_with(*betfair_access_layer.todays_racecard) \ .observe_on(main_worker) return merged_root