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 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())