Auto-format code using pep8 (#324)

Co-authored-by: GitHub Actions <actions@github.com>

Author: github-actions[bot]

src/acom_music_box/conditions.py

@@ -327,4 +327,3 @@ def read_data_values_from_table(cls, data_json, react_types=None):
         logger.debug(f"For {react_types} data_values = {data_values}")
 
         return data_values
-

src/acom_music_box/music_box.py

@@ -91,7 +91,7 @@ def solve(self, callback=None):
             raise Exception(f"Error: MusicBox object {self} has no chemistry step time.")
         if self.box_model_options.output_step_time is None:
             raise Exception(f"Error: MusicBox object {self} has no output step time.")
-        
+
         # sets up initial conditions to be current conditions
         curr_conditions = self.initial_conditions
 
@@ -112,11 +112,10 @@ def solve(self, callback=None):
 
         header = ["time.s", "ENV.temperature.K", "ENV.pressure.Pa", "ENV.air number density.mol m-3"]
         for species, _ in self.state.get_concentrations().items():
-            header.append("CONC."+species+".mol m-3")
-
+            header.append("CONC." + species + ".mol m-3")
 
         # set the initial conditions in the state
-        self.state.set_conditions(curr_conditions.temperature, curr_conditions.pressure) # air denisty will be calculated based on Ideal gas law
+        self.state.set_conditions(curr_conditions.temperature, curr_conditions.pressure)  # air denisty will be calculated based on Ideal gas law
         self.state.set_concentrations(curr_conditions.species_concentrations)
         self.state.set_user_defined_rate_parameters(curr_conditions.rate_parameters)
 
@@ -137,7 +136,7 @@ def solve(self, callback=None):
                     row.append(conditions["pressure"][0])
                     row.append(conditions["air_density"][0])
                     for _, concentration in self.state.get_concentrations().items():
-                       row.append(concentration[0])
+                        row.append(concentration[0])
                     output_array.append(row)
 
                     next_output_time += self.box_model_options.output_step_time
@@ -165,7 +164,7 @@ def solve(self, callback=None):
                     else:
                         next_conditions = None
                     # set the current conditions in the state
-                    self.state.set_conditions(curr_conditions.temperature, curr_conditions.pressure) # air denisty will be calculated based on Ideal gas law
+                    self.state.set_conditions(curr_conditions.temperature, curr_conditions.pressure)  # air denisty will be calculated based on Ideal gas law
                     self.state.set_concentrations(curr_conditions.species_concentrations)
                     self.state.set_user_defined_rate_parameters(curr_conditions.rate_parameters)
 
@@ -214,13 +213,13 @@ def loadJson(self, path_to_json):
         camp_path = os.path.join(os.path.dirname(path_to_json), self.config_file)
 
         # Initalize the musica solver
-        self.solver = musica.MICM(config_path = camp_path, solver_type=musica.SolverType.rosenbrock_standard_order)
+        self.solver = musica.MICM(config_path=camp_path, solver_type=musica.SolverType.rosenbrock_standard_order)
         self.state = self.solver.create_state(1)
 
     def load_mechanism(self, mechanism, solver_type=musica.SolverType.rosenbrock_standard_order):
         """
         Creates a solver for the specified mechanism.
-        
+
         Args:
             mechanism (Mechanism): The mechanism to be used for the solver.
         """

tests/integration/test_analytical.py

@@ -126,11 +126,11 @@ def test_in_code(self):
         C = mc.Species(name="C")
         gas = mc.Phase(name="gas", species=[A, B, C])
         arr1 = mc.Arrhenius(name="B->C", A=1.2e-4, B=7, C=75, D=50, E=0.5,
-            reactants=[B], products=[C], gas_phase=gas)
+                            reactants=[B], products=[C], gas_phase=gas)
         arr2 = mc.Arrhenius(name="A->B", A=4.0e-3, C=50,
-            reactants=[A], products=[B], gas_phase=gas)
+                            reactants=[A], products=[B], gas_phase=gas)
         mechanism = mc.Mechanism(name="test_mechanism", species=[A, B, C],
-            phases=[gas], reactions=[arr1, arr2])
+                                 phases=[gas], reactions=[arr1, arr2])
         box_model.load_mechanism(mechanism)
 
         # Set up the initial conditions
@@ -147,7 +147,6 @@ def test_in_code(self):
 
         self.solve_and_compare(box_model)
 
-    
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)

tests/integration/test_chapman.py

@@ -16,7 +16,7 @@ def test_run(self):
         # solves and saves output
         model = box_model.solve()
 
-        model.columns = [ column for column in model.columns ]
+        model.columns = [column for column in model.columns]
 
         current_dir = os.path.dirname(__file__)
         expected_results_path = os.path.join(current_dir, "expected_results/chapman_test.csv")

tests/integration/test_in_code_mechanism.py

@@ -18,7 +18,7 @@ def define_system(self):
         D = mc.Species(name="D")
         E = mc.Species(name="E")
         F = mc.Species(name="F")
-        species = { "A": A, "B": B, "C": C, "D": D, "E": E, "F": F }
+        species = {"A": A, "B": B, "C": C, "D": D, "E": E, "F": F}
         gas = mc.Phase(name="gas", species=list(species.values()))
 
         return gas, species
@@ -32,38 +32,38 @@ def create_box_model(self, mechanism):
 
         # Set the initial conditions
         box_model.initial_conditions = Conditions(
-          temperature=298.15,
-          pressure=101325.0,
-          species_concentrations={
-            "A": 1.0,
-            "B": 0.0,
-            "C": 0.0,
-            "D": 10.0,
-            "E": 0.0,
-            "F": 0.0,
-          })
+            temperature=298.15,
+            pressure=101325.0,
+            species_concentrations={
+                "A": 1.0,
+                "B": 0.0,
+                "C": 0.0,
+                "D": 10.0,
+                "E": 0.0,
+                "F": 0.0,
+            })
 
         # Set the evolving conditions
         box_model.add_evolving_condition(
-          300.0,
-          Conditions(
-            temperature=310.0,
-            pressure=100100.0,
-            species_concentrations={
-              "D": 1.0,
-              "E": 0.0,
-              "F": 0.0,
-            }))
+            300.0,
+            Conditions(
+                temperature=310.0,
+                pressure=100100.0,
+                species_concentrations={
+                    "D": 1.0,
+                    "E": 0.0,
+                    "F": 0.0,
+                }))
         box_model.add_evolving_condition(
-          450.0,
-          Conditions(
-            temperature=280.0,
-            pressure=90500.0,
-            species_concentrations={
-              "A": 100.0,
-              "B": 0.0,
-              "C": 0.0,
-            }))
+            450.0,
+            Conditions(
+                temperature=280.0,
+                pressure=90500.0,
+                species_concentrations={
+                    "A": 100.0,
+                    "B": 0.0,
+                    "C": 0.0,
+                }))
 
         # Set the time step and duration
         box_model.box_model_options.simulation_length = 600.0
@@ -177,48 +177,47 @@ def solve_and_compare(self, box_model, calc_k1, calc_k2, calc_k3, calc_k4):
                 assert math.isclose(A_conc, A_conc_model, rel_tol=1e-6, abs_tol=1.0e-3), f"A concentrations differ at time {time}"
                 assert math.isclose(B_conc, B_conc_model, rel_tol=1e-6, abs_tol=1.0e-3), f"B concentrations differ at time {time}"
                 assert math.isclose(C_conc, C_conc_model, rel_tol=1e-6, abs_tol=1.0e-3), f"C concentrations differ at time {time}"
-        
-        
+
     def test_arrhenius(self):
         """
         Test the Arrhenius reaction mechanism.
         """
         gas, species = self.define_system()
         arr1 = mc.Arrhenius(name="A->B", A=4.0e-3, C=50,
-            reactants=[species["A"]], products=[species["B"]], gas_phase=gas)
+                            reactants=[species["A"]], products=[species["B"]], gas_phase=gas)
         arr2 = mc.Arrhenius(name="B->C", A=1.2e-4, B=2.5, C=75, D=50, E=0.5,
-            reactants=[species["B"]], products=[species["C"]], gas_phase=gas)
+                            reactants=[species["B"]], products=[species["C"]], gas_phase=gas)
         arr3 = mc.Arrhenius(name="D->E", A=4.0e-3, C=35,
-            reactants=[species["D"]], products=[species["E"]], gas_phase=gas)
+                            reactants=[species["D"]], products=[species["E"]], gas_phase=gas)
         arr4 = mc.Arrhenius(name="E->F", A=1.2e-4, B=1.4, C=75, D=50, E=0.1,
-            reactants=[species["E"]], products=[species["F"]], gas_phase=gas)
+                            reactants=[species["E"]], products=[species["F"]], gas_phase=gas)
         mechanism = mc.Mechanism(name="test_mechanism", species=list(species.values()),
-            phases=[gas], reactions=[arr1, arr2, arr3, arr4])
-        
+                                 phases=[gas], reactions=[arr1, arr2, arr3, arr4])
+
         box_model = self.create_box_model(mechanism)
 
         # Define the rate constants as functions of temperature, pressure, and air density
         def calc_k1(temperature, pressure, air_density):
             return 4.0e-3 * math.exp(50 / temperature)
 
         def calc_k2(temperature, pressure, air_density):
-            return  (
+            return (
                 1.2e-4
                 * math.exp(75 / temperature)
                 * (temperature / 50) ** 2.5
                 * (1.0 + 0.5 * pressure)
-              )
-        
+            )
+
         def calc_k3(temperature, pressure, air_density):
             return 4.0e-3 * math.exp(35 / temperature)
 
         def calc_k4(temperature, pressure, air_density):
-            return  (
+            return (
                 1.2e-4
                 * math.exp(75 / temperature)
                 * (temperature / 50) ** 1.4
                 * (1.0 + 0.1 * pressure)
-              )
+            )
 
         self.solve_and_compare(box_model, calc_k1, calc_k2, calc_k3, calc_k4)
 
@@ -227,7 +226,3 @@ def calc_k4(temperature, pressure, air_density):
     logging.basicConfig(level=logging.DEBUG)
     test = TestInCodeMechanism()
     test.test_arrhenius()
-        
-        
-
-