def test_with_observe_on(self): self.source.pipe( operators.do_action(lambda x: print(f"Producing {x}")), operators.observe_on(NewThreadScheduler()), operators.map(self.slow_op), operators.do_action(self.stop), operators.take_until(self._stop), ).run()
def dispose(): def _async_dispose(*args): # prevent join in the same thread. self.logger.info("Stopping image acquisition") self.acquirer.stop_image_acquisition() self.acquirer.destroy() self.logger.info("Stopped image acquisition") (scheduler or NewThreadScheduler()).schedule(_async_dispose)
def step(self): last_result = (rx.from_iterable(self.islands).pipe( ops.subscribe_on(NewThreadScheduler()), ops.flat_map(lambda island: island.epoch(self.epoch_length).pipe( ops.last())), ops.buffer_with_count(len(self.islands)), ).run()) self.migration() self.update_cost(last_result)
def from_process(worker: Callable, *args, executor: ProcessPoolExecutor = None, **kwargs): executor = executor if executor else default_process_executor def run_as_process(): future = executor.submit(worker, *args, **kwargs) return future.result() return rx.from_callable(run_as_process, NewThreadScheduler())
def test_new_thread_schedule_action(self): scheduler = NewThreadScheduler() ran = False def action(scheduler, state): nonlocal ran ran = True scheduler.schedule(action) sleep(0.1) assert ran is True
def test_new_thread_schedule_action_cancel(self): ran = False scheduler = NewThreadScheduler() def action(scheduler, state): nonlocal ran ran = True d = scheduler.schedule_relative(timedelta(milliseconds=1), action) d.dispose() sleep(0.1) assert ran is False
def execute_this_method(self): self.stream = Subject() url = URL websocket.enableTrace(True) ws = websocket.WebSocketApp( url, on_message=self.on_message, on_error=self.on_error, ) ws.run_forever() react = self.stream.pipe(NewThreadScheduler()) return react.subscribe()
def configure_timed_read(self): interval = self.config.getfloat("fp50", "interval") if interval > 0: logger.info("Configuring timed read") # enabled rx.interval(interval, scheduler=NewThreadScheduler()).pipe( operators.flat_map(lambda x: self.control.get_power()), operators.map(lambda x: self.upload_power(x)), operators.delay(self.config.getfloat("fp50", "query_delay")), operators.flat_map( lambda x: self.control.get_internal_temperature()), operators.map(lambda x: self.upload_internal_temperature(x)), operators.catch(error_handler)).subscribe()
def subscribe( self, observer: Optional[Union[typing.Observer, typing.OnNext]] = None, on_error: Optional[typing.OnError] = None, on_completed: Optional[typing.OnCompleted] = None, on_next: Optional[typing.OnNext] = None, *, scheduler: Optional[typing.Scheduler] = None) -> typing.Disposable: scheduler = scheduler or NewThreadScheduler() return super().subscribe(observer, on_error, on_completed, on_next, scheduler=scheduler)
def test_new_thread_schedule_action_due(self): scheduler = NewThreadScheduler() starttime = default_now() endtime = None def action(scheduler, state): nonlocal endtime endtime = default_now() scheduler.schedule_relative(timedelta(milliseconds=200), action) sleep(0.4) assert endtime is not None diff = endtime - starttime assert diff > timedelta(milliseconds=180)
def test_new_thread_schedule_periodic_cancel(self): scheduler = NewThreadScheduler() period = 0.1 counter = 4 def action(state): nonlocal counter if state: counter -= 1 return state - 1 disp = scheduler.schedule_periodic(period, action, counter) sleep(0.4) disp.dispose() assert 0 <= counter < 4
def test_create_and_run_all_supported_algorithms(self): sys = ActorSystem("multiprocTCPBase", logDefs=log_helper.EVOGIL_LOG_CONFIG) test_cases = run_config.algorithms for test_case in test_cases: with self.subTest(algorithm=test_case): algo_factory, _ = prepare(test_case, "ZDT1") algorithm = algo_factory() simple_simulation = StepsRun(1) result = list( simple_simulation.create_job(algorithm) .pipe(ops.subscribe_on(NewThreadScheduler()), ops.to_iterable()) .run() ) self.assertEqual(1, len(result)) self.assertIsInstance(result[0], ProgressMessage) sys.shutdown()
def test_new_thread_schedule_periodic(self): scheduler = NewThreadScheduler() gate = threading.Semaphore(0) period = 0.05 counter = 3 def action(state): nonlocal counter if state: counter -= 1 return state - 1 if counter == 0: gate.release() scheduler.schedule_periodic(period, action, counter) gate.acquire() assert counter == 0
def run(self): print('Starting server {}'.format(self._server)) self._subscription = rx.create(self._receive).pipe( ops.subscribe_on(NewThreadScheduler()), ops.map(lambda msg: self._mapper(msg)), ops.filter(lambda gfx: gfx is not None), ).subscribe(lambda gfx: self._entities.append(gfx)) print('Start') while True: with canvas(self._virtual) as draw: for entity in self._entities: entity.render(draw) entity.update() self._entities[:] = [ent for ent in self._entities if not ent.can_destroy()] time.sleep(0.010)
def __init__(self, name="pump_control"): super().__init__(name) self.pump_control_config = self.config["pumpControl"] self.control_delay = self.pump_control_config["controlDelay"] self.tq = Subject() self.scheduler = NewThreadScheduler() self.update_subject = Subject() def on_next(job): try: job() except Exception as ex: self.logger.error(ex) self.tq.pipe(operators.observe_on(self.scheduler)).subscribe( on_next, lambda ex: self.logger.error(ex), lambda: self.serial.close()) self.state = [0.0, 0.0] self.enable_remote_control(True)
def run_metaepoch(self): node_jobs = [] for node in self.level_nodes[2]: node_jobs.append(node.run_metaepoch()) for node in self.level_nodes[1]: node_jobs.append(node.run_metaepoch()) for node in self.level_nodes[0]: node_jobs.append(node.run_metaepoch()) # _plot_node(node, 'r', [[0, 1], [0, 3]]) node_costs = [] for node_job in node_jobs: node_job.pipe( ops.subscribe_on(NewThreadScheduler()), ops.map(lambda message: self._update_cost(message)), ops.sum(), ops.do_action( on_next=lambda cost: node_costs.append(cost))).run() # self.cost += max(node_costs) self.cost += sum(node_costs)
def __init__(self, client: MQTTClientWrapper, name="fp50", config=None): super().__init__(name, config=config) self.client = client self.topic_base = self.config["waterBath"][name]["topicBase"] self.topic = self.topic_base + "/setpoint" self.message_subject = Subject() self.client.subscribe(self.topic_base + "/crystallizer_temperature") self.client.subscribe(self.topic_base + "/setpoint") self.interval_scheduler = NewThreadScheduler() def update(x, scheduler=None): self.client.publish(self.topic_base + "/crystallizer_temperature", None) rx.interval(self.config["waterBath"][name]["interval"], self.interval_scheduler).subscribe(update) def convert(x): payloads = [xx[2].payload for xx in x] for p in payloads: if not p: # skipping conversion request return None return { # "power": float(payloads[0]), # "internal_temperature": float(payloads[1]), "crystallizer_temperature": float(payloads[0]), "setpoint": float(payloads[1]), } rx.combine_latest( from_callback( self.client.message_callback_add)(self.topic_base + "/crystallizer_temperature"), from_callback(self.client.message_callback_add)(self.topic_base + "/setpoint"), ).pipe(operators.map(convert), operators.filter(lambda x: x is not None), operators.debounce(0.6)).subscribe(self.message_subject)
def main(): def create_server_graph(): inputs = [Input(shape=(None,), dtype="bytes")] x = inputs[0] outputs = [x] return Model(inputs=inputs, outputs=outputs) def create_client_graph(): inputs = [Input(shape=(None,), dtype="bytes")] x = inputs[0] x = ServerSubgraph( addr=("localhost", 5678), graph=create_server_graph(), )(x) outputs = [x] return Model(inputs=inputs, outputs=outputs) client_model = create_client_graph() frames = rx.from_iterable(["abc", "def", "ghi"]) outputs = client_model.to_rx(frames) outputs[0].subscribe(print, subscribe_on=NewThreadScheduler())
def test_imga_cost_calculation(self): final_driver, problem_mod = prepare("IMGA+NSGAII", "ZDT1") imga = final_driver() steps_run = StepsRun(4) total_costs = [] islands_costs = [] def on_imga_result(result): total_costs.append(result.cost), islands_costs.append( sum([island.driver.cost for island in imga.islands])) steps_run.create_job(imga).pipe( ops.subscribe_on(NewThreadScheduler()), ops.do_action(on_next=on_imga_result), ).run() self.assertListEqual(total_costs, islands_costs)
def update_scheduler(self): self.clear_scheduler_if_running() self.schedule_obj = NewThreadScheduler().schedule_relative( self.absence_due_second, self.detect_absence)
import rx import rx.operators as ops from rx.scheduler import NewThreadScheduler import threading import time new_thread_scheduler = NewThreadScheduler() numbers = rx.from_([1, 2, 3, 4], scheduler=new_thread_scheduler) subscription = numbers.pipe( ops.map(lambda i: i * 2), ops.map(lambda i: "number is: {}".format(i)), ).subscribe( on_next=lambda i: print("on_next({}) {}".format(threading.get_ident(), i)), on_error=lambda e: print("on_error({}): {}".format(threading.get_ident(), e )), on_completed=lambda: print("on_completed({})".format(threading.get_ident()) )) print("main({})".format(threading.get_ident())) time.sleep(1.0)
def accept_conn_rx(item: Tuple[str, socket.socket]) -> Any: return rx.from_iterable([item]).pipe( ops.observe_on(NewThreadScheduler()), ops.map(lambda x: accept_conn(x)), )
ops.subscribe_on(pool_scheduler), ops.map(lambda r: generate_content(r)), ).subscribe( on_next=dataSubscriber.on_next, on_error=dataSubscriber.on_error, on_completed=dataSubscriber.on_completed, ) if __name__ == "__main__": requestA = Request("A", 10 * 1000) requestB = Request("B", 10 * 1000) requestC = Request("C", 10 * 1000) dataSubscriberC = DataSubscriber(requestC) scheduler = NewThreadScheduler() #optimal_thread_count = multiprocessing.cpu_count() pool_schedulerA = scheduler #NewThreadScheduler()#EventLoopScheduler() #ThreadPoolScheduler(optimal_thread_count) runProcess(requestA, pool_schedulerA) #pool_schedulerB = EventLoopScheduler() #runProcess(requestB, pool_schedulerB) pool_schedulerC = scheduler #EventLoopScheduler() runProcessSubscriber(requestC, pool_schedulerC, dataSubscriberC) print("running background") print("main thread sleep 5 seconds") time.sleep(5) print("force stop all") requestA.stop() requestB.stop() requestC.stop()
if args.enable_monitor_wakeup: try: enable_monitor_mode(args.interface) except: raise RuntimeError("Failed while enabling monitor mode") print(f"Listening on {args.interface}") queue = FileQueue(args.queue_path) connection_string = os.environ.get("IOTHUB_DEVICE_CONNECTION_STRING") assert len(connection_string) > 0, "IoTHub connection string should not be empty" upload_service = AttendanceUploadService.create(connection_string, queue, is_dry_run=False) user_querier = UserQuerier(args.configs) device_sniffer = DeviceSniffer(user_querier, args.interface) state_context_manager = AttendanceStateContextManager(args.configs, device_sniffer.get_observable(), upload_service) if args.enable_regular_queue_check: regular_check_task = NewThreadScheduler().schedule_periodic( args.regular_queue_check_interval, lambda x: send_queued_messages_if_connected_to_internet(upload_service, SimpleConnectionService()) ) try: device_sniffer.start() while True: time.sleep(1) except KeyboardInterrupt: device_sniffer.stop() regular_check_task.dispose() print("Exiting program...")
def test_new_thread_now(self): scheduler = NewThreadScheduler() diff = scheduler.now - default_now() assert abs(diff) < timedelta(milliseconds=5)
def test_new_thread_now_units(self): scheduler = NewThreadScheduler() diff = scheduler.now sleep(1.1) diff = scheduler.now - diff assert timedelta(milliseconds=1000) < diff < timedelta(milliseconds=1300)