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 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),
}
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)
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
