Python Queue.get_nowait方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
    def test_exception_and_forwarded_and_processed_queues_behave_correctly_when_dummy_handler_and_bad_event(self):
        events = Queue()
        exceptions_q = Queue()
        forward_q = Queue()
        processed_event_q = Queue()
        looper = EventLoop(events, DummyEventHandler(), exceptions_q=exceptions_q,
                           forward_q=forward_q, processed_event_q=processed_event_q)
        price_thread = Thread(target=looper.start, args=[])
        price_thread.start()
        ev = None
        events.put(ev)
        sleep(2*looper.heartbeat)
        looper.stop()
        price_thread.join(timeout=2*looper.heartbeat)

        out_event = exceptions_q.get_nowait()
        self.assertIsNone(out_event.orig_event)

        self.assertIsNone(ev, forward_q.get_nowait())

        try:
            processed_event_q.get_nowait()
            self.fail('got processed event when exception happened')
        except Empty:
            pass

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
    def test_max_connections_blocks(self):
        """Getting a connection should block for until available."""

        import time
        from copy import deepcopy
        from threading import Thread

        # We use a queue for cross thread communication within the unit test.
        try: # Python 3
            from queue import Queue
        except ImportError:
            from Queue import Queue

        q = Queue()
        q.put_nowait('Not yet got')
        pool = self.get_pool(max_connections=2, timeout=5)
        c1 = pool.get_connection('_')
        c2 = pool.get_connection('_')
        
        target = lambda: q.put_nowait(pool.get_connection('_'))
        Thread(target=target).start()

        # Blocks while non available.
        time.sleep(0.05)
        c3 = q.get_nowait()
        self.assertEquals(c3, 'Not yet got')
        
        # Then got when available.
        pool.release(c1)
        time.sleep(0.05)
        c3 = q.get_nowait()
        self.assertEquals(c1, c3)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class ThreadedClient(threading.Thread):
    def __init__(self, host, port=None, start=False, timeout=3.0):
        super(ThreadedClient, self).__init__()
        self.host = host
        self.port = port
        self.timeout = timeout
        self._q = Queue()

        if start:
            self.start()

    def run(self, *args, **kw):
        self.client = Client((self.host, self.port))

        while True:
            msg = self._q.get()
            if msg is None:
                break

            addr, msg = msg
            log.debug("Sending OSC msg %s, %r", addr, msg)
            self.client.send(addr, *msg)

        self.client.close()

    def send(self, addr, *args, **kw):
        self._q.put((addr, args), timeout=kw.get('timeout', self.timeout))

    def close(self, **kw):
        timeout = kw.get('timeout', self.timeout)
        log.debug("Emptying send queue...")

        while True:
            try:
                self._q.get_nowait()
            except QueueEmpty:
                break

        if self.is_alive():
            log.debug("Signalling OSC client thread to exit...")
            self._q.put(None, timeout=timeout)

            log.debug("Joining OSC client thread...")
            self.join(timeout)

            if self.is_alive():
                log.warning("OSC client thread still alive after join().")

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
def downloads(urls, outputs=[], concurrency=cpu_count()):
	# 用于线程同步的队列
	exit_queue = Queue(1)
	job_queue = Queue()
	result_queue = Queue()

	# 创建下载任务，并加入到任务队列
	outputs = [None for _ in urls] if not outputs else outputs
	for url, output in zip(urls, outputs):
		job_queue.put(Param(url, output))

	job_size = job_queue.qsize()
	works = []

	# 创建工作线程并启动
	concurrency = job_size if concurrency > job_size else concurrency
	for _ in range(concurrency):
		t = Worker(job_queue, result_queue, exit_queue)
		works.append(t)
		t.start()

	# 检测任务是否完成，主要有两种情况
	# 1.所有任务都执行了
	# 2.用户主动按ctrl+c结束任务,这里会等待已经运行的任务继续运行
	alive = True
	try:
		while alive:
			for work in works:
				if work.isAlive():
					alive = True
					break
			else:
				alive = False
			if result_queue.qsize() == job_size and exit_queue.qsize() == 0:
				exit_queue.put(1)
	except KeyboardInterrupt:
		logger.warning("ctrl + c is precessed!wait running task to complate..")
		exit_queue.put(1)
		for work in works:
			if work.isAlive():
				work.join()

	# 结果收集并返回
	results = []
	while job_queue.qsize() > 0:
		param = job_queue.get_nowait()
		results.append(Result(False, "task not excute", param.url))
	while result_queue.qsize() > 0:
		result = result_queue.get_nowait()
		results.append(result)
	return results

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
 def test_forwarded_and_processed_event_should_be_same_as_input_event_when_dummy_handler(self):
     events = Queue()
     forward_q = Queue()
     processed_event_q = Queue()
     looper = EventLoop(events, DummyEventHandler(), forward_q=forward_q, processed_event_q=processed_event_q)
     price_thread = Thread(target=looper.start, args=[])
     price_thread.start()
     ev = 'dummy event'
     events.put(ev)
     sleep(2*looper.heartbeat)
     looper.stop()
     price_thread.join(timeout=2*looper.heartbeat)
     self.assertEqual(ev, forward_q.get_nowait())
     self.assertEqual(ev, processed_event_q.get_nowait())

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class InMemoryBufferedLogSubscriber(LogSubscriber):

    @property
    def enabled(self):
        return self._enabled

    @enabled.setter
    def enabled(self, value):
        self._enabled = value

    @property
    def is_buffer_full(self):
        return self._log_entry_queue.qsize() >= self._max_buffer_size

    def __init__(self, max_buffer_size):
        self._log_entry_queue = Queue()
        self._max_buffer_size = max_buffer_size
        self._enabled = True

    def log(self, log_entry):
        if not self._enabled or self.is_buffer_full:
            return
        self._log_entry_queue.put(log_entry)

    def flush(self):
        items = []
        for i in range(self._max_buffer_size):
            try:
                items.append(self._log_entry_queue.get_nowait())
            except Empty:
                break
        return items

    def close(self):
        pass # Intentionally blank

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
  def test_sigpipe(self):
    r, w = os.pipe()
    outstream = os.fdopen(w, 'wb')
    task = self.create_task(self.context(console_outstream=outstream))
    raised = Queue(maxsize=1)

    def execute():
      try:
        task.execute()
      except IOError as e:
        raised.put(e)

    execution = threading.Thread(target=execute, name='ConsoleTaskTestBase_sigpipe')
    execution.setDaemon(True)
    execution.start()
    try:
      data = os.read(r, 5)
      self.assertEqual(b'jake\n', data)
      os.close(r)
    finally:
      task.stop()
      execution.join()

    with self.assertRaises(Empty):
      e = raised.get_nowait()

      # Instead of taking the generic assertRaises raises message, provide a more detailed failure
      # message that shows exactly what untrapped error was on the queue.
      self.fail('task raised {0}'.format(e))

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
def manage(worker, n_threads = 10, catalogs = download.catalogs):
    'Manage a bunch of worker threads, and generate their results.'
    # Download in random order
    args = []
    for catalog in catalogs:
        for dataset in download.datasets(catalog):
            args.append((catalog, dataset))
    random.shuffle(args)

    read_queue = Queue()
    for a in args:
        read_queue.put(a)

    write_queue = Queue()
    threads = []
    for i in range(n_threads):
        threads.append(Thread(target = worker, args = (read_queue,write_queue)))
        threads[-1].start()

    while not (read_queue.empty() and write_queue.empty() and set(t.is_alive() for t in threads) == {False}):
        try:
            x = write_queue.get_nowait()
        except Empty:
            pass
        else:
            yield x

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
    def test_should_allow_to_read_string_journals(self):
        filename = os.path.join(OUTPUT_DIR, 'journal_read_ut.txt')
        try:
            os.remove(filename)
        except OSError:
            pass

        print('writing..')
        journaler = FileJournaler(full_path=filename)
        journaler.start()
        event = 'this is a test event #1'
        journaler.log_event(get_time(), event)

        sleep(0.2)
        journaler.close()
        print('reading..')

        eq = Queue()
        reader = FileJournalerReader(eq, full_path=filename)
        reader.read_events()
        try:
            message = eq.get_nowait()
            self.assertEqual(event, message)
        except Empty:
            pass

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class TurtleCanvas(tk.Canvas):

    def __init__(self, master, *args, **kwargs):

        tk.Canvas.__init__(self, master, *args, **kwargs)
        self.pil_image = None
        self._q = Queue()
        self._cancel_current = Event()
        self.update_this()

    def begin_new(self):
        self._q = Queue()
        self._q.put((None, None))

    def queue_line(self, line, color):
        self._q.put((line, color))

    def update_this(self):
        try:
            for i in range(4000):  # draw 2000 lines at a cycle
                line, color = self._q.get_nowait()
                if line is None:
                    self.delete('all')
                    continue
                self.create_line(*line, fill=color)

        except Empty:
            pass

        self.update_idletasks()
        self.after(5, self.update_this)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class FakeBot:
    def __init__(self, *args, **kwargs):
        self.next_message_id = next_message_id()
        self.next_update_id = next_message_id()
        self.user = telegram.User(1234567890, 'Unittest')
        self.updates = Queue()

    def getUpdates(self, last_update_id, *args, **kwargs):
        updates = []
        try:
            while not self.updates.empty():
                updates.append(self.updates.get_nowait())
        except Empty:
            pass
        return updates

    def sendMessage(self, chat_id, message, *args, **kwargs):
        chat = telegram.Chat(chat_id, telegram.Chat.SUPERGROUP)
        message = telegram.Message(next(self.next_message_id), self.user,
                         datetime.datetime.now(), chat)
        return message

    def sendSticker(self, chat_id, *args, **kwargs):
        pass

    def sendLocation(self, chat_id, *args, **kwargs):
        pass

    def add_update(self, chat_id, text):
        chat = telegram.Chat(chat_id, telegram.Chat.SUPERGROUP)
        user = telegram.User(1234, 'test')
        message = telegram.Message(next(self.next_message_id), user,
                                   datetime.datetime.now(), chat, text=text)
        update = telegram.Update(next(self.next_update_id), message=message)
        self.updates.put_nowait(update)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class CarCommandHandler(WebSocketHandler):
    need_background = True

    def connect_handler(self, request):
        self.car_id = int(request.match_info['car_id'])
        self.car = core.models.Car.objects.get(id=self.car_id)
        print('websocket connection started for car ID', self.car_id)

        self.command_queue = Queue()

    async def process_msg(self, msg_text: str):
        # print('Got', msg_text, now())
        self.command_queue.put(msg_text)

    async def background(self, ws: web.WebSocketResponse):
        commander = car_connector.Commander(self.car)

        while not ws.closed:
            try:
                command = self.command_queue.get_nowait()
                commander.send_command(command)
                ws.send_str(command)
                # print('Response:', response, now())
                self.command_queue.task_done()
            except Empty:
                await asyncio.sleep(0.01)
        print('Close background for car ID', self.car_id)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class ThreadHandler():
    """
    Class for running calculations in a seperate thread
    """
    def __init__(self):
        self._resultsQueue = Queue()
        self._currentThreadID = 0
        self._currentCalculationType = None
        self._currentResult = None
        
    def startCalculation(self, calculationType, args):
        """
        Creates a WorkerThread to carry out func(*args). Will cause any
        previous still running calculations to be cancelled
        """

        if calculationType == Model.EXP:
            function = exponentialModelAnalysis
        elif calculationType == Model.POW:
            function = powerLawModelAnalysis
        elif calculationType == Model.WEI:
            function = weibullModelAnalysis

        self._currentThreadID += 1
        self._currentCalculationType = calculationType
        newThread = WorkerThread(function, args, self._calculationFinished, self._resultsQueue, self._currentThreadID)
        newThread.setDaemon(True)
        newThread.start()
        
    def _calculationFinished(self):
        """
        Called internally by the WorkerThreads. If the calculation was cancelled
        the result is ignored, otherwise if it ended in an error the result type is changed to error,
        and the result of the calculation is stored in _currentResult ready for retrieval
        """
        threadID, results = self._resultsQueue.get_nowait()
        if threadID == None:
            self._currentResult = ("Error",results)
        elif threadID == self._currentThreadID:
            self._currentResult = (self._currentCalculationType,results)
            
    def cancelLastCalculation(self):
        """
        Tells the ThreadHandler to cancel the last calculation
        At the moment this involves leaving the calculation to run and
        ignoring the result when it is returned
        """
        self._currentThreadID += 1
    
    def getCurrentCalculationResult(self):
        """
        Returns the result of the last calculation if finished
        otherwise returns None
        """
        if self._currentResult is not None:
            result = self._currentResult
            self._currentResult = None
            return result
        else:
            return None

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
class PeekableIterator(object):
    def __init__(self, stream):
        self._stream = iter(stream)
        self._peeked = Queue()

    def __iter__(self):
        return self

    def __next__(self):
        try:
            return self._peeked.get_nowait()
        except Empty:
            return next(self._stream)

    def peek(self, n=1):
        peeked = tuple(islice(self, None, n))
        put = self._peeked.put_nowait
        for item in peeked:
            put(item)
        return peeked

    def lookahead_iter(self):
        while True:
            yield from self.peek(1)
            try:
                next(self)
            except StopIteration:
                break

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import get_nowait [as 别名]
    def run(self):

        ON_POSIX = 'posix' in sys.builtin_module_names

        def enqueue_output(out, queue):
            for line in iter(out.readline, b''):
                queue.put(line)
            out.close()


        commands = self.make_gatt_commands()
        proc = subprocess.Popen([commands],stdout=subprocess.PIPE, stdin=subprocess.PIPE, close_fds=ON_POSIX, shell=True)


        q = Queue()
        t = Thread(target=enqueue_output, args=(proc.stdout, q))
        t.daemon = True # thread dies with the program
        t.start()

        while True:
            try:
                line = q.get_nowait().decode()

                # print(str(datetime.datetime.now()), line.decode())

                self._parse_notification(line)

            except Empty:
                # print('no output yet')
                pass
            time.sleep(1)