OptlangHelper 0.0.2__tar.gz → 0.0.3__tar.gz

{OptlangHelper-0.0.2 → optlanghelper-0.0.3/OptlangHelper.egg-info}/PKG-INFO

@@ -1,13 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: OptlangHelper
-Version: 0.0.2
+Version: 0.0.3
 Summary: Python package for building Linear Programming models that are compatible with Optlang
 Home-page: https://github.com/Freiburgermsu/OptlangHelper
 Author: Andrew Freiburger
 Author-email: afreiburger@anl.gov
-License: UNKNOWN
 Project-URL: Issues, https://github.com/Freiburgermsu/OptlangHelper/issues
-Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: Intended Audience :: Science/Research
@@ -18,6 +16,21 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Natural Language :: English
 Description-Content-Type: text/x-rst
+Requires-Dist: optlang
+Provides-Extra: matrix
+Requires-Dist: numpy; extra == "matrix"
+Requires-Dist: scipy; extra == "matrix"
+Requires-Dist: gurobipy; extra == "matrix"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 
 
@@ -168,4 +181,34 @@ Example
  model = define_model("< model name>", list(variables.values()), list(constraints.values()), objective, True)
 
 
+Release 0.0.3
+----------------------
+
+Bug fixes
+
++ the published 0.0.2 wheel was unimportable (``__init__`` imported from the package
+  name instead of the submodule) and crashed on nested expressions (a stale internal
+  reference to the pre-rename class); both are fixed and covered by tests.
++ ``__version__`` is synchronized with the package metadata, and the import-time
+  ``print`` is now a debug log line.
+
+New
+
++ the historic ``OptlangHelper`` class is restored as the solver-agnostic base;
+  ``GLPKHelper`` / ``CPLEXHelper`` / ``GurobiHelper`` are interface-pinned subclasses
+  (previously the latter two were empty stubs).
++ ``MatrixHelper.define_model`` builds very large LPs as a sparse CSR matrix directly
+  through ``gurobipy`` (install with ``pip install OptlangHelper[matrix]``): optlang's
+  per-constraint interfaces scale super-linearly (~n^1.8 measured on Gurobi — 48 s at
+  1e5 constraints, ~90 min extrapolated at 1.4e6), while the CSR path ingests 1.4e6
+  constraints in seconds.
++ ``define_model_auto(name, variables, constraints, objective, limit=300000)``
+  dispatches by size: an optlang model at or below ``limit`` constraints, a gurobipy
+  model above it (both expose ``.optimize()``; their result APIs differ).
+
+.. code-block:: python
+
+ from optlanghelper import define_model_auto
 
+ model = define_model_auto("community_fba", variables, constraints, objective)
+ model.optimize()

{OptlangHelper-0.0.2 → optlanghelper-0.0.3}/OptlangHelper.egg-info/SOURCES.txt

@@ -6,4 +6,5 @@ OptlangHelper.egg-info/dependency_links.txt
 OptlangHelper.egg-info/requires.txt
 OptlangHelper.egg-info/top_level.txt
 optlanghelper/__init__.py
-optlanghelper/optlanghelper.py
+optlanghelper/optlanghelper.py
+tests/test_optlanghelper.py

optlanghelper-0.0.3/OptlangHelper.egg-info/requires.txt

@@ -0,0 +1,6 @@
+optlang
+
+[matrix]
+numpy
+scipy
+gurobipy

OptlangHelper-0.0.2/README.rst → optlanghelper-0.0.3/PKG-INFO

@@ -1,3 +1,37 @@
+Metadata-Version: 2.4
+Name: OptlangHelper
+Version: 0.0.3
+Summary: Python package for building Linear Programming models that are compatible with Optlang
+Home-page: https://github.com/Freiburgermsu/OptlangHelper
+Author: Andrew Freiburger
+Author-email: afreiburger@anl.gov
+Project-URL: Issues, https://github.com/Freiburgermsu/OptlangHelper/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Natural Language :: English
+Description-Content-Type: text/x-rst
+Requires-Dist: optlang
+Provides-Extra: matrix
+Requires-Dist: numpy; extra == "matrix"
+Requires-Dist: scipy; extra == "matrix"
+Requires-Dist: gurobipy; extra == "matrix"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
 
 
 Efficiently creating optimization models
@@ -146,3 +180,35 @@ Example
  # create an optlang model from all of the variables, constraints, and objective defined above
  model = define_model("< model name>", list(variables.values()), list(constraints.values()), objective, True)
 
+
+Release 0.0.3
+----------------------
+
+Bug fixes
+
++ the published 0.0.2 wheel was unimportable (``__init__`` imported from the package
+  name instead of the submodule) and crashed on nested expressions (a stale internal
+  reference to the pre-rename class); both are fixed and covered by tests.
++ ``__version__`` is synchronized with the package metadata, and the import-time
+  ``print`` is now a debug log line.
+
+New
+
++ the historic ``OptlangHelper`` class is restored as the solver-agnostic base;
+  ``GLPKHelper`` / ``CPLEXHelper`` / ``GurobiHelper`` are interface-pinned subclasses
+  (previously the latter two were empty stubs).
++ ``MatrixHelper.define_model`` builds very large LPs as a sparse CSR matrix directly
+  through ``gurobipy`` (install with ``pip install OptlangHelper[matrix]``): optlang's
+  per-constraint interfaces scale super-linearly (~n^1.8 measured on Gurobi — 48 s at
+  1e5 constraints, ~90 min extrapolated at 1.4e6), while the CSR path ingests 1.4e6
+  constraints in seconds.
++ ``define_model_auto(name, variables, constraints, objective, limit=300000)``
+  dispatches by size: an optlang model at or below ``limit`` constraints, a gurobipy
+  model above it (both expose ``.optimize()``; their result APIs differ).
+
+.. code-block:: python
+
+ from optlanghelper import define_model_auto
+
+ model = define_model_auto("community_fba", variables, constraints, objective)
+ model.optimize()

OptlangHelper-0.0.2/OptlangHelper.egg-info/PKG-INFO → optlanghelper-0.0.3/README.rst

@@ -1,24 +1,3 @@
-Metadata-Version: 2.1
-Name: OptlangHelper
-Version: 0.0.2
-Summary: Python package for building Linear Programming models that are compatible with Optlang
-Home-page: https://github.com/Freiburgermsu/OptlangHelper
-Author: Andrew Freiburger
-Author-email: afreiburger@anl.gov
-License: UNKNOWN
-Project-URL: Issues, https://github.com/Freiburgermsu/OptlangHelper/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Classifier: Intended Audience :: Science/Research
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Natural Language :: English
-Description-Content-Type: text/x-rst
-
 
 
 Efficiently creating optimization models
@@ -168,4 +147,34 @@ Example
  model = define_model("< model name>", list(variables.values()), list(constraints.values()), objective, True)
 
 
+Release 0.0.3
+----------------------
+
+Bug fixes
+
++ the published 0.0.2 wheel was unimportable (``__init__`` imported from the package
+  name instead of the submodule) and crashed on nested expressions (a stale internal
+  reference to the pre-rename class); both are fixed and covered by tests.
++ ``__version__`` is synchronized with the package metadata, and the import-time
+  ``print`` is now a debug log line.
+
+New
+
++ the historic ``OptlangHelper`` class is restored as the solver-agnostic base;
+  ``GLPKHelper`` / ``CPLEXHelper`` / ``GurobiHelper`` are interface-pinned subclasses
+  (previously the latter two were empty stubs).
++ ``MatrixHelper.define_model`` builds very large LPs as a sparse CSR matrix directly
+  through ``gurobipy`` (install with ``pip install OptlangHelper[matrix]``): optlang's
+  per-constraint interfaces scale super-linearly (~n^1.8 measured on Gurobi — 48 s at
+  1e5 constraints, ~90 min extrapolated at 1.4e6), while the CSR path ingests 1.4e6
+  constraints in seconds.
++ ``define_model_auto(name, variables, constraints, objective, limit=300000)``
+  dispatches by size: an optlang model at or below ``limit`` constraints, a gurobipy
+  model above it (both expose ``.optimize()``; their result APIs differ).
+
+.. code-block:: python
+
+ from optlanghelper import define_model_auto
 
+ model = define_model_auto("community_fba", variables, constraints, objective)
+ model.optimize()

optlanghelper-0.0.3/optlanghelper/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+
+import logging
+
+__author__ = "Andrew Freiburger"
+__email__ = "afreiburger@anl.gov"
+__version__ = "0.0.3"
+
+logger = logging.getLogger(__name__)
+logger.debug("OptlangHelper %s", __version__)
+
+from .optlanghelper import (OptlangHelper, GLPKHelper, CPLEXHelper, GurobiHelper, MatrixHelper,
+                            Bounds, tupVariable, tupConstraint, tupObjective, define_model_auto)

optlanghelper-0.0.3/optlanghelper/optlanghelper.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 18 10:26:32 2022
+@author: Andrew Freiburger
+"""
+from collections import namedtuple
+from importlib import import_module
+from optlang import Model
+from typing import Iterable, Union
+import logging
+
+logger = logging.getLogger(__name__)
+
+Bounds = namedtuple("Bounds", ("lb", "ub"), defaults=(0,1000))
+tupVariable = namedtuple("tupVariable", ("name", "bounds", "type"), defaults=("varName", Bounds(), "continuous"))
+tupConstraint = namedtuple("tupConstraint", ("name", "bounds", "expr"), defaults=("consName", Bounds(0,0), None))
+tupObjective = namedtuple("tupObjective", ("name", "expr", "direction"), defaults=("objectiveName", None, "max"))
+
+def isIterable(term):
+    try:
+        iter(term)
+        if type(term) is not str:  return True
+        return False
+    except:  return False
+
+def isnumber(obj):
+    try:  float(obj)  ;  return True
+    except:  return False
+
+def define_term(value):
+    if isnumber(value):
+        return {"type":"Number", "value": value}
+    if isinstance(value, str):
+        return {"type":"Symbol", "name": value}
+    logger.error(f"The {value} of type {type(value)} is not known.")
+
+def get_expression_template(expr):
+    if isinstance(expr, list):
+        return {"type": "Add", "args": []}
+    return {"type": expr["operation"], "args": []}
+
+
+class OptlangHelper:
+    """Bulk construction of an optlang model from tuple/dict descriptions.
+
+    ``interface`` pins the optlang solver interface (``"glpk"``, ``"cplex"``,
+    ``"gurobi"``); when None, optlang's preferred available interface is used
+    (whatever ``from optlang import Model`` resolves to)."""
+
+    interface = None
+
+    @classmethod
+    def _model_cls(cls):
+        if cls.interface is None:
+            return Model
+        try:
+            return import_module(f"optlang.{cls.interface}_interface").Model
+        except Exception as exc:
+            raise ImportError(
+                f"The optlang {cls.interface} interface is unavailable: {exc}") from exc
+
+    @staticmethod
+    def add_variables(var_name:str, var_bounds:(list, tuple), var_type:str="continuous"):
+        assert var_bounds[0] <= var_bounds[1], f"The {var_name} variable lower bound {var_bounds[0]} is greater than the upper bound {var_bounds[1]}.  The lower bound must be less than the upper bound."
+        return {"name": var_name.replace(" ", "_"), "lb": var_bounds[0], "ub": var_bounds[1], "type": var_type}
+
+    @classmethod
+    def add_constraint(cls, cons_name:str, cons_bounds:(list, tuple), cons_expr:dict):
+        assert cons_bounds[0] is None or cons_bounds[1] is None or cons_bounds[0] <= cons_bounds[1], f"The {cons_name} constraint lower bound {cons_bounds[0]} is greater than the upper bound {cons_bounds[1]}.  The lower bound must be less than the upper bound."
+        return {"name": cons_name.replace(" ", "_"),
+                "expression": cls._define_expression(cons_expr),
+                "lb": cons_bounds[0], "ub": cons_bounds[1], "indicator_variable": None, "active_when": 1}
+
+    @classmethod
+    def add_objective(cls, obj_name:str, objective_expr:Union[dict, list], direction:str):
+        if isinstance(objective_expr, list):
+            obj_expr = {"type": "Add", "args": [
+                cls._define_expression(expr) for expr in objective_expr]}
+        elif isinstance(objective_expr, dict):
+            obj_expr = {"type": objective_expr["operation"],
+                        "args": [define_term(term) for term in objective_expr["elements"]]}
+        return {"name": obj_name.replace(" ", "_"), "expression": obj_expr, "direction": direction}
+
+    @classmethod
+    def define_model(cls, model_name, variables, constraints, objective, optlang=False):
+        model = {'name':model_name, 'variables':[], 'constraints':[]}
+        for var in variables:
+            var = list(var)
+            if len(var) == 2:  var.append("continuous")
+            model["variables"].append(cls.add_variables(var[0], var[1], var[2]))
+        for cons in constraints:
+            model["constraints"].append(cls.add_constraint(cons[0], cons[1], cons[2]))
+        model["objective"] = cls.add_objective(objective[0], objective[1], objective[2])
+        if optlang:  return cls._model_cls().from_json(model)
+        return model
+
+    @classmethod
+    def _define_expression(cls, expr:dict):
+        expression = get_expression_template(expr)
+        level1_coef = 0
+        for ele in expr["elements"]:
+            if not isnumber(ele) and not isinstance(ele, str):
+                arguments = []
+                level2_coef = 0
+                for ele2 in ele["elements"]:
+                    if not isnumber(ele2) and not isinstance(ele2, str):
+                        arguments.append(cls._define_expression(ele2))
+                    elif isinstance(ele2, str): arguments.append(define_term(ele2))
+                    else:  level2_coef += float(ele2)
+                expression["args"].append(get_expression_template(ele))
+                if level2_coef != 0:  arguments.append(define_term(level2_coef))
+                expression["args"][-1]["args"] = arguments
+            elif isinstance(ele, str): expression["args"].append(define_term(ele))
+            else:  level1_coef += float(ele)
+        if level1_coef != 0:  expression["args"].append(define_term(level1_coef))
+        return expression
+
+    @staticmethod
+    def dot_product(zipped_to_sum, heuns_coefs=None):
+        # ensure that the lengths are compatible for heun's dot-products
+        if heuns_coefs is not None:
+            coefs = heuns_coefs if isinstance(heuns_coefs, (list, set)) else heuns_coefs.tolist()
+            zipped_length = len(zipped_to_sum); coefs_length = len(coefs)
+            if zipped_length != coefs_length:
+                raise IndexError(f"ERROR: The length of zipped elements {zipped_length}"
+                                 f" is unequal to that of coefficients {coefs_length}")
+
+        elements = []
+        for index, (term1, term2) in enumerate(zipped_to_sum):
+            if heuns_coefs is not None:
+                elements.extend([{"operation": "Mul", "elements": [heuns_coefs[index], term1]},
+                                 {"operation": "Mul", "elements": [heuns_coefs[index], term2]}])
+            else:
+                elements.append({"operation": "Mul", "elements": [term1, term2]})
+        return elements
+
+
+class GLPKHelper(OptlangHelper):
+    interface = "glpk"
+
+class CPLEXHelper(OptlangHelper):
+    interface = "cplex"
+
+class GurobiHelper(OptlangHelper):
+    interface = "gurobi"
+
+
+# --------------------------------------------------------------------------- matrix path
+def _linear_terms(expr, var_index):
+    """Flatten a tuple-format linear expression into ({var_idx: coef}, constant).
+
+    Handles the shapes produced by ``dot_product``/``tupConstraint``: an Add of
+    Mul-dicts, bare variable names, and numeric constants; Muls may hold the
+    coefficient and variable in either order. Nested Adds are recursed."""
+    coefs, const = {}, 0.0
+    elements = expr["elements"] if isinstance(expr, dict) else expr
+    for ele in elements:
+        if isinstance(ele, str):
+            coefs[var_index[ele]] = coefs.get(var_index[ele], 0.0) + 1.0
+        elif isnumber(ele):
+            const += float(ele)
+        elif isinstance(ele, dict) and ele.get("operation") == "Mul":
+            coef, name = 1.0, None
+            for ele2 in ele["elements"]:
+                if isinstance(ele2, str):  name = ele2
+                elif isnumber(ele2):  coef *= float(ele2)
+                else:  raise ValueError(f"Non-linear or nested Mul term is not supported by the matrix path: {ele}")
+            if name is None:  const += coef
+            else:  coefs[var_index[name]] = coefs.get(var_index[name], 0.0) + coef
+        elif isinstance(ele, dict) and ele.get("operation") == "Add":
+            sub_coefs, sub_const = _linear_terms(ele, var_index)
+            const += sub_const
+            for j, c in sub_coefs.items():  coefs[j] = coefs.get(j, 0.0) + c
+        else:
+            raise ValueError(f"Unsupported expression element for the matrix path: {ele}")
+    return coefs, const
+
+
+class MatrixHelper:
+    """CSR/gurobipy construction for very large LPs.
+
+    optlang's per-constraint interfaces scale super-linearly (~n^1.8 measured on
+    Gurobi: 48 s at 1e5 constraints, ~90 min extrapolated at 1.4e6), while
+    gurobipy ingests a CSR matrix in C time (seconds at 1.4e6 constraints).
+    Requires numpy, scipy, and gurobipy (``pip install OptlangHelper[matrix]``).
+    Returns a ``gurobipy.Model`` (``.optimize()``; status 2 == optimal), NOT an
+    optlang model."""
+
+    @staticmethod
+    def define_model(model_name, variables, constraints, objective, verbose=False):
+        import numpy as np
+        from scipy.sparse import coo_matrix
+        import gurobipy as gp
+
+        names, lbs, ubs = [], [], []
+        for var in variables:
+            var = list(var)
+            name = var[0].replace(" ", "_")
+            names.append(name); lbs.append(float(var[1][0])); ubs.append(float(var[1][1]))
+        var_index = {n: j for j, n in enumerate(names)}
+
+        rows_eq, rows_le, rows_ge = [], [], []   # (coefs, rhs)
+        for cons in constraints:
+            _, bounds, expr = cons[0], cons[1], cons[2]
+            coefs, const = _linear_terms(expr, var_index)
+            lb = None if bounds[0] is None else float(bounds[0]) - const
+            ub = None if bounds[1] is None else float(bounds[1]) - const
+            if lb is not None and ub is not None and lb == ub:
+                rows_eq.append((coefs, lb))
+            else:
+                if ub is not None:  rows_le.append((coefs, ub))
+                if lb is not None:  rows_ge.append((coefs, lb))
+
+        env = gp.Env(empty=True); env.setParam("OutputFlag", 1 if verbose else 0); env.start()
+        model = gp.Model(model_name, env=env)
+        x = model.addMVar(len(names), lb=np.array(lbs), ub=np.array(ubs))
+        model._var_names = names
+        model._var_index = var_index
+
+        def add_block(rows, sense):
+            if not rows:  return
+            r, c, v, rhs = [], [], [], []
+            for i, (coefs, b) in enumerate(rows):
+                rhs.append(b)
+                for j, coef in coefs.items():
+                    r.append(i); c.append(j); v.append(coef)
+            S = coo_matrix((v, (r, c)), shape=(len(rows), len(names))).tocsr()
+            model.addMConstr(S, x, sense, np.array(rhs))
+        add_block(rows_eq, "="); add_block(rows_le, "<"); add_block(rows_ge, ">")
+
+        obj_expr = objective[1] if isinstance(objective[1], (list, dict)) else [objective[1]]
+        if isinstance(obj_expr, list):
+            obj_expr = {"elements": obj_expr, "operation": "Add"}
+        ocoefs, oconst = _linear_terms(obj_expr, var_index)
+        lin = gp.LinExpr(oconst)
+        for j, coef in ocoefs.items():  lin += coef * x[j]
+        model.setObjective(lin, gp.GRB.MAXIMIZE if objective[2] in ("max", "maximize") else gp.GRB.MINIMIZE)
+        model._mvar = x
+        return model
+
+
+def define_model_auto(model_name, variables, constraints, objective, limit=300000, helper=None):
+    """Size-aware dispatch: optlang construction up to ``limit`` constraints,
+    CSR/gurobipy (``MatrixHelper``) beyond it.
+
+    Below the limit an OPTLANG model is returned (from ``helper`` or
+    ``OptlangHelper``); above it a GUROBIPY model is returned — both expose
+    ``.optimize()``, but their status/attribute APIs differ, so branch on
+    ``isinstance`` or on ``len(constraints) > limit`` when reading results."""
+    if len(constraints) <= limit:
+        return (helper or OptlangHelper).define_model(model_name, variables, constraints, objective, optlang=True)
+    logger.info(f"{model_name}: {len(constraints)} constraints exceeds limit={limit}; "
+                "building through MatrixHelper (gurobipy CSR)")
+    return MatrixHelper.define_model(model_name, variables, constraints, objective)

{OptlangHelper-0.0.2 → optlanghelper-0.0.3}/setup.py

@@ -7,7 +7,7 @@ with open("README.rst") as f:
 
 setup(
     name="OptlangHelper",
-    version="0.0.2",
+    version="0.0.3",
     description="Python package for building Linear Programming models that are compatible with Optlang",
     long_description_content_type="text/x-rst",
     long_description=readme,
@@ -28,10 +28,10 @@ setup(
     ],
     install_requires=[
         "optlang",
-        # "glpk",
-        # "cplex",
-        # "gurobipy"
     ],
+    extras_require={
+        "matrix": ["numpy", "scipy", "gurobipy"],
+    },
     # tests_require=[
     #     "pytest",
     # ],

optlanghelper-0.0.3/tests/test_optlanghelper.py

@@ -0,0 +1,81 @@
+import pytest
+from optlanghelper import (OptlangHelper, GLPKHelper, GurobiHelper, MatrixHelper,
+                           Bounds, tupVariable, tupConstraint, tupObjective, define_model_auto)
+
+
+def _small_problem():
+    # max v0  s.t.  v0 - v1 = 0;  v1 + v2 <= 8;  0 <= v* <= 5
+    variables = [[f"v{i}", [0, 5]] for i in range(3)]
+    constraints = [
+        ["c_eq", [0, 0], {"operation": "Add", "elements": [
+            {"operation": "Mul", "elements": [1.0, "v0"]},
+            {"operation": "Mul", "elements": [-1.0, "v1"]}]}],
+        ["c_le", [None, 8], {"operation": "Add", "elements": [
+            {"operation": "Mul", "elements": [1.0, "v1"]},
+            {"operation": "Mul", "elements": [1.0, "v2"]}]}],
+    ]
+    objective = ["obj", [{"operation": "Mul", "elements": [1.0, "v0"]}], "max"]
+    return variables, constraints, objective
+
+
+def test_optlang_default_interface():
+    v, c, o = _small_problem()
+    mdl = OptlangHelper.define_model("t", v, c, o, optlang=True)
+    mdl.optimize()
+    assert mdl.status == "optimal"
+    assert abs(mdl.objective.value - 5.0) < 1e-6
+
+
+def test_glpk_interface():
+    v, c, o = _small_problem()
+    mdl = GLPKHelper.define_model("t", v, c, o, optlang=True)
+    assert type(mdl).__module__ == "optlang.glpk_interface"
+    mdl.optimize()
+    assert abs(mdl.objective.value - 5.0) < 1e-6
+
+
+def test_gurobi_interface():
+    pytest.importorskip("gurobipy")
+    v, c, o = _small_problem()
+    mdl = GurobiHelper.define_model("t", v, c, o, optlang=True)
+    assert type(mdl).__module__ == "optlang.gurobi_interface"
+    mdl.optimize()
+    assert abs(mdl.objective.value - 5.0) < 1e-6
+
+
+def test_dict_output_backcompat():
+    v, c, o = _small_problem()
+    d = OptlangHelper.define_model("t", v, c, o, optlang=False)
+    assert set(d) == {"name", "variables", "constraints", "objective"}
+    assert len(d["variables"]) == 3 and len(d["constraints"]) == 2
+
+
+def test_matrix_helper_matches_optlang():
+    pytest.importorskip("gurobipy")
+    v, c, o = _small_problem()
+    g = MatrixHelper.define_model("t", v, c, o)
+    g.optimize()
+    assert g.Status == 2
+    assert abs(g.ObjVal - 5.0) < 1e-6
+
+
+def test_auto_dispatch():
+    pytest.importorskip("gurobipy")
+    v, c, o = _small_problem()
+    small = define_model_auto("t", v, c, o, limit=10)
+    assert hasattr(small, "objective")           # optlang model
+    big = define_model_auto("t", v, c, o, limit=1)
+    assert type(big).__module__.startswith("gurobipy")
+    big.optimize()
+    assert abs(big.ObjVal - 5.0) < 1e-6
+
+
+def test_tuple_inputs_accepted():
+    v = [tupVariable(f"v{i}", Bounds(0, 5)) for i in range(2)]
+    c = [tupConstraint("c", Bounds(0, 0), {"operation": "Add", "elements": [
+        {"operation": "Mul", "elements": [1.0, "v0"]},
+        {"operation": "Mul", "elements": [-1.0, "v1"]}]})]
+    o = tupObjective("obj", [{"operation": "Mul", "elements": [1.0, "v0"]}], "max")
+    mdl = OptlangHelper.define_model("t", v, c, o, optlang=True)
+    mdl.optimize()
+    assert abs(mdl.objective.value - 5.0) < 1e-6

OptlangHelper-0.0.2/OptlangHelper.egg-info/requires.txt

@@ -1 +0,0 @@
-optlang

OptlangHelper-0.0.2/optlanghelper/__init__.py

@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import absolute_import
-
-import logging
-
-__author__ = "Andrew Freiburger"
-__email__ = "afreiburger@anl.gov"
-__version__ = "0.0.1"
-
-logger = logging.getLogger(__name__)
-
-print("OptlangHelper", __version__)
-
-from optlanghelper import GLPKHelper, CPLEXHelper, GurobiHelper, Bounds, tupVariable, tupConstraint, tupObjective

OptlangHelper-0.0.2/optlanghelper/optlanghelper.py

@@ -1,134 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Thu Aug 18 10:26:32 2022
-@author: Andrew Freiburger
-"""
-from collections import namedtuple
-from optlang import Model
-from typing import Iterable, Union
-from pprint import pprint
-import logging
-
-logger = logging.getLogger(__name__)
-
-Bounds = namedtuple("Bounds", ("lb", "ub"), defaults=(0,1000))
-tupVariable = namedtuple("tupVariable", ("name", "bounds", "type"), defaults=("varName", Bounds(), "continuous"))
-tupConstraint = namedtuple("tupConstraint", ("name", "bounds", "expr"), defaults=("consName", Bounds(0,0), None))
-tupObjective = namedtuple("tupObjective", ("name", "expr", "direction"), defaults=("objectiveName", None, "max"))
-
-def isIterable(term):
-    try:
-        iter(term)
-        if type(term) is not str:  return True
-        return False
-    except:  return False
-    
-def isnumber(obj):
-    try:  float(obj)  ;  return True
-    except:  return False
-    
-def define_term(value):
-    if isnumber(value):
-        return {"type":"Number", "value": value}
-    if isinstance(value, str):
-        return {"type":"Symbol", "name": value}
-    print(f"ERROR: The {value} of type {type(value)} is not known.")
-    
-def get_expression_template(expr):
-    # print(expr)
-    if isinstance(expr, list):
-        return {"type": "Add", "args": []}
-    return {"type": expr["operation"], "args": []}
-
-    
-class GLPKHelper:
-    
-    @staticmethod
-    def add_variables(var_name:str, var_bounds:(list, tuple), var_type:str="continuous"):
-        assert var_bounds[0] <= var_bounds[1], f"The {var_name} variable lower bound {var_bounds[0]} is greater than the upper bound {var_bounds[1]}.  The lower bound must be less than the upper bound."
-        return {"name": var_name.replace(" ", "_"), "lb": var_bounds[0], "ub": var_bounds[1], "type": var_type}
-    
-    @staticmethod
-    def add_constraint(cons_name:str, cons_bounds:(list, tuple), cons_expr:dict):
-        assert cons_bounds[0] <= cons_bounds[1], f"The {cons_name} constraint lower bound {cons_bounds[0]} is greater than the upper bound {cons_bounds[1]}.  The lower bound must be less than the upper bound."
-        return {"name": cons_name.replace(" ", "_"),
-                "expression": OptlangHelper._define_expression(cons_expr),
-                "lb": cons_bounds[0], "ub": cons_bounds[1], "indicator_variable": None, "active_when": 1}
-    
-    @staticmethod
-    def add_objective(obj_name:str, objective_expr:Union[dict, list], direction:str):
-        if isinstance(objective_expr, list):
-            obj_expr = {"type": "Add", "args": [
-                OptlangHelper._define_expression(expr) for expr in objective_expr]}
-        elif isinstance(objective_expr, dict):
-            obj_expr = {"type": objective_expr["operation"], 
-                        "args": [define_term(term) for term in objective_expr["elements"]]}
-        return {"name": obj_name.replace(" ", "_"), "expression": obj_expr, "direction": direction}
-    
-    @staticmethod
-    def define_model(model_name, variables, constraints, objective, optlang=False):
-        model = {'name':model_name, 'variables':[], 'constraints':[]}
-        # pprint(objective)
-        for var in variables:
-            if len(var) == 2:  var.append("continuous")
-            model["variables"].append(OptlangHelper.add_variables(var[0], var[1], var[2]))
-        for cons in constraints:
-            model["constraints"].append(OptlangHelper.add_constraint(cons[0], cons[1], cons[2]))
-        # if not isinstance(obj, str): # catches a strange error of the objective name as the objective itself
-        model["objective"] = OptlangHelper.add_objective(objective[0], objective[1], objective[2])
-        if optlang:  return Model.from_json(model)
-        return model
-    
-    @staticmethod
-    def _define_expression(expr:dict):
-        expression = get_expression_template(expr)
-        level1_coef = 0
-        for ele in expr["elements"]:
-            if not isnumber(ele) and not isinstance(ele, str):
-                # print(expr, ele, end="\r")
-                arguments = []
-                level2_coef = 0
-                for ele2 in ele["elements"]:
-                    if not isnumber(ele2) and not isinstance(ele2, str):
-                        # print("recursive ele\t\t", type(ele2), ele2)
-                        arguments.append(OptlangHelper._define_expression(ele2))
-                    elif isinstance(ele2, str): arguments.append(define_term(ele2))
-                    else:  level2_coef += float(ele2)
-                expression["args"].append(get_expression_template(ele))
-                if level2_coef != 0:  arguments.append(define_term(level2_coef))
-                expression["args"][-1]["args"] = arguments
-            elif isinstance(ele, str): expression["args"].append(define_term(ele))
-            else:  level1_coef += float(ele)
-        if level1_coef != 0:  expression["args"].append(define_term(level1_coef))
-        # pprint(expression)
-        return expression
-    
-    @staticmethod
-    def dot_product(zipped_to_sum, heuns_coefs=None):
-        # ensure that the lengths are compatible for heun's dot-products
-        if heuns_coefs is not None:
-            coefs = heuns_coefs if isinstance(heuns_coefs, (list, set)) else heuns_coefs.tolist()
-            zipped_length = len(zipped_to_sum); coefs_length = len(coefs)
-            if zipped_length != coefs_length:
-                raise IndexError(f"ERROR: The length of zipped elements {zipped_length}"
-                                 f" is unequal to that of coefficients {coefs_length}")
-                
-        elements = []
-        for index, (term1, term2) in enumerate(zipped_to_sum):
-            if heuns_coefs is not None:
-                elements.extend([{"operation": "Mul", "elements": [heuns_coefs[index], term1]},
-                                 {"operation": "Mul", "elements": [heuns_coefs[index], term2]}])
-            else:
-                elements.append({"operation": "Mul", "elements": [term1, term2]})
-        return elements
-    
-    
-
-class CPLEXHelper:
-    pass
-
-
-
-
-class GurobiHelper:
-    pass