Esempio n. 1
0
 def test_enqueue_five_elements_and_iterate_queue(self):
     queue = Queue()
     langs = ['python', 'java', 'ruby', 'php', 'go']
     for lang in langs:
         queue.enqueue(lang)
     self.assertEqual(len(langs), queue.size())
     for element in queue:
         self.assertIn(element, langs)
Esempio n. 2
0
def bfs(start):
	start.setDistance(0)
	start.setPred(None)
	# Queue for hold vertexes.
	vertQueue = Queue()
	vertQueue.enqueue(start)

	while vertQueue.size() > 0:
		# Get first value from queue.
		curVertex = vertQueue.dequeue()
		# Go through all the neigbors of the current vertex.
		for nbr in curVertex.getConnections():
			# Check if the neighbor was not achieved.
			if nbr.getColor() == 'white':
				# Mark neighbor as achieved.
				nbr.setColor('grey')
				# Compute distance between current vertex and neighbor.
				nbr.setDistance(curVertex.getDistance() + 1)
				# Set predecessor as a current vertex for,
				# for afterwards recreate the path.
				nbr.setPred(curVertex)
				# Add neighbor to end of queue.
				vertQueue.enqueue(nbr)
		# Mark current vertex as passed.
		curVertex.setColor('black')
Esempio n. 3
0
class PostMessage(App):
    '''
    Join messages from previous processor
    '''
    def __init__(self, config):
        super(PostMessage, self).__init__()

        self.queue = Queue(config)

    def run(self, process=None):
        self.logger.info('Start ...')

    def process(self, messages=None):
        if messages:
            self.queue.post(messages)
Esempio n. 4
0
 def breadth_first(self):
     visited = Queue()
     visited.enqueue(self)
     while visited:
         try:
             node = visited.dequeue()
         except LookupError:
             return
         if node.left:
             visited.enqueue(node.left)
         if node.right:
             visited.enqueue(node.right)
         yield node
Esempio n. 5
0
    def level_order_traverse(root):
        if root is None:
            return

        queue = Queue()
        queue.enqueue(root)
        while not queue.is_empty():
            node = queue.dequeue()
            print node,
            if node.lchild is not None:
                queue.enqueue(node.lchild)
            if node.rchild is not None:
                queue.enqueue(node.rchild)

        print
Esempio n. 6
0
 def breadth_first(self):
     visited = Queue()
     visited.enqueue(self)
     while visited:
         try:
             node = visited.dequeue()
         except LookupError:
             return
         if node.left:
             visited.enqueue(node.left)
         if node.right:
             visited.enqueue(node.right)
         yield node
Esempio n. 7
0
 def test_enqueue_five_elements_to_queue_and_dequeue_all_elements(self):
     queue = Queue()
     langs = ['python', 'java', 'ruby', 'php', 'go']
     for lang in langs:
         queue.enqueue(lang)
     self.assertEqual(len(langs), queue.size())
     element1 = queue.dequeue()
     element2 = queue.dequeue()
     element3 = queue.dequeue()
     element4 = queue.dequeue()
     element5 = queue.dequeue()
     self.assertEqual('python', element1)
     self.assertEqual('java', element2)
     self.assertEqual('ruby', element3)
     self.assertEqual('php', element4)
     self.assertEqual('go', element5)
     self.assertTrue(queue.is_empty())
Esempio n. 8
0
 def test_dequeue(self):
     queue = Queue()
     queue.enqueue(1)
     queue.enqueue(2)
     queue.enqueue(13)
     queue.enqueue(31)
     # assert that the item dequeued was the item at the head
     self.assertEqual(queue.dequeue(), 1)
     # assert that the item at the head of the linked list was removed
     self.assertEqual(queue.items.walk(), [2, 13, 31])
Esempio n. 9
0
 def _bfs(self, node_name):
     search_queue = Queue()
     search_queue.add(self.root)
     while len(search_queue) > 0:
         n = search_queue.remove()
         if n.name == node_name:
             return n
         for c in n.get_children():
             search_queue.add(c)
     return None
Esempio n. 10
0
 def test_enqueue(self):
     queue = Queue()
     queue.enqueue(1)
     queue.enqueue(2)
     queue.enqueue(13)
     queue.enqueue(31)
     self.assertEqual(queue.items.walk(), [1, 2, 13, 31])
Esempio n. 11
0
 def test_enqueue_five_elements_to_queue_and_dequeue_two_elements(self):
     queue = Queue()
     langs = ['python', 'java', 'ruby', 'php', 'go']
     for lang in langs:
         queue.enqueue(lang)
     self.assertEqual(len(langs), queue.size())
     element1 = queue.dequeue()
     element2 = queue.dequeue()
     self.assertEqual('python', element1)
     self.assertEqual('java', element2)
     self.assertEqual(3, queue.size())
Esempio n. 12
0
 def setUp(self):
     self.data = ["d1", "d2"]
     self.l1 = Queue()
     self.l2 = Queue()
     self.l3 = Queue()
     self.l2.add(self.data[0])
     for datum in self.data:
         self.l3.add(datum)
def bfs(g, start):
    start.set_distance(0)
    start.set_pred(None)
    vert_queue = Queue()
    vert_queue.enqueue(start)

    while vert_queue.size() > 0:
        current_vert = vert_queue.dequeue()
Esempio n. 14
0
 def bft_print_tree(self):
     """breadth first traversal method to print a tree """
     if self is None:
         return None
     # make a queue, add thehfirst node
     current = self
     lst = Queue()
     lst.enqueue(current.value)
     # while queue is not empty
     while len(lst) > 0:
         # remove the current, and print it
         print(lst.dequeue())
         # add all children of the current
         if current.left:
             current = current.left
             lst.enqueue(current.value)
         if current.right:
             current = current.right
             lst.enqueue(current.value)
Esempio n. 15
0
    def __init__(self, main_window):
        Gtk.Grid.__init__(self)
        self.main_window = main_window
        self.set_column_homogeneous = True

        self.queue = Queue()

        self.set_column_spacing(100)

        results_box = Gtk.ListBox()
        self.results_line = Gtk.ListBox()
        results_box.set_border_width(4)
        results_box.add(self.results_line)

        schedule_button = Gtk.Button('Schedule')
        schedule_button.connect('clicked', self.schedule)

        results_box.set_hexpand(True)
        results_box.add(schedule_button)

        self.attach(results_box, 0, 0, 1, 1)

        processes_box = Gtk.ListBox()
        self.process_lines = Gtk.ListBox()
        processes_box.add(self.process_lines)
        add_process_button = Gtk.Button('Add Process')
        add_process_button.connect('clicked', self.add_process_dialog)

        processes_box.set_hexpand(True)
        processes_box.set_border_width(5)
        processes_box.add(add_process_button)

        self.attach(processes_box, 3, 0, 1, 1)

        self.gantt_chart_box = Gtk.Box()
        self.gantt_chart_box.add(Gtk.Label('GANTT CHART GOES HERE'))
        self.attach(self.gantt_chart_box, 0, 1, 3, 1)
Esempio n. 16
0
    def bfs(self, current):
        # Implementation: Iterative 1
        if current is None:
            return
        queue = Queue()
        queue.enqueue(current)

        while current is not None:
            current = current.next_sibling

            if queue and current is None:
                current = queue.dequeue().first_child

            if current and current.first_child:
                queue.enqueue(current)
Esempio n. 17
0
    def _get_node(self, element):
        queue = Queue()
        queue.enqueue(self.root)

        while queue:
            current = queue.dequeue()
            if current.element == element:
                return current

            children = current.get_children()

            if children:
                for child in children:
                    queue.enqueue(child)
        return None
Esempio n. 18
0
    def move(self, element, parent):
        moving_node = self._get_node(element)
        destination_node = self._get_node(parent)

        if not moving_node:
            raise ElementNotFoundError(
                "Could not find element {}".format(element))

        if not destination_node:
            raise ElementNotFoundError(
                "Could not find parent {}".format(parent))

        if moving_node == self.root:
            raise MovingRootError("Cannot move root node.")

        parent_node = None
        previous_sibling_node = None

        queue = Queue()
        queue.enqueue(self.root)

        while queue:
            current = queue.dequeue()

            if current.first_child == moving_node:
                parent_node = current
            if current.next_sibling == moving_node:
                previous_sibling_node = current

            if current == moving_node:
                break

            children = current.get_children()
            if children:
                for child in children:
                    queue.enqueue(child)

        if parent_node:
            parent_node.first_child = moving_node.next_sibling

        if previous_sibling_node:
            previous_sibling_node.next_sibling = moving_node.next_sibling

        next_sibling_node = destination_node.first_child
        destination_node.first_child = moving_node
        moving_node.next_sibling = next_sibling_node
Esempio n. 19
0
class TestQueue(unittest.TestCase):
    def setUp(self):
        self.data = ["d1", "d2"]
        self.l1 = Queue()
        self.l2 = Queue()
        self.l3 = Queue()
        self.l2.add(self.data[0])
        for datum in self.data:
            self.l3.add(datum)

    def test_Queue__init__(self):
        self.assertEqual(self.l1.head, None)
        self.assertEqual(self.l1.len, 0)

    def test_Queue__iter__(self):
        for n in self.l1:
            self.assertTrue(False)
        for l in [self.l2, self.l3]:
            for n in l:
                self.assertTrue(repr(n) in self.data)

    def test_Queue_add(self):
        len1 = len(self.l1)
        self.l1.add("foo")
        self.assertTrue(len(self.l1) - len1 == 1)
        self.assertTrue(self.l1.remove() == "foo")

    def test_Queue_remove(self):
        self.assertTrue(self.l3.remove() == self.data[0])

    def test_Queue__len__(self):
        self.assertEquals(len(self.l1), 0)
        self.assertEquals(len(self.l2), 1)
        self.assertEquals(len(self.l3), 2)

    def test_Queue__repr__(self):
        self.assertEquals(repr(self.l1), '')
        self.assertEquals(repr(self.l2), 'd1')
        self.assertEquals(repr(self.l3), 'd1 -> d2')
Esempio n. 20
0
 def __init__(self):
     self._queue_one = Queue()
     self._queue_two = Queue()
Esempio n. 21
0
 def test_peak(self):
     queue = Queue()
     queue.enqueue(1)
     self.assertEqual(queue.peek(), 1)
     queue.enqueue(2)
     self.assertEqual(queue.peek(), 1)
     queue.enqueue(13)
     self.assertEqual(queue.peek(), 1)
     queue.dequeue()
     self.assertEqual(queue.peek(), 2)
Esempio n. 22
0
 def test_empty_list(self):
     queue = Queue()
     # assert that an empty linked list is created
     self.assertEqual(queue.items.head, None)
     self.assertEqual(queue.items.tail, None)
     self.assertEqual(queue.items.walk(), [])
Esempio n. 23
0
    def __init__(self, config):
        super(PostMessage, self).__init__()

        self.queue = Queue(config)
Esempio n. 24
0
 def test_no_element_in_queue(self):
     queue = Queue()
     self.assertTrue(queue.is_empty())
Esempio n. 25
0
class StackUsingQueue(object):
    def __init__(self):
        self._queue_one = Queue()
        self._queue_two = Queue()

    def __str__(self):
        return self._queue_one.__str__()

    def push(self, element):
        '''
            :param element: element to be pushed onto stack
        '''
        while not self._queue_one.is_empty():
            self._queue_two.enqueue(self._queue_one.dequeue())

        self._queue_one.enqueue(element)

        while not self._queue_two.is_empty():
            self._queue_one.enqueue(self._queue_two.dequeue())
        return

    def pop(self):
        return self._queue_one.dequeue()
Esempio n. 26
0
 def test_enqueue_one_element_to_queue(self):
     queue = Queue()
     queue.enqueue('python')
     self.assertEqual(1, queue.size())
Esempio n. 27
0
class MainWindow(Gtk.Grid):
    def __init__(self, main_window):
        Gtk.Grid.__init__(self)
        self.main_window = main_window
        self.set_column_homogeneous = True

        self.queue = Queue()

        self.set_column_spacing(100)

        results_box = Gtk.ListBox()
        self.results_line = Gtk.ListBox()
        results_box.set_border_width(4)
        results_box.add(self.results_line)

        schedule_button = Gtk.Button('Schedule')
        schedule_button.connect('clicked', self.schedule)

        results_box.set_hexpand(True)
        results_box.add(schedule_button)

        self.attach(results_box, 0, 0, 1, 1)

        processes_box = Gtk.ListBox()
        self.process_lines = Gtk.ListBox()
        processes_box.add(self.process_lines)
        add_process_button = Gtk.Button('Add Process')
        add_process_button.connect('clicked', self.add_process_dialog)

        processes_box.set_hexpand(True)
        processes_box.set_border_width(5)
        processes_box.add(add_process_button)

        self.attach(processes_box, 3, 0, 1, 1)

        self.gantt_chart_box = Gtk.Box()
        self.gantt_chart_box.add(Gtk.Label('GANTT CHART GOES HERE'))
        self.attach(self.gantt_chart_box, 0, 1, 3, 1)

    def add_process_dialog(self, widget):
        self.dialog = Gtk.Dialog('Add Process', self.main_window)
        dialog_main_window = self.dialog.get_content_area()

        #Row for the text fields
        first_row = Gtk.Box(spacing=50)

        #Row for the Add and Cancel buttons
        second_row = Gtk.Box(spacing=50)

        #Row for validation information
        third_row = Gtk.Box(spacing=50)

        dialog_main_window.add(first_row)
        dialog_main_window.add(second_row)
        dialog_main_window.add(third_row)

        #Add the text fields to the first row
        self.process_name_input = Gtk.Entry()
        self.process_name_input.set_text('Process Name')

        self.process_time_input = Gtk.Entry()
        self.process_time_input.set_text('4')

        self.process_arrival_input = Gtk.Entry()
        self.process_arrival_input.set_text('1')

        first_row.pack_start(self.process_name_input, True, True, 0)
        first_row.pack_start(self.process_time_input, True, True, 0)
        first_row.pack_start(self.process_arrival_input, True, True, 0)

        #Add the buttons to the second row

        add_process_button = Gtk.Button('Add')
        add_process_button.connect('clicked', self.validate)

        cancel_button = Gtk.Button('Cancel')
        cancel_button.connect('clicked', self.cancel)
        second_row.pack_start(add_process_button, True, True, 0)
        second_row.pack_start(cancel_button, True, True, 0)

        #Add the validations row
        self.validations = Gtk.Label()
        third_row.pack_start(self.validations, True, True, 0)

        self.dialog.show_all()

    def cancel(self, widget):
        self.dialog.close()

    def validate(self, widget):
        process_name = self.process_name_input.get_text()
        process_time = self.process_time_input.get_text()
        process_arrival = self.process_arrival_input.get_text()

        try:
            process_time = int(process_time)
            process_arrival = int(process_arrival)
            if (process_arrival < 0 and process_time < 0
                    and process_name is ''):
                raise Exception('')
            self.queue.addProcess(
                NormalProcess(process_name, process_arrival, process_time))
        except Exception as e:
            self.validations.set_label(
                'The Process Name is Required, and the process arrival and Time should be non-negative integers'
            )
        else:
            self.cancel(widget)
            self.draw_queue()

    def draw_queue(self):
        for child in self.process_lines.get_children():
            self.process_lines.remove(child)
        for process in self.queue.processes:
            t = str(process.name) + " /// " + str(
                process.arrival) + " /// " + str(process.time)
            self.process_lines.add(Gtk.Label(t))
            self.process_lines.show_all()

    def schedule(self, widget):
        pass

    def draw_gantt(self, gantt_chart):
        for child in self.gantt_chart_box.get_children():
            self.gantt_chart_box.remove(child)

        for process in gantt_chart.chart:
            l = 'X'
            if process is not None:
                l = process.name
            l = Gtk.Button(l)
            self.gantt_chart_box.add(l)
            self.gantt_chart_box.show_all()
Esempio n. 28
0
class TestQueue(unittest.TestCase):
    def setUp(self):
        self.queue = Queue()

    def tearDown(self):
        return super().tearDown()

    def test_size(self):
        self.assertEqual(self.queue.size(), 0)

    def test_enqueue(self):
        self.queue.enqueue(1)
        self.assertEqual(self.queue.size(), 1)

    def test_dequeue(self):
        self.queue.enqueue(1)
        self.assertEqual(self.queue.dequeue(), 1)
        self.assertEqual(self.queue.size(), 0)

    def test_front(self):
        self.queue.enqueue(1)
        self.assertEqual(self.queue.front(), 1)

    def test_dequeue_exception(self):
        self.assertIsNone(self.queue.dequeue())

    def test_front_exception(self):
        self.assertIsNone(self.queue.front())
Esempio n. 29
0
 def setUp(self):
     self.queue = Queue()
Esempio n. 30
0
#!/usr/bin/python

import sys, os, json
sys.dont_write_bytecode = True
from queue.queue import Queue
import bson.json_util

exportdir="/tmp/snerimport"

def writefile(filename, data):
	if not data: data=""
	with open(filename,'w') as f:
                f.write(data)
	f.close()

	
q = Queue()
workedlist = q.worked_list(data=True)

if workedlist and os.path.exists(exportdir) == False:
	os.mkdir(exportdir)

for item in workedlist:
	dumpfile = exportdir+"/"+item["id"]+"."+item["type"]
	if item["type"] == "input":
		writefile(dumpfile, bson.json_util.dumps(item, indent=2))
	else:
		writefile(dumpfile, item.get("data", ""))

Esempio n. 31
0
    def test_queue(self):
        q = Queue()
        q.append(2)
        q.append(3)
        self.assertEqual(q.size() == 2, True)
        val = q.pop()
        self.assertEqual(val == 2, True)
        self.assertEqual(q.size() == 1, True)

        self.assertEqual(q.pop() == 3, True)
        self.assertEqual(q.pop() == None, True)

        val = [1, 2, 3, 4, 5]
        for v in val:
            q.append(v)
        for v in val:
            self.assertEqual(q.pop() == v, True)
Esempio n. 32
0
 def test_queue(self):
     q = Queue(1)
     q.enqueue(2)
     q.enqueue(3)
     assert q.peek() == 1
     assert q.dequeue() == 1
     q.enqueue(4)
     assert q.dequeue() == 2
     assert q.dequeue() == 3
     assert q.dequeue() == 4
     q.enqueue(5)
     assert q.peek() == 5
Esempio n. 33
0
#!/usr/bin/python

import sys
sys.dont_write_bytecode = True
from queue.queue import Queue

q = Queue()
q.flush()
Esempio n. 34
0
#!/usr/bin/python

import sys
sys.dont_write_bytecode = True
from queue.queue import Queue

q = Queue()
try:
	with open(sys.argv[1],'r') as f:
        	content = f.read()
	
	items = content.replace(',',' ').replace('\n',' ').split()
        q = Queue()
        for i in items:
        	q.work_add(i.rstrip())

except Exception as e:
	print "ERROR: push to queue failed", e