black formatter

Author: robfitzgerald

nrel/hive/initialization/initialize_simulation_with_sampling.py

@@ -187,8 +187,6 @@ def _add_row_unsafe(
 
     # add all stations to the simulation once we know they are complete
     stations = DictOps.iterate_vals(stations_builder)
-    sim_with_stations = simulation_state_ops.add_entities(
-        simulation_state, stations
-    )
+    sim_with_stations = simulation_state_ops.add_entities(simulation_state, stations)
 
     return sim_with_stations

nrel/hive/state/simulation_state/simulation_state.py

@@ -90,14 +90,14 @@ def get_request_ids(self) -> Tuple[RequestId, ...]:
     def get_stations(
         self,
         filter_function: Optional[Callable[[Station], bool]] = None,
-        sort_key: Optional[Callable] = None
+        sort_key: Optional[Callable] = None,
     ) -> Tuple[Station, ...]:
         return DictOps.iterate_sim_coll(self.stations, filter_function, sort_key)
 
     def get_bases(
         self,
         filter_function: Optional[Callable[[Base], bool]] = None,
-        sort_key: Optional[Callable] = None
+        sort_key: Optional[Callable] = None,
     ) -> Tuple[Base, ...]:
         return DictOps.iterate_sim_coll(self.bases, filter_function, sort_key)
 

nrel/hive/state/simulation_state/update/step_simulation_ops.py

@@ -101,7 +101,7 @@ def _sort_by_vehicle_state(vs: Tuple[Vehicle, ...]) -> Tuple[Vehicle, ...]:
             lambda v: isinstance(v.vehicle_state, ChargeQueueing), vs
         )
 
-        # sort queueing vehicles by enqueue time followed by id as a 
+        # sort queueing vehicles by enqueue time followed by id as a
         # deterministic tie-breaker via their VehicleId
         sorted_charge_queueing_vehicles = tuple(
             sorted(

nrel/hive/util/dict_ops.py

@@ -1,6 +1,19 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Iterator, List, NamedTuple, Tuple, Optional, TypeVar, FrozenSet, TYPE_CHECKING, Hashable, Union
+from typing import (
+    Any,
+    Callable,
+    Iterator,
+    List,
+    NamedTuple,
+    Tuple,
+    Optional,
+    TypeVar,
+    FrozenSet,
+    TYPE_CHECKING,
+    Hashable,
+    Union,
+)
 
 import h3
 import immutables
@@ -11,7 +24,6 @@
     from _typeshed import SupportsRichComparison
 
 
-
 class EntityUpdateResult(NamedTuple):
     entities: Optional[immutables.Map[EntityId, Entity]] = None
     locations: Optional[immutables.Map[GeoId, FrozenSet[EntityId]]] = None
@@ -23,9 +35,11 @@ class DictOps:
     V = TypeVar("V")
 
     @classmethod
-    def iterate_vals(cls, xs: immutables.Map[K, V], key: Optional[Callable[[V], SupportsRichComparison]]=None) -> Tuple[V, ...]:
+    def iterate_vals(
+        cls, xs: immutables.Map[K, V], key: Optional[Callable[[V], SupportsRichComparison]] = None
+    ) -> Tuple[V, ...]:
         """
-        helper function for iterating on Maps in HIVE which sorts values by key unless a key function 
+        helper function for iterating on Maps in HIVE which sorts values by key unless a key function
         is provided. for all stateful Map collections that are being iterated on in HIVE, we need
         to sort them _somehow_ to guarantee deterministic runs.
 
@@ -34,7 +48,7 @@ def iterate_vals(cls, xs: immutables.Map[K, V], key: Optional[Callable[[V], Supp
 
         :param xs: collection to iterate values of
         :type xs: immutables.Map[K, V]
-        :return: values of xs, sorted by key 
+        :return: values of xs, sorted by key
         :rtype: Tuple[V, ...]
         """
         # forcing ignore here after numerous attempts to set the bounds for K
@@ -47,17 +61,21 @@ def iterate_vals(cls, xs: immutables.Map[K, V], key: Optional[Callable[[V], Supp
         else:
             vs = sorted(xs.values(), key=key)  # type: ignore
             return vs
-    
+
     @classmethod
-    def iterate_items(cls, xs: immutables.Map[K, V], key: Optional[Callable[[Tuple[K, V]], SupportsRichComparison]]=None) -> List[Tuple[K, V]]:
+    def iterate_items(
+        cls,
+        xs: immutables.Map[K, V],
+        key: Optional[Callable[[Tuple[K, V]], SupportsRichComparison]] = None,
+    ) -> List[Tuple[K, V]]:
         """
-        helper function for iterating on Maps in HIVE which sorts values by key unless a key function 
+        helper function for iterating on Maps in HIVE which sorts values by key unless a key function
         is provided. for all stateful Map collections that are being iterated on in HIVE, we need
         to sort them _somehow_ to guarantee deterministic runs.
 
         :param xs: collection to iterate values of
         :type xs: immutables.Map[K, V]
-        :return: values of xs, sorted by key 
+        :return: values of xs, sorted by key
         :rtype: Tuple[V, ...]
         """
         # forcing ignore here after numerous attempts to set the bounds for K
@@ -71,10 +89,10 @@ def iterate_items(cls, xs: immutables.Map[K, V], key: Optional[Callable[[Tuple[K
 
     @classmethod
     def iterate_sim_coll(
-            cls,
-            collection: immutables.Map[K, V],
-            filter_function: Optional[Callable[[V], bool]] = None,
-            sort_key: Optional[Callable] = None
+        cls,
+        collection: immutables.Map[K, V],
+        filter_function: Optional[Callable[[V], bool]] = None,
+        sort_key: Optional[Callable] = None,
     ) -> Tuple[V, ...]:
         """
         helper to iterate through a collection on the SimulationState with optional
@@ -89,14 +107,13 @@ def iterate_sim_coll(
         :return: _description_
         :rtype: Tuple[V, ...]
         """
-        
-        vals = DictOps.iterate_vals(collection, sort_key) 
+
+        vals = DictOps.iterate_vals(collection, sort_key)
         if filter_function:
             return tuple(filter(filter_function, vals))
         else:
             return vals
 
-
     @classmethod
     def add_to_dict(cls, xs: immutables.Map[K, V], obj_id: K, obj: V) -> immutables.Map[K, V]:
         """

tests/test_run_cosim.py

@@ -9,7 +9,6 @@
 
 
 class TestRunCosim(TestCase):
-
     def test_load_and_run_denver(self):
         # read scenario
         sim = mock_sim()

tests/test_simulationstate.py

@@ -632,9 +632,7 @@ def test_get_bases(self):
             )
         )
 
-        sorted_bases = sim.get_bases(
-            sort_key=lambda b: -b.total_stalls
-        )
+        sorted_bases = sim.get_bases(sort_key=lambda b: -b.total_stalls)
 
         self.assertEqual(sorted_bases[0].id, "b2", "base 2 has the most stalls")