style: apply ruff format to geospatial files

Apply ruff code formatting to files modified in the geospatial index
feature branch. No functional changes, only formatting adjustments
for consistency.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: adacovsk

autotest/test_edge_cases.py

@@ -50,17 +50,17 @@ def test_thin_sliver_cell():
         vertices=vertices,
         cell2d=cell2d,
         top=np.ones(ncells) * 10.0,
-        botm=np.zeros(ncells)
+        botm=np.zeros(ncells),
     )
 
     # Build index
     index = GeospatialIndex(grid)
 
     # Test points in/near the sliver region
     test_points = [
-        (50.025, 50.0),   # Should be in a sliver cell
-        (50.075, 25.0),   # Should be in a sliver cell
-        (50.025, 75.0),   # Should be in a sliver cell
+        (50.025, 50.0),  # Should be in a sliver cell
+        (50.075, 25.0),  # Should be in a sliver cell
+        (50.025, 75.0),  # Should be in a sliver cell
     ]
 
     found_count = 0
@@ -71,6 +71,7 @@ def test_thin_sliver_cell():
             xv, yv, _ = grid.xyzvertices
             verts = np.column_stack([xv[result], yv[result]])
             from matplotlib.path import Path
+
             path = Path(verts)
             is_inside = path.contains_point((x, y), radius=1e-9)
 
@@ -88,8 +89,7 @@ def test_thin_sliver_cell():
     # At least some points should be found
     # (not all may be in cells due to Delaunay triangulation specifics)
     assert found_count > 0, (
-        f"Should find at least some points in sliver cells, "
-        f"found {found_count}/3"
+        f"Should find at least some points in sliver cells, found {found_count}/3"
     )
 
 
@@ -114,19 +114,17 @@ def test_boundary_points():
     ]
 
     grid = VertexGrid(
-        vertices=vertices,
-        cell2d=cell2d,
-        top=np.ones(4) * 10.0,
-        botm=np.zeros(4)
+        vertices=vertices, cell2d=cell2d, top=np.ones(4) * 10.0, botm=np.zeros(4)
     )
 
     index = GeospatialIndex(grid)
 
     # Test point exactly on a shared edge (between cells 0 and 1)
     # Should find one of the two cells
     result = index.query_point(1.0, 0.5, k=10)
-    assert result is not None or result == 0 or result == 1, \
+    assert result is not None or result == 0 or result == 1, (
         "Point on boundary should be found in one of the adjacent cells"
+    )
 
 
 def test_corner_points():
@@ -148,10 +146,7 @@ def test_corner_points():
     ]
 
     grid = VertexGrid(
-        vertices=vertices,
-        cell2d=cell2d,
-        top=np.ones(4) * 10.0,
-        botm=np.zeros(4)
+        vertices=vertices, cell2d=cell2d, top=np.ones(4) * 10.0, botm=np.zeros(4)
     )
 
     index = GeospatialIndex(grid)
@@ -180,10 +175,7 @@ def test_outside_grid():
     ]
 
     grid = VertexGrid(
-        vertices=vertices,
-        cell2d=cell2d,
-        top=np.array([10.0]),
-        botm=np.array([0.0])
+        vertices=vertices, cell2d=cell2d, top=np.array([10.0]), botm=np.array([0.0])
     )
 
     index = GeospatialIndex(grid)
@@ -199,8 +191,7 @@ def test_outside_grid():
     for x, y in outside_points:
         result = index.query_point(x, y, k=10)
         assert result is None, (
-            f"Point ({x}, {y}) outside grid should return None, "
-            f"got {result}"
+            f"Point ({x}, {y}) outside grid should return None, got {result}"
         )
 
 

autotest/test_geospatial_benchmark.py

@@ -17,11 +17,13 @@
 
 def benchmark_decorator(func):
     """Decorator to time function execution."""
+
     def wrapper(*args, **kwargs):
         start = time.perf_counter()
         result = func(*args, **kwargs)
         elapsed = time.perf_counter() - start
         return result, elapsed
+
     return wrapper
 
 
@@ -45,9 +47,12 @@ def old_vertex_intersect(grid, x, y):
             ya = np.array(yv[icell2d])
 
             # Bounding box check
-            if (np.any(xi <= xa) and np.any(xi >= xa) and
-                np.any(yi <= ya) and np.any(yi >= ya)):
-
+            if (
+                np.any(xi <= xa)
+                and np.any(xi >= xa)
+                and np.any(yi <= ya)
+                and np.any(yi >= ya)
+            ):
                 path = Path(np.stack((xa, ya)).transpose())
                 if is_clockwise(xa, ya):
                     radius = -1e-9
@@ -110,32 +115,29 @@ def test_benchmark_vertex_grid_small():
     # CRITICAL: Verify results are identical (treating None and nan as equivalent)
     # Convert both to use nan for unfound points
     results_old_normalized = np.array(
-        [r if r is not None else np.nan for r in results_old],
-        dtype=float
+        [r if r is not None else np.nan for r in results_old], dtype=float
     )
     results_new_normalized = np.array(
         [
-            r if not (isinstance(r, float) and np.isnan(r))
-            else np.nan
+            r if not (isinstance(r, float) and np.isnan(r)) else np.nan
             for r in results_new
         ],
-        dtype=float
+        dtype=float,
     )
 
     # Check matches including nan==nan comparisons
     both_valid = ~np.isnan(results_old_normalized) & ~np.isnan(results_new_normalized)
     both_invalid = np.isnan(results_old_normalized) & np.isnan(results_new_normalized)
-    matches = (
-        np.sum((results_old_normalized == results_new_normalized) & both_valid)
-        + np.sum(both_invalid)
-    )
+    matches = np.sum(
+        (results_old_normalized == results_new_normalized) & both_valid
+    ) + np.sum(both_invalid)
     mismatches = n_test - matches
 
-    print(f"\n{'='*60}")
+    print(f"\n{'=' * 60}")
     print(f"Small VertexGrid Test ({ncells} cells, {n_test} points)")
-    print(f"{'='*60}")
+    print(f"{'=' * 60}")
     print("CORRECTNESS:")
-    print(f"  Matching results:    {matches}/{n_test} ({100*matches/n_test:.1f}%)")
+    print(f"  Matching results:    {matches}/{n_test} ({100 * matches / n_test:.1f}%)")
     print(f"  Mismatches:          {mismatches}")
     if mismatches > 0:
         print("  ERROR: Methods produced different results!")
@@ -150,14 +152,15 @@ def test_benchmark_vertex_grid_small():
 
     speedup = time_old / time_new
     print("\nPERFORMANCE:")
-    print(f"  Old method (O(n) loop):       {time_old*1000:.2f} ms")
-    print(f"  New method (KD-tree + Hull):  {time_new*1000:.2f} ms")
+    print(f"  Old method (O(n) loop):       {time_old * 1000:.2f} ms")
+    print(f"  New method (KD-tree + Hull):  {time_new * 1000:.2f} ms")
     print(f"  Speedup:                      {speedup:.2f}x")
-    print(f"{'='*60}\n")
+    print(f"{'=' * 60}\n")
 
     # MUST match exactly (treating None and nan as equivalent)
-    assert mismatches == 0, \
+    assert mismatches == 0, (
         f"Results don't match! {mismatches} mismatches out of {n_test} points"
+    )
 
 
 def test_benchmark_vertex_grid_medium():
@@ -200,32 +203,29 @@ def test_benchmark_vertex_grid_medium():
     # CRITICAL: Verify results are identical (treating None and nan as equivalent)
     # Convert both to use nan for unfound points
     results_old_normalized = np.array(
-        [r if r is not None else np.nan for r in results_old],
-        dtype=float
+        [r if r is not None else np.nan for r in results_old], dtype=float
     )
     results_new_normalized = np.array(
         [
-            r if not (isinstance(r, float) and np.isnan(r))
-            else np.nan
+            r if not (isinstance(r, float) and np.isnan(r)) else np.nan
             for r in results_new
         ],
-        dtype=float
+        dtype=float,
     )
 
     # Check matches including nan==nan comparisons
     both_valid = ~np.isnan(results_old_normalized) & ~np.isnan(results_new_normalized)
     both_invalid = np.isnan(results_old_normalized) & np.isnan(results_new_normalized)
-    matches = (
-        np.sum((results_old_normalized == results_new_normalized) & both_valid)
-        + np.sum(both_invalid)
-    )
+    matches = np.sum(
+        (results_old_normalized == results_new_normalized) & both_valid
+    ) + np.sum(both_invalid)
     mismatches = n_test - matches
 
-    print(f"\n{'='*60}")
+    print(f"\n{'=' * 60}")
     print(f"Medium VertexGrid Test ({ncells} cells, {n_test} points)")
-    print(f"{'='*60}")
+    print(f"{'=' * 60}")
     print("CORRECTNESS:")
-    print(f"  Matching results:    {matches}/{n_test} ({100*matches/n_test:.1f}%)")
+    print(f"  Matching results:    {matches}/{n_test} ({100 * matches / n_test:.1f}%)")
     print(f"  Mismatches:          {mismatches}")
     if mismatches > 0:
         print("  ERROR: Methods produced different results!")
@@ -245,14 +245,15 @@ def test_benchmark_vertex_grid_medium():
 
     speedup = time_old / time_new
     print("\nPERFORMANCE:")
-    print(f"  Old method (O(n) loop):       {time_old*1000:.2f} ms")
-    print(f"  New method (KD-tree + Hull):  {time_new*1000:.2f} ms")
+    print(f"  Old method (O(n) loop):       {time_old * 1000:.2f} ms")
+    print(f"  New method (KD-tree + Hull):  {time_new * 1000:.2f} ms")
     print(f"  Speedup:                      {speedup:.2f}x")
-    print(f"{'='*60}\n")
+    print(f"{'=' * 60}\n")
 
     # MUST match exactly (treating None and nan as equivalent)
-    assert mismatches == 0, \
+    assert mismatches == 0, (
         f"Results don't match! {mismatches} mismatches out of {n_test} points"
+    )
 
 
 @pytest.mark.slow
@@ -293,43 +294,41 @@ def test_benchmark_vertex_grid_large():
     # CRITICAL: Verify results are identical (treating None and nan as equivalent)
     # Convert both to use nan for unfound points
     results_old_normalized = np.array(
-        [r if r is not None else np.nan for r in results_old],
-        dtype=float
+        [r if r is not None else np.nan for r in results_old], dtype=float
     )
     results_new_normalized = np.array(
         [
-            r if not (isinstance(r, float) and np.isnan(r))
-            else np.nan
+            r if not (isinstance(r, float) and np.isnan(r)) else np.nan
             for r in results_new
         ],
-        dtype=float
+        dtype=float,
     )
 
     # Check matches including nan==nan comparisons
     both_valid = ~np.isnan(results_old_normalized) & ~np.isnan(results_new_normalized)
     both_invalid = np.isnan(results_old_normalized) & np.isnan(results_new_normalized)
-    matches = (
-        np.sum((results_old_normalized == results_new_normalized) & both_valid)
-        + np.sum(both_invalid)
-    )
+    matches = np.sum(
+        (results_old_normalized == results_new_normalized) & both_valid
+    ) + np.sum(both_invalid)
     mismatches = n_test - matches
 
     speedup = time_old / time_new
-    print(f"\n{'='*60}")
+    print(f"\n{'=' * 60}")
     print(f"Large VertexGrid Benchmark ({ncells} cells, {n_test} points)")
-    print(f"{'='*60}")
+    print(f"{'=' * 60}")
     print("CORRECTNESS:")
-    print(f"  Matching results:    {matches}/{n_test} ({100*matches/n_test:.1f}%)")
+    print(f"  Matching results:    {matches}/{n_test} ({100 * matches / n_test:.1f}%)")
     print(f"  Mismatches:          {mismatches}")
     print("\nPERFORMANCE:")
-    print(f"  Old method (O(n) loop):       {time_old*1000:.2f} ms")
-    print(f"  New method (KD-tree + Hull):  {time_new*1000:.2f} ms")
+    print(f"  Old method (O(n) loop):       {time_old * 1000:.2f} ms")
+    print(f"  New method (KD-tree + Hull):  {time_new * 1000:.2f} ms")
     print(f"  Speedup:                      {speedup:.2f}x")
-    print(f"{'='*60}\n")
+    print(f"{'=' * 60}\n")
 
     # MUST match exactly (treating None and nan as equivalent)
-    assert mismatches == 0, \
+    assert mismatches == 0, (
         f"Results don't match! {mismatches} mismatches out of {n_test} points"
+    )
 
 
 def test_benchmark_structured_grid():
@@ -373,16 +372,16 @@ def test_benchmark_structured_grid():
     assert np.array_equal(results_new_array, results_old_array), "Results don't match!"
 
     speedup = time_old / time_new
-    print(f"\n{'='*60}")
+    print(f"\n{'=' * 60}")
     print(
-        f"StructuredGrid Benchmark ({nrow}x{ncol} = {nrow*ncol} "
+        f"StructuredGrid Benchmark ({nrow}x{ncol} = {nrow * ncol} "
         f"cells, {n_test} points)"
     )
-    print(f"{'='*60}")
-    print(f"Old method (optimized):       {time_old*1000:.2f} ms")
-    print(f"New method (KD-tree + Hull):  {time_new*1000:.2f} ms")
+    print(f"{'=' * 60}")
+    print(f"Old method (optimized):       {time_old * 1000:.2f} ms")
+    print(f"New method (KD-tree + Hull):  {time_new * 1000:.2f} ms")
     print(f"Speedup:                      {speedup:.2f}x")
-    print(f"{'='*60}\n")
+    print(f"{'=' * 60}\n")
 
     # For structured grids, should be comparable (both are fast)
     # We're not expecting huge speedup here since old method was already optimized
@@ -403,4 +402,4 @@ def test_benchmark_structured_grid():
     print("\nRunning structured grid benchmark...")
     test_benchmark_structured_grid()
 
-    print("\nAll benchmarks complete!")
+    print("\nAll benchmarks complete!")

flopy/discretization/structuredgrid.py

@@ -1030,7 +1030,7 @@ def intersect(self, x, y, z=None, local=False, forgive=False):
 
         # Vectorized column finding using searchsorted
         # For each x[i], find rightmost edge where x[i] > edge
-        cols_valid = np.searchsorted(xe, x, side='right') - 1
+        cols_valid = np.searchsorted(xe, x, side="right") - 1
         # searchsorted returns index in [0, len(xe)], but valid cols are [0, ncol-1]
         cols_mask = (cols_valid >= 0) & (cols_valid < self.ncol)
         cols[cols_mask] = cols_valid[cols_mask]
@@ -1039,7 +1039,7 @@ def intersect(self, x, y, z=None, local=False, forgive=False):
         # For each y[i], find rightmost edge where y[i] < edge
         # Since ye is in descending order (top to bottom), we need to flip it
         ye_flipped = ye[::-1]
-        rows_flipped = np.searchsorted(ye_flipped, y, side='left')
+        rows_flipped = np.searchsorted(ye_flipped, y, side="left")
         rows_valid = len(ye) - 1 - rows_flipped
         rows_mask = (rows_valid >= 0) & (rows_valid < self.nrow)
         rows[rows_mask] = rows_valid[rows_mask]

flopy/discretization/unstructuredgrid.py

@@ -772,7 +772,7 @@ def intersect(self, x, y, z=None, local=False, forgive=False):
             x, y = super().get_coords(x, y)
 
         # Build or retrieve geospatial index for fast queries
-        if not hasattr(self, '_geospatial_index') or self._geospatial_index is None:
+        if not hasattr(self, "_geospatial_index") or self._geospatial_index is None:
             self._geospatial_index = GeospatialIndex(self)
 
         # Use KD-tree for fast spatial queries
@@ -820,8 +820,7 @@ def intersect(self, x, y, z=None, local=False, forgive=False):
                     else:
                         xi, yi = x[i], y[i]
                         raise ValueError(
-                            f"point ({xi}, {yi}, {zi}) is outside of the "
-                            f"model area"
+                            f"point ({xi}, {yi}, {zi}) is outside of the model area"
                         )
 
         # Return scalar if input was scalar, otherwise return array

flopy/discretization/vertexgrid.py

@@ -402,7 +402,7 @@ def intersect(self, x, y, z=None, local=False, forgive=False):
             x, y = super().get_coords(x, y)
 
         # Build or retrieve geospatial index for fast queries
-        if not hasattr(self, '_geospatial_index') or self._geospatial_index is None:
+        if not hasattr(self, "_geospatial_index") or self._geospatial_index is None:
             self._geospatial_index = GeospatialIndex(self)
 
         # Use KD-tree for fast spatial queries