diff --git a/CHANGELOG.md b/CHANGELOG.md index f6c046a93..b2beeb90e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ - Added more type annotations and deprecation markers to the stubs. - Added tests for `getObjVal()` and `getVal()` - Added `addConsLinear()` to add linear constraints from variables and coefficients without building an expression +- Added `SCIP_BOUNDTYPE` and `SCIP_BOUNDCHGTYPE` enums ### Fixed - Fixed `MatrixVariable.varMayRound()` rounding direction - Fixed `lotsizing_lazy` example: lock the handler's variables in `conslock` so presolve cannot aggregate them away (#1252) @@ -15,6 +16,7 @@ - Fixed incorrect `getObjVal()` result when called before `getBestSol()` (e.g., in event handlers). - Fixed `getDualsolKnapsack()` and `getDualfarkasKnapsack()` returning 0 for original constraints, and the handler check in `getVarsAnd()` that could never fail ### Changed +- Replaced SCIP constant classes with `IntEnum` and `IntFlag`, including enum return values and type annotations (#1286). - Replaced `format()` with f-strings in examples - Refactor general expression conversion into per-class `to_scip_expr` recursion - Made expression fields read-only to prevent accidental runtime modification diff --git a/src/pyscipopt/__init__.py b/src/pyscipopt/__init__.py index 170d86e42..91c5d873f 100644 --- a/src/pyscipopt/__init__.py +++ b/src/pyscipopt/__init__.py @@ -55,6 +55,8 @@ from pyscipopt.scip import PY_SCIP_LPSOLSTAT as SCIP_LPSOLSTAT from pyscipopt.scip import PY_SCIP_BRANCHDIR as SCIP_BRANCHDIR from pyscipopt.scip import PY_SCIP_BENDERSENFOTYPE as SCIP_BENDERSENFOTYPE +from pyscipopt.scip import PY_SCIP_BOUNDTYPE as SCIP_BOUNDTYPE +from pyscipopt.scip import PY_SCIP_BOUNDCHGTYPE as SCIP_BOUNDCHGTYPE from pyscipopt.scip import PY_SCIP_ROWORIGINTYPE as SCIP_ROWORIGINTYPE from pyscipopt.scip import PY_SCIP_SOLORIGIN as SCIP_SOLORIGIN from pyscipopt.scip import PY_SCIP_NODETYPE as SCIP_NODETYPE diff --git a/src/pyscipopt/benders.pxi b/src/pyscipopt/benders.pxi index 913f12584..2d0d77c23 100644 --- a/src/pyscipopt/benders.pxi +++ b/src/pyscipopt/benders.pxi @@ -135,7 +135,7 @@ cdef SCIP_RETCODE PyBendersPresubsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_ solution = None else: solution = Solution.create(scip, sol) - enfotype = type + enfotype = PY_SCIP_BENDERSENFOTYPE(type) result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) infeasible[0] = result_dict.get("infeasible", False) auxviol[0] = result_dict.get("auxviol", False) @@ -179,7 +179,7 @@ cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SO solution = None else: solution = Solution.create(scip, sol) - enfotype = type + enfotype = PY_SCIP_BENDERSENFOTYPE(type) mergecandidates = [] for i in range(nmergecands): mergecandidates.append(mergecands[i]) diff --git a/src/pyscipopt/benderscut.pxi b/src/pyscipopt/benderscut.pxi index 475dec16e..b880faf04 100644 --- a/src/pyscipopt/benderscut.pxi +++ b/src/pyscipopt/benderscut.pxi @@ -69,7 +69,7 @@ cdef SCIP_RETCODE PyBenderscutExec (SCIP* scip, SCIP_BENDERS* benders, SCIP_BEND solution = None else: solution = Solution.create(scip, sol) - enfotype = type + enfotype = PY_SCIP_BENDERSENFOTYPE(type) result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) result[0] = result_dict.get("result", result[0]) return SCIP_OKAY diff --git a/src/pyscipopt/conshdlr.pxi b/src/pyscipopt/conshdlr.pxi index 79ae972b0..245db97ce 100644 --- a/src/pyscipopt/conshdlr.pxi +++ b/src/pyscipopt/conshdlr.pxi @@ -327,7 +327,7 @@ cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** c constraints = [] for i in range(nconss): constraints.append(getPyCons(conss[i])) - result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) + result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, PY_SCIP_PROPTIMING(proptiming)) result[0] = result_dict.get("result", result[0]) return SCIP_OKAY @@ -353,8 +353,8 @@ cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** result_dict["nupgdconss"] = nupgdconss[0] result_dict["nchgcoefs"] = nchgcoefs[0] result_dict["nchgsides"] = nchgsides[0] - result_dict["result"] = result[0] - PyConshdlr.conspresol(constraints, nrounds, presoltiming, + result_dict["result"] = PY_SCIP_RESULT(result[0]) + PyConshdlr.conspresol(constraints, nrounds, PY_SCIP_PRESOLTIMING(presoltiming), nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) result[0] = result_dict["result"] @@ -379,10 +379,10 @@ cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: PyConshdlr = getPyConshdlr(conshdlr) if cons == NULL: - PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) + PyConshdlr.conslock(None, PY_SCIP_LOCKTYPE(locktype), nlockspos, nlocksneg) else: PyCons = getPyCons(cons) - PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg) + PyConshdlr.conslock(PyCons, PY_SCIP_LOCKTYPE(locktype), nlockspos, nlocksneg) return SCIP_OKAY cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: diff --git a/src/pyscipopt/heuristic.pxi b/src/pyscipopt/heuristic.pxi index da5efeccc..9756d508d 100644 --- a/src/pyscipopt/heuristic.pxi +++ b/src/pyscipopt/heuristic.pxi @@ -72,6 +72,6 @@ cdef SCIP_RETCODE PyHeurExec (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurt cdef SCIP_HEURDATA* heurdata heurdata = SCIPheurGetData(heur) PyHeur = heurdata - result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) + result_dict = PyHeur.heurexec(PY_SCIP_HEURTIMING(heurtiming), nodeinfeasible) result[0] = result_dict.get("result", result[0]) return SCIP_OKAY diff --git a/src/pyscipopt/lp.pxi b/src/pyscipopt/lp.pxi index a33961190..6ff4723fd 100644 --- a/src/pyscipopt/lp.pxi +++ b/src/pyscipopt/lp.pxi @@ -538,7 +538,7 @@ cdef class LP: Returns ------- - tuple of (list of int, list of int) + tuple of (list of SCIP_BASESTAT, list of SCIP_BASESTAT) Column basis statuses and row basis statuses. """ @@ -550,8 +550,8 @@ cdef class LP: 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)] + cstat = [PY_SCIP_BASESTAT(c_cstat[i]) for i in range(ncols)] + rstat = [PY_SCIP_BASESTAT(c_rstat[i]) for i in range(nrows)] free(c_rstat) free(c_cstat) diff --git a/src/pyscipopt/presol.pxi b/src/pyscipopt/presol.pxi index 7f4096d98..1c608ffe6 100644 --- a/src/pyscipopt/presol.pxi +++ b/src/pyscipopt/presol.pxi @@ -76,7 +76,7 @@ cdef SCIP_RETCODE PyPresolExec (SCIP* scip, SCIP_PRESOL* presol, int nrounds, SC cdef SCIP_PRESOLDATA* presoldata presoldata = SCIPpresolGetData(presol) PyPresol = presoldata - result_dict = PyPresol.presolexec(nrounds, presoltiming) + result_dict = PyPresol.presolexec(nrounds, PY_SCIP_PRESOLTIMING(presoltiming)) result[0] = result_dict.get("result", result[0]) nfixedvars[0] += result_dict.get("nnewfixedvars", 0) naggrvars[0] += result_dict.get("nnewaggrvars", 0) diff --git a/src/pyscipopt/propagator.pxi b/src/pyscipopt/propagator.pxi index 4601b6634..e09aa24ab 100644 --- a/src/pyscipopt/propagator.pxi +++ b/src/pyscipopt/propagator.pxi @@ -117,8 +117,8 @@ cdef SCIP_RETCODE PyPropPresol (SCIP* scip, SCIP_PROP* prop, int nrounds, SCIP_P result_dict["nupgdconss"] = nupgdconss[0] result_dict["nchgcoefs"] = nchgcoefs[0] result_dict["nchgsides"] = nchgsides[0] - result_dict["result"] = result[0] - PyProp.proppresol(nrounds, presoltiming, + result_dict["result"] = PY_SCIP_RESULT(result[0]) + PyProp.proppresol(nrounds, PY_SCIP_PRESOLTIMING(presoltiming), nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) result[0] = result_dict["result"] @@ -138,7 +138,7 @@ cdef SCIP_RETCODE PyPropExec (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING propt cdef SCIP_PROPDATA* propdata propdata = SCIPpropGetData(prop) PyProp = propdata - returnvalues = PyProp.propexec(proptiming) + returnvalues = PyProp.propexec(PY_SCIP_PROPTIMING(proptiming)) result_dict = returnvalues result[0] = result_dict.get("result", result[0]) return SCIP_OKAY @@ -154,7 +154,7 @@ cdef SCIP_RETCODE PyPropResProp (SCIP* scip, SCIP_PROP* prop, SCIP_VAR* infervar #TODO: parse bdchgidx? PyProp = propdata - returnvalues = PyProp.propresprop(confvar, inferinfo, boundtype, relaxedbd) + returnvalues = PyProp.propresprop(confvar, inferinfo, PY_SCIP_BOUNDTYPE(boundtype), relaxedbd) result_dict = returnvalues result[0] = result_dict.get("result", result[0]) return SCIP_OKAY diff --git a/src/pyscipopt/scip.pxi b/src/pyscipopt/scip.pxi index 841eed6c7..78837353c 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -18,10 +18,23 @@ from posix.stdio cimport fileno from collections.abc import Iterable from itertools import repeat from dataclasses import dataclass +from enum import Enum, Flag, IntEnum, IntFlag from typing import Union import numpy as np +class _ScipEnum(IntEnum): + __str__ = Enum.__str__ + + def __format__(self, spec): + return str(self) if not spec else int.__format__(self, spec) + +class _ScipFlag(IntFlag): + __str__ = Flag.__str__ + + def __format__(self, spec): + return str(self) if not spec else int.__format__(self, spec) + include "expr.pxi" include "lp.pxi" include "benders.pxi" @@ -71,7 +84,7 @@ cdef extern from "scip/config.h": # This is required to return SCIP_RESULT in the python code # In __init__.py this is imported as SCIP_RESULT to keep the # original naming scheme using capital letters -cdef class PY_SCIP_RESULT: +class PY_SCIP_RESULT(_ScipEnum): DIDNOTRUN = SCIP_DIDNOTRUN DELAYED = SCIP_DELAYED DIDNOTFIND = SCIP_DIDNOTFIND @@ -90,13 +103,13 @@ cdef class PY_SCIP_RESULT: SUSPENDED = SCIP_SUSPENDED SUCCESS = SCIP_SUCCESS -cdef class PY_SCIP_PARAMSETTING: +class PY_SCIP_PARAMSETTING(_ScipEnum): DEFAULT = SCIP_PARAMSETTING_DEFAULT AGGRESSIVE = SCIP_PARAMSETTING_AGGRESSIVE FAST = SCIP_PARAMSETTING_FAST OFF = SCIP_PARAMSETTING_OFF -cdef class PY_SCIP_LPPARAM: +class PY_SCIP_LPPARAM(_ScipEnum): FROMSCRATCH = SCIP_LPPAR_FROMSCRATCH FASTMIP = SCIP_LPPAR_FASTMIP SCALING = SCIP_LPPAR_SCALING @@ -118,13 +131,13 @@ cdef class PY_SCIP_LPPARAM: POLISHING = SCIP_LPPAR_POLISHING REFACTOR = SCIP_LPPAR_REFACTOR -cdef class PY_SCIP_BASESTAT: +class PY_SCIP_BASESTAT(_ScipEnum): LOWER = SCIP_BASESTAT_LOWER BASIC = SCIP_BASESTAT_BASIC UPPER = SCIP_BASESTAT_UPPER ZERO = SCIP_BASESTAT_ZERO -cdef class PY_SCIP_PARAMEMPHASIS: +class PY_SCIP_PARAMEMPHASIS(_ScipEnum): DEFAULT = SCIP_PARAMEMPHASIS_DEFAULT CPSOLVER = SCIP_PARAMEMPHASIS_CPSOLVER EASYCIP = SCIP_PARAMEMPHASIS_EASYCIP @@ -138,7 +151,7 @@ cdef class PY_SCIP_PARAMEMPHASIS: NUMERICS = SCIP_PARAMEMPHASIS_NUMERICS BENCHMARK = SCIP_PARAMEMPHASIS_BENCHMARK -cdef class PY_SCIP_STATUS: +class PY_SCIP_STATUS(_ScipEnum): UNKNOWN = SCIP_STATUS_UNKNOWN USERINTERRUPT = SCIP_STATUS_USERINTERRUPT NODELIMIT = SCIP_STATUS_NODELIMIT @@ -157,8 +170,7 @@ cdef class PY_SCIP_STATUS: UNBOUNDED = SCIP_STATUS_UNBOUNDED INFORUNBD = SCIP_STATUS_INFORUNBD -StageNames = {} -cdef class PY_SCIP_STAGE: +class PY_SCIP_STAGE(_ScipEnum): INIT = SCIP_STAGE_INIT PROBLEM = SCIP_STAGE_PROBLEM TRANSFORMING = SCIP_STAGE_TRANSFORMING @@ -174,7 +186,9 @@ cdef class PY_SCIP_STAGE: FREETRANS = SCIP_STAGE_FREETRANS FREE = SCIP_STAGE_FREE -cdef class PY_SCIP_NODETYPE: +StageNames = {stage.value: stage.name for stage in PY_SCIP_STAGE} + +class PY_SCIP_NODETYPE(_ScipEnum): FOCUSNODE = SCIP_NODETYPE_FOCUSNODE PROBINGNODE = SCIP_NODETYPE_PROBINGNODE SIBLING = SCIP_NODETYPE_SIBLING @@ -187,19 +201,19 @@ cdef class PY_SCIP_NODETYPE: SUBROOT = SCIP_NODETYPE_SUBROOT REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE -cdef class PY_SCIP_PROPTIMING: +class PY_SCIP_PROPTIMING(_ScipFlag): BEFORELP = SCIP_PROPTIMING_BEFORELP DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP AFTERLPLOOP = SCIP_PROPTIMING_AFTERLPLOOP AFTERLPNODE = SCIP_PROPTIMING_AFTERLPNODE -cdef class PY_SCIP_PRESOLTIMING: +class PY_SCIP_PRESOLTIMING(_ScipFlag): NONE = SCIP_PRESOLTIMING_NONE FAST = SCIP_PRESOLTIMING_FAST MEDIUM = SCIP_PRESOLTIMING_MEDIUM EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE -cdef class PY_SCIP_HEURTIMING: +class PY_SCIP_HEURTIMING(_ScipFlag): BEFORENODE = SCIP_HEURTIMING_BEFORENODE DURINGLPLOOP = SCIP_HEURTIMING_DURINGLPLOOP AFTERLPLOOP = SCIP_HEURTIMING_AFTERLPLOOP @@ -212,8 +226,7 @@ cdef class PY_SCIP_HEURTIMING: DURINGPRESOLLOOP = SCIP_HEURTIMING_DURINGPRESOLLOOP AFTERPROPLOOP = SCIP_HEURTIMING_AFTERPROPLOOP -EventNames = {} -cdef class PY_SCIP_EVENTTYPE: +class PY_SCIP_EVENTTYPE(_ScipFlag): DISABLED = SCIP_EVENTTYPE_DISABLED VARADDED = SCIP_EVENTTYPE_VARADDED VARDELETED = SCIP_EVENTTYPE_VARDELETED @@ -271,16 +284,18 @@ cdef class PY_SCIP_EVENTTYPE: ROWCHANGED = SCIP_EVENTTYPE_ROWCHANGED ROWEVENT = SCIP_EVENTTYPE_ROWEVENT -cdef class PY_SCIP_LOCKTYPE: +EventNames = {eventtype.value: eventtype.name for eventtype in PY_SCIP_EVENTTYPE.__members__.values()} + +class PY_SCIP_LOCKTYPE(_ScipEnum): MODEL = SCIP_LOCKTYPE_MODEL CONFLICT = SCIP_LOCKTYPE_CONFLICT -cdef class PY_SCIP_IMPLINTTYPE: +class PY_SCIP_IMPLINTTYPE(_ScipEnum): NONE = SCIP_IMPLINTTYPE_NONE WEAK = SCIP_IMPLINTTYPE_WEAK STRONG = SCIP_IMPLINTTYPE_STRONG -cdef class PY_SCIP_LPSOLSTAT: +class PY_SCIP_LPSOLSTAT(_ScipEnum): NOTSOLVED = SCIP_LPSOLSTAT_NOTSOLVED OPTIMAL = SCIP_LPSOLSTAT_OPTIMAL INFEASIBLE = SCIP_LPSOLSTAT_INFEASIBLE @@ -290,25 +305,34 @@ cdef class PY_SCIP_LPSOLSTAT: TIMELIMIT = SCIP_LPSOLSTAT_TIMELIMIT ERROR = SCIP_LPSOLSTAT_ERROR -cdef class PY_SCIP_BRANCHDIR: +class PY_SCIP_BRANCHDIR(_ScipEnum): DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS UPWARDS = SCIP_BRANCHDIR_UPWARDS FIXED = SCIP_BRANCHDIR_FIXED AUTO = SCIP_BRANCHDIR_AUTO -cdef class PY_SCIP_BENDERSENFOTYPE: +class PY_SCIP_BOUNDTYPE(_ScipEnum): + LOWER = SCIP_BOUNDTYPE_LOWER + UPPER = SCIP_BOUNDTYPE_UPPER + +class PY_SCIP_BOUNDCHGTYPE(_ScipEnum): + BRANCHING = SCIP_BOUNDCHGTYPE_BRANCHING + CONSINFER = SCIP_BOUNDCHGTYPE_CONSINFER + PROPINFER = SCIP_BOUNDCHGTYPE_PROPINFER + +class PY_SCIP_BENDERSENFOTYPE(_ScipEnum): LP = SCIP_BENDERSENFOTYPE_LP RELAX = SCIP_BENDERSENFOTYPE_RELAX PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO CHECK = SCIP_BENDERSENFOTYPE_CHECK -cdef class PY_SCIP_ROWORIGINTYPE: +class PY_SCIP_ROWORIGINTYPE(_ScipEnum): UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC CONS = SCIP_ROWORIGINTYPE_CONS SEPA = SCIP_ROWORIGINTYPE_SEPA REOPT = SCIP_ROWORIGINTYPE_REOPT -cdef class PY_SCIP_SOLORIGIN: +class PY_SCIP_SOLORIGIN(_ScipEnum): ORIGINAL = SCIP_SOLORIGIN_ORIGINAL ZERO = SCIP_SOLORIGIN_ZERO LPSOL = SCIP_SOLORIGIN_LPSOL @@ -393,7 +417,7 @@ cdef class Event: PY_SCIP_EVENTTYPE """ - return SCIPeventGetType(self.event) + return PY_SCIP_EVENTTYPE(SCIPeventGetType(self.event)) def getName(self): """ @@ -404,16 +428,7 @@ cdef class Event: str """ - if not EventNames: - self._getEventNames() - return EventNames[self.getType()] - - def _getEventNames(self): - """Gets event names.""" - for name in dir(PY_SCIP_EVENTTYPE): - attr = getattr(PY_SCIP_EVENTTYPE, name) - if isinstance(attr, int): - EventNames[attr] = name + return self.getType().name def __repr__(self): return str(self.getType()) @@ -857,7 +872,7 @@ cdef class Row: PY_SCIP_ROWORIGINTYPE """ - return SCIProwGetOrigintype(self.scip_row) + return PY_SCIP_ROWORIGINTYPE(SCIProwGetOrigintype(self.scip_row)) def getConsOriginConshdlrtype(self): """ @@ -1145,7 +1160,7 @@ cdef class Solution: ------- PY_SCIP_SOLORIGIN """ - return SCIPsolGetOrigin(self.sol) + return PY_SCIP_SOLORIGIN(SCIPsolGetOrigin(self.sol)) def retransform(self): """ retransforms solution to original problem space """ @@ -1223,11 +1238,11 @@ cdef class BoundChange: Returns ------- - int - (0 = branching, 1 = consinfer, 2 = propinfer) + PY_SCIP_BOUNDCHGTYPE + BRANCHING, CONSINFER or PROPINFER """ - return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + return PY_SCIP_BOUNDCHGTYPE(SCIPboundchgGetBoundchgtype(self.scip_boundchg)) def getBoundtype(self): """ @@ -1235,11 +1250,11 @@ cdef class BoundChange: Returns ------- - int - (0 = lower, 1 = upper) + PY_SCIP_BOUNDTYPE + LOWER or UPPER """ - return SCIPboundchgGetBoundtype(self.scip_boundchg) + return PY_SCIP_BOUNDTYPE(SCIPboundchgGetBoundtype(self.scip_boundchg)) def isRedundant(self): """ @@ -1361,7 +1376,7 @@ cdef class Node: PY_SCIP_NODETYPE """ - return SCIPnodeGetType(self.scip_node) + return PY_SCIP_NODETYPE(SCIPnodeGetType(self.scip_node)) def getLowerbound(self): """ @@ -1468,7 +1483,7 @@ cdef class Node: ------- list of Variable list of float - list of int + list of PY_SCIP_BOUNDTYPE """ cdef int nbranchvars = self.getNParentBranchings() @@ -1483,7 +1498,7 @@ cdef class Node: py_variables = [Variable.create(branchvars[i]) for i in range(nbranchvars)] py_branchbounds = [branchbounds[i] for i in range(nbranchvars)] - py_boundtypes = [boundtypes[i] for i in range(nbranchvars)] + py_boundtypes = [PY_SCIP_BOUNDTYPE(boundtypes[i]) for i in range(nbranchvars)] free(boundtypes) free(branchbounds) free(branchvars) @@ -1636,7 +1651,7 @@ cdef class Variable(Expr): ------- PY_SCIP_IMPLINTTYPE """ - return SCIPvarGetImplType(self.scip_var) + return PY_SCIP_IMPLINTTYPE(SCIPvarGetImplType(self.scip_var)) def getStatus(self): """ @@ -4515,7 +4530,7 @@ cdef class Model: _heur = SCIPfindHeur(self._scip, n) if _heur == NULL: raise ValueError("Could not find heuristic <%s>" % heurname) - return SCIPheurGetTimingmask(_heur) + return PY_SCIP_HEURTIMING(SCIPheurGetTimingmask(_heur)) def disablePropagation(self, onlyroot=False): """ @@ -5529,7 +5544,7 @@ cdef class Model: SCIP_LPSOLSTAT """ - return SCIPgetLPSolstat(self._scip) + return PY_SCIP_LPSOLSTAT(SCIPgetLPSolstat(self._scip)) def constructLP(self): """ @@ -10120,7 +10135,7 @@ cdef class Model: initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) return constraint - def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST): + def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=PY_SCIP_PRESOLTIMING.FAST): """ Include a presolver. @@ -10217,7 +10232,7 @@ cdef class Model: self._plugins.append(reader) def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, - proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True): + proptiming, presoltiming=PY_SCIP_PRESOLTIMING.FAST, priority=1, freq=1, delay=True): """ Include a propagator. @@ -10258,7 +10273,7 @@ cdef class Model: self._plugins.append(prop) def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, - maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False): + maxdepth=-1, timingmask=PY_SCIP_HEURTIMING.BEFORENODE, usessubscip=False): """ Include a primal heuristic. @@ -11909,10 +11924,10 @@ cdef class Model: Returns ------- - int + SCIP_STAGE """ - return SCIPgetStage(self._scip) + return PY_SCIP_STAGE(SCIPgetStage(self._scip)) def getStageName(self): """ @@ -11923,16 +11938,7 @@ cdef class Model: str """ - if not StageNames: - self._getStageNames() - return StageNames[self.getStage()] - - def _getStageNames(self): - """Gets names of stages.""" - for name in dir(PY_SCIP_STAGE): - attr = getattr(PY_SCIP_STAGE, name) - if isinstance(attr, int): - StageNames[attr] = name + return self.getStage().name def getStatus(self): """ @@ -13015,7 +13021,7 @@ cdef class Model: """ cdef SCIP_RESULT result PY_SCIP_CALL(SCIPbranchLPExact(self._scip, &result)) - return result + return PY_SCIP_RESULT(result) def addRowExact(self, RowExact rowexact): """ diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index a69f46dc3..8b3d38b35 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -1,5 +1,6 @@ import os from collections.abc import Iterable, Mapping, Sequence +from enum import IntEnum, IntFlag from typing import Any, ClassVar, Literal, SupportsFloat, overload import numpy as np @@ -69,14 +70,17 @@ class Benders: def benderspostsolve( self, solution: Incomplete, - enfotype: Incomplete, + enfotype: PY_SCIP_BENDERSENFOTYPE, mergecandidates: Incomplete, npriomergecands: Incomplete, checkint: Incomplete, infeasible: Incomplete, ) -> Incomplete: ... def benderspresubsolve( - self, solution: Incomplete, enfotype: Incomplete, checkint: Incomplete + self, + solution: Incomplete, + enfotype: PY_SCIP_BENDERSENFOTYPE, + checkint: Incomplete, ) -> Incomplete: ... def benderssolvesub( self, solution: Incomplete, probnumber: Incomplete @@ -92,7 +96,10 @@ class Benderscut: name: Incomplete def __init__(self) -> None: ... def benderscutexec( - self, solution: Incomplete, probnumber: Incomplete, enfotype: Incomplete + self, + solution: Incomplete, + probnumber: Incomplete, + enfotype: PY_SCIP_BENDERSENFOTYPE, ) -> Incomplete: ... def benderscutexit(self) -> Incomplete: ... def benderscutexitsol(self) -> Incomplete: ... @@ -103,8 +110,8 @@ class Benderscut: @disjoint_base class BoundChange: def __init__(self) -> None: ... - def getBoundchgtype(self) -> Incomplete: ... - def getBoundtype(self) -> Incomplete: ... + def getBoundchgtype(self) -> PY_SCIP_BOUNDCHGTYPE: ... + def getBoundtype(self) -> PY_SCIP_BOUNDTYPE: ... def getNewBound(self) -> float: ... def getVar(self) -> Variable: ... def isRedundant(self) -> bool: ... @@ -207,7 +214,7 @@ class Conshdlr: def conslock( self, constraint: Incomplete, - locktype: Incomplete, + locktype: PY_SCIP_LOCKTYPE, nlockspos: Incomplete, nlocksneg: Incomplete, ) -> Incomplete: ... @@ -216,7 +223,7 @@ class Conshdlr: self, constraints: Incomplete, nrounds: Incomplete, - presoltiming: Incomplete, + presoltiming: PY_SCIP_PRESOLTIMING, nnewfixedvars: Incomplete, nnewaggrvars: Incomplete, nnewchgvartypes: Incomplete, @@ -235,7 +242,7 @@ class Conshdlr: constraints: Incomplete, nusefulconss: Incomplete, nmarkedconss: Incomplete, - proptiming: Incomplete, + proptiming: PY_SCIP_PROPTIMING, ) -> Incomplete: ... def consresprop(self) -> Incomplete: ... def conssepalp( @@ -315,13 +322,12 @@ class Event: data: Any name: Incomplete def __init__(self) -> None: ... - def _getEventNames(self) -> None: ... def getName(self) -> str: ... def getNewBound(self) -> float: ... def getNode(self) -> Node | None: ... def getOldBound(self) -> float: ... def getRow(self) -> Row: ... - def getType(self) -> Incomplete: ... + def getType(self) -> PY_SCIP_EVENTTYPE: ... def getVar(self) -> Variable: ... def __eq__(self, other: object, /) -> bool: ... def __ge__(self, other: object, /) -> bool: ... @@ -481,7 +487,7 @@ class Heur: name: Incomplete def __init__(self) -> None: ... def heurexec( - self, heurtiming: Incomplete, nodeinfeasible: Incomplete + self, heurtiming: PY_SCIP_HEURTIMING, nodeinfeasible: Incomplete ) -> Incomplete: ... def heurexit(self) -> Incomplete: ... def heurexitsol(self) -> Incomplete: ... @@ -550,19 +556,19 @@ class LP: def delCols(self, firstcol: int, lastcol: int) -> None: ... def delRows(self, firstrow: int, lastrow: int) -> None: ... def getActivity(self) -> list[float]: ... - def getBase(self) -> tuple[list[Incomplete], list[Incomplete]]: ... + def getBase(self) -> tuple[list[PY_SCIP_BASESTAT], list[PY_SCIP_BASESTAT]]: ... def getBasisInds(self) -> list[int]: ... def getBounds( self, firstcol: int = 0, lastcol: int | None = None ) -> tuple[list[float], list[float]] | None: ... def getDual(self) -> list[float]: ... def getDualRay(self) -> list[float] | None: ... - def getIntParam(self, param: Incomplete) -> int: ... + def getIntParam(self, param: PY_SCIP_LPPARAM) -> int: ... def getNIterations(self) -> int: ... def getObjVal(self) -> float: ... def getPrimal(self) -> list[float]: ... def getPrimalRay(self) -> list[float] | None: ... - def getRealParam(self, param: Incomplete) -> float: ... + def getRealParam(self, param: PY_SCIP_LPPARAM) -> float: ... def getRedcost(self) -> list[float]: ... def getSides( self, firstrow: int = 0, lastrow: int | None = None @@ -575,9 +581,11 @@ class LP: def ncols(self) -> int: ... def nrows(self) -> int: ... def readLP(self, filename: bytes | bytearray) -> None: ... - def setBase(self, cstat: Incomplete, rstat: Incomplete) -> None: ... - def setIntParam(self, param: Incomplete, value: int) -> None: ... - def setRealParam(self, param: Incomplete, value: float) -> None: ... + def setBase( + self, cstat: Sequence[PY_SCIP_BASESTAT], rstat: Sequence[PY_SCIP_BASESTAT] + ) -> None: ... + def setIntParam(self, param: PY_SCIP_LPPARAM, value: int) -> None: ... + def setRealParam(self, param: PY_SCIP_LPPARAM, value: float) -> None: ... def solve(self, dual: bool = True) -> float: ... def writeLP(self, filename: bytes | bytearray) -> None: ... @@ -698,7 +706,6 @@ class Model: def _createConsQuadratic( self, quadcons: ExprCons, **kwargs: Incomplete ) -> Constraint: ... - def _getStageNames(self) -> None: ... def activateBenders(self, benders: Benders, nsubproblems: int) -> None: ... def addBendersSubproblem(self, benders: Benders, subproblem: Model) -> None: ... def addCoefKnapsack( @@ -1039,7 +1046,7 @@ class Model: ) -> Variable: ... def addVarLocks(self, var: Variable, nlocksdown: int, nlocksup: int) -> None: ... def addVarLocksType( - self, var: Variable, locktype: int, nlocksdown: int, nlocksup: int + self, var: Variable, locktype: PY_SCIP_LOCKTYPE, nlocksdown: int, nlocksup: int ) -> None: ... def addVarSOS1(self, cons: Constraint, var: Variable, weight: float) -> None: ... def addVarSOS2(self, cons: Constraint, var: Variable, weight: float) -> None: ... @@ -1067,7 +1074,7 @@ class Model: description: Incomplete = ..., ) -> Incomplete: ... def backtrackProbing(self, probingdepth: int) -> None: ... - def branchLPExact(self) -> Incomplete: ... + def branchLPExact(self) -> PY_SCIP_RESULT: ... def branchVar(self, variable: Variable) -> tuple[Node, Node | None, Node]: ... def branchVarVal( self, variable: Variable, value: float @@ -1075,14 +1082,16 @@ class Model: def cacheRowExtensions(self, row: Row) -> None: ... def calcChildEstimate(self, variable: Variable, targetvalue: float) -> float: ... def calcNodeselPriority( - self, variable: Variable, branchdir: Incomplete, targetvalue: float + self, variable: Variable, branchdir: PY_SCIP_BRANCHDIR, targetvalue: float ) -> float: ... - def catchEvent(self, eventtype: Incomplete, eventhdlr: Eventhdlr) -> None: ... + def catchEvent( + self, eventtype: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr + ) -> None: ... def catchRowEvent( - self, row: Row, eventtype: Incomplete, eventhdlr: Eventhdlr + self, row: Row, eventtype: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr ) -> None: ... def catchVarEvent( - self, var: Variable, eventtype: Incomplete, eventhdlr: Eventhdlr + self, var: Variable, eventtype: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr ) -> None: ... def checkBendersSubproblemOptimality( self, solution: Solution, probnumber: int, benders: Benders | None = None @@ -1189,12 +1198,12 @@ class Model: def delVar(self, var: Variable) -> bool: ... def disableDebugSol(self) -> None: ... def disablePropagation(self, onlyroot: bool = False) -> None: ... - def dropEvent(self, eventtype: Incomplete, eventhdlr: Eventhdlr) -> None: ... + def dropEvent(self, eventtype: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr) -> None: ... def dropRowEvent( - self, row: Row, eventtype: Incomplete, eventhdlr: Eventhdlr + self, row: Row, eventtype: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr ) -> None: ... def dropVarEvent( - self, var: Variable, eventtype: Incomplete, eventhdlr: Eventhdlr + self, var: Variable, eventtype: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr ) -> None: ... def enableDebugSol(self) -> None: ... def enableExactSolving(self, enable: bool) -> None: ... @@ -1290,7 +1299,7 @@ class Model: def getDualsolLinear(self, cons: Constraint) -> float: ... def getDualsolLogicor(self, logicor_cons: Constraint) -> float: ... def getGap(self) -> float: ... - def getHeurTiming(self, heurname: str) -> Incomplete: ... + def getHeurTiming(self, heurname: str) -> PY_SCIP_HEURTIMING: ... def getIIS(self) -> IIS: ... def getLPBInvARow(self, row: int) -> list[float]: ... def getLPBInvRow(self, row: int) -> list[float]: ... @@ -1301,7 +1310,7 @@ class Model: def getLPColsData(self) -> list[Column]: ... def getLPObjVal(self) -> float: ... def getLPRowsData(self) -> list[Row]: ... - def getLPSolstat(self) -> Incomplete: ... + def getLPSolstat(self) -> PY_SCIP_LPSOLSTAT: ... def getLeaves(self) -> list[Node]: ... def getLhs(self, cons: Constraint) -> float: ... def getLinearConsIndicator(self, cons: Constraint) -> Constraint | None: ... @@ -1408,7 +1417,7 @@ class Model: def getSolVal(self, sol: Solution | None, expr: MatrixExpr) -> np.ndarray: ... def getSols(self) -> list[Solution]: ... def getSolvingTime(self) -> float: ... - def getStage(self) -> Incomplete: ... + def getStage(self) -> PY_SCIP_STAGE: ... def getStageName(self) -> str: ... def getStatus( self, @@ -1450,7 +1459,9 @@ class Model: def getValsLinear(self, cons: Constraint) -> dict[str, float]: ... def getVarDict(self, transformed: bool = False) -> dict[str, float]: ... def getVarLbDive(self, var: Variable) -> float: ... - def getVarPseudocost(self, var: Variable, branchdir: Incomplete) -> float: ... + def getVarPseudocost( + self, var: Variable, branchdir: PY_SCIP_BRANCHDIR + ) -> float: ... def getVarPseudocostScore(self, var: Variable, solVal: float) -> float: ... def getVarRedcost(self, var: Variable) -> float: ... def getVarStrongbranch( @@ -1518,8 +1529,8 @@ class Model: delaysepa: bool = False, delayprop: bool = False, needscons: bool = True, - proptiming: Incomplete = ..., - presoltiming: Incomplete = ..., + proptiming: PY_SCIP_PROPTIMING = ..., + presoltiming: PY_SCIP_PRESOLTIMING = ..., ) -> None: ... def includeCutsel( self, cutsel: Cutsel, name: str, desc: str, priority: int @@ -1536,7 +1547,7 @@ class Model: freq: int = 1, freqofs: int = 0, maxdepth: int = -1, - timingmask: Incomplete = ..., + timingmask: PY_SCIP_HEURTIMING = ..., usessubscip: bool = False, ) -> None: ... def includeIISfinder( @@ -1562,7 +1573,7 @@ class Model: desc: str, priority: int, maxrounds: int, - timing: Incomplete = ..., + timing: PY_SCIP_PRESOLTIMING = ..., ) -> None: ... def includePricer( self, @@ -1579,8 +1590,8 @@ class Model: desc: str, presolpriority: int, presolmaxrounds: int, - proptiming: Incomplete, - presoltiming: Incomplete = ..., + proptiming: PY_SCIP_PROPTIMING, + presoltiming: PY_SCIP_PRESOLTIMING = ..., priority: int = 1, freq: int = 1, delay: bool = True, @@ -1681,10 +1692,12 @@ class Model: def setBoolParam(self, name: str, value: bool) -> None: ... def setCharParam(self, name: str, value: str) -> None: ... def setCheck(self, cons: Constraint, newCheck: bool) -> None: ... - def setEmphasis(self, paraemphasis: Incomplete, quiet: bool = True) -> None: ... + def setEmphasis( + self, paraemphasis: PY_SCIP_PARAMEMPHASIS, quiet: bool = True + ) -> None: ... def setEnforced(self, cons: Constraint, newEnf: bool) -> None: ... - def setHeurTiming(self, heurname: str, heurtiming: Incomplete) -> None: ... - def setHeuristics(self, setting: Incomplete) -> None: ... + def setHeurTiming(self, heurname: str, heurtiming: PY_SCIP_HEURTIMING) -> None: ... + def setHeuristics(self, setting: PY_SCIP_PARAMSETTING) -> None: ... def setInitial(self, cons: Constraint, newInit: bool) -> None: ... def setIntParam(self, name: str, value: int) -> None: ... def setLogfile(self, path: str | None) -> None: ... @@ -1703,12 +1716,12 @@ class Model: def setParam(self, name: str, value: object) -> None: ... def setParams(self, params: Mapping[str, bool | float | str]) -> None: ... def setParamsCountsols(self) -> None: ... - def setPresolve(self, setting: Incomplete) -> None: ... + def setPresolve(self, setting: PY_SCIP_PARAMSETTING) -> None: ... def setProbName(self, name: str) -> None: ... def setRealParam(self, name: str, value: float) -> None: ... def setRelaxSolVal(self, var: Variable, val: float) -> None: ... def setRemovable(self, cons: Constraint, newRem: bool) -> None: ... - def setSeparating(self, setting: Incomplete) -> None: ... + def setSeparating(self, setting: PY_SCIP_PARAMSETTING) -> None: ... def setSolVal(self, solution: Solution, var: Variable, val: float) -> None: ... def setStringParam(self, name: str, value: str) -> None: ... def setupBendersSubproblem( @@ -1716,7 +1729,7 @@ class Model: probnumber: int, benders: Benders | None = None, solution: Solution | None = None, - checktype: Incomplete = ..., + checktype: PY_SCIP_BENDERSENFOTYPE = ..., ) -> None: ... def solveBendersSubproblem( self, @@ -1864,8 +1877,8 @@ class Node: def getParent(self) -> Node | None: ... def getParentBranchings( self, - ) -> tuple[list[Variable], list[float], list[Incomplete]] | None: ... - def getType(self) -> Incomplete: ... + ) -> tuple[list[Variable], list[float], list[PY_SCIP_BOUNDTYPE]] | None: ... + def getType(self) -> PY_SCIP_NODETYPE: ... def isActive(self) -> bool: ... def isPropagatedAgain(self) -> bool: ... def __eq__(self, other: object, /) -> bool: ... @@ -1906,269 +1919,259 @@ class Op: sqrt: ClassVar[str] = ... varidx: ClassVar[str] = ... -class PY_SCIP_BENDERSENFOTYPE: - CHECK: ClassVar[int] = ... - LP: ClassVar[int] = ... - PSEUDO: ClassVar[int] = ... - RELAX: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_BRANCHDIR: - AUTO: ClassVar[int] = ... - DOWNWARDS: ClassVar[int] = ... - FIXED: ClassVar[int] = ... - UPWARDS: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_EVENTTYPE: - BESTSOLFOUND: ClassVar[int] = ... - BOUNDCHANGED: ClassVar[int] = ... - BOUNDRELAXED: ClassVar[int] = ... - BOUNDTIGHTENED: ClassVar[int] = ... - DISABLED: ClassVar[int] = ... - DOMCHANGED: ClassVar[int] = ... - DUALBOUNDIMPROVED: ClassVar[int] = ... - FIRSTLPSOLVED: ClassVar[int] = ... - GAPUPDATED: ClassVar[int] = ... - GBDCHANGED: ClassVar[int] = ... - GHOLEADDED: ClassVar[int] = ... - GHOLECHANGED: ClassVar[int] = ... - GHOLEREMOVED: ClassVar[int] = ... - GLBCHANGED: ClassVar[int] = ... - GUBCHANGED: ClassVar[int] = ... - HOLECHANGED: ClassVar[int] = ... - IMPLADDED: ClassVar[int] = ... - LBCHANGED: ClassVar[int] = ... - LBRELAXED: ClassVar[int] = ... - LBTIGHTENED: ClassVar[int] = ... - LHOLEADDED: ClassVar[int] = ... - LHOLECHANGED: ClassVar[int] = ... - LHOLEREMOVED: ClassVar[int] = ... - LPEVENT: ClassVar[int] = ... - LPSOLVED: ClassVar[int] = ... - NODEBRANCHED: ClassVar[int] = ... - NODEDELETE: ClassVar[int] = ... - NODEEVENT: ClassVar[int] = ... - NODEFEASIBLE: ClassVar[int] = ... - NODEFOCUSED: ClassVar[int] = ... - NODEINFEASIBLE: ClassVar[int] = ... - NODESOLVED: ClassVar[int] = ... - OBJCHANGED: ClassVar[int] = ... - POORSOLFOUND: ClassVar[int] = ... - PRESOLVEROUND: ClassVar[int] = ... - ROWADDEDLP: ClassVar[int] = ... - ROWADDEDSEPA: ClassVar[int] = ... - ROWCHANGED: ClassVar[int] = ... - ROWCOEFCHANGED: ClassVar[int] = ... - ROWCONSTCHANGED: ClassVar[int] = ... - ROWDELETEDLP: ClassVar[int] = ... - ROWDELETEDSEPA: ClassVar[int] = ... - ROWEVENT: ClassVar[int] = ... - ROWSIDECHANGED: ClassVar[int] = ... - SOLEVENT: ClassVar[int] = ... - SOLFOUND: ClassVar[int] = ... - SYNC: ClassVar[int] = ... - UBCHANGED: ClassVar[int] = ... - UBRELAXED: ClassVar[int] = ... - UBTIGHTENED: ClassVar[int] = ... - VARADDED: ClassVar[int] = ... - VARCHANGED: ClassVar[int] = ... - VARDELETED: ClassVar[int] = ... - VAREVENT: ClassVar[int] = ... - VARFIXED: ClassVar[int] = ... - VARUNLOCKED: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_HEURTIMING: - AFTERLPLOOP: ClassVar[int] = ... - AFTERLPNODE: ClassVar[int] = ... - AFTERLPPLUNGE: ClassVar[int] = ... - AFTERPROPLOOP: ClassVar[int] = ... - AFTERPSEUDONODE: ClassVar[int] = ... - AFTERPSEUDOPLUNGE: ClassVar[int] = ... - BEFORENODE: ClassVar[int] = ... - BEFOREPRESOL: ClassVar[int] = ... - DURINGLPLOOP: ClassVar[int] = ... - DURINGPRESOLLOOP: ClassVar[int] = ... - DURINGPRICINGLOOP: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_IMPLINTTYPE: - NONE: ClassVar[int] = ... - STRONG: ClassVar[int] = ... - WEAK: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_LOCKTYPE: - CONFLICT: ClassVar[int] = ... - 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] = ... - DUALFEASTOL: ClassVar[int] = ... - FASTMIP: ClassVar[int] = ... - FEASTOL: ClassVar[int] = ... - FROMSCRATCH: ClassVar[int] = ... - LPINFO: ClassVar[int] = ... - LPITLIM: ClassVar[int] = ... - LPTILIM: ClassVar[int] = ... - MARKOWITZ: ClassVar[int] = ... - OBJLIM: ClassVar[int] = ... - POLISHING: ClassVar[int] = ... - PRESOLVING: ClassVar[int] = ... - PRICING: ClassVar[int] = ... - RANDOMSEED: ClassVar[int] = ... - REFACTOR: ClassVar[int] = ... - ROWREPSWITCH: ClassVar[int] = ... - SCALING: ClassVar[int] = ... - THREADS: ClassVar[int] = ... - TIMING: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_LPSOLSTAT: - ERROR: ClassVar[int] = ... - INFEASIBLE: ClassVar[int] = ... - ITERLIMIT: ClassVar[int] = ... - NOTSOLVED: ClassVar[int] = ... - OBJLIMIT: ClassVar[int] = ... - OPTIMAL: ClassVar[int] = ... - TIMELIMIT: ClassVar[int] = ... - UNBOUNDEDRAY: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_NODETYPE: - CHILD: ClassVar[int] = ... - DEADEND: ClassVar[int] = ... - FOCUSNODE: ClassVar[int] = ... - FORK: ClassVar[int] = ... - JUNCTION: ClassVar[int] = ... - LEAF: ClassVar[int] = ... - PROBINGNODE: ClassVar[int] = ... - PSEUDOFORK: ClassVar[int] = ... - REFOCUSNODE: ClassVar[int] = ... - SIBLING: ClassVar[int] = ... - SUBROOT: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_PARAMEMPHASIS: - BENCHMARK: ClassVar[int] = ... - COUNTER: ClassVar[int] = ... - CPSOLVER: ClassVar[int] = ... - DEFAULT: ClassVar[int] = ... - EASYCIP: ClassVar[int] = ... - FEASIBILITY: ClassVar[int] = ... - HARDLP: ClassVar[int] = ... - NUMERICS: ClassVar[int] = ... - OPTIMALITY: ClassVar[int] = ... - PHASEFEAS: ClassVar[int] = ... - PHASEIMPROVE: ClassVar[int] = ... - PHASEPROOF: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_PARAMSETTING: - AGGRESSIVE: ClassVar[int] = ... - DEFAULT: ClassVar[int] = ... - FAST: ClassVar[int] = ... - OFF: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_PRESOLTIMING: - EXHAUSTIVE: ClassVar[int] = ... - FAST: ClassVar[int] = ... - MEDIUM: ClassVar[int] = ... - NONE: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_PROPTIMING: - AFTERLPLOOP: ClassVar[int] = ... - AFTERLPNODE: ClassVar[int] = ... - BEFORELP: ClassVar[int] = ... - DURINGLPLOOP: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_RESULT: - BRANCHED: ClassVar[int] = ... - CONSADDED: ClassVar[int] = ... - CONSCHANGED: ClassVar[int] = ... - CUTOFF: ClassVar[int] = ... - DELAYED: ClassVar[int] = ... - DIDNOTFIND: ClassVar[int] = ... - DIDNOTRUN: ClassVar[int] = ... - FEASIBLE: ClassVar[int] = ... - FOUNDSOL: ClassVar[int] = ... - INFEASIBLE: ClassVar[int] = ... - NEWROUND: ClassVar[int] = ... - REDUCEDDOM: ClassVar[int] = ... - SEPARATED: ClassVar[int] = ... - SOLVELP: ClassVar[int] = ... - SUCCESS: ClassVar[int] = ... - SUSPENDED: ClassVar[int] = ... - UNBOUNDED: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_ROWORIGINTYPE: - CONS: ClassVar[int] = ... - REOPT: ClassVar[int] = ... - SEPA: ClassVar[int] = ... - UNSPEC: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_SOLORIGIN: - LPSOL: ClassVar[int] = ... - NLPSOL: ClassVar[int] = ... - ORIGINAL: ClassVar[int] = ... - PARTIAL: ClassVar[int] = ... - PSEUDOSOL: ClassVar[int] = ... - RELAXSOL: ClassVar[int] = ... - UNKNOWN: ClassVar[int] = ... - ZERO: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_STAGE: - EXITPRESOLVE: ClassVar[int] = ... - EXITSOLVE: ClassVar[int] = ... - FREE: ClassVar[int] = ... - FREETRANS: ClassVar[int] = ... - INIT: ClassVar[int] = ... - INITPRESOLVE: ClassVar[int] = ... - INITSOLVE: ClassVar[int] = ... - PRESOLVED: ClassVar[int] = ... - PRESOLVING: ClassVar[int] = ... - PROBLEM: ClassVar[int] = ... - SOLVED: ClassVar[int] = ... - SOLVING: ClassVar[int] = ... - TRANSFORMED: ClassVar[int] = ... - TRANSFORMING: ClassVar[int] = ... - def __init__(self) -> None: ... - -class PY_SCIP_STATUS: - BESTSOLLIMIT: ClassVar[int] = ... - DUALLIMIT: ClassVar[int] = ... - GAPLIMIT: ClassVar[int] = ... - INFEASIBLE: ClassVar[int] = ... - INFORUNBD: ClassVar[int] = ... - MEMLIMIT: ClassVar[int] = ... - NODELIMIT: ClassVar[int] = ... - OPTIMAL: ClassVar[int] = ... - PRIMALLIMIT: ClassVar[int] = ... - RESTARTLIMIT: ClassVar[int] = ... - SOLLIMIT: ClassVar[int] = ... - STALLNODELIMIT: ClassVar[int] = ... - TIMELIMIT: ClassVar[int] = ... - TOTALNODELIMIT: ClassVar[int] = ... - UNBOUNDED: ClassVar[int] = ... - UNKNOWN: ClassVar[int] = ... - USERINTERRUPT: ClassVar[int] = ... - def __init__(self) -> None: ... +class PY_SCIP_BENDERSENFOTYPE(IntEnum): + CHECK = ... + LP = ... + PSEUDO = ... + RELAX = ... + +class PY_SCIP_BOUNDCHGTYPE(IntEnum): + BRANCHING = ... + CONSINFER = ... + PROPINFER = ... + +class PY_SCIP_BOUNDTYPE(IntEnum): + LOWER = ... + UPPER = ... + +class PY_SCIP_BRANCHDIR(IntEnum): + AUTO = ... + DOWNWARDS = ... + FIXED = ... + UPWARDS = ... + +class PY_SCIP_EVENTTYPE(IntFlag): + BESTSOLFOUND = ... + BOUNDCHANGED = ... + BOUNDRELAXED = ... + BOUNDTIGHTENED = ... + DISABLED = ... + DOMCHANGED = ... + DUALBOUNDIMPROVED = ... + FIRSTLPSOLVED = ... + GAPUPDATED = ... + GBDCHANGED = ... + GHOLEADDED = ... + GHOLECHANGED = ... + GHOLEREMOVED = ... + GLBCHANGED = ... + GUBCHANGED = ... + HOLECHANGED = ... + IMPLADDED = ... + LBCHANGED = ... + LBRELAXED = ... + LBTIGHTENED = ... + LHOLEADDED = ... + LHOLECHANGED = ... + LHOLEREMOVED = ... + LPEVENT = ... + LPSOLVED = ... + NODEBRANCHED = ... + NODEDELETE = ... + NODEEVENT = ... + NODEFEASIBLE = ... + NODEFOCUSED = ... + NODEINFEASIBLE = ... + NODESOLVED = ... + OBJCHANGED = ... + POORSOLFOUND = ... + PRESOLVEROUND = ... + ROWADDEDLP = ... + ROWADDEDSEPA = ... + ROWCHANGED = ... + ROWCOEFCHANGED = ... + ROWCONSTCHANGED = ... + ROWDELETEDLP = ... + ROWDELETEDSEPA = ... + ROWEVENT = ... + ROWSIDECHANGED = ... + SOLEVENT = ... + SOLFOUND = ... + SYNC = ... + UBCHANGED = ... + UBRELAXED = ... + UBTIGHTENED = ... + VARADDED = ... + VARCHANGED = ... + VARDELETED = ... + VAREVENT = ... + VARFIXED = ... + VARUNLOCKED = ... + +class PY_SCIP_HEURTIMING(IntFlag): + AFTERLPLOOP = ... + AFTERLPNODE = ... + AFTERLPPLUNGE = ... + AFTERPROPLOOP = ... + AFTERPSEUDONODE = ... + AFTERPSEUDOPLUNGE = ... + BEFORENODE = ... + BEFOREPRESOL = ... + DURINGLPLOOP = ... + DURINGPRESOLLOOP = ... + DURINGPRICINGLOOP = ... + +class PY_SCIP_IMPLINTTYPE(IntEnum): + NONE = ... + STRONG = ... + WEAK = ... + +class PY_SCIP_LOCKTYPE(IntEnum): + CONFLICT = ... + MODEL = ... + +class PY_SCIP_BASESTAT(IntEnum): + LOWER = ... + BASIC = ... + UPPER = ... + ZERO = ... + +class PY_SCIP_LPPARAM(IntEnum): + BARRIERCONVTOL = ... + CONDITIONLIMIT = ... + DUALFEASTOL = ... + FASTMIP = ... + FEASTOL = ... + FROMSCRATCH = ... + LPINFO = ... + LPITLIM = ... + LPTILIM = ... + MARKOWITZ = ... + OBJLIM = ... + POLISHING = ... + PRESOLVING = ... + PRICING = ... + RANDOMSEED = ... + REFACTOR = ... + ROWREPSWITCH = ... + SCALING = ... + THREADS = ... + TIMING = ... + +class PY_SCIP_LPSOLSTAT(IntEnum): + ERROR = ... + INFEASIBLE = ... + ITERLIMIT = ... + NOTSOLVED = ... + OBJLIMIT = ... + OPTIMAL = ... + TIMELIMIT = ... + UNBOUNDEDRAY = ... + +class PY_SCIP_NODETYPE(IntEnum): + CHILD = ... + DEADEND = ... + FOCUSNODE = ... + FORK = ... + JUNCTION = ... + LEAF = ... + PROBINGNODE = ... + PSEUDOFORK = ... + REFOCUSNODE = ... + SIBLING = ... + SUBROOT = ... + +class PY_SCIP_PARAMEMPHASIS(IntEnum): + BENCHMARK = ... + COUNTER = ... + CPSOLVER = ... + DEFAULT = ... + EASYCIP = ... + FEASIBILITY = ... + HARDLP = ... + NUMERICS = ... + OPTIMALITY = ... + PHASEFEAS = ... + PHASEIMPROVE = ... + PHASEPROOF = ... + +class PY_SCIP_PARAMSETTING(IntEnum): + AGGRESSIVE = ... + DEFAULT = ... + FAST = ... + OFF = ... + +class PY_SCIP_PRESOLTIMING(IntFlag): + EXHAUSTIVE = ... + FAST = ... + MEDIUM = ... + NONE = ... + +class PY_SCIP_PROPTIMING(IntFlag): + AFTERLPLOOP = ... + AFTERLPNODE = ... + BEFORELP = ... + DURINGLPLOOP = ... + +class PY_SCIP_RESULT(IntEnum): + BRANCHED = ... + CONSADDED = ... + CONSCHANGED = ... + CUTOFF = ... + DELAYED = ... + DIDNOTFIND = ... + DIDNOTRUN = ... + FEASIBLE = ... + FOUNDSOL = ... + INFEASIBLE = ... + NEWROUND = ... + REDUCEDDOM = ... + SEPARATED = ... + SOLVELP = ... + SUCCESS = ... + SUSPENDED = ... + UNBOUNDED = ... + +class PY_SCIP_ROWORIGINTYPE(IntEnum): + CONS = ... + REOPT = ... + SEPA = ... + UNSPEC = ... + +class PY_SCIP_SOLORIGIN(IntEnum): + LPSOL = ... + NLPSOL = ... + ORIGINAL = ... + PARTIAL = ... + PSEUDOSOL = ... + RELAXSOL = ... + UNKNOWN = ... + ZERO = ... + +class PY_SCIP_STAGE(IntEnum): + EXITPRESOLVE = ... + EXITSOLVE = ... + FREE = ... + FREETRANS = ... + INIT = ... + INITPRESOLVE = ... + INITSOLVE = ... + PRESOLVED = ... + PRESOLVING = ... + PROBLEM = ... + SOLVED = ... + SOLVING = ... + TRANSFORMED = ... + TRANSFORMING = ... + +class PY_SCIP_STATUS(IntEnum): + BESTSOLLIMIT = ... + DUALLIMIT = ... + GAPLIMIT = ... + INFEASIBLE = ... + INFORUNBD = ... + MEMLIMIT = ... + NODELIMIT = ... + OPTIMAL = ... + PRIMALLIMIT = ... + RESTARTLIMIT = ... + SOLLIMIT = ... + STALLNODELIMIT = ... + TIMELIMIT = ... + TOTALNODELIMIT = ... + UNBOUNDED = ... + UNKNOWN = ... + USERINTERRUPT = ... @disjoint_base class PowExpr(GenExpr): @@ -2182,7 +2185,7 @@ class Presol: model: Incomplete def __init__(self) -> None: ... def presolexec( - self, nrounds: Incomplete, presoltiming: Incomplete + self, nrounds: Incomplete, presoltiming: PY_SCIP_PRESOLTIMING ) -> Incomplete: ... def presolexit(self) -> Incomplete: ... def presolexitpre(self) -> Incomplete: ... @@ -2213,7 +2216,7 @@ class ProdExpr(GenExpr): class Prop: model: Incomplete def __init__(self) -> None: ... - def propexec(self, proptiming: Incomplete) -> Incomplete: ... + def propexec(self, proptiming: PY_SCIP_PROPTIMING) -> Incomplete: ... def propexit(self) -> Incomplete: ... def propexitpre(self) -> Incomplete: ... def propexitsol(self, restart: Incomplete) -> Incomplete: ... @@ -2222,13 +2225,16 @@ class Prop: def propinitpre(self) -> Incomplete: ... def propinitsol(self) -> Incomplete: ... def proppresol( - self, nrounds: Incomplete, presoltiming: Incomplete, result_dict: Incomplete + self, + nrounds: Incomplete, + presoltiming: PY_SCIP_PRESOLTIMING, + result_dict: Incomplete, ) -> Incomplete: ... def propresprop( self, confvar: Incomplete, inferinfo: Incomplete, - bdtype: Incomplete, + bdtype: PY_SCIP_BOUNDTYPE, relaxedbd: Incomplete, ) -> Incomplete: ... @@ -2288,7 +2294,7 @@ class Row: def getNLPNonz(self) -> int: ... def getNNonz(self) -> int: ... def getNorm(self) -> float: ... - def getOrigintype(self) -> Incomplete: ... + def getOrigintype(self) -> PY_SCIP_ROWORIGINTYPE: ... def getRhs(self) -> float: ... def getVals(self) -> list[float]: ... def isInGlobalCutpool(self) -> bool: ... @@ -2327,7 +2333,7 @@ class Solution: data: Any def __init__(self, raise_error: bool = True) -> None: ... def _checkStage(self, method: str) -> None: ... - def getOrigin(self) -> Incomplete: ... + def getOrigin(self) -> PY_SCIP_SOLORIGIN: ... def retransform(self) -> None: ... def translate(self, target: Model) -> Solution: ... @overload @@ -2447,18 +2453,18 @@ class Variable(Expr): def __init__(self) -> None: ... def getAvgSol(self) -> float: ... def getCol(self) -> Column: ... - def getImplType(self) -> Incomplete: ... + def getImplType(self) -> PY_SCIP_IMPLINTTYPE: ... def getIndex(self) -> int: ... def getLPSol(self) -> float: ... def getLbGlobal(self) -> float: ... def getLbLocal(self) -> float: ... def getLbOriginal(self) -> float: ... - def getNBranchings(self, branchdir: Incomplete) -> int: ... - def getNBranchingsCurrentRun(self, branchdir: Incomplete) -> int: ... + def getNBranchings(self, branchdir: PY_SCIP_BRANCHDIR) -> int: ... + def getNBranchingsCurrentRun(self, branchdir: PY_SCIP_BRANCHDIR) -> int: ... def getNLocksDown(self) -> int: ... - def getNLocksDownType(self, locktype: Incomplete) -> int: ... + def getNLocksDownType(self, locktype: PY_SCIP_LOCKTYPE) -> int: ... def getNLocksUp(self) -> int: ... - def getNLocksUpType(self, locktype: Incomplete) -> int: ... + def getNLocksUpType(self, locktype: PY_SCIP_LOCKTYPE) -> int: ... def getObj(self) -> float: ... def getStatus( self, diff --git a/tests/test_event.py b/tests/test_event.py index 9efcb5770..c5380754c 100644 --- a/tests/test_event.py +++ b/tests/test_event.py @@ -81,6 +81,7 @@ def eventexit(self): self.model.dropEvent(self.event_type, self) def eventexec(self, event): + assert isinstance(event.getType(), SCIP_EVENTTYPE) assert str(event) == event.getName() assert type(event.getName()) == str @@ -126,19 +127,12 @@ def eventexec(self, event): def test_event(): - all_events = {} - for attr_name in dir(SCIP_EVENTTYPE): - if not attr_name.startswith('_'): - attr = getattr(SCIP_EVENTTYPE, attr_name) - if isinstance(attr, int): - all_events[attr_name] = attr - all_event_hdlrs = [] - for event_name, event in all_events.items(): + for event_name, event in SCIP_EVENTTYPE.__members__.items(): s = Model() s.hideOutput() all_event_hdlrs.append(MyEvent()) - all_event_hdlrs[-1].event_type = all_events[event_name] + all_event_hdlrs[-1].event_type = event s.includeEventhdlr(all_event_hdlrs[-1], str(event), "python event handler to catch %s" % str(event_name)) x = {} diff --git a/tests/test_heur.py b/tests/test_heur.py index b9d1f7fcc..10509ea80 100644 --- a/tests/test_heur.py +++ b/tests/test_heur.py @@ -34,6 +34,7 @@ def heurexec(self, heurtiming, nodeinfeasible): # This heuristic does not run if the LP status is not optimal lpsolstat = scip.getLPSolstat() + assert isinstance(lpsolstat, SCIP_LPSOLSTAT) if lpsolstat != SCIP_LPSOLSTAT.OPTIMAL: return {"result": result} @@ -133,5 +134,8 @@ def test_simple_round_heur(): def test_heurTiming(): model = Model() - model.setHeurTiming('rins', SCIP_HEURTIMING.BEFORENODE) - print("timing of rins: %d\n" % model.getHeurTiming('rins')) + timing = SCIP_HEURTIMING.BEFORENODE | SCIP_HEURTIMING.AFTERLPNODE + model.setHeurTiming('rins', timing) + returned_timing = model.getHeurTiming('rins') + assert isinstance(returned_timing, SCIP_HEURTIMING) + assert returned_timing == timing diff --git a/tests/test_lp.py b/tests/test_lp.py index deb416d58..2542b05df 100644 --- a/tests/test_lp.py +++ b/tests/test_lp.py @@ -98,6 +98,7 @@ def test_lp(): cstat, rstat = myLP.getBase() assert len(cstat) == myLP.ncols() assert len(rstat) == myLP.nrows() + assert all(isinstance(s, SCIP_BASESTAT) for s in cstat + rstat) assert all(s in (SCIP_BASESTAT.LOWER, SCIP_BASESTAT.BASIC, SCIP_BASESTAT.UPPER, SCIP_BASESTAT.ZERO) for s in cstat) assert all(s in (SCIP_BASESTAT.LOWER, SCIP_BASESTAT.BASIC, diff --git a/tests/test_model.py b/tests/test_model.py index fdc9dc6f7..7fa9c7332 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -284,18 +284,18 @@ def test_objLim(): def test_getStage(): m = Model() - assert m.getStage() == SCIP_STAGE.PROBLEM + assert m.getStage() is SCIP_STAGE.PROBLEM assert m.getStageName() == "PROBLEM" x = m.addVar() m.addCons(x >= 1) - assert m.getStage() == SCIP_STAGE.PROBLEM + assert m.getStage() is SCIP_STAGE.PROBLEM assert m.getStageName() == "PROBLEM" m.optimize() - assert m.getStage() == SCIP_STAGE.SOLVED + assert m.getStage() is SCIP_STAGE.SOLVED assert m.getStageName() == "SOLVED" def test_getObjective(): diff --git a/tests/test_node.py b/tests/test_node.py index 783580af9..748ac51e6 100644 --- a/tests/test_node.py +++ b/tests/test_node.py @@ -1,4 +1,4 @@ -from pyscipopt import SCIP_RESULT, Eventhdlr, SCIP_EVENTTYPE, scip +from pyscipopt import SCIP_RESULT, Eventhdlr, SCIP_EVENTTYPE, SCIP_NODETYPE, scip from helpers.utils import random_mip_1 class cutoffEventHdlr(Eventhdlr): @@ -78,6 +78,7 @@ def eventexec(self, event): assert isinstance(focus, scip.Node) assert isinstance(current, scip.Node) + assert focus.getType() is SCIP_NODETYPE.FOCUSNODE # focus and current node should be the same before probing assert focus.getNumber() == current.getNumber() diff --git a/tests/test_row_dual.py b/tests/test_row_dual.py index 32dbd8d8f..2ee7ae298 100644 --- a/tests/test_row_dual.py +++ b/tests/test_row_dual.py @@ -1,4 +1,4 @@ -from pyscipopt import Model, Sepa, SCIP_RESULT, SCIP_PARAMSETTING +from pyscipopt import Model, Sepa, SCIP_RESULT, SCIP_PARAMSETTING, SCIP_ROWORIGINTYPE class SimpleSepa(Sepa): @@ -26,6 +26,7 @@ def sepaexeclp(self): cut = scip.createEmptyRowSepa(self, lhs=-scip.infinity(), rhs=1.0) + assert cut.getOrigintype() is SCIP_ROWORIGINTYPE.SEPA scip.cacheRowExtensions(cut) diff --git a/tests/test_solution.py b/tests/test_solution.py index 45dc7fd50..89058fff8 100644 --- a/tests/test_solution.py +++ b/tests/test_solution.py @@ -220,10 +220,10 @@ def test_getOrigin_retrasform(): m.optimize() sol = m.getBestSol() - assert sol.getOrigin() == SCIP_SOLORIGIN.ZERO + assert sol.getOrigin() is SCIP_SOLORIGIN.ZERO sol.retransform() - assert sol.getOrigin() == SCIP_SOLORIGIN.ORIGINAL + assert sol.getOrigin() is SCIP_SOLORIGIN.ORIGINAL def test_translate(): diff --git a/tests/test_tree.py b/tests/test_tree.py index 14eaccc1b..5f4947951 100644 --- a/tests/test_tree.py +++ b/tests/test_tree.py @@ -1,6 +1,6 @@ import pytest -from pyscipopt import Model, Eventhdlr, SCIP_RESULT, SCIP_EVENTTYPE, SCIP_PARAMSETTING +from pyscipopt import Model, Eventhdlr, SCIP_RESULT, SCIP_EVENTTYPE, SCIP_PARAMSETTING, SCIP_BOUNDTYPE, SCIP_BOUNDCHGTYPE class NodeEventHandler(Eventhdlr): @@ -31,6 +31,9 @@ def eventexec(self, event): domain_changes = node.getDomchg() bound_changes = domain_changes.getBoundchgs() assert len(bound_changes) == 1 + assert isinstance(boundtypes[0], SCIP_BOUNDTYPE) + assert bound_changes[0].getBoundtype() == boundtypes[0] + assert bound_changes[0].getBoundchgtype() == SCIP_BOUNDCHGTYPE.BRANCHING def test_tree(): diff --git a/tests/test_vars.py b/tests/test_vars.py index 220ae9167..8df903738 100644 --- a/tests/test_vars.py +++ b/tests/test_vars.py @@ -71,7 +71,7 @@ def test_vtype(): assert is_int(z) and not is_implint(z) and is_bin(z) assert w.vtype() == "CONTINUOUS" and is_int(w) and is_implint(w) and not is_bin(w) - assert w.getImplType() == SCIP_IMPLINTTYPE.WEAK + assert w.getImplType() is SCIP_IMPLINTTYPE.WEAK m.chgVarType(x, 'I') assert x.vtype() == "INTEGER"