fix(lint): update ruff config and pin to latest version

- Add UP045 to ignored rules (Optional[X] -> X | None modernization)
- Update pre-commit hooks to latest versions:
  - ruff v0.8.4 -> v0.14.9
  - pre-commit-hooks v5.0.0 -> v6.0.0
  - codespell v2.3.0 -> v2.4.1
- Pin ruff==0.14.9 in CI workflow for consistency
- Apply minor formatting changes from newer ruff version

Author: andrewkern

.github/workflows/test.yml

@@ -80,7 +80,7 @@ jobs:
     - name: Install Ruff
       run: |
         python -m pip install --upgrade pip
-        pip install ruff
+        pip install ruff==0.14.9
 
     - name: Check linting with Ruff
       run: |

.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 repos:
   # Basic file fixes
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -16,15 +16,15 @@ repos:
 
   # Ruff - replaces black, isort, flake8, and all their plugins
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.4
+    rev: v0.14.9
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
 
   # Spell checking (catches typos in code/comments)
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.3.0
+    rev: v2.4.1
     hooks:
       - id: codespell
         args: [--skip, "*.ipynb,*.html,*.css,*.js"]

example/parallel_ensemble_demo.py

@@ -56,7 +56,7 @@ def train_sequential_ensemble(locator_seq, genotypes, samples, k_folds, output_d
 
     seq_time = time.time() - start_time
     print(f"\nSequential training completed in {seq_time:.1f} seconds")
-    print(f"Average time per fold: {seq_time/k_folds:.1f} seconds")
+    print(f"Average time per fold: {seq_time / k_folds:.1f} seconds")
 
     # Get averaged normalization parameters
     seq_norm = seq_result["normalization_params"]
@@ -91,7 +91,7 @@ def train_parallel_ensemble(
         par_time = time.time() - start_time
 
         print(f"\nParallel training completed in {par_time:.1f} seconds")
-        print(f"Average time per fold: {par_time/k_folds:.1f} seconds")
+        print(f"Average time per fold: {par_time / k_folds:.1f} seconds")
 
         # Get averaged normalization parameters
         par_norm = par_result["normalization_params"]

locator/cli.py

@@ -290,7 +290,7 @@ def main():  # noqa: C901
 
     # Report runtime
     end = time.time()
-    print(f"Run time: {(end-start)/60:.2f} minutes")
+    print(f"Run time: {(end - start) / 60:.2f} minutes")
 
     return 0
 

locator/parallel/parallel_analysis.py

@@ -413,7 +413,7 @@ def parallel_k_fold_holdouts(  # noqa: C901
 
     if verbose:
         print(
-            f"\nCompleted {k}-fold CV in {total_time:.1f}s ({total_time/k:.1f}s per fold)"
+            f"\nCompleted {k}-fold CV in {total_time:.1f}s ({total_time / k:.1f}s per fold)"
         )
 
     # Restore original bandwidth setting if we changed it
@@ -902,7 +902,7 @@ def parallel_holdouts(  # noqa: C901
 
     if verbose:
         print(
-            f"\nCompleted {n_reps} replicates in {total_time:.1f}s ({total_time/n_reps:.1f}s per replicate)"
+            f"\nCompleted {n_reps} replicates in {total_time:.1f}s ({total_time / n_reps:.1f}s per replicate)"
         )
 
     # Restore original bandwidth setting if we changed it
@@ -1450,7 +1450,7 @@ def parallel_windows_holdouts(  # noqa: C901
             )
 
     if verbose and len(windows) > 10:
-        print(f"... and {len(windows)-10} more windows")
+        print(f"... and {len(windows) - 10} more windows")
 
     # Wait for all windows to complete with progress bar
     if verbose:
@@ -1485,7 +1485,7 @@ def parallel_windows_holdouts(  # noqa: C901
 
     if verbose:
         print(
-            f"\nCompleted {len(windows)} windows in {total_time:.1f}s ({total_time/len(windows):.1f}s per window)"
+            f"\nCompleted {len(windows)} windows in {total_time:.1f}s ({total_time / len(windows):.1f}s per window)"
         )
 
         # Show GPU utilization summary
@@ -1497,7 +1497,7 @@ def parallel_windows_holdouts(  # noqa: C901
         print("\nGPU utilization:")
         for gpu_id in sorted(gpu_counts.keys()):
             print(
-                f"  GPU {gpu_id}: {gpu_counts[gpu_id]} windows ({gpu_counts[gpu_id]/len(windows)*100:.1f}%)"
+                f"  GPU {gpu_id}: {gpu_counts[gpu_id]} windows ({gpu_counts[gpu_id] / len(windows) * 100:.1f}%)"
             )
 
     # Restore original bandwidth setting if we changed it
@@ -1884,7 +1884,7 @@ def parallel_train_ensemble(  # noqa: C901
 
     if verbose:
         print(
-            f"\nCompleted ensemble training in {total_time:.1f}s ({total_time/k:.1f}s per fold)"
+            f"\nCompleted ensemble training in {total_time:.1f}s ({total_time / k:.1f}s per fold)"
         )
 
         # Show speedup vs sequential

locator/plotting.py

@@ -552,8 +552,8 @@ def plot_error_summary(  # noqa: C901
         f"Mean error: {merged['error'].mean():.2f} {error_units}\n"
         f"Median error: {merged['error'].median():.2f} {error_units}\n"
         f"Max error: {merged['error'].max():.2f} {error_units}\n"
-        f"R² (x): {np.corrcoef(merged['x_pred'], merged['x_true'])[0,1]**2:.3f}\n"
-        f"R² (y): {np.corrcoef(merged['y_pred'], merged['y_true'])[0,1]**2:.3f}"
+        f"R² (x): {np.corrcoef(merged['x_pred'], merged['x_true'])[0, 1] ** 2:.3f}\n"
+        f"R² (y): {np.corrcoef(merged['y_pred'], merged['y_true'])[0, 1] ** 2:.3f}"
     )
     hist_ax.text(
         0.95,
@@ -1313,7 +1313,7 @@ def _repr_html_(self):  # noqa: C901
                 if k in self.config["weight_samples"].keys():
                     if self.config["weight_samples"][k] is not None:
                         html.append(
-                            f"<tr><td style='padding:5px'>{'weight_samples '+k}</td>"
+                            f"<tr><td style='padding:5px'>{'weight_samples ' + k}</td>"
                             f"<td style='padding:5px'>{self.config['weight_samples'][k]}</td></tr>"
                         )
 

locator/training.py

@@ -318,14 +318,14 @@ def train(  # noqa: C901
             if self.config.get("verbose_splits", False):
                 print("\nData split summary:")
                 print(
-                    f"  Training samples: {len(train)} ({len(train)/len(samples)*100:.1f}%)"
+                    f"  Training samples: {len(train)} ({len(train) / len(samples) * 100:.1f}%)"
                 )
                 print(
-                    f"  Validation samples: {len(test)} ({len(test)/len(samples)*100:.1f}%)"
+                    f"  Validation samples: {len(test)} ({len(test) / len(samples) * 100:.1f}%)"
                 )
                 if len(pred) > 0:
                     print(
-                        f"  Prediction samples (no coords): {len(pred)} ({len(pred)/len(samples)*100:.1f}%)"
+                        f"  Prediction samples (no coords): {len(pred)} ({len(pred) / len(samples) * 100:.1f}%)"
                     )
                 print(f"  Total samples: {len(samples)}")
                 print(f"  Total SNPs: {self.filtered_genotypes.shape[0]}")
@@ -548,13 +548,13 @@ def train_holdout(  # noqa: C901
         if self.config.get("verbose_splits", False):
             print("\nHoldout split summary:")
             print(
-                f"  Training samples: {len(train_indices)} ({len(train_indices)/len(samples)*100:.1f}%)"
+                f"  Training samples: {len(train_indices)} ({len(train_indices) / len(samples) * 100:.1f}%)"
             )
             print(
-                f"  Validation samples: {len(test_indices)} ({len(test_indices)/len(samples)*100:.1f}%)"
+                f"  Validation samples: {len(test_indices)} ({len(test_indices) / len(samples) * 100:.1f}%)"
             )
             print(
-                f"  Holdout samples: {len(holdout_idx)} ({len(holdout_idx)/len(samples)*100:.1f}%)"
+                f"  Holdout samples: {len(holdout_idx)} ({len(holdout_idx) / len(samples) * 100:.1f}%)"
             )
             print(f"  Total samples: {len(samples)}")
             print(f"  Total SNPs: {self.filtered_genotypes.shape[0]}")
@@ -739,12 +739,12 @@ def _create_model(self, input_shape):
         """Create neural network model. Extracted to avoid duplication."""
         loss_fn = None
         if self.config.get("use_range_penalty"):
-            assert (
-                self.config.get("species_range_shapefile") is not None
-            ), "species_range_shapefile must be provided if use_range_penalty is True"
-            assert (
-                self.config.get("resolution") is not None
-            ), "resolution must be provided if use_range_penalty is True"
+            assert self.config.get("species_range_shapefile") is not None, (
+                "species_range_shapefile must be provided if use_range_penalty is True"
+            )
+            assert self.config.get("resolution") is not None, (
+                "resolution must be provided if use_range_penalty is True"
+            )
 
             mask_tensor, mask_transform = rasterize_species_range(
                 self.config["species_range_shapefile"],

pyproject.toml

@@ -126,7 +126,8 @@ ignore = [
     "B904",   # raise from err/None in except clause
     # pyupgrade (type annotation modernization - requires Python 3.10+)
     "UP006",  # use tuple instead of Tuple
-    "UP007",  # use X | Y instead of Optional[X]
+    "UP007",  # use X | Y instead of Union[X, Y]
+    "UP045",  # use X | None instead of Optional[X]
 ]
 
 [tool.ruff.lint.per-file-ignores]

tests/test_separate_mode_predict_all.py

@@ -70,16 +70,16 @@ def test_separate_mode_predicts_all_samples(self, tmp_path):
         predictions = locator.predict(return_df=True, save_preds_to_disk=False)
 
         # Check that we got predictions for ALL samples
-        assert (
-            len(predictions) == 20
-        ), f"Expected 20 predictions but got {len(predictions)}"
+        assert len(predictions) == 20, (
+            f"Expected 20 predictions but got {len(predictions)}"
+        )
 
         # Check that predictions include all sample IDs
         pred_sample_ids = set(predictions["sampleID"])
         all_sample_ids = set(samples)
-        assert (
-            pred_sample_ids == all_sample_ids
-        ), "Predictions should include all samples"
+        assert pred_sample_ids == all_sample_ids, (
+            "Predictions should include all samples"
+        )
 
     def test_separate_mode_with_no_na_samples(self, tmp_path):
         """Test that 'separate' mode works correctly when all samples have coordinates."""
@@ -105,9 +105,9 @@ def test_separate_mode_with_no_na_samples(self, tmp_path):
         predictions = locator.predict(return_df=True, save_preds_to_disk=False)
 
         # Check that we still get predictions for all samples
-        assert (
-            len(predictions) == 10
-        ), f"Expected 10 predictions but got {len(predictions)}"
+        assert len(predictions) == 10, (
+            f"Expected 10 predictions but got {len(predictions)}"
+        )
 
     def test_exclude_mode_only_predicts_na(self, tmp_path):
         """Test that 'exclude' mode excludes NA samples from both training and prediction."""
@@ -137,6 +137,6 @@ def test_exclude_mode_only_predicts_na(self, tmp_path):
         predictions = locator.predict(return_df=True, save_preds_to_disk=False)
 
         # In exclude mode, there are no samples to predict
-        assert (
-            len(predictions) == 0
-        ), f"Expected 0 predictions in exclude mode but got {len(predictions)}"
+        assert len(predictions) == 0, (
+            f"Expected 0 predictions in exclude mode but got {len(predictions)}"
+        )