lint :(

Author: electronsandstuff

xopt/generators/ga/nsga2.py

@@ -24,6 +24,7 @@
 # Helper functions
 ########################################################################################################################
 
+
 def vocs_data_to_arr(data: list | np.ndarray) -> np.ndarray:
     """Force data coming from VOCS object into 2D numpy array (or None) for compatibility with helper functions"""
     if isinstance(data, list):
@@ -106,33 +107,33 @@ def crowded_comparison_argsort(
         has_nan = has_nan | np.any(~np.isfinite(pop_g), axis=1)
     nan_indices = np.where(has_nan)[0]
     finite_indices = np.where(~has_nan)[0]
-    
+
     # If all values are non-finite, return the original indices
     if len(finite_indices) == 0:
         return np.arange(pop_f.shape[0])
-    
+
     # Extract only finite values for processing
     pop_f_finite = pop_f[finite_indices, :]
-    
+
     # Handle constraints if provided
     pop_g_finite = None
     if pop_g is not None:
         pop_g_finite = pop_g[finite_indices, :]
-    
+
     # Apply domination ranking
     ranks = fast_dominated_argsort(pop_f_finite, pop_g_finite)
-    
+
     # Calculate crowding distance and sort within each rank
     sorted_finite_indices = []
     for rank in ranks:
         dist = get_crowding_distance(pop_f_finite[rank, :])
         sorted_rank = np.array(rank)[np.argsort(dist)[::-1]]
         sorted_finite_indices.extend(sorted_rank)
-    
+
     # Map back to original indices and put nans at end
     sorted_original_indices = finite_indices[sorted_finite_indices]
     final_sorted_indices = np.concatenate([sorted_original_indices, nan_indices])
-    
+
     return final_sorted_indices[::-1]
 
 

xopt/tests/generators/ga/test_nsga2.py

@@ -405,28 +405,24 @@ def compare(val_a, val_b):
     "pop_f, pop_g, expected_indices_options",
     [
         # Two individuals in different ranks
-        (
-            np.array([[1.0, 2.0], [2.0, 3.0]]),
-            None,
-            [np.array([1, 0])]
-        ),
+        (np.array([[1.0, 2.0], [2.0, 3.0]]), None, [np.array([1, 0])]),
         # Non-dominated, different crowding distances
         (
             np.array([[1.0, 3.0], [2.0, 2.0], [3.0, 1.0]]),
             None,
-            [np.array([1, 2, 0]), np.array([1, 0, 2])]
+            [np.array([1, 2, 0]), np.array([1, 0, 2])],
         ),
         # NaN values
         (
             np.array([[1.0, 2.0], [np.nan, 3.0], [2.0, 1.0]]),
             None,
-            [np.array([1, 2, 0]), np.array([1, 0, 2])]
+            [np.array([1, 2, 0]), np.array([1, 0, 2])],
         ),
         # Constrained
         (
             np.array([[2.0, 2.0], [1.0, 1.0]]),
             np.array([[-1.0, -1.0], [1.0, -1.0]]),
-            [np.array([1, 0])]
+            [np.array([1, 0])],
         ),
         # Multiple individuals with same rank but potentially same crowding distances
         (
@@ -437,26 +433,26 @@ def compare(val_a, val_b):
                 np.array([1, 3, 2, 0]),
                 np.array([3, 1, 0, 2]),
                 np.array([1, 3, 0, 2]),
-            ]
+            ],
         ),
         # NaN values and constraints
         (
             np.array([[1.0, 2.0], [np.nan, 3.0], [2.0, 1.0]]),
             np.array([[-1.0, -1.0, -1.0], [0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]),
-            [np.array([1, 2, 0])]
+            [np.array([1, 2, 0])],
         ),
         # All NaN
         (
             np.array([[np.nan, np.nan], [np.nan, np.nan]]),
             None,
-            [np.array([0, 1]), np.array([1, 0])]
+            [np.array([0, 1]), np.array([1, 0])],
         ),
     ],
 )
 def test_crowded_comparison_argsort(pop_f, pop_g, expected_indices_options):
     """
     Test the crowded_comparison_argsort function with various explicit input.
-    
+
     Parameters
     ----------
     pop_f : numpy.ndarray
@@ -468,10 +464,12 @@ def test_crowded_comparison_argsort(pop_f, pop_g, expected_indices_options):
     """
     # Call the function
     result = crowded_comparison_argsort(pop_f, pop_g)
-    
+
     # Check if the result matches any of the expected options
-    matches_any = any(np.array_equal(result, expected) for expected in expected_indices_options)
-    
+    matches_any = any(
+        np.array_equal(result, expected) for expected in expected_indices_options
+    )
+
     if not matches_any:
         message = (
             f"Result {result} doesn't match any expected ordering.\n"