Python Queue.task_done方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class FlashForgeIO(Thread):
	_instance = None
	
	def __init__(self, reconnect_timeout=5, vendorid=0x2b71, deviceid=0x0001):
		Thread.__init__(self)
		self.queue = Queue()
	
	def run(self):
		app.logger.info('[FlashforgeIO] started')
		ff = FlashForge()
		while True:
			app.logger.info('[FlashForgeIO] Waiting for next GCode command')
			command = self.queue.get()
			if not command.endswith('\n'):
				command += '\n'
			socketio.emit('terminal', '> ' + command)
			app.logger.info('[FlashForgeIO]  Executing command: {0}'.format(command))
			
			try:
				data = ff.gcodecmd(command)
				if not data.endswith('\n'):
					data += '\n'
				socketio.emit('terminal', '< ' + data)
				self.queue.task_done()
			except FlashForgeError as error:
				socketio.emit('terminal', 'COMERROR: {0}'.format(error.message))

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [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 task_done [as 别名]
def multiget(client, keys, **options):
    """
    Executes a parallel-fetch across multiple threads. Returns a list
    containing :class:`~riak.riak_object.RiakObject` instances, or
    3-tuples of bucket, key, and the exception raised.

    :param client: the client to use
    :type client: :class:`~riak.client.RiakClient`
    :param keys: the bucket/key pairs to fetch in parallel
    :type keys: list of two-tuples -- bucket/key pairs
    :rtype: list
    """
    outq = Queue()

    RIAK_MULTIGET_POOL.start()
    for bucket, key in keys:
        task = Task(client, outq, bucket, key, options)
        RIAK_MULTIGET_POOL.enq(task)

    results = []
    for _ in range(len(keys)):
        if RIAK_MULTIGET_POOL.stopped():
            raise RuntimeError("Multi-get operation interrupted by pool "
                               "stopping!")
        results.append(outq.get())
        outq.task_done()

    return results

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
    def lookup_statuses(self, min_status, codename, hardware):
        """Scrape statuses/info in from launchpad.net mirror pages"""
        while (self.got["data"] < self.status_num) and self.ranked:
            data_queue = Queue()
            num_threads = self.__queue_lookups(codename, hardware, data_queue)
            if num_threads == 0:
                break
            # Get output of all started thread methods from queue
            progress_msg(self.got["data"], self.status_num)
            for _ in range(num_threads):
                try:
                    # We don't care about timeouts longer than 7 seconds as
                    # we're only getting 16 KB
                    info = data_queue.get(block=True, timeout=7)
                except Empty:
                    pass
                else:
                    data_queue.task_done()
                    if info[1] and info[1]["Status"] in self.status_opts:
                        self.urls[info[0]].update(info[1])
                        self.got["data"] += 1
                        self.top_list.append(info[0])
                        progress_msg(self.got["data"], self.status_num)
                    else:
                        # Remove unqualified results from ranked list so
                        # queueing can use it to populate the right threads
                        self.ranked.remove(info[0])

                if (self.got["data"] == self.status_num):
                    break

            data_queue.join()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class Banker:
    number_of_bankers = 0
    active_bankers = []

    def __init__(self):
        self.q = Queue()
        self.currently_serving = None
        self.active = True
        self.number = Banker.number_of_bankers = Banker.number_of_bankers + 1
        Banker.active_bankers.append(self)

    def serve(self, person):
        # serve client - here we only pretend to do work by calling sleep
        time.sleep(person.time_for_service)
        Observer.notify()

    def do_banky_stuff(self):
        # take the person at top of own queue and serve it
        while self.active:
            item = self.q.get()
            self.currently_serving = item
            self.serve(item)
            self.currently_serving = None
            self.q.task_done()

    def stop(self):
        print("Banker no. " + str(self.number) + ": I quit this damn job!")
        Banker.active_bankers.remove(self)
        self.active = False
        Regulator.spread_queue(self)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
    def _port_ping(self, hosts: Queue, interface: str, results: set):
        self.logger.debug("{}: Starting TCP SYN ping thread.".format(threading.current_thread().name))

        while True:
            ip = hosts.get()  # type: IPAddress
            ip_str = str(ip)

            # Send SYN with random Src Port for each Dst port
            for dstPort in self.portstoscan:
                srcPort = random.randint(1025, 65534)
                resp = sr1(IP(dst=ip_str) / TCP(sport=srcPort, dport=dstPort, flags=ScapyTCPFlag.SYN), timeout=1,
                           verbose=False,
                           iface=interface)
                if resp and resp.haslayer(TCP):
                    if resp[TCP].flags == (TCPFlag.SYN | TCPFlag.ACK) or resp[TCP].flags == (TCPFlag.RST | TCPFlag.ACK):
                        # Send Reset packet (RST)
                        send(IP(dst=ip_str) / TCP(sport=srcPort, dport=dstPort, flags=ScapyTCPFlag.RST),
                             iface=interface, verbose=False)

                        # We know the port is closed or opened (we got a response), so we deduce that the host exists
                        node = NetworkNode()
                        node.ip = ip
                        node.mac = EUI(resp.src)
                        node.host = resolve_ip(resp[IP].src)
                        results.add(node)

                        self.logger.debug(
                            "Found a live host by pinging port {port_nbr}: {live_host}.".format(port_nbr=dstPort,
                                                                                                live_host=str(node)))

                        # We don't need to test the other ports. We know the host exists.
                        break

            hosts.task_done()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class TaskManager:

    # Initialise the object
    def __init__(self):
        self.q = Queue(maxsize=0)
        thread = threading.Thread(target=self.loop)
        thread.start()

    # Continuously loop through tasks that need to be completed
    def loop(self):
        # General Application loop
        while True:
            mytime = str(time.time())
            thistask = self.q.get()
            # Lets check what type of task we have
            for case in Switch(thistask['type']):
                # Create a new node
                if case('parse_submission'):
                    cherrypy.config['model'].parse_submission(thistask['data'])
                    break
                # A test so we can easily track things
                if case('test'):
                    break
            logging.debug("COMPLETED "+thistask['type']+" UID: "+thistask['uid']+" START:"+thistask['start']+" FIN: "+mytime)
            self.q.task_done()
    
    # Add a new task to the queue in the form of: {'type':'create_node','data':data}
    def add(self, task):
        task['uid'] = str( uuid.uuid1() )
        logging.debug('ADDED NEW TASK TO THE QUEUE: '+task['uid'])
        task['start'] = str(time.time())
        self.q.put(task)
        return task['uid']

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class Cloner:
    '''A worker with its own queue for cloning repositories located at the
    submitted URLs.

    '''
    def __init__(self, handler):
        '''Build a new cloner. The handler argument should be a function that
        accepts two arguments, repo and code.

        '''
        self.work_queue = Queue()
        self.handler = handler
        self.worker = Thread(target=self._work)
        self.worker.setDaemon(True)
        self.worker.start()
    
    def add_work(self, repo):
        '''Add a repository to be cloned.'''
        self.work_queue.put(repo)
        
    def _work(self):
        '''Loop forever, pulling work off the work_queue to clone github
        repositories and calling the handler upon each finished
        clone.

        '''
        while True:
            if not self.work_queue.empty():
                next_url = self.work_queue.get()
                code = mkdirs_clone(next_url).wait()
                self.work_queue.task_done()
                self.handler(next_url, code)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class MessageDispatcher(threading.Thread):
    """Simple queue based message dispatcher."""

    def __init__(self):
        threading.Thread.__init__(self)

        self._message_queue = Queue()
        self._stop_event = threading.Event()

    def start(self):
        """ Starts the dispatcher.  """
        if threading.currentThread() == self:
            raise RuntimeError("Cannot call start on the thread itself.")
        threading.Thread.start(self)

    def stop(self):
        """Stops processing the queue.

        Doesn't ensure that queue is empty before stop. Message are thrown away.
        Look at _message_queue.join() in future.
        """
        if threading.currentThread() == self:
            raise RuntimeError("Cannot call start on the thread itself.")
        self._stop_event.set()

    def queue_message(self, message):
        """Queue a Message to be dispatched.

        Args:
            message: message to be dispatched. Type: Message.
        """
        if type(message) is not Message:
            raise TypeError("Only objects of type Message can be queued.")
        if message.signal.receivers:
            logger.info("MessageDispatcher: added message: " +
                        message.kwargs.__str__())
            logger.debug("MessageDispatcher: receivers: " +
                         message.signal.receivers.__str__())
            self._message_queue.put(message)
        else:
            logger.info("MessageDispatcher: skipped message: " +
                        message.kwargs.__str__())

    def run(self):
        """Worker for the message dispatcher thread."""
        while self._stop_event.is_set() is False:
            while self._message_queue.empty() is False:
                message = self._message_queue.get()

                # It is possible that we a signal is dispatched to a receiver
                # not present during enqueue of the message, how ever is present
                # now. YAGNI call for the moment.
                logger.debug("MessageDispatcher: dispatch message: " +
                             message.kwargs.__str__())
                logger.debug("MessageDispatcher: receivers: " +
                             message.signal.receivers.__str__())
                message.send()
                logger.debug("MessageDispatcher: message dispatched!")
                self._message_queue.task_done()
            self._stop_event.wait(0.01)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class Command(BaseCommand):
    help = "Update the number of words to translate in every task"

    queue = Queue()
    num_threads = 80
    threads = []

    def handle(self, *args, **options):
        self.queue = Queue()
        self.stdout.write('Reading tasks...')
        for it in TransTask.objects.all():
            self.queue.put({'id': it.id, 'num': get_num_words(it.object_field_value)})

        for i in range(self.num_threads):
            t = Thread(target=self.worker_elements)
            t.start()
            self.threads.append(t)
        self.stdout.write("Waiting for empty queue")
        self.queue.join()
        self.stop_threads()

    def stop_threads(self):
        for t in self.threads:
            t.join()
        self.stdout.write('Exiting main thread')

    def worker_elements(self):
        while not self.queue.empty():
            try:
                item = self.queue.get(timeout=2)
                TransTask.objects.filter(pk=item['id']).update(number_of_words=item['num'])
            except Empty:
                break
            finally:
                self.queue.task_done()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class SockSendThread(threading.Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None):
        super(SockSendThread, self).__init__(group=group, target=target, name=name)

        (self.conn, self.c) = args
        self.q = Queue()

    def run(self):
        while not self.c.quitf:
            try:
                message = self.q.get(block=False)
            except queue.Empty:
                time.sleep(0.1)
                continue
            try:
                #print("Sent data on socket: " + str(message))
                self.conn.send(message)
                self.q.task_done()
            except Exception as e:
                if '35' in str(e):
                    pass
                else:
                    print(e)
                    break
        # came out of loop
        self.conn.close()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class Sound(hass.Hass):

  def initialize(self):
    
    # Create Queue
    self.queue = Queue(maxsize=0)

    # Create worker thread
    t = Thread(target=self.worker)
    t.daemon = True
    t.start()
    
    self.event = Event()
    
  def worker(self):
    active = True
    while active:
      try:
        # Get data from queue
        data = self.queue.get()
        if data["type"] == "terminate":
          active = False
        else:
          # Save current volume
          volume = self.get_state(self.args["player"], attribute="volume_level")
          # Set to the desired volume
          self.call_service("media_player/volume_set", entity_id = self.args["player"], volume_level = data["volume"])
          if data["type"] == "tts":
            # Call TTS service
            self.call_service("tts/amazon_polly_say", entity_id = self.args["player"], message = data["text"])
          if data["type"] == "play":
            netpath = netpath = 'http://{}:{}/local/{}/{}'.format(self.args["ip"], self.args["port"], self.args["base"], data["path"])
            self.call_service("media_player/play_media", entity_id = self.args["player"], media_content_id = netpath, media_content_type = data["content"])

          # Sleep to allow message to complete before restoring volume
          time.sleep(int(data["length"]))
          # Restore volume
          self.call_service("media_player/volume_set", entity_id = self.args["player"], volume_level = volume)
          # Set state locally as well to avoid race condition
          self.set_state(self.args["player"], attributes = {"volume_level": volume})
      except:
        self.log("Error")
        self.log(sys.exc_info())

      # Rinse and repeat
      self.queue.task_done()
      
    self.log("Worker thread exiting")
    self.event.set()
       
  def tts(self, text, volume, length):
    self.queue.put({"type": "tts", "text": text, "volume": volume, "length": length})
    
  def play(self, path, content, volume, length):
    self.queue.put({"type": "play", "path": path, "content": content, "volume": volume, "length": length})

  def terminate(self):
    self.event.clear()
    self.queue.put({"type": "terminate"})
    self.event.wait()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class Comparisons:
    def __init__(self, query):
        self.workers = Queue()
        self.query = query

    def __call__(self):
        return self.run()

    def run(self):
        slaves_thread = Thread(target=self.slaves)
        slaves_thread.start()
        return self.master()

    def master(self):
        count = 0
        while True: # not workers.empty()
            worker = self.workers.get()
            item = worker.join()
            self.workers.task_done()
            if item is not None:
                json_item = json.dumps(worker.join())
                yield json_item
            elif item is False:
                print('All done!!')
                break

    def slaves(self):
        cars = GetCars(self.query)
        for car in cars():
            car_appraisal = AppraiseCar(car)
            worker = ThreadWithReturnValue(target=car_appraisal.run)
            worker.start()
            self.workers.put(worker)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import task_done [as 别名]
class MangaUpdateWorker(QtCore.QThread):
    data_updated = QtCore.pyqtSignal(object)

    def __init__(self, parent):
        super(MangaUpdateWorker, self).__init__()
        self._parent = parent
        self.q = Queue()
        self.thread().daemon = True
        self._abort = False

    def abort(self):
        self._abort = True

    def push(self, title):
        self.q.put(title)

    def run(self):
        while not self.q.empty() and not self._abort:
            title = self.q.get()
            self.update_manga(title)
            self.q.task_done()
        self.data_updated.emit('\n{} Update Completed {}'.format('-' * 21, '-' * 21))

    def update_manga(self, title):
        factor = 60 - (len(title) + 2)
        self.data_updated.emit('{}: {}\n'.format(title, '-' * factor))
        chapters = Library.update_manga_by_title(title)
        if len(chapters) > 0:
            for chapter in chapters:
                self.data_updated.emit('     {}\n'.format(chapter.title))

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

	server_version = "Extremon/0.1"

	def do_GET(self):
		self.outq=Queue(maxsize=10)
		self.running=True
		self.server.add_consumer(self)

		self.send_response(200)
		self.send_header("Content-type", "text/plain")
		self.end_headers()
		self.running=True

		try:
			while self.running:
				try:
					self.wfile.write(self.outq.get())
					self.outq.task_done()
				except error:
					self.running=False
		finally:
			self.server.remove_consumer(self)	

	def write(self,data):
		try:
			self.outq.put(data,block=False)
		except Full:
			pass