def __init__( self, transport: Transport, handshake: ServerHandshake, organization_id: OrganizationID, device_id: DeviceID, human_handle: Optional[HumanHandle], profile: UserProfile, public_key: PublicKey, verify_key: VerifyKey, ): super().__init__(transport, handshake) self.organization_id = organization_id self.profile = profile self.device_id = device_id self.human_handle = human_handle self.public_key = public_key self.verify_key = verify_key self.event_bus_ctx = None # Overwritten in BackendApp.handle_client self.channels = trio.open_memory_channel(100) self.realms = set() self.events_subscribed = False self.conn_id = self.transport.conn_id self.logger = self.transport.logger = self.transport.logger.bind( conn_id=self.conn_id, handshake_type=self.handshake_type.value, organization_id=self.organization_id, device_id=self.device_id, )
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.controller = Controller() self.reader = None # type: asyncio.StreamReader self.writer = None # type: asyncio.StreamWriter self._replies_in, self._replies_out = trio.open_memory_channel(10) self.controller.reset(True)
async def main(): global attributes, password_options, spinner mainspinner = Halo(text='yamit Importing ', spinner='dots') mainspinner.start() with open(csv_file, 'r') as f: c = csv.reader(f, delimiter=',') mainspinner.succeed("Fetching attributes...") mainspinner.start() for row in c: attributes = row password_options = attributes if 'password' in attributes: pw_ind = attributes.index('password') attributes = attributes[:pw_ind] break f.seek(0) f.close() check_atr() mainspinner.succeed("Compared attributes to Okta user schema...") async with trio.open_nursery() as nursery: send_channel, receive_channel = trio.open_memory_channel(0) nursery.start_soon(csv_emitter, send_channel) spinner.start() for i in range(0, N): nursery.start_soon(worker, [ f'/api/v1/users?activate={activate}', receive_channel.clone() ])
def listen(self, *event_types, buffer_size=10): ''' Return an async iterator that iterates over events matching the indicated types. ''' sender, receiver = trio.open_memory_channel(buffer_size) for event_type in event_types: self.channels[event_type].add(sender) return receiver
async def _handle_lifespan(self, scope: Scope, receive: Callable, send: Callable) -> None: import trio self.app_queues = { path: trio.open_memory_channel(MAX_QUEUE_SIZE) for path in self.mounts } self.startup_complete = {path: False for path in self.mounts} self.shutdown_complete = {path: False for path in self.mounts} async with trio.open_nursery() as nursery: for path, app in self.mounts.items(): nursery.start_soon( invoke_asgi, app, scope, self.app_queues[path][1].receive, partial(self.send, path, send), ) while True: message = await receive() for channels in self.app_queues.values(): await channels[0].send(message) if message["type"] == "lifespan.shutdown": break
async def resolve(**dnsquery): global stats_requests, stats_names, stat_res nonlocal nursery stats_requests += 1 stat_res = dnsquery resolvers = [ rediscache, *sorted(nclients, key=lambda nc: stats_time[nc.name] or 1) ] stats_names = [r.name for r in resolvers] # RedisCache and Cloudflare cannot answer type ANY requests type_any = dnsquery['type'] == 255 if type_any: resolvers = [ r for r in resolvers if r.name not in ("RedisCache", "cloudflare") ] sender, receiver = trio.open_memory_channel(len(nclients)) async with sender, receiver: # Staggered startups of resolving tasks on each suitable provider nursery.start_soon(resolve_happy, resolvers, dnsquery, nursery, sender.clone()) fastest = None # Timeout for answering downstream requests with trio.move_on_after(5 if type_any else 0.95): fastest = await receiver.receive() sender.send_nowait(fastest) # Put the fastest back for cacher # Cache any received answers nursery.start_soon(cacher_task, receiver.clone()) if fastest: statkey = fastest["NameClient"] stat_res = fastest stats_fastest[statkey] += 1 return fastest raise trio.TooSlowError
async def spawn_child_nursery(spawn, shutdown_timeout=math.inf): send_channel, receive_channel = trio.open_memory_channel(0) async with receive_channel: shutdown_trigger = Event() spawn(_run_nursery_until_event, send_channel, shutdown_trigger, shutdown_timeout) return await receive_channel.receive(), shutdown_trigger
async def wrapper(*args, **kwargs): send_channel, receive_channel = trio.open_memory_channel(0) async with trio.open_nursery() as nursery: async def adapter(): async with send_channel, aclosing(wrapped(*args, **kwargs)) as agen: while True: try: # Advance underlying async generator to next yield value = await agen.__anext__() except StopAsyncIteration: break while True: try: # Forward the yielded value into the send channel try: await send_channel.send(value) except trio.BrokenResourceError: return break except BaseException: # pylint: disable=broad-except # If send_channel.send() raised (e.g. Cancelled), # throw the raised exception back into the generator, # and get the next yielded value to forward. try: value = await agen.athrow(*sys.exc_info()) except StopAsyncIteration: return nursery.start_soon(adapter, name=wrapped) async with receive_channel: yield receive_channel
async def request(self, receiver_node_id: NodeID, message: BaseMessage) -> IncomingMessage: response_channels: Tuple[ SendChannel[IncomingMessage], ReceiveChannel[IncomingMessage], ] = trio.open_memory_channel(0) response_send_channel, response_receive_channel = response_channels async with self.add_response_handler( receiver_node_id, message.request_id, ) as response_subscription: outgoing_message = await self.prepare_outgoing_message( receiver_node_id, message) self.logger.debug( "Sending %s to %s with request id %d", outgoing_message, encode_hex(receiver_node_id), message.request_id, ) await self.outgoing_message_send_channel.send(outgoing_message) response = await response_subscription.receive() self.logger.debug( "Received %s from %s with request id %d as response to %s", response, outgoing_message, encode_hex(receiver_node_id), message.request_id, ) return response
def open_memory_channel(max_items): '''Wrapper around trio.open_memory_channel, which patches the send channel for queue-like compatibility''' send, recv = trio.open_memory_channel(max_items) # monkey-patch here for compatibility with a regular queue: send.put = send.send return TrioMemoryChannelPair(send, recv)
async def request(self, name, arguments=None): sender, receiver = trio.open_memory_channel(0) await self.sender.send( dict(sender=sender, name=name, arguments=arguments)) async with receiver: async for response in receiver: return response
def add_request_handler( self, message_type: int, ) -> ChannelHandlerSubscription[IncomingMessage]: if message_type in self.request_handler_send_channels: raise ValueError( f"Request handler for type {message_type} is already added") request_channels: Tuple[ SendChannel[IncomingMessage], ReceiveChannel[IncomingMessage], ] = trio.open_memory_channel(0) self.request_handler_send_channels[message_type] = request_channels[0] self.logger.debug("Adding request handler for message type %d", message_type) def remove() -> None: try: self.request_handler_send_channels.pop(message_type) except KeyError: raise ValueError( f"Request handler for type {message_type} has already been removed" ) else: self.logger.debug( "Removing request handler for message type %d", message_type) return ChannelHandlerSubscription( send_channel=request_channels[0], receive_channel=request_channels[1], remove_fn=remove, )
def get_orders( emsd_uid: tuple[str, str] = None ) -> OrderBook: """" OrderBook singleton factory per actor. """ if emsd_uid is not None: # TODO: read in target emsd's active book on startup pass global _orders if _orders is None: size = 100 tx, rx = trio.open_memory_channel(size) brx = broadcast_receiver(rx, size) # setup local ui event streaming channels for request/resp # streamging with EMS daemon _orders = OrderBook( _to_ems=tx, _from_order_book=brx, ) return _orders
async def build_cm_and_channel(store_path, pebble): send, recv = trio.open_memory_channel(1) store = FilesystemStorageProvider(store_path) cm = await CertManager.build( store, send, pebble.dir_url, "*****@*****.**", verify_ssl=False ) return cm, recv
async def run(player_process): with trio.CancelScope() as cancel_scope: async with trio.open_nursery() as nursery: send_channel, receive_channel = trio.open_memory_channel(0) idle() nursery.start_soon(monitor_occupancy, send_channel) while True: transition = await receive_channel.receive() # print(f"received transition: {transition}") if transition == "start": print("starting ...") nursery.start_soon(start_session) elif transition == "stop": print("stopping ...") cancel_scope.cancel() terminate(player_process) break
def init(self, threads=1): '''Start worker threads''' self.trio_token = trio.hazmat.current_trio_token() self.to_upload = trio.open_memory_channel(0) for _ in range(threads): t = threading.Thread(target=self._upload_loop) t.start() self.upload_threads.append(t) self.to_remove = Queue(1000) with self.backend_pool() as backend: has_delete_multi = backend.has_delete_multi if has_delete_multi: t = threading.Thread(target=self._removal_loop_multi) t.daemon = True # interruption will do no permanent harm t.start() self.removal_threads.append(t) else: for _ in range(20): t = threading.Thread(target=self._removal_loop_simple) t.daemon = True # interruption will do no permanent harm t.start() self.removal_threads.append(t)
async def test_receive_channel_clone_and_close(): s, r = open_memory_channel(10) r2 = r.clone() r3 = r.clone() s.send_nowait(None) await r.aclose() with r2: pass with pytest.raises(trio.ClosedResourceError): r.clone() with pytest.raises(trio.ClosedResourceError): r2.clone() # Can still send, r3 is still open s.send_nowait(None) await r3.aclose() # But now the receiver is really closed with pytest.raises(trio.BrokenResourceError): s.send_nowait(None)
async def execf(self, tid, res, fn): with self.wg: self.resultq[tid], rq = trio.open_memory_channel(0) try: await self._c.send( dict(tid=tid, res=res, func=pickle_dumps(fn))) with optional_cm(trio.fail_after, getattr(res, 'T', -180) + 180): # 3min grace period ok, r = await rq.receive() except (trio.ClosedResourceError, trio.EndOfChannel): # TODO: dedicated error class? ok, r = False, ( "", RuntimeError( f"remote {self.name} closed connection unexpectedly")) except trio.TooSlowError: log_event("lost_or_late_response") ok, r = False, ( "", trio.TooSlowError( f"remote {self.name} lost track of job {tid}")) if ok: self.health = FULL_HEALTH del self.resultq[tid] return ok, r
async def to_process_map_as_completed( sync_fn, job_aiter, cancellable=False, limiter=None, *, task_status, ): if limiter is None: limiter = trio_parallel.current_default_worker_limiter() send_chan, recv_chan = trio.open_memory_channel(0) task_status.started(recv_chan) async def worker(job_item, task_status): # Backpressure: hold limiter for entire task to avoid # spawning too many workers async with limiter: task_status.started() result = await trio_parallel.run_sync( sync_fn, *job_item, cancellable=cancellable, limiter=trio.CapacityLimiter(1), ) await send_chan.send(result) async with send_chan, trio.open_nursery() as nursery: async for job_item in job_aiter: await nursery.start(worker, job_item)
async def refine(self, input, output): async with trio.open_nursery() as nursery: if input: source = input elif self.source: source = self.source else: raise RuntimeError('No input provided.') send_channel, receive_channel = trio.open_memory_channel(0) async def pull_task(): async with send_channel, aclosing(source) as aiter: async for item in aiter: await send_channel.send(item) nursery.start_soon(pull_task) while True: buffer = [] try: self._add_item(await receive_channel.receive(), buffer) with trio.move_on_after(self.interval): while True: if len(buffer) == self.max_size: break self._add_item(await receive_channel.receive(), buffer) except trio.EndOfChannel: if buffer: await output(self._process_result(buffer)) break await output(self._process_result(buffer))
async def main(): async with trio.open_nursery() as nursery: # Get our CTRL-C handler, tunnel, and trio channels running nursery.start_soon(control_c_handler, nursery) send_channel, receive_channel = trio.open_memory_channel(0) async with send_channel, receive_channel: # Start the configtunnel listener # nursery.start_soon(tunnel.listen, send_channel.clone()) # Start the database listener nursery.start_soon(manager.db.watchConfig, send_channel.clone()) everything_else = await nursery.start( partial(manager.activate, user="******") ) # Respond to incoming updates async for command in receive_channel: print("config command '{!r}' received".format(command)) everything_else.cancel() # clean tasks manager.processList = dict() # clean listener objects print("Reconfiguring Replay Manager: ", command) everything_else = await nursery.start( partial( manager.activate, updateSniffer="sniff" in command, updateOpenPorts="ports" in command, user=command[-1] if "user" in command else "system", ) )
async def request_response_subscription( self, receiver_node_id: NodeID, message: BaseMessage, endpoint: Optional[Endpoint] = None, ) -> AsyncGenerator[IncomingMessageSubscription, None]: if endpoint is None: endpoint = await self.get_endpoint_from_node_db(receiver_node_id) response_channels: Tuple[ SendChannel[IncomingMessage], ReceiveChannel[IncomingMessage], ] = trio.open_memory_channel(0) response_send_channel, response_receive_channel = response_channels async with self.add_response_handler( receiver_node_id, message.request_id, ) as response_subscription: outgoing_message = OutgoingMessage( message=message, receiver_node_id=receiver_node_id, receiver_endpoint=endpoint, ) self.logger.debug( "Sending %s to %s with request id %d", outgoing_message, encode_hex(receiver_node_id), message.request_id, ) await self.outgoing_message_send_channel.send(outgoing_message) yield response_subscription
def __init__(self): self._motor_left = 0 self._motor_right = 0 self._motor_flipper = 0 self._rover_data_to_memory_channel = { i: trio.open_memory_channel(0) for i in ROVER_DATA_ELEMENTS.keys() }
async def open(self): self.send, self.recv = trio.open_memory_channel( max_buffer_size=self.max_nums) # Init available numbers for i in range(self.max_nums): await self.release(i)
def filter(self, rule, *, channel: Optional[trio.MemorySendChannel] = None, bufsize=1): """Create a filter for incoming messages Usage:: async with router.filter(rule) as receive_channel: matching_msg = await receive_channel.receive() # OR: send_chan, recv_chan = trio.open_memory_channel(1) async with router.filter(rule, channel=send_chan): matching_msg = await recv_chan.receive() If the channel fills up, The sending end of the channel is closed when leaving the ``async with`` block, whether or not it was passed in. :param jeepney.MatchRule rule: Catch messages matching this rule :param trio.MemorySendChannel channel: Send matching messages here :param int bufsize: If no channel is passed in, create one with this size """ if channel is None: channel, recv_channel = trio.open_memory_channel(bufsize) else: recv_channel = None return TrioFilterHandle(self._filters, rule, channel, recv_channel)
async def main(): # make sure it all works within the runtime async with tractor.open_root_actor(): tx, rx = trio.open_memory_channel(1) brx = broadcast_receiver(rx, 1) cs = trio.CancelScope() async def sub_and_recv(): with cs: async with brx.subscribe() as bc: async for value in bc: print(value) async def cancel_and_send(): await trio.sleep(0.2) cs.cancel() await tx.send(1) async with trio.open_nursery() as n: n.start_soon(sub_and_recv) await trio.sleep(0.1) assert brx._state.recv_ready n.start_soon(cancel_and_send) # ensure that we don't hang because no-task is now # waiting on the underlying receive.. with trio.fail_after(0.5): value = await brx.receive() print(f'parent: {value}') assert value == 1
async def amap(async_fn, iterable, *, max_at_once=None, max_per_second=None, max_burst=1, iterable_is_async="guess", capture_outcome=False, include_index=False, include_value=False, max_buffer_size=0): send_channel, receive_channel = trio.open_memory_channel(max_buffer_size) async with receive_channel: async with trio.open_nursery() as nursery: nursery.start_soon( partial( run_on_each, # Pass through: async_fn, iterable, max_at_once=max_at_once, max_per_second=max_per_second, max_burst=max_burst, iterable_is_async=iterable_is_async, capture_outcome=capture_outcome, include_index=include_index, include_value=include_value, # Not a simple pass-through: send_to=send_channel, )) await yield_(receive_channel)
async def test_wsgi_trio() -> None: middleware = TrioWSGIMiddleware(echo_body) scope = { "http_version": "1.1", "method": "GET", "path": "/", "query_string": b"a=b", "raw_path": b"/", "scheme": "http", "type": "http", } send_channel, receive_channel = trio.open_memory_channel(1) await send_channel.send({"type": "http.request"}) messages = [] async def _send(message: dict) -> None: nonlocal messages messages.append(message) await middleware(scope, receive_channel.receive, _send) assert messages == [ { "headers": [(b"content-type", b"text/plain; charset=utf-8"), (b"content-length", b"0")], "status": 200, "type": "http.response.start", }, {"body": bytearray(b""), "type": "http.response.body"}, ]
def __init__(self, queue_len=None): if queue_len is None: queue_len = 10000 # Processing queue self._q_send, self._q_recv = trio.open_memory_channel(queue_len) # which files to close? self._close_files = set() # set up super().__init__(_TrioSelector()) # replaced internal data self._ready = _Clear() self._scheduled = _Clear() self._default_executor = TrioExecutor() self._orig_signals = {} # we do our own timeout handling self._timers = [] # Marker whether the loop is actually running self._stopped = trio.Event() self._stopped.set()
async def api_public_payment_longpolling(payment_hash): payment = await get_standalone_payment(payment_hash) if not payment: return jsonify({"message": "Payment does not exist."}), HTTPStatus.NOT_FOUND elif not payment.pending: return jsonify({"status": "paid"}), HTTPStatus.OK try: invoice = bolt11.decode(payment.bolt11) expiration = datetime.datetime.fromtimestamp(invoice.date + invoice.expiry) if expiration < datetime.datetime.now(): return jsonify({"status": "expired"}), HTTPStatus.OK except: return jsonify({"message": "Invalid bolt11 invoice."}), HTTPStatus.BAD_REQUEST send_payment, receive_payment = trio.open_memory_channel(0) print("adding standalone invoice listener", payment_hash, send_payment) api_invoice_listeners.append(send_payment) async for payment in receive_payment: if payment.payment_hash == payment_hash: return jsonify({"status": "paid"}), HTTPStatus.OK
def init_endpoints(self) -> TrioChannelPair: """Initialize the pusher.""" if self.maxlen is None: maxlen = math.inf else: maxlen = self.maxlen return trio.open_memory_channel(max_buffer_size=maxlen)
def __init__(self, app, vault, update_on_idle=False): self.app = app self.vault = vault self.nursery = None # type: Nursery self.update_on_idle = update_on_idle self.logger = VaultLoggerAdapter(self.vault, logging.getLogger(__name__)) send_channel, receive_channel = trio.open_memory_channel(128) # type: Tuple[trio.abc.SendChannel, trio.abc.ReceiveChannel] self.file_changes_send_channel = send_channel # type: trio.abc.SendChannel self.file_changes_receive_channel = receive_channel # type: trio.abc.ReceiveChannel
def add_receiver(self, max_buffer_size) -> trio.abc.ReceiveChannel: """\ Adds a receiver to this broadcast channel with the given buffer capacity. The send end of the receiver is closed when the broadcast channel is closed, and if the receive end is closed, it is discarded from the broadcast channel. """ send, receive = trio.open_memory_channel(max_buffer_size) self._stack.push_async_exit(send) self._send_channels.add(send) return receive
async def _poll_task(self, *, task_status=trio.TASK_STATUS_IGNORED): self.intervals, intervals = trio.open_memory_channel(0) task_status.started() async with trio.open_nursery() as nursery: async def poller(interval, *, task_status=trio.TASK_STATUS_IGNORED): with trio.CancelScope() as scope: task_status.started(scope) while True: await self.streamer.send(await self.poll()) await trio.sleep(interval) @nursery.start_soon async def read_interval(): scope = None async for interval in intervals: # cancel the old polling task if scope is not None: scope.cancel() scope = None # start new polling task if interval >= 0: scope = await nursery.start(poller, interval)
def __init__(self, *, update_buffer_size=10) -> None: self._updates_in, self._updates_out = trio.open_memory_channel(update_buffer_size) self._stack: AsyncExitStack = None
def __init__(self, pool_size): self._size = pool_size self.send_channel, self.receive_channel = trio.open_memory_channel(pool_size)