ci: enforce ruff in CI, reformat to ruff 0.15.0, prune dead lint deps (#1688)

- code-style job now runs 'ruff check' and 'ruff format --check' (no --fix /
  no in-place format), so violations fail CI instead of being auto-fixed in the
  runner and discarded. Pin the ruff action to 0.15.0 to match pyproject and
  pre-commit.
- Reformat the files that had drifted under the old discard-the-fix flow.
- Drop unused lint deps (flake8, flake8-docstrings, isort, pep8, myst-parser).
- Sync the pre-commit ruff-pre-commit pin to v0.15.0.
- Enable uv caching in the build/test workflow.

Closes #1671

Author: vprusso

.github/workflows/build-test-actions.yml

@@ -19,11 +19,18 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
+      # Pin ruff to the version in pyproject so CI formatting matches local/pre-commit.
       - uses: astral-sh/ruff-action@v3
-      - run: ruff check --fix
-      - run: ruff format
+        with:
+          version: "0.15.0"
+      # Check only (no --fix / no in-place format): style and format violations must fail CI
+      # rather than being silently auto-fixed in the runner and discarded.
+      - run: ruff check
+      - run: ruff format --check
       - name: Install uv
         uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
       # Run the ty type checker for visibility. Non-blocking for now: there is a large backlog of existing
       # diagnostics, so failing CI on them would require a separate type-annotation cleanup.
       - name: Type-check with ty (non-blocking)
@@ -57,6 +64,8 @@ jobs:
           brew install openblas lapack suite-sparse
       - name: Install uv
         uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
       - name: Install toqito + dependencies
         run: |
           uv sync --group dev --no-group docs --no-group lint

.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version (keep in sync with the version in pyproject.toml)
-  rev: v0.11.0
+  rev: v0.15.0
   hooks:
     # Run the linter.
     - id: ruff

pyproject.toml

@@ -57,11 +57,6 @@ dev = [
     "pre-commit>=3.0.0",
 ]
 lint = [
-    "flake8==7.3.0",
-    "flake8-docstrings==1.7.0",
-    "isort==8.0.1",
-    "myst-parser==5.1.0",
-    "pep8==1.7.1",
     "ruff==0.15.0",
     "ty==0.0.12",
 ]

toqito/channel_metrics/channel_exclusion.py

@@ -166,8 +166,7 @@ def _min_error_primal(
     problem = pc.Problem()
 
     strategy_ops = [
-        pc.HermitianVariable(f"W[{idx}]", (dim_in * dim_out, dim_in * dim_out))
-        for idx in range(n_channels)
+        pc.HermitianVariable(f"W[{idx}]", (dim_in * dim_out, dim_in * dim_out)) for idx in range(n_channels)
     ]
     x_var = pc.HermitianVariable("X", (dim_in, dim_in))
 

toqito/channel_metrics/channel_relative_entropy.py

@@ -113,13 +113,9 @@ def channel_relative_entropy(
     if hamiltonian.shape != (in_dim, in_dim):
         raise ValueError("The Hamiltonian must have shape (in_dim, in_dim).")
     if not is_quantum_channel(channel_1):
-        raise ValueError(
-            "Channel relative entropy is only defined if channel_1 is a quantum channel."
-        )
+        raise ValueError("Channel relative entropy is only defined if channel_1 is a quantum channel.")
     if not is_completely_positive(channel_2):
-        raise ValueError(
-            "Channel relative entropy is only defined if channel_2 is completely positive."
-        )
+        raise ValueError("Channel relative entropy is only defined if channel_2 is completely positive.")
     if np.allclose(channel_1, channel_2):
         if mean:
             return 0.0
@@ -156,12 +152,7 @@ def channel_relative_entropy(
         cvx.Maximize(
             cvx.real(
                 cvx.trace(cvx.kron(rho_a, eye_out) @ (choi_1 - choi_2))
-                + cvx.sum(
-                    [
-                        cvx.trace(qs[k] @ (alpha[k] * choi_1 + beta[k] * choi_2))
-                        for k in range(r - 1)
-                    ]
-                )
+                + cvx.sum([cvx.trace(qs[k] @ (alpha[k] * choi_1 + beta[k] * choi_2)) for k in range(r - 1)])
             )
         ),
         cons,
@@ -180,10 +171,7 @@ def channel_relative_entropy(
     upper_cons = (
         [y_var >= 0]
         + [ns[0] - choi_1 + choi_2 >> 0]
-        + [
-            ns[k] - gamma[k - 1] * choi_1 - delta[k - 1] * choi_2 >> 0
-            for k in range(1, r + 1)
-        ]
+        + [ns[k] - gamma[k - 1] * choi_1 - delta[k - 1] * choi_2 >> 0 for k in range(1, r + 1)]
         + [ns[k] >> 0 for k in range(1, r + 1)]
         + [
             x_var * np.eye(in_dim)

toqito/channel_metrics/tests/test_channel_relative_entropy.py

@@ -12,9 +12,7 @@
 from toqito.cones.integral_relative_entropy import _sandwich_parameters
 from toqito.perms import swap_operator
 
-_CHANNEL_RELATIVE_ENTROPY_MOD = importlib.import_module(
-    "toqito.channel_metrics.channel_relative_entropy"
-)
+_CHANNEL_RELATIVE_ENTROPY_MOD = importlib.import_module("toqito.channel_metrics.channel_relative_entropy")
 
 
 def _dense(mat):
@@ -91,9 +89,7 @@ def test_identical_channels_zero():
     """Identical channels should give zero in both bounds and mean modes."""
     choi = depolarizing(2, 1)
 
-    lower, upper = channel_relative_entropy(
-        choi, choi, in_dim=2, epsilon_dec=0.2, mean=False
-    )
+    lower, upper = channel_relative_entropy(choi, choi, in_dim=2, epsilon_dec=0.2, mean=False)
     avg = channel_relative_entropy(choi, choi, in_dim=2, epsilon_dec=0.2, mean=True)
 
     assert lower == 0
@@ -252,9 +248,7 @@ def solve(self, **kwargs):
     monkeypatch.setattr(_CHANNEL_RELATIVE_ENTROPY_MOD.cvx, "Problem", FakeProblem)
 
     with pytest.raises(RuntimeError, match="Lower-bound SDP failed"):
-        channel_relative_entropy(
-            depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2
-        )
+        channel_relative_entropy(depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2)
 
 
 def test_raises_when_upper_sdp_fails(monkeypatch):
@@ -280,9 +274,7 @@ def solve(self, **kwargs):
     monkeypatch.setattr(_CHANNEL_RELATIVE_ENTROPY_MOD.cvx, "Problem", FakeProblem)
 
     with pytest.raises(RuntimeError, match="Upper-bound SDP failed"):
-        channel_relative_entropy(
-            depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2
-        )
+        channel_relative_entropy(depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2)
 
 
 def test_warns_on_optimal_inaccurate_lower(monkeypatch):
@@ -299,9 +291,7 @@ class FakeProblem:
         def __init__(self, objective, constraints):
             self.value = 1.0
             FakeProblem.created += 1
-            self.status = (
-                cvx.OPTIMAL_INACCURATE if FakeProblem.created == 1 else cvx.OPTIMAL
-            )
+            self.status = cvx.OPTIMAL_INACCURATE if FakeProblem.created == 1 else cvx.OPTIMAL
 
         def solve(self, **kwargs):
             pass
@@ -310,9 +300,7 @@ def solve(self, **kwargs):
     monkeypatch.setattr(_CHANNEL_RELATIVE_ENTROPY_MOD.cvx, "Problem", FakeProblem)
 
     with pytest.warns(UserWarning, match="Lower-bound SDP returned OPTIMAL_INACCURATE"):
-        channel_relative_entropy(
-            depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2
-        )
+        channel_relative_entropy(depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2)
 
 
 def test_warns_on_optimal_inaccurate_upper(monkeypatch):
@@ -329,9 +317,7 @@ class FakeProblem:
         def __init__(self, objective, constraints):
             self.value = 1.0
             FakeProblem.created += 1
-            self.status = (
-                cvx.OPTIMAL if FakeProblem.created == 1 else cvx.OPTIMAL_INACCURATE
-            )
+            self.status = cvx.OPTIMAL if FakeProblem.created == 1 else cvx.OPTIMAL_INACCURATE
 
         def solve(self, **kwargs):
             pass
@@ -340,9 +326,7 @@ def solve(self, **kwargs):
     monkeypatch.setattr(_CHANNEL_RELATIVE_ENTROPY_MOD.cvx, "Problem", FakeProblem)
 
     with pytest.warns(UserWarning, match="Upper-bound SDP returned OPTIMAL_INACCURATE"):
-        channel_relative_entropy(
-            depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2
-        )
+        channel_relative_entropy(depolarizing(2, 0.2), depolarizing(2, 0.4), in_dim=2, epsilon_dec=0.2)
 
 
 @pytest.mark.slow
@@ -363,11 +347,7 @@ def test_channel_relative_entropy_paper_example(param_p: float, expected_mean: f
     # N_deph(rho) = 0.4 rho + 0.6 sigma_z rho sigma_z
     # M_dep(rho) = (1 - 3p/4) rho + p/4 (X rho X + Y rho Y + Z rho Z)
     channel_1 = _dense(pauli_channel(np.array([0.4, 0.0, 0.0, 0.6])))
-    channel_2 = _dense(
-        pauli_channel(
-            np.array([1 - 3 * param_p / 4, param_p / 4, param_p / 4, param_p / 4])
-        )
-    )
+    channel_2 = _dense(pauli_channel(np.array([1 - 3 * param_p / 4, param_p / 4, param_p / 4, param_p / 4])))
 
     lower, upper = channel_relative_entropy(channel_1, channel_2, in_dim=2, mean=False)
     avg = (lower + upper) / 2

toqito/channels/bitflip.py

@@ -77,8 +77,7 @@ def bitflip(
         raise ValueError("Input matrix must be 2x2 for the bitflip channel.")
 
     warnings.warn(
-        "Passing `input_mat` to `bitflip` is deprecated; "
-        "use `apply_channel(input_mat, bitflip(...))` instead.",
+        "Passing `input_mat` to `bitflip` is deprecated; use `apply_channel(input_mat, bitflip(...))` instead.",
         DeprecationWarning,
         stacklevel=2,
     )

toqito/cones/integral_relative_entropy.py

@@ -23,15 +23,11 @@ def _sandwich_parameters(rho: np.ndarray, sigma: np.ndarray) -> tuple[float, flo
         w_xy = _generalized_eigenvalues(rho, sigma)
         w_yx = _generalized_eigenvalues(sigma, rho)
     except LinAlgError as exc:
-        raise ValueError(
-            "Failed to compute sandwich parameters from generalized eigenvalues."
-        ) from exc
+        raise ValueError("Failed to compute sandwich parameters from generalized eigenvalues.") from exc
     finite_xy = w_xy[np.isfinite(w_xy)]
     finite_yx = w_yx[np.isfinite(w_yx)]
     if finite_xy.size == 0 or finite_yx.size == 0:
-        raise ValueError(
-            "Failed to compute sandwich parameters from generalized eigenvalues."
-        )
+        raise ValueError("Failed to compute sandwich parameters from generalized eigenvalues.")
     lam = float(np.max(finite_xy))
     mu = float(np.min(finite_yx))
     return mu, lam

toqito/cones/lieb_ando.py

@@ -3,7 +3,6 @@
 # Adapted from CVXQUAD (https://github.com/hfawzi/cvxquad), BSD-2-Clause.
 # Original implementation by Fawzi, Saunderson, et al.
 
-
 import cvxpy
 import numpy as np
 from scipy.linalg import fractional_matrix_power
@@ -72,9 +71,7 @@ def lieb_ando(
     _require_square_2d(mat_b, "mat_b")
     _require_2d(mat_k, "mat_k")
     if mat_k.shape[0] != mat_a.shape[0] or mat_k.shape[1] != mat_b.shape[1]:
-        raise ValueError(
-            "mat_k must have the same number of rows as mat_a and the same number of columns as mat_b."
-        )
+        raise ValueError("mat_k must have the same number of rows as mat_a and the same number of columns as mat_b.")
 
     if isinstance(mat_a, np.ndarray) and isinstance(mat_b, np.ndarray):
         if not is_positive_semidefinite(mat_a) or not is_positive_semidefinite(mat_b):
@@ -83,36 +80,26 @@ def lieb_ando(
         b_raised = fractional_matrix_power(mat_b, t)
         return float(np.real(np.trace(mat_k.conj().T @ a_raised @ mat_k @ b_raised)))
     elif isinstance(mat_a, np.ndarray):
-        if not is_positive_semidefinite(mat_a) or not is_positive_semidefinite(
-            mat_b.value
-        ):
+        if not is_positive_semidefinite(mat_a) or not is_positive_semidefinite(mat_b.value):
             raise ValueError("mat_a and mat_b must be positive semidefinite.")
         mat_kak = mat_k.conj().T @ fractional_matrix_power(mat_a, 1 - t) @ mat_k
         mat_kak = (mat_kak + mat_kak.conj().T) / 2
         return trace_matrix_power(mat_b, t, mat_kak)
     elif isinstance(mat_b, np.ndarray):
-        if not is_positive_semidefinite(mat_a.value) or not is_positive_semidefinite(
-            mat_b
-        ):
+        if not is_positive_semidefinite(mat_a.value) or not is_positive_semidefinite(mat_b):
             raise ValueError("mat_a and mat_b must be positive semidefinite.")
         mat_kkb = mat_k @ fractional_matrix_power(mat_b, t) @ mat_k.conj().T
         mat_kkb = (mat_kkb + mat_kkb.conj().T) / 2
         return trace_matrix_power(mat_a, 1 - t, mat_kkb)
     else:
         if not mat_a.is_affine() or not mat_b.is_affine():
             raise ValueError("mat_a and mat_b must be affine expressions.")
-        if not is_positive_semidefinite(mat_a.value) or not is_positive_semidefinite(
-            mat_b.value
-        ):
+        if not is_positive_semidefinite(mat_a.value) or not is_positive_semidefinite(mat_b.value):
             raise ValueError("mat_a and mat_b must be positive semidefinite.")
 
         n = mat_a.shape[0]
         m = mat_b.shape[0]
-        is_cplx = (
-            np.any(np.imag(mat_a.value) != 0)
-            or np.any(np.imag(mat_b.value) != 0)
-            or np.any(np.imag(mat_k) != 0)
-        )
+        is_cplx = np.any(np.imag(mat_a.value) != 0) or np.any(np.imag(mat_b.value) != 0) or np.any(np.imag(mat_k) != 0)
         Kvec = np.reshape(mat_k.T, (n * m, 1), order="F")
         KvKv = Kvec @ Kvec.conj().T
         KvKv = (KvKv + KvKv.conj().T) / 2
@@ -127,18 +114,14 @@ def lieb_ando(
         mat_a_kron = cvxpy.kron(mat_a, np.eye(m))
         mat_b_kron = cvxpy.kron(np.eye(n), cvxpy.conj(mat_b))
         if t >= 0 and t <= 1:
-            cons = geometric_mean_hypo_cone(
-                mat_a_kron, mat_b_kron, T, t, fullhyp=False, hermitian=is_cplx
-            )
+            cons = geometric_mean_hypo_cone(mat_a_kron, mat_b_kron, T, t, fullhyp=False, hermitian=is_cplx)
             problem = cvxpy.Problem(cvxpy.Maximize(obj), cons)
             result = problem.solve()
             if problem.status not in (cvxpy.OPTIMAL, cvxpy.OPTIMAL_INACCURATE):
                 raise ValueError(f"The SDP did not solve successfully (status: {problem.status}).")
             return result
         elif (t >= -1 and t <= 0) or (t >= 1 and t <= 2):
-            cons = geometric_mean_epi_cone(
-                mat_a_kron, mat_b_kron, T, t, hermitian=is_cplx
-            )
+            cons = geometric_mean_epi_cone(mat_a_kron, mat_b_kron, T, t, hermitian=is_cplx)
             problem = cvxpy.Problem(cvxpy.Minimize(obj), cons)
             result = problem.solve()
             if problem.status not in (cvxpy.OPTIMAL, cvxpy.OPTIMAL_INACCURATE):

toqito/cones/ln_quantum_entropy.py

@@ -14,9 +14,7 @@
 from toqito.matrix_props import is_positive_semidefinite
 
 
-def ln_quantum_entropy(
-    mat_x: np.ndarray | cvxpy.Expression, m: int = 3, k: int = 3, apx: int = 0
-) -> float:
+def ln_quantum_entropy(mat_x: np.ndarray | cvxpy.Expression, m: int = 3, k: int = 3, apx: int = 0) -> float:
     r"""Compute the quantum entropy \(-\operatorname{tr}(X \log X)\) for PSD \(X\).
 
     Note that this function uses the natural logarithm (base e) and not the base-2 logarithm.
@@ -68,9 +66,7 @@ def ln_quantum_entropy(
     if not mat_x.is_affine():
         raise ValueError("mat_x must be an affine CVXPY expression.")
     if mat_x.value is None:
-        raise ValueError(
-            "Affine mat_x has no numeric initial value; set `.value` for PSD checks."
-        )
+        raise ValueError("Affine mat_x has no numeric initial value; set `.value` for PSD checks.")
     if not is_positive_semidefinite(mat_x.value):
         raise ValueError("mat_x must be positive semidefinite at the initial value.")