def __init__(self): Thread.__init__(self) self.ufd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.ufd.settimeout(4) self.nid = random_nid() self.nodes_deque = deque(maxlen=MAX_NODES_DEQUE_SIZE) self.nodes_set = set() self.info_hash_deque = deque(maxlen=MAX_INFO_HASH_DEQUE_SIZE) self.num_find_node_request_send = 0 self.num_find_node_response = 0 self.num_query_received = 0
def growing_exps(): fringe = deque([((0,),1)]) while True: rep, val = fringe.popleft() # append children fringe.extend(get_children(rep)) fringe = deque(sorted(fringe,key=lambda x:x[1])) # fringe.sort(key=lambda x:x[1]) # yield val yield val
def component(ijk, volume): c = deque() o = deque([ijk]) bi, bj, bk = volume.shape while len(o) != 0: p = o.popleft() if p not in c and volume[p] > 0: ns = filter(lambda (i, j, k): 0<=i<bi and 0<=j<bj and 0<=k<bk, neighbors(p)) o += filter(lambda n: n not in o, ns) c.append(p) return c
def __init__(self, log_train_step_every=10, smooth_episode_scores_over=10): self.steps_count = 0 self.episodes_count = 0 self.timer_started = False self.episode_start = 0 self.steps_deq = deque() self.episodes_deq = deque() self.steps_window = log_train_step_every self.episodes_window = smooth_episode_scores_over self.deqs = dict() self.starts = dict() self.steps = dict() self.ignored = set() pass
def check_route1(node1, node2): if node1 is node2: return True elif node1 is None or node2 is None: return False visited = set([node1, node2]) queue = deque([node1]) while len(queue) > 0: # pop() is last in first out # popleft() is first in first out node = queue.popleft() for child in node.neighbours: if child is node2: return True elif child not in visited: visited.add(child) queue.append(child) return False
def __init__(self, capacity): """ :type capacity: int """ from Queue import deque self.capacity = capacity self.queue = deque() # Back --> Front self.time_stamp = 0 self.cache = {}
def growing_exps(): fringe = deque([(0,)]) while True: rep = fringe.popleft() # append children fringe.extend(get_children(rep)) # yield val yield rep
def __init__(self, l=None): if not l: self.root = None return q = deque(map(Node, l)) while len(q) > 1: a, b = q.popleft(), q.popleft() q.append(Node.merge(a, b)) self.root = q.pop()
def __cacheGetJoints(self): from Queue import deque result = [] queue = deque([self.rootJoint]) while len(queue) > 0: joint = queue.popleft() result.append(joint) queue.extend(joint.children) self.jointslist = result
def __init__(self, gateway, behaviour, settings): composer = globals().get(settings.get('composer', 'baroq')) if not composer: raise RuntimeError("Composer is not configured correctly") self.composer = composer.Composer(gateway, settings, behaviour) self.behaviour = behaviour self.playing = None self.stopped = False self.force_caesura = False self.settings = settings self.gateway = self.composer.gateway # keep this between 0 and MAX_SHUFFLE self.shuffle_delay = behaviour["shuffle_delay"] self.meter = self.composer.applied_meter self.metronome = metronome.Metronome(self.meter) self.automate_binaural_diffs = behaviour["automate_binaural_diffs"] self.automate_meters = behaviour["automate_meters"] self.speed_change = behaviour["speed_change"] self.MIN_SPEED = behaviour["min_speed"] self.MAX_SPEED = behaviour["max_speed"] self.MAX_SHUFFLE = behaviour["max_shuffle"] self.musical_logger = logging.getLogger('musical') self.behaviour_logger = logging.getLogger('behaviour') self.gui_logger = logging.getLogger('gui') self.add_setters() if behaviour['automate_microspeed_change']: self.new_microspeed_sine() self.state = {"comp": self.composer, "speed": behaviour["speed"]} self.speed_target = behaviour["speed_target"] self.speed = self.state["speed"] if behaviour['follow_bar_sequence']: self.state.update({ 'bar_sequence': behaviour['bar_sequence'], 'bar_sequence_current_position': 0}) for voice in self.composer.voices.values(): self.apply_voice_adsr(voice) self.has_gui = settings['gui'] self.gui_sender = self.has_gui and GuiConnect() or None self.allowed_incoming_messages = ( self.has_gui and self.behaviour.keys() + ['play', 'sys', 'scale', 'force_caesura', 'trigger_wavetable'] or None) if self.has_gui: self.incoming = deque() self.gui_sender.update_gui(self) #start the reader thread thre = threading.Thread(target=self.gui_sender.read_incoming_messages, args=(self.incoming,)) thre.daemon = True thre.start()
def __cacheGetBones(self): from Queue import deque result = [] queue = deque(self.roots) while len(queue) > 0: bone = queue.popleft() bone.index = len(result) result.append(bone) queue.extend(bone.children) self.boneslist = result
def solve(): T = int(raw_input()) for t in xrange(1, T + 1): S = list(raw_input()) l = len(S) q = deque([S[0]]) for i in xrange(1, l): if S[i] >= q[0]: q.appendleft(S[i]) else: q.append(S[i]) print "Case #%d: %s" % (t, "".join(q))
def analyze_all(self, data_closes): close_prices = deque(data_closes[:500], maxlen=500) remaining = data_closes[len(close_prices):] # send the modified data to the analyzer analyzed_data = [] analyzed_data.append(analyze(close_prices)) for close in remaining: close_prices.append(close) analyzed_data.append(analyze(close_prices)) return analyzed_data
def BFSFindRoute(node1, node2): if node1 == node2: return True q = deque([node1]) node1.visited = True while q: node = q.popleft() for n in node.edges: if n == node2: return True elif not n.visited: q.append(n) n.visited = True return False
def maxInWindows(self, num, size): # write code here from Queue import deque queue = deque() res = [] for i in range(len(num)): while (len(queue) and num[queue[-1]] < num[i]): queue.pop() while (len(queue) and i - queue[0] + 1 > size): queue.popleft() queue.append(i) if size and i - size + 1 >= 0: res.append(num[queue[0]]) return res
def breadth_first_search(graph, start, goal): border = deque() border.append(start) came_from = {} came_from[start] = None while border: current = border.popleft() if current == goal: break for node in graph.neighbors(current): if node not in came_from: border.append(node) came_from[node] = current return came_from
def __init__(self, logger, config, ip_manager, connection_manager, http1worker=Http1Worker, http2worker=Http2Worker): self.logger = logger self.config = config self.ip_manager = ip_manager self.connection_manager = connection_manager self.connection_manager.set_ssl_created_cb(self.on_ssl_created_cb) self.http1worker = http1worker self.http2worker = http2worker self.request_queue = Queue() self.workers = [] self.working_tasks = {} self.h1_num = 0 self.h2_num = 0 self.last_request_time = time.time() self.task_count_lock = threading.Lock() self.task_count = 0 self.running = True # for statistic self.success_num = 0 self.fail_num = 0 self.continue_fail_num = 0 self.last_fail_time = 0 self.rtts = [] self.last_sent = self.total_sent = 0 self.last_received = self.total_received = 0 self.second_stats = deque() self.last_statistic_time = time.time() self.second_stat = { "rtt": 0, "sent": 0, "received": 0 } self.minute_stat = { "rtt": 0, "sent": 0, "received": 0 } self.trigger_create_worker_cv = SimpleCondition() self.wait_a_worker_cv = simple_queue.Queue() threading.Thread(target=self.dispatcher).start() threading.Thread(target=self.create_worker_thread).start() threading.Thread(target=self.connection_checker).start()
def find(self, item): ''' Find. Przyjmuje obiekt Item(). Zwraca reprezentanta szukanego elementu. ''' elem = self.__ITEMS[item] d = deque() while elem.parent: # przejście do korzenia d.append(elem) # odkładanie na stos elem = self.__ITEMS[elem.parent.obj] root = elem while len(d) > 0: # kompresja ścieżki elem = d.pop() elem.parent = root return root
def findRouteBFS(node1, node2): if node1 == node2: return True if node1 == None or node2 == None: return False visited = set([node1, node2]) queue = deque([node1]) while len(queue) > 0: node = queue.popLeft() for child in node.neighbors: if child == node2: return True elif child not in node.neighbors: visited.add(child) queue.append(child) return False
def is_route_between2(node1, node2): if node1 is node2: return True elif node1 is None or node2 is None: return False visited = set([node1, node2]) from Queue import deque queue = deque([node1]) while len(queue) > 0: node = queue.popleft() for child in node.neighbours: if child is node2: return True elif child not in visited: visited.add(child) queue.append(child) return False
def report_action_finish(self, name, every_k=100): if name in self.ignored: return assert name in self.starts duration = time.time() - self.starts[name] if not name in self.deqs: self.deqs[name] = deque() self.steps[name] = 0 self.deqs[name].append(duration) self.steps[name] += 1 if len(self.deqs[name]) > self.steps_window + 1: self.deqs[name].popleft() if self.steps[name] % every_k == 0: sec_per_action = float(sum(self.deqs[name])) / every_k logging.info('Action %s over %d last occurences took %.4f on average' % (name + ' ' * (20 - len(name)), every_k, sec_per_action))
def BFS(start, target): q = deque() visited = set() q.append(start) visited.add(start) step = 0 while q: n = len(q) for i in range(n): cur = q.popleft() if cur == target: return step for k in cur.children: q.append(k) visited.add(k) step += 1
def canFinish(self, numCourses, prerequisites): nodes = dict() for i in prerequisites: nodes.setdefault(i[0], list()) nodes[i[0]].append(i[1]) for i in range(numCourses): q = deque() visited = [False] * numCourses q.append(i) while q: for k in range(len(q)): j = q.popleft() if visited[j]: return False visited[j] = True q.extend(nodes.get(j, list())) return True
def perframe( channels, lambdaOp=None, filt=None, numFrames=1 ): assert( numFrames > 0 ) if numFrames > 1: queue = deque() while True: samples = dict( ( ( channel, [] ) for channel in channels ) ) parsed = read_one_frame() if not parsed: break ( header, frameSamples ) = parsed for channel, data in frameSamples.items(): if channel not in channels: continue samples[channel].extend( data ) if lambdaOp: samples = dict( ( ( c, lambdaOp( samples[c] ) ) for c in channels ) ) if filt: samples = dict(( ( c, filters.apply( samples[c], filt ) ) for c in channels )) if numFrames == 1: yield ( header, samples ) else: queue.append( samples ) if len( queue ) > numFrames: queue.popleft() header.num_samples *= len( queue ) # generate merged dictionary samples = dict( ( ( channel, [] ) for channel in channels ) ) for queueItem in queue: for channel, data in queueItem.items(): samples[channel].extend( data ) yield ( header, samples )
def parseClassList(pageURL): """ Parse the drug class list to obtain url links for all the leaves to get the brand name and generic type for drugs in the category """ urlLinks = deque() soup = BeautifulSoup(requests.get(pageURL).text) alphabetView = soup.find("a", text=re.compile("Alphabetical View")) itemList = alphabetView.parent.next_sibling()[0] ## Get all the children links for item in itemList.find_all("li"): if item.find("ul") == None: aItem = item.find("a") catName = aItem.get_text() link = BASE_URL + aItem.get('href') urlLinks.append([link, catName]) ## parse the trees treeStruct = parseTreeStruct(itemList, []) return urlLinks, treeStruct
def find_path2(start, end): if start is end: return True elif start is None or end is None: return False visited = set([start, end]) from Queue import deque # double-ended queue supports adding & removing elements from either end queue = deque([start]) while len(queue) > 0: node = queue.popleft() for child in node.neighbors: if child is end: return True elif child not in visited: visited.add(child) queue.append(child) return False
def removeInvalidParentheses(self, s): # BFS def is_balanced(s): count = 0 for i in s: if i == "(": count += 1 elif i == ")": count -= 1 if count < 0: return False return count == 0 queue = deque([s]) result = [] visited = {} reached = False while queue: top = queue.popleft() if is_balanced(top): result.append(top) reached = True # stop adding as minimum removals reached continue if not reached: for i in range(len(top)): if top[i] not in "()": # as we can only remove brackets continue new_pattern = top[:i] + top[i + 1:] if new_pattern not in visited: queue.append(new_pattern) visited[new_pattern] = True return result
def costlimiteddfs(self, puzzletype, root, cutoff): frontier = deque([root]) nextcutoff = sys.maxint generatednodes = 0 maxfrontiersize = len(frontier) explored = [] depthlimited = 0 pathsolution = [] while frontier: if len(frontier) == 0: print("Fail happens!!!") exit(1) node = frontier.pop() pathsolution.append(node) print("The node poped from the frontier is:") print node.state depthlimited += 1 if depthlimited > 100000: return nextcutoff, pathsolution, generatednodes, maxfrontiersize, len(explored) explored.append(node.state) if puzzletype.hn(node) + node.pathcost <= cutoff: if puzzletype.goaltest(node): return nextcutoff, puzzletype.solution(node), generatednodes, maxfrontiersize, len(explored) childnodeslist = puzzletype.generatechildnodes(node) generatednodes += len(childnodeslist) for child in node.childnodes: frontier.append(child) if maxfrontiersize < len(frontier): maxfrontiersize = len(frontier) else: if puzzletype.hn(node) + node.pathcost < nextcutoff: nextcutoff = puzzletype.hn(node) + node.pathcost
def largestValues(self, root): """ :type root: TreeNode :rtype: List[int] """ if not root: return [] qu = deque() qu.append([root]) result = [] while qu: root_list = qu.popleft() result.append(max(root_list, key=lambda x: x.val).val) next_layer = [] for ro in root_list: if ro.left: next_layer.append(ro.left) if ro.right: next_layer.append(ro.right) if next_layer: qu.append(next_layer) return result
def minMeetingRooms(self, intervals): """ :type intervals: List[Interval] :rtype: int """ if len(intervals) == 0: return 0 intervals.sort(key=attrgetter("start")) q = deque() q.append(intervals[0]) rooms = 1 p = 1 while p < len(intervals): intv = intervals[p] count = 1 for x in q: if x.end > intv.start: count += 1 if count > 1: q.append(intv) p += 1 rooms = max(rooms,count) else: if len(q): q.popleft() else: q.append(intv) p += 1 return rooms #Meeting Rooms II #https://leetcode.com/problems/meeting-rooms-ii/description/
def __init__(self, handlers): self.stack = deque() self.hostname = None self.handlers = handlers self.cache = bsddb3.hashopen('./cache')
def __init__(self): logging.Handler.__init__(self) self.setLevel(logging.INFO) self.queue = deque(maxlen=MAX_LEN_RECENT_ENTRIES)
def __init__(self): self.msg_queue = deque([], 3000)
def __init__(self, max_size): self.max_size = max_size self.urls = deque() self.contents = {}
def __init__(self, handlers): self.stack = deque() self.hostname = None self.handlers = handlers self.cache = {}
import psutil from collections import defaultdict from Queue import deque output_file = '/dev/shm/tmuxstatus' pid_file = '/tmp/tmuxstatus.pid' stop = threading.Event() cpulock = threading.RLock() netlock = threading.RLock() net = {} net_hist_max = 10 net_hist = defaultdict(lambda: deque(maxlen=net_hist_max)) cpu = [] class ColorTextRun(object): def __init__(self, *items): self.items = list(items) def __len__(self): return sum(map(len, self.items)) def __str__(self): return str(''.join(map(str, self.items))) def __add__(self, other): self.items.append(other)
def __init__(self): self.size = 0 self.content = deque()
def __init__(self,scene,parent = None): super(OptionGroup,self).__init__(parent) self.scene = scene self.items = deque()
def __init__(self, id, composer, note_range=[24, 48], register=None, behaviour=None, note=None, real_note=None, note_length_grouping=sample(GROUPINGS)): # AFFILIATION self.composer = composer # store the composer # IDENTITY self.id = id self.register = (self.composer.registers[register] if register else self.composer.registers[sample(self.composer.registers.keys())]) # TECH self.track_me = False self.queue = deque([], composer.settings['track_voices_length']) # STARTUP self.pan_pos = composer.behaviour.voice_get(self.id, "default_pan_position") self.range = sorted(note_range) self.dir = 0 self.prior_note = None self.note_change = True self.generator = self.voice() self.generator.next() # set the coroutine to the yield-point self.counter = 0 self.volume = composer.behaviour.voice_get(self.id, "default_volume") self.scale = composer.scale self.do_embellish = False self.note_delta = None self.weight = MEDIUM self.note = note or int((max(self.range) - min(self.range)) / 2) + min(self.range) self.real_note = (real_note or int((max(self.range) - min(self.range)) / 2) + min(self.range)) # BEHAVIOUR if behaviour: if isinstance(behaviour, basestring): self.behaviour = behaviour else: self.behaviour = behaviour[0] self.followed_voice_id = behaviour[1] self.following_counter = 0 self.follow_limit = sample(range(5, 11)) else: self.behaviour = self.composer.behaviour["default_behaviour"] self.should_play_a_melody = self.composer.behaviour.voice_get( self.id, 'should_play_a_melody') self.playing_a_melody = False self.current_adsr = self.composer.behaviour.voice_get(self.id, 'adsr') self.duration_in_msec = 0 self.change_rhythm_after_times = 1 self.note_length_grouping = note_length_grouping self.set_rhythm_grouping(note_length_grouping) self.note_duration_steps = 1 self.pause_prob = self.composer.behaviour.voice_get(self.id, 'default_pause_prob') self.legato_prob = 0.1 # to-do: really implement it # probability to have an embellishment-ornament during the current note self.embellishment_prob = self.composer.behaviour['default_embellishment_prob'] self.movement_probs = DEFAULT_MOVEMENT_PROBS self.binaural_diff = 0 # this is not used in this module directly, but serves to track self.slide = self.composer.behaviour.voice_get(self.id, "automate_slide") self.slide_duration_prop = self.composer.behaviour.voice_get( self.id, 'slide_duration_prop') self.next_pat_length = None self.note_duration_prop = composer.behaviour['default_note_duration_prop'] # WAVETABLE - this is used for non-automated wavetables self.wavetable_generation_type = sample( composer.behaviour.voice_get(self.id, 'wavetable_specs'))[0] self.partial_pool = sample( sample(self.composer.behaviour.voice_get(self.id, 'wavetable_specs'))[1]) self.num_partials = composer.behaviour.voice_get(self.id, 'default_num_partial') self.set_note_length_groupings() self.add_setters_for_behaviour_dict() self.musical_logger = logging.getLogger('musical') if self.composer.behaviour['automate_microvolume_change']: self.new_microvolume_sine() self.microvolume_variation = self.composer.behaviour.voice_get( self.id, 'microvolume_variation') self.current_microvolume = self.update_current_microvolume()
def __init__(self, maxLen): self.ax = deque([0.0] * maxLen) self.ay = deque([0.0] * maxLen) self.maxLen = maxLen self.datas = 0