Python源码示例：queue.Empty()
示例1
def run(self):
window_name = "Olympe Streaming Example"
cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
main_thread = next(
filter(lambda t: t.name == "MainThread", threading.enumerate())
)
while main_thread.is_alive():
with self.flush_queue_lock:
try:
yuv_frame = self.frame_queue.get(timeout=0.01)
except queue.Empty:
continue
try:
self.show_yuv_frame(window_name, yuv_frame)
except Exception:
# We have to continue popping frame from the queue even if
# we fail to show one frame
traceback.print_exc()
finally:
# Don't forget to unref the yuv frame. We don't want to
# starve the video buffer pool
yuv_frame.unref()
cv2.destroyWindow(window_name)
示例2
def _loop_for_observer(self):
"""
Loop to pass data (put by method feed) to observer.
:return: None
"""
while self._request_end is False:
try:
data, timestamp = self._queue.get(True, self._timeout_for_get_from_queue)
try:
self.logger.log(level=TRACE, msg=r'notifying {}({!r})'.format(self._observer, repr(data)))
except ReferenceError:
self._request_end = True # self._observer is no more valid.
try:
if self._observer_self:
self._observer(self._observer_self, data, timestamp)
else:
self._observer(data, timestamp)
except ReferenceError:
self._request_end = True # self._observer is no more valid.
except Exception:
self.logger.exception(msg=r'Exception inside: {}({!r})'.format(self._observer, repr(data)))
except queue.Empty:
pass # No incoming data within self._timeout_for_get_from_queue
self._observer = None
self._observer_self = None
示例3
def reset(self):
"""
Resets the generator by stopping all processes
"""
self.alive.value = False
qsize = 0
try:
while True:
self.queue.get(timeout=0.1)
qsize += 1
except QEmptyExcept:
pass
print("Queue size on reset: {}".format(qsize))
for i, p in enumerate(self.proc):
p.join()
self.proc.clear()
示例4
def extractInfo(self):
try:
while not self.exit:
try:
frame = self.frame_queue.get(block=True, timeout=1)
except queue.Empty:
print("Queue empty")
continue
try:
# Publish new image
msg = self.bridge.cv2_to_imgmsg(frame, 'rgb8')
if not self.exit:
self.image_publisher.publish(msg)
except CvBridgeError as e:
print("Error Converting cv image: {}".format(e.message))
self.frame_num += 1
except Exception as e:
print("Exception after loop: {}".format(e))
raise
示例5
def _check_and_execute(self):
wakeup_queue = self._wakeup_queue
while 1:
(next_expired_time, expired_timers) = self._get_expired_timers()
for timer in expired_timers:
try:
# Note, please make timer callback effective/short
timer()
except Exception:
logging.error(traceback.format_exc())
self._reset_timers(expired_timers)
sleep_time = _calc_sleep_time(next_expired_time)
try:
wakeup = wakeup_queue.get(timeout=sleep_time)
if wakeup is TEARDOWN_SENTINEL:
break
except Queue.Empty:
pass
logging.info('TimerQueue stopped.')
示例6
def _check_and_execute(self):
wakeup_queue = self._wakeup_queue
while 1:
(next_expired_time, expired_timers) = self._get_expired_timers()
for timer in expired_timers:
try:
# Note, please make timer callback effective/short
timer()
except Exception:
logging.error(traceback.format_exc())
self._reset_timers(expired_timers)
sleep_time = _calc_sleep_time(next_expired_time)
try:
wakeup = wakeup_queue.get(timeout=sleep_time)
if wakeup is TEARDOWN_SENTINEL:
break
except Queue.Empty:
pass
logging.info('TimerQueue stopped.')
示例7
def _do_admin(self):
admin_q = self._admin_queue
resize_win = self._resize_window
while 1:
try:
wakup = admin_q.get(timeout=resize_win + 1)
except queue.Empty:
self._do_resize_according_to_loads()
continue
if wakup is None:
break
else:
self._do_resize_according_to_loads()
log.logger.info("ThreadPool admin thread=%s stopped.",
threading.current_thread().getName())
示例8
def get(self, timeout=None):
"""
Return the result when it arrives. If timeout is not None and the
result does not arrive within timeout seconds then
multiprocessing.TimeoutError is raised. If the remote call raised an
exception then that exception will be reraised by get().
"""
try:
res = self._q.get(timeout=timeout)
except queue.Empty:
raise multiprocessing.TimeoutError("Timed out")
if isinstance(res, Exception):
raise res
return res
示例9
def worker(work_queue, results_queue, throttle):
while True:
try:
item = work_queue.get(block=False)
except Empty:
break
else:
while not throttle.consume():
pass
try:
result = fetch_place(item)
except Exception as err:
results_queue.put(err)
else:
results_queue.put(result)
finally:
work_queue.task_done()
示例10
def display(self):
if os.getpid() != self._creator:
return
while not self._stop:
lines_displayed = 0
while True:
try:
line = self._stream.get_nowait()
sys.stdout.write(line)
lines_displayed += 1
except Empty:
break
if self._stop or lines_displayed > self._max_lines_displayed:
break
else:
await asyncio.sleep(0)
sys.stdout.flush()
if not self._stop:
await cancellable_sleep(self._interval)
示例11
def test_run_empty(self, m_count):
events = [(x, (), {}) for x in (mock.sentinel.event1,
mock.sentinel.event2)]
group = mock.sentinel.group
m_queue = mock.Mock()
m_queue.empty.return_value = True
m_queue.get.side_effect = events + [queue.Empty()]
m_handler = mock.Mock()
m_count.return_value = list(range(5))
async_handler = h_async.Async(m_handler, mock.Mock(), mock.Mock())
with mock.patch('time.sleep'):
async_handler._run(group, m_queue)
m_handler.assert_has_calls([mock.call(event[0]) for event in events])
self.assertEqual(len(events), m_handler.call_count)
示例12
def install_pyro_queue_callback(self):
"""
Add a callback to the tkinter event loop that is invoked every so often.
The callback checks the Pyro work queue for work and processes it.
"""
def check_pyro_queue():
try:
while True:
# get a work item from the queue (until it is empty)
workitem = self.pyro_queue.get_nowait()
# execute it in the gui's mainloop thread
workitem["callable"](*workitem["vargs"], **workitem["kwargs"])
except queue.Empty:
pass
self.tk.after(1000 // PYRO_QUEUE_HZ, check_pyro_queue)
self.tk.after(1000 // PYRO_QUEUE_HZ, check_pyro_queue)
示例13
def api(self, request, data=None):
log.debug('api: %s, %s', request, data)
msg = {
'req': request.lower(),
'data': data,
'sender': 'RemoteServer'}
self.q_send.put(msg)
try:
status, data = self.q_recv.get(timeout=5)
except queue.Empty:
status, data = False, 'Timeout waiting for response.'
return flask.jsonify({
'status': status,
'msg': 'OK' if status else data,
'data': data if status else None,
})
示例14
def handle_output(self) -> None:
"""Handles output from stream.
"""
while self.is_alive():
try:
order_books = self._output_queue.get(
block=True, timeout=self.streaming_timeout
)
except queue.Empty: # todo snap every 5s or so anyway
if self.flumine.markets.live_orders:
order_books = self._listener.snap(
market_ids=self.flumine.markets.open_market_ids
)
else:
continue
if order_books:
self.flumine.handler_queue.put(CurrentOrdersEvent(order_books))
logger.info("Stopped output_thread (OrderStream {0})".format(self.stream_id))
示例15
def handle_output(self) -> None:
"""Handles output from stream.
"""
while self.is_alive():
try:
market_books = self._output_queue.get(
block=True, timeout=self.streaming_timeout
)
except queue.Empty:
market_books = self._listener.snap(
market_ids=self.flumine.markets.open_market_ids
)
if market_books:
self.flumine.handler_queue.put(MarketBookEvent(market_books))
logger.info("Stopped output_thread (MarketStream {0})".format(self.stream_id))
示例16
def download_worker_function(download_queue, vtapikey):
while True:
try:
sha256 = download_queue.get()
except queue.Empty:
continue
if sha256 == "STOP":
download_queue.task_done()
return True
print("{} downloading".format(sha256))
sample_path = os.path.join(samples_path, sha256)
success = vt_download_sample(sha256, sample_path, vtapikey)
if not success:
print("{} had a problem".format(sha256))
print("{} done".format(sha256))
download_queue.task_done()
示例17
def db_jobs(self):
# print("Running do_jobs")
while not self.has_been_stopped.is_set():
try:
item = self.db_jobs_queue.get() # timeout=1)
self.db_jobs_queue.task_done()
except Empty:
if self.has_been_stopped.is_set():
break
else:
if item is None or self.has_been_stopped.is_set():
break
db_job: RayDbJob = item
# self.print_timecheck("Doing db job", item)
try:
db_job.execute()
except Exception as e:
if db_job.error is None:
print(traceback.format_exc())
self._print_timecheck(
"Continuing after error running DB job:", e
)
sleep(1)
# else:
# self.print_timecheck("Done db job", item)
示例18
def act(self, action):
if self.nthreads > 1:
new = self.pool.map(env_step, zip(self.env, action))
else:
new = [env.step(act) for env, act in zip(self.env, action)]
reward = np.asarray([i[1] for i in new], dtype=np.float32)
done = np.asarray([i[2] for i in new], dtype=np.float32)
channels = self.state_.shape[1]//self.input_length
state = np.zeros_like(self.state_)
state[:,:-channels,:,:] = self.state_[:,channels:,:,:]
for i, (ob, env) in enumerate(zip(new, self.env)):
if ob[2]:
state[i,-channels:,:,:] = env.reset().transpose((2,0,1))
else:
state[i,-channels:,:,:] = ob[0].transpose((2,0,1))
self.state_ = state
if self.web_viz:
try:
while self.queue.qsize() > 10:
self.queue.get(False)
except queue.Empty:
pass
frame = self.visual()
self.queue.put(frame)
return reward, done
示例19
def run(self):
while not self._stopped:
try:
task = self.queue.get(timeout=0.2)
except Empty:
continue
else:
args = task.args or ()
kwargs = task.kwargs or {}
self.task_func(*args, **kwargs)
self.queue.task_done()
示例20
def get_request(self, timeout=None):
if timeout is not None:
try:
return self.send_queue.get(
timeout=timeout
)
except queue.Empty:
return None
return self.send_queue.get()
示例21
def generator(self):
while not self.closed:
# Use a blocking get() to ensure there's at least one chunk of
# data, and stop iteration if the chunk is None, indicating the
# end of the audio stream.
chunk = self._buff.get()
if chunk is None:
return
data = [chunk]
# Now consume whatever other data's still buffered.
while True:
try:
chunk = self._buff.get(block=False)
if chunk is None:
return
data.append(chunk)
except queue.Empty:
break
ans = np.fromstring(b"".join(data), dtype=np.float32)
# yield uniform-sized chunks
ans = np.split(ans, np.shape(ans)[0] / self._chunk)
# Resample the audio to 22050, librosa default
for chunk in ans:
yield librosa.core.resample(chunk, self._rate, 22050)
示例22
def _monitor(self):
"""
Monitor the queue for records, and ask the handler
to deal with them.
This method runs on a separate, internal thread.
The thread will terminate if it sees a sentinel object in the queue.
"""
q = self.queue
has_task_done = hasattr(q, 'task_done')
while not self._stop.isSet():
try:
record = self.dequeue(True)
if record is self._sentinel:
break
self.handle(record)
if has_task_done:
q.task_done()
except queue.Empty:
pass
# There might still be records in the queue.
while True:
try:
record = self.dequeue(False)
if record is self._sentinel:
break
self.handle(record)
if has_task_done:
q.task_done()
except queue.Empty:
break
示例23
def _get_conn(self, timeout=None):
"""
Get a connection. Will return a pooled connection if one is available.
If no connections are available and :prop:`.block` is ``False``, then a
fresh connection is returned.
:param timeout:
Seconds to wait before giving up and raising
:class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and
:prop:`.block` is ``True``.
"""
conn = None
try:
conn = self.pool.get(block=self.block, timeout=timeout)
except AttributeError: # self.pool is None
raise ClosedPoolError(self, "Pool is closed.")
except Empty:
if self.block:
raise EmptyPoolError(self,
"Pool reached maximum size and no more "
"connections are allowed.")
pass # Oh well, we'll create a new connection then
# If this is a persistent connection, check if it got disconnected
if conn and is_connection_dropped(conn):
log.info("Resetting dropped connection: %s" % self.host)
conn.close()
if getattr(conn, 'auto_open', 1) == 0:
# This is a proxied connection that has been mutated by
# httplib._tunnel() and cannot be reused (since it would
# attempt to bypass the proxy)
conn = None
return conn or self._new_conn()
示例24
def close(self):
"""
Close all pooled connections and disable the pool.
"""
# Disable access to the pool
old_pool, self.pool = self.pool, None
try:
while True:
conn = old_pool.get(block=False)
if conn:
conn.close()
except Empty:
pass # Done.
示例25
def _poll(self):
try:
event = self.queue.get(block=False)
except q.Empty:
pass
else:
if event == CORPUS_LOADED_EVENT:
self.handle_corpus_loaded(event)
elif event == SEARCH_TERMINATED_EVENT:
self.handle_search_terminated(event)
elif event == SEARCH_ERROR_EVENT:
self.handle_search_error(event)
elif event == ERROR_LOADING_CORPUS_EVENT:
self.handle_error_loading_corpus(event)
self.after = self.top.after(POLL_INTERVAL, self._poll)
示例26
def _poll(self):
try:
event = self.queue.get(block=False)
except q.Empty:
pass
else:
if event == CORPUS_LOADED_EVENT:
self.handle_corpus_loaded(event)
elif event == ERROR_LOADING_CORPUS_EVENT:
self.handle_error_loading_corpus(event)
self.after = self.top.after(POLL_INTERVAL, self._poll)
示例27
def evaluate(self, genomes, config):
"""
Evaluates the genomes.
This method raises a ModeError if the
DistributedEvaluator is not in primary mode.
"""
if self.mode != MODE_PRIMARY:
raise ModeError("Not in primary mode!")
tasks = [(genome_id, genome, config) for genome_id, genome in genomes]
id2genome = {genome_id: genome for genome_id, genome in genomes}
tasks = chunked(tasks, self.secondary_chunksize)
n_tasks = len(tasks)
for task in tasks:
self.inqueue.put(task)
tresults = []
while len(tresults) < n_tasks:
try:
sr = self.outqueue.get(block=True, timeout=0.2)
except (queue.Empty, managers.RemoteError):
continue
tresults.append(sr)
results = []
for sr in tresults:
results += sr
for genome_id, fitness in results:
genome = id2genome[genome_id]
genome.fitness = fitness
示例28
def _worker(self):
"""The worker function"""
while self.working:
try:
genome_id, genome, config = self.inqueue.get(
block=True,
timeout=0.2,
)
except queue.Empty:
continue
f = self.eval_function(genome, config)
self.outqueue.put((genome_id, genome, f))
示例29
def extractInfo(self):
# times = []
try:
while not self.exit:
try:
frame = self.frame_queue.get(block=True, timeout=1)
except queue.Empty:
print("Frame queue empty")
continue
# 1 ms per loop
# TODO: check that this conversion is not needed
# frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
if self.debug:
self.out_queue.put(item=frame, block=False)
else:
try:
# start_time = time.time()
turn_percent, centroids = processImage(frame)
# times.append(time.time() - start_time)
self.out_queue.put(item=(turn_percent, centroids), block=False)
except Exception as e:
print("Exception in RBGAnalyser processing image: {}".format(e))
self.frame_num += 1
except Exception as e:
print("Exception in RBGAnalyser after loop: {}".format(e))
# s_per_loop_image = np.mean(times)
# print("Image processing: {:.2f}ms per loop | {} fps".format(s_per_loop_image * 1000, int(1 / s_per_loop_image)))
示例30
def _do_write_events(self):
event_queue = self._event_queue
write = sys.stdout.write
got_shutdown_signal = False
while 1:
try:
event = event_queue.get(timeout=3)
if event is not None:
if isinstance(event, string_types):
if sys.version_info[0] > 2:
event = event.encode("utf-8")
write(event)
elif isinstance(event, Iterable):
for evt in event:
if sys.version_info[0] > 2 and isinstance(evt, string_types):
evt = evt.encode("utf-8")
write(evt)
else:
log.logger.info("Event writer got tear down signal")
got_shutdown_signal = True
except queue.Empty:
# We need drain the queue before shutdown
# timeout means empty for now
if got_shutdown_signal:
log.logger.info("Event writer is going to exit...")
break
else:
continue
except Exception:
log.logger.exception("EventWriter encounter exception which may"
"cause data loss, queue leftsize={"
"}".format(
event_queue.qsize()))
self._exception = True
break
log.logger.info("Event writer stopped, queue leftsize={}".format(
event_queue.qsize()))
