async def test_run_until_first_complete(): task1_finished = anyio.Event() task2_finished = anyio.Event() async def task1(): task1_finished.set() async def task2(): await task1_finished.wait() await anyio.sleep(0) # pragma: nocover task2_finished.set() # pragma: nocover await run_until_first_complete((task1, {}), (task2, {})) assert task1_finished.is_set() assert not task2_finished.is_set()
async def test_streaming_response_stops_if_receiving_http_disconnect(): streamed = 0 disconnected = anyio.Event() async def receive_disconnect(): await disconnected.wait() return {"type": "http.disconnect"} async def send(message): nonlocal streamed if message["type"] == "http.response.body": streamed += len(message.get("body", b"")) # Simulate disconnection after download has started if streamed >= 16: disconnected.set() async def stream_indefinitely(): while True: # Need a sleep for the event loop to switch to another task await anyio.sleep(0) yield b"chunk " response = StreamingResponse(content=stream_indefinitely()) with anyio.move_on_after(1) as cancel_scope: await response({}, receive_disconnect, send) assert not cancel_scope.cancel_called, "Content streaming should stop itself."
async def test_await_stop_event(tmp_path: Path, write_soon): sleep(0.05) write_soon(tmp_path / 'foo.txt') stop_event = anyio.Event() async for changes in awatch(tmp_path, debounce=50, step=10, watch_filter=None, stop_event=stop_event): assert changes == {(Change.added, str((tmp_path / 'foo.txt')))} stop_event.set()
def __new__(cls, service, id): # pylint: disable=redefined-builtin family_id, code, chksum = split_id(id) cls = dev_classes.get(family_id) # pylint: disable=self-cls-assignment if cls is None: class cls(Device): # pylint: disable=function-redefined family = family_id cls.__name__ = "Device_%02x" % (family_id, ) dev_classes[family_id] = cls self = object.__new__(cls) self.id = id.upper() self.family = family_id self.code = code self.chksum = chksum self.service = service self.bus = None self._unseen = 0 self._events = [] self._wait_bus = anyio.Event() self._poll = {} # name > poll task scopes self._intervals = {} self._task_lock = anyio.Lock() return self
async def _run_one(self, val: ValueEvent): try: async with anyio.create_task_group() as tg: self._current_tg = tg self.stream = await anyio.connect_tcp(self.host, self.port) ml, self.requests = deque(self.requests), deque() try: self._msg_proto = MessageProtocol(self, is_server=False) e_w = anyio.Event() e_r = anyio.Event() tg.spawn(self._writer, e_w) tg.spawn(self._reader, e_r) await e_r.wait() await e_w.wait() # re-send messages, but skip those that have been cancelled while ml: msg = ml.popleft() if not msg.cancelled: try: await self._wqueue_w.send(msg) except BaseException: ml.appendleft(msg) except BaseException: self.requests = ml raise await self.chat(NOPMsg()) if self._scan_args is not None: tg.spawn(partial(self.start_scan, **self._scan_args)) if val is not None: val.set(None) self._backoff = 0.1 pass # wait for tasks pass # exited tasks finally: self._current_tg = None if self.stream is not None: with anyio.CancelScope(shield=True): await self.stream.aclose() self.stream = None
def put_nowait(self, item: Any) -> None: logger.debug('trying to add %s to queue', item) self._send_channel.send_nowait(item) self._tasks_in_progress += 1 logger.debug('number of tasks in progress is now: %s', self._tasks_in_progress) if self._finished.is_set(): self._finished = anyio.Event()
async def continue_parsing(self): if self.parsing_paused_event: # join waiting for the current parse results return await self.parsing_paused_event.wait() self.parsing_paused_event = anyio.Event() chunk = await anext(self.input) for args in self.parser.feed(chunk): self._process_parsed(*args) self.parsing_paused_event.set() self.parsing_paused_event = None
async def test_fail_after_after_cancellation() -> None: event = anyio.Event() async with anyio.create_task_group() as tg: tg.cancel_scope.cancel() await event.wait() block_complete = False with pytest.raises(TimeoutError): with fail_after(0.1): await anyio.sleep(0.5) block_complete = True assert not block_complete
def __init__( self, pub_cancel: abc.Publication[GoalID], goal_id: GoalID, ) -> None: self._pub_cancel = pub_cancel self._goal_id = goal_id self._sm = CommStateMachine(goal_id) self._terminated = anyio.Event() self._result: Optional[abc.ResultT] = None ( self._feedback_send_stream, self._feedback_receive_stream, ) = anyio.create_memory_object_stream(float("inf"), abc.FeedbackT)
async def test_bestow(library): task = None task_started = anyio.Event() portal_installed = anyio.Event() async def task_fn(): nonlocal task task = greenback._impl.current_task() task_started.set() await portal_installed.wait() await_(anyio.sleep(0)) async with anyio.create_task_group() as tg: tg.start_soon(task_fn) await task_started.wait() assert not has_portal(task) greenback.bestow_portal(task) assert has_portal(task) greenback.bestow_portal(task) portal_installed.set() with pytest.raises(RuntimeError): await_(anyio.sleep(0))
async def next_seq(self): """ Returns the next seq num for sending. May need to delay until an ack is received. """ async with self._send_lock: self._n_sent += 1 res = self._n_sent if self._delay is None and self._n_sent - self._n_ack >= self.len: logger.debug("%s: wait: %d/%d", self._info, self._n_sent, self._n_ack) self._delay = anyio.Event() if self._delay is not None: await self._delay.wait() return res
async def changes(self, since=None, continuous=False): """"Like CouchDB's _changes with style=all_docs""" while True: # send (new) changes to the caller async for change in self._changes(since): since = change.seq yield change if not continuous: # stop immediately. break # wait for new changes to come available, then loop if not hasattr(self, '_update_event'): self._update_event = anyio.Event() await self._update_event.wait()
async def test_shielded_cancel_sleep_time() -> None: """Test that cancelling a shielded tasks spends more time sleeping than cancelling.""" event = anyio.Event() hang_time = 0.2 async def set_event() -> None: await sleep(hang_time) event.set() async def never_cancel_task() -> None: with CancelScope(shield=True): await sleep(0.2) await event.wait() async with create_task_group() as tg: tg.start_soon(set_event) async with create_task_group() as tg: tg.start_soon(never_cancel_task) tg.cancel_scope.cancel() process_time = time.process_time() assert (time.process_time() - process_time) < hang_time
def __init__(self, *, size, frame_rate, draw_fn): """ :param size: sequence of width, height :param frame_rate: rate of draw calls when the view is active :param draw_fn: draw function called each frame when the view is active """ self.width, self.height = size self._draw_fn = draw_fn self._frame_rate = frame_rate self._peers = set() self._hasPeers = anyio.Event() # NOTE: empty string is used to force a batching boundary self._sendQueue = [] self._receiveQueue = [] # oldest to newest self._shapeState = _ShapeState.NONE self._images = [] self._is_draw_context = False self.frameCount = 0 self.mousePressed = False self.mouseX = 0 self.mouseY = 0 self.keyPressed = False self.key = '' self.inputEvents = []
async def request(self, protocol, method, body, noresponse=False): if self.closed: raise RuntimeError("RMC connection is closed") call_id = self.call_id self.call_id = (self.call_id + 1) & 0xFFFFFFFF if not noresponse: event = anyio.Event() self.requests[call_id] = event message = RMCMessage.request(self.settings, protocol, method, call_id, body) await self.client.send(message.encode()) if not noresponse: await event.wait() if self.closed: raise RuntimeError("RMC connection is closed") message = self.responses.pop(call_id) if message.error != -1: raise common.RMCError(message.error) return message.body
# cleanup by awaiting the (now complete) stop_soon_task await stop_soon_task asyncio.run(main()) ``` """ if raise_interrupt is not None: warnings.warn( 'raise_interrupt is deprecated, KeyboardInterrupt will cause this coroutine to be cancelled and then ' 'be raised by the top level asyncio.run call or equivalent, and should be caught there. See #136.', DeprecationWarning, ) if stop_event is None: stop_event_: 'AnyEvent' = anyio.Event() else: stop_event_ = stop_event force_polling = _default_force_pulling(force_polling) with RustNotify([str(p) for p in paths], debug, force_polling, poll_delay_ms) as watcher: timeout = _calc_async_timeout(rust_timeout) CancelledError = anyio.get_cancelled_exc_class() while True: async with anyio.create_task_group() as tg: try: raw_changes = await anyio.to_thread.run_sync(watcher.watch, debounce, step, timeout, stop_event_) except (CancelledError, KeyboardInterrupt): stop_event_.set() # suppressing KeyboardInterrupt wouldn't stop it getting raised by the top level asyncio.run call
async def server( # pylint: disable=dangerous-default-value # intentional tree={}, options={}, events=None, polling=False, scan=None, initial_scan=True, **kw): """ This is a mock 1wire server+client. The context manager returns the client. ``tree`` and ``opotions`` are used as in `some_server`, ``polling``, ``scan`` and ``initial_scan`` are used to set up the client, other keyword arguments are forwarded to the client constructor. """ PORT = (os.getpid() % 9999) + 40000 async with OWFS(**kw) as ow: async with anyio.create_task_group() as tg: s = None try: listener = await anyio.create_tcp_listener( local_host="127.0.0.1", local_port=PORT, reuse_port=True) async def may_close(): try: await listener.serve( partial(some_server, tree, options)) except (anyio.ClosedResourceError, anyio.BrokenResourceError): pass except trio.MultiError as exc: exc = exc.filter( lambda x: None if isinstance(x, trio.Cancelled) else x, exc) if not isinstance(exc, (anyio.ClosedResourceError, anyio.BrokenResourceError)): raise except BaseException as exc: import pdb pdb.set_trace() raise if events is not None: evt = anyio.Event() tg.spawn(events, ow, evt) await evt.wait() addr = listener.extra( anyio.abc.SocketAttribute.raw_socket).getsockname() tg.spawn(may_close) s = await ow.add_server(*addr, polling=polling, scan=scan, initial_scan=initial_scan) ow.test_server = s yield ow finally: ow.test_server = None await listener.aclose() with anyio.CancelScope(shield=True): if s is not None: await s.drop() await ow.push_event(None) await anyio.sleep(0.1) tg.cancel_scope.cancel()
def _handleClose(self, peer): self._peers.remove(peer) if not self._peers: self._hasPeers = anyio.Event()
async def delocate(self, bus): """The device is no longer located here.""" if self.bus is bus: self._wait_bus = anyio.Event() await self._delocate()
def __init__(self) -> None: self._event = anyio.Event()
def __init__(self, group): self.group = group self.handle = itertools.count() self.event = anyio.Event() self.events = {}
async def process(self): while True: timeout = self.process_timers() with anyio.move_on_after(timeout): await self.event.wait() self.event = anyio.Event()