fix: resolve lint errors for CI

- Add builtins = ["_"] for i18n function
- Add per-file-ignores for notebooks
- Remove unused imports (multiprocessing, utils, GITHUB_REPO)
- Remove duplicate BallTree import
- Rename ambiguous variable l to label
- Apply ruff formatting

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mrosseel

python/PiFinder/audit_images.py

@@ -44,8 +44,8 @@ def check_object_image(catalog_object):
         aka_rec = conn.execute(
             f"""
             SELECT common_name from names
-            where catalog = "{catalog_object['catalog']}"
-            and sequence = "{catalog_object['sequence']}"
+            where catalog = "{catalog_object["catalog"]}"
+            and sequence = "{catalog_object["sequence"]}"
             and common_name like "NGC%"
         """
         ).fetchone()

python/PiFinder/auto_exposure.py

@@ -534,7 +534,7 @@ def handle(
             self._sweep_results = []
             logger.debug(
                 f"Histogram handler activated: starting {self._sweep_steps}-step histogram sweep "
-                f"from {self._sweep_exposures[0]/1000:.1f}ms to {self._sweep_exposures[-1]/1000:.1f}ms"
+                f"from {self._sweep_exposures[0] / 1000:.1f}ms to {self._sweep_exposures[-1] / 1000:.1f}ms"
             )
             return self._sweep_exposures[0]
 
@@ -548,16 +548,16 @@ def handle(
             self._sweep_results.append((sweep_exposure, viable, metrics))
 
             logger.debug(
-                f"Histogram analysis for {sweep_exposure/1000:.1f}ms: "
+                f"Histogram analysis for {sweep_exposure / 1000:.1f}ms: "
                 f"viable={'YES' if viable else 'NO'}, "
                 f"mean={metrics['mean']:.1f}, std={metrics['std']:.1f}, sat={metrics['saturation_pct']:.1f}%"
             )
 
             # Track viable exposures but continue sweep to find best option
             if viable:
                 logger.debug(
-                    f"Histogram handler: found viable exposure {sweep_exposure/1000:.1f}ms "
-                    f"(step {self._sweep_index+1}/{self._sweep_steps}), continuing sweep"
+                    f"Histogram handler: found viable exposure {sweep_exposure / 1000:.1f}ms "
+                    f"(step {self._sweep_index + 1}/{self._sweep_steps}), continuing sweep"
                 )
 
         # If we've completed the sweep, settle on target exposure
@@ -574,22 +574,22 @@ def handle(
                         # Use highest viable exposure for best star detection
                         self._target_exposure = max(viable_exposures)
                         logger.debug(
-                            f"Histogram handler: settling on highest viable exposure {self._target_exposure/1000:.1f}ms"
+                            f"Histogram handler: settling on highest viable exposure {self._target_exposure / 1000:.1f}ms"
                         )
                     else:
                         # No viable exposures - use highest from sweep
                         highest_exp = self._sweep_results[-1][0]
                         self._target_exposure = highest_exp
                         logger.debug(
-                            f"Histogram handler: no viable exposure found, using highest {highest_exp/1000:.1f}ms"
+                            f"Histogram handler: no viable exposure found, using highest {highest_exp / 1000:.1f}ms"
                         )
                 else:
                     # Fallback to middle exposure
                     middle_idx = len(self._sweep_exposures) // 2
                     middle_exp = self._sweep_exposures[middle_idx]
                     self._target_exposure = middle_exp
                     logger.debug(
-                        f"Histogram handler: no analysis data, using middle {middle_exp/1000:.1f}ms"
+                        f"Histogram handler: no analysis data, using middle {middle_exp / 1000:.1f}ms"
                     )
 
             # Hold at target
@@ -602,7 +602,7 @@ def handle(
         if self._sweep_index < len(self._sweep_exposures):
             next_exp = self._sweep_exposures[self._sweep_index]
             logger.debug(
-                f"Histogram handler: sweep step {self._sweep_index+1}/{self._sweep_steps} → {next_exp/1000:.1f}ms"
+                f"Histogram handler: sweep step {self._sweep_index + 1}/{self._sweep_steps} → {next_exp / 1000:.1f}ms"
             )
             return next_exp
         else:
@@ -663,7 +663,7 @@ def __init__(
         logger.info(
             f"AutoExposure SNR: target_bg={target_background}, "
             f"range=[{min_background}, {max_background}] ADU, "
-            f"exp_range=[{min_exposure/1000:.0f}, {max_exposure/1000:.0f}]ms, "
+            f"exp_range=[{min_exposure / 1000:.0f}, {max_exposure / 1000:.0f}]ms, "
             f"adjustment={adjustment_factor}x"
         )
 
@@ -694,7 +694,7 @@ def from_camera_profile(
         profile = get_camera_profile(camera_type)
 
         # Derive thresholds from camera specs
-        max_adu = (2 ** profile.bit_depth) - 1
+        max_adu = (2**profile.bit_depth) - 1
         bias = profile.bias_offset
 
         # min_background: bias + margin (2x bias or bias + 8, whichever larger)
@@ -726,7 +726,7 @@ def update(
         current_exposure: int,
         image: Image.Image,
         noise_floor: Optional[float] = None,
-        **kwargs  # Ignore other params (matched_stars, etc.)
+        **kwargs,  # Ignore other params (matched_stars, etc.)
     ) -> Optional[int]:
         """
         Update exposure based on background level.
@@ -756,7 +756,7 @@ def update(
         background = float(np.percentile(img_array, 10))
 
         logger.debug(
-            f"SNR AE: bg={background:.1f}, min={min_bg:.1f} ADU, exp={current_exposure/1000:.0f}ms"
+            f"SNR AE: bg={background:.1f}, min={min_bg:.1f} ADU, exp={current_exposure / 1000:.0f}ms"
         )
 
         # Determine adjustment
@@ -767,14 +767,14 @@ def update(
             new_exposure = int(current_exposure * self.adjustment_factor)
             logger.info(
                 f"SNR AE: Background too low ({background:.1f} < {min_bg:.1f}), "
-                f"increasing exposure {current_exposure/1000:.0f}ms → {new_exposure/1000:.0f}ms"
+                f"increasing exposure {current_exposure / 1000:.0f}ms → {new_exposure / 1000:.0f}ms"
             )
         elif background > self.max_background:
             # Too bright - decrease exposure
             new_exposure = int(current_exposure / self.adjustment_factor)
             logger.info(
                 f"SNR AE: Background too high ({background:.1f} > {self.max_background}), "
-                f"decreasing exposure {current_exposure/1000:.0f}ms → {new_exposure/1000:.0f}ms"
+                f"decreasing exposure {current_exposure / 1000:.0f}ms → {new_exposure / 1000:.0f}ms"
             )
         else:
             # Background is in acceptable range
@@ -908,7 +908,9 @@ def _update_pid(self, matched_stars: int, current_exposure: int) -> Optional[int
         # from crashing exposure when conditions change suddenly
         # (e.g., going from too many stars to too few stars)
         if self._last_error is not None:
-            if (error > 0 and self._last_error < 0) or (error < 0 and self._last_error > 0):
+            if (error > 0 and self._last_error < 0) or (
+                error < 0 and self._last_error > 0
+            ):
                 logger.debug(
                     f"PID: Error sign changed ({self._last_error:.0f} → {error:.0f}), resetting integral"
                 )

python/PiFinder/camera_interface.py

@@ -141,12 +141,8 @@ def _process_pending_commands(self):
                         self.exposure_time = int(exp_value)
                         self.set_camera_config(self.exposure_time, self.gain)
                         self._cfg.set_option("camera_exp", self.exposure_time)
-                        self._console_queue.put(
-                            "CAM: Exp=" + str(self.exposure_time)
-                        )
-                        logger.info(
-                            f"Manual exposure set: {self.exposure_time}µs"
-                        )
+                        self._console_queue.put("CAM: Exp=" + str(self.exposure_time))
+                        logger.info(f"Manual exposure set: {self.exposure_time}µs")
 
                 elif command.startswith("set_gain"):
                     old_gain = self.gain
@@ -172,9 +168,7 @@ def _process_pending_commands(self):
                                 max_exposure=self._auto_exposure_pid.max_exposure,
                             )
                         elif handler_type == "reset":
-                            new_handler = ResetZeroStarHandler(
-                                reset_exposure=400000
-                            )
+                            new_handler = ResetZeroStarHandler(reset_exposure=400000)
                         elif handler_type == "histogram":
                             new_handler = HistogramZeroStarHandler(
                                 min_exposure=self._auto_exposure_pid.min_exposure,
@@ -186,12 +180,8 @@ def _process_pending_commands(self):
                             )
 
                         if new_handler is not None:
-                            self._auto_exposure_pid._zero_star_handler = (
-                                new_handler
-                            )
-                            self._console_queue.put(
-                                f"CAM: AE Handler={handler_type}"
-                            )
+                            self._auto_exposure_pid._zero_star_handler = new_handler
+                            self._console_queue.put(f"CAM: AE Handler={handler_type}")
                             logger.info(
                                 f"Auto-exposure zero-star handler changed to: {handler_type}"
                             )
@@ -204,12 +194,8 @@ def _process_pending_commands(self):
                     mode = command.split(":")[1]
                     if mode in ["pid", "snr"]:
                         self._auto_exposure_mode = mode
-                        self._console_queue.put(
-                            f"CAM: AE Mode={mode.upper()}"
-                        )
-                        logger.info(
-                            f"Auto-exposure mode changed to: {mode.upper()}"
-                        )
+                        self._console_queue.put(f"CAM: AE Mode={mode.upper()}")
+                        logger.info(f"Auto-exposure mode changed to: {mode.upper()}")
                     else:
                         logger.warning(
                             f"Unknown auto-exposure mode: {mode} (valid: pid, snr)"
@@ -222,17 +208,13 @@ def _process_pending_commands(self):
                     else:
                         self.exposure_time = int(self.exposure_time * 0.75)
                     self.set_camera_config(self.exposure_time, self.gain)
-                    self._console_queue.put(
-                        "CAM: Exp=" + str(self.exposure_time)
-                    )
+                    self._console_queue.put("CAM: Exp=" + str(self.exposure_time))
 
                 elif command == "exp_save":
                     self._auto_exposure_enabled = False
                     self._cfg.set_option("camera_exp", self.exposure_time)
                     self._cfg.set_option("camera_gain", int(self.gain))
-                    self._console_queue.put(
-                        f"CAM: Exp Saved ({self.exposure_time}µs)"
-                    )
+                    self._console_queue.put(f"CAM: Exp Saved ({self.exposure_time}µs)")
                     logger.info(
                         f"Exposure saved and auto-exposure disabled: {self.exposure_time}µs"
                     )
@@ -241,17 +223,12 @@ def _process_pending_commands(self):
                     self._save_next_to = command.split(":")[1]
                     self._console_queue.put("CAM: Save flag set")
 
-                elif (
-                    command.startswith("capture")
-                    and command != "capture_exp_sweep"
-                ):
+                elif command.startswith("capture") and command != "capture_exp_sweep":
                     captured_image = self.capture()
                     self._camera_image.paste(captured_image)
 
                     if self._save_next_to:
-                        filename = (
-                            f"{utils.data_dir}/captures/{self._save_next_to}"
-                        )
+                        filename = f"{utils.data_dir}/captures/{self._save_next_to}"
                         if not filename.endswith(".png"):
                             filename += ".png"
                         self.capture_file(filename)
@@ -278,9 +255,7 @@ def _process_pending_commands(self):
                     self._console_queue.put("CAM: Started camera")
 
             except ValueError as e:
-                logger.error(
-                    f"Error processing camera command '{command}': {str(e)}"
-                )
+                logger.error(f"Error processing camera command '{command}': {str(e)}")
 
     def _run_exposure_sweep(self, command):
         """Capture exposure sweep for SQM testing."""
@@ -336,15 +311,11 @@ def _run_exposure_sweep(self, command):
 
             exp_ms = exp_us / 1000
 
-            processed_filename = (
-                sweep_dir / f"img_{i:03d}_{exp_ms:.2f}ms_processed.png"
-            )
+            processed_filename = sweep_dir / f"img_{i:03d}_{exp_ms:.2f}ms_processed.png"
             processed_img = self.capture()
             processed_img.save(str(processed_filename))
 
-            raw_filename = (
-                sweep_dir / f"img_{i:03d}_{exp_ms:.2f}ms_raw.tiff"
-            )
+            raw_filename = sweep_dir / f"img_{i:03d}_{exp_ms:.2f}ms_raw.tiff"
             self.capture_raw_file(str(raw_filename))
 
             logger.debug(
@@ -379,23 +350,19 @@ def _run_exposure_sweep(self, command):
                 observer_lat=location.lat,
                 observer_lon=location.lon,
                 observer_altitude_m=location.altitude,
-                gps_datetime=gps_datetime.isoformat()
-                if gps_datetime
-                else None,
+                gps_datetime=gps_datetime.isoformat() if gps_datetime else None,
                 reference_sqm=reference_sqm,
                 ra_deg=ra_deg,
                 dec_deg=dec_deg,
                 altitude_deg=altitude_deg,
                 azimuth_deg=azimuth_deg,
-                notes=f"Exposure sweep: {num_images} images, {min_exp/1000:.1f}-{max_exp/1000:.1f}ms",
+                notes=f"Exposure sweep: {num_images} images, {min_exp / 1000:.1f}-{max_exp / 1000:.1f}ms",
             )
             logger.info(
                 f"Successfully saved sweep metadata to {sweep_dir}/sweep_metadata.json"
             )
         except Exception as e:
-            logger.error(
-                f"Failed to save sweep metadata: {e}", exc_info=True
-            )
+            logger.error(f"Failed to save sweep metadata: {e}", exc_info=True)
 
         self._console_queue.put("CAM: Sweep done!")
         logger.info(
@@ -566,22 +533,29 @@ def get_image_loop(
                                     if self._auto_exposure_snr is None:
                                         # Use camera profile to derive thresholds
                                         try:
-                                            cam_type = detect_camera_type(self.get_cam_type())
+                                            cam_type = detect_camera_type(
+                                                self.get_cam_type()
+                                            )
                                             cam_type = f"{cam_type}_processed"
-                                            self._auto_exposure_snr = (
-                                                ExposureSNRController.from_camera_profile(cam_type)
+                                            self._auto_exposure_snr = ExposureSNRController.from_camera_profile(
+                                                cam_type
                                             )
                                         except ValueError as e:
                                             # Unknown camera, use defaults
                                             logger.warning(
                                                 f"Camera detection failed: {e}, using default SNR thresholds"
                                             )
-                                            self._auto_exposure_snr = ExposureSNRController()
+                                            self._auto_exposure_snr = (
+                                                ExposureSNRController()
+                                            )
                                     # Get adaptive noise floor from shared state
-                                    adaptive_noise_floor = self.shared_state.noise_floor()
+                                    adaptive_noise_floor = (
+                                        self.shared_state.noise_floor()
+                                    )
                                     new_exposure = self._auto_exposure_snr.update(
-                                        self.exposure_time, base_image,
-                                        noise_floor=adaptive_noise_floor
+                                        self.exposure_time,
+                                        base_image,
+                                        noise_floor=adaptive_noise_floor,
                                     )
                                 else:
                                     # PID mode: use star-count based controller (default)

python/PiFinder/catalog_imports/catalog_import_utils.py

@@ -213,7 +213,8 @@ def insert_catalog_max_sequence(catalog_name):
     if result:
         query = f"""
             update catalogs set max_sequence = {
-            dict(result)['MAX(sequence)']} where catalog_code = '{catalog_name}'
+            dict(result)["MAX(sequence)"]
+        } where catalog_code = '{catalog_name}'
             """
         db_c.execute(query)
         conn.commit()
@@ -322,7 +323,7 @@ def resolve_object_images():
                     ORDER BY {priority_case_sql}
                 ) as priority_rank
             FROM catalog_objects co
-            WHERE co.catalog_code IN ({','.join(['?'] * len(catalog_priority))})
+            WHERE co.catalog_code IN ({",".join(["?"] * len(catalog_priority))})
         )
         SELECT 
             o.id as object_id,

python/PiFinder/catalog_imports/specialized_loaders.py

@@ -602,7 +602,7 @@ def expand(name):
             for additional in parts[1:]:
                 if additional.isdigit():
                     # If the additional part is a number, add it directly
-                    expanded_list.append(f"{base_part[:-len(additional)]}{additional}")
+                    expanded_list.append(f"{base_part[: -len(additional)]}{additional}")
                 else:
                     expanded_list.append(additional)
         else:

python/PiFinder/catalog_imports/wds_loader.py

@@ -263,7 +263,7 @@ def handle_multiples(key, values) -> dict:
             coord_2000 = entry["Coordinates_2000"]
             coord_arcsec = entry["Coordinates_Arcsec"]
             logging.error(
-                f"Empty or invalid RA/DEC detected for WDS object at line {i+1}"
+                f"Empty or invalid RA/DEC detected for WDS object at line {i + 1}"
             )
             logging.error(f"  Coordinates_2000: '{coord_2000}'")
             logging.error(f"  Coordinates_Arcsec: '{coord_arcsec}'")
@@ -273,7 +273,7 @@ def handle_multiples(key, values) -> dict:
             )
             logging.error(f"  Final RA: {entry['ra']}, DEC: {entry['dec']}")
             raise ValueError(
-                f"Invalid RA/DEC coordinates for WDS object at line {i+1}: RA={entry['ra']}, DEC={entry['dec']}"
+                f"Invalid RA/DEC coordinates for WDS object at line {i + 1}: RA={entry['ra']}, DEC={entry['dec']}"
             )
 
     # make a dictionary of WDS objects to group duplicates

python/PiFinder/catalogs.py

@@ -481,10 +481,7 @@ def is_loading(self) -> bool:
     def start_background_loading(self):
         """Start deferred catalog loading in background thread.
         Call after event loop is ready to avoid SD I/O contention during startup."""
-        if (
-            hasattr(self, "_background_loader")
-            and self._background_loader is not None
-        ):
+        if hasattr(self, "_background_loader") and self._background_loader is not None:
             self._background_loader.start()
 
     def __repr__(self):