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