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