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 function(*args):
arguments = list(args)
def subscribe(
observer: typing.Observer,
scheduler: Optional[typing.Scheduler] = None
) -> typing.Disposable:
def handler(*args):
results = list(args)
if mapper:
try:
results = mapper(args)
except Exception as err: # pylint: disable=broad-except
observer.on_error(err)
return
observer.on_next(results)
else:
if isinstance(results, list) and len(results) <= 1:
observer.on_next(*results)
else:
observer.on_next(results)
# observer.on_completed()
arguments.append(handler)
func(*arguments)
return Disposable()
return Observable(subscribe)
def from_marbles(string: str,
timespan: RelativeTime = 0.1,
lookup: Dict = None,
error: Optional[Exception] = None,
scheduler: Optional[Scheduler] = None) -> Observable:
disp = CompositeDisposable()
messages = parse(string,
timespan=timespan,
lookup=lookup,
error=error,
raise_stopped=True)
def schedule_msg(message, observer, scheduler):
timespan, notification = message
def action(scheduler, state=None):
notification.accept(observer)
disp.add(scheduler.schedule_relative(timespan, action))
def subscribe(observer, scheduler_):
_scheduler = scheduler or scheduler_ or new_thread_scheduler
for message in messages:
# Don't make closures within a loop
schedule_msg(message, observer, _scheduler)
return disp
return Observable(subscribe)
def _subscription_listener(source: Observable) -> Observable:
def subscribe(observer, scheduler_=None):
_scheduler = scheduler or scheduler_
subscription = source.subscribe(observer, scheduler=scheduler)
def dispose():
subscription.dispose()
action()
return Disposable(dispose)
return Observable(subscribe)
def unsafe_subscribe(
self, subscriber: MultiCastSubscriber) -> rx.typing.Observable:
source = self.source.get_source(info=info)
def subscribe(observer, scheduler=None):
def on_next(value) -> None:
for val in self.func(value):
observer.on_next(val)
return source.subscribe_(on_next, observer.on_error,
observer.on_completed, scheduler)
return Observable(subscriber)
def connect(self):
def on_connect(conn):
self.conn = conn
self.opened.on_next(conn)
self.opened.on_completed()
self.opened.dispose()
def on_message_callback(message):
self.messages.on_next(message)
future = websocket_connect(self._url,
on_message_callback=on_message_callback)
#connection = rx(from_future=future).subscribe(on_connect)
Observable(from_future=future).subscribe(on_connect)
class Rng(Component):
"""
A random number generator component. Produces uniformly distributed random floats between [0,1)
:var output_random_number: A stream of the generated random numbers.
"""
output_random_number = Observable()
def __init__(self):
super().__init__()
# every second emit a uniformly distributed random float between [0,1)
self.output_random_number = rx.timer(0, 1).pipe(
ops.map(lambda s: random.random()))
def map(source: Observable) -> Observable:
def subscribe(obv: Observer,
scheduler: Scheduler = None) -> Disposable:
def on_next(value: Any) -> None:
try:
# print(value)
data_list.append(value)
result = None
current_time = round_seconds(
datetime.datetime.fromtimestamp(value.epoch))
# _, _, _, _, min_2, sec_2, _, _, _ = current_time.timetuple()
if vars['start_time'] is None:
vars['start_time'] = current_time
window_begin_time = vars['start_time']
# _, _, _, _, min_1, sec_1, _, _, _ = window_begin_time.timetuple()
time_sec_diff = current_time - window_begin_time
time_sec_diff = time_sec_diff.seconds
# min_diff = min_2 - min_1
# sec_diff = sec_2 - sec_1
# print(time_sec_diff, time, time_sec_diff >= time)
if time_sec_diff >= time:
result = list(data_list)
data_list.clear()
vars['start_time'] = None
# print(len(data_list))
# result = value
except Exception as err: # pylint: disable=broad-except
obv.on_error(err)
else:
obv.on_next(result)
return source.subscribe_(on_next, obv.on_error, obv.on_completed,
scheduler)
return Observable(subscribe)
def unsafe_subscribe(
self, subscriber: MultiCastSubscriber) -> rx.typing.Observable:
source = self.source.get_source(info=info)
def subscribe(observer, scheduler=None):
def on_next(x):
observer.on_next(x)
observer.on_completed()
def on_completed():
try:
observer.on_next(self.lazy_val())
observer.on_completed()
except Exception as exc:
observer.on_error(exc)
return source.subscribe_(on_next, observer.on_error, on_completed,
scheduler)
return Observable(subscriber)
def map(source: Observable) -> Observable:
def subscribe(obv: Observer, scheduler: Scheduler = None) -> Disposable:
def on_next(value: Any) -> None:
try:
window_que.put(value)
result = None
if window_que.full():
result = list(window_que.queue)
for i in range(skip):
window_que.get()
# window_que.put()
# result = value
except Exception as err: # pylint: disable=broad-except
obv.on_error(err)
else:
obv.on_next(result)
return source.subscribe_(on_next, obv.on_error, obv.on_completed, scheduler)
return Observable(subscribe)
def map(source: Observable) -> Observable:
def subscribe(obv: Observer, scheduler: Scheduler = None) -> Disposable:
def on_next(value: TickWindow) -> None:
try:
result = None
# if vars['start_time'] is None:
# vars['start_time'] = value.epoch
#
if vars['start_time'] and vars['start_time'] != value.epoch:
result = value
vars['start_time'] = value.epoch
# result = value
except Exception as err: # pylint: disable=broad-except
obv.on_error(err)
else:
obv.on_next(result)
return source.subscribe_(on_next, obv.on_error, obv.on_completed, scheduler)
return Observable(subscribe)
def test_skip_until_has_completed_causes_disposal(self):
scheduler = TestScheduler()
l_msgs = [
on_next(150, 1),
on_next(210, 2),
on_next(220, 3),
on_next(230, 4),
on_next(240, 5),
on_completed(250)
]
disposed = [False]
l = scheduler.create_hot_observable(l_msgs)
def subscribe(observer):
disposed[0] = True
r = Observable(subscribe)
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal()
assert (disposed[0])
def hot(string: str,
timespan: RelativeTime = 0.1,
duetime: AbsoluteOrRelativeTime = 0.0,
lookup: Dict = None,
error: Optional[Exception] = None,
scheduler: Optional[Scheduler] = None) -> Observable:
_scheduler = scheduler or new_thread_scheduler
if isinstance(duetime, datetime):
duetime = duetime - _scheduler.now
messages = parse(
string,
timespan=timespan,
time_shift=duetime,
lookup=lookup,
error=error,
raise_stopped=True,
)
lock = threading.RLock()
is_stopped = False
observers = []
def subscribe(observer, scheduler=None):
# should a hot observable already completed or on error
# re-push on_completed/on_error at subscription time?
if not is_stopped:
with lock:
observers.append(observer)
def dispose():
with lock:
try:
observers.remove(observer)
except ValueError:
pass
return Disposable(dispose)
def create_action(notification):
def action(scheduler, state=None):
nonlocal is_stopped
with lock:
for observer in observers:
notification.accept(observer)
if notification.kind in ('C', 'E'):
is_stopped = True
return action
for message in messages:
timespan, notification = message
action = create_action(notification)
# Don't make closures within a loop
_scheduler.schedule_relative(timespan, action)
return Observable(subscribe)
def test_for_each_argument_checking(self):
some = Observable.just(42).to_blocking()
self.assertRaises(TypeError, lambda: Observable(None).to_blocking().for_each(lambda x: x))
self.assertRaises(TypeError, lambda: some.for_each(lambda: None))
