PuLP 3.2.0__tar.gz → 3.2.2__tar.gz

pulp-3.2.2/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: PuLP
+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>
+Maintainer-email: Franco Peschiera <pchtsp@gmail.com>
+License: 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
+Provides-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
+Requires-Dist: gurobipy; extra == "public-py"
+Requires-Dist: coptpy; extra == "public-py"
+Requires-Dist: xpress; extra == "public-py"
+
+pulp
+**************************
+
+.. image:: https://travis-ci.org/coin-or/pulp.svg?branch=master
+    :target: https://travis-ci.org/coin-or/pulp
+.. image:: https://img.shields.io/pypi/v/pulp
+    :target: https://pypi.org/project/PuLP/
+    :alt: PyPI
+.. image:: https://img.shields.io/pypi/dm/pulp
+    :target: https://pypi.org/project/PuLP/
+    :alt: PyPI - Downloads
+
+PuLP is an linear and mixed integer programming modeler written in Python. With PuLP, it is simple to create MILP optimisation problems and solve them with the latest open-source (or proprietary) solvers.  PuLP can generate MPS or LP files and call solvers such as GLPK_, COIN-OR CLP/`CBC`_, CPLEX_, GUROBI_, MOSEK_, XPRESS_, CHOCO_, MIPCL_, HiGHS_, SCIP_/FSCIP_.
+
+The documentation for PuLP can be `found here <https://coin-or.github.io/pulp/>`_.
+
+PuLP is part of the `COIN-OR project <https://www.coin-or.org/>`_. 
+
+Installation
+================
+
+PuLP requires Python 3.9 or newer.
+
+The easiest way to install PuLP is with ``pip``. If ``pip`` is available on your system, type::
+
+     python -m pip install pulp
+
+Otherwise follow the download instructions on the `PyPi page <https://pypi.python.org/pypi/PuLP>`_.
+
+
+Quickstart 
+===============
+
+Use ``LpVariable`` to create new variables. To create a variable x with 0  ≤  x  ≤  3::
+
+     from pulp import *
+     x = LpVariable("x", 0, 3)
+
+To create a binary variable, y, with values either 0 or 1::
+
+     y = LpVariable("y", cat="Binary")
+
+Use ``LpProblem`` to create new problems. Create a problem called "myProblem" like so::
+
+     prob = LpProblem("myProblem", LpMinimize)
+
+Combine variables in order to create expressions and constraints, and then add them to the problem.::
+
+     prob += x + y <= 2
+
+An expression is a constraint without a right-hand side (RHS) sense (one of ``=``, ``<=`` or ``>=``). If you add an expression to a problem, it will become the objective::
+
+     prob += -4*x + y
+
+To solve the problem  with the default included solver::
+
+     status = prob.solve()
+
+If you want to try another solver to solve the problem::
+
+     status = prob.solve(GLPK(msg = 0))
+
+Display the status of the solution::
+
+     LpStatus[status]
+     > 'Optimal'
+
+You can get the value of the variables using ``value``. ex::
+
+     value(x)
+     > 2.0
+
+
+Essential Classes
+------------------
+
+
+* ``LpProblem`` -- Container class for a Linear or Integer programming problem
+* ``LpVariable`` -- Variables that are added into constraints in the LP problem
+* ``LpConstraint`` -- Constraints of the general form
+
+      a1x1 + a2x2 + ... + anxn (<=, =, >=) b
+
+* ``LpConstraintVar`` -- A special type of constraint for constructing column of the model in column-wise modelling
+
+Useful Functions
+------------------
+
+* ``value()`` -- Finds the value of a variable or expression
+* ``lpSum()`` -- Given a list of the form [a1*x1, a2*x2, ..., an*xn] will construct a linear expression to be used as a constraint or variable
+* ``lpDot()`` -- Given two lists of the form [a1, a2, ..., an] and [x1, x2, ..., xn] will construct a linear expression to be used as a constraint or variable
+
+More Examples
+================
+
+Several tutorial are given in `documentation <https://coin-or.github.io/pulp/CaseStudies/index.html>`_ and pure code examples are available in `examples/ directory <https://github.com/coin-or/pulp/tree/master/examples>`_ .
+
+The examples use the default solver (CBC). To use other solvers they must be available (installed and accessible). For more information on how to do that, see the `guide on configuring solvers <https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html>`_.
+
+
+For Developers 
+================
+
+
+If you want to install the latest version from GitHub you can run::
+
+    python -m pip install -U git+https://github.com/coin-or/pulp
+
+
+On Linux and MacOS systems, you must run the tests to make the default solver executable::
+
+     sudo pulptest
+
+
+
+
+Building the documentation
+--------------------------
+
+The PuLP documentation is built with `Sphinx <https://www.sphinx-doc.org>`_.  We recommended using a
+`virtual environment <https://docs.python.org/3/library/venv.html>`_ to build the documentation locally.
+
+To build, run the following in a terminal window, in the PuLP root directory
+
+::
+
+    python3 -m pip install --upgrade pip
+    pip install --group=dev .
+    cd doc
+    make html
+
+A folder named html will be created inside the ``build/`` directory.
+The home page for the documentation is ``doc/build/html/index.html`` which can be opened in a browser.
+
+Contributing to PuLP
+-----------------------
+Instructions for making your first contribution to PuLP are given `here <https://coin-or.github.io/pulp/develop/contribute.html>`_.
+
+**Comments, bug reports, patches and suggestions are very welcome!**
+
+* Comments and suggestions: https://github.com/coin-or/pulp/discussions
+* Bug reports: https://github.com/coin-or/pulp/issues
+* Patches: https://github.com/coin-or/pulp/pulls
+
+Copyright and License 
+=======================
+PuLP is distributed under an MIT license. 
+
+     Copyright J.S. Roy, 2003-2005
+     Copyright Stuart A. Mitchell
+     See the LICENSE file for copyright information.
+
+.. _Python: http://www.python.org/
+
+.. _GLPK: http://www.gnu.org/software/glpk/glpk.html
+.. _CBC: https://github.com/coin-or/Cbc
+.. _CPLEX: http://www.cplex.com/
+.. _GUROBI: http://www.gurobi.com/
+.. _MOSEK: https://www.mosek.com/
+.. _XPRESS: https://www.fico.com/es/products/fico-xpress-solver
+.. _CHOCO: https://choco-solver.org/
+.. _MIPCL: http://mipcl-cpp.appspot.com/
+.. _SCIP: https://www.scipopt.org/
+.. _HiGHS: https://highs.dev
+.. _FSCIP: https://ug.zib.de

pulp-3.2.2/PuLP.egg-info/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: PuLP
+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>
+Maintainer-email: Franco Peschiera <pchtsp@gmail.com>
+License: 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
+Provides-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
+Requires-Dist: gurobipy; extra == "public-py"
+Requires-Dist: coptpy; extra == "public-py"
+Requires-Dist: xpress; extra == "public-py"
+
+pulp
+**************************
+
+.. image:: https://travis-ci.org/coin-or/pulp.svg?branch=master
+    :target: https://travis-ci.org/coin-or/pulp
+.. image:: https://img.shields.io/pypi/v/pulp
+    :target: https://pypi.org/project/PuLP/
+    :alt: PyPI
+.. image:: https://img.shields.io/pypi/dm/pulp
+    :target: https://pypi.org/project/PuLP/
+    :alt: PyPI - Downloads
+
+PuLP is an linear and mixed integer programming modeler written in Python. With PuLP, it is simple to create MILP optimisation problems and solve them with the latest open-source (or proprietary) solvers.  PuLP can generate MPS or LP files and call solvers such as GLPK_, COIN-OR CLP/`CBC`_, CPLEX_, GUROBI_, MOSEK_, XPRESS_, CHOCO_, MIPCL_, HiGHS_, SCIP_/FSCIP_.
+
+The documentation for PuLP can be `found here <https://coin-or.github.io/pulp/>`_.
+
+PuLP is part of the `COIN-OR project <https://www.coin-or.org/>`_. 
+
+Installation
+================
+
+PuLP requires Python 3.9 or newer.
+
+The easiest way to install PuLP is with ``pip``. If ``pip`` is available on your system, type::
+
+     python -m pip install pulp
+
+Otherwise follow the download instructions on the `PyPi page <https://pypi.python.org/pypi/PuLP>`_.
+
+
+Quickstart 
+===============
+
+Use ``LpVariable`` to create new variables. To create a variable x with 0  ≤  x  ≤  3::
+
+     from pulp import *
+     x = LpVariable("x", 0, 3)
+
+To create a binary variable, y, with values either 0 or 1::
+
+     y = LpVariable("y", cat="Binary")
+
+Use ``LpProblem`` to create new problems. Create a problem called "myProblem" like so::
+
+     prob = LpProblem("myProblem", LpMinimize)
+
+Combine variables in order to create expressions and constraints, and then add them to the problem.::
+
+     prob += x + y <= 2
+
+An expression is a constraint without a right-hand side (RHS) sense (one of ``=``, ``<=`` or ``>=``). If you add an expression to a problem, it will become the objective::
+
+     prob += -4*x + y
+
+To solve the problem  with the default included solver::
+
+     status = prob.solve()
+
+If you want to try another solver to solve the problem::
+
+     status = prob.solve(GLPK(msg = 0))
+
+Display the status of the solution::
+
+     LpStatus[status]
+     > 'Optimal'
+
+You can get the value of the variables using ``value``. ex::
+
+     value(x)
+     > 2.0
+
+
+Essential Classes
+------------------
+
+
+* ``LpProblem`` -- Container class for a Linear or Integer programming problem
+* ``LpVariable`` -- Variables that are added into constraints in the LP problem
+* ``LpConstraint`` -- Constraints of the general form
+
+      a1x1 + a2x2 + ... + anxn (<=, =, >=) b
+
+* ``LpConstraintVar`` -- A special type of constraint for constructing column of the model in column-wise modelling
+
+Useful Functions
+------------------
+
+* ``value()`` -- Finds the value of a variable or expression
+* ``lpSum()`` -- Given a list of the form [a1*x1, a2*x2, ..., an*xn] will construct a linear expression to be used as a constraint or variable
+* ``lpDot()`` -- Given two lists of the form [a1, a2, ..., an] and [x1, x2, ..., xn] will construct a linear expression to be used as a constraint or variable
+
+More Examples
+================
+
+Several tutorial are given in `documentation <https://coin-or.github.io/pulp/CaseStudies/index.html>`_ and pure code examples are available in `examples/ directory <https://github.com/coin-or/pulp/tree/master/examples>`_ .
+
+The examples use the default solver (CBC). To use other solvers they must be available (installed and accessible). For more information on how to do that, see the `guide on configuring solvers <https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html>`_.
+
+
+For Developers 
+================
+
+
+If you want to install the latest version from GitHub you can run::
+
+    python -m pip install -U git+https://github.com/coin-or/pulp
+
+
+On Linux and MacOS systems, you must run the tests to make the default solver executable::
+
+     sudo pulptest
+
+
+
+
+Building the documentation
+--------------------------
+
+The PuLP documentation is built with `Sphinx <https://www.sphinx-doc.org>`_.  We recommended using a
+`virtual environment <https://docs.python.org/3/library/venv.html>`_ to build the documentation locally.
+
+To build, run the following in a terminal window, in the PuLP root directory
+
+::
+
+    python3 -m pip install --upgrade pip
+    pip install --group=dev .
+    cd doc
+    make html
+
+A folder named html will be created inside the ``build/`` directory.
+The home page for the documentation is ``doc/build/html/index.html`` which can be opened in a browser.
+
+Contributing to PuLP
+-----------------------
+Instructions for making your first contribution to PuLP are given `here <https://coin-or.github.io/pulp/develop/contribute.html>`_.
+
+**Comments, bug reports, patches and suggestions are very welcome!**
+
+* Comments and suggestions: https://github.com/coin-or/pulp/discussions
+* Bug reports: https://github.com/coin-or/pulp/issues
+* Patches: https://github.com/coin-or/pulp/pulls
+
+Copyright and License 
+=======================
+PuLP is distributed under an MIT license. 
+
+     Copyright J.S. Roy, 2003-2005
+     Copyright Stuart A. Mitchell
+     See the LICENSE file for copyright information.
+
+.. _Python: http://www.python.org/
+
+.. _GLPK: http://www.gnu.org/software/glpk/glpk.html
+.. _CBC: https://github.com/coin-or/Cbc
+.. _CPLEX: http://www.cplex.com/
+.. _GUROBI: http://www.gurobi.com/
+.. _MOSEK: https://www.mosek.com/
+.. _XPRESS: https://www.fico.com/es/products/fico-xpress-solver
+.. _CHOCO: https://choco-solver.org/
+.. _MIPCL: http://mipcl-cpp.appspot.com/
+.. _SCIP: https://www.scipopt.org/
+.. _HiGHS: https://highs.dev
+.. _FSCIP: https://ug.zib.de

{pulp-3.2.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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(