def __call__(self, graph, start_node, target_node): frontier = PriorityQueue() current_node = start_node distance_dict = defaultdict(lambda: infinity) distance_dict[current_node] = 0 ancestors_dict = {} visited_set = set() while True: neighbors = graph.get_neighbors(current_node) current_distance = distance_dict[current_node] for neighbor in neighbors: if neighbor not in visited_set and (current_distance + 1) < distance_dict[neighbor]: distance_dict[neighbor] = current_distance + 1 ancestors_dict[neighbor] = current_node frontier.put((self.cost_function(distance_dict[neighbor], neighbor, target_node), neighbor)) self.nodes_expanded += 1 visited_set.add(current_node) self.nodes_visited += 1 if current_node == target_node: return list(reversed(find_ancestors(ancestors_dict, current_node, start_node))) else: try: current_node = frontier.get_nowait()[1] except Empty: break
def __init__(self, name, directory_scenarii, clean_func, state_file, cmd_display_func): self.name = name self.list_scenario = [] self.selected_scenario = [] self.directory_scenarii = directory_scenarii self.clean_system = clean_func self.cmd_display_func = cmd_display_func self.state_file = state_file # save the current context to restaure it at the end of the testsuite backends = [ line for line in process.execute(['get', 'config', 'backends'])[0].split('\n') if 'U' in line and line != '' ] self.user_context = backends[0].split('(')[0] self.current_context = self.user_context self.to_run = PriorityQueue() self.failed = PriorityQueue() self.passed = [] self.best_state = 1 self.working = Event() # used to modify the best state behaviour when running one one test # or the whole TS. self.best_state_only_one = 0 # used to build initial testsuite data self.batch_run = False self.interactive = False
def getAlphaBeta( game, player, other, reward=AlphaBeta(-100,100), depth=10, tab=0 ): ''' alpha: minimum bound of the outcome -- currently, evaluate of best move possible by other beta: maximum bound of the outcome -- currently, evaluate of best move possible by player returns: (alpha, beta, evaluation, move) ''' # evaluation is the current value of board, assuming no more moves in future # alpha == beta == finalvalue if we figure out the outcome. reward.evaluation = game.evaluate_cached( player ) move = Move(-1,-1) # base case: can't play further, lost if (reward.evaluation==reward.beta): # print 'Player', player, 'won!!!' return AlphaBetaOfMove(AlphaBeta(reward.beta, reward.beta, reward.beta), move) # base case: can't evaluate further if (depth == 0): return AlphaBetaOfMove(reward, move ) q = PriorityQueue() for m in game.next_moves( ): # g2 = copy.deepcopy( game ) assert game.move( player, m) try: oponent_reward = AlphaBeta(-reward.beta, -reward.alpha, -reward.evaluation) oponent_reward = getAlphaBeta(game, other, player, reward=oponent_reward, depth=depth-1, tab=tab+1 ).alphabeta player_reward = AlphaBeta(-oponent_reward.beta, -oponent_reward.alpha, -oponent_reward.evaluation) q.put_nowait( AlphaBetaOfMove( player_reward, m ) ) finally: assert game.unmove(player, m) # if( tab < 1 ): # print ("\t"*tab), (player,row,col), (other,other_r,other_c), (other_alpha,other_beta,other_evaluation), (next_alpha,next_beta,evaluation), update if( q.empty() ): return AlphaBetaOfMove( reward, Move(-1,-1) ) else: return q.get_nowait()
def longestIncreasingPath(self, matrix): """ :type matrix: List[List[int]] :rtype: int """ m = len(matrix) if m == 0: return 0 n = len(matrix[0]) queue = PriorityQueue() res = 0 mem = [[0] * n for _ in range(m)] dirs = [(-1,0),(1,0),(0,-1),(0,1)] def next_smalles(i,j): results = [0] for di, dj in dirs: ni, nj = di + i, dj + j if ni >= 0 and ni < m and nj >= 0 and nj < n and matrix[i][j] > matrix[ni][nj]: results += mem[ni][nj], return results for i in range(m): for j in range(n): queue.put((matrix[i][j],i,j)) while not queue.empty(): v, i, j = queue.get() mem[i][j] = max(next_smalles(i,j)) + 1 res = max(res, mem[i][j]) return res
class EventQueue(object): def __init__(self): """Event queue for executing events at specific timepoints. In current form it is NOT thread safe.""" self.q = PriorityQueue() def schedule(self, f, ts): """Schedule f to be execute at time ts""" self.q.put(EqItem(ts, f)) def schedule_recurring(self, f, interval): """Schedule f to be run every interval seconds. It will be run for the first time interval seconds from now""" def recuring_f(): f() self.schedule(recuring_f, time.time() + interval) self.schedule(recuring_f, time.time() + interval) def run(self): """Execute events in the queue as timely as possible.""" while True: event = self.q.get() now = time.time() if now < event.ts: time.sleep(event.ts - now) event.f()
def prepPriorityQueue(game): global sudokuQueue sudokuQueue = PriorityQueue() for i in range(0,N): for j in range(0,N): if((not game[i][j].domain==None) and (len(game[i][j].domain )!=0)): sudokuQueue.put((len(game[i][j].domain),game[i][j]))
def conflicts(board): conlist=PriorityQueue() clist=[] global conflictval,n,m,k #consistency check along col,row and grid for row in range(int(n)): for col in range(int(n)): recurval=0 for c in range(int(n)): #print "row check",board[row][c] if board[row][c] == board[row][col]: recurval=recurval+1 for r in range(int(n)): if board[r][col] == board[row][col]: recurval=recurval+1 for r1 in range(int(m)): for c1 in range(int(k)): if (board[r1+row-(row%int(m))][c1+col-(col%int(k))] == board[row][col]): recurval=recurval+1 if(recurval>3): clist.append((row,col)) conlist.put((recurval,(row,col))) #conflictval[(row,col)]=recurval return clist
class PoolStreamData(StreamData): def __init__(self, feat_path, feature_maker, label_path=None, fold_in_cv=None): self.pool = PriorityQueue(100000) super(PoolStreamData, self).__init__(feat_path, feature_maker, label_path, fold_in_cv) self.fill_pool() def fill_pool(self): while not self.pool.full(): try: ins = super(PoolStreamData,self).next() self.pool.put((random.random(),ins)) # insert ins with random priority --> kind of random shuffle except StopIteration: break def rewind(self): self.pool = PriorityQueue(100000) super(PoolStreamData,self).rewind() self.fill_pool() def next(self): try: (_,ins) = self.pool.get(False) except Empty: raise StopIteration self.fill_pool() return ins
def __buildFromDB(self): try: dbConnection = self.pool.connection() cursor = dbConnection.cursor() cursor.execute("""select request_spec, id from priority_queue""") moreDBElement = True while moreDBElement: item = cursor.fetchone() if item: request_spec = json.loads(item[0]) idRecord = item[1] instance_properties = request_spec.get("instance_properties") userId = instance_properties.get("user_id") projectId = instance_properties.get("project_id") timestamp = instance_properties.get("created_at") requestPQ = { "priority": 0, "userId": userId, "projectId": projectId, "timestamp": timestamp, "retryCount": 0, "idRecord": idRecord, } PriorityQueue.put(self, (0, requestPQ)) else: moreDBElement = False except MySQLdb.Error, e: if dbConnection: dbConnection.rollback() LOG.info("Error %d: %s" % (e.args[0], e.args[1]))
class MinimumWeightMatchingWithEdges: """Find a minimum weight matching using a greedy method. Attributes ---------- graph : input undirected graph mate : dict with nodes (values are edges or None) cardinality : number """ # Bedzie potrzebne do problemu chinskiego listonosza. def __init__(self, graph): """The algorithm initialization.""" if graph.is_directed(): raise ValueError("the graph is directed") self.graph = graph self.mate = dict((node, None) for node in self.graph.iternodes()) self.cardinality = 0 self._pq = PriorityQueue() def run(self): """Executable pseudocode.""" for edge in self.graph.iteredges(): self._pq.put((edge.weight, edge)) while not self._pq.empty(): _, edge = self._pq.get() if (self.mate[edge.source] is None and self.mate[edge.target] is None): self.mate[edge.source] = edge self.mate[edge.target] = ~edge self.cardinality += 1
def run(self): """ basically calculate the shortest path with A* search algorithm """ origin = Node(self.startPose) #PriorityQueue of nodes pq = PriorityQueue() currentNode = origin # Compute the AStar search algorithm while not currentNode.pos.equals(self.goalPose) and not rospy.is_shutdown(): children = self.expandNode(currentNode) for node in children: pq.put((node.cost(), node)) #it is ranked by the cost if(pq.qsize() == 0): #no more nodes to be expanded print "didn't find a path" currentNode = origin break # pop the "closest" node to the goal currentNode = pq.get()[1] self.calcPathWayPoints(currentNode) #lastNode
def find_corners_for_room(self, room_center): """ returns the 4 corners of given room center :param room_center: :return: [right_up, left_up, left_down, right_down] """ [x, y] = room_center prio_q = PriorityQueue() [right_up, left_up, left_down, right_down] = [None, None, None, None] # find the 4 closest corners for corner in self.found_corners: dist = Calc.get_dist_from_point_to_point(room_center, corner) prio_q.put([dist, corner]) for i in xrange(4): [x_c, y_c] = prio_q.get()[1] if x_c < x and y_c > y: left_up = [x_c, y_c] elif x_c < x and y_c < y: left_down = [x_c, y_c] elif x_c > x and y_c > y: right_up = [x_c, y_c] elif x_c > x and y_c < y: right_down = [x_c, y_c] return [right_up, left_up, left_down, right_down]
def segment(img) : g = numpy.array(img.getdata()) g = g.reshape(img.size) gx = g[:-1,1:] - g[:-1,:-1] gy = g[1:,:-1] - g[:-1,:-1] gms = gx * gx + gy * gy seg = Image.new('L', gms.shape) taken = numpy.zeros(seg.size) #print 'original local mininum' for i in range(seg.size[0]) : for j in range(seg.size[1]) : if localmin(gms, i, j) : taken[i][j] = 1 seg.putpixel((j, i), img.getpixel((j, i))) #print (j, i), img.getpixel((j, i)) q = PriorityQueue(-1) #print 'expand' for i in range(seg.size[0]) : for j in range(seg.size[1]) : if taken[i][j] > 0 : addNeighbor(seg, gms, taken, i, j, q) #print q.qsize() while not q.empty() : (i, j) = q.get()[1] addNeighbor(seg, gms, taken, i, j, q) #print q.qsize() return seg
class EventManager(object): """ Keeps track of and triggers events in our network simulation Instance Properties: Q - A priority queue of events ordered by time """ def __init__(self): self._Q = PriorityQueue() self.t = 0 def add_event(self, t, event, args): """ Add an event onto the event queue :param t: The time of the event :param event: The event to add :param args: A list of args for the event """ self._Q.put((t, event, args)) def pop_event(self): """ Getting the first event off of the event queue. :return: Returns a tuple consisting of the time, event, and the args for the event """ return self._Q.get() def has_events(self): """ Whether or not the manager has any more events on its queue :return: True or False based on whether its empty """ return not self._Q.empty()
class PriorityScheduler(): def __init__(self): self._readyq = PriorityQueue() self._pcbsQ = [] self._counter = 0 self._quantum = -1 def add(self, pcb): self._readyq.put((pcb._priority, self._counter, pcb)) self._pcbsQ.append(pcb) self._counter += 1 def get_pcb(self): #El [2] es porque el next() me devuelve la tupla que guarda la PQ, por lo que le pido el objeto. self.pcb_to_give = self._readyq.get()[2] self._pcbsQ.remove(self.pcb_to_give) for pcb in self._pcbsQ: pcb.increase_priority() return self.pcb_to_give def set_scheduler(self, scheduler): scheduler.set_as_pq() def get_quantum(self): return self._quantum
def consume_solution_queue(q): priority_queue = PriorityQueue() proposed_solutions = set() try: while True: fetch = True while fetch: try: item = q.get_nowait() if item[1] not in proposed_solutions: priorized_item = (-1 * (item[0] / len(item[1])), item[0], item[1]) priority_queue.put(priorized_item) proposed_solutions.add(item[1]) except Empty: fetch = False try: solution = priority_queue.get_nowait() print_solution(solution[1], solution[2]) except Empty: pass time.sleep(2) except KeyboardInterrupt: pass
def get(self, time, *args, **kwargs): a, b, item = PriorityQueue.get(self, *args, **kwargs) if a == time: return item else: PriorityQueue.put(self, (a, 0, item)) raise NameError("No more tasks scheduled!")
def solve(self): nexts = PriorityQueue() while True: self.step += 1 self.current.visited = True possibilities = visitable_points(self.current, self.maze) for node in possibilities: nexts.put((node.get_cost(), node)) next = nexts.get() try: while next[1].visited or (not are_neighbors(next[1].coords(), self.current.coords())): next = nexts.get(False) self.current = next[1] self.solution.append((self.step,self.current, str(self))) except Queue.Empty: try: self.current = self.solution.pop()[1] self.step -= 1 except IndexError: print "No solution" exit(1) self.update()
class CrawlManager(object): def __init__(self, config): try: self.queue_size = int(config.get('queue_size')) except: self.queue_size = 1000 try: self.num_threads = int(config.get('num_threads')) except: self.num_threads = 10 self.queue = PriorityQueue(maxsize=self.queue_size) self.processors = ProcessorManager(config) for i in range(self.num_threads): t = Thread(target=self.queue_target, name="CrawlDaemon-%s" % i) t.daemon = True t.start() def queue_target(self): while True: try: queue_entry = self.queue.get(True) self.handle(queue_entry[1]) self.queue.task_done() except Exception, e: log.exception(e)
class MaxHeap(object): """ Max Heap for the greedy algorithms """ def __init__(self): self.popped = set() self.pq = PriorityQueue() def pop(self): """ returns next item and its priority on the priority queue and removes item from the priority queue. Returns (-1, 0) if queue is empty """ while not self.pq.empty(): a = self.pq.get() if a[1] not in self.popped: self.popped.add(a[1]) return a[1], -a[0], a[2] return (-1, 0, None) def update(self, x, v, aux = None): """ updates key x with value v. If x is currently not in the priority queue, x is inserted """ if x in self.popped: self.popped.remove(x) self.pq.put((-v, x, aux))
def __main__(): #check aruguments if len(sys.argv) == 1: details() sys.exit() if len(sys.argv) < 2: usage() try: opts, args = getopt.getopt(sys.argv[2:],"l:") except getopt.GetoptError: usage() for opt, arg in opts: if opt == "-l": global _log _log = str(arg) else: print ("Unrecognized option: "+opt+"\n") usage() annot = open(sys.argv[1],"r") if (annot == None): print ("Bad annotation name: "+sys.argv[1]) sys.exit() logfile = open(_log,"w") if (logfile == None): print ("Bad logfile name: "+_log) sys.exit() #reg ex annotpat = re.compile("\w+_(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)(.*)") negQueue = PriorityQueue() #read the vcf file... for line in annot: line = line.rstrip() m = annotpat.match(line) if (m == None):# if we find a weird line... sys.stderr.write("Non-standard line (annot):\n\t"+line+"\n") continue else: scaf = int(m.group(1)) start = int(m.group(2)) direction = m.group(5) if direction == "-": negQueue.put_nowait((start, line)) continue else: while not negQueue.empty(): print(negQueue.get()[1]) print(line)
def expand_tree(node): priorityqueue = PriorityQueue() while True: # Check if current node is the goal node if node.pixels == goal: break surrounding_area = get_surrounding_pixels(node.pixels) # Iterate through the all 8 pixels around the current x, y point for current_pixel in surrounding_area: # Only add pixel is a child if it isn't visisted already if current_pixel[0] not in visited and isFree(current_pixel[0]): # Create new node #weight = edge_weight_distance(node.value) next = Node(node, current_pixel[0]) next.set_value(current_pixel[1]) visited.add(next.pixels) #nodesToExplore.append(next) next = priorityqueue.put((next, next.value)) #node = nodesToExplore.popleft() node = priorityqueue.get()[0] # Once breaking, return the full path of the goal node return node.return_full_path()
def __init__ (self, sock, addr, cwnd, ploss, pcorr): self.init = False self.end = False self.requesting = False self.sock = sock self.addr = addr self.ploss = ploss self.pcorr = pcorr self.cwnd = cwnd if self.cwnd <= 0: self.cwnd = WINDOW_SIZE self.attempt = 0 self.timer = None self.lock = threading.Lock() # PQueue will sort packets by segnum, so when inserting in queue, packets will be like: # Acks - segnum = 0 # Failed packets (for their segnum is securely < unset packets) # Unsent packets # So ordering is guaranteed and ACKs should be sent immediately self.buff = PQueue() # packets to send self.waiting = PQueue(cwnd) # packets wating for ACK self.seg = 0 # current packet self.ack = 0 # last valid ack self.nextSeg = random.randint(1,1000) # next expected packet
def p_mod_abs(domain_config, problem_config, solvers_config, max_iter=100): hl_solver, ll_solver = ParseSolversConfig.parse(solvers_config, domain_config) domain = ParseDomainConfig.parse(domain_config) problem = ParseProblemConfig.parse(problem_config, domain) if problem.goal_test(): return False, "Goal is already satisfied. No planning done." n0 = HLSearchNode(hl_solver.translate_problem(problem), domain, problem) Q = PriorityQueue() Q.put((0, n0)) for _ in range(max_iter): n = Q.get()[1] if n.is_hl_node(): c_plan = n.plan(hl_solver) c = LLSearchNode(c_plan) Q.put((-n.heuristic(), n)) Q.put((-c.heuristic(), c)) elif n.is_ll_node(): n.plan(ll_solver) if n.solved(): return n.curr_plan, None Q.put((-n.heuristic(), n)) if n.gen_child(): fail_step, fail_pred = n.get_failed_pred() n_problem = n.get_problem(fail_step, fail_pred) c = HLSearchNode(hl_solver.translate_problem(n_problem), domain, n_problem, prefix=n.curr_plan.prefix(fail_step)) Q.put((-c.heuristic(), c)) return False, "Hit iteration limit, aborting."
def update(self): #Queues to manage downloading dateQ = Queue(0) xmlTrialQ = PriorityQueue(100) # Create the single SQLAlchemy thread to update DB records sqlaThread = threading.Thread(target=self.updateTrials, args=(dateQ, xmlTrialQ)) sqlaThread.daemon = True sqlaThread.start() startDate = self.fetchStartDate() delta = dt.date.today() - startDate dateList = [startDate + dt.timedelta(days=x) for x in range(0, delta.days)] print dateList # Add relevant dates to the list to be fetched for currentDate in dateList: dateQ.put(currentDate) print dateQ.queue numWorkerThreads = min(10, dateQ.qsize()) # Create n worker threads to fetch the zip files of updated content and produce xmlTrial objects for i in range(numWorkerThreads): t = threading.Thread(target=self.fetchUpdatedTrials, args=(dateQ, xmlTrialQ)) t.daemon = True t.start() dateQ.join() # block until all dates have been fetched xmlTrialQ.join() # block until all xmlTrials have been created
def _solve(board, searchfun): """ This is the top level function of the program. `board` is given to the search function by placing it into an empty `PriorityQueue`. A path to the result is returned. """ cost = manhattan_distance(board) start = Node(0, cost, board, None) queue = PriorityQueue() queue.put(start) visited = set() result = searchfun(queue, visited) def getpath(node, path): path.append(node) if node.parent is not None: return getpath(node.parent, path) else: return path if queue.empty(): # Something went wrong with the search algorithm. raise ValueError("Bad search") return getpath(result, [])
def order_domain_values(csp, variable): """Returns a list of (ordered) domain values for the given variable. This method implements the least-constraining-value (LCV) heuristic; that is, the value that rules out the fewest choices for the neighboring variables in the constraint graph are placed before others. """ rating = 0 #To prioritize queue = PriorityQueue() lister = [] #List that is going to be returned for value in variable.domain: rating = 0 #Reset back to 0 for rating of a new value in the domain of the variable for constraint in csp.constraints[variable]: #Get the constraints of the variable for dim in constraint.var2.domain: #Check with all the value of the constraint varaibles domain to check if the value can be satisfied with these domain values if (constraint.is_satisfied(value, dim)): rating = rating + 1 queue.put((rating, value)) # Ordered by rating while not queue.empty(): #Putting into a list i = 0 holder = queue.get() lister.insert(i, holder[1]) i = i + 1 return lister
def dijkstraQ(graph, initial): visited = {initial: 0} path = {} nodes = PriorityQueue() for node in graph.nodes: nodes.put() while nodes: min_node = None for node in nodes: if node in visited: if min_node is None: min_node = node elif visited[node] < visited[min_node]: min_node = node if min_node is None: break nodes.remove(min_node) current_weight = visited[min_node] for edge in graph.edges[min_node]: try: weight = current_weight + graph.distances[(min_node, edge)] except: continue if edge not in visited or weight < visited[edge]: visited[edge] = weight path[edge] = min_node return visited, path
def mapper(): reader = csv.reader(sys.stdin, delimiter='\t') writer = csv.writer(sys.stdout, delimiter='\t', quotechar='"', quoting=csv.QUOTE_ALL) pq = PriorityQueue() topsize = 10 result = [] for line in reader: # YOUR CODE HERE post = line[4] if pq.qsize() < topsize: pq.put((len(post), line)) else: minpost = pq.get() if minpost[0] >= post[0]: pq.put((len(minpost), line)) else: pq.put((len(post), line)) for i in range(topsize): result.append(pq.get()) # writer.writerow(line) result.sort(key=lambda x: x[0]) for r in result: writer.writerow(r[1])
def neighbors(self): aux = PriorityQueue() neighbors = [] dx = [0, 0, 1, -1 ] dy = [1, -1, 0, 0 ] posx = 0 posy = 0 for i in range(self.size()): for j in range(self.size()): if self.blocks[i][j] == 0: posx = i posy = j break for k in range(4): nx = posx + dx[k] ny = posy + dy[k] if nx >= 0 and nx < self.size() and ny >= 0 and ny < self.size(): tmp = copy.deepcopy(self.blocks) tmp[posx][posy] = tmp[nx][ny] tmp[nx][ny] = 0 b = Board(tmp) aux.put((b.hamming(),b)) while not aux.empty(): neighbors.append(aux.get()[1]) return neighbors
def put(self, tup): newtup = tup[0] * -1, tup[1], tup[2] PriorityQueue.put(self, newtup)
def findOptimalPath(ghostCrd, pManCrd, scene): global graph drc = isAdjacent(Node(pManCrd),Node(ghostCrd),scene) if drc: return [(Node(ghostCrd),drc),(Node(ghostCrd),None)] graph = generateStateGraph(ghostCrd, pManCrd, scene) frontier = PriorityQueue() # create start node start = graph[repr(Node(ghostCrd))] start.g = 0 # create frontier frontier.put(start) # keep track of visited states and previous min cost with # dictionary visited = {repr(start):start} while not frontier.empty(): current_node = frontier.get() # if node has already been pruned, ignore if current_node.pruned: continue # check if node represents solution if current_node == Node(pManCrd): # reconstruct path using parent attribute path = [] dest = current_node while dest.parent: path.append((dest.parent,[e.drc for e in dest.parent.edges if e.adjNode == dest][0])) dest = path[-1][0] return list(reversed(path)) # expand node by generating child nodes from legal moves for edge in current_node.edges: c = edge.adjNode c.edges = graph[str(c)].edges if any(c == edge.adjNode for edge in graph[repr(Node(pManCrd))].edges): if c.crd[1] == pManCrd[1]: minDist = min((abs(c.crd[0]-pManCrd[0]),'LEFT'), (len(scene[0])-abs(c.crd[0]-pManCrd[0]),'RIGHT')) else: if c.crd[1] < pManCrd[1]: minDist = (pManCrd[1]-c.crd[1],'DOWN') else: minDist = (c.crd[1]-pManCrd[1],'UP') c.edges.add(Edge(graph[repr(Node(pManCrd))], *minDist)) c.g = current_node.g+edge.weight c.h = heuristic(c, pManCrd,scene) c.f = c.g+c.h c.parent = current_node # ignore if visited or path is not more efficient # if path is more efficient, prune previous node if repr(c) in visited: if c.g >= visited[repr(c)].g: continue else: visited[repr(c)].pruned = True # add to visited nodes visited[repr(c)] = c # add to frontier frontier.put(c)
def __init__(self): self._timers = PriorityQueue() self._map = {}
def __init__(self): PriorityQueue.__init__(self) self.counter = 0
def getItemAndPriority(self, *args, **kwargs): _, _, item = PriorityQueue.get(self, *args, **kwargs) return item, self.ppp[item]
def get(self, *args, **kwargs): _, _, item = PriorityQueue.get(self, *args, **kwargs) return item
def put(self, item, priority): PriorityQueue.put(self, (priority, self.counter, item)) self.counter += 1
''' Node class and sample Priority Queue ''' from Queue import PriorityQueue pq = PriorityQueue() class Node(object): def __init__(self, level=None, path=None, bound=None): self.level = level self.path = path self.bound = bound def __cmp__(self, other): return cmp(self.bound, other.bound) def __str__(self): return str(tuple([self.level, self.path, self.bound])) if __name__ == '__main__': pq = PriorityQueue() pq.put(Node(2, [1, 2, 3], 6)) pq.put(Node(4, [1, 3, 2], 1)) pq.put(Node(1, [1, 2], 7)) while not pq.empty(): print pq.get() pq.put(Node(3, [1, 2, 5], 12))
def __init__(self): PriorityQueue.__init__(self) self.first_element_changed = Condition(self.mutex)
class AsyncoreReactor(object): _thread = None _is_live = False logger = logging.getLogger("Reactor") def __init__(self): self._timers = PriorityQueue() self._map = {} def start(self): self._is_live = True self._thread = threading.Thread(target=self._loop, name="hazelcast-reactor") self._thread.daemon = True self._thread.start() def _loop(self): self.logger.debug("Starting Reactor Thread") Future._threading_locals.is_reactor_thread = True while self._is_live: try: asyncore.loop(count=10, timeout=0.01, map=self._map) self._check_timers() except select.error as err: # TODO: parse error type to catch only error "9" self.logger.warn("Connection closed by server.") pass except: self.logger.exception("Error in Reactor Thread") # TODO: shutdown client return self.logger.debug("Reactor Thread exited. %s" % self._timers.qsize()) self._cleanup_all_timers() def _check_timers(self): now = time.time() while not self._timers.empty(): try: _, timer = self._timers.queue[0] except IndexError: return if timer.check_timer(now): try: self._timers.get_nowait() except Empty: pass else: return def add_timer_absolute(self, timeout, callback): timer = Timer(timeout, callback, self._cleanup_timer) self._timers.put_nowait((timer.end, timer)) return timer def add_timer(self, delay, callback): return self.add_timer_absolute(delay + time.time(), callback) def shutdown(self): if not self._is_live: return self._is_live = False for connection in self._map.values(): try: connection.close(HazelcastError("Client is shutting down")) except OSError, connection: if connection.args[0] == socket.EBADF: pass else: raise self._map.clear() self._thread.join()
def find_path(source, destination, mesh): print "I'm in the method" sx, sy = source dx, dy = destination sourcebox = None destbox = None visited = [] path = [] detail_points = {} for box in mesh['boxes']: x1, x2, y1, y2 = box if x1 < sx and x2 > sx and y1 < sy and y2 > sy: #visited.append(box) sourcebox = box if x1 < dx and x2 > dx and y1 < dy and y2 > dy: #visited.append(box) destbox = box if sourcebox == destbox: return [(source, destination)], [sourcebox] #Dijkstra's Algorithm/ANY SEARCH THINGY HERE dist = {} prev = {} dist[sourcebox] = 0 prev[sourcebox] = None firstboxsource = (dist[sourcebox], sourcebox) priorityQ = PriorityQueue() priorityQ.put(firstboxsource) standing_point = source path = [] while not priorityQ.empty(): #print "I'm in an infinite loop!" current = priorityQ.get() visited.append(current[1]) if current[1] == destbox: end = current[1] boxes = [] while end is not None: boxes.append(end) #print prev[end] end = prev[end] stand = source print boxes for box in boxes: path.append((stand, find_point(stand, box))) stand = find_point(stand, box) path.append((stand, destination)) print path return path, visited neighbors = mesh['adj'][current[1]] for n in neighbors: alt = dist[current[1]] + point_distance( standing_point, find_point(standing_point, current[1])) if n not in dist or alt < dist[n]: standing_point = find_point(standing_point, current[1]) dist[n] = alt prior = alt + heuristic_basic(destbox, current[1]) priorityQ.put((prior, n)) prev[n] = current[1] '''#breadth first search vertex = None prev = {} counter = 0 q = Queue() q.put(sourcebox) prev[sourcebox] = None visited.append(sourcebox) finalbox = None while not q.empty(): v = q.get() if box_equal(v, destbox): finalbox = v break for n in mesh['adj'][v]: if n not in visited: q.put(n) visited.append(n) prev[n] = v''' '''end = finalbox path.append(((dx, dy), (get_midpoint(end)))) while prev[end] is not None: path.append((get_midpoint(prev[end]), get_midpoint(end))) end = prev[end] path.append(((sx, sy), get_midpoint(end)))''' print "No path!" return [], visited
envObj.graph[b].adjList.append(Edge(a, wt)) #agent.budget = int(raw_input()) #envObj.congestion = int(raw_input()) # Calculate heuristic-----------------------DIJKSTRA---- #We will assume that agent always takes bus except when dist<3 agent = Agent(5) #agent(budget) calcHeuristic(envObj, agent) #------------------------------------------- for i in range(3): print("===============================================") destinationNode = None pq = PriorityQueue() pq.put(QueueNode(envObj.source, 0, 0, None, State(envObj.source,Mode.bus, agent.budget))) agent = Agent(10) #agent(budget) envObj.congestion = (2 - i) * 50 print("Congestion = ", envObj.getCongestion(),"%") print("Budget = ", agent.budget) print("Source = ", envObj.graph[envObj.source].coord.toString()) print("Goal = ", envObj.graph[envObj.goal].coord.toString()) print("BusSpeed = ", agent.getBusSpeed(envObj)) print("BusFare = ", agent.busFare) print("CycleSpeed = ", agent.getCycleSpeed()) while(not pq.empty()): curr = pq.get() # print(curr.state.toString()) if(envObj.isGoal(curr.ind)): #if agent reached the goal destinationNode = curr
GLOBAL_FLOOD_COOLDOWN = timedelta( seconds=config.getint('regexbot', 'global_flood_cooldown')) MAX_MESSAGES = config.getint('regexbot', 'max_messages') MAX_MESSAGE_SIZE = config.getint('regexbot', 'max_message_size') try: NICKSERV_PASS = str(config.get('regexbot', 'nickserv_pass')) except: NICKSERV_PASS = None message_buffer = {} last_message = datetime.now() last_message_times = {} flooders = {} ignore_list = [] channel_list = [] user_timeouts = PriorityQueue() channel_timeouts = PriorityQueue() if config.has_section('ignore'): for k, v in config.items('ignore'): try: ignore_list.append(regex.compile(str(v), regex.I)) except Exception, ex: print "Error compiling regular expression in ignore list (%s):" % k print " %s" % v print ex exit(1) for channel in CHANNELS: c = channel.lower() message_buffer[c] = []
l3 = ListNode(2) l3.next = ListNode(6) lists = [l1, l2, l3] # foreachListNode(mergeKLists1(lists)) foreachListNode(mergeKLists2(lists)) def HeapSort(list): # 将 list 构建成堆 heapq.heapify(list) heap = [] while list: heap.append(heapq.heappop(lists)) list[:] = heap return list from Queue import PriorityQueue q = PriorityQueue() q.put(1) q.put(5) q.put(4) q.put(3) print q.task_done()
def __init__(self, _k): self.q = PriorityQueue() self.k = _k self.s = 0 self.min = 0
def aStar(self, start, goal): visited = [] goal = [int(goal[0]), int(goal[1])] start = [int(start[0]), int(start[1])] frontier = PriorityQueue() path = [] bestPathSoFar = [9999999, []] found = False mult = 75 print(goal) #if (self.gridToInd(start) == False): # print("Robot is out of map!") # return None H = self.heuristic(start, goal) frontier.put((H, 0, start, [start])) print("H:", H, "*", mult, "=", H * mult) #if (self.gridToInd(goal) == False): # print("Goal is out of map!") # return None #goalInd = self.tmp dist = [[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [-1, 1], [1, -1], [-1, -1]] print(self.width * self.height) print(self.grid[start[0]][start[1]]) print(self.grid[goal[0]][goal[1]]) H = H * mult while not frontier.empty(): #for i in range(0,10): current = frontier.get() #print("New iter #") #print(current) #print(frontier.qsize()) #print(current[2], goal) if current[2] == goal: path = current[3] break if (current[2] in visited): continue else: visited.append(current[2]) if (len(visited) > H): break for k in range(len(dist)): try: #print("Cons: ", current[2][0] + dist[k][0], current[2][1] + dist[k][1]) if ([ current[2][0] + dist[k][0], current[2][1] + dist[k][1] ] == goal): print("GOAL IS FOUND!") found = True cost = current[1] + 1 if (k >= 4): cost += 0.41 #ind_cp = path_cp = current[3][:] path_cp.append(goal) frontier = PriorityQueue() frontier.put((priority, cost, goal, path_cp)) else: #print(current[2][0] + dist[k][0], current[2][1] + dist[k][1], dist[k], self.grid[current[2][0] + dist[k][0]][current[2][1] + dist[k][1]]) if (not found and ((self.grid[current[2][0] + dist[k][0]][current[2][1] + dist[k][1]] < 26 and self.grid[current[2][0] + dist[k][0]][ current[2][1] + dist[k][1]] >= 0) or len(current[3]) < self.threshould)): ind = [ current[2][0] + dist[k][0], current[2][1] + dist[k][1] ] if (ind not in visited): cost = current[1] + 1 if (k >= 4): cost += 0.41 #print("HERE") heur = self.heuristic(ind, goal) priority = cost + heur path_cp = current[3][:] path_cp.append(ind) frontier.put((priority, cost, ind, path_cp)) #print("ADDED: ", priority, cost, ind, path_cp) if bestPathSoFar[0] > heur: bestPathSoFar = [heur, path_cp] #visited.append(ind) if (self.toPlot): self.plotPlan(ind) except: pass print(frontier.qsize(), len(visited)) path_fin = [] # else: # print("WTF IS GOING ON???") if (len(path) == 0): print("CANNOT FIND A PATH!") print(bestPathSoFar) #return bestPathSoFar[1] if (bestPathSoFar[0] < 35 and len(bestPathSoFar[1]) > 12): #self.threshould+5 path = bestPathSoFar[1] if (len(path) <= 10 or len(path) > 75): path = [] for ind2, n in enumerate(path): # if (self.indToGrid(n)): #print(self.grid[n[0]][n[1]]) print(ind2, n, self.grid[n[0]][n[1]]) #path_fin.append(np.array((n[0],n[1]), dtype=float)) if (ind2 < (self.threshould) or (self.grid[n[0]][n[1]] <= 26 and self.grid[n[0]][n[1]] >= 0)): path_fin.append(np.array((int(n[0]), int(n[1])), dtype=int)) return path_fin
class ConnectionPool(object): """ Container holding the :class:`~elasticsearch.Connection` instances, managing the selection process (via a :class:`~elasticsearch.ConnectionSelector`) and dead connections. It's only interactions are with the :class:`~elasticsearch.Transport` class that drives all the actions within `ConnectionPool`. Initially connections are stored on the class as a list and, along with the connection options, get passed to the `ConnectionSelector` instance for future reference. Upon each request the `Transport` will ask for a `Connection` via the `get_connection` method. If the connection fails (it's `perform_request` raises a `ConnectionError`) it will be marked as dead (via `mark_dead`) and put on a timeout (if it fails N times in a row the timeout is exponentially longer - the formula is `default_timeout * 2 ** (fail_count - 1)`). When the timeout is over the connection will be resurrected and returned to the live pool. A connection that has been peviously marked as dead and succeedes will be marked as live (it's fail count will be deleted). """ def __init__(self, connections, dead_timeout=60, timeout_cutoff=5, selector_class=RoundRobinSelector, randomize_hosts=True, **kwargs): """ :arg connections: list of tuples containing the :class:`~elasticsearch.Connection` instance and it's options :arg dead_timeout: number of seconds a connection should be retired for after a failure, increases on consecutive failures :arg timeout_cutoff: number of consecutive failures after which the timeout doesn't increase :arg selector_class: :class:`~elasticsearch.ConnectionSelector` subclass to use if more than one connection is live :arg randomize_hosts: shuffle the list of connections upon arrival to avoid dog piling effect across processes """ if not connections: raise ImproperlyConfigured("No defined connections, you need to " "specify at least one host.") self.connection_opts = connections self.connections = [c for (c, opts) in connections] # remember original connection list for resurrect(force=True) self.orig_connections = tuple(self.connections) # PriorityQueue for thread safety and ease of timeout management self.dead = PriorityQueue(len(self.connections)) self.dead_count = {} if randomize_hosts: # randomize the connection list to avoid all clients hitting same node # after startup/restart random.shuffle(self.connections) # default timeout after which to try resurrecting a connection self.dead_timeout = dead_timeout self.timeout_cutoff = timeout_cutoff self.selector = selector_class(dict(connections)) def mark_dead(self, connection, now=None): """ Mark the connection as dead (failed). Remove it from the live pool and put it on a timeout. :arg connection: the failed instance """ # allow inject for testing purposes now = now if now else time.time() try: self.connections.remove(connection) except ValueError: # connection not alive or another thread marked it already, ignore return else: dead_count = self.dead_count.get(connection, 0) + 1 self.dead_count[connection] = dead_count timeout = self.dead_timeout * 2**min(dead_count - 1, self.timeout_cutoff) self.dead.put((now + timeout, connection)) logger.warning( 'Connection %r has failed for %i times in a row, putting on %i second timeout.', connection, dead_count, timeout) def mark_live(self, connection): """ Mark connection as healthy after a resurrection. Resets the fail counter for the connection. :arg connection: the connection to redeem """ try: del self.dead_count[connection] except KeyError: # race condition, safe to ignore pass def resurrect(self, force=False): """ Attempt to resurrect a connection from the dead pool. It will try to locate one (not all) eligible (it's timeout is over) connection to return to the live pool. Any resurrected connection is also returned. :arg force: resurrect a connection even if there is none eligible (used when we have no live connections). If force is specified resurrect always returns a connection. """ # no dead connections if self.dead.empty(): # we are forced to return a connection, take one from the original # list. This is to avoid a race condition where get_connection can # see no live connections but when it calls resurrect self.dead is # also empty. We assume that other threat has resurrected all # available connections so we can safely return one at random. if force: return random.choice(self.orig_connections) return try: # retrieve a connection to check timeout, connection = self.dead.get(block=False) except Empty: # other thread has been faster and the queue is now empty. If we # are forced, return a connection at random again. if force: return random.choice(self.orig_connections) return if not force and timeout > time.time(): # return it back if not eligible and not forced self.dead.put((timeout, connection)) return # either we were forced or the connection is elligible to be retried self.connections.append(connection) logger.info('Resurrecting connection %r (force=%s).', connection, force) return connection def get_connection(self): """ Return a connection from the pool using the `ConnectionSelector` instance. It tries to resurrect eligible connections, forces a resurrection when no connections are availible and passes the list of live connections to the selector instance to choose from. Returns a connection instance and it's current fail count. """ self.resurrect() connections = self.connections[:] # no live nodes, resurrect one by force and return it if not connections: return self.resurrect(True) # only call selector if we have a selection if len(connections) > 1: return self.selector.select(self.connections) # only one connection, no need for a selector return connections[0]
def calc_max_coverage_coor(xmin, ymin, zmin, xmax, ymax, zmax, rmax): def bot_clips_bbox(bot, bbox_xmin, bbox_ymin, bbox_zmin, bbox_xmax, bbox_ymax, bbox_zmax): ## test if this bot's octahedral sensor-volume ## intersects the bbox {x,y,z}min - {x,y,z}max assert (bbox_xmin <= bbox_xmax) assert (bbox_ymin <= bbox_ymax) assert (bbox_zmin <= bbox_zmax) dist = 0 dist += (bbox_xmin - bot[0]) * (bot[0] < bbox_xmin) dist += (bot[0] - bbox_xmax) * (bot[0] > bbox_xmax) dist += (bbox_ymin - bot[1]) * (bot[1] < bbox_ymin) dist += (bot[1] - bbox_ymax) * (bot[1] > bbox_ymax) dist += (bbox_zmin - bot[2]) * (bot[2] < bbox_zmin) dist += (bot[2] - bbox_zmax) * (bot[2] > bbox_zmax) return (dist <= bot[3]) def pq_add(pq, bbox_xmin, bbox_ymin, bbox_zmin, cur_bbox_size): bbox_xmax = bbox_xmin + cur_bbox_size - 1 bbox_ymax = bbox_ymin + cur_bbox_size - 1 bbox_zmax = bbox_zmin + cur_bbox_size - 1 num_bots_in_bbox = 0 for bot in bots: num_bots_in_bbox += bot_clips_bbox(bot, bbox_xmin, bbox_ymin, bbox_zmin, bbox_xmax, bbox_ymax, bbox_zmax) if (num_bots_in_bbox == 0): return False ## find Manhattan distance from origin to the closest corner of the bounding-box ## box with largest number of bots clipping it should be processed first, negate ## the count since PQ is constructed as a min-heap ## in case of ties, PQ will yield the box with smallest origin distance and size ## (ordering by size first and distance second also works and is slightly faster ## on the given input) ## this processing order ensures the problem is solved when reaching a 1x1x1 box ## since 1) no larger box can intersect more bot sensor-volumes, and 2) no other ## 1x1x1 box intersecting as many sensor-volumes can be closer to the origin ## min_orig_dist_x = min(abs(bbox_xmin), abs(bbox_xmax)) min_orig_dist_y = min(abs(bbox_ymin), abs(bbox_ymax)) min_orig_dist_z = min(abs(bbox_zmin), abs(bbox_zmax)) min_orig_dist = min_orig_dist_x + min_orig_dist_y + min_orig_dist_z ##!! pq.put((-num_bots_in_bbox, min_orig_dist, cur_bbox_size, bbox_xmin, bbox_ymin, bbox_zmin)) pq.put((-num_bots_in_bbox, cur_bbox_size, min_orig_dist, bbox_xmin, bbox_ymin, bbox_zmin)) return True ## determine size of the power-of-two bounding cube max_size = max(xmax - xmin, ymax - ymin, zmax - zmin, rmax) bbox_size = next_power_of_two(max_size) bbox_queue = PriorityQueue() pq_add(bbox_queue, xmin, ymin, zmin, bbox_size) while (bbox_queue.qsize() > 0): ##!! (num_bots, orig_dist, bb_size, x, y, z) = bbox_queue.get() (num_bots, bb_size, orig_dist, x, y, z) = bbox_queue.get() if (bb_size == 1): return ((x, y, z), orig_dist, -num_bots) bb_size >>= 1 ## insert top-left corner coordinates of each child bounding-box pq_add(bbox_queue, x, y, z, bb_size) pq_add(bbox_queue, x, y, z + bb_size, bb_size) pq_add(bbox_queue, x, y + bb_size, z, bb_size) pq_add(bbox_queue, x, y + bb_size, z + bb_size, bb_size) pq_add(bbox_queue, x + bb_size, y, z, bb_size) pq_add(bbox_queue, x + bb_size, y, z + bb_size, bb_size) pq_add(bbox_queue, x + bb_size, y + bb_size, z, bb_size) pq_add(bbox_queue, x + bb_size, y + bb_size, z + bb_size, bb_size) return ((0, 0, 0), 0, 0)
from Queue import Queue from Queue import PriorityQueue a1 = 'a1' a2 = 'a2' a3 = 'a3' a4 = 'a4' a5 = 'a5' b1 = 'b1' b2 = 'b2' b3 = 'b3' b4 = 'b4' b5 = 'b5' q = Queue() pq = PriorityQueue() for i in xrange(5): p = 5 - i q.put("a" + str(p)) q.put("b" + str(p)) pq.put((p, "a" + str(p))) pq.put((p, "b" + str(p))) for i in xrange(5): p = 5 - i q.put("a" + str(p) + str(i + 5)) q.put("b" + str(p) + str(i + 5)) pq.put((p, "a" + str(p) + str(i + 5))) pq.put((p, "b" + str(p) + str(i + 5)))
from pritunl import logger from pritunl import mongo from pritunl import listener from Queue import PriorityQueue import pymongo import random import bson import datetime import threading import time import bson import collections running_queues = {} runner_queues = [PriorityQueue() for _ in xrange(3)] thread_limits = [ threading.Semaphore(x) for x in ( settings.app.queue_low_thread_limit, settings.app.queue_med_thread_limit, settings.app.queue_high_thread_limit, ) ] def add_queue_item(queue_item): if queue_item.id in running_queues: return running_queues[queue_item.id] = queue_item logger.debug(
class SchedulingController(object): """ The SchedulingController keeps track of the actions that are scheduled and calls a callback when the actions has to be executed. The SchedulingController handles actions as String, it is the callers responsibility to create a string representation of the action. """ def __init__(self, db_filename, callback, action_timeout=60): new_database = not os.path.exists(db_filename) self.__connection = sqlite3.connect( db_filename, detect_types=sqlite3.PARSE_DECLTYPES, check_same_thread=False, isolation_level=None) self.__cursor = self.__connection.cursor() if new_database: self.__create_tables() self.__callback = callback self.__action_timeout = action_timeout self.__stop = False self.__input_queue = Queue() self.__action_queue = PriorityQueue() for action in self.__read_actions(): self.__action_queue.put(action) self.__thread = Thread(target=self.__run, name="SchedulingController thread") self.__thread.daemon = True def __create_tables(self): """ Create the Scheduled actions table. """ self.__cursor.execute( "CREATE TABLE actions (id INTEGER PRIMARY KEY, description TEXT, " "action TEXT, timestamp INTEGER);") def __read_actions(self): """ Read the actions from the table. """ ret = [] for row in self.__cursor.execute( "SELECT timestamp, id, description, action FROM actions;"): ret.append((row[0], row[1], row[2], row[3])) return ret def __create_action(self, timestamp, description, action): """ Create an action with a given timestamp in the database. Returns the id of the action in the datbase. """ self.__cursor.execute( "INSERT INTO actions (timestamp, description, action) VALUES (?,?,?)", (timestamp, description, action)) return (timestamp, self.__cursor.lastrowid, description, action) def __remove_action_from_db(self, id): """ Remove an action from the database. """ self.__cursor.execute("DELETE FROM actions WHERE id = ?;", (id, )) def __execute_action(self, id, description, action): """ Execute a scheduled action, delete the action from the database and execute it. """ LOGGER.info("Executing scheduled action '%s'", description) self.__remove_action_from_db(id) def run_callback(): """ Run the callback. """ try: self.__callback(action) except: LOGGER.exception( "Exception while executing scheduled action '%s'", description) callback_thread = Thread(target=run_callback) callback_thread.daemon = True callback_thread.start() callback_thread.join(self.__action_timeout) if callback_thread.isAlive(): LOGGER.error( "Scheduled action '%s' is still executing after %d sec", description, self.__action_timeout) def start(self): """ Start the background thread. """ self.__thread.start() def stop(self): """ Stop the SchedulingController. """ self.__stop = True self.__input_queue.put(None) self.__thread.join() def __run(self): """ Code for the background thread. """ while not self.__stop: # Wait on the input_queue, take actions from the action_queue when scheduled. timeout = None while self.__action_queue.qsize() > 0: element = self.__action_queue.get() (timestamp, id, description, action) = element if timestamp <= time(): self.__execute_action(id, description, action) else: timeout = timestamp - time() self.__action_queue.put(element) break try: value = self.__input_queue.get(True, timeout) if value == None: # Stop signal ! continue elif value == REFRESH: # Refresh the action queue self.__action_queue = PriorityQueue() for action in self.__read_actions(): self.__action_queue.put(action) else: # Got a new action (timestamp, description, action) = value self.__action_queue.put( self.__create_action(timestamp, description, action)) except Empty: pass # Timeout - do the loop def schedule_action(self, timestamp, description, action): """ Schedule a new action, that should be executed at a given timestamp. """ self.__input_queue.put((timestamp, description, action)) def list_scheduled_actions(self): """ Get a list of all scheduled actions. :returns: a list of dictionaries with keys (id, timestamp, description, action) """ actions = self.__read_actions() ret = [] for action in actions: ret.append({ 'timestamp': action[0], 'id': action[1], 'description': action[2], 'action': action[3] }) return ret def remove_scheduled_action(self, id): """ Remove a scheduled action, when the id of the scheduled action is provided. """ self.__remove_action_from_db(id) self.__input_queue.put(REFRESH) def close(self): """ Commit the changes and close the database connection. """ self.__connection.commit() self.__connection.close()
class srQueue(threading.Thread): def __init__(self, name="QUEUE"): super(srQueue, self).__init__(name=name) self._queue = PriorityQueue() self.currentItem = None self.min_priority = 0 self.amActive = False self.lock = threading.Lock() self.stop = threading.Event() self.daemon = True def run(self): """ Process items in this queue """ while not self.stop.is_set(): with self.lock: self.amActive = True if self.currentItem is None or not self.currentItem.is_alive(): if self.currentItem: self.currentItem = None self.currentItem = self.get() if self.currentItem.priority < self.min_priority: self.put(self.currentItem) self.currentItem = None else: self.currentItem.start() self.amActive = False @property def queue(self): return self._queue.queue def get(self, *args, **kwargs): _, item = self._queue.get(*args, **kwargs) return item def put(self, item, *args, **kwargs): """ Adds an item to this queue :param item: Queue object to add :return: item """ item.added = datetime.now() item.name = "{}-{}".format(self.name, item.name) self._queue.put((item.priority, item), *args, **kwargs) return item def pause(self): """Pauses this queue""" sickrage.srCore.srLogger.info("Pausing queue") self.min_priority = 999999999999 def unpause(self): """Unpauses this queue""" sickrage.srCore.srLogger.info("Unpausing queue") self.min_priority = 0 def shutdown(self): self.stop.set() try: self.join(10) except: pass
import os import sys from Queue import PriorityQueue pq = PriorityQueue() visited_states = set() class Puzzle(object): """ A* search with MANHATTAN HEURISTIC """ def __init__(self, init_state, goal_state): # you may add more attributes if you think is useful self.cost = 0 self.init_state = init_state self.goal_state = goal_state self.actions = list() self.explored = [0] self.explored_tot = 0 self.num_nodes = [0] self.total_prev_h_cost = 0 def __cmp__(self, other): return cmp(self.cost, other.cost) def to_int_rep(self): return tuple(map(tuple, self.init_state)) def is_solvable(self): """Checks if state is solvable."""
class MulticastChat: multicast_group = ('224.3.29.71', 10000) multicast_ip = '224.3.29.71' hostIp = '0.0.0.0' pid = os.getpid() queueMsg = PriorityQueue() numberAckList = {} pid_list = [pid] time = 0 server_address = ((hostIp, 10000)) conversationList = [] sendDelay = 0 def __init__(self, numberOfProcesses): self.numberOfProcesses = numberOfProcesses self.sock = self.initConnection() self.synchronize(self.numberOfProcesses) self.pid_list.sort() self.pid = self.pid_list.index(self.pid) thread.start_new_thread(self.recvListener, ()) print "Ready - " + self.presentationMsg() print "Send your message:" while True: msg = raw_input() if msg[:5] == "DELAY": stopPid = int(msg[5:].split("-s")[0]) seconds = int(msg[5:].split("-s")[1]) self.sendDelayMsg(stopPid, seconds) elif msg[:4] == "LIST": self.printConversationLog() elif msg[:3] == "PID": print self.presentationMsg() elif msg[:3] == "STP": pidStop = int(msg[4:].split("-s")[0]) seconds = int(msg[4:].split("-s")[1]) self.sendStopMsg(pidStop, seconds) else: self.sendMsg(msg) print "end" def presentationMsg(self): return "I'm the process no: " + str(self.pid) def printConversationLog(self): for i in self.conversationList: print i def sendDelayMsg(self, pidDelay, seconds): msg = "DELAY " + str(pidDelay) + " -s" + str(seconds) self.sock.sendto(msg, self.multicast_group) def initConnection(self): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) membership = socket.inet_aton(self.multicast_ip) + socket.inet_aton( self.hostIp) sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, membership) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) sock.bind(self.server_address) return sock def synchronize(self, numberOfProcesses): print '\nSynchronizing..' #print 'Recv %s'%self.pid synchroMsg = 'SYN ' + str(self.pid) while len(self.pid_list) < self.numberOfProcesses: self.sock.sendto(synchroMsg, self.multicast_group) data, address = self.sock.recvfrom(1024) pidRecv = int(data[4:]) if not (pidRecv in self.pid_list): self.pid_list.append(pidRecv) #print 'Recv %s'%data self.sock.sendto(synchroMsg, self.multicast_group) def sendStopMsg(self, pidNo, seconds): msg = "STP " + str(pidNo) + " -s " + str(seconds) self.sock.sendto(msg, self.multicast_group) def sendMsg(self, msg): self.time += 1 msgTosend = "MSG ID:" + str(self.time) + "-" + str( self.pid) + "\r\nContent:" + msg #print "sended: "+msgTosend if self.sendDelay > 0: print "delaying on send for %d seconds" % self.sendDelay time.sleep(self.sendDelay) self.sendDelay = 0 self.sock.sendto(msgTosend, self.multicast_group) def recvMsg(self, msg, msgId, timestamp, senderId): msgGuard = str(senderId) + " - Time " + str( timestamp) + ": " + msg.split(":")[1] self.queueMsg.put((msgId, msgGuard)) self.time = 1 + max(self.time, timestamp) self.ackMsg(msgId) def ackMsg(self, msgId): self.time += 1 ack = "ACK " + str(msgId) + ":" + str(self.time) if self.sendDelay > 0: print "delaying on ACK for %d seconds" % self.sendDelay time.sleep(self.sendDelay) print "sending" self.sendDelay = 0 self.sock.sendto(ack, self.multicast_group) def recvAck(self, msgId, timestamp): self.time = 1 + max(self.time, timestamp) if msgId in self.numberAckList: self.numberAckList[msgId] += 1 else: self.numberAckList[msgId] = 1 def deliverMsg(self, msgId): if self.numberAckList[msgId] < self.numberOfProcesses: return time, msg = self.queueMsg.get(False) if time != msgId: self.queueMsg.put((time, msg)) return self.conversationList.append(msg) print msg self.time += 1 del self.numberAckList[msgId] while not (self.queueMsg.empty()): time, msg = self.queueMsg.get(False) if (self.numberAckList[time] < self.numberOfProcesses): self.queueMsg.put((time, msg)) break self.conversationList.append(msg) print msg self.time += 1 del self.numberAckList[time] def recvListener(self): while True: data, address = self.sock.recvfrom(1024) cmd = data[:3] if data[:5] == "DELAY": stopPid = int(data[5:].split("-s")[0]) seconds = int(data[5:].split("-s")[1]) if (stopPid == self.pid): self.sendDelay = seconds print "Delayed on send" elif cmd == "ACK": msgID = int(data.split(":")[0][4:]) timestamp = int(data.split(":")[1]) self.recvAck(msgID, timestamp) self.deliverMsg(msgID) elif cmd == "MSG": msgId, contentMsg = data.split("\r\n") timeRecv = int(msgId[7:].split("-")[0]) senderId = int(msgId[7:].split("-")[1]) msgId = int("".join(msgId[7:].split("-"))) content = str(msgId) + ": " + contentMsg[8:] self.recvMsg(content, msgId, timeRecv, senderId) elif cmd == "STP": stopPid = int(data[4:].split("-s")[0]) seconds = int(data[4:].split("-s")[1]) if stopPid != self.pid: continue print "Stopped to listen for %d seconds" % seconds time.sleep(seconds) print "Woke up"
def __init__(self): self._queue = PriorityQueue()
def get(self): tup = PriorityQueue.get(self) newtup = tup[0] * -1, tup[1], tup[2] return newtup
def __init__(self, start, goal): self.path = [] self.visitedQueue = [] self.priorityQueue = PriorityQueue() self.start = start self.goal = goal
def __init__(self, maxlength=0, length_tol=1000): self.pq = PriorityQueue() self.decrease_length = multiprocessing.Lock() self.maxlength = maxlength self.length_tol = length_tol
def compute(self, start, goal): frontier = PriorityQueue() frontier.put((0, start)) frontier_nodes = [start] already_explored = [start] came_from = {start: None} cost_so_far = {start: 0} while not frontier.empty(): queue_entry = frontier.get() current = queue_entry[1] if self.draw and (current in frontier_nodes): frontier_nodes.remove(current) for next_node in current.neighbors: # Get the current node from the graph next_node = self._graph[next_node] new_cost = cost_so_far[current] + 1 #self._costmap.data[current.y * self._costmap.info.height + current.x] if (next_node not in cost_so_far) or (new_cost < cost_so_far[next_node]): cost_so_far[next_node] = new_cost priority = new_cost + self.heuristic(next_node, goal) frontier.put((priority, next_node)) came_from[next_node] = current if self.draw and (next_node not in frontier_nodes): frontier_nodes.append(next_node) if current not in already_explored: already_explored.append(current) # Update visualization if self.draw: self.drawNodes(frontier_nodes, "frontier") self.drawNodes(already_explored, "explored") if current == goal: break # Work our way back through the came_from chain from the goal to the start path = [goal] previous_node = came_from[goal] while previous_node is not None: path.insert(0, previous_node) previous_node = came_from[previous_node] self.drawNodes(path, "path") # Compute ros Path waypoints = [] index = 0 current_dir = None for node in path: try: next_node = path[index + 1] # If we've changed directions, and add a waypoint if so this_dir = math.atan2((next_node.y - node.y), (next_node.x - node.x)) if current_dir == None or this_dir != current_dir: current_dir = this_dir # copied some stuff from # https://www.programcreek.com/python/example/70252/geometry_msgs.msg.PoseStamped pose = PoseStamped() pose.header.seq = len(waypoints) pose.header.frame_id = "map" pose.header.stamp = rospy.Time.now() (xc, yc) = self.mapCoordsToWorld(node.x, node.y) pose.pose.position.x = xc pose.pose.position.y = yc pose.pose.position.z = 0 q = quaternion_from_euler(0.0, 0.0, current_dir) pose.pose.orientation = Quaternion(*q) waypoints.append(pose) index += 1 except IndexError: # We've reached the end of the loop, add last waypoint pose = PoseStamped() pose.header.seq = len(waypoints) pose.header.frame_id = "map" pose.header.stamp = rospy.Time.now() (xc, yc) = self.mapCoordsToWorld(node.x, node.y) pose.pose.position.x = xc pose.pose.position.y = yc pose.pose.position.z = 0 q = quaternion_from_euler(0.0, 0.0, current_dir) pose.pose.orientation = Quaternion(*q) waypoints.append(pose) path_msg = Path() path_msg.header.frame_id = "map" path_msg.header.stamp = rospy.Time.now() path_msg.poses = waypoints return path_msg
def __init__(self, limit = 0): PriorityQueue.__init__(self, limit) self.max_prio = 0 self.none_send = False