lint: tighten flake8 strict-select to all-style + sync pre-commit + dev-onboarding

Adds the full E-class style codes plus the pyflakes bug-detectors to
the CI strict-select list so they fail the build instead of merely
warning. Local pre-commit config now mirrors CI, so 'green locally'
implies 'green CI'. Plus README onboarding for new contributors.

Strict-select gates now include:
  * E9 / F63 / F7 / F82  syntax errors, undefined names
  * F401 / F811 / F841   unused imports / redefinitions / unused locals
  * E202                  whitespace before '}'
  * E226                  missing whitespace around arithmetic operator
  * E251                  unexpected spaces around keyword/parameter equals
  * E402                  module-level import not at top of file
  * E501                  line too long (88-char limit, matches BoTorch)
  * E741                  ambiguous variable name ('I'/'l'/'O')

Files modified to conform:
  * boxcrete/slump_model.py         drop unused 'import torch'
  * docs/generate_mix_analyses.py   drop unused 'cost'/'str_1' locals;
                                    wrap ~20 long f-strings
  * test/test_partial_fixed_noise_likelihood.py  drop unused 'n_total'
  * boxcrete/features.py            move 'from boxcrete.utils import
                                    DEFAULT_X_COLUMNS' to top of module
  * experiments/regenerate_strength_json.py  relocate '# noqa: E402'
                                    to opening line of multi-line import
  * boxcrete/plotting.py:191        rename 'I' -> 'eye_n' (E741)
  * test/test_models.py:412         rename 'I' -> 'eye_n' (E741)
  * boxcrete/utils.py:275-276,467   f-string '{x = }' -> '{x=}' (E202/E251)
  * experiments/check_artifacts_drift.py  '*100' -> '* 100' (E226)
  * test/test_lengthscale_identifiability.py  '*100' -> '* 100' (E226)
  * boxcrete/concrete_model.py      wrap 5 long docstring/error lines
  * boxcrete/kernels.py             wrap 196-char inline comment
  * boxcrete/likelihoods.py         wrap 4 long pragma-comment lines
  * boxcrete/utils.py               wrap 5 long docstring/error lines
  * boxcrete/slump_model.py         wrap 1 long module-docstring line
  * docs/generate_mix_analyses.py   wrap 1 long obs-str line
  * experiments/regenerate_strength_json.py  wrap 2 long print lines
  * test/test_models.py:220         tighten long docstring
  * test/test_strength_curve_monotonicity.py  wrap 3 long error-msg lines
  * test/test_utils.py:679          tighten long docstring

Bonus fix in .flake8: explicit 'exclude' list was silently overriding
flake8's defaults, so .git, __pycache__, .hg, etc. were being linted.
Sapling stores backup copies of working-tree files under
.git/sl/origbackups/ — without the explicit re-add of the default
excludes, flake8 was reporting violations from old deleted research
code. Defaults restored explicitly.

Developer ergonomics:
  * .pre-commit-config.yaml synced to the CI strict-select so the
    local pre-commit hook fails on the same codes CI does (no more
    'green locally, red on CI' surprises).
  * README adds a 'Development' section explaining
    'pip install -e ".[dev]" && pre-commit install' onboarding, the
    role of black (auto-fix) vs flake8 (gate), and the 88-char line
    convention (matches BoTorch/GPyTorch).

Author: SebastianAment

.flake8

@@ -2,4 +2,18 @@
 # E203, W503: black and flake8 disagree on whitespace/operator placement
 ignore = E203, W503
 max-line-length = 88
-exclude = build, dist, .eggs
+# When ``exclude`` is set explicitly it OVERRIDES flake8's defaults
+# (.svn, CVS, .bzr, .hg, .git, __pycache__, .tox, .eggs, *.egg) — so we
+# spell them out here. ``.git`` is critical: Sapling stores backup
+# copies of working-tree files under ``.git/sl/origbackups/`` and
+# without this exclude flake8 would lint them.
+exclude =
+    .git,
+    .hg,
+    .svn,
+    __pycache__,
+    .tox,
+    .eggs,
+    *.egg,
+    build,
+    dist,

.github/workflows/tests.yml

@@ -93,7 +93,10 @@ jobs:
 
       - name: Lint with flake8
         run: |
-          # Stop build if there are Python syntax errors or undefined names
-          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-          # Exit-zero treats all errors as warnings
+          # Hard gate: syntax errors, undefined names, unused imports /
+          # locals (real bugs), AND style violations (long lines,
+          # whitespace, etc.) — keeping local pre-commit and CI in sync
+          # so 'green locally' implies 'green on CI'.
+          flake8 . --count --select=E9,E202,E226,E251,E402,E501,E741,F401,F63,F7,F811,F82,F841 --show-source --statistics
+          # Exit-zero treats remaining E/W warnings as informational.
           flake8 . --count --exit-zero --statistics

.pre-commit-config.yaml

@@ -20,11 +20,11 @@ repos:
     rev: 7.1.1
     hooks:
       - id: flake8
-        # CI's hard gate: fail only on syntax errors / undefined names.
-        # Style warnings are reported but non-blocking on CI, and we keep
-        # the same posture locally to avoid pre-commit becoming a nag.
+        # Mirrors the CI lint gate in .github/workflows/tests.yml. Fails
+        # on the same codes CI fails on, so a successful local commit
+        # implies a green lint job upstream.
         args:
           - --count
-          - --select=E9,F63,F7,F82
+          - --select=E9,E202,E226,E251,E402,E501,E741,F401,F63,F7,F811,F82,F841
           - --show-source
           - --statistics

README.md

@@ -235,5 +235,30 @@ For the earlier workshop paper that introduced the model with mortar data, pleas
 }
 ```
 
+## Development
+
+For local development, install with the `dev` extras and register the
+pre-commit hook so every `git commit` is auto-checked against the same
+lint gate the CI uses:
+
+```bash
+pip install -e ".[dev]"
+pre-commit install
+```
+
+`black` will auto-format whitespace, quoting, and most line wrapping on
+commit. `flake8` will fail the commit if it finds any of: syntax errors,
+undefined names, unused imports / locals, late imports, ambiguous names,
+or lines over 88 characters. To run the gate manually across the whole
+repo (matching CI):
+
+```bash
+pre-commit run --all-files
+```
+
+When adding a new long string literal or comment that black can't auto-
+split, hand-wrap it to ≤ 88 columns — the same convention BoTorch and
+GPyTorch use.
+
 ## License
 `SustainableConcrete` is released under the MIT license, as found in the LICENSE file.

boxcrete/concrete_model.py

@@ -65,8 +65,9 @@ def __init__(
             slump_model: The slump model. Defaults to None.
             cost_model: The cost model. Defaults to None.
             d: The dimensionality of the input to the strength model.
-                Is inferred automatically if the fit functions are called. NOTE: The model
-                assumes that the last element of the input corresponds to the time dimension.
+                Is inferred automatically if the fit functions are called.
+                NOTE: The model assumes that the last element of the input
+                corresponds to the time dimension.
         """
         self.strength_days = strength_days
         self.strength_model = strength_model
@@ -273,7 +274,8 @@ def get_model_list(
         """
         if self.d is None or self.strength_model is None or self.gwp_model is None:
             raise ValueError(
-                "Model not fit yet. Call fit_gwp_model() and fit_strength_model() first."
+                "Model not fit yet. Call fit_gwp_model() and "
+                "fit_strength_model() first."
             )
 
         time_idx = self.d - 1  # last column is Time
@@ -330,7 +332,8 @@ def model_names(self) -> list[str]:
         """Ordered names of outputs in the ``ModelList`` from ``get_model_list``.
 
         Returns:
-            A list like ``["GWP", "1-day Strength", "28-day Strength", "Slump (in)", "Cost"]``.
+            A list like
+            ``["GWP", "1-day Strength", "28-day Strength", "Slump (in)", "Cost"]``.
         """
         names = ["GWP"]
         for day in self.strength_days:
@@ -363,7 +366,8 @@ def get_model_dict(
     ) -> dict[str, Model]:
         """Returns a name-to-model dictionary for the multi-output model.
 
-        Equivalent to ``dict(zip(model.model_names, model.get_model_list(...).models))``.
+        Equivalent to
+        ``dict(zip(model.model_names, model.get_model_list(...).models))``.
 
         Args:
             fixed_features: Same as ``get_model_list``.

boxcrete/features.py

@@ -35,6 +35,8 @@
 from botorch.models.transforms.input import InputTransform
 from torch import Tensor
 
+from boxcrete.utils import DEFAULT_X_COLUMNS
+
 # Time gate constant: h(t) = 1 - exp(-t / GATE_TAU).
 # tau=0.05 (post-input-transform time units) was found to be optimal in
 # the τ-sweep; see §4.5 of the benchmark.
@@ -54,8 +56,6 @@
 )
 
 
-from boxcrete.utils import DEFAULT_X_COLUMNS
-
 # Short alias → full column name in :data:`boxcrete.utils.DEFAULT_X_COLUMNS`.
 # The integer indices in :data:`IDX` are *derived* from
 # ``DEFAULT_X_COLUMNS`` at import time, so any reorder / addition /
@@ -176,10 +176,11 @@ def append_engineered_features_callable(
     """
 
     def f(X: torch.Tensor) -> torch.Tensor:
-        if (
-            not feature_names
-        ):  # pragma: no cover -- V2 fit always has F5_alllog (7 features); empty-feature_names branch only used by research-only ablations
-            return X.new_empty((*X.shape[:-1], 1, 0))
+        if not feature_names:
+            # ``pragma: no cover`` -- V2 fit always has F5_alllog
+            # (7 features); empty-feature_names branch only used by
+            # research-only ablations.
+            return X.new_empty((*X.shape[:-1], 1, 0))  # pragma: no cover
         feats = torch.cat([FEATURE_BUILDERS[n](X) for n in feature_names], dim=-1)
         return feats.unsqueeze(-2)
 
@@ -197,10 +198,11 @@ def max_scale_Y(Y: Tensor) -> tuple[Tensor, Tensor, Tensor]:
     Returns ``(Y_scaled, y_mean=0, y_std=y_max)`` so the existing untransform
     code path ``mean * y_std + y_mean`` works correctly.
     """
-    if (
-        Y.dim() == 1
-    ):  # pragma: no cover -- V2 callers pass [n, 1] Y (Y-shape guard at fit_strength_gp top); 1D fallback retained for symmetry with BoTorch's Standardize signature
-        Y = Y.unsqueeze(-1)
+    if Y.dim() == 1:
+        # ``pragma: no cover`` -- V2 callers pass [n, 1] Y (Y-shape
+        # guard at ``fit_strength_gp`` top); 1D fallback retained for
+        # symmetry with BoTorch's Standardize signature.
+        Y = Y.unsqueeze(-1)  # pragma: no cover
     y_max = Y.abs().max(dim=0, keepdim=True).values.clamp_min(1e-6)
     y_mean = torch.zeros_like(y_max)
     return Y / y_max, y_mean, y_max
@@ -215,10 +217,11 @@ def augmented_bounds(
     empirical [min, max] (with 5% padding) over the appended features
     evaluated on X.
     """
-    if (
-        not feature_names
-    ):  # pragma: no cover -- V2 fit always passes F5_alllog (7 features); empty-feature_names branch only used by research-only no-feature ablations
-        return bounds
+    if not feature_names:
+        # ``pragma: no cover`` -- V2 fit always passes F5_alllog
+        # (7 features); empty-feature_names branch only used by
+        # research-only no-feature ablations.
+        return bounds  # pragma: no cover
     appended_vals = torch.cat([FEATURE_BUILDERS[n](X) for n in feature_names], dim=-1)
     aug_lower = appended_vals.min(dim=0).values
     aug_upper = appended_vals.max(dim=0).values

boxcrete/kernels.py

@@ -173,9 +173,11 @@ def forward(self, x1, x2, diag=False, last_dim_is_batch=False, **params):
         h2 = self._h(x2[..., self.time_idx])
         if diag:
             # K shape: [..., n] — element-wise multiply by h1, h2 (same shape)
-            return (
-                K * h1 * h2
-            )  # pragma: no cover -- diag=True kernel-eval branch; BoTorch's posterior(...).variance computes full covariance and extracts the diagonal, never calling kernel.forward with diag=True
+            # ``diag=True`` kernel-eval branch; BoTorch's
+            # ``posterior(...).variance`` computes the full covariance
+            # and extracts the diagonal, so kernel.forward is never
+            # called with diag=True in the production fit path.
+            return K * h1 * h2  # pragma: no cover
         # K shape: [..., n1, n2]; multiply by h1[...,n1,1] and h2[...,1,n2]
         return K * h1.unsqueeze(-1) * h2.unsqueeze(-2)
 

boxcrete/likelihoods.py

@@ -128,10 +128,12 @@ def __init__(
         noise_prior=None,
         **kwargs,
     ):
-        if (
-            noise_constraint is None
-        ):  # pragma: no cover -- production callers always pass an explicit noise_constraint via build_strength_kernel_for_aug_dim; this default-fallback path is research-only
-            noise_constraint = LogTransformedInterval(
+        if noise_constraint is None:
+            # ``pragma: no cover`` -- production callers always pass
+            # an explicit ``noise_constraint`` via
+            # ``build_strength_kernel_for_aug_dim``; this default-
+            # fallback path is research-only.
+            noise_constraint = LogTransformedInterval(  # pragma: no cover
                 1e-6,
                 1.0,
                 initial_value=1e-1,
@@ -161,9 +163,10 @@ def noise(self) -> torch.Tensor:
         doesn't proxy this automatically when we override
         ``_shaped_noise_covar`` with a ``HomoskedasticNoise`` placeholder,
         so we expose it explicitly here."""
-        return (
-            self.noise_covar.noise
-        )  # pragma: no cover -- exposed for notebook ergonomics; production fit/predict paths read self.noise_covar.noise directly
+        # ``pragma: no cover`` -- exposed for notebook ergonomics;
+        # production fit/predict paths read ``self.noise_covar.noise``
+        # directly.
+        return self.noise_covar.noise  # pragma: no cover
 
     def set_train_times(self, time_values: torch.Tensor) -> None:
         """Stash post-input-transform train times so the MLL path (which
@@ -193,8 +196,13 @@ def _shaped_noise_covar(self, base_shape, *params, **kwargs):
             t = params[0][..., self.time_idx]
         elif getattr(self, "_train_times", None) is not None:
             t = self._train_times
-        else:  # pragma: no cover -- defensive fallback; V2 fit always either passes a 2D X (training) or has _train_times set (eval) before this method is called
-            return super()._shaped_noise_covar(base_shape, *params, **kwargs)
+        else:
+            # ``pragma: no cover`` -- defensive fallback; V2 fit always
+            # either passes a 2D X (training) or has ``_train_times``
+            # set (eval) before this method is called.
+            return super()._shaped_noise_covar(  # pragma: no cover
+                base_shape, *params, **kwargs
+            )
         h = self._gate(t)
         h2 = h * h  # element-wise [n]
         # Scalar global noise (broadcasted to per-row).
@@ -203,9 +211,12 @@ def _shaped_noise_covar(self, base_shape, *params, **kwargs):
         n = int(base_shape[-1])
         if per_row_var.shape[0] >= n:
             per_row_var = per_row_var[:n]
-        else:  # pragma: no cover -- pad branch; V2 fit pre-sizes _train_times to match training data, so per_row_var.shape[0] always >= n
-            pad = sigma2.expand(n - per_row_var.shape[0])
-            per_row_var = torch.cat([per_row_var, pad], dim=0)
+        else:
+            # ``pragma: no cover`` -- pad branch; V2 fit pre-sizes
+            # ``_train_times`` to match training data, so
+            # ``per_row_var.shape[0]`` always >= n.
+            pad = sigma2.expand(n - per_row_var.shape[0])  # pragma: no cover
+            per_row_var = torch.cat([per_row_var, pad], dim=0)  # pragma: no cover
         return DiagLinearOperator(per_row_var)
 
 

boxcrete/plotting.py

@@ -188,8 +188,8 @@ def compute_loo_cv(
     L = psd_safe_cholesky(K)
     residuals = (train_Y - prior_dist.mean).unsqueeze(-1)
     K_inv_res = torch.cholesky_solve(residuals, L)
-    I = torch.eye(n, dtype=L.dtype, device=L.device)
-    L_inv = torch.linalg.solve_triangular(L, I, upper=False)
+    eye_n = torch.eye(n, dtype=L.dtype, device=L.device)
+    L_inv = torch.linalg.solve_triangular(L, eye_n, upper=False)
     K_inv_diag = (L_inv**2).sum(dim=-2)
     loo_var = (1.0 / K_inv_diag).unsqueeze(-1)
     loo_mean = train_Y.unsqueeze(-1) - K_inv_res * loo_var

boxcrete/slump_model.py

@@ -17,13 +17,12 @@
   * :func:`fit_slump_gp` — fit a slump GP on raw (X, Y, Yvar) data.
 
 The HRWR/binder ratio is appended via :class:`AppendDerivedFeatures`
-from :mod:`boxcrete.features` (the same transform :mod:`boxcrete.strength_model_legacy`'s
-V1 input transform composes with).
+from :mod:`boxcrete.features` (the same transform
+:mod:`boxcrete.strength_model_legacy`'s V1 input transform composes with).
 """
 
 from __future__ import annotations
 
-import torch
 from botorch import fit_gpytorch_mll
 from botorch.models import SingleTaskGP
 from botorch.models.transforms.input import ChainedInputTransform, Normalize