Python源码示例：asyncio.QueueEmpty()
示例1
def get(self) -> ParsedAnswer:
try:
item = self._queue.get_nowait()
except asyncio.QueueEmpty:
item = await self._queue.get()
self._queue.task_done()
# If we receive an exception when reading the queue, we raise it
if isinstance(item, Exception):
self._closed = True
raise item
# Don't need to save new answers or
# send the stop message if we already received the complete message
answer_type, execution_result = item
if answer_type == "complete":
self.send_stop = False
self._closed = True
return item
示例2
def get_available_candidate(self) -> discord.TextChannel:
"""
Return a dormant channel to turn into an available channel.
If no channel is available, wait indefinitely until one becomes available.
"""
log.trace("Getting an available channel candidate.")
try:
channel = self.channel_queue.get_nowait()
except asyncio.QueueEmpty:
log.info("No candidate channels in the queue; creating a new channel.")
channel = await self.create_dormant()
if not channel:
log.info("Couldn't create a candidate channel; waiting to get one from the queue.")
await self.notify()
channel = await self.wait_for_dormant_channel()
return channel
示例3
def receive_until(self, monotonic_deadline: float) -> typing.Optional[pyuavcan.transport.TransferFrom]:
try:
timeout = monotonic_deadline - self._loop.time()
if timeout > 0:
transfer = await asyncio.wait_for(self._queue.get(), timeout, loop=self._loop)
else:
transfer = self._queue.get_nowait()
except (asyncio.TimeoutError, asyncio.QueueEmpty):
# If there are unprocessed transfers, allow the caller to read them even if the instance is closed.
if self._maybe_finalizer is None:
raise pyuavcan.transport.ResourceClosedError(f'{self} is closed')
return None
else:
assert isinstance(transfer, pyuavcan.transport.TransferFrom), 'Internal protocol violation'
assert transfer.source_node_id == self._specifier.remote_node_id or self._specifier.remote_node_id is None
return transfer
示例4
def main(self):
print('start')
async_q = self._queue.async_q
main_loop = asyncio.get_event_loop()
while not (self._stopped and async_q.empty()):
try:
event = self.queue.get_nowait()
except asyncio.QueueEmpty:
pass
else:
asyncio.run_coroutine_threadsafe(
self.event_hadler(event),
main_loop
)
async_q.task_done()
await asyncio.sleep(0.0001)
示例5
def __handle_queue_update(cls,
q: Union[queue.Queue, asyncio.Queue],
first: object) -> list:
ret = first if isinstance(first, list) else [first]
while True:
try:
elem = q.get_nowait()
if isinstance(elem, list):
ret.extend(elem)
else:
ret.append(elem)
except (asyncio.QueueEmpty, queue.Empty):
break
return ret
示例6
def _stream_protocol_messages(self,
protocol_class: Type[ProtocolAPI],
) -> AsyncIterator[CommandAPI[Any]]:
"""
Stream the messages for the specified protocol.
"""
async with self._protocol_locks[protocol_class]:
self.raise_if_streaming_error()
msg_queue = self._protocol_queues[protocol_class]
while self.is_streaming:
try:
# We use an optimistic strategy here of using
# `get_nowait()` to reduce the number of times we yield to
# the event loop. Since this is an async generator it will
# yield to the loop each time it returns a value so we
# don't have to worry about this blocking other processes.
yield msg_queue.get_nowait()
except asyncio.QueueEmpty:
yield await msg_queue.get()
#
# Message reading and streaming API
#
示例7
def raise_errors(self):
# If the error monitor is running then just return, as that means we are
# running as a worker and so can rely on the error monitor to pickup the
# errors which an happen in the various background tasks
if self._error_monitor_lock.locked():
return
# Check queue for errors
try:
error: Error = self.error_queue.get_nowait()
except asyncio.QueueEmpty:
# No errors, everything ok
return
else:
# If there is an error then raise it
raise error.value
示例8
def run(self, *args):
while True:
msg = await self.queue.get()
async with self.get_connection() as conn:
self.connect_counter += 1
while True:
try:
await self.send_message(msg, conn)
self.mail_success += 1
except:
self.mail_failed += 1
await conn.close()
logger.exception('Mailer reconnect')
self.reconnect_counter += 1
await asyncio.sleep(2)
await conn.open()
try:
msg = self.queue.get_nowait()
except asyncio.QueueEmpty:
break
示例9
def get(
self, *, no_ack=False, fail=True, timeout=5
) -> Optional[IncomingMessage]:
""" Get message from the queue.
:param no_ack: if :class:`True` you don't need to call
:func:`aio_pika.message.IncomingMessage.ack`
:param timeout: execution timeout
:param fail: Should return :class:`None` instead of raise an
exception :class:`aio_pika.exceptions.QueueEmpty`.
:return: :class:`aio_pika.message.IncomingMessage`
"""
msg = await asyncio.wait_for(
self.channel.basic_get(self.name, no_ack=no_ack), timeout=timeout,
) # type: Optional[DeliveredMessage]
if msg is None:
if fail:
raise QueueEmpty
return
return IncomingMessage(msg, no_ack=no_ack)
示例10
def close(self):
if not self._consumer_tag:
return
await self._amqp_queue.cancel(self._consumer_tag)
self._consumer_tag = None
def get_msg():
try:
return self._queue.get_nowait()
except asyncio.QueueEmpty:
return
# Reject all messages
msg = get_msg() # type: IncomingMessage
while msg and not self._amqp_queue.channel.closing.done():
await msg.reject(requeue=True)
msg = get_msg() # type: IncomingMessage
示例11
def poll(self):
"""Wait for packets to send to the client."""
try:
packets = [await asyncio.wait_for(self.queue.get(),
self.server.ping_timeout)]
self.queue.task_done()
except (asyncio.TimeoutError, asyncio.CancelledError):
raise exceptions.QueueEmpty()
if packets == [None]:
return []
while True:
try:
pkt = self.queue.get_nowait()
self.queue.task_done()
if pkt is None:
self.queue.put_nowait(None)
break
packets.append(pkt)
except asyncio.QueueEmpty:
break
return packets
示例12
def handle_get_request(self, environ):
"""Handle a long-polling GET request from the client."""
connections = [
s.strip()
for s in environ.get('HTTP_CONNECTION', '').lower().split(',')]
transport = environ.get('HTTP_UPGRADE', '').lower()
if 'upgrade' in connections and transport in self.upgrade_protocols:
self.server.logger.info('%s: Received request to upgrade to %s',
self.sid, transport)
return await getattr(self, '_upgrade_' + transport)(environ)
if self.upgrading or self.upgraded:
# we are upgrading to WebSocket, do not return any more packets
# through the polling endpoint
return [packet.Packet(packet.NOOP)]
try:
packets = await self.poll()
except exceptions.QueueEmpty:
exc = sys.exc_info()
await self.close(wait=False)
six.reraise(*exc)
return packets
示例13
def _consume(
self,
payload_queue: asyncio.Queue,
request_meta: Optional[RequestMeta] = None,
add_start_dispatch: Optional[List[str]] = None,
) -> None:
while True:
try:
task = await payload_queue.get()
# Determine whether the provider has returned a `Payload`, or a task.
# If it is a task, load the defined archiver plugin to load the
# `Payload`, otherwise, simply continue on with the scanning.
if isinstance(task, Payload):
request = Request([task], request_meta)
await self.scan_request(request, add_start_dispatch)
else:
for source_archiver, task_meta in task.items():
self.log.debug(
f'Provider task received: source_archiver: {source_archiver}, '
f'task_meta: {task_meta}'
)
try:
ar = ArchiverResponse(task_meta)
payload = await self._loaded_source_archiver_plugins[
source_archiver
].get(ar)
if payload:
request = Request([payload], request_meta)
await self.scan_request(request, add_start_dispatch)
except Exception as e:
self.log.warn(
f'"{task_meta}" failed with archiver "{source_archiver}": {str(e)}'
)
payload_queue.task_done()
except asyncio.QueueEmpty:
pass
示例14
def next(self):
if self.users.empty():
await self.fill_users()
try:
return self.users.get_nowait()
except asyncio.QueueEmpty:
raise NoMoreItems()
示例15
def next(self):
if self.messages.empty():
await self.fill_messages()
try:
return self.messages.get_nowait()
except asyncio.QueueEmpty:
raise NoMoreItems()
示例16
def next(self):
if self.entries.empty():
await self._fill()
try:
return self.entries.get_nowait()
except asyncio.QueueEmpty:
raise NoMoreItems()
示例17
def next(self):
if self.guilds.empty():
await self.fill_guilds()
try:
return self.guilds.get_nowait()
except asyncio.QueueEmpty:
raise NoMoreItems()
示例18
def next(self):
if self.members.empty():
await self.fill_members()
try:
return self.members.get_nowait()
except asyncio.QueueEmpty:
raise NoMoreItems()
示例19
def async_test(timeout=1):
func = None
if callable(timeout):
func = timeout
timeout = 1
def _decorator(f):
@functools.wraps(f)
def _wrapper(self, *args, **kwargs):
task = self.loop.create_task(
asyncio.coroutine(f)(self, *args, **kwargs))
def _cancel():
task.print_stack()
task.cancel()
time_handle = self.loop.call_later(timeout, _cancel)
try:
return self.loop.run_until_complete(task)
except asyncio.CancelledError:
events = []
while True:
try:
events.append(self.server.events.get_nowait())
except asyncio.QueueEmpty:
break
self.fail('server events: {}'.format(events))
finally:
time_handle.cancel()
return _wrapper
if func is not None:
return _decorator(func)
return _decorator
示例20
def receive_for(self, timeout: float) \
-> typing.Optional[typing.Tuple[MessageClass, pyuavcan.transport.TransferFrom]]:
"""
Blocks until either a valid message is received,
in which case it is returned along with the transfer which delivered it;
or until the timeout is expired, in which case None is returned.
The method will never return None unless the timeout has expired or its session is closed;
in order words, a spurious premature cancellation cannot occur.
If the timeout is non-positive, the method will non-blockingly check if there is any data;
if there is, it will be returned, otherwise None will be returned immediately.
It is guaranteed that no context switch will occur if the timeout is negative, as if the method was not async.
"""
self._raise_if_closed_or_failed()
try:
if timeout > 0:
message, transfer = await asyncio.wait_for(self._rx.queue.get(), timeout, loop=self._loop)
else:
message, transfer = self._rx.queue.get_nowait()
except asyncio.QueueEmpty:
return None
except asyncio.TimeoutError:
return None
else:
assert isinstance(message, self._impl.dtype), 'Internal protocol violation'
assert isinstance(transfer, pyuavcan.transport.TransferFrom), 'Internal protocol violation'
return message, transfer
# ---------------------------------------- ITERATOR API ----------------------------------------
示例21
def frame_queue_capacity(self, value: typing.Optional[int]) -> None:
if value is not None and not value > 0:
raise ValueError(f'Invalid value for queue capacity: {value}')
old_queue = self._queue
self._queue = asyncio.Queue(int(value) if value is not None else 0, loop=self._loop)
try:
while True:
self._push_frame(*old_queue.get_nowait())
except asyncio.QueueEmpty:
pass
示例22
def receive_until(self, monotonic_deadline: float) -> typing.Optional[pyuavcan.transport.TransferFrom]:
try:
timeout = monotonic_deadline - self._loop.time()
if timeout > 0:
transfer = await asyncio.wait_for(self._queue.get(), timeout, loop=self._loop)
else:
transfer = self._queue.get_nowait()
except (asyncio.TimeoutError, asyncio.QueueEmpty):
# If there are unprocessed transfers, allow the caller to read them even if the instance is closed.
self._raise_if_closed()
return None
else:
assert isinstance(transfer, pyuavcan.transport.TransferFrom), 'Internal protocol violation'
assert transfer.source_node_id == self._specifier.remote_node_id or self._specifier.remote_node_id is None
return transfer
示例23
def getc(self):
"""Return one character from the input queue"""
try:
return await self.cookedq.get()
except asyncio.QueueEmpty:
return b''
# --------------------------- Output Functions -----------------------------
示例24
def queue_items(self, send_q, return_q):
n_items = 0
for recipe_dir in self.recipe_dirs:
await send_q.put(Recipe(recipe_dir, self.recipe_base))
n_items += 1
while return_q.qsize():
try:
return_q.get_nowait()
return_q.task_done()
n_items -= 1
except asyncio.QueueEmpty:
break
for n in range(n_items):
await return_q.get()
return_q.task_done()
示例25
def request(req, addr, timeout=3.0):
'''
Send raw data with a connection pool.
'''
qdata = req.pack()
bsize = struct.pack('!H', len(qdata))
key = addr.to_str(53)
queue = _connections.setdefault(key, asyncio.Queue(maxsize=_DEFAULT_QUEUE_SIZE))
for _retry in range(5):
reader = writer = None
try:
reader, writer = queue.get_nowait()
except asyncio.QueueEmpty:
pass
if reader is None:
try:
reader, writer = await asyncio.wait_for(asyncio.open_connection(addr.host, addr.port), timeout)
except asyncio.TimeoutError:
pass
if reader is None:
continue
writer.write(bsize)
writer.write(qdata)
try:
await writer.drain()
size, = struct.unpack('!H', await reader.readexactly(2))
data = await reader.readexactly(size)
queue.put_nowait((reader, writer))
except asyncio.QueueFull:
pass
return data
else:
raise DNSConnectionError
示例26
def handle_inbox(self) -> int:
""" Do not override `handle_inbox`, instead go for
`handle_one_inbox_message`
:returns: How many messages have been handled
"""
n_handled = 0
try:
while True:
msg = self.inbox_.get_nowait()
n_handled += 1
self.handle_one_inbox_message(msg)
except asyncio.QueueEmpty:
return n_handled
示例27
def _cancel(self) -> None:
"""
Cancel active and all pending jobs. Return whether the final
job has been removed.
Add a 'done' callback to each job in order to mark the job
queue as 'closed' after all functions, which may want to handle
the cancellation, have handled that cancellation.
This for example prevents a 'disconnect' message from being
sent before a 'send-error' message has been sent, see:
https://github.com/saltyrtc/saltyrtc-server-python/issues/77
"""
if self._state < JobQueueState.cancelled:
self._state = JobQueueState.cancelled
self._log.debug('Cancelled job queue')
if self._active_job is not None:
self._log.debug('Cancelling active job')
# Note: We explicitly DO NOT add the 'job done' callback here since the job
# does that in all cases.
util.cancel_awaitable(self._active_job, self._log)
self._active_job = None
self._log.debug('Cancelling {} queued jobs', self._queue.qsize())
while True:
try:
job = self._queue.get_nowait()
except asyncio.QueueEmpty:
break
if isinstance(job, FinalJob):
self._job_done(job, silent=True)
else:
util.cancel_awaitable(job, self._log, done_cb=self._job_done)
示例28
def test_nonblocking_get_exception(self):
q = asyncio.Queue(loop=self.loop)
self.assertRaises(asyncio.QueueEmpty, q.get_nowait)
示例29
def readline(self):
if self.queue.empty():
raise asyncio.QueueEmpty
line = yield from self.queue.get()
return line
示例30
def process_lines(self, lines):
for line in lines:
self.putline(line)
while True:
try:
yield from self.client.parse()
except asyncio.QueueEmpty:
break
