def test_filled_queue():
queue = Queue()
queue.add(1)
assert queue.remove() == 1
queue.add(1).add(2).add(3)
assert queue.remove() == 1
assert queue.remove() == 2
def find_path(node_a, node_b):
if node_a == node_b:
return True
queue = Queue()
queue.add(node_a)
node_a.visited = True
while not queue.is_empty():
children = queue.remove()
if children:
for child in children:
if child.visited == False:
child.visited = True
if child == node_b:
return True
queue.add(child)
children.visited = True
return False
def test_add(self):
queue = Queue()
queue.add(1)
self.assertEqual(1, queue.peek())
self.assertFalse(queue.isEmpty())
queue.add(2)
queue.add(3)
self.assertEqual(1, queue.peek())
def weave(q1, q2):
q_out = Queue()
while q1.peek() is not None or q2.peek() is not None:
if q1.peek() is not None:
q_out.add(q1.remove())
if q2.peek() is not None:
q_out.add(q2.remove())
return q_out
class AnimalShelter:
def __init__(self):
self.cats = Queue()
self.dogs = Queue()
self.pos = 0
# Time complexity: O(1)
# Space complexity: O(1)
def enqueue(self, animal: Animal):
if animal == Animal.cat:
self.cats.add([animal, self.pos])
else:
self.dogs.add([animal, self.pos])
self.pos += 1
return self
# Time complexity: O(1)
# Space complexity: O(1)
def dequeue(self):
if self.dogs.is_empty() and self.cats.is_empty():
raise Exception('no animal in shelter')
if self.dogs.is_empty():
return self.cats.remove()
if self.cats.is_empty():
return self.dogs.remove()
dog_pos = self.dogs.peek()[1]
cat_pos = self.cats.peek()[1]
if cat_pos < dog_pos:
return self.cats.remove()
else:
return self.dogs.remove()
# Time complexity: O(1)
# Space complexity: O(1)
def dequeueCat(self):
if self.cats.is_empty():
raise Exception('no cats in shelter')
return self.cats.remove()
# Time complexity: O(1)
# Space complexity: O(1)
def dequeueDog(self):
if self.dogs.is_empty():
raise Exception('no dogs in shelter')
return self.dogs.remove()
def __str__(self):
return 'cats: ' + str(self.cats) + '\ndogs: ' + str(self.dogs)
def test_remove(self):
queue = Queue()
queue.add(1)
self.assertEqual(1, queue.remove())
self.assertTrue(queue.isEmpty())
queue.add(2)
queue.add(3)
self.assertEqual(2, queue.remove())
self.assertEqual(3, queue.remove())
self.assertTrue(queue.isEmpty())
def main():
values = Queue()
values.add(0)
values.add(1)
values.add(2)
values.add(3)
print(values.peek() == 0)
print(values.length == 4)
print(values.pop() == 0)
print(values.pop() == 1)
print(values.pop() == 2)
print(values.pop() == 3)
print(values.is_empty())
def generate_queue(file):
f = open(file, "r")
lines = f.readlines()
f.close
queue = Queue()
for line in lines:
queue.add(line.strip())
return queue
# print generate_queue("../static/puzzles.txt")
def test_uneven_weave(self):
q1 = Queue()
q1.add(2)
q1.add(3)
q1.add(4)
q1.add(6)
q1.add(7)
q2 = Queue()
q2.add("Hi")
q2.add("Ho")
q2.add("He")
self.assertEqual(
weave(q1, q2).array, [7, 6, "He", 4, "Ho", 3, "Hi", 2])
def levelOrder(self,a):
q = Queue()
r = a
while r is not None:
print(r.root.data)
if r.root.left is not None:
q.add(r.root.left)
if r.root.right is not None:
q.add(r.root.right)
if q.isEmpty():
print("empty")
r = None
else:
r = q.delete()
def answer(a): #使用一个栈从两个方向获取数值
c = Queue()
b = Stack()
cur = a.element()
while cur != None:
b.push(Node(cur.value))
cur = cur.next
c = Queue()
a_pre = a.element()
add_a_pre = False # queue length is odd
while a.element().value != b.peek().value and \
a_pre.value != b.peek().value:
if a_pre.value == b.peek().value:
add_a_pre = True
a_pre = a.remove()
c.add(Node(a_pre.value))
c.add(Node(b.pop().value))
if add_a_pre: # odd
c.add(Node(a_pre.value))
else: # even
c.add(Node(a.remove().value))
return c
def spin(alist, marker):
circle = Queue()
for student in alist:
circle.add(student)
while len(circle) > 1:
for round in range(marker):
circle.add(circle.remove())
circle.remove()
return circle[0]
def breadth_first_search(value, root):
"""Using a Queue"""
queue = Queue()
queue.add(root)
while queue.queue:
node = queue.remove()
print(node)
if node.data == value:
return True
else:
for child in node.children:
queue.add(child)
return False
def test_equal_weave(self):
q1 = Queue()
q1.add(3)
q1.add(4)
q1.add(6)
q2 = Queue()
q2.add("Hi")
q2.add("Ho")
q2.add("He")
self.assertEqual(weave(q1, q2).array, ["He", 6, "Ho", 4, "Hi", 3])
class Character:
def __init__(self, move_list, speed):
self.move_list = move_list
self.speed = speed
self.move_queue = Queue()
def queue_move(self, move):
self.move_queue.add(move)
def perform_move(self):
move = self.move_queue.remove()
def start(self):
while (self.move_queue.empty() == False):
seconds = floor((20 / self.speed))
time.sleep(seconds)
action = self.move_queue.remove()
print('Performing Action:', action)
def BFS(start, end):
queue = Queue()
queue.add(start)
visited_set = {}
visited_set[start.label] = True
while not queue.is_empty():
current = queue.remove()
for i in range(current.neighbors_num):
node = current.neighbors[i]
if not visited_set.has_key(node.label):
visited_set[node.label] = True
if node.label == end.label:
return True
else:
queue.add(node)
return False
def __repr__(self):
"""String representation."""
queue = Queue()
self.marked = True
queue.add(self)
s = ''
counter = 1
depth = 0
while not queue.is_empty():
r = queue.remove()
s += str(r.name)
s += '\t'
if counter == 2**depth:
s += '\n'
counter = 0
depth += 1
counter += 1
if r.left is not None:
if r.left.marked == False:
r.left.marked = True
queue.add(r.left)
if r.right is not None:
if r.right.marked == False:
r.right.marked = True
queue.add(r.right)
return s
def answer3(a): #使用快慢指针来均分链表， 然后把后面一半倒序, 拆分为2个队列，上看去更简洁
slow = fast = a.first
pre = None
while fast:
pre = slow
slow = slow.next
if fast.next:
fast = fast.next.next
else:
fast = fast.next
if fast == a.last:
break;
pre.next = None
a.last = pre
b = Queue()
while slow:
b.add(slow)
slow = slow.next
import reverse_list
b2 = reverse_list.answer(b)
r = Queue()
while a.element() and b.element() :
r.add(Node(a.remove().value))
r.add(Node(b.remove().value))
if b.element():
r.add(Node(b.remove().value))
return r
def answer2(a): #使用快慢指针来均分链表， 然后把后面一半倒序
slow = fast = a.first
while fast:
slow = slow.next
if fast.next:
fast = fast.next.next
else:
fast = fast.next
if fast == a.last:
break;
mid = slow
b = Queue()
while slow:
b.add(slow)
slow = slow.next
import reverse_list
b2 = reverse_list.answer(b)
r = Queue()
_a = a.first
_b = b.first
while _a.value != mid.value:
r.add(Node(_a.value))
r.add(Node(_b.value))
_a = _a.next
_b = _b.next
if _b:
r.add(Node(_b.value))
return r
def main():
employee_directory = []
sudo_usernames_data = [
"Inger Hella", "Saga Janina", "Alfred Dorotea", "Tessan Helen",
"Michael Rigmor", "Edith Ida", "John Henrike", "Hella Lukas",
"Thyra Karolina", "Øyvind Nathalie", "Miroslav Tikhon",
"Tòmas Prokhor", "Timofei Vitaliy", "Beileag Logan", "Filipp Vadim",
"Ruaridh Lilia", "Filat Svyatoslav", "Sofiya Bhaltair", "Max Saveli",
"Yeva Snezhana"
]
for i, val in enumerate(sudo_usernames_data):
# output = f'{i} {val} {random.randrange(100,999)} {predict_shift[random.randrange(1,4)]}'
employee_directory.append(
Employee(val, random.randrange(100, 999), random.randrange(1, 4)))
# print(employee_directory[i].to_string())
print("Before id number sort: \n ----------")
EmployeeArrayUtilities.print_array(employee_directory)
array_size = len(employee_directory)
EmployeeArrayUtilities.print_array(employee_directory,
"\nBefore last-name sort:")
EmployeeArrayUtilities.sort_array(employee_directory, array_size)
EmployeeArrayUtilities.print_array(employee_directory,
"\nAfter last-name sort: ")
s1 = Queue(10, Employee())
print("Enter an employee number to add to the queue: ", end="")
new_search_value = input()
# s1 = Queue(10, 0)
found = EmployeeArrayUtilities.binary_search_number(
employee_directory, int(new_search_value), 0, array_size - 1)
# print("found: ", found)
if found != EmployeeArrayUtilities.NOT_FOUND:
print(new_search_value + " IS in list at position " + str(found))
else:
print(new_search_value + " is NOT in list.")
# print("capacity: ", s1.get_capacity())
# print(employee_directory[0])
# s1.add(employee_directory[0])
# s1.add(employee_directory[1])
# s1.add(employee_directory[2])
# s1.add(employee_directory[3])
# s1.add(employee_directory[4])
s1.add(1)
s1.add(2)
s1.add(3)
s1.add(4)
s1.add(5)
s1.add(6)
print(s1.que)
for k in range(0, 3):
print("[" + str(s1.remove()) + "]")
print(s1.que)
def main():
students = [Student(student_id) for student_id in range(1, 10)]
print_queue = Queue()
print("\n\t\tPrinter Initiated")
for student in students:
tasks_list = [Task(), Task()]
student.addTasks(tasks_list)
print_queue.add(student)
while not bool(print_queue):
student_tasks = print_queue.remove()
tasks = student_tasks.tasks
for task in range(len(tasks)):
printer = Printer()
print("\n\t---PRINTING!!--")
if printer.isBusy():
printer.task = tasks[task]
printer.print()
current_status = QueueStatus(print_queue, printer)
print("Printing Student {0} task:{1}".format(
student_tasks.id, task + 1))
print("Total pages: ", current_status[1])
print("Average waiting time {0} min".format(current_status[0]))
if printer.taskCompleted():
print("Current Task Print Completed")
else:
print(
"Printer is busy, will update you the status very shortly "
)
print("ALL TASKS HAVE PRINTED")
def serialize_tree(tree):
tree_list = []
queue = Queue()
queue.add(tree)
while queue.queue:
node = queue.remove()
if node is None:
tree_list.append(-1)
else:
tree_list.append(node.data)
if node.left:
queue.add(node.left)
else:
queue.add(None)
if node.right:
queue.add(node.right)
else:
queue.add(None)
return tree_list
class Animal_Queue(object):
def __init__(self):
self.dog_queue = Queue()
self.cat_queue = Queue()
self.time = 0
def enqueue(self, animal):
animal.order = self.time
self.time += 1
if animal.kind == 'dog':
self.dog_queue.add(animal)
else:
self.cat_queue.add(animal)
def dequeue_any(self):
if self.dog_queue.front().order < self.cat_queue.front().order:
self.dog_queue.remove()
else:
self.cat_queue.remove()
def dequeue_dog(self):
self.dog_queue.remove()
def dequeue_cat(self):
self.cat_queue.remove()
def print_animal_queue(self):
print '[',
for i in range(self.dog_queue.size):
print self.dog_queue.list[i].name,
print ']'
print '[',
for i in range(self.cat_queue.size):
print self.cat_queue.list[i].name,
print ']'
def answer(a, b):
c = Queue()
carry = 0
while a.element() != None and b.element() != None:
sum = a.remove().value + b.remove().value + carry
c.add(Node(sum%10))
carry = sum/10
while a.element() != None:
sum = a.remove().value + carry
c.add(Node(sum%10))
carry = sum/10
while b.element() != None:
sum = b.remove().value + carry
c.add(Node(sum%10))
carry = sum/10
if carry > 0:
c.add(Node(carry))
return c
def main():
print("Queue")
print("Creating an empty queue")
q = Queue()
print("Add 2 to queue")
q.add(2)
q.print_queue()
print("Add 8 to queue")
q.add(8)
print("Add 5 to queue")
q.add(5)
print("Add 90 to queue")
q.add(90)
q.print_queue()
print("Queue length:",len(q))
print("Now serve the first item in queue")
q.serve()
q.print_queue()
def __str__(self):
queue = Queue()
queue.add(self.root)
values = []
while not queue.is_empty():
exp = queue.remove()
values.append(str(exp.value))
if exp.value.left:
queue.add(exp.value.left)
if exp.value.right:
queue.add(exp.value.right)
return str(values)
def test_queue(N):
print("Testing queue")
q = Queue()
print("Check if empty")
print(q.empty())
print(f"Adding {N} values")
[q.add(i) for i in range(N)]
print("")
print("Peeking front value")
print(q.peek())
print("Removing values")
[q.remove() for i in range(int(N / 2) - 1)]
print("Mid-value:")
print(q.remove())
[q.remove() for i in range(int(N / 2))]
print("Queue should now be empty")
try:
q.remove()
except Exception:
print("Got expected Exception")
def breadth_first_search(value, root):
"""Using a Queue"""
queue = Queue()
queue.add(root)
while queue.queue:
node = queue.remove()
print(node)
if node.data == value:
return True
else:
if node.left:
queue.add(node.left)
if node.right:
queue.add(node.right)
return False
def BFS(node): queue=Queue() queue.add(node) visited=set() visited.add(node) while not queue.is_empty(): r=queue.remove() print(r.value) if r.left!=None: if r.left not in visited: queue.add(r.left) visited.add(r.left) if r.right!=None: if r.right not in visited: queue.add(r.right) visited.add(r.right)
def list_of_depths(bt: BinarySearchTree):
nodes = {}
que = Queue()
que.add([bt.root, 1])
while not que.is_empty():
(node, pos) = que.remove().value
if not nodes.get(pos):
nodes[pos] = LinkedList()
nodes[pos].unshift(node.value)
if node.left:
que.add([node.left, pos + 1])
if node.right:
que.add([node.right, pos + 1])
return nodes
def check_if_binary_search_tree(root):
"""Using a Queue"""
queue = Queue()
queue.add(root)
while queue.queue:
node = queue.remove()
print(node)
if node.left:
# If left node, check it is smaller
if node.left.data < node.data:
queue.add(node.left)
else:
return False
if node.right:
# If right node, check it is greater
if node.right.data > node.data:
queue.add(node.right)
else:
return False
return True
def demo():
a = Queue()
a.add(Node(2)); a.add(Node(4)); a.add(Node(5))
print a
b = Queue()
b.add(Node(5)); b.add(Node(6)); b.add(Node(4))
print b
c = answer(a, b)
print c
def test_remove(self):
q = Queue()
q.add(3)
q.add(4)
q.add(6)
self.assertEqual(q.remove(), 3)
def test_add(self):
q = Queue()
q.add(3)
q.add(4)
q.add(6)
self.assertEqual(q.array, [6, 4, 3])
from queue import Queue
queue = Queue()
queue.add('a')
queue.add('b')
queue.add('c')
print queue.isEmpty()
print queue.poll()
print queue.poll()
print queue.poll()
print queue.isEmpty()
print queue.poll()
ser = serial.Serial('', 9600)
time.sleep(1)
s = set()
q = Queue()
BASE_URL = 'http://13.66.209.37:3000'
states = ['DispenseCup', 'DispensePearls', 'DispenseTea']
while 1:
r = requests.get(BASE_URL+'/orders/')
json = r.json()
for item in json:
if item['id'] is not in s:
s.add(item['id'])
q.add(item)
robot = requests.get(BASE_URL+'/robots')
robot = robot.json()[0]
# if robot['state'] in states:
if robot['ack']:
serial.write(robot['state'])
rob = requests.patch(BASE_URL + '/robots/' + robot['id'],
json = {'ack': False, 'state': states[(states.index(robot['state']) + 1 ) % len(states)]},
headers = {'Content-Type': 'application/json'})
time.sleep(3)
class AutoDrone (Drone, Thread):
"""
AR Drone 2.0 qui suit une cible à l'aide de la caméra avant.
Classe abstraite.
"""
__metaclass__ = ABCMeta
CAM_RES = (640,360)
VID_PORT = 5555
# Frames per cmd -> combien de frames on attend pour envoyer une commande
DEF_FPC = 3
DEF_MIN_SPEED = 0.2
DEF_MAX_SPEED = 2
# La distance initiale de la caméra du drone à la cible, en m
DEF_INITIAL_D = 1
# Contrôleur proportionnel
KP_X = 2
KP_Y = 2
KP_Z = 0.8
# Contrôleur intégral
KI_X = 0.1
KI_Y = 0.1
KI_Z = 0.1
# Contrôleur dérivée
KD_X = 1
KD_Y = 1
KD_Z = 1
def __init__(self, stopped, min_speed=DEF_MIN_SPEED, max_speed=DEF_MAX_SPEED, verbosity=Drone.QUIET, fpc=DEF_FPC, initial_d=DEF_INITIAL_D):
"""
[stopped] -> cf Drone.
[min_speed] et [max_speed] -> Les vitesses min et max que l'on peut avoir en donnant des ordres au drone (selon le drone).
[verbosity] -> cf Drone.
[fpc] -> Le nombre d'images que l'on attend avant d'envoyer une commande (règle la précision et la réactivité).
[initial_d] -> La distance initiale entre la cible et le drone lors de sa sélection (pour se déplacer en avant et en arrière).
[mode] -> Selon si l'on choisit nous-même la zone d'image à suivre ou si le drone le fait automatiquement.
"""
Drone.__init__(self, stopped, max_speed, verbosity)
Thread.__init__(self)
self.min_speed = min_speed
self.max_speed = max_speed
self.tracking = False
self.queue = Queue(self, fpc)
self.frontCam()
self.initial_d = initial_d
self._autoMove_last_t = datetime.now()
# Contrôleur PID
self.pid_x = PID(kp=AutoDrone.KP_X, ki=AutoDrone.KI_X, kd=AutoDrone.KD_X)
self.pid_y = PID(kp=AutoDrone.KP_Y, ki=AutoDrone.KI_Y, kd=AutoDrone.KD_Y)
self.pid_z = PID(kp=AutoDrone.KP_Z, ki=AutoDrone.KI_Z, kd=AutoDrone.KD_Z)
################################################################################################################
################################################ Vidéo ##########################################
################################################################################################################
def bottomCam(self):
"""
Demande au drone de laisser sur le port vidéo le flux de la caméra du bas.
"""
self.config("video:video_channel", "1")
print "Choice : bottom camera"
def frontCam(self):
"""
Demande au drone de laisser sur le port vidéo le flux de la caméra du haut.
"""
self.config("video:video_channel", "0")
print "Choice : front camera"
def enableCam(self):
"""
Tenter de récupérer le flux sur le port vidéo.
"""
self.cam = cv2.VideoCapture( 'tcp://{0}:{1}'.format(Drone.IP, AutoDrone.VID_PORT) )
if not self.cam.isOpened():
print "Drone camera not reachable"
return False
print "Drone camera OK"
return True
def releaseCam(self):
self.cam.release()
def viewCam(self):
"""
Regarder le stream video en temps réel.
"""
cont, frame = self.cam.read()
while cont:
cv2.imshow('cam', frame)
cont, frame = self.cam.read()
if (cv2.waitKey(1) & 0xFF) == ord('q'):
cont = False
cv2.destroyAllWindows()
################################################################################################################
########################################## Déplacement autonome ##################################
################################################################################################################
def autoMove(self, roi):
"""
[roi] est la zone de l'image où se situe l'objet à suivre.
Extrapôle le décalage en x,y,z par rapport à la position idéale, et la fournit à la file d'attente.
Les vitesses en x,y,z sont régulées grâce à un contrôleur PID.
"""
mid_x = roi[0] + 0.5*roi[2]
mid_y = roi[1] + 0.5*roi[3]
# Prélèvement du temps
t = datetime.now()
delta_t = (t - self._autoMove_last_t).total_seconds()
self._autoMove_last_t = t
error_x = mid_x - self.ideal_center[0]
error_y = self.ideal_center[1] - mid_y
# Pour x et y, c'est simple : on regarde l'éloignement par rapport au centre de la frame et on y applique un correcteur PID
x_speed = self.pid_x.getOrder(error_x, delta_t) / AutoDrone.CAM_RES[0]
y_speed = self.pid_y.getOrder(error_y, delta_t) / AutoDrone.CAM_RES[1]
# Pour z, -> cf doc. (formule de trigo). On fait la moyenne des quotients sur x et sur y.
z_speed = 0
if roi[2] != 0 and roi[3] != 0:
d = self.initial_d * ( self.ideal_target[2] / roi[2] + self.ideal_target[3] / roi[3] )/2
error_z = d - self.initial_d
z_speed = self.pid_z.getOrder(error_z, delta_t)
verif = lambda x : x if -1 < x < 1 else (1.0 if x>0 else -1.0)
x_speed,y_speed,z_speed = map(verif, (x_speed, y_speed, z_speed))
self.queue.add((x_speed,y_speed,z_speed))
self.queue.check()
def processVector(self, vector):
print "{} {} {}".format(vector.x, vector.y, vector.z)
self.move(False, 0, vector.z, vector.y, vector.x)
# DBG
#self.move(False, 0, vector.z, 0, 0)
@abstractmethod
def initROI(self):
pass
def showGUI(self, frame, roi):
"""
Par défaut, on affiche la zone détectée.
"""
frame_copy = deepcopy(frame)
cv2.rectangle(frame_copy, (int(roi[0]), int(roi[1])), (int(roi[2]+roi[0]), int(roi[3]+roi[1])), (0,0,255), thickness=7)
cv2.rectangle( frame_copy,
(self.ideal_target[0], self.ideal_target[1]),
(self.ideal_target[0]+self.ideal_target[2], self.ideal_target[1]+self.ideal_target[3]),
(0,255,0), thickness=7 )
cv2.imshow("Drone camera", frame_copy)
if cv2.waitKey(1) & 0xFF == ord('q'):
self.tracking= False
def run(self):
"""
Globalement, ce que fait la fonction:
/////// Initialisation ///////
+ on choisit la zone d'image (ROI en anglais) manuellement ou automatiquement, qui sera la zone à suivre pendant la suite. (1)
+ on définit à partir de la ROI choisie la cible parfaite (dimensions initialies et située au centre de l'écran). (2)
+ on suit la cible à l'aide d'un algorithme de traçage, appelé MedianFlow. (3)
/////// En boucle ///////
+ on récupère la position de l'objet à traçer, puis on la compare à la position idéale et on bouge en fonction. (4)
+ on vérifie qu'il n'y ait pas trop de latence, sinon on supprime les commandes trop anciennes.(5)
"""
if hasattr(self, 'cam'):
self.releaseCam()
self.tracking = self.enableCam()
#1
self.initROI()
#2
self.ideal_target = (int( (AutoDrone.CAM_RES[0]-roi[2])/2 ), int( (AutoDrone.CAM_RES[1]-roi[3])/2 ), int(roi[2]), int(roi[3]))
self.ideal_center = (self.ideal_target[0] + self.ideal_target[2]/2, self.ideal_target[1] + self.ideal_target[3]/2)
self.ideal_area = self.ideal_target[2]*self.ideal_target[3]
#3
tracker = cv2.TrackerMedianFlow_create()
if self.tracking:
self.tracking = tracker.init(frame, roi)
while self.tracking:
check_time = datetime.now()
#4
self.autoMove(roi)
self.showGUI(frame, roi)
_, roi = tracker.update(frame)
if self.tracking:
self.tracking, frame = self.cam.read()
#5
latency = (datetime.now() - check_time).total_seconds()
if latency >= 1.0:
self.queue.empty()
print "WARNING : REALLY TOO SLOW!!!"
if latency >= 0.2:
print "WARNING : high latency : {} s.".format(latency)
def inactivate(self):
self.tracking = False
Drone.inactivate(self)
self.releaseCam()
class Scheduler(Thread):
file_semaphore = Semaphore()
def __init__(self,controller,dispatch,error):
Thread.__init__(self)
self.policy = policy.get_policy()
self.controller = controller
self.do_dispatch = dispatch
self.error = error
self.queue = Queue()
self.queue.load()
self.lock = Lock()
self._quit = Event()
self.add_queue = SyncQueue(0)
self.num_run = 0
self.log = get_logger()
def job(self,id):
return self.queue.get(id)
def jobs(self):
return self.queue.get()
def save(self):
self.queue.save()
def add(self,item):
if self.lock.acquire(0):
self.queue.add(item)
self.lock.release()
else:
self.add_queue.put(item)
def add_url(self,url,referer=None):
try:
fd = urlopen(url,referer=referer)
meta = fd.read()
fullurl = fd.geturl()
fd.close()
save_torrent = 1
if fullurl.startswith('file://'):
torrent_file = urllib.unquote(url)
if torrent_file.startswith('file://'):
torrent_file = torrent_file[7:]
elif fullurl.startswith('file:/') and fullurl[8] == '|':
torrent_file = urllib.unquote(url)
torrent_file = torrent_file[7]+':'+torrent_file[9:]
if torrent_file.find('Temporary Internet Files') >= 0:
filename = os.path.split(url)[1]
torrent_file = os.path.join(self.policy(policy.TORRENT_PATH),
filename)
else:
filename = urllib.unquote(os.path.split(url)[1])
torrent_file = os.path.join(self.policy(policy.TORRENT_PATH),
filename)
torrent_path = os.path.dirname(torrent_file)
if not os.path.exists(torrent_path):
os.mkdir(torrent_path)
if save_torrent:
fd = open(torrent_file,'wb')
fd.write(meta)
fd.close()
#~ d = Download() #cbt
try: #cbt
rd = bdecode(meta) #cbt
if rd['cbt_user'] == self.policy(policy.CBT_LOGIN): #cbt
dest_path = rd['cbt_path'] #cbt
except: #cbt
dest_path = self.policy(policy.DEST_PATH) #cbt
self.add(QueueEntry(torrent_file, dest_path=dest_path)) #cbt
except Exception,why:
return str(why)
from stack import Stack
from queue import Queue
if __name__ == '__main__':
print 'Stack'
stack = Stack()
name = 'Maikel Maciel Ronnau'
[stack.push(x) for x in name]
for x in name:
print stack.pop().data,
print
print '\nQueue'
queue = Queue()
name = 'Maikel Maciel Ronnau'
[queue.add(x) for x in name]
for x in name:
print queue.remove().data,
def demo():
a = Queue()
a.add(Node(1)); a.add(Node(2)); a.add(Node(3)); a.add(Node(4)); a.add(Node(5))
print a
print answer(a)