def __init__(self):
self.initRequest = Subject()
self.addSegmentConfigRequest = Subject()
self.removeSegmentConfigRequest = Subject()
self.updateSegmentConfigRequest = Subject()
self.generateManipulatorRequest = Subject()
self.updateTensionsRequest = Subject()
self.computeStateRequest = Subject()
segment_config_repo_op = ops.merge(
self.initRequest.pipe(
ops.map(Repo().publish_init_segments_config)
),
self.addSegmentConfigRequest.pipe(
ops.map(Repo().add_segment)
),
self.removeSegmentConfigRequest.pipe(
ops.map(Repo().remove_segment)
),
self.updateSegmentConfigRequest.pipe(
ops.map(Repo().update_segment_config)
)
)
self._segment_configs_stream = Observable().pipe(
segment_config_repo_op,
)
# TODO
self._segment_configs_err_stream = Observable().pipe(
segment_config_repo_op,
ops.flat_map(lambda x: Observable.just(Repo().get_error()))
)
self._tension_inputs_stream = Observable().pipe(
ops.merge(
self.generateManipulatorRequest.pipe(
ops.map(Repo().generate_manipulator)
),
self.updateTensionsRequest.pipe(
ops.map(Repo().updateTensions)
),
)
)
compute_state_result = self.computeStateRequest.pipe(
ops.map(Repo().computeTensions)
)
self._text_result_stream = compute_state_result.pipe(
ops.map(format_manipulator)
)
self._graph_stream = compute_state_result.pipe(
)
def __init__(self,
concurrency_per_group,
delay_seconds=0,
description=None):
self._queue = Subject()
self._description = description
self.request_scheduler = ThreadPoolScheduler(concurrency_per_group)
producer_scheduler = ThreadPoolScheduler(concurrency_per_group)
def on_next(result):
output = result['output']
output.on_next({
'value': result.get('value'),
'completed': result.get('completed')
})
self._subscription = self._queue.pipe(
observe_on(producer_scheduler), group_by(lambda r: r['group']),
flat_map(lambda concurrency_group: concurrency_group.pipe(
map(lambda r: r['work']),
delay(delay_seconds),
merge(max_concurrent=concurrency_per_group),
merge_all(),
)), take_until_disposed()).subscribe(
on_next=on_next,
on_error=lambda error: logging.exception(
'Error in {} request stream'.format(self)),
scheduler=producer_scheduler)
def mergeOperator(self):
source = of(1, 2, 3, 4, 5)
source2 = of(11, 12, 13, 14, 15, 16)
result = source.pipe(op.merge(source2))
result.subscribe(
lambda item: print('"Subscribe Merge" output: {}'.format(item)))
def merge_(
stream1: Union[rx.typing.Observable[T1], rx.typing.Subject[T1, T1], ],
stream2: Union[rx.typing.Observable[T2], rx.typing.Subject[T2, T2], ],
) -> rx.typing.Observable[Union[T1, T2]]:
return cast(rx.Observable, stream1)\
.pipe(
ops.merge(cast(rx.Observable, stream2))
)
def test_spot_instance_checker_through_404(requests_mock):
requests_mock.get(INSTANCE_ACTION_URL, text="test", status_code=404)
o = spot_instance_check_observable(0.1).pipe(ops.merge(rx.timer(0.5)),
ops.first())
def on_next(x):
assert x == 0
o.subscribe(on_next=on_next, scheduler=CurrentThreadScheduler())
def test_spot_instance_checker_terminate(requests_mock):
body = {"action": "terminate", "time": "2017-09-18T08:22:00Z"}
requests_mock.get(INSTANCE_ACTION_URL, json=body)
o = spot_instance_check_observable(0.1).pipe(ops.merge(rx.timer(0.5)),
ops.first())
def on_next(x):
assert isinstance(x, CheckerMessage)
assert x.checker_type == "spot_instance"
assert x.body == f'"spot/instance-action": {body}'
o.subscribe(on_next=on_next, scheduler=CurrentThreadScheduler())
def test_spot_instance_checker_observer(requests_mock):
with mock.patch("igata.checkers.aws.observers.logger.info") as mock_method:
requests_mock.get(INSTANCE_ACTION_URL,
json={
"action": "terminate",
"time": "2017-09-18T08:22:00Z"
})
o = spot_instance_check_observable(0.1).pipe(
ops.merge(rx.timer(0.3)), ops.take(2),
ops.filter(lambda x: isinstance(x, CheckerMessage)))
o.subscribe(CheckersObserver(), scheduler=CurrentThreadScheduler())
mock_method.assert_called_once()
def complexMerge(self):
# This is infinite
source = interval(1).pipe(
op.map(lambda item: item * 10),
op.map(lambda second: self.intense_calculation(second)))
source2 = of('Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon').pipe(
op.map(lambda second: self.intense_calculation(second)))
result = source.pipe(op.merge(source2))
result.subscribe(on_next=lambda item: print(
'"Subscribe Complex Merge" output: {}'.format(item)),
on_error=lambda err: print('Error: {}'.format(e)))
input('Press any key to exit\n')
def timestampOperator(self):
source = interval(1).pipe(
op.map(lambda second: self.intense_calculation(second)),
op.timestamp()
)
source2 = of('Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon').pipe(
op.map(lambda second: self.intense_calculation(second)),
op.timestamp()
)
result = source.pipe(
op.merge(source2)
)
result.subscribe(lambda item: print('"Subscribe Timestamp" output: {}'.format(item)))
def getCategoryAndDependencies(selectedJobId):
return rx.of(selectedJobId).pipe(
ops.flat_map(
lambda selectedJobId: getCategory(selectedJobId)
),
ops.flat_map(
lambda category: getTestruns(category)
),
ops.flat_map(
lambda testruns: rx.from_(testruns)
),
ops.map(
lambda testrun: getTestrunDependencies(testrun)
),
ops.merge(max_concurrent=1),
)
def __init__(self, concurrency_per_group, description=None):
self.scheduler = ThreadPoolScheduler(concurrency_per_group)
self._requests = Subject()
self._output = ReplaySubject()
self._description = description
self._subscription = self._requests.pipe(
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)))).subscribe(
on_next=lambda request: self._output.on_next(request),
on_error=lambda error: logging.exception(
'Error in {} request stream'.format(self)),
on_completed=lambda: logging.error(
'{} request stream unexpectedly completed'.format(self
)),
scheduler=self.scheduler)
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 __init__(self):
self.__rawPluginOutputStream = Subject()
self.__connectionStatusStream = Subject()
self.__speechStream = with_latest_from(
self.__rawPluginOutputStream.pipe(
map(lambda dehydratedMsgDict: rehydrateMessage(
dehydratedMsgDict))),
self.__connectionStatusStream,
).pipe(
map(lambda combinedTuple: {
**combinedTuple[0],
**combinedTuple[1]
}),
merge(self.__connectionStatusStream),
)
# TODO - need to trigger NVDA to startup, if it isn't already
# - first need to check if NVDA is installed + if the plugin is
asyncio.create_task(self.__startListeningForOutput())
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 op
from rx.subject import Subject
import datetime
print('1-100求和')
rx.range(1, 101).pipe(
op.reduce(lambda acc, i: acc + i, 0)
).subscribe(lambda i: print(i))
# 操作数据流
print('求所有偶数')
some_data = rx.of(1, 2, 3, 4, 5, 6, 7, 8)
some_data2 = rx.from_iterable(range(10, 20))
some_data.pipe(
op.merge(some_data2),
op.filter(lambda i: i % 2 == 0),
# op.map(lambda i: i * 2)
).subscribe(lambda i: print(i))
# debounce操作符，仅在时间间隔之外的可以发射
print('防止重复发送')
ob = Subject()
ob.pipe(
op.throttle_first(3)
# op.debounce(3)
).subscribe(
on_next=lambda i: print(i),
on_completed=lambda: print('Completed')
)
ctxmgr_settings = collect_ctxmgr_settings(args.input_ctx_manager,
args.output_ctx_manager)
for setting in ctxmgr_settings:
logger.info(f"{setting}: {ctxmgr_settings[setting]}")
scheduler = ThreadPoolScheduler(max_workers=1)
checkers_observable = rx.empty()
if settings.INSTANCE_ON_AWS:
logger.info(f"instance_type: {get_instance_type()}"
) # Assumes being run on AWS EC2 instance
if args.is_spot_instance or settings.AWS_ENABLE_SPOTINSTANCE_STATE_LOGGING:
logger.info(f"Start spot_instance_observable monitoring...")
spot_instance_observable = spot_instance_check_observable()
checkers_observable = checkers_observable.pipe(
ops.merge(spot_instance_observable))
elif args.is_spot_instance or settings.AWS_ENABLE_SPOTINSTANCE_STATE_LOGGING:
logger.warning(
f'"--spot-instance" flag or AWS_ENABLE_SPOTINSTANCE_STATE_LOGGING envar given, '
f"but INSTANCE_ON_AWS == False, logging NOT performed!")
checkers_observable.pipe(ops.publish()).connect(scheduler=scheduler)
checkers_observable.subscribe(CheckersObserver())
input_values = None
if args.inputs:
input_values = [v.strip() for v in args.inputs.split(",")]
summary = execute_prediction(
predictor=external_predictor,
input_ctx_manager=args.input_ctx_manager,
def create():
return xs.pipe(ops.merge(ys))
def create():
return xs.pipe(ops.merge(max_concurrent=2))
class MyObserver(Observer):
def on_next(self, x):
print("Got: %s" % x)
def on_error(self, e):
print("Got error: %s" % e)
def on_completed(self):
print("Sequence completed")
print("------ observer ------")
range(5).subscribe(MyObserver())
print("------ of ------")
of(7, 8).pipe(op.map(lambda x: x * 3)).subscribe(print)
of([7, 8]).pipe(op.map(lambda x: x * 3)).subscribe(print)
print("------ map ------")
range(10).pipe(op.map(lambda x: x * 2)).subscribe(print)
print("------ map ------")
range(10, 20, 2).pipe(op.map(lambda x: "%d" % (x * 2))).subscribe(print)
print("------ merge ------")
s1 = range(1, 5)
s2 = of("abcde", "def")
s1.pipe(op.merge(s2)).subscribe(print)
import rx
from rx import operators as ops
items = ["134/34/235/132/77", "64/22/98/112/86/11", "66/08/34/778/22/12"]
# RxPy v3.0 에서 부터 concat_all() 이 없어지고 merge 연산을 사용하고 max_concurrent 아규먼트를 1로 설정하도록 변경되었다.
rx.from_(items).pipe(
ops.map(lambda s: rx.from_(s.split("/"))),
ops.merge(max_concurrent=1),
ops.map(lambda s: int(s))
).subscribe(
lambda i: print(i)
)
op.catch() op.retry() """Utility""" op.delay() op.materialize() op.time_interval() op.timeout() op.timestamp() """Conditional and Boolean""" op.all() op.contains() op.default_if_empty() op.sequence_equal() op.skip_until() op.skip_while() op.take_until() op.take_while() """Connectable""" op.publish() op.ref_count() op.replay() """Combining""" op.combine_latest() op.merge() op.start_with() op.zip()
def throw_when(errors: Observable) -> Callable[[Observable], Observable]:
return rx.pipe(merge(errors.pipe(flat_map(lambda e: throw(e)))))
def create():
return xs.pipe(ops.merge(ys))
def create():
return xs.pipe(ops.merge(max_concurrent=2))
