PuLP 3.2.2__tar.gz → 3.3.0__tar.gz

pulp-3.3.0/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2002-2005, Jean-Sebastien Roy
+Modifications Copyright (c) 2007- Stuart Anthony Mitchell
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

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

@@ -1,31 +1,47 @@
 Metadata-Version: 2.4
 Name: PuLP
-Version: 3.2.2
+Version: 3.3.0
 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>
 Maintainer-email: Franco Peschiera <pchtsp@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: source, https://github.com/coin-or/pulp
 Project-URL: download, https://github.com/coin-or/pulp/archive/master.zip
 Keywords: Optimization,Linear Programming,Operations Research
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
+License-File: LICENSE
 Provides-Extra: open-py
-Requires-Dist: cylp; sys_platform != "win32" and extra == "open-py"
+Requires-Dist: cylp; extra == "open-py"
 Requires-Dist: highspy; extra == "open-py"
 Requires-Dist: pyscipopt; extra == "open-py"
 Provides-Extra: public-py
 Requires-Dist: gurobipy; extra == "public-py"
 Requires-Dist: coptpy; extra == "public-py"
 Requires-Dist: xpress; extra == "public-py"
+Requires-Dist: cplex; (sys_platform != "darwin" or python_full_version < "3.12") and extra == "public-py"
+Provides-Extra: highs
+Requires-Dist: highspy; extra == "highs"
+Provides-Extra: scip
+Requires-Dist: pyscipopt; extra == "scip"
+Provides-Extra: gurobi
+Requires-Dist: gurobipy; extra == "gurobi"
+Provides-Extra: xpress
+Requires-Dist: xpress; extra == "xpress"
+Provides-Extra: copt
+Requires-Dist: coptpy; extra == "copt"
+Provides-Extra: cplex
+Requires-Dist: cplex; (sys_platform != "darwin" or python_full_version < "3.12") and extra == "cplex"
+Provides-Extra: mosek
+Requires-Dist: mosek; extra == "mosek"
+Dynamic: license-file
 
 pulp
 **************************
@@ -56,6 +72,25 @@ The easiest way to install PuLP is with ``pip``. If ``pip`` is available on your
 
 Otherwise follow the download instructions on the `PyPi page <https://pypi.python.org/pypi/PuLP>`_.
 
+Installing solvers
+----------------------
+
+PuLP can use a variety of solvers. The default solver is the COIN-OR CBC solver, which is included with PuLP. If you want to use other solvers, PuLP offers a quick way to install most solvers via their pypi package (some require a commercial license for running or for running large models)::
+
+    python -m pip install pulp[gurobi]
+    python -m pip install pulp[cplex]
+    python -m pip install pulp[xpress]
+    python -m pip install pulp[scip]
+    python -m pip install pulp[highs]
+    python -m pip install pulp[copt]
+    python -m pip install pulp[mosek]
+    python -m pip install pulp[cylp]
+
+
+If you want to install all open source solvers (scip, highs, cylp), you can use the shortcut::
+    python -m pip install pulp[open_py]
+
+For more information on how to install solvers, see the `guide on configuring solvers <https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html>`_.
 
 Quickstart 
 ===============

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

@@ -1,31 +1,47 @@
 Metadata-Version: 2.4
 Name: PuLP
-Version: 3.2.2
+Version: 3.3.0
 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>
 Maintainer-email: Franco Peschiera <pchtsp@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: source, https://github.com/coin-or/pulp
 Project-URL: download, https://github.com/coin-or/pulp/archive/master.zip
 Keywords: Optimization,Linear Programming,Operations Research
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
+License-File: LICENSE
 Provides-Extra: open-py
-Requires-Dist: cylp; sys_platform != "win32" and extra == "open-py"
+Requires-Dist: cylp; extra == "open-py"
 Requires-Dist: highspy; extra == "open-py"
 Requires-Dist: pyscipopt; extra == "open-py"
 Provides-Extra: public-py
 Requires-Dist: gurobipy; extra == "public-py"
 Requires-Dist: coptpy; extra == "public-py"
 Requires-Dist: xpress; extra == "public-py"
+Requires-Dist: cplex; (sys_platform != "darwin" or python_full_version < "3.12") and extra == "public-py"
+Provides-Extra: highs
+Requires-Dist: highspy; extra == "highs"
+Provides-Extra: scip
+Requires-Dist: pyscipopt; extra == "scip"
+Provides-Extra: gurobi
+Requires-Dist: gurobipy; extra == "gurobi"
+Provides-Extra: xpress
+Requires-Dist: xpress; extra == "xpress"
+Provides-Extra: copt
+Requires-Dist: coptpy; extra == "copt"
+Provides-Extra: cplex
+Requires-Dist: cplex; (sys_platform != "darwin" or python_full_version < "3.12") and extra == "cplex"
+Provides-Extra: mosek
+Requires-Dist: mosek; extra == "mosek"
+Dynamic: license-file
 
 pulp
 **************************
@@ -56,6 +72,25 @@ The easiest way to install PuLP is with ``pip``. If ``pip`` is available on your
 
 Otherwise follow the download instructions on the `PyPi page <https://pypi.python.org/pypi/PuLP>`_.
 
+Installing solvers
+----------------------
+
+PuLP can use a variety of solvers. The default solver is the COIN-OR CBC solver, which is included with PuLP. If you want to use other solvers, PuLP offers a quick way to install most solvers via their pypi package (some require a commercial license for running or for running large models)::
+
+    python -m pip install pulp[gurobi]
+    python -m pip install pulp[cplex]
+    python -m pip install pulp[xpress]
+    python -m pip install pulp[scip]
+    python -m pip install pulp[highs]
+    python -m pip install pulp[copt]
+    python -m pip install pulp[mosek]
+    python -m pip install pulp[cylp]
+
+
+If you want to install all open source solvers (scip, highs, cylp), you can use the shortcut::
+    python -m pip install pulp[open_py]
+
+For more information on how to install solvers, see the `guide on configuring solvers <https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html>`_.
 
 Quickstart 
 ===============

{pulp-3.2.2 → pulp-3.3.0}/PuLP.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.rst
 pyproject.toml
 PuLP.egg-info/PKG-INFO

pulp-3.3.0/PuLP.egg-info/requires.txt

@@ -0,0 +1,36 @@
+
+[copt]
+coptpy
+
+[cplex]
+
+[cplex:sys_platform != "darwin" or python_full_version < "3.12"]
+cplex
+
+[gurobi]
+gurobipy
+
+[highs]
+highspy
+
+[mosek]
+mosek
+
+[open_py]
+cylp
+highspy
+pyscipopt
+
+[public_py]
+gurobipy
+coptpy
+xpress
+
+[public_py:sys_platform != "darwin" or python_full_version < "3.12"]
+cplex
+
+[scip]
+pyscipopt
+
+[xpress]
+xpress

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

@@ -27,6 +27,25 @@ The easiest way to install PuLP is with ``pip``. If ``pip`` is available on your
 
 Otherwise follow the download instructions on the `PyPi page <https://pypi.python.org/pypi/PuLP>`_.
 
+Installing solvers
+----------------------
+
+PuLP can use a variety of solvers. The default solver is the COIN-OR CBC solver, which is included with PuLP. If you want to use other solvers, PuLP offers a quick way to install most solvers via their pypi package (some require a commercial license for running or for running large models)::
+
+    python -m pip install pulp[gurobi]
+    python -m pip install pulp[cplex]
+    python -m pip install pulp[xpress]
+    python -m pip install pulp[scip]
+    python -m pip install pulp[highs]
+    python -m pip install pulp[copt]
+    python -m pip install pulp[mosek]
+    python -m pip install pulp[cylp]
+
+
+If you want to install all open source solvers (scip, highs, cylp), you can use the shortcut::
+    python -m pip install pulp[open_py]
+
+For more information on how to install solvers, see the `guide on configuring solvers <https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html>`_.
 
 Quickstart 
 ===============

{pulp-3.2.2 → pulp-3.3.0}/pulp/__init__.py

@@ -35,7 +35,6 @@ from .pulp import *
 from .apis import *
 from .utilities import *
 from .constants import *
-from .tests import pulpTestAll
 
 __doc__ = pulp.__doc__  # type: ignore[name-defined]
 __version__ = VERSION

{pulp-3.2.2 → pulp-3.3.0}/pulp/apis/coin_api.py

@@ -108,6 +108,10 @@ class COIN_CMD(LpSolver_CMD):
         :param str timeMode: "elapsed": count wall-time to timeLimit; "cpu": count cpu-time
         :param int maxNodes: max number of nodes during branching. Stops the solving when reached.
         """
+        if warmStart and not keepFiles and operating_system == "win":
+            warnings.warn(
+                "When using CBC on Windows, warmStart requires keepFiles=True."
+            )
 
         LpSolver_CMD.__init__(
             self,

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

@@ -240,6 +240,21 @@ class CPLEX_CMD(LpSolver_CMD):
         return True
 
 
+def check_solverModel(func):
+    """
+    Decorator that checks if the solverModel is initialized.
+
+    :raises PulpSolverError: If the ``solverModel`` attribute is not initialized
+    """
+
+    def wrapper(self, *args, **kwargs):
+        if self.solverModel is None:
+            raise PulpSolverError("solverModel not initialized")
+        return func(self, *args, **kwargs)
+
+    return wrapper
+
+
 class CPLEX_PY(LpSolver):
     """
     The CPLEX LP/MIP solver (via a Python Binding)
@@ -308,7 +323,8 @@ class CPLEX_PY(LpSolver):
                 logPath=logPath,
                 threads=threads,
             )
-            self.solverParams = solverParams
+            self.solver_params = solverParams
+            self.solverModel = None
 
         def available(self):
             """True if the solver is available"""
@@ -444,7 +460,7 @@ class CPLEX_PY(LpSolver):
                 self.solverModel.MIP_starts.add(
                     cplex.SparsePair(ind=ind, val=val), effort, "1"
                 )
-            for param, value in self.solverParams.items():
+            for param, value in self.solver_params.items():
                 self.set_param(param, value)
 
         def set_param(self, name: str, value):
@@ -461,6 +477,7 @@ class CPLEX_PY(LpSolver):
             param = self.search_param(name=name)
             return param.get()
 
+        @check_solverModel
         def search_param(self, name: str):
             """
             Searches for a solver model parameter by its name and returns the corresponding attribute.
@@ -474,12 +491,14 @@ class CPLEX_PY(LpSolver):
                 param = getattr(param, attr)
             return param
 
+        @check_solverModel
         def get_all_params(self):
             """
             Returns all parameters from the solver model.
             """
             return self.solverModel.parameters.get_all()
 
+        @check_solverModel
         def get_changed_params(self):
             """
             Returns the parameters that have been changed in the solver model.
@@ -515,7 +534,7 @@ class CPLEX_PY(LpSolver):
 
         def callSolver(
             self,
-            isMIP,
+            isMIP: bool,
             callback: Optional[Iterable[type[cplex.callbacks.Callback]]] = None,
         ):
             """

{pulp-3.2.2 → pulp-3.3.0}/pulp/apis/cuopt_api.py

@@ -155,6 +155,8 @@ class CUOPT(LpSolver):
             settings = solver_settings.SolverSettings()
             settings.set_parameter("infeasibility_detection", True)
             settings.set_parameter("log_to_console", self.msg)
+            if log_file:
+                settings.set_parameter("log_file", log_file)
             if self.timeLimit:
                 settings.set_parameter("time_limit", self.timeLimit)
             for key, value in self.solver_params.items():
@@ -163,8 +165,7 @@ class CUOPT(LpSolver):
             gapRel = self.optionsDict.get("gapRel")
             if gapRel:
                 settings.set_parameter("relative_gap_tolerance", gapRel)
-
-            solution = solver.Solve(lp.solverModel, settings, log_file)
+            solution = solver.Solve(lp.solverModel, settings)
 
             self.solveTime += clock()
             return solution
@@ -231,6 +232,7 @@ class CUOPT(LpSolver):
             lp.solverModel.set_row_types(np.array(sense))
 
             lp.solverModel.set_objective_coefficients(np.array(obj_coeff))
+            lp.solverModel.set_objective_offset(lp.objective.constant)
 
         def actualSolve(self, lp, callback=None):
             """

{pulp-3.2.2 → pulp-3.3.0}/pulp/apis/xpress_api.py

@@ -426,14 +426,30 @@ class XPRESS_PY(LpSolver):
     def findSolutionValues(self, lp):
         try:
             model = lp.solverModel
-            # Collect results
+
+            # Build ordered lists of solver vars/cons for new API
+            # PuLP stores Xpress handles in v._xprs / c._xprs; index 1 is the handle.
+            xpress_vars = []
+            for v in lp.variables():
+                h = (
+                    v._xprs[1]
+                    if isinstance(v._xprs, (list, tuple)) and len(v._xprs) > 1
+                    else v._xprs
+                )
+                xpress_vars.append((v, h))
+
+            xpress_cons = []
+            for n, c in lp.constraints.items():
+                h = (
+                    c._xprs[1]
+                    if isinstance(c._xprs, (list, tuple)) and len(c._xprs) > 1
+                    else c._xprs
+                )
+                xpress_cons.append((n, c, h))
+
             if _ismip(lp) and self.mip:
-                # Solved as MIP
-                x, slacks, duals, djs = [], [], None, None
-                try:
-                    model.getmipsol(x, slacks)
-                except:
-                    x, slacks = None, None
+                # ------- MIP branch -------
+                vals = slacks = duals = djs = None
                 statusmap = {
                     0: constants.LpStatusUndefined,  # XPRS_MIP_NOT_LOADED
                     1: constants.LpStatusUndefined,  # XPRS_MIP_LP_NOT_OPTIMAL
@@ -445,14 +461,35 @@ class XPRESS_PY(LpSolver):
                     7: constants.LpStatusUndefined,  # XPRS_MIP_UNBOUNDED
                 }
                 statuskey = "mipstatus"
-            else:
-                # Solved as continuous
-                x, slacks, duals, djs = [], [], [], []
+
+                # New API first
                 try:
-                    model.getlpsol(x, slacks, duals, djs)
-                except:
-                    # No solution available
-                    x, slacks, duals, djs = None, None, None, None
+                    var_vals = model.getSolution([h for _, h in xpress_vars])
+                    slacks = (
+                        model.getSlacks([h for _, _, h in xpress_cons])
+                        if xpress_cons
+                        else None
+                    )
+                    vals = var_vals
+                except Exception as e:
+                    # Fallback to deprecated API (avoids DeprecationWarning only if not hit)
+                    try:
+                        print(e)
+                        x_list, s_list = [], []
+                        model.getmipsol(x_list, s_list)
+                        vals, slacks = (
+                            x_list if x_list else None,
+                            s_list if s_list else None,
+                        )
+                    except Exception:
+                        vals = slacks = None
+
+                duals = None
+                djs = None
+
+            else:
+                # ------- LP (continuous) branch -------
+                vals = slacks = duals = djs = None
                 statusmap = {
                     0: constants.LpStatusNotSolved,  # XPRS_LP_UNSTARTED
                     1: constants.LpStatusOptimal,  # XPRS_LP_OPTIMAL
@@ -465,24 +502,54 @@ class XPRESS_PY(LpSolver):
                     8: constants.LpStatusUndefined,  # XPRS_LP_NONCONVEX
                 }
                 statuskey = "lpstatus"
-            if x is not None:
-                lp.assignVarsVals({v.name: x[v._xprs[0]] for v in lp.variables()})
+
+                # New API first
+                try:
+                    var_vals = model.getSolution([h for _, h in xpress_vars])
+                    vals = var_vals
+                    slacks = (
+                        model.getSlacks([h for _, _, h in xpress_cons])
+                        if xpress_cons
+                        else None
+                    )
+                    duals = (
+                        model.getDuals([h for _, _, h in xpress_cons])
+                        if xpress_cons
+                        else None
+                    )
+                    djs = model.getRedCosts([h for _, h in xpress_vars])
+                except Exception:
+                    # Fallback to deprecated API
+                    try:
+                        x_list, s_list, d_list, rc_list = [], [], [], []
+                        model.getlpsol(x_list, s_list, d_list, rc_list)
+                        vals = x_list if x_list else None
+                        slacks = s_list if s_list else None
+                        duals = d_list if d_list else None
+                        djs = rc_list if rc_list else None
+                    except Exception:
+                        vals = slacks = duals = djs = None
+
+            # ---- write back into PuLP structures ----
+            if vals is not None:
+                lp.assignVarsVals(
+                    {v.name: val for (v, _), val in zip(xpress_vars, vals)}
+                )
+
             if djs is not None:
-                lp.assignVarsDj({v.name: djs[v._xprs[0]] for v in lp.variables()})
+                lp.assignVarsDj({v.name: rc for (v, _), rc in zip(xpress_vars, djs)})
+
             if duals is not None:
-                lp.assignConsPi(
-                    {n: duals[c._xprs[0]] for (n, c) in lp.constraints.items()}
-                )
+                # constraints dict preserves insertion order in Python 3.7+
+                lp.assignConsPi({n: pi for (n, c, _), pi in zip(xpress_cons, duals)})
+
             if slacks is not None:
-                lp.assignConsSlack(
-                    {n: slacks[c._xprs[0]] for (n, c) in lp.constraints.items()}
-                )
+                lp.assignConsSlack({n: s for (n, c, _), s in zip(xpress_cons, slacks)})
 
             status = statusmap.get(
                 model.getAttrib(statuskey), constants.LpStatusUndefined
             )
             lp.assignStatus(status)
-
             return status
 
         except (xpress.ModelError, xpress.InterfaceError, xpress.SolverError) as err:
@@ -648,6 +715,39 @@ class XPRESS_PY(LpSolver):
         """
         self._reset(lp)
         try:
+            # Map PuLP senses -> XPRESS tokens (prefer xp.leq/geq/eq if present; else fall back to 'L','G','E')
+            _XP_LEQ = getattr(xpress, "leq", "L")
+            _XP_GEQ = getattr(xpress, "geq", "G")
+            _XP_EQ = getattr(xpress, "eq", "E")
+
+            _SENSE_MAP = {
+                constants.LpConstraintLE: _XP_LEQ,
+                constants.LpConstraintGE: _XP_GEQ,
+                constants.LpConstraintEQ: _XP_EQ,
+            }
+
+            def _xp_make_constraint(lhs, rhs, xp_sense, name=None):
+                """
+                Create an XPRESS constraint in a way that works with both APIs:
+                new: xpress.constraint(body=..., type=..., rhs=..., name=...)
+                old: xpress.constraint(body=..., sense=..., rhs=..., name=...)
+                """
+                # Prefer the new keyword first
+                try:
+                    return xpress.constraint(
+                        body=lhs, type=xp_sense, rhs=rhs, name=name
+                    )
+                except TypeError:
+                    # Fallback to old keyword
+                    try:
+                        return xpress.constraint(
+                            body=lhs, sense=xp_sense, rhs=rhs, name=name
+                        )
+                    except TypeError as e:
+                        raise PulpSolverError(
+                            f"XPRESS constraint constructor is incompatible: {e}"
+                        )
+
             model = xpress.problem()
             if lp.sense == constants.LpMaximize:
                 model.chgobjsense(xpress.maximize)
@@ -689,16 +789,14 @@ class XPRESS_PY(LpSolver):
                     for x, a in sorted(con.items(), key=lambda x: x[0]._xprs[0])
                 )
                 rhs = -con.constant
-                if con.sense == constants.LpConstraintLE:
-                    c = xpress.constraint(body=lhs, sense=xpress.leq, rhs=rhs)
-                elif con.sense == constants.LpConstraintGE:
-                    c = xpress.constraint(body=lhs, sense=xpress.geq, rhs=rhs)
-                elif con.sense == constants.LpConstraintEQ:
-                    c = xpress.constraint(body=lhs, sense=xpress.eq, rhs=rhs)
-                else:
-                    raise PulpSolverError(
-                        "Unsupprted constraint type " + str(con.sense)
-                    )
+
+                xp_sense = _SENSE_MAP.get(con.sense)
+                if xp_sense is None:
+                    raise PulpSolverError(f"Unsupported constraint type {con.sense}")
+
+                c = _xp_make_constraint(
+                    lhs=lhs, rhs=rhs, xp_sense=xp_sense, name=con.name
+                )
                 cons.append((i, c, con))
                 if len(cons) > 100:
                     model.addConstraint([c for _, c, _ in cons])

{pulp-3.2.2 → pulp-3.3.0}/pulp/constants.py

@@ -27,7 +27,7 @@
 This file contains the constant definitions for PuLP
 Note that hopefully these will be changed into something more pythonic
 """
-VERSION = "3.0.2"
+VERSION = "3.3.0"
 EPS = 1e-7
 
 # variable categories

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

@@ -306,9 +306,9 @@ def writeMPS(
     wasNone, dummyVar = lp.fixObjective()
     if mpsSense == 0:
         mpsSense = lp.sense
-    cobj = lp.objective
-    if cobj is None:
+    if lp.objective is None:
         raise ValueError("objective is None")
+    cobj: LpAffineExpression = lp.objective
     if mpsSense != lp.sense:
         n = cobj.name
         cobj = -cobj

{pulp-3.2.2 → pulp-3.3.0}/pulp/tests/test_pulp.py

@@ -19,6 +19,7 @@ from pulp import (
     LpFractionConstraint,
     LpProblem,
     LpVariable,
+    PulpSolverError,
 )
 from pulp import constants as const
 from pulp import lpSum
@@ -924,7 +925,7 @@ class BaseSolverTest:
             """
             Test the availability of the function pulpTestAll
             """
-            from pulp import pulpTestAll
+            from pulp.tests.run_tests import pulpTestAll
 
         def test_export_dict_LP(self):
             prob = LpProblem(self._testMethodName, const.LpMinimize)
@@ -2071,7 +2072,7 @@ class CPLEX_CMDTest(BaseSolverTest.PuLPTest):
 
 
 class CPLEX_PYTest(BaseSolverTest.PuLPTest):
-    solveInst = solvers.CPLEX_CMD
+    solveInst = solvers.CPLEX_PY
 
     def _build(self, **kwargs):
         """
@@ -2082,6 +2083,15 @@ class CPLEX_PYTest(BaseSolverTest.PuLPTest):
         solver.buildSolverModel(lp=problem)
         return solver
 
+    def test_search_param_without_solver_model(self):
+        """
+        Tests the behavior of the `search_param` method when invoked without a `solverModel`
+        initialized. Validates that an appropriate error is raised under these conditions.
+        """
+        solver = self.solveInst()
+        with self.assertRaises(PulpSolverError):
+            solver.search_param("barrier.algorithm")
+
     def test_get_param(self):
         """
         Tests the `get_param` method of the solver instance to ensure the correct
@@ -2118,13 +2128,6 @@ class CPLEX_PYTest(BaseSolverTest.PuLPTest):
         solver = self._build(**{param: 100})
         self.assertEqual(len(solver.get_changed_params()), 1)
 
-    def test_set_all_params(self):
-        solver = self._build()
-        parameters = solver.get_all_params()
-        for param, value in parameters:
-            solver.set_param(name=str(param), value=value)
-        self.assertEqual(solver.get_changed_params(), [])
-
     def test_callback(self):
         from cplex.callbacks import IncumbentCallback  # type: ignore[import-not-found, import-untyped, unused-ignore]
 
@@ -2136,7 +2139,9 @@ class CPLEX_PYTest(BaseSolverTest.PuLPTest):
                 counter += 1
 
         problem = create_bin_packing_problem(bins=5, seed=55)
-        pulpTestCheck(problem, self.solver, [LpStatusOptimal], callback=[Callback])
+        pulpTestCheck(
+            problem, self.solver, [const.LpStatusOptimal], callback=[Callback]
+        )
         self.assertGreaterEqual(counter, 1)
 
 
@@ -2405,7 +2410,7 @@ def pulpTestCheck(
         )
     if sol is not None:
         for v, x in sol.items():
-            if abs(v.varValue - x) > eps:
+            if v.varValue is not None and abs(v.varValue - x) > eps:
                 dumpTestProblem(prob)
                 raise PulpError(
                     "Tests failed for solver {}:\nvar {} == {} != {}".format(

{pulp-3.2.2 → pulp-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PuLP"
-version = "3.2.2"
+dynamic = ["version"]
 description = "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."
 authors = [
     {name = 'J.S. Roy'},
@@ -11,12 +11,12 @@ maintainers= [{name= "Franco Peschiera", email= "pchtsp@gmail.com"}]
 dependencies = []
 requires-python = ">=3.9"
 readme = "README.rst"
-license = {text = "MIT"}
+license = "MIT"
+license-files = ["LICENSE"]
 classifiers=[
     "Development Status :: 5 - Production/Stable",
     "Environment :: Console",
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: MIT License",
     "Natural Language :: English",
     "Programming Language :: Python",
     "Topic :: Scientific/Engineering :: Mathematics",
@@ -39,7 +39,7 @@ module = [
 follow_imports = "skip"
 
 [build-system]
-requires = ["setuptools"]
+requires = ["setuptools>=77"]
 build-backend = "setuptools.build_meta"
 
 [dependency-groups]
@@ -63,8 +63,9 @@ packages = [
         "pulp.solverdir.cbc.osx.i64",
         "pulp.apis",
         "pulp.tests"]
-# This is a workaround for https://github.com/astral-sh/uv/issues/9513
-license-files = []
+
+[tool.setuptools.dynamic]
+version = {attr = "pulp.__version__"}
 
 [tool.setuptools.package-data]
 "pulp.solverdir.cbc.linux.i32"= ["*", "*.*"]
@@ -83,6 +84,19 @@ target-version = ['py37']
 include = '\.pyi?$'
 exclude = '/(\.eggs|\.git|\.hg|\.mypy_cache|\.tox|\.venv|_build|buck-out|build|dist)/'
 
+[tool.uv]
+required-environments = [
+    "sys_platform == 'darwin'",
+]
+
+
 [project.optional-dependencies]
-open_py = ["cylp; sys_platform != 'win32'", "highspy", "pyscipopt"]
-public_py = ["gurobipy", "coptpy", 'xpress']
+open_py = ["cylp", "highspy", "pyscipopt"]
+public_py = ["gurobipy", "coptpy", 'xpress', "cplex; sys_platform != 'darwin' or python_full_version < '3.12'"]
+highs = ["highspy"]
+scip = ["pyscipopt"]
+gurobi = ["gurobipy"]
+xpress = ["xpress"]
+copt = ["coptpy"]
+cplex = ["cplex; sys_platform != 'darwin' or python_full_version < '3.12'"]
+mosek = ["mosek"]

pulp-3.2.2/PuLP.egg-info/requires.txt

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