Merge branch 'master' into model-annotations-1

Author: jonathanberthias

.github/workflows/stubs.yml

@@ -78,6 +78,7 @@ jobs:
       - name: Install Ruff
         uses: astral-sh/ruff-action@v3
         with:
+          version: "0.14.11"
           args: "--version"
 
       - name: Lint type stubs

CHANGELOG.md

@@ -4,8 +4,13 @@
 ### Added
 ### Fixed
 ### Changed
+- Speed up `Expr.__add__` and `Expr.__iadd__` via the C-level API
 ### Removed
 
+## 6.2.1 - 2026.05.16
+### Fixed
+- Fixed `AttributeError` when comparing NumPy scalars (e.g. `np.float64`) or 0-dim NumPy arrays against `Expr`/`Variable` on NumPy 2.x (#1218)
+
 ## 6.2.0 - 2026.05.11
 ### Added
 - Added `solveProbingLPWithPricing()` and test

setup.py

@@ -133,7 +133,7 @@
 
 setup(
     name="PySCIPOpt",
-    version="6.2.0",
+    version="6.2.1",
     description="Python interface and modeling environment for SCIP",
     long_description=long_description,
     long_description_content_type="text/markdown",

src/pyscipopt/_version.py

@@ -1 +1 @@
-__version__: str = '6.2.0'
+__version__: str = '6.2.1'

src/pyscipopt/expr.pxi

@@ -55,6 +55,7 @@ from cpython.object cimport Py_LE, Py_EQ, Py_GE, Py_TYPE
 from cpython.ref cimport PyObject
 from cpython.tuple cimport PyTuple_GET_ITEM
 
+cimport numpy as cnp
 from pyscipopt.scip cimport Variable, Solution
 
 
@@ -203,16 +204,25 @@ cdef class ExprLike:
             )
 
         if method == "__call__":
-            if arrays := [a for a in args if isinstance(a, np.ndarray)]:
+            if arrays := [a for a in args if isinstance(a, np.ndarray) and a.ndim >= 1]:
                 if any(a.dtype.kind not in "fiub" for a in arrays):
                     return NotImplemented
                 # If the np.ndarray is of numeric type, all arguments are converted to
                 # MatrixExpr or MatrixGenExpr and then the ufunc is applied.
                 return ufunc(*[_ensure_matrix(a) for a in args], **kwargs)
 
-            # Convert `np.generic` to native Python types to stop __array_ufunc__
-            # recursion from `np.generic + MatrixExpr`.
-            args = [a.item() if isinstance(a, np.generic) else a for a in args]
+            # Convert `np.generic` and 0-dim `np.ndarray` to native Python types to stop
+            # __array_ufunc__ recursion from `np.generic + MatrixExpr/Expr` or
+            # `0-dim np.ndarray + MatrixExpr/Expr`.
+            args = [
+                a.item()
+                if (
+                    isinstance(a, np.generic)
+                    or (isinstance(a, np.ndarray) and a.ndim == 0)
+                )
+                else a
+                for a in args
+            ]
 
             if ufunc is np.add:
                 return args[0] + args[1]
@@ -291,29 +301,22 @@ cdef class Expr(ExprLike):
         if not _is_expr_compatible(other):
             return NotImplemented
 
-        left = self
-        right = other
-        terms = left.terms.copy()
+        if _is_number(other):
+            terms = self.terms.copy()
+            terms[CONST] = terms.get(CONST, 0.0) + <double>other
+            return Expr(terms)
 
-        if isinstance(right, Expr):
-            # merge the terms by component-wise addition
-            for v,c in right.terms.items():
-                terms[v] = terms.get(v, 0.0) + c
-        elif _is_number(right):
-            c = float(right)
-            terms[CONST] = terms.get(CONST, 0.0) + c
-        return Expr(terms)
+        return Expr(_to_dict(self, other, copy=True))
 
     def __iadd__(self, other):
         if not _is_expr_compatible(other):
             return NotImplemented
 
-        if isinstance(other, Expr):
-            for v,c in other.terms.items():
-                self.terms[v] = self.terms.get(v, 0.0) + c
-        elif _is_number(other):
-            c = float(other)
-            self.terms[CONST] = self.terms.get(CONST, 0.0) + c
+        if _is_number(other):
+            self.terms[CONST] = self.terms.get(CONST, 0.0) + <double>other
+        else:
+            _to_dict(self, other, copy=False)
+
         return self
 
     def __mul__(self, other):
@@ -1010,6 +1013,26 @@ cdef inline object _ensure_matrix(object arg):
     matrix = MatrixExpr if isinstance(arg, Expr) else MatrixGenExpr
     return np.array(arg, dtype=object).view(matrix)
 
+cdef dict _to_dict(Expr expr, Expr other, bool copy = True):
+    cdef dict children = expr.terms.copy() if copy else expr.terms
+    cdef Py_ssize_t pos = <Py_ssize_t>0
+    cdef PyObject* k_ptr = NULL
+    cdef PyObject* v_ptr = NULL
+    cdef PyObject* old_v_ptr = NULL
+    cdef double other_v
+    cdef object k_obj
+
+    while PyDict_Next(other.terms, &pos, &k_ptr, &v_ptr):
+        other_v = <double>(<object>v_ptr)
+        k_obj = <object>k_ptr
+        old_v_ptr = PyDict_GetItem(children, k_obj)
+        if old_v_ptr != NULL:
+            children[k_obj] = <double>(<object>old_v_ptr) + other_v
+        else:
+            children[k_obj] = other_v
+
+    return children
+
 
 def expr_to_nodes(expr):
     '''transforms tree to an array of nodes. each node is an operator and the position of the 

tests/test_expr.py

@@ -328,6 +328,34 @@ def test_binary_ufunc(model):
     assert str(np.greater_equal(a, x)) == "[ExprCons(Expr({Term(x): 1.0}), None, 2.0)]"
 
 
+def test_np_generic_vs_expr():
+    # test #1218
+    m = Model()
+    x = m.addVar(name="x")
+    value = np.float64(5.0)
+
+    # test <=, np.generic vs Variable
+    assert str(x <= -value) == "ExprCons(Expr({Term(x): 1.0}), None, -5.0)"
+    assert str(x <= value) == "ExprCons(Expr({Term(x): 1.0}), None, 5.0)"
+    assert str(-value <= x) == "ExprCons(Expr({Term(x): 1.0}), -5.0, None)"
+    assert str(value <= x) == "ExprCons(Expr({Term(x): 1.0}), 5.0, None)"
+    assert str(np.int64(5) <= x) == "ExprCons(Expr({Term(x): 1.0}), 5.0, None)"
+
+    # test >=, np.generic vs Variable
+    assert str(value >= x) == "ExprCons(Expr({Term(x): 1.0}), None, 5.0)"
+    assert str(-value >= x) == "ExprCons(Expr({Term(x): 1.0}), None, -5.0)"
+
+    # test ==, np.generic vs Variable
+    assert str(value == x) == "ExprCons(Expr({Term(x): 1.0}), 5.0, 5.0)"
+
+    # test <=, 0-ndim int array vs Variable
+    assert str(np.array(5) <= x) == "ExprCons(Expr({Term(x): 1.0}), 5.0, None)"
+
+    # test <=, 0-ndim Variable array vs Variable
+    with pytest.raises(TypeError):
+        1 <= np.array(x)
+
+
 def test_mul():
     m = Model()
     x = m.addVar(name="x")
@@ -494,3 +522,28 @@ def test_term_eq():
     assert t3 != t4  # same length, but different term
     assert t1 != t3  # different length
     assert t1 != "not a term"  # different type
+
+
+def test_Expr_add_Expr():
+    m = Model()
+    x = m.addVar(name="x")
+    y = m.addVar(name="y")
+
+    e1 = -x + 1
+    e2 = y - 1
+    e3 = e1 + e2
+    assert str(e1) == "Expr({Term(x): -1.0, Term(): 1.0})"
+    assert str(e2) == "Expr({Term(y): 1.0, Term(): -1.0})"
+    assert str(e3) == "Expr({Term(x): -1.0, Term(): 0.0, Term(y): 1.0})"
+
+
+def test_Expr_iadd_Expr():
+    m = Model()
+    x = m.addVar(name="x")
+    y = m.addVar(name="y")
+
+    e1 = -x + 1
+    e2 = y - 1
+    e1 += e2
+    assert str(e1) == "Expr({Term(x): -1.0, Term(): 0.0, Term(y): 1.0})"
+    assert str(e2) == "Expr({Term(y): 1.0, Term(): -1.0})"