def bi_directional_search(self, src, dst):
self._add_inverted_children()
self.reset_node_paths()
queue_src = Queue()
queue_dst = Queue()
src_visited = set()
dst_visited = set()
queue_src.add(src)
src_visited.add(src)
queue_dst.add(dst)
dst_visited.add(dst)
collided = False
while not queue_src.is_empty() or not queue_dst.is_empty():
if len(src_visited.intersection(dst_visited)) > 0:
collided = True
break
if not queue_src.is_empty():
src_output = queue_src.remove()
for child in src_output.children:
if child not in src_visited:
child.forward_pre = src_output
queue_src.add(child)
src_visited.add(child)
if len(src_visited.intersection(dst_visited)) > 0:
collided = True
break
if not queue_dst.is_empty():
dst_output = queue_dst.remove()
if dst_output in self.inverted:
for child in self.inverted[dst_output]:
if child not in dst_visited:
child.backward_pre = dst_output
queue_dst.add(child)
dst_visited.add(child)
if collided:
intersect = src_visited.intersection(dst_visited).pop()
forward = []
ref = intersect
while ref is not None:
forward = [ref.data] + forward
ref = ref.forward_pre
ref = intersect
backward = []
while ref is not None:
backward += [ref.data]
ref = ref.backward_pre
return forward[:-1] + backward
else:
return []
def simulation(numseconds, pagesperminute):
labprinter = Printer(pagesperminute)
printerqueue = Queue()
waitingtimes = []
longestqueue = 0
for currentsecond in range(numseconds):
if newprinttask():
newtask = Task(currentsecond)
printerqueue.enqueue(newtask)
if printerqueue.size() > longestqueue:
longestqueue = printerqueue.size()
if not labprinter.busy() and printerqueue.has_items():
nexttask = printerqueue.dequeue()
waitingtimes.append(nexttask.waittime(currentsecond))
labprinter.startnext(nexttask)
labprinter.tick()
averagewait = sum(waitingtimes) / len(waitingtimes)
print "Average Wait %6.2f secs %3d tasks remaining." % (
averagewait, printerqueue.size())
print "The longest the queue got to was %d tasks. \n" % (longestqueue)
def __startFromDeath(self):
"""
Starts from an unexpected power loss. Retreives last known position from temp file.
Issues: Target stage *could* be manually moved on us prior to reviving. User initiative to ensure
nothing moves.
:return: None
"""
if self.s:
self.queue = None
currentline = self.__retrieveTempData()
try:
f = open(self.filename, 'r')
self.queue = Queue()
positionFound = False
for line in f:
if line == currentline:
positionFound = True
if positionFound:
if line != '' and line[0] != ';':
self.queue.enqueue(line)
print('Loaded ' + self.filename)
self.start_from_death_btn.configure(text='Start?',
fg='green',
command=self.runFile)
except FileNotFoundError:
self.file_entry.delete(0, 'end')
self.file_entry.insert(0, 'File does not exist')
else:
self.start_from_death_btn.configure(text='Not\nconnected')
self.window.after(
5000, lambda: self.start_from_death_btn.configure(
text='Load\nData?'))
def initMasterQueue():
masterQueue = Queue(MAX_SIZE)
i = 0
while i < 4:
masterQueue.enqueue(int(
input("Enter a master key code input (1-4): ")))
i += 1
return masterQueue
def test_hot_potato(self):
players = Queue()
names = ["Gloria", "Schwern", "Frankie", "Eric"]
for name in names:
players.enqueue(name)
test_input = StringIO("1\n1\n1\n")
sys.stdin = test_input
sys.stdout = StringIO()
self.assertEqual(hot_potato(players), "Gloria")
def player_builder():
print "Let's play hot potato! Please enter the names of the players, type 'DONE' when done."
name = raw_input('> ')
players = Queue()
while (name != 'DONE'):
players.enqueue(name)
name = raw_input('> ')
return players
def test_size(self):
queue = Queue()
self.assertEqual(queue.size(), 0)
self.assertEqual(queue.inefficient_size(), 0)
queue.enqueue('thing 1')
queue.enqueue('thing2')
queue.enqueue('thing3')
self.assertEqual(queue.size(), 3, 'size works')
self.assertEqual(queue.inefficient_size(), 3, 'inefficient_size works')
queue.dequeue()
self.assertEqual(queue.size(), 2)
self.assertEqual(queue.size(), queue.inefficient_size(), 'size methods equal')
def _bfs(self, start_node):
result = []
queue = Queue()
queue.add(start_node)
self.visited.add(start_node)
while not queue.is_empty():
output_node = queue.remove()
for child in output_node.children:
if child not in self.visited:
queue.add(child)
self.visited.add(child)
result += [output_node.data]
return result
def getFile(self, filename):
"""
Opens file containing gcode. Does not parse for correctness.
Inputs all non blank lines / comments into a queue for usage
:param filename: File to open
:return: None
"""
# queue with timing calculation for next move
# wipe queue
self.queue = None
try:
self.filename = filename
f = open(filename, 'r')
self.queue = Queue()
for line in f:
if line != '' and line[0] != ';':
self.queue.enqueue(line)
self.output.insert('end', '\n' + '> ' + ' Loaded ' + filename)
self.output.yview(tk.END)
except FileNotFoundError:
self.file_entry.delete(0, 'end')
self.output.insert('end', '\n' + '!> ' + ' File does not exist')
self.output.yview(tk.END)
# actual code to do program ----
from time import sleep
from QueueClass import Queue
import RPi.GPIO as GPIO
from time import sleep
from sendmail import send_mail
MAX_SIZE = 4
CHANNELTOINPUT = {} # dictionary associating the channel with its input value
CHANNEL1 = 7
CHANNEL2 = 11
CHANNEL3 = 13
CHANNEL4 = 15
ledPin = 12
# Pins to use for buttons : Pin 7, Pin 11, Pin 13, Pin 15
queue = Queue(MAX_SIZE) # global queue to hold the input buttons
#Sets up the gpio pins for the buttons for input and output
def setup():
GPIO.setmode(GPIO.BOARD)
GPIO.setup(CHANNEL1, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(CHANNEL2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(CHANNEL3, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(CHANNEL4, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(ledPin, GPIO.OUT)
# Initalizes the queue that will represent the buttons the user must push to "successfully" open/ turn on led
def initMasterQueue():
def test_dequeue(self):
queue = Queue()
queue.enqueue('thingi')
self.assertEqual(queue.dequeue(), 'thingi')
self.assertTrue(queue.is_empty())
def test_has_items(self):
queue = Queue()
self.assertFalse(queue.has_items())
queue.enqueue('a thing')
self.assertTrue(queue.has_items())
def test_is_empty(self):
queue = Queue()
self.assertTrue(queue.is_empty())
queue.enqueue('an item')
self.assertFalse(queue.is_empty())
def test_is_empty(self):
schwerns_queue = Queue()
self.assertTrue(schwerns_queue.is_empty())
schwerns_queue.enqueue('dicks')
self.assertFalse(schwerns_queue.is_empty())
def setUp(self):
self.queue = Queue()
def __init__(self):
self.dog_queue = Queue()
self.cat_queue = Queue()
