class Collision: def __init__(self, sensors, queue_size=2): self.history = None self.ready = False self.sensors = sensors # [('center', object),...] self.stopped = False self.Q = Queue(maxsize=queue_size) self.t = None def start(self): if self.t: return self.t = Thread(target=self.update, args=()) self.t.daemon = True self.t.start() def update(self): while True: if self.stopped == True: return result = {} for sensor in self.sensors: result[sensor[0]] = sensor[1].check_collision() if self.Q.full(): self.Q.get() self.Q.put(result) #logger.info("Collision(): Info added to queue") self.ready = True sleep(2) # Required by UD Sensor Hardware def stop(self): self.stopped = True self.t = None def more(self): return not self.Q.empty() def ready(self): return self.ready def get(self, latest = False): # logger.info("Collision Queue: " + str(self.Q.qsize())) while latest: if not self.Q.empty(): self.history = self.Q.get() else: break else: if not self.Q.empty(): self.history = self.Q.get() return self.history def clear_queue(self): self.Q.clear()
class file(): def __init__(self): self.__queue = Queue() def SetPath(self, path): self.__path = path def GetPath(self): return self.__path def GetSize(self): fsize = os.path.getsize(self.__path) fsize = fsize / float(1024) return round(fsize, 2) #打开文件读取数据 def Read(self): self.__queue.clear() file_content = None try: f = open(self.__path, "rb") #直接以二进制读入,传输时不用encode和decode了 file_content = f.read() f.close() except Exception as ret: print("没有此文件")
def add_node_to_tree( self, data): #if given a list, how to add all the elements in the list if self.root == None: self.root = TreeNode(data) self.no_of_nodes += 1 #print "root: ",self.root.data else: q = Queue() node = self.root q.enqueue([node]) while not q.IsQueueEmpty(): node = q.dequeue() if node.left is None: node.left = TreeNode(data) self.no_of_nodes += 1 #print node.left.data q.clear() elif node.right is None: node.right = TreeNode(data) self.no_of_nodes += 1 #print node.right.data q.clear() else: q.enqueue([node.left, node.right])
def main(): queue = Queue() queue.enqueue('hello') queue.enqueue('dog') queue.enqueue(3) print(queue.display()) queue.dequeue() print(queue.display()) queue.dequeue() print(queue.display()) queue.dequeue() print(queue.display()) queue.dequeue() queue.enqueue('world') queue.enqueue('cat') queue.enqueue(1) print(queue.size()) print(queue.display()) queue.clear() print(queue.display())
class GraylogConnection(object): """Used by GraylogHandler to keep track of connections to Graylog servers. Stores messages in a circular buffer of limited length until connection is established and the messages are sent to the server. Spawns a thread in order to enable connection to multipe Graylog servers.""" #---------------------------------------------------------------------- def __init__(self, host, port, queue_len): """Inits the Graylog connection using the provided host and port. The length of the message queue is set with queue_len. """ self.queue_len = queue_len self.message_queue = Queue() self.status_queue = Queue() self.conf_queue = Queue() self.status_str = "Not connected" thread_kwargs = { "host": host, "port": port, "msg_queue": self.message_queue, "stat_queue": self.status_queue, "conf_queue": self.conf_queue } self.thread = threading.Thread(target=thread_function, kwargs=thread_kwargs) self.thread.daemon = True self.thread.start() #---------------------------------------------------------------------- def __del__(self): """Destructor. Tells the thread to exit and then waits for it to do so.""" self.conf_queue.put("exit") self.thread.join() #---------------------------------------------------------------------- def SendMsg(self, msg): """Simply sends a log message. Tells the thread to exit if the message is 'exit'.""" if (msg == "exit"): self.message_queue.clear() if (self.message_queue.qsize() >= self.queue_len): return if (type(msg) == str): msg = bytearray(msg.encode("utf-8")) self.message_queue.put(msg) #---------------------------------------------------------------------- @property def status(self): """Returns the connection status.""" while (not self.status_queue.empty()): self.status_str = self.status_queue.get() return self.status_str #---------------------------------------------------------------------- @property def messages_in_queue(self): """Returns the number of messages in the message queue.""" return self.message_queue.qsize()
def test_queue_clear(self): ''' test the clear() method ''' q = Queue() q.enqueue(3) q.enqueue(4) q.enqueue(13) q.clear() self.assertIsNone(q.head) self.assertIsNone(q.tail)
def insert(self, k, v): """Inserts a node into the binary tree. A node is inserted at the bottom most level using BFS to find the correct spot in order to keep the tree balanced. Time complexity: O(n) Keyword arguments: k - key of node v - value of node """ node = BinaryNode(k, v) if not self.root: self.root = node else: # Perform BFS for the first empty spot to insert the new node queue = Queue() queue.enqueue(self.root) while not queue.is_empty(): n = queue.dequeue() if n.left_child and n.right_child: # n is an internal node (keeps binary structure) queue.enqueue(n.left_child) queue.enqueue(n.right_child) else: # Add child if n.left_child: n.right_child = node else: n.left_child = node # Empty queue out as to not continue processing further nodes queue.clear() self.size += 1 return node
class BFS: '''Breadth Fisrt Search. Each BFS object is initialized for a source vertex. BFS methods are first applied to the source vertex, followed by those with a path to the source in the Graph.''' def __init__(self, vertex): self.root = vertex self._visited = [vertex] self._edgeTo = {vertex.name: vertex} self._q = Queue() self._q.enqueue(vertex) def _bfs(self, w): while len(self._q) != 0: u = self._q.dequeue() for v in u.ajcList: if v not in self._visited: self._visited.append(v) self._edgeTo[v.name] = u self._q.enqueue(v) if v is w: self._q.clear() break self._bfs(w) def search(self, w): '''Starting from source, breadth first search for w.''' if self.root is w: return [w] self._bfs(w) return self._path(w) def _path(self, w): ''' Creat path from source to w in the BFS tree.''' s = Stack() while self._edgeTo[w.name] is not w: s.push(w) w = self._edgeTo[w.name] return [self.root] + [s.pop() for i in range(len(s))]
class BFS: '''Breadth Fisrt Search. Each BFS object is initialized for a source vertex. BFS methods are first applied to the source vertex, followed by those with a path to the source in the Graph.''' def __init__(self, vertex): self.root = vertex self.visited = [vertex] self.edgeTo = {vertex.room: vertex} self._q = Queue() self._q.enqueue(vertex) def bfs(self, target): while len(self._q) != 0: u = self._q.dequeue() for v in u.ajcList: if v not in self.visited: self.visited.append(v) self.edgeTo[v.room] = u self._q.enqueue(v) if v.room == target: self._q.clear() break self.bfs(target)
class TestStack(unittest.TestCase): def setUp(self): self.queue = Queue() def test_init(self): self.assertEqual(self.queue.get_size(), 0) new_queue = Queue("Bob") self.assertEqual(new_queue.get_size(), 1) def test_enqueue(self): self.queue.enqueue("Bob") self.assertEqual(self.queue.get_size(), 1) def test_dequeue(self): self.queue.enqueue("Bob") dequeued_item = self.queue.dequeue() self.assertEqual(dequeued_item, "Bob") another_dequeued_item = self.queue.dequeue() self.assertIsNone(another_dequeued_item) def test_peek(self): self.queue.enqueue("Bob") self.queue.enqueue("Bill") self.queue.enqueue("Boris") peeked_item = self.queue.peek() self.assertEqual(peeked_item, "Bob") def test_clear(self): for i in range(0, 100): self.queue.enqueue("Bob") self.assertEqual(self.queue.get_size(), 100) self.queue.clear() self.assertEqual(self.queue.get_size(), 0) def test_get_size(self): self.assertEqual(self.queue.get_size(), self.queue.linked_list.size)
class FIFOQueue: def __init__(self, multiprocess=False, is_deque=True, max_len=200): if multiprocess: is_deque = False self._queue = None self._size = 0 # qsize() might not be implemented for MP queue self._use_deque = is_deque self._use_mpqueue = multiprocess if self._use_deque: if max_len == 0: max_len = None self._queue = deque(maxlen=max_len) else: if max_len is None: max_len = 0 if self._use_mpqueue: self._queue = MPQueue(maxsize=max_len) else: self._queue = Queue(maxsize=max_len) def clear(self): self._size = 0 if self._use_deque: self._queue.clear() else: while self._queue.get() is not None: pass def size(self): if self._use_deque: return len(self._queue) try: return self._queue.qsize() except NotImplementedError: return self._size def put(self, x): if self._use_deque: self._queue.append(x) else: try: self._queue.put_nowait(x) self._size += 1 except: return False return True def get(self): if self._use_deque: try: return self._queue.popleft() except: return None try: x = self._queue.get_nowait() except: return None self._size -= 1 return x
class Connection(object): """Abstracción de conexión. Maneja colas de entrada y salida de datos, y una funcion de estado (task). Maneja tambien el avance de la maquina de estados. """ def __init__(self, fd, address=''): """Crea una conexión asociada al descriptor fd""" self.socket = fd self.task = None # El estado de la maquina de estados self.input = Queue() self.output = Queue() # Esto se setea a true para pedir al proxy que desconecte self.remove = False self.address = address def fileno(self): """ Número de descriptor del socket asociado. Este metodo tiene que existir y llamarse así para poder pasar instancias de esta clase a select.poll() """ return self.socket.fileno() def direction(self): """ Modo de la conexión, devuelve uno de las constantes DIR_*; también puede devolver None si el estado es el final y no hay datos para enviar. """ # La cola de salida puede estar vacia por dos motivos: # -1) Se enviaron todos los datos -> Remove es True # -2) La cola de salida no esta lista AUN -> Sigue recibiendo if self.output.data == "": if self.remove: # (1) return None # El estado es el final else: # (2) return DIR_READ # Sigue recibiendo else: # La cola de salida esta lista para enviarse return DIR_WRITE def recv(self): """ Lee datos del socket y los pone en la cola de entrada. También maneja lo que pasa cuando el remoto se desconecta. Aqui va la unica llamada a recv() sobre sockets. """ try: data = self.socket.recv(RECV_SIZE) # Receive if data == "": # El remoto se ha desconectado self.remove = True # Hay que removerlo self.input.put(data) # Encola los datos recibidos except socket_error: self.send_error(INTERNAL_ERROR, "Internal Error") self.remove = True def send(self): """Manda lo que se pueda de la cola de salida""" # Envia sended_size bytes sended_size = self.socket.send(self.output.data) # Elimina los datos enviados de la cola self.output.remove(sended_size) def close(self): """Cierra el socket. OJO que tambien hay que avisarle al proxy que nos borre. """ self.socket.close() self.remove = True self.output.clear() def send_error(self, code, message): """Funcion auxiliar para mandar un mensaje de error""" logging.warning("Generating error response %s [%s]", code, self.address) self.output.put("HTTP/1.1 %d %s\r\n" % (code, message)) self.output.put("Content-Type: text/html\r\n") self.output.put("\r\n") self.output.put( "<body><h1>%d ERROR: %s</h1></body>\r\n" % (code, message)) self.remove = True
class Connection(object): """Abstracción de conexión. Maneja colas de entrada y salida de datos, y una funcion de estado (task). Maneja tambien el avance de la maquina de estados. """ def __init__(self, fd, address=''): """Crea una conexión asociada al descriptor fd""" self.socket = fd self.task = None # El estado de la maquina de estados self.input = Queue() self.output = Queue() # Esto se setea a true para pedir al proxy que desconecte self.remove = False self.address = address def fileno(self): """ Número de descriptor del socket asociado. Este metodo tiene que existir y llamarse así para poder pasar instancias de esta clase a select.poll() """ return self.socket.fileno() def direction(self): """ Modo de la conexión, devuelve uno de las constantes DIR_*; también puede devolver None si el estado es el final y no hay datos para enviar. """ # La cola de salida puede estar vacia por dos motivos: # -1) Se enviaron todos los datos -> Remove es True # -2) La cola de salida no esta lista AUN -> Sigue recibiendo if self.output.data == "": if self.remove: # (1) return None # El estado es el final else: # (2) return DIR_READ # Sigue recibiendo else: # La cola de salida esta lista para enviarse return DIR_WRITE def recv(self): """ Lee datos del socket y los pone en la cola de entrada. También maneja lo que pasa cuando el remoto se desconecta. Aqui va la unica llamada a recv() sobre sockets. """ try: data = self.socket.recv(RECV_SIZE) # Receive if data == "": # El remoto se ha desconectado self.remove = True # Hay que removerlo self.input.put(data) # Encola los datos recibidos except socket_error: self.send_error(INTERNAL_ERROR, "Internal Error") self.remove = True def send(self): """Manda lo que se pueda de la cola de salida""" # Envia sended_size bytes sended_size = self.socket.send(self.output.data) # Elimina los datos enviados de la cola self.output.remove(sended_size) def close(self): """Cierra el socket. OJO que tambien hay que avisarle al proxy que nos borre. """ self.socket.close() self.remove = True self.output.clear() def send_error(self, code, message): """Funcion auxiliar para mandar un mensaje de error""" logging.warning("Generating error response %s [%s]", code, self.address) self.output.put("HTTP/1.1 %d %s\r\n" % (code, message)) self.output.put("Content-Type: text/html\r\n") self.output.put("\r\n") self.output.put("<body><h1>%d ERROR: %s</h1></body>\r\n" % (code, message)) self.remove = True
class Camera(): def __init__(self, camera_type, camera_num=0, resolution=(320, 240), framerate=20, rotation=0): self.fps = None self.ready = False self.camera = None self.camera_type = camera_type self.stopped = False self.Q = Queue(maxsize=2 * framerate) self.t = None self.history = None self.rotation = rotation self.resolution = resolution self.framerate_ms = 1.0 / float(framerate) if self.camera_type == PICAMERA: self.camera = picamera.PiCamera() if rotation: self.camera.rotation = rotation self.camera.resolution = resolution self.camera.framerate = framerate self.camera.sharpness = 0 self.camera.contrast = 0 self.camera.brightness = 65 self.camera.saturation = 0 self.camera.ISO = 0 self.camera.video_stabilization = True self.camera.exposure_compensation = 0 self.camera.exposure_mode = 'auto' self.camera.meter_mode = 'average' self.camera.awb_mode = 'auto' self.camera.image_effect = 'none' self.camera.color_effects = None #sleep(2) #while self.camera.analog_gain < 1 or self.camera.digital_gain < 1: # sleep(0.1) #self.camera.exposure_mode = 'off' #if self.camera.analog_gain < 1 or self.camera.digital_gain < 1: # raise RuntimeError('low gains') elif self.camera_type == USB: w, h = resolution self.camera = cv2.VideoCapture(camera_num) self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, w) self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, h) #self.camera.set(cv2.cv.CV_CAP_PROP_FPS, framerate) # doesnt works, using sleep to maintain fps else: raise EnviormentError("Invalid camera type") #logging.debug("CameraOne.__init__()") def start(self): if self.t: return f = None if self.camera_type == PICAMERA: f = self.update_picamera else: f = self.update_usb self.t = Thread(target=f, args=()) self.t.daemon = True self.t.start() def update_picamera(self): stream = PiRGBArray(self.camera) image = self.camera.capture_continuous(stream, format="bgr", use_video_port=True) start = time() temp_fps = 0 while True: if self.stopped: return frame = image.next() # Framerate updater if (time() - start) >= 1: self.fps = temp_fps temp_fps = 0 start = time() temp_fps += 1 frame = frame.array stream.truncate(0) if self.Q.full(): self.Q.get() self.Q.put(frame) # logging.info("Camera(): Frame added to queue") self.ready = True def update_usb(self): start = time() temp_fps = 0 while True: if self.stopped: return (grabbed, frame) = self.camera.read() # Framerate updater if (time() - start) >= 1: self.fps = temp_fps temp_fps = 0 start = time() temp_fps += 1 if not grabbed: self.stop() return if self.rotation != 0: frame = cv2.flip(frame, self.rotation) if self.Q.full(): self.Q.get() self.Q.put(frame) #logging.info("Camera(): Frame added to queue") self.ready = True #sleep(0.2) sleep(self.framerate_ms ) # webcam doesn't go over 9 fps on Raspberry Pi def stop(self): self.stopped = True if self.camera_type == USB: self.camera.release() else: self.camera.close() self.t = None def more(self): return not self.Q.empty() def ready(self): return self.ready def get_frame(self, latest=False): if latest and not self.Q.empty(): size = self.Q.qsize() for i in range(size - 2): # Keep atleast x values in queue self.Q.get() return self.Q.get() #, size else: return self.Q.get( timeout=10 ) #, "Wait" # OpenCV throw select timeout after 10 sec def clear_queue(self): self.Q.clear()
def test_clear(self): Q = Queue([4, 2, 1]) Q.clear() self.assertEqual(str(Q), '[]') self.assertEqual(Q.pop(), None)
from queue import Queue q = Queue() while True: what = input("Push Pop Print Peek or Clear\n") if what == "push": q.push(input("Enter Value: ")) elif what == "pop": print(q.pop()) elif what == "print": q.printer() elif what == "clear": q.clear()
class Connection(object): """ Abstracción de conexión. Maneja colas de entrada y salida de datos, y una función de estado (task). Maneja también el avance de la máquina de estados. """ def __init__(self, fd, address=''): """ Crea una conexión asociada al descriptor fd. """ self.socket = fd self.task = None # El estado de la maquina de estados. self.input = Queue() self.output = Queue() # Se setea a true para pedir al proxy que desconecte. self.remove = False self.address = address def fileno(self): """ Número de descriptor del socket asociado. Este metodo tiene que existir y llamarse así para poder pasar instancias de esta clase a select.poll(). """ return self.socket.fileno() def direction(self): """ Modo de la conexión, devuelve una de las constantes DIR_*; también puede devolver None si el estado es el final y no hay datos para enviar. """ if self.output.data: return DIR_WRITE elif self.task is not None: return DIR_READ else: return None def recv(self): """ Lee datos del socket y los pone en la cola de entrada. También maneja lo que pasa cuando el remoto se desconecta. Aquí va la única llamada a recv() sobre sockets. """ try: data = self.socket.recv(BUFFSIZE) self.input.put(data) if len(data) == 0: self.remove = True except: self.remove = True def send(self): """ Manda lo que se pueda de la cola de salida. """ try: bytes_sent = self.socket.send(self.output.data) self.output.remove(bytes_sent) except: self.remove = True self.output.clear() def close(self): """ Cierra el socket. También hay que avisarle al proxy que borre. """ self.socket.close() self.remove = True self.output.clear() def send_error(self, code, message): """ Función auxiliar para mandar un mensaje de error. """ logging.warning("Generating error response %s [%s]", code, self.address) self.output.put("HTTP/1.1 %d %s\r\n" % (code, message)) self.output.put("Content-Type: text/html\r\n") self.output.put("\r\n") self.output.put("<body><h1>%d ERROR: %s</h1></body>\r\n" % (code, message)) self.remove = True
class Stream(): # TODO use Threads for output distribution def __init__(self,stapModuleInstance, args = {}, interval = 0.1, withdraw=False): self.id = id(self) self.args = args self.log = print if 'logStream' not in args else args['logStream'] self.name = stapModuleInstance.name self.queue = Queue() # the input queue self.receivers = [] self.interval = interval # check every x seconds for output in queue. self.withdraw = withdraw # if True, drop incomming input if we have no listeners self.thread = Thread(target=self.run) self.thread.daemon = True self.thread.running = True self.thread.start() stapModuleInstance.queue = self.queue def __str__(self): return "<Stream,name=%s,queue=%s,receivers=%s>" % (self.name, self.queue, self.receivers) def register(self,stapLabModuleInstance): if stapLabModuleInstance is not None: if stapLabModuleInstance not in self.receivers: self.receivers += [stapLabModuleInstance] stapLabModuleInstance.queue = self.queue self.log("registered %s to %s" % (str(stapLabModuleInstance), self.name)) else: self.log("%s already in receivers of Stream %s" % (stapLabModuleInstance.name, self)) def unregister(self,module): if module is not None: try: self.receivers.remove(module) self.log("unregistered %s from %s" % (str(module), self.name)) except ValueError: self.log("cannot unregister module %s to stream %s" %(module,self)) def emtpyQueue(self): with self.queue.mutex: self.queue.clear() def run(self): self.log("%s entering mainLoop" % self) while self.thread.running: if not self.queue.empty(): if len(self.receivers) > 0: data = self.queue.get() for receiver in self.receivers: if receiver is not None: receiver.enqData(data) else: if self.withdraw: self.emptyQueue() for receiver in self.receivers: if not receiver.thread.running: self.unregister(receiver) sleep(self.interval) self.log("%s leaving mainLoop" % self) def stop(self): self.thread.running = False