def variance(source: ObservableBase) -> ObservableBase:
"""
Returns the statistical variance of the numerical emissions.
The sequence must be finite.
"""
squared_values = source.to_list() \
.flat_map(lambda l: Observable.from_(l).average().flat_map(lambda avg: Observable.from_(l).map(lambda i: i - avg))) \
.map(lambda i: i * i) \
.publish() \
.auto_connect(2)
return Observable.zip(squared_values.sum(), squared_values.count(), lambda sum, ct: sum / (ct - 1))
def test_time_interval_default_scheduler(self):
import datetime
xs = Observable.from_((1,2)).time_interval().pluck_attr('interval')
l = []
d = xs.subscribe(lambda x: l.append(x))
self.assertEqual(len(l), 2)
[self.assertIsInstance(el, datetime.timedelta) for el in l]
def merge(cls, *args):
"""Merges all the observable sequences into a single observable
sequence. The scheduler is optional and if not specified, the
immediate scheduler is used.
1 - merged = rx.Observable.merge(xs, ys, zs)
2 - merged = rx.Observable.merge([xs, ys, zs])
3 - merged = rx.Observable.merge(scheduler, xs, ys, zs)
4 - merged = rx.Observable.merge(scheduler, [xs, ys, zs])
Returns the observable sequence that merges the elements of the
observable sequences.
"""
if not args[0]:
scheduler = immediate_scheduler
sources = args[1:]
elif isinstance(args[0], Scheduler):
scheduler = args[0]
sources = args[1:]
else:
scheduler = immediate_scheduler
sources = args[:]
if isinstance(sources[0], list):
sources = sources[0]
return Observable.from_(sources, scheduler).merge_all()
def test_time_interval_default_scheduler(self):
import datetime
xs = Observable.from_((1, 2)).time_interval().pluck_attr('interval')
l = []
d = xs.subscribe(lambda x: l.append(x))
self.assertEqual(len(l), 2)
[self.assertIsInstance(el, datetime.timedelta) for el in l]
def projection(x, i):
mapper_result = mapper(x) if mapper else mapper_indexed(x, i)
if isinstance(mapper_result, collections.Iterable):
result = Observable.from_(mapper_result)
else:
result = Observable.from_future(mapper_result) if is_future(mapper_result) else mapper_result
return result
def mode(source: ObservableBase) -> ObservableBase:
"""
Returns the most frequently emitted value (or "values" if they have the same number of occurrences).
The sequence must be finite.
"""
return source.group_by(lambda v: v) \
.flat_map(lambda grp: grp.count().map(lambda ct: (grp.key, ct))) \
.to_sorted_list(lambda t: t[1], reverse=True) \
.flat_map(lambda l: Observable.from_(l).take_while(lambda t: t[1] == l[0][1])) \
.map(lambda t: t[0])
def projection(x: Any, idx: int) -> Any:
mapper_result = mapper(x)
if isinstance(mapper_result, collections.abc.Iterable):
result = Observable.from_(mapper_result)
else:
result = Observable.from_future(
mapper_result) if is_future(
mapper_result) else mapper_result
return result.map(lambda y: result_mapper(x, y))
def projection(x: Any, idx: int) -> Any:
mapper_result = mapper(x) if mapper else mapper_indexed(x, idx)
if isinstance(mapper_result, collections.Iterable):
result = Observable.from_(mapper_result)
else:
result = Observable.from_future(mapper_result) if is_future(mapper_result) else mapper_result
if result_mapper:
return result.map(lambda y: result_mapper(x, y))
else:
return result.map(mapper_indexed=lambda y, i: result_mapper_indexed(x, y, i))
def go():
scheduler = AsyncIOScheduler()
xs = Observable.from_([x for x in range(10)], scheduler=scheduler)
gen = xs.to_async_generator()
# Wish we could write something like:
# ys = (x for x in yield from gen())
while True:
x = yield from gen()
if x is None:
break
print(x)
def go():
scheduler = AsyncIOScheduler()
xs = Observable.from_([x for x in range(10)], scheduler=scheduler)
gen = xs.to_async_generator()
# Wish we could write something like:
# ys = (x for x in yield from gen())
while True:
x = yield from gen()
if x is None:
break
print(x)
def start_with(self, *args, **kw):
"""Prepends a sequence of values to an observable sequence with an
optional scheduler and an argument list of values to prepend.
1 - source.start_with(1, 2, 3)
2 - source.start_with(Scheduler.timeout, 1, 2, 3)
Returns the source sequence prepended with the specified values.
"""
if isinstance(args[0], Scheduler):
scheduler = args[0]
args = args[1:]
else:
scheduler = kw.get("scheduler", immediate_scheduler)
sequence = [Observable.from_(args, scheduler), self]
return Observable.concat(sequence)
def action1(scheduler, state):
xs[0] = Observable.from_(["alpha", "apple", "beta", "bat", "gamma"]) \
.group_by(lambda s: s[0]) \
.map(lambda group: group.to_list()) \
.merge_all()
def get_observable(self) -> Observable:
return Observable.from_(self.poll())
def get_observable(self) -> Observable:
return Observable.from_(open(self.file).readlines())
