Python Queue.put_nowait方法代码示例

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

    def __init__(self, logger):
        super().__init__()
        self.queue = Queue(5)
        self.logger = logger

    def handle_event(self, event):
        self.logger.debug("Received event")
        args = event.args

        callback = args["callback"]
        callback_args = args["callback_args"]
        result = args["result"]

        callback(result, *callback_args)

    def fetch(self, albuminfo, callback, callback_args=[]):
        artist = albuminfo["artist"]
        album = albuminfo["album"]

        self.logger.debug("Fetch {} - {}", artist, album)
        self.queue.put_nowait({
            "albuminfo": albuminfo,
            "callback": callback,
            "callback_args": callback_args})

    def tick(self, tick):
        return False

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
class Kernel(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.programsQueue = Queue()
        self.isFirstLoad = True
        self.shouldShutDown= False

    def initializeKernel(self, clock, programloader, scheduler):
        self.programLoader = programloader
        self.scheduler = scheduler
        self.clock = clock

    def load(self, program):
        # Sets a program that the program loader will load to the memory
        self.programsQueue.put_nowait(program)

    def run(self):
        Thread.run(self)

        while not self.shouldShutDown:
            if not self.programsQueue.qsize() == 0:
                program = self.programsQueue.get_nowait()
                self.isFirstLoad = len(self.programLoader.pcbTable.pcbs) == 0
                self.programLoader.load(program)
                if self.isFirstLoad:
                    self.scheduler.setNextPcbToCpu()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
def breadthFirstExplore(maze,x,y):
    '''explore a maze in a breadth first manner'''
    qLen=len(maze[0][:])*len(maze)
    pointQueue=Queue(qLen)
    pointQueue.put_nowait((x,y,qLen))
    goal=None
    maze[x][y]=qLen
    while not pointQueue.empty():
        i=pointQueue.get_nowait()
        x=i[0]
        y=i[1]
        k=i[2]
        val=getMazeValue(maze, x, y)
        if val==2:
            goal=(x,y)
            return goal
        else:
            maze[x][y]=k
        #explore the neighborhood
        a=getMazeValue(maze, x+1, y)
        b=getMazeValue(maze, x, y+1)
        c=getMazeValue(maze, x-1, y)
        d=getMazeValue(maze, x, y-1)
        if a==0 or a ==2:
            pointQueue.put((x+1,y,k-1))
        if b==0 or b==2:
            pointQueue.put((x,y+1,k-1))
        if c==0 or c==2:
            pointQueue.put((x-1,y,k-1))
        if d==0 or d==2:
            pointQueue.put((x,y-1,k-1))
    return goal  

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
class TestCommandEvents(unittest.TestCase):

    def setUp(self):
        domain = ENVIRONMENTS['streaming'][TARGET_ENV]
        settings = read_settings(CONFIG_PATH_FOR_UNIT_TESTS, TARGET_ENV)

        self.streamer = OandaEventStreamer(domain, settings['ACCESS_TOKEN'], settings['ACCOUNT_ID'], Journaler())
        self.streamer.set_events_q(Queue()).set_heartbeat_q(Queue()).set_exception_q(Queue())
        self.streamer.set_context(OANDA_CONTEXT_EVENTS)
        self.streaming_thread = Thread(target=self.streamer.stream, args=[])

        self.command_q = Queue()
        self.listener = QueueCommandListener(self.command_q, self.streamer.on_command)
        self.command_thread = self.listener.start_thread()

        self.streaming_thread.start()

    def tearDown(self):
        if self.streamer.streaming:
            self.streamer.stop()
            self.command_thread.join(timeout=5)
            self.streaming_thread.join(timeout=5)

    def test_should_be_able_to_connect_for_receiving_streaming_account_events(self):
        self.command_q.put_nowait(COMMAND_STOP)
        self.streaming_thread.join(timeout=5)
        self.command_thread.join(timeout=5)
        self.assertFalse(self.streamer.streaming, 'streaming should have stopped, but did not')

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_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 put_nowait [as 别名]
class MockSock:
    def __init__(self, autorespond=False):
        self.sent_queue = Queue()
        self.recv_queue = Queue()
        self.closed = False
        self.timeout = 0.5
        self.autorespond = autorespond

    def gettimeout(self):
        return self.timeout 

    def close(self):
        self.closed = True

    def send(self, message):
        parsed = json.loads(message)
        self.sent_queue.put_nowait(parsed)
        if self.autorespond:
            self.recv_queue.put_nowait({'msg': RESULT, 'id': parsed['id']})

    def recv(self):
        try:
            message = self.recv_queue.get(timeout=self.timeout)
        except Empty as e:
            raise JCoreAPITimeoutException("recv timed out", e) 

        if isinstance(message, Exception):
            raise message
        return json.dumps(message)

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

    def __init__(self):
        Thread.__init__(self)
        self.running = False
        self.starting = True
        self.tasks = Queue()

    def pause(self):
        self.running = False

    def resume(self):
        self.running = True

    def stop(self):
        self.pause()
        self.starting = False

    def add(self, item):
        self.tasks.put_nowait(item)

    def run(self):
        print("事件监听start")
        while self.starting:
            if self.running:
                continue
            try:
                func, fuin, suin, iseq, content = self.tasks.get()
                print("取出队列: %s %s %s %s %s", func, fuin, suin, iseq, content)
                func(fuin, suin, iseq, content)
            except Empty:
                pass
            sleep(0.1)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
class TestQueuedCommandListener(unittest.TestCase):

    def on_command(self, command):
        self.last_command = command

    def setUp(self):
        self.command_q = Queue()
        self.listener = QueueCommandListener(self.command_q, self.on_command)
        self.last_command = None
        self.command_thread = self.listener.start_thread()

    def tearDown(self):
        if self.listener.listening:
            self.listener.force_stop()
        self.command_thread.join(timeout=2)

    def test_should_listen_to_STOP_command(self):
        self.command_q.put_nowait(COMMAND_STOP)
        self.command_thread.join(timeout=2)
        self.assertEqual(COMMAND_STOP, self.last_command)

    def test_should_stop_listening_after_STOP_command(self):
        self.command_q.put_nowait(COMMAND_STOP)
        self.command_thread.join(timeout=2)
        self.assertFalse(self.listener.listening, 'listening should have stopped, but did not')

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

    def __init__(self, logger):
        super().__init__()
        self.queue = Queue(5)
        self.logger = logger

    def handle_event(self, event):
        self.logger.debug("Received event")
        args = event.args

        callback = args["callback"]
        callback_args = args["callback_args"]
        result = args["result"]

        callback(result, *callback_args)

    def fetch(self, albuminfo, callback, callback_args=[]):
        artist = albuminfo["artist"]
        album = albuminfo["album"]

        self.logger.debug("Fetch {} - {}", artist, album)
        self.queue.put_nowait({
            "albuminfo": albuminfo,
            "callback": callback,
            "callback_args": callback_args})

    def fetch_mosaic(self, playlist, callback, callback_args=[]):
        ''' Takes a sequence of set of '''
        raise

    def tick(self, tick):
        return False

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
class CallbackMulti:
    """ Call callback whenever a result is available. """

    def __init__(self, future, cb, *args):
        super(CallbackMulti, self).__init__()
        self.future = future
        self.cb = cb
        self._results = {}
        self._reuslt_q = Queue()
        self.job_count = 0
        self.finished_job_count = 0
        glob_executor.submit(self._wait_result, cb, *args)

    def set_result(self, args, result_type, result):
        self._results[args] = {result_type: result}
        if result:
            self._reuslt_q.put_nowait((args, self._results[args]))
        else:
            # result == None, adding a job to _results
            self.job_count += 1

    def _wait_result(self, callback, *args):
        while True:
            arg_result = self._reuslt_q.get()
            callback(arg_result, *args)
            self.finished_job_count += 1
            if self._all_job_done():
                self.future.finished.set()
                break

    def _all_job_done(self):
        return self.finished_job_count == self.job_count

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
	def findFirstTri(vert, lastMFace, mirrorMesh, searchData) :
		#
		#	Itterates through all faces in the mirror mesh and tests for intersection, first intersecting adjacent face connected to the initial search face is returned
		#
		
		faceQueue = Queue()
		#Tag keep track on what face we have tested / in queue. False for not tested
		taggedFaces = []
		
		#Start testing from the initial face!
		lastMFace.tag = True
		faceQueue.put_nowait(lastMFace)
		taggedFaces.append(lastMFace)
		
		while not faceQueue.empty() :
			face = faceQueue.get_nowait()
			mDat = MirrorMesh.triIntersection(vert.co, face)
			if mDat is not None and mDat._intersected :
				searchData[vert.index].setMirror(mDat)
				break #we found an intersecting tri
			#Queue connected faces
			MirrorMesh.queueConnectedFaces(face, mirrorMesh, faceQueue, taggedFaces)
		
		for f in taggedFaces :
			f.tag = False

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_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 put_nowait [as 别名]
 def put_nowait(self, *args, **kwargs):
     if self.full():
         try:
             # oldest_data
             self.get()
         except Queue.Empty:
             pass
     Queue.put_nowait(self, *args, **kwargs)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
def create_step60(maindir,mbconnect=None,maxsongs=100,nfilesbuffer=0):
    """
    Makes sure we have the similar artists to the top 100 most familiar
    artists, and then go on with more similar artists.
    INPUT
       maindir       - root directory of the Million Song dataset
       mbconnect     - open pg connection to Musicbrainz
       maxsongs      - max number of song per search (max=100)
       nfilesbuffer  - number of files we leave unfilled in the dataset
    RETURN
       the number of songs actually created
    """
    # will contain artists TID that are done or already in the queue
    artists_done = set()
    # get all artists ids
    artist_queue = Queue()
    artists = get_most_familiar_artists(nresults=100)
    n_most_familiars = len(artists)
    npr.shuffle(artists)
    for a in artists:
        artists_done.add( a.id )
        artist_queue.put_nowait( a )
    # for each of them create all songs
    cnt_created = 0
    cnt_artists = 0
    while not artist_queue.empty():
        artist = artist_queue.get_nowait()
        cnt_artists += 1
        # CLOSED CREATION?
        if CREATION_CLOSED:
            break
        if cnt_artists % 10 == 0:
            nh5 = count_h5_files(maindir)
            print('found',nh5,'h5 song files in',maindir); sys.stdout.flush()
            if nh5 > TOTALNFILES - nfilesbuffer:
                return cnt_created
        # verbose
        print('doing artist',cnt_artists,'(pid='+str(os.getpid())+')'); sys.stdout.flush()
        # encode that artist unless it was done in step10
        #if cnt_artists > n_most_familiars:
        # we had to relaunch this function, lets not redo all the same artists over and over
        if cnt_artists > 1000:
            cnt_created += create_track_files_from_artist(maindir,artist,
                                                          mbconnect=mbconnect,
                                                          maxsongs=maxsongs)
        # get similar artists, add to queue
        similars = get_similar_artists(artist)
        if len(similars) == 0: continue
        npr.shuffle(similars)
        similars = similars[:10] # we keep 10 at random, the radius of artists grows faster
                                 # the thread dont redo the same artists over and over
                                 # too bad for the artists we miss (if any...)
        for a in similars:
            if a.id in artists_done:
                continue
            artists_done.add(a.id)
            artist_queue.put_nowait(a)
    return cnt_created

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import put_nowait [as 别名]
class WatcherHandler(FileSystemEventHandler):
    def __init__(self, filename, counter, notifier, config, queue_len = 100):
        self.filename = path.abspath(filename)
        self.queue = Queue(queue_len)
        self.monitor = Monitor(self.queue, counter, notifier)
        self.offset_persistance = OffsetPersistance(config)
        self.fd = None
        self.time = datetime.now()
        self.offset = self.offset_persistance.get(filename)
        if path.isfile(self.filename):
            self.fd = open(self.filename)
            self.offset = path.getsize(self.filename)

    def on_created(self, event):
        if event.src_path == self.filename and path.isfile(self.filename):
            self.offset  = 0
            self.fd = open(self.filename, 'r')
            self.fd.seek(self.offset,0)

    def on_deleted(self, event):
        if event.src_path == self.filename:
            self.fd.closed()

    def on_modified(self, event):
        self.fd.seek(self.offset, 0)
        for line in self.fd:
            line = line.rstrip('\n')
            try:
                self.queue.put_nowait(line)
            except Full:
                logging.error('{0} input queue is full!'.format(datetime.now()))
        self.offset = self.fd.tell()
        if (datetime.now() - self.time).seconds > 30:
            self.offset_persistance.put(self.filename, self.offset)
            self.time = datetime.now()

    def on_moved(self, event):
        if path.abspath(event.src_path) == self.filename:
            self.fd.close()
            self.offset = 0

        if path.abspath(event.dest_path) == self.filename:
            self.fd = open(self.filename,'r')
            self.offset = path.getsize(self.fd)

    def start(self):
        self.monitor.start()

    def stop(self):
        self.monitor.stop()
        if self.fd is not None and not self.fd.closed:
            self.fd.close()
        self.offset_persistance.sync()
        self.offset_persistance.close()