From c4acd6e6fda1c41e0375863742e150387932f0e8 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Sun, 8 Nov 2026 21:25:24 +0100 Subject: [PATCH 1/7] Replace SCIP constant classes with runtime enums --- src/pyscipopt/scip.pxi | 39 ++-- src/pyscipopt/scip.pyi | 508 ++++++++++++++++++++--------------------- 2 files changed, 265 insertions(+), 282 deletions(-) diff --git a/src/pyscipopt/scip.pxi b/src/pyscipopt/scip.pxi index a849a30b3..55b7c175e 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -18,6 +18,7 @@ from posix.stdio cimport fileno from collections.abc import Iterable from itertools import repeat from dataclasses import dataclass +from enum import IntEnum, IntFlag from typing import Union import numpy as np @@ -71,7 +72,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(IntEnum): DIDNOTRUN = SCIP_DIDNOTRUN DELAYED = SCIP_DELAYED DIDNOTFIND = SCIP_DIDNOTFIND @@ -90,13 +91,13 @@ cdef class PY_SCIP_RESULT: SUSPENDED = SCIP_SUSPENDED SUCCESS = SCIP_SUCCESS -cdef class PY_SCIP_PARAMSETTING: +class PY_SCIP_PARAMSETTING(IntEnum): 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(IntEnum): FROMSCRATCH = SCIP_LPPAR_FROMSCRATCH FASTMIP = SCIP_LPPAR_FASTMIP SCALING = SCIP_LPPAR_SCALING @@ -118,13 +119,13 @@ cdef class PY_SCIP_LPPARAM: POLISHING = SCIP_LPPAR_POLISHING REFACTOR = SCIP_LPPAR_REFACTOR -cdef class PY_SCIP_BASESTAT: +class PY_SCIP_BASESTAT(IntEnum): 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(IntEnum): DEFAULT = SCIP_PARAMEMPHASIS_DEFAULT CPSOLVER = SCIP_PARAMEMPHASIS_CPSOLVER EASYCIP = SCIP_PARAMEMPHASIS_EASYCIP @@ -138,7 +139,7 @@ cdef class PY_SCIP_PARAMEMPHASIS: NUMERICS = SCIP_PARAMEMPHASIS_NUMERICS BENCHMARK = SCIP_PARAMEMPHASIS_BENCHMARK -cdef class PY_SCIP_STATUS: +class PY_SCIP_STATUS(IntEnum): UNKNOWN = SCIP_STATUS_UNKNOWN USERINTERRUPT = SCIP_STATUS_USERINTERRUPT NODELIMIT = SCIP_STATUS_NODELIMIT @@ -158,7 +159,7 @@ cdef class PY_SCIP_STATUS: INFORUNBD = SCIP_STATUS_INFORUNBD StageNames = {} -cdef class PY_SCIP_STAGE: +class PY_SCIP_STAGE(IntEnum): INIT = SCIP_STAGE_INIT PROBLEM = SCIP_STAGE_PROBLEM TRANSFORMING = SCIP_STAGE_TRANSFORMING @@ -174,7 +175,7 @@ cdef class PY_SCIP_STAGE: FREETRANS = SCIP_STAGE_FREETRANS FREE = SCIP_STAGE_FREE -cdef class PY_SCIP_NODETYPE: +class PY_SCIP_NODETYPE(IntEnum): FOCUSNODE = SCIP_NODETYPE_FOCUSNODE PROBINGNODE = SCIP_NODETYPE_PROBINGNODE SIBLING = SCIP_NODETYPE_SIBLING @@ -187,19 +188,19 @@ cdef class PY_SCIP_NODETYPE: SUBROOT = SCIP_NODETYPE_SUBROOT REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE -cdef class PY_SCIP_PROPTIMING: +class PY_SCIP_PROPTIMING(IntFlag): 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(IntFlag): 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(IntFlag): BEFORENODE = SCIP_HEURTIMING_BEFORENODE DURINGLPLOOP = SCIP_HEURTIMING_DURINGLPLOOP AFTERLPLOOP = SCIP_HEURTIMING_AFTERLPLOOP @@ -213,7 +214,7 @@ cdef class PY_SCIP_HEURTIMING: AFTERPROPLOOP = SCIP_HEURTIMING_AFTERPROPLOOP EventNames = {} -cdef class PY_SCIP_EVENTTYPE: +class PY_SCIP_EVENTTYPE(IntFlag): DISABLED = SCIP_EVENTTYPE_DISABLED VARADDED = SCIP_EVENTTYPE_VARADDED VARDELETED = SCIP_EVENTTYPE_VARDELETED @@ -271,16 +272,16 @@ cdef class PY_SCIP_EVENTTYPE: ROWCHANGED = SCIP_EVENTTYPE_ROWCHANGED ROWEVENT = SCIP_EVENTTYPE_ROWEVENT -cdef class PY_SCIP_LOCKTYPE: +class PY_SCIP_LOCKTYPE(IntEnum): MODEL = SCIP_LOCKTYPE_MODEL CONFLICT = SCIP_LOCKTYPE_CONFLICT -cdef class PY_SCIP_IMPLINTTYPE: +class PY_SCIP_IMPLINTTYPE(IntEnum): NONE = SCIP_IMPLINTTYPE_NONE WEAK = SCIP_IMPLINTTYPE_WEAK STRONG = SCIP_IMPLINTTYPE_STRONG -cdef class PY_SCIP_LPSOLSTAT: +class PY_SCIP_LPSOLSTAT(IntEnum): NOTSOLVED = SCIP_LPSOLSTAT_NOTSOLVED OPTIMAL = SCIP_LPSOLSTAT_OPTIMAL INFEASIBLE = SCIP_LPSOLSTAT_INFEASIBLE @@ -290,25 +291,25 @@ cdef class PY_SCIP_LPSOLSTAT: TIMELIMIT = SCIP_LPSOLSTAT_TIMELIMIT ERROR = SCIP_LPSOLSTAT_ERROR -cdef class PY_SCIP_BRANCHDIR: +class PY_SCIP_BRANCHDIR(IntEnum): DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS UPWARDS = SCIP_BRANCHDIR_UPWARDS FIXED = SCIP_BRANCHDIR_FIXED AUTO = SCIP_BRANCHDIR_AUTO -cdef class PY_SCIP_BENDERSENFOTYPE: +class PY_SCIP_BENDERSENFOTYPE(IntEnum): 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(IntEnum): 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(IntEnum): ORIGINAL = SCIP_SOLORIGIN_ORIGINAL ZERO = SCIP_SOLORIGIN_ZERO LPSOL = SCIP_SOLORIGIN_LPSOL diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 85b000c32..740ebec62 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 @@ -1898,269 +1899,250 @@ 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_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): From e2ab7dbfb1171106cc6985630c23b13f1349dfb6 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Sun, 8 Nov 2026 21:25:24 +0100 Subject: [PATCH 2/7] Adapt enum return values, name lookups, typing, and tests --- src/pyscipopt/lp.pxi | 6 +++--- src/pyscipopt/scip.pxi | 48 ++++++++++++++---------------------------- src/pyscipopt/scip.pyi | 48 ++++++++++++++++++++++-------------------- tests/test_event.py | 12 +++-------- tests/test_heur.py | 8 +++++-- tests/test_lp.py | 1 + tests/test_model.py | 6 +++--- tests/test_node.py | 3 ++- tests/test_row_dual.py | 3 ++- tests/test_solution.py | 4 ++-- tests/test_vars.py | 2 +- 11 files changed, 64 insertions(+), 77 deletions(-) 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/scip.pxi b/src/pyscipopt/scip.pxi index 55b7c175e..026851a25 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -158,7 +158,6 @@ class PY_SCIP_STATUS(IntEnum): UNBOUNDED = SCIP_STATUS_UNBOUNDED INFORUNBD = SCIP_STATUS_INFORUNBD -StageNames = {} class PY_SCIP_STAGE(IntEnum): INIT = SCIP_STAGE_INIT PROBLEM = SCIP_STAGE_PROBLEM @@ -175,6 +174,8 @@ class PY_SCIP_STAGE(IntEnum): FREETRANS = SCIP_STAGE_FREETRANS FREE = SCIP_STAGE_FREE +StageNames = {stage.value: stage.name for stage in PY_SCIP_STAGE} + class PY_SCIP_NODETYPE(IntEnum): FOCUSNODE = SCIP_NODETYPE_FOCUSNODE PROBINGNODE = SCIP_NODETYPE_PROBINGNODE @@ -213,7 +214,6 @@ class PY_SCIP_HEURTIMING(IntFlag): DURINGPRESOLLOOP = SCIP_HEURTIMING_DURINGPRESOLLOOP AFTERPROPLOOP = SCIP_HEURTIMING_AFTERPROPLOOP -EventNames = {} class PY_SCIP_EVENTTYPE(IntFlag): DISABLED = SCIP_EVENTTYPE_DISABLED VARADDED = SCIP_EVENTTYPE_VARADDED @@ -272,6 +272,8 @@ class PY_SCIP_EVENTTYPE(IntFlag): ROWCHANGED = SCIP_EVENTTYPE_ROWCHANGED ROWEVENT = SCIP_EVENTTYPE_ROWEVENT +EventNames = {eventtype.value: eventtype.name for eventtype in PY_SCIP_EVENTTYPE.__members__.values()} + class PY_SCIP_LOCKTYPE(IntEnum): MODEL = SCIP_LOCKTYPE_MODEL CONFLICT = SCIP_LOCKTYPE_CONFLICT @@ -394,7 +396,7 @@ cdef class Event: PY_SCIP_EVENTTYPE """ - return SCIPeventGetType(self.event) + return PY_SCIP_EVENTTYPE(SCIPeventGetType(self.event)) def getName(self): """ @@ -405,16 +407,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()) @@ -858,7 +851,7 @@ cdef class Row: PY_SCIP_ROWORIGINTYPE """ - return SCIProwGetOrigintype(self.scip_row) + return PY_SCIP_ROWORIGINTYPE(SCIProwGetOrigintype(self.scip_row)) def getConsOriginConshdlrtype(self): """ @@ -1146,7 +1139,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 """ @@ -1362,7 +1355,7 @@ cdef class Node: PY_SCIP_NODETYPE """ - return SCIPnodeGetType(self.scip_node) + return PY_SCIP_NODETYPE(SCIPnodeGetType(self.scip_node)) def getLowerbound(self): """ @@ -1637,7 +1630,7 @@ cdef class Variable(Expr): ------- PY_SCIP_IMPLINTTYPE """ - return SCIPvarGetImplType(self.scip_var) + return PY_SCIP_IMPLINTTYPE(SCIPvarGetImplType(self.scip_var)) def getStatus(self): """ @@ -4428,7 +4421,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): """ @@ -5442,7 +5435,7 @@ cdef class Model: SCIP_LPSOLSTAT """ - return SCIPgetLPSolstat(self._scip) + return PY_SCIP_LPSOLSTAT(SCIPgetLPSolstat(self._scip)) def constructLP(self): """ @@ -11822,10 +11815,10 @@ cdef class Model: Returns ------- - int + SCIP_STAGE """ - return SCIPgetStage(self._scip) + return PY_SCIP_STAGE(SCIPgetStage(self._scip)) def getStageName(self): """ @@ -11836,16 +11829,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): """ @@ -12928,7 +12912,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 740ebec62..20b22f543 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -316,13 +316,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: ... @@ -548,7 +547,7 @@ 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 @@ -696,7 +695,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( @@ -1065,7 +1063,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,12 +1073,14 @@ class Model: def calcNodeselPriority( self, variable: Variable, branchdir: Incomplete, 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 @@ -1187,12 +1187,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: ... @@ -1287,7 +1287,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]: ... @@ -1298,7 +1298,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: ... @@ -1404,7 +1404,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, @@ -1675,10 +1675,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: ... @@ -1697,12 +1699,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( @@ -1858,7 +1860,7 @@ class Node: def getParentBranchings( self, ) -> tuple[list[Variable], list[float], list[Incomplete]] | None: ... - def getType(self) -> Incomplete: ... + def getType(self) -> PY_SCIP_NODETYPE: ... def isActive(self) -> bool: ... def isPropagatedAgain(self) -> bool: ... def __eq__(self, other: object, /) -> bool: ... @@ -2262,7 +2264,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: ... @@ -2301,7 +2303,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 @@ -2421,7 +2423,7 @@ 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: ... 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 bf2b4dbf2..18a8f6e43 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_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" From 67f4010f29fa0a84e56b1080a70f2a6754b4928e Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Sat, 14 Nov 2026 23:26:19 +0100 Subject: [PATCH 3/7] Complete enum input annotations and add changelog entry --- CHANGELOG.md | 1 + src/pyscipopt/scip.pxi | 6 +++--- src/pyscipopt/scip.pyi | 42 +++++++++++++++++++++++------------------- 3 files changed, 27 insertions(+), 22 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4daaf48c2..c11862174 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,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/scip.pxi b/src/pyscipopt/scip.pxi index 026851a25..8f9c70703 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -10026,7 +10026,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. @@ -10123,7 +10123,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. @@ -10164,7 +10164,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. diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 20b22f543..9dff17189 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -554,12 +554,12 @@ class LP: ) -> 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 @@ -572,9 +572,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: ... @@ -1035,7 +1037,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: ... @@ -1071,7 +1073,7 @@ 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: PY_SCIP_EVENTTYPE, eventhdlr: Eventhdlr @@ -1446,7 +1448,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( @@ -1514,8 +1518,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 @@ -1532,7 +1536,7 @@ class Model: freq: int = 1, freqofs: int = 0, maxdepth: int = -1, - timingmask: Incomplete = ..., + timingmask: PY_SCIP_HEURTIMING = ..., usessubscip: bool = False, ) -> None: ... def includeIISfinder( @@ -1558,7 +1562,7 @@ class Model: desc: str, priority: int, maxrounds: int, - timing: Incomplete = ..., + timing: PY_SCIP_PRESOLTIMING = ..., ) -> None: ... def includePricer( self, @@ -1575,8 +1579,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, @@ -1712,7 +1716,7 @@ class Model: probnumber: int, benders: Benders | None = None, solution: Solution | None = None, - checktype: Incomplete = ..., + checktype: PY_SCIP_BENDERSENFOTYPE = ..., ) -> None: ... def solveBendersSubproblem( self, @@ -2429,12 +2433,12 @@ class Variable(Expr): 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, From d38df708c35c170e25de849ca7256255e3b31a46 Mon Sep 17 00:00:00 2001 From: Joao-Dionisio Date: Sun, 15 Nov 2026 16:07:14 +0000 Subject: [PATCH 4/7] Print SCIP enums by member name on all Python versions --- src/pyscipopt/scip.pxi | 52 ++++++++++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 20 deletions(-) diff --git a/src/pyscipopt/scip.pxi b/src/pyscipopt/scip.pxi index 8f9c70703..4db5b4ca8 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -18,11 +18,23 @@ from posix.stdio cimport fileno from collections.abc import Iterable from itertools import repeat from dataclasses import dataclass -from enum import IntEnum, IntFlag +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" @@ -72,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 -class PY_SCIP_RESULT(IntEnum): +class PY_SCIP_RESULT(_ScipEnum): DIDNOTRUN = SCIP_DIDNOTRUN DELAYED = SCIP_DELAYED DIDNOTFIND = SCIP_DIDNOTFIND @@ -91,13 +103,13 @@ class PY_SCIP_RESULT(IntEnum): SUSPENDED = SCIP_SUSPENDED SUCCESS = SCIP_SUCCESS -class PY_SCIP_PARAMSETTING(IntEnum): +class PY_SCIP_PARAMSETTING(_ScipEnum): DEFAULT = SCIP_PARAMSETTING_DEFAULT AGGRESSIVE = SCIP_PARAMSETTING_AGGRESSIVE FAST = SCIP_PARAMSETTING_FAST OFF = SCIP_PARAMSETTING_OFF -class PY_SCIP_LPPARAM(IntEnum): +class PY_SCIP_LPPARAM(_ScipEnum): FROMSCRATCH = SCIP_LPPAR_FROMSCRATCH FASTMIP = SCIP_LPPAR_FASTMIP SCALING = SCIP_LPPAR_SCALING @@ -119,13 +131,13 @@ class PY_SCIP_LPPARAM(IntEnum): POLISHING = SCIP_LPPAR_POLISHING REFACTOR = SCIP_LPPAR_REFACTOR -class PY_SCIP_BASESTAT(IntEnum): +class PY_SCIP_BASESTAT(_ScipEnum): LOWER = SCIP_BASESTAT_LOWER BASIC = SCIP_BASESTAT_BASIC UPPER = SCIP_BASESTAT_UPPER ZERO = SCIP_BASESTAT_ZERO -class PY_SCIP_PARAMEMPHASIS(IntEnum): +class PY_SCIP_PARAMEMPHASIS(_ScipEnum): DEFAULT = SCIP_PARAMEMPHASIS_DEFAULT CPSOLVER = SCIP_PARAMEMPHASIS_CPSOLVER EASYCIP = SCIP_PARAMEMPHASIS_EASYCIP @@ -139,7 +151,7 @@ class PY_SCIP_PARAMEMPHASIS(IntEnum): NUMERICS = SCIP_PARAMEMPHASIS_NUMERICS BENCHMARK = SCIP_PARAMEMPHASIS_BENCHMARK -class PY_SCIP_STATUS(IntEnum): +class PY_SCIP_STATUS(_ScipEnum): UNKNOWN = SCIP_STATUS_UNKNOWN USERINTERRUPT = SCIP_STATUS_USERINTERRUPT NODELIMIT = SCIP_STATUS_NODELIMIT @@ -158,7 +170,7 @@ class PY_SCIP_STATUS(IntEnum): UNBOUNDED = SCIP_STATUS_UNBOUNDED INFORUNBD = SCIP_STATUS_INFORUNBD -class PY_SCIP_STAGE(IntEnum): +class PY_SCIP_STAGE(_ScipEnum): INIT = SCIP_STAGE_INIT PROBLEM = SCIP_STAGE_PROBLEM TRANSFORMING = SCIP_STAGE_TRANSFORMING @@ -176,7 +188,7 @@ class PY_SCIP_STAGE(IntEnum): StageNames = {stage.value: stage.name for stage in PY_SCIP_STAGE} -class PY_SCIP_NODETYPE(IntEnum): +class PY_SCIP_NODETYPE(_ScipEnum): FOCUSNODE = SCIP_NODETYPE_FOCUSNODE PROBINGNODE = SCIP_NODETYPE_PROBINGNODE SIBLING = SCIP_NODETYPE_SIBLING @@ -189,19 +201,19 @@ class PY_SCIP_NODETYPE(IntEnum): SUBROOT = SCIP_NODETYPE_SUBROOT REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE -class PY_SCIP_PROPTIMING(IntFlag): +class PY_SCIP_PROPTIMING(_ScipFlag): BEFORELP = SCIP_PROPTIMING_BEFORELP DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP AFTERLPLOOP = SCIP_PROPTIMING_AFTERLPLOOP AFTERLPNODE = SCIP_PROPTIMING_AFTERLPNODE -class PY_SCIP_PRESOLTIMING(IntFlag): +class PY_SCIP_PRESOLTIMING(_ScipFlag): NONE = SCIP_PRESOLTIMING_NONE FAST = SCIP_PRESOLTIMING_FAST MEDIUM = SCIP_PRESOLTIMING_MEDIUM EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE -class PY_SCIP_HEURTIMING(IntFlag): +class PY_SCIP_HEURTIMING(_ScipFlag): BEFORENODE = SCIP_HEURTIMING_BEFORENODE DURINGLPLOOP = SCIP_HEURTIMING_DURINGLPLOOP AFTERLPLOOP = SCIP_HEURTIMING_AFTERLPLOOP @@ -214,7 +226,7 @@ class PY_SCIP_HEURTIMING(IntFlag): DURINGPRESOLLOOP = SCIP_HEURTIMING_DURINGPRESOLLOOP AFTERPROPLOOP = SCIP_HEURTIMING_AFTERPROPLOOP -class PY_SCIP_EVENTTYPE(IntFlag): +class PY_SCIP_EVENTTYPE(_ScipFlag): DISABLED = SCIP_EVENTTYPE_DISABLED VARADDED = SCIP_EVENTTYPE_VARADDED VARDELETED = SCIP_EVENTTYPE_VARDELETED @@ -274,16 +286,16 @@ class PY_SCIP_EVENTTYPE(IntFlag): EventNames = {eventtype.value: eventtype.name for eventtype in PY_SCIP_EVENTTYPE.__members__.values()} -class PY_SCIP_LOCKTYPE(IntEnum): +class PY_SCIP_LOCKTYPE(_ScipEnum): MODEL = SCIP_LOCKTYPE_MODEL CONFLICT = SCIP_LOCKTYPE_CONFLICT -class PY_SCIP_IMPLINTTYPE(IntEnum): +class PY_SCIP_IMPLINTTYPE(_ScipEnum): NONE = SCIP_IMPLINTTYPE_NONE WEAK = SCIP_IMPLINTTYPE_WEAK STRONG = SCIP_IMPLINTTYPE_STRONG -class PY_SCIP_LPSOLSTAT(IntEnum): +class PY_SCIP_LPSOLSTAT(_ScipEnum): NOTSOLVED = SCIP_LPSOLSTAT_NOTSOLVED OPTIMAL = SCIP_LPSOLSTAT_OPTIMAL INFEASIBLE = SCIP_LPSOLSTAT_INFEASIBLE @@ -293,25 +305,25 @@ class PY_SCIP_LPSOLSTAT(IntEnum): TIMELIMIT = SCIP_LPSOLSTAT_TIMELIMIT ERROR = SCIP_LPSOLSTAT_ERROR -class PY_SCIP_BRANCHDIR(IntEnum): +class PY_SCIP_BRANCHDIR(_ScipEnum): DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS UPWARDS = SCIP_BRANCHDIR_UPWARDS FIXED = SCIP_BRANCHDIR_FIXED AUTO = SCIP_BRANCHDIR_AUTO -class PY_SCIP_BENDERSENFOTYPE(IntEnum): +class PY_SCIP_BENDERSENFOTYPE(_ScipEnum): LP = SCIP_BENDERSENFOTYPE_LP RELAX = SCIP_BENDERSENFOTYPE_RELAX PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO CHECK = SCIP_BENDERSENFOTYPE_CHECK -class PY_SCIP_ROWORIGINTYPE(IntEnum): +class PY_SCIP_ROWORIGINTYPE(_ScipEnum): UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC CONS = SCIP_ROWORIGINTYPE_CONS SEPA = SCIP_ROWORIGINTYPE_SEPA REOPT = SCIP_ROWORIGINTYPE_REOPT -class PY_SCIP_SOLORIGIN(IntEnum): +class PY_SCIP_SOLORIGIN(_ScipEnum): ORIGINAL = SCIP_SOLORIGIN_ORIGINAL ZERO = SCIP_SOLORIGIN_ZERO LPSOL = SCIP_SOLORIGIN_LPSOL From d28ca9a58501e5a4b2afee0328d5c0f3d1c320cf Mon Sep 17 00:00:00 2001 From: Joao-Dionisio Date: Sun, 15 Nov 2026 16:10:26 +0000 Subject: [PATCH 5/7] Pass enums to plugin callbacks and type their parameters --- src/pyscipopt/benders.pxi | 4 ++-- src/pyscipopt/benderscut.pxi | 2 +- src/pyscipopt/conshdlr.pxi | 10 +++++----- src/pyscipopt/heuristic.pxi | 2 +- src/pyscipopt/presol.pxi | 2 +- src/pyscipopt/propagator.pxi | 6 +++--- src/pyscipopt/scip.pyi | 29 +++++++++++++++++++---------- 7 files changed, 32 insertions(+), 23 deletions(-) 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/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..43e17de3e 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 diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 9dff17189..9c971d66c 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -70,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 @@ -93,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: ... @@ -208,7 +214,7 @@ class Conshdlr: def conslock( self, constraint: Incomplete, - locktype: Incomplete, + locktype: PY_SCIP_LOCKTYPE, nlockspos: Incomplete, nlocksneg: Incomplete, ) -> Incomplete: ... @@ -217,7 +223,7 @@ class Conshdlr: self, constraints: Incomplete, nrounds: Incomplete, - presoltiming: Incomplete, + presoltiming: PY_SCIP_PRESOLTIMING, nnewfixedvars: Incomplete, nnewaggrvars: Incomplete, nnewchgvartypes: Incomplete, @@ -236,7 +242,7 @@ class Conshdlr: constraints: Incomplete, nusefulconss: Incomplete, nmarkedconss: Incomplete, - proptiming: Incomplete, + proptiming: PY_SCIP_PROPTIMING, ) -> Incomplete: ... def consresprop(self) -> Incomplete: ... def conssepalp( @@ -478,7 +484,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: ... @@ -2162,7 +2168,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: ... @@ -2193,7 +2199,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: ... @@ -2202,7 +2208,10 @@ 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, From ac2ef5f12ffbf0d4a7e4d1bd66308fd439caacc6 Mon Sep 17 00:00:00 2001 From: Joao-Dionisio Date: Sun, 15 Nov 2026 16:18:08 +0000 Subject: [PATCH 6/7] Add SCIP_BOUNDTYPE and SCIP_BOUNDCHGTYPE enums --- CHANGELOG.md | 1 + src/pyscipopt/__init__.py | 2 ++ src/pyscipopt/propagator.pxi | 2 +- src/pyscipopt/scip.pxi | 23 +++++++++++++++-------- src/pyscipopt/scip.pyi | 17 +++++++++++++---- tests/test_tree.py | 5 ++++- 6 files changed, 36 insertions(+), 14 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c11862174..a5817ad15 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,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`, returned by `BoundChange.getBoundtype()`, `BoundChange.getBoundchgtype()` and `Node.getParentBranchings()` and passed to `Prop.propresprop()` ### Fixed - Fixed `lotsizing_lazy` example: lock the handler's variables in `conslock` so presolve cannot aggregate them away (#1252) - Dual and Farkas getters for linear, knapsack, and logicor constraints now return zero when presolving has removed them. 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/propagator.pxi b/src/pyscipopt/propagator.pxi index 43e17de3e..e09aa24ab 100644 --- a/src/pyscipopt/propagator.pxi +++ b/src/pyscipopt/propagator.pxi @@ -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 4db5b4ca8..43656ccc4 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -311,6 +311,15 @@ class PY_SCIP_BRANCHDIR(_ScipEnum): FIXED = SCIP_BRANCHDIR_FIXED AUTO = SCIP_BRANCHDIR_AUTO +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 @@ -1229,11 +1238,10 @@ cdef class BoundChange: Returns ------- - int - (0 = branching, 1 = consinfer, 2 = propinfer) + PY_SCIP_BOUNDCHGTYPE """ - return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + return PY_SCIP_BOUNDCHGTYPE(SCIPboundchgGetBoundchgtype(self.scip_boundchg)) def getBoundtype(self): """ @@ -1241,11 +1249,10 @@ cdef class BoundChange: Returns ------- - int - (0 = lower, 1 = upper) + PY_SCIP_BOUNDTYPE """ - return SCIPboundchgGetBoundtype(self.scip_boundchg) + return PY_SCIP_BOUNDTYPE(SCIPboundchgGetBoundtype(self.scip_boundchg)) def isRedundant(self): """ @@ -1474,7 +1481,7 @@ cdef class Node: ------- list of Variable list of float - list of int + list of PY_SCIP_BOUNDTYPE """ cdef int nbranchvars = self.getNParentBranchings() @@ -1489,7 +1496,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) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 9c971d66c..8e7aa127e 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -110,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: ... @@ -1869,7 +1869,7 @@ class Node: def getParent(self) -> Node | None: ... def getParentBranchings( self, - ) -> tuple[list[Variable], list[float], list[Incomplete]] | None: ... + ) -> tuple[list[Variable], list[float], list[PY_SCIP_BOUNDTYPE]] | None: ... def getType(self) -> PY_SCIP_NODETYPE: ... def isActive(self) -> bool: ... def isPropagatedAgain(self) -> bool: ... @@ -1917,6 +1917,15 @@ class PY_SCIP_BENDERSENFOTYPE(IntEnum): PSEUDO = ... RELAX = ... +class PY_SCIP_BOUNDCHGTYPE(IntEnum): + BRANCHING = ... + CONSINFER = ... + PROPINFER = ... + +class PY_SCIP_BOUNDTYPE(IntEnum): + LOWER = ... + UPPER = ... + class PY_SCIP_BRANCHDIR(IntEnum): AUTO = ... DOWNWARDS = ... @@ -2217,7 +2226,7 @@ class Prop: self, confvar: Incomplete, inferinfo: Incomplete, - bdtype: Incomplete, + bdtype: PY_SCIP_BOUNDTYPE, relaxedbd: Incomplete, ) -> Incomplete: ... 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(): From c32ed7388eca731a962de28f9309be0dd54bba75 Mon Sep 17 00:00:00 2001 From: Joao-Dionisio Date: Sun, 15 Nov 2026 16:40:01 +0000 Subject: [PATCH 7/7] Keep possible values in bound type docstrings --- CHANGELOG.md | 2 +- src/pyscipopt/scip.pxi | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a5817ad15..89934a61b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,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`, returned by `BoundChange.getBoundtype()`, `BoundChange.getBoundchgtype()` and `Node.getParentBranchings()` and passed to `Prop.propresprop()` +- Added `SCIP_BOUNDTYPE` and `SCIP_BOUNDCHGTYPE` enums ### Fixed - Fixed `lotsizing_lazy` example: lock the handler's variables in `conslock` so presolve cannot aggregate them away (#1252) - Dual and Farkas getters for linear, knapsack, and logicor constraints now return zero when presolving has removed them. diff --git a/src/pyscipopt/scip.pxi b/src/pyscipopt/scip.pxi index 43656ccc4..442f5e181 100644 --- a/src/pyscipopt/scip.pxi +++ b/src/pyscipopt/scip.pxi @@ -1239,6 +1239,7 @@ cdef class BoundChange: Returns ------- PY_SCIP_BOUNDCHGTYPE + BRANCHING, CONSINFER or PROPINFER """ return PY_SCIP_BOUNDCHGTYPE(SCIPboundchgGetBoundchgtype(self.scip_boundchg)) @@ -1250,6 +1251,7 @@ cdef class BoundChange: Returns ------- PY_SCIP_BOUNDTYPE + LOWER or UPPER """ return PY_SCIP_BOUNDTYPE(SCIPboundchgGetBoundtype(self.scip_boundchg))