Adhere to pep8

Author: michaeldorner

simulation/minimal_distances.py

@@ -37,7 +37,8 @@ def single_source_dijkstra_hyperedges(hypergraph: TimeVaryingHypergraph, source_
                         case DistanceType.SHORTEST:
                             new_distance = prior_distance + 1
                         case DistanceType.FASTEST:
-                            new_distance = prior_distance + (next_hedge_timing - source_hedge_timing)
+                            new_distance = prior_distance + \
+                                (next_hedge_timing - source_hedge_timing)
                         case DistanceType.FOREMOST:
                             new_distance = next_hedge_timing
                     if next_hedge not in hedge_distances or new_distance < hedge_distances[next_hedge]:
@@ -86,7 +87,8 @@ def single_source_dijkstra_vertices(hypergraph: TimeVaryingHypergraph, source_ve
                         case DistanceType.SHORTEST:
                             new_distance = distance + 1
                         case DistanceType.FASTEST:
-                            new_distance = distance + (next_hedge_timing - source_hedge_timing)
+                            new_distance = distance + \
+                                (next_hedge_timing - source_hedge_timing)
                         case DistanceType.FOREMOST:
                             new_distance = next_hedge_timing
                     if new_reachable not in distances or new_distance < distances[new_reachable]:

test/test_minimal_distances.py

@@ -61,16 +61,21 @@ def test_minimal_distance(self):
             for start_vertex, _minimal_distances in minimal_distances.items():
                 for distance_type in DistanceType:
                     with self.subTest(implementation='single_source_dijkstra_vertices', distance_type=distance_type.name, communication_network=communication_network.name):
-                        self.assertEqual(single_source_dijkstra_vertices(communication_network, start_vertex, distance_type, min_timing=0), _minimal_distances[distance_type])
+                        self.assertEqual(single_source_dijkstra_vertices(
+                            communication_network, start_vertex, distance_type, min_timing=0), _minimal_distances[distance_type])
 
                     with self.subTest(implementation='single_source_dijkstra_hyperedges', distance_type=distance_type.name, communication_network=communication_network.name):
-                        self.assertEqual(single_source_dijkstra_hyperedges(communication_network, start_vertex, distance_type, min_timing=0), _minimal_distances[distance_type])
+                        self.assertEqual(single_source_dijkstra_hyperedges(
+                            communication_network, start_vertex, distance_type, min_timing=0), _minimal_distances[distance_type])
 
     def test_pairwise_minimal_distance(self):
         for communication_network in (MinimalPathTest.communication_network_1, MinimalPathTest.communication_network_2, ):
             for distance_type in DistanceType:
                 for vertex in communication_network.vertices():
                     with self.subTest(distance_type=distance_type.name, vertex=vertex):
-                        result_1 = single_source_dijkstra_vertices(communication_network, vertex, distance_type, min_timing=0)
-                        result_2 = single_source_dijkstra_hyperedges(communication_network, vertex, distance_type, min_timing=0)
-                        self.assertEqual(result_1, result_2, f'Single-source Dijkstra implementations for {distance_type.name} and vertex {vertex} are not equivalent')
+                        result_1 = single_source_dijkstra_vertices(
+                            communication_network, vertex, distance_type, min_timing=0)
+                        result_2 = single_source_dijkstra_hyperedges(
+                            communication_network, vertex, distance_type, min_timing=0)
+                        self.assertEqual(result_1, result_2, f'Single-source Dijkstra implementations for {
+                                         distance_type.name} and vertex {vertex} are not equivalent')

test/test_model.py

@@ -11,19 +11,24 @@ class TimeVaryingHypergraphTest(unittest.TestCase):
     def test_vertices(self):
         for hedge, vertices in TimeVaryingHypergraphTest.hyperedges.items():
             with self.subTest(hyperedge=hedge):
-                self.assertEqual(TimeVaryingHypergraphTest.hypergraph.vertices(hedge), set(vertices))
+                self.assertEqual(
+                    TimeVaryingHypergraphTest.hypergraph.vertices(hedge), set(vertices))
 
     def test_hyperedges(self):
-        self.assertEqual(TimeVaryingHypergraphTest.hypergraph.hyperedges('v1'), {'h1'})
+        self.assertEqual(
+            TimeVaryingHypergraphTest.hypergraph.hyperedges('v1'), {'h1'})
 
     def test_timings(self):
-        self.assertEqual(TimeVaryingHypergraphTest.hypergraph.timings(), TimeVaryingHypergraphTest.timings)
+        self.assertEqual(TimeVaryingHypergraphTest.hypergraph.timings(
+        ), TimeVaryingHypergraphTest.timings)
 
     def test_unknown_vertex(self):
-        self.assertRaises(EntityNotFound, TimeVaryingHypergraphTest.hypergraph.vertices, 'vx')
+        self.assertRaises(
+            EntityNotFound, TimeVaryingHypergraphTest.hypergraph.vertices, 'vx')
 
     def test_unknown_hyperedge(self):
-        self.assertRaises(EntityNotFound, TimeVaryingHypergraphTest.hypergraph.hyperedges, 'hx')
+        self.assertRaises(
+            EntityNotFound, TimeVaryingHypergraphTest.hypergraph.hyperedges, 'hx')
 
 
 class CommunicationNetworkTest(unittest.TestCase):
@@ -34,23 +39,28 @@ class CommunicationNetworkTest(unittest.TestCase):
     def test_pairwise_vertex_participant_equivalence(self):
         for hedge in list(CommunicationNetworkTest.hyperedges):
             with self.subTest(hyperedge=hedge):
-                self.assertEqual(CommunicationNetworkTest.communication_network.vertices(hedge), CommunicationNetworkTest.communication_network.participants(hedge))
+                self.assertEqual(CommunicationNetworkTest.communication_network.vertices(
+                    hedge), CommunicationNetworkTest.communication_network.participants(hedge))
 
     def test_vertex_participant_equivalence(self):
-        self.assertEqual(CommunicationNetworkTest.communication_network.vertices(), CommunicationNetworkTest.communication_network.participants())
+        self.assertEqual(CommunicationNetworkTest.communication_network.vertices(
+        ), CommunicationNetworkTest.communication_network.participants())
 
     def test_pairwise_hyperedge_channel_equivalence(self):
         for vertex in {v for vertices in CommunicationNetworkTest.hyperedges.values() for v in vertices}:
             with self.subTest(hyperedge=vertex):
-                self.assertEqual(CommunicationNetworkTest.communication_network.hyperedges(vertex), CommunicationNetworkTest.communication_network.channels(vertex))
+                self.assertEqual(CommunicationNetworkTest.communication_network.hyperedges(
+                    vertex), CommunicationNetworkTest.communication_network.channels(vertex))
 
     def test_hyperedge_channel_equivalence(self):
-        self.assertEqual(CommunicationNetworkTest.communication_network.hyperedges(), CommunicationNetworkTest.communication_network.channels())
+        self.assertEqual(CommunicationNetworkTest.communication_network.hyperedges(
+        ), CommunicationNetworkTest.communication_network.channels())
 
 
 class ParametrizedCommunicationNetworkTest(unittest.TestCase):
     def test_with_paramtrization(self):
-        communciation_network = CommunicationNetwork.from_json('./data/networks/microsoft.json.bz2')
+        communciation_network = CommunicationNetwork.from_json(
+            './data/networks/microsoft.json.bz2')
         with self.subTest():
             self.assertEqual(len(communciation_network.participants()), 37103)
         with self.subTest():

test/test_results.py

@@ -24,13 +24,16 @@ class ResultsTest(unittest.TestCase):
     @unittest.skipIf(not ZENODO_ACCESS_TOKEN or not REQUESTS_INSTALLED, 'Skipped because no Zenodo access token was provided.')
     def test_results(self):
         zenodo_access_token = os.environ.get('ZENODO_ACCESS_TOKEN')
-        response = requests.get('https://zenodo.org/api/records/8042256', params={'access_token': zenodo_access_token}, timeout=10)
+        response = requests.get('https://zenodo.org/api/records/8042256',
+                                params={'access_token': zenodo_access_token}, timeout=10)
         response.raise_for_status()
-        zenodo_reference = {record['key']: record['checksum'][len('md5:'):] for record in response.json()['files']}
+        zenodo_reference = {record['key']: record['checksum'][len(
+            'md5:'):] for record in response.json()['files']}
         if zenodo_reference:
             for file_path in sorted(Path('./').glob('./data/minimal_distances/*.bz2'), reverse=True):
                 file_name = file_path.name
                 with self.subTest(file_name=file_name):
                     md5_hash = md5(file_path)
                     md5_hash_reference = zenodo_reference.get(file_name)
-                    self.assertEqual(md5_hash, md5_hash_reference, 'md5 hash is not equivalent with reference on Zenodo')
+                    self.assertEqual(
+                        md5_hash, md5_hash_reference, 'md5 hash is not equivalent with reference on Zenodo')