Merge pull request #34 from AladdinPerzon/format_code

format code using black

Author: aladdinpersson

Algorithm_tests/cryptology_tests/ceasar_test.py

@@ -4,27 +4,25 @@
 
 # For importing from different folders
 # OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
-sys.path.append('Algorithms/cryptology/ceasar_shifting_cipher')
+sys.path.append("Algorithms/cryptology/ceasar_shifting_cipher")
 
 # If run from local:
-#sys.path.append('../../Algorithms/cryptology/ceasar_shifting_cipher')
+# sys.path.append('../../Algorithms/cryptology/ceasar_shifting_cipher')
 
 from ceasar_shift_cipher import encrypt, decrypt
 
 # Note this is not robust.. but im trying to make it a habit to make some tests.
 # Some are better than nothing. But these are not complete at all.
 class test_ceasar_cipher(unittest.TestCase):
-
     def setUp(self):
         # test cases we wish to run
-        self.message1 = 'abc'
+        self.message1 = "abc"
         self.shift1 = 3
-        self.correct_encrypt1 = 'def'
+        self.correct_encrypt1 = "def"
 
-        self.message2 = 'xyz '
+        self.message2 = "xyz "
         self.shift2 = 1
-        self.correct_encrypt2 = 'yz a'
-
+        self.correct_encrypt2 = "yz a"
 
     def test_encryption_message1(self):
         encrypted_message1 = encrypt(self.message1, self.shift1)
@@ -42,6 +40,7 @@ def test_decryption_message2(self):
         decrypted_message2 = decrypt(self.correct_encrypt2, self.shift2)
         self.assertEqual(decrypted_message2, self.message2)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     print("Running ceasar cipher tests:")
-    unittest.main()
+    unittest.main()

Algorithm_tests/dynamic_programming_tests/knapsack_tests/knapsack_bottomup_test.py

@@ -3,12 +3,13 @@
 
 # For importing from different folders
 # OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
-sys.path.append('Algorithms/dynamic_programming/knapsack')
+sys.path.append("Algorithms/dynamic_programming/knapsack")
 
 # If run from local:
-#sys.path.append('../../../Algorithms/dynamic_programming/knapsack/')
+# sys.path.append('../../../Algorithms/dynamic_programming/knapsack/')
 from knapsack_bottomup import knapsack
 
+
 class test_KnapSack(unittest.TestCase):
     def setUp(self):
         self.weights1, self.values1, self.capacity1 = [], [], 100
@@ -23,7 +24,11 @@ def setUp(self):
         self.n3 = len(self.weights2)
         self.correctvalue3, self.correctitems3 = 0, []
 
-        self.weights4, self.values4, self.capacity4 = [1, 2, 4, 2, 5], [5, 3, 5, 3, 2], 5
+        self.weights4, self.values4, self.capacity4 = (
+            [1, 2, 4, 2, 5],
+            [5, 3, 5, 3, 2],
+            5,
+        )
         self.n4 = len(self.weights4)
         self.correctvalue4, self.correctitems4 = 11, [0, 1, 3]
 
@@ -32,30 +37,41 @@ def setUp(self):
         self.correctvalue5, self.correctitems5 = 0, []
 
     def test_noitems(self):
-        total_value, items = knapsack(self.n1, self.capacity1, self.weights1, self.values1)
+        total_value, items = knapsack(
+            self.n1, self.capacity1, self.weights1, self.values1
+        )
         self.assertEqual(self.correctvalue1, total_value)
         self.assertEqual(self.correctitems1, items)
 
     def test_singleitem_value(self):
-        total_value, items = knapsack(self.n2, self.capacity2, self.weights2, self.values2)
+        total_value, items = knapsack(
+            self.n2, self.capacity2, self.weights2, self.values2
+        )
         self.assertEqual(self.correctvalue2, total_value)
         self.assertEqual(self.correctitems2, items)
 
     def test_negativevalues(self):
-        total_value, items = knapsack(self.n3, self.capacity3, self.weights3, self.values3)
+        total_value, items = knapsack(
+            self.n3, self.capacity3, self.weights3, self.values3
+        )
         self.assertEqual(self.correctvalue3, total_value)
         self.assertEqual(self.correctitems3, items)
 
     def test_simpleexample(self):
-        total_value, items = knapsack(self.n4, self.capacity4, self.weights4, self.values4)
+        total_value, items = knapsack(
+            self.n4, self.capacity4, self.weights4, self.values4
+        )
         self.assertEqual(self.correctvalue4, total_value)
         self.assertEqual(self.correctitems4, items)
 
     def test_weight_too_heavy(self):
-        total_value, items = knapsack(self.n5, self.capacity5, self.weights5, self.values5)
+        total_value, items = knapsack(
+            self.n5, self.capacity5, self.weights5, self.values5
+        )
         self.assertEqual(self.correctvalue5, total_value)
         self.assertEqual(self.correctitems5, items)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     print("Running Knapsack tests:")
-    unittest.main()
+    unittest.main()

Algorithm_tests/dynamic_programming_tests/sequence_alignment/sequence_alignment_test.py

@@ -3,57 +3,58 @@
 
 # For importing from different folders
 # OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
-sys.path.append('Algorithms/dynamic_programming/')
+sys.path.append("Algorithms/dynamic_programming/")
 
 # If run from local:
-#sys.path.append('../../../Algorithms/dynamic_programming/')
+# sys.path.append('../../../Algorithms/dynamic_programming/')
 from sequence_alignment import SequenceAlignment
 
+
 class test_sequence_alignment(unittest.TestCase):
     def setUp(self):
-        self.x1 = 'ABC'
-        self.y1 = 'ADC'
+        self.x1 = "ABC"
+        self.y1 = "ADC"
         self.correct_editstep1 = 1
 
-        self.x2 = 'AB'
-        self.y2 = 'A'
+        self.x2 = "AB"
+        self.y2 = "A"
         self.correct_editstep2 = 1
 
-        self.x3 = 'A'
-        self.y3 = ''
+        self.x3 = "A"
+        self.y3 = ""
         self.correct_editstep3 = 1
 
-        self.x4 = 'ABC'
-        self.y4 = 'ABCDE'
+        self.x4 = "ABC"
+        self.y4 = "ABCDE"
         self.correct_editstep4 = 2
 
-        self.x5 = 'ABCKL'
-        self.y5 = 'ADCE'
+        self.x5 = "ABCKL"
+        self.y5 = "ADCE"
         self.correct_editstep5 = 3
 
-        self.x6 = 'A'*10
-        self.y6 = ''
+        self.x6 = "A" * 10
+        self.y6 = ""
         self.correct_editstep6 = 10
 
-        self.x7 = ''
-        self.y7 = 'A' * 10
+        self.x7 = ""
+        self.y7 = "A" * 10
         self.correct_editstep7 = 10
 
-        self.x8 = 'TGACGTGC'
-        self.y8 = 'TCGACGTCA'
+        self.x8 = "TGACGTGC"
+        self.y8 = "TCGACGTCA"
         self.correct_editstep8 = 3
 
-        self.x9 = 'XYZ'
-        self.y9 = 'XKZ'
-        self.correct_solution9 = ['align_X', 'align_K', 'align_Z']
+        self.x9 = "XYZ"
+        self.y9 = "XKZ"
+        self.correct_solution9 = ["align_X", "align_K", "align_Z"]
 
-        self.x10 = 'XX'
-        self.y10 = ''
-        self.correct_solution10 = ['remove_X', 'remove_X']
+        self.x10 = "XX"
+        self.y10 = ""
+        self.correct_solution10 = ["remove_X", "remove_X"]
 
-        self.x11 = ''
-        self.y11 = 'XX'
-        self.correct_solution11 = ['insert_X', 'insert_X']
+        self.x11 = ""
+        self.y11 = "XX"
+        self.correct_solution11 = ["insert_X", "insert_X"]
 
     def test_simplecase(self):
         sequence_align = SequenceAlignment(self.x1, self.y1)
@@ -110,6 +111,7 @@ def test_findsolution_empty_x(self):
         _, solution = sequence_align.alignment()
         self.assertEqual(self.correct_solution11, solution)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     print("Running Sequence Alignment tests:")
-    unittest.main()
+    unittest.main()

Algorithm_tests/dynamic_programming_tests/weighted_interval_scheduling/weighted_interval_scheduling_test.py

@@ -3,35 +3,36 @@
 
 # For importing from different folders
 # OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
-sys.path.append('Algorithms/dynamic_programming/')
+sys.path.append("Algorithms/dynamic_programming/")
 
 # If run from local:
-#sys.path.append('../../../Algorithms/dynamic_programming/')
+# sys.path.append('../../../Algorithms/dynamic_programming/')
 from weighted_interval_scheduling import WeightedIntervalScheduling
 
+
 class test_weighted_interval_scheduling(unittest.TestCase):
     def setUp(self):
         self.I1 = []
         self.correct_maxweight1 = 0
         self.correct_intervals1 = []
 
-        self.I2 = [(0,3,10)]
+        self.I2 = [(0, 3, 10)]
         self.correct_maxweight2 = 10
-        self.correct_intervals2 = [(0,3,10)]
+        self.correct_intervals2 = [(0, 3, 10)]
 
-        self.I3 = [(0,3,5), (2,5,15), (4, 6, 5)]
+        self.I3 = [(0, 3, 5), (2, 5, 15), (4, 6, 5)]
         self.correct_maxweight3 = 15
-        self.correct_intervals3 = [(2,5,15)]
+        self.correct_intervals3 = [(2, 5, 15)]
 
         self.I4 = [(0, 3, 5), (3, 5, 15), (5, 7, 5)]
         self.correct_maxweight4 = 25
         self.correct_intervals4 = [(0, 3, 5), (3, 5, 15), (5, 7, 5)]
 
         self.I5 = [(0, 3, 5), (3, 5, -100), (5, 7, -50)]
         self.correct_maxweight5 = 5
-        self.correct_intervals5 = [(0,3,5)]
+        self.correct_intervals5 = [(0, 3, 5)]
 
-        self.I6 = [(0, 50, 1), (0, 49, 1), (0, 48, 1), (15,20,10)]
+        self.I6 = [(0, 50, 1), (0, 49, 1), (0, 48, 1), (15, 20, 10)]
         self.correct_maxweight6 = 10
         self.correct_intervals6 = [(15, 20, 10)]
 
@@ -101,6 +102,7 @@ def test_earliest_finish_time_not_best(self):
         self.assertEqual(self.correct_maxweight9, max_weight)
         self.assertEqual(self.correct_intervals9, best_intervals)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     print("Running Weighted Interval Scheduling tests:")
-    unittest.main()
+    unittest.main()

Algorithm_tests/graphtheory_tests/BFS_test.py

@@ -5,30 +5,38 @@
 
 # For importing from different folders
 # OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
-sys.path.append('Algorithms/graphtheory/breadth-first-search/')
+sys.path.append("Algorithms/graphtheory/breadth-first-search/")
 
 # If run from local:
-#sys.path.append('../../Algorithms/graphtheory/breadth-first-search/')
+# sys.path.append('../../Algorithms/graphtheory/breadth-first-search/')
 from BFS_queue_iterative import BFS
 
-class test_BFS(unittest.TestCase):
 
+class test_BFS(unittest.TestCase):
     def setUp(self):
-        self.G1 = {1:[2],2:[1,3],3:[2]}
+        self.G1 = {1: [2], 2: [1, 3], 3: [2]}
         self.correct_visited1 = [True] * 3
-        self.correct_path1 = [1,2,3]
+        self.correct_path1 = [1, 2, 3]
 
-        self.G2 = {1:[2], 2:[1,3,4], 3:[2], 4:[2,5], 5:[4]}
+        self.G2 = {1: [2], 2: [1, 3, 4], 3: [2], 4: [2, 5], 5: [4]}
         self.correct_visited2 = [True] * 5
 
-        self.G3 = {1:[2], 2:[1,3,4], 3:[2], 4:[2], 5:[]}
-        self.correct_visited3 = [True]*4 + [False]
+        self.G3 = {1: [2], 2: [1, 3, 4], 3: [2], 4: [2], 5: []}
+        self.correct_visited3 = [True] * 4 + [False]
 
-        self.G4 = {1:[2,3,4], 2:[1,3,4], 3:[1,2,4], 4:[1,2,3]}
-        self.correct_visited4 = [True]*4
+        self.G4 = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2, 4], 4: [1, 2, 3]}
+        self.correct_visited4 = [True] * 4
 
-        self.G5 = {1:[2,3,4], 2:[1,5], 3:[1,7], 4:[1,6], 5:[2], 6:[4], 7:[3]}
-        self.correct_visited5 = [True]*7
+        self.G5 = {
+            1: [2, 3, 4],
+            2: [1, 5],
+            3: [1, 7],
+            4: [1, 6],
+            5: [2],
+            6: [4],
+            7: [3],
+        }
+        self.correct_visited5 = [True] * 7
 
     def test_linear_graph(self):
         visited, path = BFS(self.G1, start_node=1)
@@ -64,6 +72,6 @@ def test_breadth_before_depth(self):
         self.assertTrue(path.index(4) < path.index(7))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print("Running BFS/DFS tests:")
-    unittest.main()
+    unittest.main()

Algorithm_tests/graphtheory_tests/DFS_test.py

@@ -5,34 +5,33 @@
 
 # For importing from different folders
 # OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
-sys.path.append('Algorithms/graphtheory/depth-first-search/')
+sys.path.append("Algorithms/graphtheory/depth-first-search/")
 
 # If run from local:
-#sys.path.append('../../Algorithms/graphtheory/depth-first-search/')
+# sys.path.append('../../Algorithms/graphtheory/depth-first-search/')
 from DFS_recursive import DFS as DFS_rec
 from DFS_stack_iterative import DFS as DFS_stack
 
-class test_DFS(unittest.TestCase):
 
+class test_DFS(unittest.TestCase):
     def setUp(self):
-        self.G1 = {1:[2],2:[1,3],3:[2]}
+        self.G1 = {1: [2], 2: [1, 3], 3: [2]}
         self.correct_visited1 = [True] * 3
-        self.correct_path1 = [1,2,3]
+        self.correct_path1 = [1, 2, 3]
         self.DFS_recursive_visited1 = [False for i in range(1, len(self.G1) + 1)]
 
-        self.G2 = {1:[2], 2:[1,3,4], 3:[2], 4:[2,5], 5:[4]}
+        self.G2 = {1: [2], 2: [1, 3, 4], 3: [2], 4: [2, 5], 5: [4]}
         self.correct_visited2 = [True] * 5
         self.DFS_recursive_visited2 = [False for i in range(1, len(self.G2) + 1)]
 
-        self.G3 = {1:[2], 2:[1,3,4], 3:[2], 4:[2], 5:[]}
-        self.correct_visited3 = [True]*4 + [False]
-        self.DFS_recursive_visited3= [False for i in range(1, len(self.G3) + 1)]
+        self.G3 = {1: [2], 2: [1, 3, 4], 3: [2], 4: [2], 5: []}
+        self.correct_visited3 = [True] * 4 + [False]
+        self.DFS_recursive_visited3 = [False for i in range(1, len(self.G3) + 1)]
 
-        self.G4 = {1:[2,3,4], 2:[1,3,4], 3:[1,2,4], 4:[1,2,3]}
-        self.correct_visited4 = [True]*4
+        self.G4 = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2, 4], 4: [1, 2, 3]}
+        self.correct_visited4 = [True] * 4
         self.DFS_recursive_visited4 = [False for i in range(1, len(self.G4) + 1)]
 
-
     def test_linear_graph(self):
         visited, path = DFS_stack(self.G1, start_node=1)
         self.assertEqual(visited, self.correct_visited1)
@@ -62,6 +61,7 @@ def test_complete_graph(self):
         DFS_rec(self.G4, 1, self.DFS_recursive_visited4)
         self.assertEqual(self.DFS_recursive_visited4, self.correct_visited4)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     print("Running BFS/DFS tests:")
-    unittest.main()
+    unittest.main()