def __init__(self, url, views, visits=0):
self.recentProxies = Queue()
self.proxies = Queue()
self.renewDriver = True
self.isActive = True
self.isAlive = True
self.views = views
self.visits = visits
self.url = url
self.scraper = Scrape(maxSize=30, protocol='SSL', cleanProxies=True)
def setUp(self):
# Create queues for the tests to use
self.new = Queue()
self.empty = Queue()
self.empty.enqueue('hi')
self.empty.dequeue()
# Don't add in ascending or descending order
self.non_empty = Queue()
self.non_empty.enqueue(5)
self.non_empty.enqueue(2)
self.non_empty.enqueue(7)
self.non_empty.enqueue(2)
def test_dequeue_different_sizes(self, lst: list) -> None:
"""
Tests the Queue.dequeue method on queues with different amounts of items.
"""
q = Queue(lst)
while not q.is_empty():
self.assertEqual(lst.pop(0), q.dequeue())
def main():
print "\ncheck stack"
stack = Stack(1, 2, 34, 5)
for x in range(0, 5):
stack.push(x)
print stack
for x in range(0, 15):
print "".join(["size=", str(len(stack)), " cur_node=", str(stack.pop())])
print "\ncheck queue"
queue = Queue(1, 2, 34, 5)
for x in range(0, 5):
queue.enter(x)
print stack
for x in range(0, 15):
print "".join(["size=", str(len(queue)), " cur_node=", str(queue.exit())])
print "\ncheck BSTree"
tree = BSTree(1, 2, 34, 5)
print tree
print tree.find(10)
print tree.find(5)
print tree.max()
print tree.min()
print tree.successor(34)
print tree.successor(5)
print tree.predecessor(1)
print tree.predecessor(2)
def test_items(self):
q = Queue()
q.enqueue('A')
q.enqueue('B')
assert ['A', 'B'] == q.items()
def eliminated(people, skip):
"""Return a list of the positions of people as they are eliminated.
The position of the last person standing is at the end of the list.
Assume people is a positive integer.
Assume skip is a non-negative integer.
For example:
>>> eliminated(3, 0)
[1, 2, 3]
>>> eliminated(3, 1)
[2, 1, 3]
>>> eliminated(3, 4)
[2, 3, 1]
"""
assert people > 0
assert skip >= 0
circle = Queue()
for position in range(1, people + 1):
circle.enqueue(position)
positions = []
while circle:
for _skipped in range(skip):
circle.enqueue(circle.dequeue())
positions.append(circle.dequeue())
return positions
def initialize(self):
self.db = mongo
self.search_cache = Cache(master=False, db=config.Cache.searchdb)
self.hot_image_cache = Cache(master=False, db=config.Cache.imagedb)
self.queue = Queue()
self.session = Session(self,
MemcacheStore(),
initializer={
'nickname': None,
'uid': None,
'avatar': None,
'email': None,
'super': False,
'channel': None,
'login': False,
'net': None,
'reso': None,
'height': 0,
'width': 0,
'show_msg': None,
'hd': True
})
self.session.processor(self)
self.context = {
'se': self.session,
'static_server': config.Server.static_server,
'cdn': config.CDN.mhost,
}
def __init__(self, urllist, visits, min, max):
self.bots = 5 # max amount of bots to use
self.count = 0 # returning bots
self.ip = None
self.alive = True
self.targets = {} # {url: visits}
self.ip_usage = 0
self.ip_fails = 0
self.max_fails = 3
self.max_usage = 3
self.proto = 'https'
self.recentIPs = Queue(15)
self.requesting_ip = False
self.min = int(min)
self.max = int(max)
self.visits = int(visits)
if not path.exists(urllist):
exit('Error: Unable to locate `{}`'.format(urllist))
# read the url list
with open(urllist, 'r') as f:
try:
for url in [_ for _ in f.read().split('\n') if _]:
self.targets[url] = 0 # initial view
except Exception as err:exit('Error:', err)
def test_add_item(self):
q = Queue()
q.enqueue('A')
assert len(q) == 1
assert q.head.data == 'A'
assert q.tail.data == 'A'
def test_queue_init(self):
que = Queue()
self.assertEqual(que.size(), 0)
self.assertEqual(que.is_empty(), True)
with self.assertRaises(IndexError):
que.pop()
with self.assertRaises(IndexError):
que.peek()
def test_queue_push(self):
que = Queue()
random_values = get_random_values()
for v in random_values:
que.push(v)
self.assertEqual(que.is_empty(), False)
self.assertEqual(que.peek(), v)
self.assertEqual(que.pop(), v)
def test_queue_peek(self):
que = Queue()
random_values = get_random_values()
for v in random_values:
que.push(v)
for v in random_values:
self.assertEqual(que.peek(), v)
que.pop()
def __init__(self, word_list, order=2, sentences=1):
super().__init__()
self.order = order # order of the markov chain
self.sentences = sentences
self.memory = Queue(order) # for sampling from markov model
if word_list is not None:
self['START'] = Dictogram()
self._create_chain(word_list)
def test_queue_size(self):
que = Queue()
random_values = get_random_values()
for i, v in enumerate(random_values):
que.push(v)
self.assertEqual(que.size(), i + 1)
for i in range(len(random_values)):
que.pop()
self.assertEqual(que.size(), len(random_values) - i - 1)
def test_queue_reverse(self):
que = Queue()
random_values = get_random_values()
for v in random_values:
que.push(v)
que.reverse()
for v in random_values[::-1]:
self.assertEqual(que.peek(), v)
que.pop()
def del_min(self):
q = Queue()
del self.tree[0][0]
q.enqueue(self.tree[self.power][len(self.tree[self.power]) - 1])
del self.tree[self.power][len(self.tree[self.power]) - 1]
self.tree[0].insert(0, q.dequeue())
return self.tree
def test_serialize(self):
q = Queue()
q.enqueue('A')
q.enqueue('B')
items = q.serialize()
assert tuple(['A', 'B']) == items
def test_queue_copy(self):
que = Queue()
random_values = get_random_values()
for v in random_values:
que.push(v)
copied_que = que.copy()
for v in random_values:
self.assertEqual(copied_que.peek(), v)
copied_que.pop()
self.assertEqual(que.size(), len(random_values))
def hot_potato(name_list, num):
q = Queue()
for i in range(0, len(name_list)):
q.enqueue(name_list[i])
for j in range(0, len(name_list) - 1):
for k in range(0, num):
q.enqueue(q.dequeue())
q.dequeue()
remaining_person = q.dequeue()
return remaining_person
def convert_to_queue(word_list):
'''
Helper function to convert a word_list into a queue
'''
queue = Queue()
for word in word_list:
queue.enqueue(word)
return queue
def test_queue_reversed(self):
que = Queue()
random_values = get_random_values()
for v in random_values:
que.push(v)
reversed_queue = reversed(que)
for v in random_values[::-1]:
self.assertEqual(reversed_queue.peek(), v)
reversed_queue.pop()
self.assertEqual(que.size(), len(random_values))
def test_iteration(self):
q = Queue()
items = ['A', 'B']
for item in items:
q.enqueue(item)
for i, item in enumerate(q):
assert item.data == items[i]
def test_enqueue_different_sizes(self, lst: list) -> None:
"""
Tests the Queue.enqueue method on queues with different amounts of items.
"""
q = Queue(lst)
new_item = randint(-100, 100)
q.enqueue(new_item)
self.assertEqual(lst + [new_item], q.get_items())
def test_queue_is_empty(self):
que = Queue()
random_values = get_random_values()
self.assertEqual(que.is_empty(), True)
for v in random_values:
que.push(v)
self.assertEqual(que.is_empty(), False)
for v in random_values:
self.assertEqual(que.is_empty(), False)
que.pop()
self.assertEqual(que.is_empty(), True)
def test_enqueue_empty(self) -> None:
"""
Tests the Queue.enqueue method on empty queues.
"""
n = 0
while n <= 10:
q = Queue()
queue_item = randint(-100, 100)
q.enqueue(queue_item)
self.assertEqual([queue_item], q.get_items())
n += 1
def test_queue_pop(self):
que = Queue()
random_values = get_random_values()
for v in random_values:
que.push(v)
for v in random_values:
que.pop()
self.assertEqual(que.is_empty(), True)
with self.assertRaises(IndexError):
que.pop()
with self.assertRaises(IndexError):
que.peek()
def hot_potato(namelist, num):
q = Queue()
for name in namelist:
q.enqueue(name)
while q.size() > 1:
for i in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
def test_enqueue_size_one(self) -> None:
"""
Tests the Queue.enqueue method on queues with 1 item only.
"""
n = 0
while n <= 10:
initial_item = randint(-1000, 1000)
q = Queue([initial_item])
new_item = randint(-1000, 1000)
q.enqueue(new_item)
self.assertEqual([initial_item, new_item], q.get_items())
n += 1
def test_len(self):
q = Queue()
assert len(q) == 0
q.enqueue('A')
assert len(q) == 1
q.enqueue('B')
assert len(q) == 2
q.dequeue()
assert len(q) == 1
q.dequeue()
assert len(q) == 0
def flatorder(self, f):
result = []
queue = Queue(self.__root)
while not queue.empty():
cur_node = queue.exit()
result.append(f(cur_node.value))
if cur_node.left is not None:
queue.enter(cur_node.left)
if cur_node.right is not None:
queue.enter(cur_node.right)
return result
