[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

dev-scripts/quadratic_constraints_remaining_tasks.md

@@ -46,16 +46,19 @@ def Qc(self) -> list[scipy.sparse.csc_matrix]:
     # Each quadratic constraint has its own Q matrix
     pass
 
+
 @property
 def qc_linear(self) -> scipy.sparse.csc_matrix:
     """Return linear coefficients for quadratic constraints."""
     pass
 
+
 @property
 def qc_sense(self) -> np.ndarray:
     """Return sense array for quadratic constraints."""
     pass
 
+
 @property
 def qc_rhs(self) -> np.ndarray:
     """Return RHS values for quadratic constraints."""
@@ -109,10 +112,7 @@ Example API:
 ```python
 # Should work with coordinates
 m.add_quadratic_constraints(
-    x * x + y * y,  # where x, y have dims=['time', 'node']
-    "<=",
-    100,
-    name="qc"
+    x * x + y * y, "<=", 100, name="qc"  # where x, y have dims=['time', 'node']
 )
 ```
 
@@ -124,6 +124,7 @@ Add methods to `QuadraticConstraint`:
 def modify_rhs(self, new_rhs: ConstantLike) -> None:
     """Modify the right-hand side of the constraint."""
 
+
 def modify_coeffs(self, new_coeffs: xr.DataArray) -> None:
     """Modify coefficients of the constraint."""
 ```

dev-scripts/quadratic_constraints_status.md

@@ -26,25 +26,22 @@ import linopy
 m = linopy.Model()
 
 # Variables
-x = m.add_variables(lower=0, name='x')
-y = m.add_variables(lower=0, name='y')
+x = m.add_variables(lower=0, name="x")
+y = m.add_variables(lower=0, name="y")
 
 # Linear constraint (existing)
-m.add_constraints(x + y <= 10, name='budget')
+m.add_constraints(x + y <= 10, name="budget")
 
 # Quadratic constraint (NEW!)
 m.add_quadratic_constraints(
-    x*x + 2*x*y + y*y + 3*x + 4*y,
-    "<=",
-    100,
-    name='quadratic_budget'
+    x * x + 2 * x * y + y * y + 3 * x + 4 * y, "<=", 100, name="quadratic_budget"
 )
 
 # Objective
-m.add_objective(x + 2*y)
+m.add_objective(x + 2 * y)
 
 # Solve (with Gurobi, MOSEK, CPLEX, etc.)
-m.solve(solver_name='gurobi')
+m.solve(solver_name="gurobi")
 ```
 
 ## What Was Implemented

examples/quadratic-constraints.ipynb

@@ -24,8 +24,9 @@
    },
    "outputs": [],
    "source": [
-    "import linopy\n",
-    "import numpy as np"
+    "import numpy as np\n",
+    "\n",
+    "import linopy"
    ]
   },
   {
@@ -300,7 +301,12 @@
     "y = m2.add_variables(lower=0, coords=[range(3)], name=\"y\")\n",
     "\n",
     "# This creates 3 quadratic constraints, one for each coordinate\n",
-    "m2.add_quadratic_constraints(x * x * np.array([1, 1.1, 1.2]) + y * y, \"<=\", np.array([20, 25, 30]), name=\"circles\")"
+    "m2.add_quadratic_constraints(\n",
+    "    x * x * np.array([1, 1.1, 1.2]) + y * y,\n",
+    "    \"<=\",\n",
+    "    np.array([20, 25, 30]),\n",
+    "    name=\"circles\",\n",
+    ")"
    ]
   },
   {

linopy/io.py

@@ -823,8 +823,9 @@ def to_mosek(
                 # MOSEK uses 0.5 * x'Qx convention, and our Q matrix is already
                 # built with doubled diagonal terms for this convention.
                 # So we pass Q directly without dividing.
-                task.putqconk(con_idx, list(Q_lower.row), list(Q_lower.col),
-                              list(Q_lower.data))
+                task.putqconk(
+                    con_idx, list(Q_lower.row), list(Q_lower.col), list(Q_lower.data)
+                )
 
     return task
 

linopy/matrices.py

@@ -12,7 +12,6 @@
 
 import numpy as np
 import pandas as pd
-import scipy.sparse
 from numpy import ndarray
 from pandas.core.indexes.base import Index
 from pandas.core.series import Series
@@ -321,9 +320,7 @@ def Qc(self) -> list[csc_matrix]:
                     cols.extend([j, i])
                     data.extend([coeff, coeff])
 
-            Q = csc_matrix(
-                (data, (rows, cols)), shape=(n_vars, n_vars)
-            )
+            Q = csc_matrix((data, (rows, cols)), shape=(n_vars, n_vars))
             matrices.append(Q)
 
         return matrices
@@ -386,6 +383,4 @@ def qc_linear(self) -> csc_matrix | None:
             "between flat_qcons and the global variable/constraint indexing."
         )
 
-        return csc_matrix(
-            (data, (rows, cols)), shape=(n_cons, n_vars)
-        )
+        return csc_matrix((data, (rows, cols)), shape=(n_cons, n_vars))

linopy/solvers.py

@@ -1200,9 +1200,7 @@ def get_solver_solution() -> Solution:
             try:
                 qcs = m.getQConstrs()
                 if qcs:
-                    qc_dual = pd.Series(
-                        {qc.QCName: qc.QCPi for qc in qcs}, dtype=float
-                    )
+                    qc_dual = pd.Series({qc.QCName: qc.QCPi for qc in qcs}, dtype=float)
             except (AttributeError, gurobipy.GurobiError):
                 # QCPi not available (non-convex or QCPDual=0)
                 pass

test/test_quadratic_constraint.py

@@ -325,7 +325,9 @@ def test_highs_rejects_quadratic_constraints(
         from linopy.solvers import quadratic_constraint_solvers
 
         if "highs" not in quadratic_constraint_solvers:
-            with pytest.raises(ValueError, match="does not support quadratic constraints"):
+            with pytest.raises(
+                ValueError, match="does not support quadratic constraints"
+            ):
                 m.solve(solver_name="highs")
 
     def test_highs_accepts_quadratic_objective(
@@ -434,9 +436,7 @@ def test_empty_container_repr(self) -> None:
 class TestMatrixAccessor:
     """Tests for matrix accessor with quadratic constraints."""
 
-    def test_qclabels(
-        self, m: Model, x: linopy.Variable, y: linopy.Variable
-    ) -> None:
+    def test_qclabels(self, m: Model, x: linopy.Variable, y: linopy.Variable) -> None:
         """Test qclabels property."""
         m.add_objective(x + y)
         m.add_quadratic_constraints(x * x, "<=", 25, name="qc1")
@@ -447,9 +447,7 @@ def test_qclabels(
         assert labels[0] == 0
         assert labels[1] == 1
 
-    def test_qc_sense(
-        self, m: Model, x: linopy.Variable, y: linopy.Variable
-    ) -> None:
+    def test_qc_sense(self, m: Model, x: linopy.Variable, y: linopy.Variable) -> None:
         """Test qc_sense property."""
         m.add_objective(x + y)
         m.add_quadratic_constraints(x * x, "<=", 25, name="qc1")
@@ -460,9 +458,7 @@ def test_qc_sense(
         assert senses[0] == "<="
         assert senses[1] == ">="
 
-    def test_qc_rhs(
-        self, m: Model, x: linopy.Variable, y: linopy.Variable
-    ) -> None:
+    def test_qc_rhs(self, m: Model, x: linopy.Variable, y: linopy.Variable) -> None:
         """Test qc_rhs property."""
         m.add_objective(x + y)
         m.add_quadratic_constraints(x * x, "<=", 25, name="qc1")
@@ -504,9 +500,7 @@ def test_Qc_cross_terms(
         assert Q[0, 0] == 0.0  # No x^2 term
         assert Q[1, 1] == 0.0  # No y^2 term
 
-    def test_qc_linear(
-        self, m: Model, x: linopy.Variable, y: linopy.Variable
-    ) -> None:
+    def test_qc_linear(self, m: Model, x: linopy.Variable, y: linopy.Variable) -> None:
         """Test qc_linear property."""
         m.add_objective(x + y)
         m.add_quadratic_constraints(x * x + 3 * x + 4 * y, "<=", 25, name="mixed")