Merge remote-tracking branch 'upstream/master' into expr/notimplemented

Author: Zeroto521

CHANGELOG.md

@@ -2,10 +2,15 @@
 
 ## Unreleased
 ### Added
+- Added `getBase()` and `setBase()` methods to `LP` class for getting/setting basis status
+- Added `getMemUsed()`, `getMemTotal()`, and `getMemExternEstim()` methods
 ### Fixed
+- Removed `Py_INCREF`/`Py_DECREF` on `Model` in `catchEvent`/`dropEvent` that caused memory leak for imbalanced usage
+- Used `getIndex()` instead of `ptr()` for sorting nonlinear expression terms to avoid nondeterministic behavior 
 ### Changed
 - Return NotImplemented for `Expr` and `GenExpr` operators, if they can't handle input types in the calculation
 ### Removed
+- Removed outdated warning about Make build system incompatibility
 
 ## 6.1.0 - 2026.01.31
 ### Added

INSTALL.md

@@ -18,10 +18,6 @@ Suite](https://www.scipopt.org/). Please, make sure that your SCIP installation
 
 **Note that the latest PySCIPOpt version is usually only compatible with the latest major release of the SCIP Optimization Suite. See the table on the README.md page for details.**
 
-If you install SCIP yourself and are not using the installer packages, you need to [install the
-SCIP Optimization Suite using CMake](https://www.scipopt.org/doc/html/md_INSTALL.php#CMAKE).
-The Makefile system is not compatible with PySCIPOpt!
-
 If installing SCIP from source or using PyPI with a python and operating system that is not mentioned above, and SCIP is not installed in the global path,
 you need to specify the install location using the environment variable
 `SCIPOPTDIR`:

docs/build.rst

@@ -44,10 +44,6 @@ To download SCIP please either use the pre-built SCIP Optimization Suite availab
     * - 3.2
       - 1.0
 
-.. note:: If you install SCIP yourself and are not using the pre-built packages,
-  you need to install the SCIP Optimization Suite using CMake.
-  The Makefile system is not compatible with PySCIPOpt!
-
 Download Source Code
 ======================
 

src/pyscipopt/__init__.py

@@ -28,6 +28,7 @@
 from pyscipopt.scip      import LP as LP
 from pyscipopt.scip      import IISfinder as IISfinder 
 from pyscipopt.scip      import PY_SCIP_LPPARAM as SCIP_LPPARAM
+from pyscipopt.scip      import PY_SCIP_BASESTAT as SCIP_BASESTAT
 from pyscipopt.scip      import readStatistics as readStatistics
 from pyscipopt.scip      import Expr as Expr
 from pyscipopt.scip      import MatrixExpr as MatrixExpr

src/pyscipopt/expr.pxi

@@ -89,7 +89,7 @@ cdef class Term:
     cdef Py_ssize_t hashval
 
     def __init__(self, *vartuple: Variable):
-        self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr()))
+        self.vartuple = tuple(sorted(vartuple, key=lambda v: v.getIndex()))
         self.ptrtuple = tuple(v.ptr() for v in self.vartuple)
         self.hashval = <Py_ssize_t>hash(self.ptrtuple)
 
@@ -119,7 +119,7 @@ cdef class Term:
         while i < n1 and j < n2:
             var1 = <Variable>PyTuple_GET_ITEM(self.vartuple, i)
             var2 = <Variable>PyTuple_GET_ITEM(other.vartuple, j)
-            if var1.ptr() <= var2.ptr():
+            if var1.getIndex() <= var2.getIndex():
                 vartuple[k] = var1
                 i += 1
             else:

src/pyscipopt/lp.pxi

@@ -531,6 +531,66 @@ cdef class LP:
 
         return binds
 
+    def getBase(self):
+        """Returns the basis status of columns and rows.
+
+        Status values are defined in SCIP_BASESTAT: LOWER, BASIC, UPPER, ZERO.
+
+        Returns
+        -------
+        tuple of (list of int, list of int)
+            Column basis statuses and row basis statuses.
+
+        """
+        cdef int ncols = self.ncols()
+        cdef int nrows = self.nrows()
+        cdef int* c_cstat = <int*> malloc(ncols * sizeof(int))
+        cdef int* c_rstat = <int*> malloc(nrows * sizeof(int))
+        cdef int i
+
+        PY_SCIP_CALL(SCIPlpiGetBase(self.lpi, c_cstat, c_rstat))
+
+        cstat = [c_cstat[i] for i in range(ncols)]
+        rstat = [c_rstat[i] for i in range(nrows)]
+
+        free(c_rstat)
+        free(c_cstat)
+
+        return cstat, rstat
+
+    def setBase(self, cstat, rstat):
+        """Sets the basis status of columns and rows.
+
+        Status values are defined in SCIP_BASESTAT: LOWER, BASIC, UPPER, ZERO.
+
+        Parameters
+        ----------
+        cstat : list of int
+            Column basis statuses (length must equal ncols).
+        rstat : list of int
+            Row basis statuses (length must equal nrows).
+
+        """
+        cdef int ncols = self.ncols()
+        cdef int nrows = self.nrows()
+        if len(cstat) != ncols:
+            raise ValueError(f"cstat has length {len(cstat)}, expected {ncols}")
+        if len(rstat) != nrows:
+            raise ValueError(f"rstat has length {len(rstat)}, expected {nrows}")
+        cdef int* c_cstat = <int*> malloc(ncols * sizeof(int))
+        cdef int* c_rstat = <int*> malloc(nrows * sizeof(int))
+        cdef int i
+
+        for i in range(ncols):
+            c_cstat[i] = cstat[i]
+        for i in range(nrows):
+            c_rstat[i] = rstat[i]
+
+        PY_SCIP_CALL(SCIPlpiSetBase(self.lpi, c_cstat, c_rstat))
+
+        free(c_rstat)
+        free(c_cstat)
+
     # Parameter Methods
 
     def setIntParam(self, param, value):

src/pyscipopt/scip.pxd

@@ -1532,6 +1532,8 @@ cdef extern from "scip/scip.h":
     SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI* lpi, SCIP_Real* ray)
     SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI* lpi, SCIP_Real* dualfarkas)
     SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI* lpi, int* bind)
+    SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI* lpi, int* cstat, int* rstat)
+    SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI* lpi, const int* cstat, const int* rstat)
     SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI* lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real* quality)
     SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI* lpi, SCIP_LPPARAM type, int* ival)
     SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI* lpi, SCIP_LPPARAM type, SCIP_Real* dval)
@@ -1822,6 +1824,11 @@ cdef extern from "blockmemshell/memory.h":
     void BMScheckEmptyMemory()
     long long BMSgetMemoryUsed()
 
+cdef extern from "scip/scip_mem.h":
+    SCIP_Longint SCIPgetMemUsed(SCIP* scip)
+    SCIP_Longint SCIPgetMemTotal(SCIP* scip)
+    SCIP_Longint SCIPgetMemExternEstim(SCIP* scip)
+
 cdef extern from "scip/scip_expr.h":
     SCIP_RETCODE SCIPcreateExpr(SCIP* scip,
                                 SCIP_EXPR** expr,

src/pyscipopt/scip.pxi

@@ -118,6 +118,12 @@ cdef class PY_SCIP_LPPARAM:
     POLISHING      = SCIP_LPPAR_POLISHING
     REFACTOR       = SCIP_LPPAR_REFACTOR
 
+cdef class PY_SCIP_BASESTAT:
+    LOWER = SCIP_BASESTAT_LOWER
+    BASIC = SCIP_BASESTAT_BASIC
+    UPPER = SCIP_BASESTAT_UPPER
+    ZERO  = SCIP_BASESTAT_ZERO
+
 cdef class PY_SCIP_PARAMEMPHASIS:
     DEFAULT      = SCIP_PARAMEMPHASIS_DEFAULT
     CPSOLVER     = SCIP_PARAMEMPHASIS_CPSOLVER
@@ -11267,7 +11273,6 @@ cdef class Model:
         else:
             raise Warning("event handler not found")
 
-        Py_INCREF(self)
         PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL))
 
     def dropEvent(self, eventtype, Eventhdlr eventhdlr):
@@ -11287,7 +11292,6 @@ cdef class Model:
         else:
             raise Warning("event handler not found")
 
-        Py_DECREF(self)
         PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1))
 
     def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr):
@@ -11466,6 +11470,41 @@ cdef class Model:
 
         locale.setlocale(locale.LC_NUMERIC,user_locale)
 
+    def getMemUsed(self):
+        """
+        Gets the total number of bytes used in block and buffer memory.
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPgetMemUsed(self._scip)
+
+    def getMemTotal(self):
+        """
+        Gets the total number of bytes in block and buffer memory
+        (i.e., total allocated, including unused).
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPgetMemTotal(self._scip)
+
+    def getMemExternEstim(self):
+        """
+        Gets the estimated number of bytes used by external software,
+        e.g., the LP solver.
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPgetMemExternEstim(self._scip)
+
     def getNLPs(self):
         """
         Gets total number of LPs solved so far.

src/pyscipopt/scip.pyi

@@ -466,6 +466,7 @@ class LP:
     def delCols(self, firstcol: Incomplete, lastcol: Incomplete) -> Incomplete: ...
     def delRows(self, firstrow: Incomplete, lastrow: Incomplete) -> Incomplete: ...
     def getActivity(self) -> Incomplete: ...
+    def getBase(self) -> Incomplete: ...
     def getBasisInds(self) -> Incomplete: ...
     def getBounds(
         self, firstcol: Incomplete = ..., lastcol: Incomplete = ...
@@ -490,6 +491,7 @@ class LP:
     def ncols(self) -> Incomplete: ...
     def nrows(self) -> Incomplete: ...
     def readLP(self, filename: Incomplete) -> Incomplete: ...
+    def setBase(self, cstat: Incomplete, rstat: Incomplete) -> Incomplete: ...
     def setIntParam(self, param: Incomplete, value: Incomplete) -> Incomplete: ...
     def setRealParam(self, param: Incomplete, value: Incomplete) -> Incomplete: ...
     def solve(self, dual: Incomplete = ...) -> Incomplete: ...
@@ -1152,6 +1154,9 @@ class Model:
     def getNLPIterations(self) -> Incomplete: ...
     def getNLPRows(self) -> Incomplete: ...
     def getNLPs(self) -> Incomplete: ...
+    def getMemUsed(self) -> int: ...
+    def getMemTotal(self) -> int: ...
+    def getMemExternEstim(self) -> int: ...
     def getNLeaves(self) -> Incomplete: ...
     def getNLimSolsFound(self) -> Incomplete: ...
     def getNNlRows(self) -> Incomplete: ...
@@ -1797,6 +1802,13 @@ class PY_SCIP_LOCKTYPE:
     MODEL: ClassVar[int] = ...
     def __init__(self) -> None: ...
 
+class PY_SCIP_BASESTAT:
+    LOWER: ClassVar[int] = ...
+    BASIC: ClassVar[int] = ...
+    UPPER: ClassVar[int] = ...
+    ZERO: ClassVar[int] = ...
+    def __init__(self) -> None: ...
+
 class PY_SCIP_LPPARAM:
     BARRIERCONVTOL: ClassVar[int] = ...
     CONDITIONLIMIT: ClassVar[int] = ...

tests/test_event.py

@@ -1,4 +1,4 @@
-import pytest, random
+import pytest, weakref, gc, random
 
 from pyscipopt import Model, Eventhdlr, SCIP_RESULT, SCIP_EVENTTYPE, SCIP_PARAMSETTING, quicksum
 
@@ -189,4 +189,42 @@ def eventexec(self, event):
     m.includeEventhdlr(ev, "var_event", "event handler for var events")
 
     with pytest.raises(Exception):
-        m.optimize()
+        m.optimize()
+
+def test_catchEvent_does_not_leak_model():
+    """catchEvent should not artificially increment the Model's reference count.
+
+    Previously, catchEvent called Py_INCREF(self) on the Model, and dropEvent
+    called Py_DECREF(self). In practice these calls are often unbalanced — event
+    handlers commonly catch events without a matching drop (e.g. calling
+    catchEvent in eventinit but omitting dropEvent in eventexit). Each unmatched
+    catchEvent permanently inflated the Model's refcount, preventing garbage
+    collection.
+    """
+
+    class SimpleEvent(Eventhdlr):
+        def eventinit(self):
+            self.model.catchEvent(SCIP_EVENTTYPE.NODEFOCUSED, self)
+
+        def eventexit(self):
+            pass  # intentionally no dropEvent, which is bad practice
+
+        def eventexec(self, event):
+            pass
+
+    m = Model()
+    m.hideOutput()
+    ev = SimpleEvent()
+    m.includeEventhdlr(ev, "simple", "test event handler")
+    m.addVar("x", obj=1, vtype="I")
+    m.optimize()
+
+    ref = weakref.ref(m)
+
+    del ev
+    gc.collect()
+    assert ref() is not None, "Model was garbage collected — event handler absorbed a reference"
+
+    del m
+    gc.collect()
+    assert ref() is None, "Model was not garbage collected — catchEvent likely leaked a reference"