def test_let_calls_function_immediately(self): called = [False] def func(x): called[0] = True return x Observable.empty().let_bind(func) assert(called[0])
def test_let_calls_function_immediately(self): called = [False] def func(x): called[0] = True return x Observable.empty().let(func) assert (called[0])
def test_merge_empty2(self): scheduler = TestScheduler() e1 = Observable.empty() e2 = Observable.empty() def create(): return Observable.merge(scheduler, e1, e2) results = scheduler.start(create) results.messages.assert_equal(on_completed(203))
def test_merge_empty2(self): scheduler = TestScheduler() e1 = Observable.empty() e2 = Observable.empty() def create(): return Observable.merge(e1, e2) results = scheduler.start(create) assert results.messages == [on_completed(200)]
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.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 )
def default_resolver(root, info): # type: (Any, ResolveInfo) -> Union[Observable, Subject] func = getattr(root, "importantEmail", None) if func: func = get_unbound_function(func) return func() return Observable.empty()
def if_then(cls, condition, then_source, else_source=None, scheduler=None): """Determines whether an observable collection contains values. Example: 1 - res = rx.Observable.if(condition, obs1) 2 - res = rx.Observable.if(condition, obs1, obs2) 3 - res = rx.Observable.if(condition, obs1, scheduler=scheduler) Keyword parameters: condition -- {Function} The condition which determines if the then_source or else_source will be run. then_source -- {Observable} The observable sequence or Promise that will be run if the condition function returns true. else_source -- {Observable} [Optional] The observable sequence or Promise that will be run if the condition function returns False. If this is not provided, it defaults to Rx.Observabe.Empty scheduler -- [Optional] Scheduler to use. Returns an observable {Observable} sequence which is either the then_source or else_source.""" else_source = else_source or Observable.empty(scheduler=scheduler) then_source = Observable.from_future(then_source) else_source = Observable.from_future(else_source) def factory(): return then_source if condition() else else_source return Observable.defer(factory)
def __call__(self, e): self.buffer += e if self.delimiter not in self.buffer: return Observable.empty() packages = self.buffer.split(self.delimiter) self.buffer = packages[-1] return Observable.from_(packages[:-1])
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 case(cls, selector, sources, default_source=None, scheduler=None): """Uses selector to determine which source in sources to use. There is an alias 'switch_case'. Example: 1 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }) 2 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0) 3 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler=scheduler) Keyword arguments: :param types.FunctionType selector: The function which extracts the value for to test in a case statement. :param list sources: A object which has keys which correspond to the case statement labels. :param Observable default_source: The observable sequence or Promise that will be run if the sources are not matched. If this is not provided, it defaults to rx.Observabe.empty with the specified scheduler. :returns: An observable sequence which is determined by a case statement. :rtype: Observable """ default_source = default_source or Observable.empty(scheduler=scheduler) def factory(): try: result = sources[selector()] except KeyError: result = default_source result = Observable.from_future(result) return result return Observable.defer(factory)
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 task_from_file(file_name): try: with open(file_name) as data_file: script = json.load(data_file) # parse, clean, and push words in text file return Observable.from_(script).distinct(lambda t: t['timestamp']) except Exception, Argument: print(Argument) return Observable.empty()
def test_empty_observer_throw_exception(): scheduler = TestScheduler() xs = Observable.empty(scheduler) xs.subscribe(lambda x: None, lambda ex: None, lambda: _raise('ex')) try: return scheduler.start() except RxException: pass
def __call__(self, command: Command, handler=lambda x: None) -> Observable: try: result = command.exec(self.shared_manager) if isinstance(result, Observable): return result return Observable.just(result) except Exception as ex: handler(ex) return Observable.empty()
def get_pipeline_run_observable(graphene_info, run_id, after=None): check.inst_param(graphene_info, 'graphene_info', ResolveInfo) check.str_param(run_id, 'run_id') check.opt_int_param(after, 'after') instance = graphene_info.context.instance run = instance.get_run(run_id) if not run: def _get_error_observable(observer): observer.on_next( graphene_info.schema. type_named('PipelineRunLogsSubscriptionFailure')( missingRunId=run_id, message='Could not load run with id {}'.format(run_id))) return Observable.create(_get_error_observable) # pylint: disable=E1101 if not instance.can_watch_events: def _get_error_observable(observer): observer.on_next( graphene_info.schema.type_named( 'PipelineRunLogsSubscriptionFailure') (message= 'Event log storage on current DagsterInstance is not watchable.' )) return Observable.create(_get_error_observable) # pylint: disable=E1101 pipeline = get_dauphin_pipeline_reference_from_selector( graphene_info, run.selector) from ..schema.pipelines import DauphinPipeline if not isinstance(pipeline, DauphinPipeline): return Observable.empty() # pylint: disable=no-member execution_plan = create_execution_plan(pipeline.get_dagster_pipeline(), run.environment_dict, RunConfig(mode=run.mode)) # pylint: disable=E1101 return Observable.create( PipelineRunObservableSubscribe( instance, run_id, after_cursor=after)).map( lambda events: graphene_info.schema. type_named('PipelineRunLogsSubscriptionSuccess')( runId=run_id, messages=[ from_event_record(graphene_info, event, pipeline, execution_plan) for event in events ], ))
def _logErrorAndResume(self, error, task): self.logger.error("Failed processing task {}. Reason: {}:{}".format( task, error.__class__.__name__, error)) try: if error.__class__.__name__ == QueryProcessingException.__name__: self._notify_task(task, "ERROR", error.get_status()) else: self._notify_task(task, "ERROR") except: traceback.print_exc() return Observable.empty()
def run(): raw_image = sys.stdin.read(360 * 640 * 3) image = np.fromstring(raw_image, dtype='uint8') image = image.reshape((360, 640, 3)) if check_startscreen(image): return Observable.just('startscreen') p1winner = check_winner(image, 207) p2winner = check_winner(image, 357) if p1winner or p2winner: return Observable.just('winner is ' + ('p1' if p1winner else 'p2')) return Observable.empty()
def take(self, count, scheduler=None): """Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of take(0). 1 - source.take(5) 2 - source.take(0, rx.Scheduler.timeout) Keyword arguments: count -- The number of elements to return. scheduler -- [Optional] Scheduler used to produce an OnCompleted message in case count is set to 0. Returns an observable sequence that contains the specified number of elements from the start of the input sequence. """ if count < 0: raise ArgumentOutOfRangeException() if not count: return Observable.empty(scheduler) observable = self def subscribe(observer): remaining = [count] def on_next(value): if remaining[0] > 0: remaining[0] -= 1 observer.on_next(value) if not remaining[0]: observer.on_completed() return observable.subscribe(on_next, observer.on_error, observer.on_completed) return AnonymousObservable(subscribe)
def case(cls, selector, sources, default_source=None, scheduler=None): """Uses selector to determine which source in sources to use. There is an alias 'switch_case'. Example: 1 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }) 2 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0) 3 - res = rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler=scheduler) Keyword arguments: selector -- {Function} The function which extracts the value for to test in a case statement. sources -- {Array} A object which has keys which correspond to the case statement labels. default_source-- {Observable} [Optional] The observable sequence or Promise that will be run if the sources are not matched. If this is not provided, it defaults to Rx.Observabe.empty with the specified scheduler. Returns an observable {Observable} sequence which is determined by a case statement.""" default_source = default_source or Observable.empty( scheduler=scheduler) def factory(): try: result = sources[selector()] except KeyError: result = default_source result = Observable.from_future(result) return result return Observable.defer(factory)
def on_error(e): logger.error("fail to fetch nodes by url: %s, %s", hub_url, str(e)) return Observable.empty()
def create(): return Observable.empty(scheduler).throttle(10, scheduler)
def create(): return Observable.empty(scheduler).time_interval( scheduler=scheduler)
def wrapper(*args, **kwargs): try: return Observable.just(map_function(*args, **kwargs)) except Exception as ex: handler(ex) return Observable.empty()
def right_duration_selector(y): if len(y.value) >= 0: raise Exception(ex) else: return Observable.empty()
from rx import Observable Observable.empty() \ .subscribe(on_next=lambda s: print(s), on_completed=lambda: print("Done!") )
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"
def test_for_each_empty(self): lst = [] Observable.empty().to_blocking().for_each(lambda x: lst.append(x)) assert(lst == [])
def create(): return Observable.empty(scheduler=scheduler).sample(0, scheduler=scheduler)
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 factory(): return Observable.empty(scheduler)
def create(): return Observable.empty(scheduler).debounce(10, scheduler)
def on_error(e): logger.error("fail to fetch appium sessions by url: %s, %s", appium_url, str(e)) return Observable.empty()
def test_For_each_index_empty(self): lstX = [] Observable.empty().to_blocking().for_each(lambda x, i: lstX.append(x)) assert(lstX == [])
def create2(): Observable.empty().transduce( compose( filtering(even), mapping(mul10)) ).subscribe(noop, noop, throw_error)
def left_duration_selector(x): if x.value >= 0: raise Exception(ex) else: return Observable.empty()
def create2(): Observable.empty().transduce( compose(filtering(even), mapping(mul10))).subscribe_(noop, noop, throw_error)
def create(): return Observable.empty(scheduler).time_interval(scheduler)
def observable_window_with_openings(window_openings, window_closing_selector): return self.window_openings.group_join(window_closing_selector, lambda: Observable.empty(), lambda _, window: window)
def default_resolver(root, info): func = getattr(root, 'importantEmail', None) if func: func = get_unbound_function(func) return func() return Observable.empty()
def catch_item(i): sink_observer.on_next(convert(i)) return Observable.empty()
def on_error(exception=None): if isinstance(exception, HttpResponse): return Observable.just(exception) if exception is not None: logger.debug('unexpected error %r', exception) return Observable.empty()
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()