minor change

evrouting/charge/routing.py

@@ -46,7 +46,9 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
 
     # Init maps to manage labels
     l_set: Dict[int, Set[Label]] = {v: set() for v in G}
-    l_uns: Dict[int, LabelPriorityQueue] = {v: LabelPriorityQueue(f_soc_factory, l_set[v]) for v in G}
+    l_uns: Dict[int, LabelPriorityQueue] = {
+        v: LabelPriorityQueue(f_soc_factory, l_set[v]) for v in G
+    }
 
     # Add dummy charging station with charging function
     # cf(t) = initial_soc (ie charging coefficient is zero).
@@ -69,28 +71,28 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
     prio_queue.insert(s, priority=0, count=0)
 
     while prio_queue:
-        minimum_node: Node = prio_queue.peak_min()
+        node_min: Node = prio_queue.peak_min()
 
-        label_minimum_node: Label = l_uns[minimum_node].delete_min()
-        l_set[minimum_node].add(label_minimum_node)
+        label_node_min: Label = l_uns[node_min].delete_min()
+        l_set[node_min].add(label_node_min)
 
-        if minimum_node == t:
-            return f_soc_factory(label_minimum_node).minimum
+        if node_min == t:
+            return f_soc_factory(label_node_min).minimum
 
         # Handle charging stations
-        if minimum_node in charging_stations and \
-                not minimum_node == label_minimum_node.last_cs:
-            f_soc: SoCFunction = f_soc_factory(label_minimum_node)
-            t_charge = f_soc.calc_optimal_t_charge(cf_map[minimum_node])
+        if node_min in charging_stations and \
+                not node_min == label_node_min.last_cs:
+            f_soc: SoCFunction = f_soc_factory(label_node_min)
+            t_charge = f_soc.calc_optimal_t_charge(cf_map[node_min])
 
             if t_charge is not None:
                 # Spawn new label at t_charge
-                l_uns[minimum_node].insert(
+                l_uns[node_min].insert(
                     Label(
-                        t_trip=label_minimum_node.t_trip + t_charge,
-                        soc_last_cs=f_soc(label_minimum_node.t_trip + t_charge),
-                        last_cs=minimum_node,
-                        soc_profile_cs_v=soc_profile_factory(minimum_node)
+                        t_trip=label_node_min.t_trip + t_charge,
+                        soc_last_cs=f_soc(label_node_min.t_trip + t_charge),
+                        last_cs=node_min,
+                        soc_profile_cs_v=soc_profile_factory(node_min)
                     )
                 )
 
@@ -98,24 +100,24 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
         # minimum label spawned is th previous step.
         try:
             prio_queue.insert(
-                item=minimum_node,
-                **keys(f_soc_factory(l_uns[minimum_node].peak_min()))
+                item=node_min,
+                **keys(f_soc_factory(l_uns[node_min].peak_min()))
             )
         except KeyError:
             # l_uns[v] empty
             prio_queue.delete_min()
 
         # scan outgoing arcs
-        for n in G.neighbors(minimum_node):
+        for n in G.neighbors(node_min):
             # Create SoC Profile for getting from minimum_node to n
-            soc_profile = label_minimum_node.soc_profile_cs_v + \
-                          soc_profile_factory(minimum_node, n)
+            soc_profile = label_node_min.soc_profile_cs_v + \
+                          soc_profile_factory(node_min, n)
 
             if soc_profile(capacity) != -inf:
                 l_new = Label(
-                    t_trip=label_minimum_node.t_trip + distance(G, minimum_node, n),
-                    soc_last_cs=label_minimum_node.soc_last_cs,
-                    last_cs=label_minimum_node.last_cs,
+                    t_trip=label_node_min.t_trip + distance(G, node_min, n),
+                    soc_last_cs=label_node_min.soc_last_cs,
+                    last_cs=label_node_min.last_cs,
                     soc_profile_cs_v=soc_profile
                 )
                 try: