Python Queue.empty方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
class FakeConsumer(BrightsideConsumer):
    """The fake consumer is a test double for a consumer wrapping messaging middleware.
        To use it, just add BrighsideMessage(s) to the queue and the call receive to pop
        then off the stack. Purge, will clean the queue
    """
    def __init__(self):
        self._queue = Queue()
        self._acknowledged_message = None

    def acknowledge(self, message):
        self._acknowledged_message = message

    def has_acknowledged(self, message):
        return (self._acknowledged_message is not None) and (self._acknowledged_message.id == message.id)

    @property
    def queue(self):
        return self._queue

    def purge(self):
        while not self._queue.empty():
            self._queue.get(block=False)

        assert self._queue.empty()

    def receive(self, timeout: int):
        return self._queue.get(block=True,timeout=timeout)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [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 empty [as 别名]
def main(filename):
    username = input('User: ')      # get username, will be echoed on the terminal
    password = getpass.getpass()    # get password, will not be echoed on the terminal, some IDE restrictions can apply

    print(time_stamp(), ': script started')

    task_queue = Queue()

    new_task = Task(task_queue)
    new_task.read(filename)

    while not task_queue.empty():
        host_queue = Queue()
        log_queue = Queue()
        task_block = task_queue.get()
        for host_ip in task_block['hosts']:
            host_queue.put(host_ip)
        config_list = task_block['tasks']

        while not host_queue.empty():

            for x in range(50):
                worker = ExecuteTask(host_queue, config_list, log_queue, username, password, mode=task_block['mode'])
                worker.daemon = True
                worker.start()

        host_queue.join()

        while not log_queue.empty():
            st = log_queue.get()
            print(st)

    print(time_stamp(), ': script stopped')

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
class GridMap():
    """
    Map class 
	"""
    def __init__(self, width, height, size):
        self.width = width
        self.height = height
        self.cellSize = size
        self.__map = np.zeros((self.width,self.height))
        self.__drawQueue = Queue()
        
        self.linear = Linear()

        
    def update(self, x, y, theta):
        self.__map[x][y] = 1
        self.__drawQueue.put((x,y))
        
        #theta = round(theta, 2)
        #self.linear.update(x, y, theta)
        
    def getPoints(self):
        points = []
        while not self.__drawQueue.empty():
            points.append(self.__drawQueue.get())
        
        return points
        
    def drawPoints(self, drawFunc):
        """
        draw the points by callback function drawFunc
        """
        if self.__drawQueue.empty():
            return 
        drawFunc(self.__drawQueue.get())

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
 def zigzagLevelOrder(self, root):
     if root == None:
         return []
     else:
         q = Queue()
         q.put(root)
         q.put("#")
         levelOrderTraversal = []
         level = []
         levelNo = 0
         while q.empty() == False:
             node = q.get()
             if node == "#":
                 if q.empty() == False:
                     q.put("#")
                 if levelNo == 0 or levelNo % 2 == 0:    
                     levelOrderTraversal.append(level)
                 else:
                     levelOrderTraversal.append(level[::-1])
                 level = []
                 levelNo += 1
             else:
                 level.append(node.val)
                 if node.left:
                     q.put(node.left)
                 if node.right:
                     q.put(node.right)
                     
         return levelOrderTraversal

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
def check_if_pingable(ip_list):
    """
    Check what IP addresses from the list are reachable
    :param ip_list: list of IP addresses to ping
    :return: list of reachable and unreachable hosts
    """

    queue_ip = Queue()
    queue_reachable = Queue()
    queue_unreachable = Queue()

    reachable = []
    unreachable = []

    for ip in ip_list:
        queue_ip.put(ip)

    while not queue_ip.empty():
        for x in range(50):
            worker = Ping(queue_ip, queue_reachable, queue_unreachable)
            worker.daemon = True
            worker.start()

    queue_ip.join()

    while not queue_reachable.empty():
        reachable.append(queue_reachable.get())

    while not queue_unreachable.empty():
        unreachable.append(queue_unreachable.get())

    return reachable, unreachable

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
 def levelOrderBottom(self, root):
     if root == None:
         return []
     else:
         q = Queue()
         q.put(root)
         q.put("#")
         levelOrderTraversal = []
         level = []
         stack = []
         
         while q.empty() == False:
             node = q.get()
             if node == "#":
                 if q.empty() == False:
                     q.put("#")
                 stack.append(level)
                 level = []
             else:
                 level.append(node.val)
                 if node.left:
                     q.put(node.left)
                 if node.right:
                     q.put(node.right)
                     
         while stack:
             levelOrderTraversal.append(stack.pop())
             
         return levelOrderTraversal

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
    def generer_graph(self):
        """Génère le graph des sorties.

        Le graph est un dictionnaire comprenant en clé un tuple
        (origine, destination) et en valeur la liste des sorties
        nécessaires pour s'y rendre.

        L'algorithme Dijkstra est utilisé.

        """
        graph = {}
        aretes = {}
        sorties = {}

        # On remplit le chemin avec toutes les liaisons
        for salle in self.salles.values():
            origine = salle.mnemonic
            aretes[origine] = []
            for sortie in salle.sorties:
                destination = sortie.salle_dest.mnemonic
                aretes[origine].append(destination)
                sorties[origine, destination] = sortie.nom

        # Population des chemins dans le graph
        for origine in range(1, len(self.salles) + 1):
            origine = str(origine)
            for destination in range(1, len(self.salles) + 1):
                destination = str(destination)
                if origine == destination:
                    continue

                frontier = Queue()
                frontier.put(origine)
                origines = {origine: None}
                while not frontier.empty():
                    actuel = frontier.get()
                    if actuel == destination:
                        break

                    for fils in aretes[actuel]:
                        if fils not in origines:
                            frontier.put(fils)
                            origines[fils] = actuel


                # Recherche la liste des sorties
                parent = Queue()
                parent.put(destination)
                chemin = []
                while not parent.empty():
                    actuel = parent.get()
                    precedent = origines[actuel]
                    sortie = sorties[precedent, actuel]
                    chemin.insert(0, sortie)
                    if precedent != origine:
                        parent.put(precedent)

                graph[origine, destination] = chemin

        self.graph = graph

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
class InsnPool:
    def __init__(self, proc, max_threads = None):
        self.numThreads = 0
        if max_threads is None:
            max_threads = multiprocessing.cpu_count() * 5
        self.max_threads = max_threads
        self.queue = Queue()
        self.proc = proc

        # A lock used to wake up the polling thread if asynchronous
        self.lock = threading.Semaphore()

    def query(self, insn):
        self.queue.put(insn)

    def signal(self):
        self.numThreads -= 1
        if self.has_cycled():
            # Wake up the polling thread if batch is done processing
            self.lock.release()

    def has_cycled(self):
        return self.numThreads == 0

    def has_finished(self):
        return self.has_cycled() and self.queue.empty()

    def poll_all(self, blocking = True, callback = None):
        if not blocking and callback is None:
            raise ValueError("If called in a non blocking way you must provide a callback function.")

        def poll_all_impl():
            while not self.has_finished():  # Wait for all threads to process
                self.poll()
                self.lock.acquire()  # Pauses the current thread and waits till batch is processed
            if callback:
                callback()

        if blocking:
            poll_all_impl()
        else:
            thread = threading.Thread(daemon = True, target = poll_all_impl)
            thread.start()

    def poll(self):
        # Batch processing, we only start a new batch when the old
        # one has finished. It is only possible to jump to a location once.
        if not self.has_cycled(): return

        locations = set()
        while self.numThreads < self.max_threads and not self.queue.empty():
            insn = self.queue.get_nowait()
            if insn.pc in locations:
                continue
            else:
                locations.add(insn.pc)

            insn.start()
            self.numThreads += 1

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
class SLIPEncoderDecoder:
	""" This class acts as an intermediary to a socket, it sends data packets in
	    SLIP format and processes incoming (in SLIP) to normal datagrams
	"""
	def __init__(self, socket):
		self.socket = socket
		self.inPacketBuf = Queue()
		self.workingRetrievalBuffer = None

	def sendPacket(self, packet):
		tempSLIPBuffer = bytearray()  
		tempSLIPBuffer.append(SLIP_END)  
		for i in packet:  
			if i == SLIP_END:  
				tempSLIPBuffer.append(SLIP_ESC)  
				tempSLIPBuffer.append(SLIP_ESC_END)  
			elif i == SLIP_ESC:  
				tempSLIPBuffer.append(SLIP_ESC)  
				tempSLIPBuffer.append(SLIP_ESC_ESC)  
			else:  
				tempSLIPBuffer.append(i)  
		tempSLIPBuffer.append(SLIP_END)
		self.socket.send(bytes(tempSLIPBuffer))

	def getPacket(self):
		if self.inPacketBuf.empty():
			self.retrieveData()
		return self.inPacketBuf.get()

	def dataWaiting(self):
		return not self.inPacketBuf.empty()

	def retrieveData(self):
		workingBuf = self.workingRetrievalBuffer
		while self.inPacketBuf.empty():
			newData = self.socket.recv(SOCKET_BUF_SIZE)
			newData = iter(newData)
			for i in newData:
				if i == SLIP_END:
					if workingBuf is None:
						workingBuf = bytearray()
					else:
						self.inPacketBuf.put(bytes(workingBuf))
						workingBuf = None
					
				elif i == SLIP_ESC:
					i = newData.__next__()
					if i == SLIP_ESC_END:
						workingBuf.append(SLIP_ESC)
					elif i == SLIP_ESC_ESC:
						workingBuf.append(SLIP_ESC)
					else:
						raise(SLIPException("Unexpected byte %x following ESCAPE character"%i))
				else:
					workingBuf.append(i)
		self.workingRetrievalBuffer = workingBuf

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
class Pipe:
    """
    In-memory file-like object that may be read and written by co-operating
    threads.
    Note: no readline() etc. is provided - only read and write.
    Note: read() will block waiting for more to be read, until close() is
    called.
    """
    def __init__(self):
        self.buffer = Queue()
        self.closed = False

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

    def write(self, s):
        for ch in s:
            self.buffer.put(ch)

    def pending(self):
        return not self.buffer.empty()

    def read(self, size=None):
        ret = ""
        count = 0
        while size is None or len(ret) < size:
            if self.buffer.empty() and self.closed:
                break
            if count > 50:
                raise Exception("Timed out waiting for read that never ended.")
            count += 1
            ret += self.buffer.get(timeout=0.1)
        return ret

    def readline(self):
        ret = ""
        count = 0
        c = "x"
        while c not in ("\n", ""):
            if self.buffer.empty() and self.closed:
                break
            if count > 50:
                raise Exception("Timed out waiting for read that never ended.")
            count += 1
            c = self.buffer.get(timeout=0.1)
            ret += c
        return ret

    def flush(self):
        pass

    def close(self):
        self.closed = True

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
class Display:
    def __init__(self, rows, columns, ports=None):
        self.matrix = []
        self.ports = ports
        self.rows = rows
        self.columns = columns
        for column in range(0, self.columns):
            column = []
            for row in range(0, self.rows):
                column.append(0)
            self.matrix.append(column)
        self.buffer = Queue()
        self.separator = [0 for _ in range(0, self.rows)]

    def write(self, text):
        for char in text:
            if not self.buffer.empty():
                self.buffer.put(self.separator)
            character = Character(char)
            matrix = character.matrix
            columns = len(matrix[0])
            rows = len(matrix)
            for column_index in range(0, columns):
                column = []
                for row_index in range(rows, 0, -1):
                    column.append(matrix[row_index - 1][column_index])
                self.buffer.put(column)
        for _ in range(0, self.columns):
            self.buffer.put(self.separator)

    def print_current_buffer(self):
        while not self.buffer.empty():
            column = self.buffer.get()
            for item in column:
                print('{}'.format(item), end=' ')
                time.sleep(0.05)
            print()

    def show(self):
        if self.ports:
            port_adapter.setup(self.ports)
        while not self.buffer.empty():
            column = self.buffer.get()
            for pos in range(1, self.columns):
                self.matrix[pos - 1] = self.matrix[pos]
            self.matrix[self.columns - 1] = column
            if self.ports:
                for column_index in range(0, self.columns):
                    for row_index in range(0, self.rows):
                        item = self.matrix[column_index][row_index]
                        port = self.ports[column_index][row_index]
                        port_adapter.output(port, item)
            for item in column:
                print('{}'.format(item), end=' ')
            print()
            time.sleep(0.2)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
	def test_dequeue(self):
		q = Queue()
		q.enqueue('a')
		last = q.dequeue()
		self.assertEqual('a', last.data)
		self.assertTrue(q.empty())
		q.enqueue('a')
		q.enqueue('b')
		q.dequeue()
		self.assertEqual('b', q.first.data)
		self.assertFalse(q.empty())

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

    def __init__(self):
        self.tx_fifo = Queue(maxsize=8)
        self.rx_fifo = Queue(maxsize=8)
        self.tx_thread = Thread(target=self.tx_worker, daemon=True)
        self.tx_thread.start()
        self.rx_thread = Thread(target=self.rx_worker, daemon=True)
        self.rx_thread.start()
        self.rx_overrun = 0
        self.rx_lock = Lock()

    def read_uart_data(self) -> int:
        c = self.rx_fifo.get(block=True)
        return int(c)

    def end(self):
        while not self.tx_fifo.empty():
            pass

    def write_uart_data(self, data: int):
        self.tx_fifo.put(data)

    def read_uart_status(self) -> int:
        with self.rx_lock:
            tx_free = bool(self.tx_fifo.not_full)
            tx_empty = bool(self.tx_fifo.empty())
            rx_ready = bool(self.rx_fifo.not_empty)
            rx_overrun = bool(self.rx_overrun)
            self.rx_overrun = 0

        return tx_free | tx_empty << 1 | rx_ready << 2 | rx_overrun << 3

    def read_uart_baud(self) -> int:
        return 0

    def write_uart_baud(self, data: int):
        pass

    def tx_worker(self):
        while True:
            c = self.tx_fifo.get(block=True)
            print(chr(c), end='')
            self.tx_fifo.task_done()

    def rx_worker(self):
        while True:
            try:
                getch = _find_getch()
                c = getch()
                self.rx_fifo.put(ord(c[0]), block=False)
            except Queue.QueueFull:
                with self.rx_lock:
                    self.rx_overrun = True

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import empty [as 别名]
def handleProcessOutputBytewise(proc, fhOut, fhErr):
	q = Queue()
	errQ = Queue()
	
	t = Thread(target=enqueue_output, args=(proc.stdout, q))
	t.daemon = True # thread dies with the program
	t.start()
	
	tErr = Thread(target=enqueue_output, args=(proc.stderr, errQ))
	tErr.daemon = True # thread dies with the program
	tErr.start()
	
	writeEveryXSecs = 1.0 / 10
	lastWrite = time.time()
	
	chars = []
	errChars = []
	
	while 1:
		try:
			char = q.get(timeout=.1)
		except Empty:
			pass
		else: # got line
			chars.append(char)
		
		if not errQ.empty():
			try:
				while 1:
					errChar = errQ.get_nowait()
					errChars.append(errChar)
			except Empty:
				pass
		
		if time.time() - lastWrite > writeEveryXSecs:
			if chars:
				fhOut(''.join(chars))
				del chars[:]
				
			if errChars:
				fhErr(''.join(errChars))
				del errChars[:]
			
			QtGui.QApplication.instance().processEvents()
			
			# Process terminated?
			exitCode = proc.poll()
			
			if (exitCode is not None) and (not t.is_alive()) and (not tErr.is_alive()) and q.empty() and errQ.empty():
				return exitCode