def create():
return xs.group_join(
ys, lambda x: Observable.timer(x.interval).flat_map(
Observable.throw(ex)
if x.value == 6 else Observable.empty()),
lambda y: Observable.timer(y.interval), lambda x, yy: yy.map(
lambda y: str(x.value) + y.value)).merge_all()
def create():
return xs.group_join(
ys, lambda x: Observable.timer(x.interval, scheduler=scheduler)
.filter(lambda _: False), lambda y: Observable.timer(
y.interval, scheduler=scheduler).filter(lambda _: False),
lambda x, yy: yy.map(lambda y: str(x.value) + y.value
)).merge_observable()
def create():
return xs.join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler).select_many(
Observable.throw_exception(ex) if y.value == "tin" else Observable.empty()),
lambda x, y: str(x.value) + y.value
)
def create():
return xs.group_join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value
)).merge_observable()
def create():
return xs.join(ys,
lambda x: Observable.timer(x.interval),
lambda y: Observable.timer(y.interval).flat_map(
Observable.throw(ex) if y.value == "tin" else Observable.empty()),
lambda x, y: str(x.value) + y.value
)
async def run(loop):
Observable.timer(
0,
1000,
scheduler=AsyncIOScheduler()
).tap(
logging.info
)
def create():
return xs.group_join(
ys, lambda x: Observable.timer(
x.interval, scheduler=scheduler).select_many(
Observable.throw_exception(ex)
if x.value == 6 else Observable.empty()),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value
)).merge_observable()
def main():
# start bluetooth scanning in the background
new_bluetooth_thread = threading.Thread(target=scanner.watch)
new_bluetooth_thread.daemon = True # stop if the program exits
new_bluetooth_thread.start()
# start listening door tag
new_doortag_thread = threading.Thread(target=door_listener.listen)
new_doortag_thread.daemon = True # stop if the program exits
new_doortag_thread.start()
# light on if pir detection or door opened
door_listener.openDoorStream.merge(pirs.pirStream)\
.subscribe(LightOnObserver())
# light of after x second with no event
door_listener.openDoorStream.merge(pirs.pirStream).debounce(parameters.lightup_duration*1000)\
.subscribe(LightOffObserver())
# send sms when unknown presence is detected
pirs.pirStream.pausable(scanner.blueStream)\
.throttle_first(parameters.sms_min_interval_between_sms*1000).subscribe(SmsObserver('presence detected'))
# send sms on open door
door_listener.openDoorStream.pausable(scanner.blueStream)\
.throttle_first(parameters.sms_min_interval_between_sms*1000).subscribe(SmsObserver('door open'))
# send sms on door vibe
door_listener.vibeDoorStream.pausable(scanner.blueStream)\
.throttle_first(parameters.sms_min_interval_between_sms*1000).subscribe(SmsObserver('door vibe'))
# turn siren when unknown presence is detected with both open door and pir
# TODO: put timer duration in a variable
door_listener.openDoorStream\
.join(pirs.pirStream,
lambda x: Observable.timer(15*1000),
lambda x: Observable.timer(15*1000),
lambda x, y: True)\
.pausable(scanner.blueStream).subscribe(SirenClientObserver())
# take photo if pir detection or door opened or door vibe
# TODO: more test on this
# TODO: put camera interval in a variable
door_listener.openDoorStream.merge(door_listener.vibeDoorStream).merge(pirs.pirStream) \
.select_many(Observable.interval(1000).take(20)).throttle_first(1000) \
.pausable(scanner.blueStream) \
.subscribe(CameraObserver())
# if the subscriber doesn't get the first blueStream event they will be paused by default
# TODO: use a replay here instead of the following workaround
scanner.scan()
while True:
# TODO: use a infinit loop instead
# TODO: manage interruption
time.sleep(1)
def create():
def result_mapper(x, yy):
if x.value >= 0:
raise Exception(ex)
else:
return yy.map(lambda y: x.value + y.value)
return xs.group_join(ys, lambda x: Observable.timer(x.interval),
lambda y: Observable.timer(y.interval),
result_mapper).merge_all()
def test_oneshot_timer_timespan_observer_throws(self):
scheduler1 = TestScheduler()
xs = Observable.timer(1, scheduler=scheduler1)
xs.subscribe(lambda x: _raise("ex"))
self.assertRaises(RxException, scheduler1.start)
scheduler2 = TestScheduler()
ys = Observable.timer(1, period=None, scheduler=scheduler2)
ys.subscribe(on_completed=lambda: _raise("ex"))
self.assertRaises(RxException, scheduler2.start)
def create():
def result_selector(x, yy):
if x.value >= 0:
raise Exception(ex)
else:
return yy.select(lambda y: x.value + y.value)
return xs.group_join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
result_selector
).merge_observable()
def create():
def result_selector(x, yy):
if x.value >= 0:
raise Exception(ex)
else:
return yy.select(lambda y: x.value + y.value)
return xs.group_join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
result_selector).merge_observable()
def _start(self, app_context: Context) -> None:
if self.__input is None:
self.__input = app_context.inst_data_mgr.get_series(
self.__input_name)
self.__input.subject.subscribe(on_next=self.on_update)
if self.__output_bar_type == Bar.Time:
current_ts = self.__clock.now()
next_ts = get_next_bar_start_time(current_ts, self.__output_size)
diff = next_ts - current_ts
Observable.timer(
int(diff), self.__output_size * 1000,
self.__clock.scheduler).subscribe(on_next=self.publish)
def create():
def result_selector(x, y):
if x.value >= 0:
raise Exception(ex)
else:
return str(x.value) + y.value
return xs.join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
result_selector,
)
def create():
def result_mapper(x, y):
if x.value >= 0:
raise Exception(ex)
else:
return str(x.value) + y.value
return xs.join(ys,
lambda x: Observable.timer(x.interval),
lambda y: Observable.timer(y.interval),
result_mapper,
)
def test_oneshot_timer_timespan_observer_throws(self):
scheduler1 = TestScheduler()
xs = Observable.timer(1, scheduler=scheduler1)
xs.subscribe(lambda x: _raise("ex"))
self.assertRaises(RxException, scheduler1.start)
scheduler2 = TestScheduler()
ys = Observable.timer(1, period=None, scheduler=scheduler2)
ys.subscribe(on_completed=lambda: _raise("ex"))
self.assertRaises(RxException, scheduler2.start)
def test_timer(self):
timer = Observable.timer(0, 200)
subscr = timer.subscribe(
lambda t: print(t),
lambda e: print(e),
lambda: print("done")
)
def start_heartbeat(client, scheduler=None):
obs = Observable.timer(0, 20000, scheduler = scheduler)
return obs.subscribe(
on_next = lambda x: client.post_heartbeat(),
on_error = lambda e: log_error(e),
on_completed = lambda: log('completed heartbeat')
)
def run_timer(length):
# Start timer
timer = Observable.timer(datetime.now(), 1000).take(length.seconds + 1)
with cursor.HiddenCursor():
for x in timer.to_blocking():
now = seconds(x)
diff = length - now
print_progress(now, diff, length)
def request(self, http_request, respond_listener):
from rx import Observable
def on_next(i):
print(i)
if data:
respond_listener.on_success(
HttpResult(http_request, None, data))
else:
respond_listener.on_fail("mock data have no:{}".format(
http_request.url))
with open(self.mock_data_path, "r") as f:
import json
mock_data = json.load(f)
data = mock_data.get(http_request.url, None)
Observable.timer(1000).subscribe(on_next)
def join(self):
return Observable.timer(
datetime.now(),
self.task_poll_rate).filter(lambda _: not self._at_capacity()).map(
lambda _: self._take_task()).filter(
lambda task: task is not None).flat_map(
lambda task: self._do_work(task)).map(
lambda task: self._mark_done(task))
def test_oneshot_timer_timespan_observer_throws(self):
scheduler1 = TestScheduler()
xs = Observable.timer(1, scheduler=scheduler1)
xs.subscribe(lambda x: _raise("ex"))
try:
return scheduler1.start()
except RxException:
pass
scheduler2 = TestScheduler()
ys = Observable.timer(1, period=None, scheduler=scheduler2)
ys.subscribe(on_completed=lambda: _raise("ex"))
try:
return scheduler2.start()
except RxException:
pass
def create():
def right_duration_selector(y):
if len(y.value) >= 0:
raise Exception(ex)
else:
return Observable.empty()
return xs.join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
right_duration_selector, lambda x, y: str(x.value) + y.value)
def create():
def left_duration_mapper(x):
if x.value >= 0:
raise Exception(ex)
else:
return Observable.empty()
return xs.group_join(
ys, left_duration_mapper,
lambda y: Observable.timer(y.interval), lambda x, yy: yy.map(
lambda y: str(x.value) + y.value)).merge_all()
def create():
def left_duration_selector(x):
if x.value >= 0:
raise Exception(ex)
else:
return Observable.empty()
return xs.group_join(ys,
left_duration_selector,
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value)
).merge_observable()
def create():
def left_duration_selector(x):
if x.value >= 0:
raise Exception(ex)
else:
return Observable.empty()
return xs.group_join(
ys, left_duration_selector,
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value
)).merge_observable()
def create():
def right_duration_selector(y):
if len(y.value) >= 0:
raise Exception(ex)
else:
return Observable.empty()
return xs.join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
right_duration_selector,
lambda x, y: str(x.value) + y.value
)
def consume():
events = inject.instance(Stream)
events \
.map(inject.instance(key_builder)) \
.group_by_until(
lambda event: event[0],
None,
lambda x: Observable.timer(group_timeout()),
None
) \
.subscribe(GroupCounter())
def create():
def right_duration_mapper(y):
if len(y.value) >= 0:
raise Exception(ex)
else:
return Observable.empty()
def result_mapper(x, yy):
return yy.map(lambda y: x.value + y.value)
return xs.group_join(ys, lambda x: Observable.timer(x.interval),
right_duration_mapper,
result_mapper).merge_all()
def create():
def right_duration_selector(y):
if len(y.value) >= 0:
raise Exception(ex)
else:
return Observable.empty()
def result_selector(x, yy):
return yy.map(lambda y: x.value + y.value)
return xs.group_join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
right_duration_selector, result_selector).merge_observable()
def create():
def right_duration_selector(y):
if len(y.value) >= 0:
raise Exception(ex)
else:
return Observable.empty()
def result_selector(x, yy):
return yy.map(lambda y: x.value + y.value)
return xs.group_join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
right_duration_selector,
result_selector
).merge_observable()
def recargaTAE(id, usuario, password, sku_code, celular, monto):
#devuelve una trupla
#print ("Recarga 1", id, usuario, password, sku_code, celular, monto)
#srcCheckTransaction = Observable.of((14)).flat_map(lambda x : Observable.just( (x)))
# .on_error_resume_next(lambda x : {'error': x } )
srcCheckTransaction = Observable.timer(2500).flat_map(
lambda tiempo: verifyRecargaTAE(id, usuario, password, sku_code,
celular, monto)).retry(10).timeout(
62000)
source = Observable.combine_latest(
solicitaTAE(id, usuario, password, sku_code, celular, monto),
srcCheckTransaction, lambda o1, o2: o2)
return source
async def run(loop):
timer = Observable.timer(
0,
1000,
scheduler=AsyncIOScheduler()
).tap(
lambda t: logging.info('timer source ({})'.format(t))
)
timer.subscribe(
logging.info
)
timer.select(
lambda t: t * 2
).subscribe(
logging.info
)
def wait(self, timeout=-1):
"""
Wait until the result is available or until `timeout` miliseconds pass.
Возвращает 'beep beep', если сработал таймер (таймер истек раньше, чем закончились расчеты),
или 0, если расчеты закончились раньше
"""
if self.stream is None:
return 0
if timeout < 0:
lasty = self.stream.to_blocking().last_or_default(0)
return 0
timer_message = 'beep beep'
timer = Observable.timer(timeout).map(lambda x: timer_message)
lasty = self.stream.last_or_default(0) \
.amb(timer) \
.observe_on(CurrentThreadScheduler()) \
.to_blocking() \
.first()
return timer_message if lasty == timer_message else 0
from modules.light import LightOffObserver
from modules.siren_client import SirenClientObserver
from modules.sms import SmsObserver
from modules.pirs import Pirs
from modules.blue import Scanner
import parameters
door_listener = DoorListener()
pirs = Pirs()
scanner = Scanner()
# check that everything is ok
Observable.just(True).subscribe(SmsObserver('alarm started'))
Observable.just(True).subscribe(LightOnObserver())
Observable.timer(2000).subscribe(LightOffObserver())
# rise error: Camera component couldn't be enabled: Out of resources (other than memory)
# Observable.just(True).subscribe(CameraObserver()) # TODO take an initial photo on startup
scanner.scan()
def main():
# start bluetooth scanning in the background
new_bluetooth_thread = threading.Thread(target=scanner.watch)
new_bluetooth_thread.daemon = True # stop if the program exits
new_bluetooth_thread.start()
# start listening door tag
new_doortag_thread = threading.Thread(target=door_listener.listen)
new_doortag_thread.daemon = True # stop if the program exits
new_doortag_thread.start()
def create():
return xs.group_join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value)
).merge_observable()
# Import key libraries, classes and functions
from rx import Observable
from rx.testing import marbles, TestScheduler
# Create a test scheduler
test_scheduler = TestScheduler()
# Function - print the observed values | To be subscribed to
def print_value(value):
print('{} is the value'.format(value))
# Observable - interval
Observable.interval(10, test_scheduler).take_until(
Observable.timer(30)).subscribe(print_value)
# Start the test scheduler
test_scheduler.start()
read_lat_line_from_file('test.csv').flat_map(
lambda line: read_lat_line_from_file('test2.csv')).subscribe(print_value)
print('window') # window is like a buffer
print('window with count')
Observable.from_(
range(3)).window_with_count(2).flat_map(lambda x: x).subscribe(print_value)
print('window with time')
test_scheduler = TestScheduler()
Observable.interval(50, test_scheduler).take_until(
Observable.timer(100)).window_with_time(10).subscribe(
lambda observable: observable.count().subscribe(print_value))
test_scheduler.start()
print('combine latest')
test_scheduler = TestScheduler()
Observable.combine_latest(
Observable.interval(1, test_scheduler).map(lambda x: 'a {}'.format(x)),
Observable.interval(2, test_scheduler).map(lambda x: 'b {}'.format(x)),
lambda a, b, : '{} {}'.format(a, b)).take_until(
Observable.timer(5)).subscribe(print)
# test_scheduler.start()
print('-- zip')
# test_scheduler = TestScheduler()
def timed_tasks_ob(time_arr, task_arr):
return Observable.from_(time_arr).flat_map(lambda i: Observable.timer(i * 1000).switch_map(lambda i: Observable.just(i).subscribe_on(pool_scheduler))).zip(Observable.from_(task_arr), lambda x, y: y).publish().ref_count()
def closing(x):
return Observable.timer(x, scheduler=scheduler)
def create():
return Observable.timer(duetime=300, scheduler=scheduler)
def create():
return xs.join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, y: "%s%s" % (x.value, y.value)
)
import rx from rx import Observable, subjects from InfoReader import DummyInfoReader global mainTimer, nodeTimer, eventBus, infoReader mainTimer = Observable.timer(0, 200) nodeTimer = Observable.timer(0, 10000) eventBus = rx.subjects.Subject() infoReader = DummyInfoReader(eventBus)
from rx import Observable
from rx.testing import TestScheduler
if __name__ == '__main__':
test_scheduler = TestScheduler()
Observable.interval(10, test_scheduler).take_until(
Observable.timer(30)).subscribe(lambda s: print(s))
test_scheduler.start()
def create():
return xs.group_join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
result_selector).merge_observable()
gevent.sleep(self.seconds)
def __str__(self):
return 'MyNoopGreenlet(%s)' % self.seconds
current_ts = DateUtils.datetime_to_unixtimemillis(starttime)
next_ts = Bar.get_next_bar_start_time(current_ts, BarSize.S5)
diff = next_ts - current_ts
# Observable.timer(int(diff), BarSize.S5 * 1000, scheduler2).subscribe(action)
# scheduler1.advance_to(starttime)
# scheduler2.schedule_absolute(datetime.utcnow() + timedelta(seconds=3), action, scheduler2.now)
# print "1", scheduler1.now()
# scheduler1.advance_to(starttime + timedelta(seconds=1))
# print "2", scheduler1.now()
# scheduler1.advance_to(starttime + timedelta(seconds=2))
# print "3", scheduler1.now()
# scheduler1.advance_to(starttime + timedelta(seconds=3))
# print "4", scheduler1.now()
# scheduler1.advance_by(2000)
# print "5", scheduler1.now()
current_ts = DateUtils.datetime_to_unixtimemillis(starttime)
next_ts = Bar.get_next_bar_start_time(current_ts, BarSize.S5)
diff = next_ts - current_ts
Observable.timer(int(diff), 1000, realtime_clock.scheduler).subscribe(on_next=action)
time.sleep(10000)
def closings():
w = window[0]
window[0] += 1
return Observable.timer(w * 100, scheduler=scheduler)
three_emissions = Observable.range(1, 3)
three_random_ints = three_emissions.map(lambda i: randint(1, 100000))
three_random_ints = three_emissions.map(lambda i: randint(1, 100000)).publish().auto_connect(2)
res = Observable.timer(5000, scheduler=Scheduler.timeout)
letters = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
intervals = Observable.interval(1000)
Observable.zip(letters, intervals, lambda s, i: (s, i)) \
.subscribe(lambda t: print(t))
def create():
return xs.group_join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
result_selector
).merge_observable()
def create():
return xs.join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, y: "%s%s" % (x.value, y.value))
def create():
return xs.group_join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler).select_many(Observable.throw_exception(ex) if x.value==6 else Observable.empty()),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value)
).merge_observable()
def create():
return Observable.timer(1000, scheduler=scheduler)
def closing():
curr = window[0]
window[0] += 1
return Observable.timer(curr * 100, scheduler=scheduler)
def __init__(self, eventbus: Subject):
self.eventBus = eventbus
self.initialized = True
self.started = False
self._runTimer = Observable.timer(0, 10000)
self._runSubscription = None
def create():
return xs.group_join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler).filter(lambda _: False),
lambda y: Observable.timer(y.interval, scheduler=scheduler).filter(lambda _: False),
lambda x, yy: yy.map(lambda y: str(x.value) + y.value)
).merge_observable()
