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 __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 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
