Merge branch 'main' into detect-implausible-switches

Author: arneboockmeyer

test/node_test.py

@@ -11,76 +11,74 @@ def create_node(x, y):
 
 
 def coords_str(node: Node):
-    return f'({node.geo_node.geo_point.x}, {node.geo_node.geo_point.y})'
+    return f"({node.geo_node.geo_point.x}, {node.geo_node.geo_point.y})"
 
 
 def test_anschluss():
     base_scenarios = [
         # Base scenarios are defined in "grids", so look at them like
         # looking at a layout (h=head, s=switch, l=left, r=right).
-
-        ( # north to south
+        (  # north to south
             (" h "),
             (" s "),
             ("   "),
             ("r l"),
         ),
-        ( # northeast to southwest:
+        (  # northeast to southwest:
             ("   h"),
             ("  s "),
             ("    "),
             ("rl  "),
         ),
-        ( # east to west:
+        (  # east to west:
             ("r   "),
             ("  sh"),
             ("l   "),
         ),
-        ( # southeast to northwest:
+        (  # southeast to northwest:
             ("lr  "),
             ("    "),
             ("  s "),
             ("   h"),
         ),
-        ( # south to north:
+        (  # south to north:
             ("l r"),
             ("   "),
             (" s "),
             (" h "),
         ),
-        ( # southwest to northeast:
+        (  # southwest to northeast:
             ("  lr"),
             ("    "),
             (" s  "),
             ("h   "),
         ),
-        ( # west to east:
+        (  # west to east:
             ("   l"),
             ("hs  "),
             ("   r"),
         ),
-        ( # northwest to southeast:
+        (  # northwest to southeast:
             ("h   "),
             (" s  "),
             ("    "),
             ("  rl"),
         ),
-        ( # curved north to south:
+        (  # curved north to south:
             ("h  "),
             ("s  "),
             ("   "),
             (" rl"),
         ),
-        ( # curved east to west:
+        (  # curved east to west:
             ("r   "),
             ("l   "),
             ("  sh"),
         ),
-        ( # branch east to west
+        (  # branch east to west
             ("r  "),
             ("lsh"),
         ),
-
     ]
 
     # base scenarios will be "moved around" by some offsets:
@@ -114,10 +112,14 @@ def test_anschluss():
 
             print(
                 "scenario:",
-                "\n  head  ", coords_str(head),
-                "\n  switch", coords_str(switch),
-                "\n  left  ", coords_str(left),
-                "\n  right ", coords_str(right)
+                "\n  head  ",
+                coords_str(head),
+                "\n  switch",
+                coords_str(switch),
+                "\n  left  ",
+                coords_str(left),
+                "\n  right ",
+                coords_str(right),
             )
 
             # connect all nodes to the switch
@@ -127,20 +129,23 @@ def test_anschluss():
             switch.calc_anschluss_of_all_nodes()
 
             # assert ``calc_anschluss_of_all_nodes`` did what it should
-            assert switch.connected_on_head == head, 'head node ' \
-                f'{coords_str(switch.connected_on_head)} incorrect'
-            assert switch.connected_on_left == left, 'left node ' \
-                f'{coords_str(switch.connected_on_left)} incorrect'
-            assert switch.connected_on_right == right, 'right node ' \
-                f'{coords_str(switch.connected_on_right)} incorrect'
+            assert switch.connected_on_head == head, (
+                "head node " f"{coords_str(switch.connected_on_head)} incorrect"
+            )
+            assert switch.connected_on_left == left, (
+                "left node " f"{coords_str(switch.connected_on_left)} incorrect"
+            )
+            assert switch.connected_on_right == right, (
+                "right node " f"{coords_str(switch.connected_on_right)} incorrect"
+            )
 
 
 def test_implausible_anschluss():
     """Assert that detection of "Anschluss" (head, left, right) raises
     an exception on really implausible geographies."""
-    head = create_node(0, 0)   # layout:
-    switch = create_node(2, 2) #      l
-    left = create_node(1, 3)   #       s r
+    head = create_node(0, 0)  # layout:
+    switch = create_node(2, 2)  #      l
+    left = create_node(1, 3)  #       s r
     right = create_node(3, 2)  #     h
 
     switch.connected_nodes.extend((head, left, right))

yaramo/node.py

@@ -1,7 +1,7 @@
+import sys
 from enum import Enum
 from itertools import permutations
-from math import sin, cos, atan2
-import sys
+from math import atan2, cos, sin
 
 from yaramo.base_element import BaseElement
 from yaramo.geo_node import GeoNode
@@ -109,8 +109,7 @@ def calc_anschluss_of_all_nodes(self):
 
         almost_zero = sys.float_info.epsilon
 
-        def get_rad_between_nodes(node_a: GeoPoint,
-                                  node_b: GeoPoint) -> float:
+        def get_rad_between_nodes(node_a: GeoPoint, node_b: GeoPoint) -> float:
             """
             Returns the angle of an (maybe imaginary) line between
             :param:`node_a` and :param:`node_b`.
@@ -132,7 +131,7 @@ def get_rad_between_nodes(node_a: GeoPoint,
                 continue
 
             right_angle_abs = get_rad_between_nodes(self, right)
-            right_angle_rel = right_angle_abs- head_angle_abs
+            right_angle_rel = right_angle_abs - head_angle_abs
             if cos(right_angle_rel) <= almost_zero:
                 # right turn more than (or almost) 90°
                 continue