def test_without_bp(self):
self.source.pipe(
operators.do_action(lambda x: print(f"Producing {x}")),
operators.map(self.slow_op),
operators.do_action(self.stop),
operators.take_until(self._stop),
).run()
def test_with_buffer(self):
self.source.pipe(
operators.do_action(lambda x: print(f"Producing {x}")),
bp_operator(BackPressure.BUFFER),
operators.map(self.slow_op),
operators.do_action(self.stop),
operators.take_until(self._stop),
).run()
def test_with_observe_on(self):
self.source.pipe(
operators.do_action(lambda x: print(f"Producing {x}")),
operators.observe_on(NewThreadScheduler()),
operators.map(self.slow_op),
operators.do_action(self.stop),
operators.take_until(self._stop),
).run()
def test_attach_size(self):
self.source.pipe(
operators.do_action(lambda x: print(f"Producing {x}")),
bp_drop_operator_attach_size(3),
operators.do_action(print),
operators.map(self.slow_op),
operators.do_action(self.stop),
operators.take_until(self._stop),
).run()
def run_metaepoch(self) -> Observable:
if self.alive:
epoch_job = StepsRun(self.metaepoch_len)
return epoch_job.create_job(self.driver).pipe(
ops.map(lambda message: self.fill_node_info(message)),
ops.do_action(
lambda message: self.update_current_cost(message)),
ops.do_action(
on_completed=lambda: self._after_metaepoch()),
)
return rx.empty()
def download(destination_file):
do_action(lambda _: os.makedirs(destination_file, exist_ok=True))
return of(create_downloader(destination_file)).pipe(
flat_map(lambda downloader: forever().pipe(
map(lambda _: next_chunk(downloader)),
take_while(lambda progress: progress < 1, inclusive=True),
map(
lambda progress: {
'progress': progress,
'downloaded_bytes': int(int(file['size']) * progress),
'file': file
}))))
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 run_parallel(args):
worker_factory, simulation_cases = factory.resolve_configuration(args)
logger.debug("Shuffling the job queue")
random.shuffle(simulation_cases)
logger.debug("Creating the pool")
processes_no = int(args["-j"])
rxtools.configure_default_executor(processes_no)
wall_time = []
start_time = datetime.now()
results = []
logger.debug("Simulation cases: %s", simulation_cases)
logger.debug("Work will be divided into %d processes", processes_no)
sys = ActorSystem("multiprocTCPBase", logDefs=log_helper.EVOGIL_LOG_CONFIG)
with log_time(system_time, logger, "Pool evaluated in {time_res}s", out=wall_time):
def process_result(subres):
results.append(subres)
log_simulation_stats(start_time, subres[-1], len(simulation_cases))
rx.from_iterable(range(len(simulation_cases))).pipe(
ops.map(lambda i: worker_factory(simulation_cases[i], i)),
# ops.map(lambda w: rxtools.from_process(w.run)),
ops.map(lambda w : w.run()),
# ops.merge(max_concurrent=1)
ops.do_action(on_next=process_result)
).run()
log_summary(args, results, simulation_cases, wall_time)
rxtools.shutdown_default_executor()
sys.shutdown()
def create():
def action(x):
i[0] += 1
sum[0] -= x
return sum[0]
return xs.pipe(_.do_action(action))
def main():
loop = asyncio.get_event_loop()
io_scheduler = AsyncIOThreadSafeScheduler(loop=loop)
scheduler = ThreadPoolScheduler(multiprocessing.cpu_count())
video_stream_observable = rx.using(
lambda: VideoStreamDisposable(),
lambda d: rx.from_iterable(video_stream_iterable(d.cap)))
disposable = video_stream_observable.pipe(
ops.subscribe_on(scheduler),
ops.sample(1 / ARGS.fps), # sample frames based on fps
ops.filter(has_face), # filter frames without faces
ops.map(lambda frame: Image.fromarray(
cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))), # map frame to PIL image
ops.observe_on(io_scheduler),
ops.map(lambda img: ImageFacesPair(img, analyse_frame(img))
), # analyse faces on frame
ops.filter(
lambda img_faces_pair: any([
face.top_prediction.confidence >= ARGS.min_confidence and face.
top_prediction.confidence <= ARGS.max_confidence
for face in img_faces_pair.faces
])
), # proceed only if min_confidence <= person_confidence <= max_confidence
ops.do_action(on_next=save_frame)).subscribe(
on_error=lambda e: logger.exception(e))
try:
loop.run_forever()
except Exception as e:
logger.exception(e)
logger.info("Data collector shutdown")
disposable.dispose()
def run_driver(self, driver: Driver, problem_mod: ModuleType,
logger: logging.Logger):
serializer = Serializer(self.simulation)
results = []
def process_results(budget: int):
finalpop = driver.finalized_population()
finalpop_fit = [[fit(x) for fit in problem_mod.fitnesses]
for x in finalpop]
serializer.store(Result(finalpop, finalpop_fit, cost=driver.cost),
str(budget))
results.append((driver.cost, finalpop))
driver.max_budget = self.budgets[-1]
for budget in self.budgets:
budget_run = BudgetRun(budget)
budget_run.create_job(driver).pipe(
ops.do_action(on_completed=lambda: process_results(budget))
).subscribe(lambda proxy: logger.debug(
"{}{} : Driver progress: budget={}, current cost={}, driver step={}"
.format(
self.simulation.algorithm_name,
self.simulation.problem_name,
budget,
proxy.cost,
proxy.step_no,
)))
return results
def run_driver(self, driver: Driver, problem_mod: ModuleType,
logger: logging.Logger):
results = []
timeout = self.simulation.params[factory.TIMEOUT_PARAM]
sampling_interval = self.simulation.params[
factory.SAMPLING_INTERVAL_PARAM]
serializer = Serializer(self.simulation)
slots_filled = set()
time_run = TimeRun(sampling_interval, timeout)
def process_results(msg: TimeProgressMessage):
finalpop = driver.finalized_population()
print(f"final pop result: {finalpop}")
finalpop_fit = [[fit(x) for fit in problem_mod.fitnesses]
for x in finalpop]
time_slot = msg.elapsed_time
serializer.store(Result(finalpop, finalpop_fit, cost=driver.cost),
str(time_slot))
results.append((driver.cost, finalpop))
slots_filled.add(time_slot)
time_run.create_job(driver).pipe(
ops.do_action(on_next=process_results)).run()
return results
def test_multiplex():
source = [1, 2, 3, 4]
actual_error = []
actual_completed = []
actual_result = []
mux_actual_result = []
def on_completed():
actual_completed.append(True)
rx.from_(source).pipe(
rs.ops.multiplex(rx.pipe(ops.do_action(
mux_actual_result.append), ), ), ).subscribe(
on_next=actual_result.append,
on_completed=on_completed,
on_error=actual_error.append,
)
assert actual_error == []
assert actual_completed == [True]
assert actual_result == source
assert mux_actual_result == [
rs.OnCreateMux((0, )),
rs.OnNextMux((0, ), 1),
rs.OnNextMux((0, ), 2),
rs.OnNextMux((0, ), 3),
rs.OnNextMux((0, ), 4),
rs.OnCompletedMux((0, )),
]
def get_products(shop: Dict[str, str], search_term: str,
options) -> Observable:
domain = re.findall("\.(.+)\.com", shop['url'])[0]
print(f"Lauching {domain}")
browser = launch_browser(f"{shop['url']}{search_term}", options, shop)
base_obs = rx.of(browser).pipe(
ops.do_action(
lambda el: print(f"Getting products prices from {domain}")),
ops.flat_map(lambda browser: rx.from_(
browser.find_elements_by_xpath(shop["xpath"]["parent"]))),
ops.filter(lambda el: el.is_displayed()),
ops.map(lambda el: (
get_property(el, shop["xpath"]["product_name"]),
get_property(el, shop["xpath"]["price"]),
)),
ops.filter(lambda el: el[0] and el[1]),
ops.map(lambda el: {
"name": el[0],
"price": el[1]
}),
ops.map(lambda product: transform_price(product, shop["priceRegexp"])),
ops.finally_action(lambda: browser.close()),
)
return base_obs
def timeout_check(process: subprocess.Popen, timeout: float,
ct: CancellationToken) -> rx.Observable:
"""Kills the given process after timeout has passed.
Args:
process: process to be killed
timeout: termination time in seconds
ct: CancellationToken
Return:
rx.Observable that fires only a single dictionary after the timeout
has passed.
"""
return rx.timer(timeout).pipe(
ops.do_action(
# Request cancellation so all simulation processes that
# share the same cancellation_token are also stopped.
# TODO not working as intended if simulation is short enough
# to stop before max_time has elapsed. Maybe let caller
# implement its own timeout check when multiple processes
# are being run.
on_next=lambda _: ct.request_cancellation()),
ops.map(
lambda _: {
# sutils.kill_process returns None, which can be casted to bool
MCERD.IS_RUNNING:
bool(sutils.kill_process(process)),
MCERD.MSG:
MCERD.SIM_TIMEOUT
}),
ops.first())
def add(self, file_name: str, content: Union[bytes, Path], override: bool = False,
config: DataRefRequestConfig = None) -> Observable['DataRef']:
r"""Uploads a file with a given name and content to the storage.
:param file_name: Name of the file to be uploaded.
:param content: Content of the file to be uploaded in bytes or a Path pointing to a file location.
:param override: (optional) Flag to specify if existing files should be overwritten. If set to false, the method
will throw an exception when trying to overwrite an existing file.
:param config: (optional) Interface which currently only contains onUploadProgress callback
:return: :class:`Observable[DataRef]` object: Reference to the newly uploaded file
:exception HttpError: Error thrown if the upload fails due to override being set to false.
"""
file_uri = DataRef.concat_uri(self.uri, file_name)
if isinstance(content, bytes):
upload_content = DataUploadContentBytes(content)
else:
upload_content = DataUploadContentPath(content)
number_of_chunks = ceil(upload_content.total_size_in_bytes / CHUNK_SIZE)
upload = DataUpload(file_uri, upload_content, number_of_chunks, override, config)
def execute_upload() -> DataRef:
self.logger.debug(f"Started upload to uri {file_uri}")
new_file_data_ref = upload.execute(self.client, self.scheduler)
self.logger.debug(f"Finished upload to uri {file_uri}")
return new_file_data_ref
return rx.from_callable(execute_upload).pipe(ops.do_action(on_error=lambda: upload_content.close(),
on_completed=lambda: upload_content.close()))
def create():
def on_next(x):
i[0] += 1
sum[0] -= x
def on_completed():
completed[0] = True
return xs.pipe(_.do_action(on_next=on_next, on_completed=on_completed))
def test_split():
source = ["1a", "2a", "3b", "4b", "5c", "6c", "7c", "8d", "9d"]
source = [
rs.OnCreateMux((1, None)),
rs.OnNextMux((1, None), '1a'),
rs.OnNextMux((1, None), '2a'),
rs.OnNextMux((1, None), '3b'),
rs.OnNextMux((1, None), '4b'),
rs.OnNextMux((1, None), '5c'),
rs.OnNextMux((1, None), '6c'),
rs.OnNextMux((1, None), '7c'),
rs.OnNextMux((1, None), '8d'),
rs.OnNextMux((1, None), '9d'),
rs.OnCompletedMux((1, None)),
]
actual_result = []
mux_actual_result = []
expected_result = [
["1a", "2a"],
["3b", "4b"],
["5c", "6c", "7c"],
["8d", "9d"],
]
def on_next(i):
actual_result.append(i)
store = rs.state.StoreManager(store_factory=rs.state.MemoryStore)
rx.from_(source).pipe(
rs.cast_as_mux_observable(),
rs.state.with_store(
store,
rs.data.split(lambda i: i[-1],
rx.pipe(ops.do_action(mux_actual_result.append), )),
),
).subscribe(on_next)
assert type(mux_actual_result[0]) is rs.state.ProbeStateTopology
assert mux_actual_result[1:] == [
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), '1a', store),
rs.OnNextMux((1, (1, None)), '2a', store),
rs.OnCompletedMux((1, (1, None)), store),
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), '3b', store),
rs.OnNextMux((1, (1, None)), '4b', store),
rs.OnCompletedMux((1, (1, None)), store),
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), '5c', store),
rs.OnNextMux((1, (1, None)), '6c', store),
rs.OnNextMux((1, (1, None)), '7c', store),
rs.OnCompletedMux((1, (1, None)), store),
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), '8d', store),
rs.OnNextMux((1, (1, None)), '9d', store),
rs.OnCompletedMux((1, (1, None)), store),
]
assert actual_result == source
def _conditional_printer(
cond: bool, msg: str) -> Callable[[rx.Observable], rx.Observable]:
if cond:
return observing.get_printer(msg)
def passer(*_):
pass
return ops.do_action(passer)
def run_metaepoch(self):
if self.node.alive:
self.log("ALIVE SO RUN EPOCH")
self.metaepoch_cost = self.node.current_cost
epoch_job = StepsRun(self.node.metaepoch_len)
self.log(
f"starting metaepoch, len={self.node.metaepoch_len}, pop_len={len(self.node.driver.population)} "
)
return epoch_job.create_job(self.node.driver).pipe(
ops.map(lambda message: self.fill_node_info(message)),
ops.do_action(
lambda message: self.update_current_cost(message)),
ops.do_action(on_completed=lambda: self._after_metaepoch()),
)
self.log("DEAD SO EMPTY MSG")
return rx.empty()
def play_step(self, step, cancel):
interval = rx.interval(0.1)
interval_steps = rx.just(step).pipe(
ops.flat_map(lambda step: interval.pipe(ops.map(lambda _: step))))
step_done = interval_steps.pipe(
ops.filter(lambda step: self.player.position() >= step.step_end),
ops.do_action(
lambda step: self.player.set_position(step.loop_start)),
ops.take(1))
loop_done = interval_steps.pipe(
ops.filter(lambda step: self.player.position() >= step.loop_end),
ops.do_action(
lambda step: self.player.set_position(step.loop_start)),
ops.take_until(cancel.pipe(ops.skip(1))))
return step_done.pipe(ops.merge(loop_done))
def create():
def on_next(x):
i[0] += 1
sum[0] -= x
def on_completed():
completed[0] = True
return xs.pipe(
_.do_action(on_next=on_next, on_completed=on_completed))
def get_printer(completed_msg=""):
"""Returns an rx.operator that prints the observed item to console.
Args:
completed_msg: message shown when the observable completes.
"""
return ops.do_action(
on_next=print,
on_error=lambda x: print("Error:", x, file=sys.stderr),
on_completed=lambda: print("Completed:", completed_msg))
def test_closing_mapper_exclude():
source = [
rs.OnCreateMux((1 ,None)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=1)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=2)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=3)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=4)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=5)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=6)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=10)),
rs.OnNextMux((1, None), datetime(2020, 1, 2, second=12)),
rs.OnCompletedMux((1, None)),
]
actual_result = []
mux_actual_result = []
def on_next(i):
actual_result.append(i)
store = rs.state.StoreManager(store_factory=rs.state.MemoryStore)
rx.from_(source).pipe(
rs.cast_as_mux_observable(),
rs.state.with_store(
store,
rs.data.time_split(
time_mapper=lambda i: i,
active_timeout=timedelta(seconds=5),
inactive_timeout=timedelta(seconds=3),
closing_mapper=lambda i: i == datetime(2020, 1, 2, second=4),
include_closing_item=False,
pipeline=rx.pipe(
ops.do_action(mux_actual_result.append),
)),
),
).subscribe(on_next)
assert type(mux_actual_result[0]) is rs.state.ProbeStateTopology
assert mux_actual_result[1:] == [
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=1), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=2), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=3), store),
rs.OnCompletedMux((1, (1, None)), store),
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=4), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=5), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=6), store),
rs.OnCompletedMux((1, (1, None)), store),
rs.OnCreateMux((1, (1, None)), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=10), store),
rs.OnNextMux((1, (1, None)), datetime(2020, 1, 2, second=12), store),
rs.OnCompletedMux((1, (1, None)), store),
]
assert actual_result == source
def create():
nonlocal completed
def on_next(x):
i[0] += 1
def on_completed():
nonlocal completed
completed = True
return rx.never().pipe(
_.do_action(on_next=on_next, on_completed=on_completed), )
def create():
nonlocal completed
def on_next(x):
i[0] += 1
def on_completed():
nonlocal completed
completed = True
return rx.never().pipe(
_.do_action(on_next=on_next, on_completed=on_completed),
)
def requestQuotes(self, tickers):
logger.debug(f'QuoteObserver.requestQuotes({tickers})')
self.quoteSubscription = create(
lambda o, s: beginStreamingQuotes(tickers, o, s)).pipe(
op.subscribe_on(config.pool_scheduler),
op.observe_on(config.pool_scheduler),
op.do_action(lambda q: logger.debug(f'QO: {q}')),
op.group_by(lambda q: q['symbol']),
).subscribe(on_next=self.handleQuote,
on_error=lambda e: logger.debug(e),
on_completed=lambda: logger.debug(
'QuoteObserver subscription completed'))
async def init(self):
self.app['REQUEST_COUNT'] = Counter('request_total', 'Total Incoming Request', ('path', 'method'), unit='requests')
self.app['REQUEST_LATENCY'] = Summary('request_latency', 'Request Process Time', ('path', 'method'), unit='seconds')
self.app['REQUEST_PROGRESS'] = Gauge('request_progress', 'Request in Progress', ('path', 'method'), unit='requests')
# Establish connection to RabbitMQ
self.rmqConn = await connect_robust(login='******', password='******')
# Establish channel for order request and declare order queue
self.channel['/order'] = await self.rmqConn.channel()
await self.channel['/order'].declare_queue('order', durable=True)
# Establish channel for account request and declare account queue
self.channel['/account'] = await self.rmqConn.channel()
await self.channel['/account'].declare_queue('account', durable=True)
# Create disposable request observer for handling order request. Only request to /order will be passed to OrderHandler
dispose = self.request.pipe(
ops.filter(lambda i : i.path == '/order'),
ops.do_action(self.logRequest),
ops.filter(self.orderHandler.orderVerificator)
).subscribe(self.orderHandler, scheduler=AsyncIOScheduler)
self.subscriptions.append(dispose)
# Create disposable request observer for handling account request. Only request to /account will be passed to OrderHandler
dispose = self.request.pipe(
ops.filter(lambda i : i.path == '/account'),
ops.do_action(self.logRequest),
ops.filter(self.accountHandler.accountVerificator)
).subscribe(self.accountHandler, scheduler=AsyncIOScheduler)
self.subscriptions.append(dispose)
self.app.router.add_post('/order', self.dispatcher, name='order')
self.app.router.add_get('/orders/{account}', self.orderQuery)
self.app.router.add_post('/account', self.dispatcher, name='account')
self.app.router.add_get('/accounts/{account}', self.accountQuery)
self.app.router.add_get('/metrics', self.metrics)
self.app.on_shutdown.append(self.on_shutdown)
return self.app
def enqueue(self,
observable: Observable,
group: str = 'default-group',
retries: int = 0,
description: str = None) -> Observable:
def log_status(status):
logging.debug(
str({
'WorkQueue': str(self),
'group': group,
status: description
}))
log_status('ENQUEUED')
output = Subject()
errors = Subject()
output_finalized = Subject()
def handle_error(e, _):
log_status('FAILED')
errors.on_next(e)
return empty()
def set_output_finalized():
output_finalized.on_next(True)
work = of(True).pipe(
do_action(lambda _: log_status('STARTED')),
take_until(output_finalized),
flat_map(lambda _: observable.pipe(
map(lambda value: of({
'value': value,
'output': output
})),
retry_with_backoff(
retries=retries,
description='{}.enqueue(group={}, description={})'.format(
self, group, description)),
catch(handler=handle_error), take_until(output_finalized),
take_until_disposed())),
concat(of(of({
'completed': True,
'output': output
}))), finally_action(lambda: log_status('COMPLETED')))
self._queue.on_next({'work': work, 'group': group})
return output.pipe(observe_on(self.request_scheduler),
throw_when(errors),
take_while(lambda r: not r.get('completed')),
map(lambda r: r.get('value')),
finally_action(set_output_finalized))
def __init__(self, obs_stream, symbol):
logger.debug(f'Stock.__init__({symbol})')
self.obs_stream = obs_stream
self.symbol = symbol
self.price = ()
self.stockSubscription = self.obs_stream.pipe(
op.subscribe_on(config.pool_scheduler),
op.observe_on(config.pool_scheduler),
op.do_action(lambda s: logger.debug(f'STK: {s}')),
).subscribe(
on_next=self.handleQuote,
on_error=lambda e: logger.debug(e),
on_completed=lambda: logger.debug('Stock subscription completed'))
def stream_metaepoch_results(self, msg: NodeMessage, sender: Actor):
self.run_metaepoch().pipe(
ops.do_action(on_completed=lambda: self.node.send(
sender,
NodeMessage(NodeOperation.METAEPOCH_END, msg.id, self.
last_result_data),
))
).subscribe(
lambda result: self.update_cost(result)
# lambda result: self.node.send(
# sender, NodeMessage(NodeOperation.NEW_RESULT, msg.id, result)
# )
)
def of_init_feature(identifier: str) -> Mapper[Observable, Observable]:
""" Operator to test for the initialization action of a feature
Args:
identifier: the identifier of the feature
Returns:
Operator function that accepts init actions for the feature, once
"""
return pipe(op.filter(is_type(INIT_ACTION)),
op.filter(has_payload(identifier)), op.take(1),
op.map(lambda x: identifier), op.do_action(logger.debug))
def test_amb_regular_should_dispose_loser(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_completed(240)]
msgs2 = [on_next(150, 1), on_next(220, 3), on_completed(250)]
source_not_disposed = [False]
o1 = scheduler.create_hot_observable(msgs1)
def action():
source_not_disposed[0] = True
o2 = scheduler.create_hot_observable(msgs2).pipe(
ops.do_action(on_next=action),
)
def create():
return o1.pipe(ops.amb(o2))
results = scheduler.start(create)
assert results.messages == [on_next(210, 2), on_completed(240)]
assert(not source_not_disposed[0])
def test_merge_error_causes_disposal(self):
ex = 'ex'
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_error(210, ex)]
msgs2 = [on_next(150, 1), on_next(220, 1), on_completed(250)]
source_not_disposed = [False]
o1 = scheduler.create_hot_observable(msgs1)
def action():
source_not_disposed[0] = True
o2 = scheduler.create_hot_observable(msgs2).pipe(ops.do_action(on_next=action))
def create():
return rx.merge(o1, o2)
results = scheduler.start(create)
assert results.messages == [on_error(210, ex)]
assert(not source_not_disposed[0])
def test_amb_loser_throws(self):
ex = 'ex'
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(220, 2), on_error(230, ex)]
msgs2 = [on_next(150, 1), on_next(210, 3), on_completed(250)]
source_not_disposed = [False]
def action():
source_not_disposed[0] = True
o1 = scheduler.create_hot_observable(msgs1).pipe(
ops.do_action(on_next=action),
)
o2 = scheduler.create_hot_observable(msgs2)
def create():
return o1.pipe(ops.amb(o2))
results = scheduler.start(create)
assert results.messages == [on_next(210, 3), on_completed(250)]
assert(not source_not_disposed[0])
def create():
def on_completed():
completed[0] = True
return xs.pipe(_.do_action(on_completed=on_completed))
import datetime
import rx
import rx.operators as ops
"""
Delay the emission of elements to the specified datetime.
"""
now = datetime.datetime.utcnow()
dt = datetime.timedelta(seconds=3.0)
duetime = now + dt
print('{} -> now\n'
'{} -> start of emission in {}s'.format(now, duetime, dt.total_seconds()))
hot = rx.hot('10--11--12--13--(14,|)', timespan=0.2, duetime=duetime)
source = hot.pipe(ops.do_action(print))
source.run()
import rx
from rx import operators as ops
"""
Specify the error to be raised in place of the # symbol.
"""
err = ValueError("I don't like 5!")
src0 = rx.from_marbles('12-----4-----67--|', timespan=0.2)
src1 = rx.from_marbles('----3----5-# ', timespan=0.2, error=err)
source = rx.merge(src0, src1).pipe(ops.do_action(print))
source.run()
import rx
from rx import operators as ops
a = rx.cold(' ---a0---a1----------------a2-| ')
b = rx.cold(' ---b1---b2---| ')
c = rx.cold(' ---c1---c2---| ')
d = rx.cold(' -----d1---d2---|')
e1 = rx.cold('a--b--------c-----d-------| ')
observableLookup = {"a": a, "b": b, "c": c, "d": d}
source = e1.pipe(
ops.flat_map(lambda value: observableLookup[value]),
ops.do_action(lambda v: print(v)),
)
source.run()
def create():
def action(x):
i[0] += 1
sum[0] -= x
return sum[0]
return xs.pipe(_.do_action(action))
def create():
def action(x):
i[0] += 1
return i[0]
return xs.pipe(_.do_action(action))
