def test_get_new_orders(self, input_data, expected): trader = Trader(None, None, None) self._mox.StubOutWithMock(trader, '_get_type_and_amount_and_price_for_new_order') for amount in input_data: trader._get_type_and_amount_and_price_for_new_order(amount).AndReturn(('order_type', amount, 'price')) self._mox.ReplayAll() result = list(trader._get_new_orders(Observable.from_iterable(input_data), 2).to_blocking()) self.assertEqual(result[-1] if result else None, expected) self._mox.VerifyAll()
def main(): reads = Observable.from_iterable(fileinput.input()) \ .map(lambda line: io.StringIO(line)) \ .map(lambda line: json.load(line)) group_reads(reads) \ .map(to_print_format) \ .subscribe( lambda x: print(json.dumps(x)), lambda ex: print("Error ", ex.Message))
def canonic_to_anagrams(self, word_iterator): d = defaultdict(set) o = Observable.from_iterable(word_iterator, AsyncIOScheduler()).map(self.normalizer.normalize) def foo(s): d[self.canonicalizer.canonicalize(s)].add(s) o.subscribe(on_next=foo) return d
def of(cls, *args, **kwargs): """This method creates a new Observable instance with a variable number of arguments, regardless of number or type of the arguments. Example: res = rx.Observable.of(1,2,3) Returns the observable sequence whose elements are pulled from the given arguments """ return Observable.from_iterable(args, scheduler=kwargs.get("scheduler"))
def _create_stream_observable(self, iterable): """ Helper for creating a published stream observable """ tmp_observable = Observable.from_iterable(iterable) \ .subscribe_on(self._scheduler.new_thread) \ .publish() # Connect so that subscribers get only relevant/recent information! tmp_observable.connect() return tmp_observable
def finite_list(): SIZE = settings.PRODUCER.FINITE_LIST_LEN return Observable.from_iterable([item for item in range(SIZE)])
#http://reactivex.io from rx import Observable obs = Observable.from_iterable(range(4)) obs.subscribe(print)
def file_stream(): gdelt_file = settings.PRODUCER.GDELT_FILE return Observable.from_iterable(open(gdelt_file))
def finite_list(): return Observable.from_iterable([item for item in range(100)])
def test_get_completed_orders_singly(self, input_data, expected): trader = Trader(None, None, None) result = list(trader._get_completed_orders_singly(Observable.from_iterable(input_data), 'pair').to_blocking()) self.assertEqual(result[-1] if result else None, expected)
def create_app(): def setup_logging(): handler = StreamHandler(stream=sys.stdout) handler.setLevel(config.log_level) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) flask_app.logger.addHandler(handler) flask_app.logger.setLevel(config.log_level) flask_app.logger.name = "docker_enforcer" flask_app = Flask(__name__) if not flask_app.debug: setup_logging() flask_app.logger.info( "Starting docker-enforcer v{0} with docker socket {1}".format( config.version, config.docker_socket)) task_scheduler = NewThreadScheduler() # task_scheduler = ThreadPoolScheduler(multiprocessing.cpu_count()) if config.run_start_events: events = Observable.from_iterable(docker_helper.get_events_observable()) \ .observe_on(scheduler=task_scheduler) \ .where(lambda e: is_configured_event(e)) \ .map(lambda e: e['id']) \ .map(lambda cid: docker_helper.check_container(cid, CheckSource.Event, remove_from_cache=True)) if config.run_periodic: periodic = Observable.interval(config.interval_sec * 1000) if config.immediate_periodical_start: flask_app.logger.debug("Run periodic immediately") periodic = periodic.start_with(-1) periodic = periodic.observe_on(scheduler=task_scheduler) \ .map(lambda _: docker_helper.check_containers(CheckSource.Periodic)) \ .flat_map(lambda c: c) detections = Observable.empty() if config.run_start_events: detections = detections.merge(events) if config.run_periodic: detections = detections.merge(periodic) verdicts = detections \ .map(lambda container: judge.should_be_killed(container)) \ .where(lambda v: v.verdict) threaded_verdicts = verdicts \ .retry() \ .subscribe_on(task_scheduler) \ .publish() \ .auto_connect(2) if not config.run_start_events and not config.run_periodic: flask_app.logger.info( "Neither start events or periodic checks are enabled. Docker Enforcer will be working in " "authz plugin mode only.") else: killer_subs = threaded_verdicts.subscribe(jurek) trigger_subs = threaded_verdicts.subscribe(trigger_handler) def on_exit(sig, frame): flask_app.logger.info("Stopping docker monitoring") if config.run_start_events or config.run_periodic: killer_subs.dispose() trigger_subs.dispose() flask_app.logger.debug("Complete, ready to finish") quit() signal.signal(signal.SIGINT, on_exit) signal.signal(signal.SIGTERM, on_exit) return flask_app
def subscribe_current_time(root, info) -> str: # TODO: demonstrate authentication return Observable.from_iterable(poll_current_time())
def generate_observables(list_of_delays): def get_iterable(): for delay in list_of_delays: yield Observable.from_iterable(generate_events(delay)) return Observable.from_iterable(list(get_iterable()))
def get_iterable(): for delay in list_of_delays: yield Observable.from_iterable(generate_events(delay))
def test_subscribe(self): xs = Observable.from_iterable(range(10)) # d = xs.subscribe(MyObserver()) d = xs.subscribe(lambda t: print(t), lambda e: print(e), lambda: print("done"))
def get_observable(self): items = self.watch() return Observable.from_iterable(items)
from rx import Observable, Observer class PrintObserver(Observer): def on_next(self, value): print("Value :", value) def on_error(self, error): print("Error :", error) def on_completed(self): print("Completed") if __name__ == '__main__': source_1 = Observable.from_iterable(range(100)) source_2 = Observable.from_iterable("ABCDEFGHIJKLMNOPQRSTUVWXYZ") source_1.merge(source_2).subscribe(PrintObserver())
for k, v in zip(header, row): # print(k, ' == ', v) d[k] = v print(d) return d def ff(row): print('row', row) return row.to_list() # Observable.from_(row).merge().subscribe(lambda g: print('g', g)) Observable.merge(row[:]).subscribe(lambda g: print('g', g)) # return row.flat_map(lambda i: i.flat_map(lambda y:y.flat_map(lambda o:o))) return Observable.merge(row[:]) return row.merge_all() def subdictes_to_dict(row): d = {} for x in row: d.update(x) return d source = Observable.from_iterable(reader)\ .map(lambda row: Observable.zip(Observable.from_(header), row, lambda k,v: {k:v}))\ .map(lambda x: x.to_list().map(subdictes_to_dict))#.subscribe(lambda r: print(r, end="\n\n\n")) print(source.flat_map(lambda x: x).subscribe(lambda x: print(x))) # Observable.merge(source[:]).merge_all()
from rx import Observable from iterator import next_impl obs = Observable.from_iterable(next_impl()) obs2 = obs.take(2) obs2.subscribe(on_next=lambda x: print("Next item: {}".format(x)), on_completed=lambda: print("no more data"))
print("Generating a sequence") class ObserverClass(Observer): def on_next(self, value): print(value) def on_error(self): pass def on_completed(self): pass src = Observable.from_iterable(range(5)) src.subscribe(ObserverClass()) print("--------") src = Observable.from_iterable(range(5)) src.subscribe(print) print("--------") src = Observable.from_iterable(range(5)) src.subscribe(lambda x: print(x)) print("--------") # Filtering a sequence
def create_app(): def setup_logging(): handler = StreamHandler(stream=sys.stdout) handler.setLevel(config.log_level) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) flask_app.logger.addHandler(handler) flask_app.logger.setLevel(config.log_level) flask_app.logger.name = "docker_enforcer" flask_app = Flask(__name__) if not flask_app.debug: setup_logging() flask_app.logger.info( "Starting docker-enforcer v{0} with docker socket {1}".format( version, config.docker_socket)) if not (config.run_start_events or config.run_periodic): raise ValueError( "Either RUN_START_EVENTS or RUN_PERIODIC must be set to True") task_scheduler = NewThreadScheduler() # task_scheduler = ThreadPoolScheduler(multiprocessing.cpu_count()) if config.run_start_events: events = Observable.from_iterable(docker_helper.get_events_observable()) \ .observe_on(scheduler=task_scheduler) \ .where(lambda e: is_configured_event(e)) \ .map(lambda e: e['id']) \ .map(lambda cid: docker_helper.check_container(cid, remove_from_cache=True)) if config.run_periodic: periodic = Observable.interval(config.interval_sec * 1000) if config.immediate_periodical_start: flask_app.logger.debug("Run periodic immediately") periodic = periodic.start_with(-1) periodic = periodic.observe_on(scheduler=task_scheduler) \ .map(lambda _: docker_helper.check_containers()) \ .flat_map(lambda c: c) if not config.run_start_events and not config.run_periodic: flask_app.logger.fatal( "Either start events or periodic checks need to be enabled") raise Exception( "No run mode specified. Please set either RUN_START_EVENTS or RUN_PERIODIC" ) detections = Observable.empty() if config.run_start_events: detections = detections.merge(events) if config.run_periodic: detections = detections.merge(periodic) verdicts = detections \ .where(lambda c: not_on_white_list(c)) \ .map(lambda container: judge.should_be_killed(container)) \ .where(lambda v: v.verdict) threaded_verdicts = verdicts \ .retry() \ .subscribe_on(task_scheduler) \ .publish()\ .auto_connect(2) killer_subs = threaded_verdicts.subscribe(jurek) trigger_subs = threaded_verdicts.subscribe(trigger_handler) def on_exit(sig, frame): flask_app.logger.info("Stopping docker monitoring") killer_subs.dispose() trigger_subs.dispose() flask_app.logger.debug("Complete, ready to finish") quit() signal.signal(signal.SIGINT, on_exit) signal.signal(signal.SIGTERM, on_exit) return flask_app
def generate_sequence_example(): Observable.from_iterable( range( 10 ) ).subscribe( MyObserver() ) Observable.from_iterable( range( 10 ) ).subscribe( print )
# -*- coding: utf-8 -*- ''' Created on 2019年5月4日 下午7:02:01 Zhukun Luo Jiangxi University of Finance and Economics ''' #响应式编程实例,RxPY from rx import Observable from rx.testing.marbles import on_next, on_completed from rx.core.py2.observable import Observable obs=Observable.from_iterable(range(4))#基于迭代器创建数据流,为此可使用工厂方法Observable.from_iterable #要接受来自obs的数据,可使用方法Observable.subscrible,这样将对数据源发射的每个值执行传入的函数 # obs.subscribe(print) ''' 0 1 2 3 有序集合 ''' #Observable是由Observer和iterable组合而成的。观察者是一个对象,可迭代对象能够生成并跟踪迭代器。生成器是一种特殊的迭代器 #注册一个观察者,并使用参数on_next和on_completed注册了两个回调函数,这两个回调函数将分别在下一项数据可用及没有更多数据时被调用。 obs.subscribe(on_next=lambda x : print(on_text='Next item: {}'),on_completed=lambda:print('no more data')) ''' Next item: 1 Next item: 2 Next item: 3 Next item: 4 no more data ''' #我们可以使用处理迭代器的方法来处理事件流
def _print(*args): print('got: {}'.format(_fmt(*args))) def print_operator(x): print('[operator]: {}'.format(x)) def print_len3(x): print('`{}` is at least 3 characters long.'.format(x)) if DEBUG: with Section('Reactive (sort of functional) programming via RxPY'): print_h2('Basic Observable') xs = Observable.from_iterable(range(10) + [None]) d = xs.subscribe(MyObserver()) observable_iterable = Observable.from_iterable(xrange(100)) logwriter = observable_iterable.subscribe(LogWriterObserver()) print(logwriter) print_h2('Observable from_') xs = Observable.from_(range(10)) gobbledygook = Observable.from_(list(string.punctuation)) letters = Observable.from_(list(string.ascii_uppercase)) merged = xs.merge(letters, gobbledygook).subscribe(_print) print_h2('Subjects') stream = TestSubject() stream.on_next(1)
def stream(): return Observable.from_iterable([(0, 1), (0, 3), (1, 4)])
def infinite_stream(): return Observable.from_iterable(itertools.count())
def on_completed(self): print("completed") def pushButton(self): pass if __name__ == "__main__": coinEvents = Observable.from_list([5, 10, 5, 5, 10, 5]).publish() Observable.from_iterable(range(4)) \ .zip(Observable.interval(250)) \ .subscribe(WaterLevelController()) totalCoinEvent = Observable.from_iterable(range(6)) \ .flat_map(lambda r: coinEvents.take(r) \ .reduce(lambda a, b: a + b, 0) ) totalCoinEvent.subscribe(CoinLCDOutputObserver()) totalCoinEvent \ .filter(lambda x: x > 20) \ .map(lambda x: True) \ .subscribe(CoinDispenser()) totalCoinEvent \
def test_get_balance(self, input_data, expected): trader = Trader(None, None, None) result = list(trader._get_balance(Observable.from_iterable(input_data), 'currency').to_blocking()) self.assertEqual(result[-1] if result else None, expected)
def class_nineteen(): letters1 = Observable.from_(["alpha", "Beta", "Gamma", "Delta", "Epsilon"]) letters2 = Observable.from_iterable(["Zeta", "Exo", "Flota", "Delta"]) Observable.concat(letters1, letters2)\ .subscribe(print)
def stream(): return Observable.from_iterable([(0,1), (0,3), (1,4)])
def on_next(self, x): print("valor de x: %s" % x) def on_error(self, e): print("Error: %s" % e) def on_completed(self): print("Recorrido completado") def f(x): print("=>: %s" % x) def f2(x): print(x) #---------------hola mundo------------------------------------- h = Observable.from_iterable("hola mundo reactivo") p = h.reduce( lambda x, y: x + y ).subscribe(f2) #------------------------------------ xs = Observable.from_iterable(range(10)) d = xs.subscribe(observer()) #imprime todos los valores del 1..10 d = xs.map( lambda x: x * 2 ).subscribe(observer()) d = xs.filter( lambda x: x % 2 ).subscribe(observer()) #imprime solo los valores impares
from rx import Observable, Observer 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") xs = Observable.from_iterable(range(10)) d = xs.subscribe(MyObserver())
def sequence_equal(self, second, comparer=None): """Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. 1 - res = source.sequence_equal([1,2,3]) 2 - res = source.sequence_equal([{ "value": 42 }], lambda x, y: x.value == y.value) 3 - res = source.sequence_equal(Observable.return_value(42)) 4 - res = source.sequence_equal(Observable.return_value({ "value": 42 }), lambda x, y: x.value == y.value) second -- Second observable sequence or array to compare. comparer -- [Optional] Comparer used to compare elements of both sequences. Returns an observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. """ first = self comparer = comparer or default_comparer if isinstance(second, collections.Iterable): second = Observable.from_iterable(second) def subscribe(observer): donel = [False] doner = [False] ql = [] qr = [] def on_next1(x): if len(qr) > 0: v = qr.pop(0) try: equal = comparer(v, x) except Exception as e: observer.on_error(e) return if not equal: observer.on_next(False) observer.on_completed() elif doner[0]: observer.on_next(False) observer.on_completed() else: ql.append(x) def on_completed1(): donel[0] = True if not len(ql): if len(qr) > 0: observer.on_next(False) observer.on_completed() elif doner[0]: observer.on_next(True) observer.on_completed() def on_next2(x): if len(ql) > 0: v = ql.pop(0) try: equal = comparer(v, x) except Exception as exception: observer.on_error(exception) return if not equal: observer.on_next(False) observer.on_completed() elif donel[0]: observer.on_next(False) observer.on_completed() else: qr.append(x) def on_completed2(): doner[0] = True if not len(qr): if len(ql) > 0: observer.on_next(False) observer.on_completed() elif donel[0]: observer.on_next(True) observer.on_completed() subscription1 = first.subscribe(on_next1, observer.on_error, on_completed1) subscription2 = second.subscribe(on_next2, observer.on_error, on_completed2) return CompositeDisposable(subscription1, subscription2) return AnonymousObservable(subscribe)
def comment(text): if True: obs = commentObservable(Observable.from_iterable(text.splitlines())) if text else Observable.empty() return obs.reduce(lambda acc, line: acc + line + "\n", "") else: return "r"
svc = tmp_svcs[svc_idx] if cli == svc: raise Exception(cli + svc) print("client=%s service=%s time=%s" % (cli, svc, str(sleep))) class something(Observer): def on_next(self, x): time.sleep(.2) print("blah") def on_error(self, e): print("Got error: %s" % e) def on_completed(self): print("Sequence completed") def handleLine(it): print(it) if __name__=="__main__": xs = Observable.from_iterable(range(60)) xs.subscribe(random_logger_observable()) # xs2 = Observable.from_iterable(range(8)) # d2 = xs2.subscribe(something())
return csv_reader def row_to_dict(row): return { 'id': int(row[0]), 'filename': row[1], 'lines': int(row[2]), 'size': int(row[3]) } files = ['test.csv', 'test2.csv'] source = Observable.merge([ Observable.from_iterable(read_csv(filename)) for filename in files ]).map(row_to_dict) # We want to be able to connect multiple subscribers before we start emitting items published = source.publish() def print_row(row): print( 'File "{filename}" has {lines} lines and its size is {size} kb'.format( **row)) def print_group(group): return group.subscribe(print_row)