def __init__(self, meta=None, events=None): self.event = curio.UniversalQueue() self.piglet_event = curio.UniversalQueue() self.piglets = curio.UniversalQueue() self.builds = curio.UniversalQueue() self.widgets = deque() self.current = None self.eric = None self.create_event_map() from karmapi import piglet # this probably needs to be a co-routine? self.eloop = piglet.EventLoop() self.eloop.set_event_queue(self.event) self.piglets.put(self.eloop.run()) self.micks = curio.UniversalQueue()
def __init__(self, pvdb, interfaces=None): super().__init__(pvdb, interfaces) self._task_group = None # _stop_queue is used like a threading.Event, allowing a thread to stop # the Context in :meth:`.stop`. self._stop_queue = curio.UniversalQueue() self.command_bundle_queue = curio.Queue() self.subscription_queue = curio.UniversalQueue()
def __init__(self, processor, sample_iter, echo=None, broadcast_socket=None): """Manages advancing through a concrete FileProcessor subblass asynchronously. The processor pushes Interval updates on to the `worker_q`, which are also forwarded to an `events_q`. Additional async tasks can subscribe to either queue; the `events_q` is considered the outward-facing point. `sample_iter` should be conform to that produced by `goetia.processing.iter_fastx_inputs`. Args: processor (libgoetia.InserterProcessor<T>): Processor to manage. sample_iter (iterator): Iterator over pairs of or single samples. echo (bool): Whether to echo `events_q` to the terminal. broadcast_socket (str, optional): AF_UNIX socket to broadcast the events queue on. """ self.worker_q = curio.UniversalQueue() self.worker_subs = QueueManager(self.worker_q, 'worker_q') self.events_q = curio.UniversalQueue() self.events_subs = QueueManager(self.events_q, 'events_q') self.channels = OrderedDict() self.channels[self.worker_subs.name] = self.worker_subs self.channels[self.events_subs.name] = self.events_subs # We want everything from the worker q to also end # up on the events q self.subscribe('worker_q', self.events_q, 'events_q') self.listener_tasks = [] self.processor = processor self.sample_iter = sample_iter self.run_echo = echo is not None self.echo_file = '/dev/stderr' if echo is True else echo self.state = RunState.READY self.processed = set() self.seconds_elapsed = 0
async def mainloop(): msg_queue = curio.UniversalQueue() quit_event = curio.UniversalEvent() parent = "NextTarget" uploader = FailSafeUploader(msg_queue, quit_event, get_firebase_default) uploader_thread = threading.Thread(target=uploader.upload, args=(parent, )) uploader_thread.start() zmqloop = await curio.spawn(loop_zmq(msg_queue)) goodbye = curio.SignalEvent(signal.SIGINT, signal.SIGTERM) await goodbye.wait() print("stopping fb uploader") await quit_event.set() await msg_queue.put(dict(_task="quit")) await curio.run_in_thread(uploader_thread.join) try: await zmqloop.cancel() except: import traceback traceback.print_exc()
def __init__(self, app=None): if app is None: self.app = Tk() self.events = curio.UniversalQueue() self.app.bind('<Key>', self.keypress)
def threaded_in_curio_wrapper(fcn): '''Run a threaded test with curio support Usage ----- Wrap the threaded function using this wrapper, call the wrapped function using `curio.run_in_thread` and then await wrapped_function.wait() inside the test kernel. ''' uqueue = curio.UniversalQueue() @functools.wraps(fcn) def wrapped(): try: fcn() except Exception as ex: uqueue.put(ex) else: uqueue.put(None) async def wait(): 'Wait for the test function completion' res = await uqueue.get() if res is not None: raise res wrapped.wait = wait return wrapped
def threaded_in_curio_wrapper(fcn): '''Run a threaded test with curio support Usage ----- Wrap the threaded function using this wrapper, call the wrapped function using `curio.run_in_thread` and then await wrapped_function.wait() inside the test kernel. ''' # Hide this import so that the other fixtures are usable by other # libraries (e.g. ophyd) without the experimental dependencies. import curio uqueue = curio.UniversalQueue() def wrapped_threaded_func(): try: fcn() except Exception as ex: uqueue.put(ex) else: uqueue.put(None) @functools.wraps(fcn) async def test_runner(): 'Wait for the test function completion' await curio.run_in_thread(wrapped_threaded_func) res = await uqueue.get() if res is not None: raise res return test_runner
async def main(): q = curio.UniversalQueue() prod_task = threading.Thread(target=producer, args=(q, )) prod_task.start() cons_task = await curio.spawn(consumer, q) await curio.run_in_thread(prod_task.join) await cons_task.cancel()
def __init__(self, game_state_store: GameStateStore): logger.debug("Creating GameStateMachine instance.") self.game_time: float = 0.0 self._event_queue = curio.UniversalQueue() self._universal_event_handler = UniversalEventHandler() self._game_state_store = game_state_store self._game_loop_is_running = False
def __init__(self, url: str) -> None: super().__init__(url) #: The gateway task running in an async thread. self._task = None # type: curio.Task self._queue = curio.UniversalQueue() self._cancelled = threading.Event() self._ws = None # type: WebSocket
def __init__(self, mick = None, *args, **kwargs): """ Fixme: configure stream according to **kwargs """ if mick is None: self.mick = get_stream() else: self.mick = mick self.queue = curio.UniversalQueue(maxsize=2)
def __init__(self, *args, **kwargs): self.keymap = self.keymap_karma.copy() print('core pig creating self.event_queue') self.event_queue = curio.UniversalQueue() print('Creating Pig with event queue', self.event_queue) self.event_map = {}
def __init__(self, devices: Sequence[gpiozero.AnalogInputDevice], device_names: Sequence[str], block_length: float = 0.1, tick: float = 0.01, max_qsize: int = 10000): self.devices = devices self.device_names = device_names self.block_length = block_length self.tick = tick self.output = curio.UniversalQueue(maxsize=max_qsize) self.running = False
def __init__(self, remote_address: tuple, event_handler, event_wire=None): logger.debug( f"Creating connection instance for remote address {remote_address}." ) self.remote_address = remote_address self.event_handler = event_handler self.event_wire = event_wire self.local_sequence = Sqn(0) self.remote_sequence = Sqn(0) self.ack_bitfield = "0" * 32 self.latency = 0.0 self.status = ConnectionStatus.get("Disconnected") self.quality = "good" # this is used for congestion avoidance self._package_interval = self._package_intervals["good"] self._outgoing_event_queue = curio.UniversalQueue() self._incoming_event_queue = curio.UniversalQueue() self._pending_acks: dict = {} self._event_callback_sequence = Sqn(0) self._events_with_callbacks: dict = {} self._event_callbacks: dict = {} self._last_recv = time.time()
def __init__(self): self.root = Tk() self.root.alt_shortcuts = set() self.model = Model() self.view = View(self.root, self.model) self.root.title("McRoss Browser") self.root.geometry("800x600") self.gui_ops = curio.UniversalQueue(withfd=True) self.coro_ops = curio.UniversalQueue() # When in the middle of an action, this flag is set to False to prevent user # from clicking other random stuff: self.allow_user_interaction = True def put_coro_op(func): def inner(*args): if self.allow_user_interaction: self.coro_ops.put(self.show_waiting_cursor_during_task(func, *args)) return inner # Make sure queued GUI operations are executed as soon as they become available if hasattr(self.root, "createfilehandler"): self.root.createfilehandler(self.gui_ops, READABLE, self.process_gui_ops) else: print("Running poll-based workaround for Windows.") # This is way more inefficient (5% CPU usage on a Surface Go at idle) but # hey it's better than not working at all! def after_cb(): self.process_gui_ops() self.root.after(10, after_cb) self.root.after(10, after_cb) self.view.go_callback = put_coro_op(self.go_callback) self.view.link_click_callback = put_coro_op(self.link_click_callback) self.view.back_callback = put_coro_op(self.back_callback) self.view.forward_callback = put_coro_op(self.forward_callback)
async def start(self) -> None: recv_task = await curio.spawn(self.recv_data) queue = curio.UniversalQueue() stdin_thread = Thread(target=read_peer_info, args=(queue,)) stdin_thread.start() peer_ip, peer_port = await queue.get() print(f'Connecting to: {peer_ip}:{peer_port}') await self._sock.sendto(b'hey there!', (peer_ip, peer_port)) stdin_thread.join() await recv_task.join()
def __init__(self, net, apply=None): # Some information about the network topology self.address = net.address self.net = net self.numservers = net.numservers self.quorum = (self.numservers // 2) + 1 self.machine = RaftMachine(self, apply) self.events = curio.UniversalQueue() self._alive = False # Persistent log self._restore_log() self._plog = open(f'{self.address}-plog.p', 'ab') self._plog.seek(0, os.SEEK_END) # Debugging/Testing. self.paused = False
def __init__(self, host, port, pvdb, *, log_level='ERROR'): self.host = host self.port = port self.pvdb = pvdb self.circuits = set() self.log_level = log_level self.broadcaster = ca.Broadcaster(our_role=ca.SERVER) self.broadcaster.log.setLevel(self.log_level) self.command_bundle_queue = curio.Queue() self.subscriptions = defaultdict(deque) self.subscription_queue = curio.UniversalQueue() self.beacon_count = 0 self.environ = get_environment_variables() ignore_addresses = self.environ['EPICS_CAS_IGNORE_ADDR_LIST'] self.ignore_addresses = ignore_addresses.split(' ')
async def start(self) -> None: queue = curio.UniversalQueue() stdin_thread = Thread(target=read_peer_info, args=(queue,)) stdin_thread.start() peer_ip, peer_port = await queue.get() print(f'Connecting to: {peer_ip}:{peer_port}') await self._sock.connect((peer_ip, peer_port)) # We must start reading only when connected, otherwise Linux returns # socket error #107 recv_task = await curio.spawn(self.recv_data) print('Connected') await self._sock.send(b'hey there!') print('Sent msg') stdin_thread.join() await recv_task.join()
def __init__(self, mode = None, scale=50, *args, **kwargs): """ Fixme: configure stream according to **kwargs """ self.queue = curio.UniversalQueue(maxsize=2) n = 2 * CHUNK if mode == 'square': frames = int(n / 32) plus = [3000] * 16 minus = [-3000] * 16 data = (plus + minus) * frames else: data = np.arange(n) data = np.sin(data * math.pi / 50.0) * (2**15 - 1) print('xxxxxxxxxxxxxxxxx', mode, len(data)) self.data = data
def __init__(self): # Need to start an event loop self.in_queue = curio.UniversalQueue() # Incoming message queue self.out_queue = curio.UniversalQueue() # Outgoing message queue self.devices = []
def __init__(self, pvdb, interfaces=None): super().__init__(pvdb, interfaces) self.command_bundle_queue = curio.Queue() self.subscription_queue = curio.UniversalQueue()
'%(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) return logger logger = get_logger() watchdir_queue = curio.Queue() # files_created_queue = curio.Queue() # to communicate with FB thread msg_queue = curio.UniversalQueue() quit_event = curio.UniversalEvent() async def watcher_spawner(): async with curio.TaskGroup() as tg: async for watchdir in watchdir_queue: await tg.spawn(watch_continously(watchdir)) # tasks.append(t) def create_msg(root, filename): _postfix = "_tan.nh.phot.cat" if not filename.endswith(_postfix): return None
def __init__(self, locals): super().__init__(locals) self.compile.compiler.flags |= ast.PyCF_ALLOW_TOP_LEVEL_AWAIT self.requests = curio.UniversalQueue() self.response = curio.UniversalQueue()
def __init__(self, pvdb, interfaces=None): super().__init__(pvdb, interfaces) self._task_group = None self._stop_event = threading.Event() self.command_bundle_queue = curio.Queue() self.subscription_queue = curio.UniversalQueue()
def __init__(self, remote_address: tuple, event_handler): super().__init__(remote_address, event_handler) self._command_queue = curio.UniversalQueue() self.game_state_context = LockedRessource(GameState())