PuLP 3.2.1__tar.gz → 3.2.2__tar.gz

{pulp-3.2.1 → pulp-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PuLP
-Version: 3.2.1
+Version: 3.2.2
 Summary: PuLP is an LP modeler written in python. PuLP can generate MPS or LP files and call GLPK, COIN CLP/CBC, CPLEX, and GUROBI to solve linear problems.
 Author: J.S. Roy
 Author-email: "S.A. Mitchell" <pulp@stuartmitchell.com>, Franco Peschiera <pchtsp@gmail.com>
@@ -19,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 Provides-Extra: open-py
-Requires-Dist: cylp; extra == "open-py"
+Requires-Dist: cylp; sys_platform != "win32" and extra == "open-py"
 Requires-Dist: highspy; extra == "open-py"
 Requires-Dist: pyscipopt; extra == "open-py"
 Provides-Extra: public-py
@@ -153,8 +153,8 @@ To build, run the following in a terminal window, in the PuLP root directory
 
 ::
 
-    cd pulp
-    python -m pip install -r requirements-dev.txt
+    python3 -m pip install --upgrade pip
+    pip install --group=dev .
     cd doc
     make html
 

{pulp-3.2.1 → pulp-3.2.2}/PuLP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PuLP
-Version: 3.2.1
+Version: 3.2.2
 Summary: PuLP is an LP modeler written in python. PuLP can generate MPS or LP files and call GLPK, COIN CLP/CBC, CPLEX, and GUROBI to solve linear problems.
 Author: J.S. Roy
 Author-email: "S.A. Mitchell" <pulp@stuartmitchell.com>, Franco Peschiera <pchtsp@gmail.com>
@@ -19,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 Provides-Extra: open-py
-Requires-Dist: cylp; extra == "open-py"
+Requires-Dist: cylp; sys_platform != "win32" and extra == "open-py"
 Requires-Dist: highspy; extra == "open-py"
 Requires-Dist: pyscipopt; extra == "open-py"
 Provides-Extra: public-py
@@ -153,8 +153,8 @@ To build, run the following in a terminal window, in the PuLP root directory
 
 ::
 
-    cd pulp
-    python -m pip install -r requirements-dev.txt
+    python3 -m pip install --upgrade pip
+    pip install --group=dev .
     cd doc
     make html
 

{pulp-3.2.1 → pulp-3.2.2}/PuLP.egg-info/requires.txt

@@ -1,9 +1,11 @@
 
 [open_py]
-cylp
 highspy
 pyscipopt
 
+[open_py:sys_platform != "win32"]
+cylp
+
 [public_py]
 gurobipy
 coptpy

{pulp-3.2.1 → pulp-3.2.2}/README.rst

@@ -124,8 +124,8 @@ To build, run the following in a terminal window, in the PuLP root directory
 
 ::
 
-    cd pulp
-    python -m pip install -r requirements-dev.txt
+    python3 -m pip install --upgrade pip
+    pip install --group=dev .
     cd doc
     make html
 

{pulp-3.2.1 → pulp-3.2.2}/pulp/apis/__init__.py

@@ -1,19 +1,19 @@
-from typing import Dict, Optional, Type, Union
-
-from .choco_api import *
-from .coin_api import *
-from .copt_api import *
-from .core import *
-from .cplex_api import *
-from .glpk_api import *
-from .gurobi_api import *
-from .highs_api import *
-from .mipcl_api import *
-from .mosek_api import *
-from .sas_api import *
-from .scip_api import *
-from .xpress_api import *
-from .cuopt_api import *
+from typing import Dict, Optional, Type, Union, List
+import json
+from .choco_api import CHOCO_CMD
+from .coin_api import CYLP, PULP_CBC_CMD, COIN_CMD, COINMP_DLL, YAPOSIB
+from .copt_api import COPT, COPT_DLL, COPT_CMD
+from .core import LpSolver, LpSolver_CMD, PulpSolverError
+from .cplex_api import CPLEX_PY, CPLEX_CMD, CPLEX
+from .glpk_api import GLPK_CMD, PYGLPK, GLPK
+from .gurobi_api import GUROBI, GUROBI_CMD
+from .highs_api import HiGHS, HiGHS_CMD
+from .mipcl_api import MIPCL_CMD
+from .mosek_api import MOSEK
+from .sas_api import SAS94, SASCAS, SASsolver
+from .scip_api import SCIP, SCIP_CMD, SCIP_PY, FSCIP_CMD, FSCIP
+from .xpress_api import XPRESS_CMD, XPRESS_PY, XPRESS
+from .cuopt_api import CUOPT
 
 _all_solvers: List[Type[LpSolver]] = [
     CYLP,
@@ -45,8 +45,6 @@ _all_solvers: List[Type[LpSolver]] = [
     CUOPT,
 ]
 
-import json
-
 LpSolverDefault: Optional[Union[PULP_CBC_CMD, GLPK_CMD, COIN_CMD]] = None
 # Default solver selection
 if PULP_CBC_CMD().available():

{pulp-3.2.1 → pulp-3.2.2}/pulp/apis/cplex_api.py

@@ -1,5 +1,6 @@
 import os
 import warnings
+from typing import Iterable, Optional
 
 from .. import constants
 from .core import LpSolver, LpSolver_CMD, PulpSolverError, clock, log, subprocess
@@ -252,7 +253,7 @@ class CPLEX_PY(LpSolver):
     name = "CPLEX_PY"
     try:
         global cplex
-        import cplex  # type: ignore[import-not-found]
+        import cplex  # type: ignore[import-not-found, import-untyped, unused-ignore]
     except Exception as e:
         err = e
         """The CPLEX LP/MIP solver from python. Something went wrong!!!!"""
@@ -276,6 +277,7 @@ class CPLEX_PY(LpSolver):
             warmStart=False,
             logPath=None,
             threads=None,
+            **solverParams,
         ):
             """
             :param bool mip: if False, assume LP even if integer variables
@@ -285,6 +287,15 @@ class CPLEX_PY(LpSolver):
             :param bool warmStart: if True, the solver will use the current value of variables as a start
             :param str logPath: path to the log file
             :param int threads: number of threads to be used by CPLEX to solve a problem (default None uses all available)
+
+            :param dict solverParams: Additional parameters to set in the CPLEX solver.
+
+            Parameters should use dot notation as specified in the CPLEX documentation.
+            The 'parameters.' prefix is optional. For example:
+
+                  * parameters.advance (or advance)
+                  * parameters.barrier.algorithm (or barrier.algorithm)
+                  * parameters.mip.strategy.probe (or mip.strategy.probe)
             """
 
             LpSolver.__init__(
@@ -297,22 +308,25 @@ class CPLEX_PY(LpSolver):
                 logPath=logPath,
                 threads=threads,
             )
+            self.solverParams = solverParams
 
         def available(self):
             """True if the solver is available"""
             return True
 
-        def actualSolve(self, lp, callback=None):  # type: ignore[misc]
+        def actualSolve(self, lp, callback: Optional[Iterable[type[cplex.callbacks.Callback]]] = None):  # type: ignore[misc]
             """
             Solve a well formulated lp problem
 
             creates a cplex model, variables and constraints and attaches
             them to the lp model which it then solves
+
+            :param callback: Optional list of CPLEX callback classes to register during solve
             """
             self.buildSolverModel(lp)
             # set the initial solution
             log.debug("Solve the Model using cplex")
-            self.callSolver(lp)
+            self.callSolver(lp, callback=callback)
             # get the solution information
             solutionStatus = self.findSolutionValues(lp)
             for var in lp._variables:
@@ -430,6 +444,47 @@ class CPLEX_PY(LpSolver):
                 self.solverModel.MIP_starts.add(
                     cplex.SparsePair(ind=ind, val=val), effort, "1"
                 )
+            for param, value in self.solverParams.items():
+                self.set_param(param, value)
+
+        def set_param(self, name: str, value):
+            """
+            Sets a parameter value using its name.
+            """
+            param = self.search_param(name=name)
+            param.set(value)
+
+        def get_param(self, name: str):
+            """
+            Returns the value of a named parameter by searching within the instance's parameters.
+            """
+            param = self.search_param(name=name)
+            return param.get()
+
+        def search_param(self, name: str):
+            """
+            Searches for a solver model parameter by its name and returns the corresponding attribute.
+
+            The method takes a parameter name string, processes it to remove the "parameters." prefix
+            and splits it by periods to traverse the attribute hierarchy of the solver model's parameters.
+            """
+            name = name.replace("parameters.", "")
+            param = self.solverModel.parameters
+            for attr in name.split("."):
+                param = getattr(param, attr)
+            return param
+
+        def get_all_params(self):
+            """
+            Returns all parameters from the solver model.
+            """
+            return self.solverModel.parameters.get_all()
+
+        def get_changed_params(self):
+            """
+            Returns the parameters that have been changed in the solver model.
+            """
+            return self.solverModel.parameters.get_changed()
 
         def setlogfile(self, fileobj):
             """
@@ -458,9 +513,21 @@ class CPLEX_PY(LpSolver):
             """
             self.solverModel.parameters.timelimit.set(timeLimit)
 
-        def callSolver(self, isMIP):
-            """Solves the problem with cplex"""
+        def callSolver(
+            self,
+            isMIP,
+            callback: Optional[Iterable[type[cplex.callbacks.Callback]]] = None,
+        ):
+            """
+            Solves the problem with cplex
+
+
+            :param callback: Optional list of CPLEX callback classes to register during solve
+            """
             # solve the problem
+            if callback is not None:
+                for call in callback:
+                    self.solverModel.register_callback(call)
             self.solveTime = -clock()
             self.solverModel.solve()
             self.solveTime += clock()

{pulp-3.2.1 → pulp-3.2.2}/pulp/mps_lp.py

@@ -312,9 +312,9 @@ def writeMPS(
     if mpsSense != lp.sense:
         n = cobj.name
         cobj = -cobj
-        cobj.name = n  # type: ignore[union-attr]
+        cobj.name = n
     if rename:
-        constrNames, varNames, cobj.name = lp.normalisedNames()  # type: ignore[union-attr]
+        constrNames, varNames, cobj.name = lp.normalisedNames()
         # No need to call self.variables() again, we have just filled self._variables:
         vs = lp._variables
     else:
@@ -324,7 +324,7 @@ def writeMPS(
     model_name = lp.name
     if rename:
         model_name = "MODEL"
-    objName = cobj.name  # type: ignore[union-attr]
+    objName = cobj.name
     if not objName:
         objName = "OBJ"
 
@@ -346,7 +346,7 @@ def writeMPS(
     for v in vs:
         name = varNames[v.name]
         columns_lines.extend(
-            writeMPSColumnLines(coefs[name], v, mip, name, cobj, objName)  # type: ignore[arg-type]
+            writeMPSColumnLines(coefs[name], v, mip, name, cobj, objName)
         )
 
     # right hand side
@@ -382,7 +382,7 @@ def writeMPS(
     if not rename:
         return vs
     else:
-        return vs, varNames, constrNames, cobj.name  # type: ignore[union-attr]
+        return vs, varNames, constrNames, cobj.name
 
 
 def writeMPSColumnLines(

{pulp-3.2.1 → pulp-3.2.2}/pulp/pulp.py

@@ -1,6 +1,5 @@
 #! /usr/bin/env python
 # PuLP : Python LP Modeler
-from __future__ import annotations
 
 # Copyright (c) 2002-2005, Jean-Sebastien Roy (js@jeannot.org)
 # Modifications Copyright (c) 2007- Stuart Anthony Mitchell (s.mitchell@auckland.ac.nz)
@@ -25,6 +24,7 @@ from __future__ import annotations
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+
 """
 PuLP is an linear and mixed integer programming modeler written in Python.
 
@@ -123,12 +123,14 @@ References
 
 """
 
+from __future__ import annotations
+
 from collections import Counter
 import sys
 import warnings
 import math
 from time import time
-from typing import Any, Literal
+from typing import Any, Literal, Optional
 
 from .apis import LpSolverDefault, PULP_CBC_CMD
 from .apis.core import clock
@@ -257,8 +259,21 @@ class LpVariable(LpElement):
         existence in the objective function and constraints
     """
 
+    varValue: Optional[float]
+    dj: Optional[float]
+    lowBound: Optional[float]
+    upBound: Optional[float]
+    cat: str
+    _lowbound_original: Optional[float]
+    _upbound_original: Optional[float]
+
     def __init__(
-        self, name, lowBound=None, upBound=None, cat=const.LpContinuous, e=None
+        self,
+        name: str,
+        lowBound: Optional[float] = None,
+        upBound: Optional[float] = None,
+        cat: str = const.LpContinuous,
+        e=None,
     ):
         LpElement.__init__(self, name)
         self._lowbound_original = self.lowBound = lowBound
@@ -270,6 +285,20 @@ class LpVariable(LpElement):
             self._lowbound_original = self.lowBound = 0
             self._upbound_original = self.upBound = 1
             self.cat = const.LpInteger
+        if self.lowBound is not None:
+            if not math.isfinite(self.lowBound):
+                raise const.PulpError(
+                    "The lower bound of a variable must be finite, got {}".format(
+                        self.lowBound
+                    )
+                )
+        if self.upBound is not None:
+            if not math.isfinite(self.upBound):
+                raise const.PulpError(
+                    "The upper bound of a variable must be finite, got {}".format(
+                        self.upBound
+                    )
+                )
         # Code to add a variable to constraints for column based
         # modelling.
         if e:
@@ -501,7 +530,7 @@ class LpVariable(LpElement):
             ):
                 self.varValue = self.upBound
             elif (
-                self.lowBound != None
+                self.lowBound is not None
                 and self.varValue < self.lowBound
                 and self.varValue >= self.lowBound - eps
             ):
@@ -515,7 +544,7 @@ class LpVariable(LpElement):
     def roundedValue(self, eps=1e-5):
         if (
             self.cat == const.LpInteger
-            and self.varValue != None
+            and self.varValue is not None
             and abs(self.varValue - round(self.varValue)) <= eps
         ):
             return round(self.varValue)
@@ -523,10 +552,10 @@ class LpVariable(LpElement):
             return self.varValue
 
     def valueOrDefault(self):
-        if self.varValue != None:
+        if self.varValue is not None:
             return self.varValue
-        elif self.lowBound != None:
-            if self.upBound != None:
+        elif self.lowBound is not None:
+            if self.upBound is not None:
                 if 0 >= self.lowBound and 0 <= self.upBound:
                     return 0
                 else:
@@ -539,7 +568,7 @@ class LpVariable(LpElement):
                     return 0
                 else:
                     return self.lowBound
-        elif self.upBound != None:
+        elif self.upBound is not None:
             if 0 <= self.upBound:
                 return 0
             else:
@@ -564,11 +593,11 @@ class LpVariable(LpElement):
         return True
 
     def infeasibilityGap(self, mip=1):
-        if self.varValue == None:
+        if self.varValue is None:
             raise ValueError("variable value is None")
-        if self.upBound != None and self.varValue > self.upBound:
+        if self.upBound is not None and self.varValue > self.upBound:
             return self.varValue - self.upBound
-        if self.lowBound != None and self.varValue < self.lowBound:
+        if self.lowBound is not None and self.varValue < self.lowBound:
             return self.varValue - self.lowBound
         if (
             mip
@@ -600,7 +629,7 @@ class LpVariable(LpElement):
             return self.name + " free"
         if self.isConstant():
             return self.name + f" = {self.lowBound:.12g}"
-        if self.lowBound == None:
+        if self.lowBound is None:
             s = "-inf <= "
         # Note: XPRESS and CPLEX do not interpret integer variables without
         # explicit bounds
@@ -731,6 +760,11 @@ class LpAffineExpression(dict):
         # TODO remove isinstance usage
         if e is None:
             e = {}
+        # maybe check for constant
+        if not math.isfinite(constant):
+            raise const.PulpError(
+                f"Invalid constant value: {constant}. It must be a finite number."
+            )
         if isinstance(e, (LpAffineExpression, LpConstraint)):
             # Will not copy the name
             self.constant = e.constant  # type: ignore[has-type]
@@ -832,9 +866,7 @@ class LpAffineExpression(dict):
         return result
 
     def __repr__(self, override_constant: float | None = None):
-        constant = constant = (
-            self.constant if override_constant is None else override_constant
-        )
+        constant = self.constant if override_constant is None else override_constant
         l = [str(self[v]) + "*" + str(v) for v in self.sorted_keys()]
         l.append(str(constant))
         s = " + ".join(l)
@@ -1090,6 +1122,8 @@ class LpConstraint:
         self.name = name
         self.constant: float = self.expr.constant  # type: ignore[annotation-unchecked]
         if rhs is not None:
+            if not math.isfinite(rhs):
+                raise const.PulpError("Cannot set constraint RHS to NaN/inf values")
             self.constant -= rhs
         self.sense = sense
         self.pi = None
@@ -1893,7 +1927,7 @@ class LpProblem:
 
     def coefficients(self, translation=None):
         coefs = []
-        if translation == None:
+        if translation is None:
             for c in self.constraints:
                 cst = self.constraints[c]
                 coefs.extend([(v.name, c, cst[v]) for v in cst])

{pulp-3.2.1 → pulp-3.2.2}/pulp/tests/test_examples.py

@@ -10,7 +10,10 @@ class Examples_DocsTests(unittest.TestCase):
 
         this_file = os.path.realpath(__file__)
         parent_dir = os.path.dirname(this_file)
-        files = os.listdir(os.path.join(parent_dir, examples_dir))
+        try:
+            files = os.listdir(os.path.join(parent_dir, examples_dir))
+        except FileNotFoundError:
+            raise unittest.SkipTest("Examples not found")
         TMP_dir = "_tmp/"
         if not os.path.exists(TMP_dir):
             os.mkdir(TMP_dir)

{pulp-3.2.1 → pulp-3.2.2}/pulp/tests/test_gurobipy_env.py

@@ -55,11 +55,11 @@ class GurobiEnvTests(unittest.TestCase):
             solver.close()
         check_dummy_env()
 
-    @unittest.skipUnless(
-        is_single_use_license(),
-        "this test is only expected to pass with a single-use license",
-    )
     def test_gp_env_no_close(self):
+        if not is_single_use_license():
+            raise unittest.SkipTest(
+                "this test is only expected to pass with a single-use license"
+            )
         # Not closing results in an error for a single use license.
         with gp.Env(params=self.env_options) as env:
             prob = generate_lp()
@@ -82,16 +82,16 @@ class GurobiEnvTests(unittest.TestCase):
 
         check_dummy_env()
 
-    @unittest.skipUnless(
-        is_single_use_license(),
-        "this test is only expected to pass with a single-use license",
-    )
     def test_backward_compatibility(self):
         """
         Backward compatibility check as previously the environment was not being
         freed. On a single-use license this passes (fails to initialise a dummy
         env).
         """
+        if not is_single_use_license():
+            raise unittest.SkipTest(
+                "this test is only expected to pass with a single-use license"
+            )
         solver = GUROBI(msg=False, **self.options)
         prob = generate_lp()
         prob.solve(solver)
@@ -122,16 +122,16 @@ class GurobiEnvTests(unittest.TestCase):
         solver2.close()
         check_dummy_env()
 
-    @unittest.skipUnless(
-        is_single_use_license(),
-        "this test is only expected to pass with a single-use license",
-    )
     def test_leak(self):
         """
         Check that we cannot initialise environments after a memory leak. On a
         single-use license this passes (fails to initialise a dummy env with a
         memory leak).
         """
+        if not is_single_use_license():
+            raise unittest.SkipTest(
+                "this test is only expected to pass with a single-use license"
+            )
         solver = GUROBI(msg=False, **self.options)
         prob = generate_lp()
         prob.solve(solver)