Updated ruff to v0.16

.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
         exclude: ^src/badger/tests/
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.16
+    rev: v0.16.8
     hooks:
       - id: ruff-check
         args: [--fix]

AGENTS.md

@@ -37,7 +37,7 @@ All tests should pass. GUI tests use `pytest-qt` and require a display server (t
 
 - **`suppress_popups` is autouse.** All tests automatically mock `ExpandableMessageBox.exec_` to prevent Qt dialogs from blocking test execution.
 
-- **Disabled tests use `x-` prefix.** Files like `x-test_db.py` are excluded from pytest collection (they don't match the `test_*.py` pattern). These require `BADGER_DB_ROOT` to be configured.
+- **Disabled tests use `x_` prefix.** Files like `x_test_db.py` are excluded from pytest collection (they don't match the `test_*.py` pattern). These require `BADGER_DB_ROOT` to be configured.
 
 - **Coverage targets the `badger` module.** `pyproject.toml` uses `--cov=badger` (module name, not a path), which resolves correctly under the `src/` layout.
 
@@ -168,6 +168,48 @@ A pre-commit hook (`check-module-docstrings`) enforces presence. Empty `__init__
 
 3. **`Interface.reset_interface()`** is called after process fork — use it to reset any non-fork-safe state (file descriptors, connections, etc.) in custom interfaces.
 
-4. **The `db.py` module is semi-deprecated** — it requires `BADGER_DB_ROOT` config which is not in the default `BadgerConfig` model. The `x-test_db.py` and `x-test_routine_id.py` files test this functionality but are excluded from normal test runs.
+4. **The `db.py` module is semi-deprecated** — it requires `BADGER_DB_ROOT` config which is not in the default `BadgerConfig` model. The `x_test_db.py` and `x_test_routine_id.py` files test this functionality but are excluded from normal test runs.
 
 5. **`utils.py` has Qt dependencies** — `BlockSignalsContext` and related utilities import from `PyQt5.QtWidgets` at the module level, so `badger.utils` cannot be imported without PyQt5 installed.
+
+## Conforming to Ruff linting rules
+
+Ruff adds many rules to the pre-commit python linting. Any of these rules can be ignored on a case-by-case basis going forward if given a valid reasoning behind the inclusion using the following format: `# noqa: <RUFF_ERROR_CODE> - <REASON FOR EXCEPTION>`
+
+Common Ruff errors going forward.
+
+### BLE001 - blind-except
+
+```python
+try:
+    foo()
+except Exception:
+    ...
+```
+
+Use instead:
+
+```python
+try:
+    foo()
+except FileNotFoundError:  # specific expected error to be thrown
+    ...
+```
+
+There are valid reasons to catch just the base exception in certain cases; however, catching the specific expected error will be preferred, and catching the base exception should now always include the reason for doing so.
+
+```python
+try:
+    foo()
+except Exception:  # noqa: BLE001 - Reason for exception
+    ...
+```
+
+Alternatively, re-raising the error or exceptions logged with `exc_info` will not be flagged.
+
+```python
+try:
+    foo()
+except BaseException:
+    logger.exception("Something went wrong")
+```

documentation/docs/getting-started/tutorial_0.md

@@ -77,24 +77,23 @@ from badger import environment
 
 
 class Environment(environment.Environment):
-
-    name = 'sphere_3d'  # name of the environment
+    name = "sphere_3d"  # name of the environment
     variables = {  # variables and their hard-limited ranges
-        'x0': [-1, 1],
-        'x1': [-1, 1],
-        'x2': [-1, 1],
+        "x0": [-1, 1],
+        "x1": [-1, 1],
+        "x2": [-1, 1],
     }
-    observables = ['f']  # measurements
+    observables = ["f"]  # measurements
 
     # Internal variables to store the current values of
     # the variables and observables
     _variables = {
-        'x0': 0.0,
-        'x1': 0.0,
-        'x2': 0.0,
+        "x0": 0.0,
+        "x1": 0.0,
+        "x2": 0.0,
     }
     _observations = {
-        'f': None,
+        "f": None,
     }
 
     # Variable getter -- tells Badger how to get current values of the variables
@@ -109,10 +108,13 @@ class Environment(environment.Environment):
             self._variables[var] = x
 
         # Filling up the observations
-        f = self._variables['x0'] ** 2 + self._variables['x1'] ** 2 + \
-            self._variables['x2'] ** 2
+        f = (
+            self._variables["x0"] ** 2
+            + self._variables["x1"] ** 2
+            + self._variables["x2"] ** 2
+        )
 
-        self._observations['f'] = [f]
+        self._observations["f"] = [f]
 
     # Observable getter -- how to get current values of the observables
     def get_observables(self, observable_names):

documentation/docs/guides/more/create-environments-and-interfaces.md

@@ -41,8 +41,7 @@ from badger import interface
 
 
 class Interface(interface.Interface):
-
-    name = 'myintf'
+    name = "myintf"
 
     def get_values(self, channel_names: list):
         pass
@@ -98,8 +97,7 @@ from badger.interface import Interface
 
 
 class Environment(environment.Environment):
-
-    name = 'myenv'
+    name = "myenv"
     variables = {}
     observables = []
 
@@ -136,52 +134,54 @@ Try to avoid doing time-consuming thing in `__init__` method. Badger would creat
 Okay, now we can start to implement the methods. Assume that our sample environment has 3 variables: `x`, `y`, and `z`, with range of [0, 1]. It also has 2 observations: `norm`, and `mean`. Then the `variables` and `observables` class variables should look like:
 
 ```python
-    variables = {
-        'x': [0, 1],
-        'y': [0, 1],
-        'z': [0, 1],
-    }
-    observables = ['norm', 'mean']
+variables = {
+    "x": [0, 1],
+    "y": [0, 1],
+    "z": [0, 1],
+}
+observables = ["norm", "mean"]
 ```
 
 Our custom env is so simple that we don't really need an interface here. Let's implement the getter and setter for the variables:
 
 ```python
-    # Internal variables start with a single underscore
-    _variables = {
-        'x': 0,
-        'y': 0,
-        'z': 0,
-    }
+# Internal variables start with a single underscore
+_variables = {
+    "x": 0,
+    "y": 0,
+    "z": 0,
+}
 
-    def get_variables(self, variable_names: list[str]) -> dict:
-        variable_outputs = {v: self._variables[v] for v in variable_names}
 
-        return variable_outputs
+def get_variables(self, variable_names: list[str]) -> dict:
+    variable_outputs = {v: self._variables[v] for v in variable_names}
 
-    def set_variables(self, variable_inputs: dict[str, float]):
-        for var, x in variable_inputs.items():
-            self._variables[var] = x
+    return variable_outputs
+
+
+def set_variables(self, variable_inputs: dict[str, float]):
+    for var, x in variable_inputs.items():
+        self._variables[var] = x
 ```
 
 Here we use a dictionary called `_variables` to hold the values for the variables.
 
 Now let's add observable related logic:
 
 ```python
-    def get_observables(self, observable_names: list[str]) -> dict:
-        x = self._variables['x']
-        y = self._variables['y']
-        z = self._variables['z']
-
-        observable_outputs = {}
-        for obs in observable_names:
-            if obs == 'norm':
-                observable_outputs[obs] = (x ** 2 + y ** 2 + z ** 2) ** 0.5
-            elif obs == 'mean':
-                observable_outputs[obs] = (x + y + z) / 3
-
-        return observable_outputs
+def get_observables(self, observable_names: list[str]) -> dict:
+    x = self._variables["x"]
+    y = self._variables["y"]
+    z = self._variables["z"]
+
+    observable_outputs = {}
+    for obs in observable_names:
+        if obs == "norm":
+            observable_outputs[obs] = (x**2 + y**2 + z**2) ** 0.5
+        elif obs == "mean":
+            observable_outputs[obs] = (x + y + z) / 3
+
+    return observable_outputs
 ```
 
 At this point, the content of `__init__.py` should be:
@@ -192,21 +192,20 @@ from badger import environment
 
 
 class Environment(environment.Environment):
-
-    name = 'myenv'
+    name = "myenv"
 
     variables = {
-        'x': [0, 1],
-        'y': [0, 1],
-        'z': [0, 1],
+        "x": [0, 1],
+        "y": [0, 1],
+        "z": [0, 1],
     }
-    observables = ['norm', 'mean']
+    observables = ["norm", "mean"]
 
     # Internal variables start with a single underscore
     _variables = {
-        'x': 0,
-        'y': 0,
-        'z': 0,
+        "x": 0,
+        "y": 0,
+        "z": 0,
     }
 
     def get_variables(self, variable_names: list[str]) -> dict:
@@ -219,15 +218,15 @@ class Environment(environment.Environment):
             self._variables[var] = x
 
     def get_observables(self, observable_names: list[str]) -> dict:
-        x = self._variables['x']
-        y = self._variables['y']
-        z = self._variables['z']
+        x = self._variables["x"]
+        y = self._variables["y"]
+        z = self._variables["z"]
 
         observable_outputs = {}
         for obs in observable_names:
-            if obs == 'norm':
-                observable_outputs[obs] = (x ** 2 + y ** 2 + z ** 2) ** 0.5
-            elif obs == 'mean':
+            if obs == "norm":
+                observable_outputs[obs] = (x**2 + y**2 + z**2) ** 0.5
+            elif obs == "mean":
                 observable_outputs[obs] = (x + y + z) / 3
 
         return observable_outputs

pyproject.toml

@@ -56,10 +56,6 @@ where = ["src"]
 include = ["badger"]
 namespaces = false
 
-[tool.ruff.lint]
-extend-select = ["TID252"] # Defaults + check imports
-ignore = ["E722"]          # Until bare except blocks get fixed
-
 [tool.pytest.ini_options]
 addopts = "--cov=badger"
 log_cli_level = "INFO"

scripts/run_tests.py

@@ -1,9 +1,8 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 import sys
 
 import pytest
 
-
 if __name__ == "__main__":
     # Show output results from every test function
     # Show the message output for skipped and expected failures
@@ -18,6 +17,6 @@
         args.extend(["--cov=badger", "--cov-report", "term-missing"])
         args.remove("--show-cov")
 
-    print("pytest arguments: {}".format(args))
+    print(f"pytest arguments: {args}")
     print(f"Running tests on Python {sys.version}")
     sys.exit(pytest.main(args))

src/badger/__main__.py

@@ -5,14 +5,14 @@
 import logging
 
 from badger.actions import show_info
+from badger.actions.config import config_settings
 from badger.actions.doctor import self_check
-from badger.actions.routine import show_routine
-from badger.actions.generator import show_generator
 from badger.actions.env import show_env
+from badger.actions.generator import show_generator
 from badger.actions.install import plugin_install
-from badger.actions.uninstall import plugin_remove
 from badger.actions.intf import show_intf
-from badger.actions.config import config_settings
+from badger.actions.routine import show_routine
+from badger.actions.uninstall import plugin_remove
 from badger.log import setup_logging
 
 logger = logging.getLogger("badger")

src/badger/actions/__init__.py

@@ -2,6 +2,7 @@
 GUI or prints config details; sub-command handlers are re-exported from
 their own modules (doctor, routine, env, generator, etc.)."""
 
+import argparse
 import os
 from importlib import metadata
 
@@ -10,27 +11,25 @@
 from badger.utils import yprint
 
 
-def show_info(args):
+def show_info(args: argparse.Namespace) -> None:
     config_path = None
 
     if args.config_filepath:
         config_path = args.config_filepath
 
-    if args.gui or args.gui_acr:
-        if check_n_config_paths(args.config_filepath):
-            from badger.gui import launch_gui
+    if (args.gui or args.gui_acr) and check_n_config_paths(args.config_filepath):
+        from badger.gui import launch_gui
 
-            launch_gui(config_path)
+        launch_gui(config_path)
 
-            return
+        return
 
-    if args.mini:
-        if check_n_config_paths(args.config_filepath):
-            from badger.gui.mini import launch_gui
+    if args.mini and check_n_config_paths(args.config_filepath):
+        from badger.gui.mini import launch_gui
 
-            launch_gui(config_path, template_filename=args.template)
+        launch_gui(config_path, template_filename=args.template)
 
-            return
+        return
 
     if not check_n_config_paths():
         return