OptlangHelper 0.0.1__tar.gz → 0.0.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OptlangHelper
-Version: 0.0.1
+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

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

@@ -4,4 +4,6 @@ OptlangHelper.egg-info/PKG-INFO
 OptlangHelper.egg-info/SOURCES.txt
 OptlangHelper.egg-info/dependency_links.txt
 OptlangHelper.egg-info/requires.txt
-OptlangHelper.egg-info/top_level.txt
+OptlangHelper.egg-info/top_level.txt
+optlanghelper/__init__.py
+optlanghelper/optlanghelper.py

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

@@ -0,0 +1 @@
+optlanghelper

{OptlangHelper-0.0.1 → OptlangHelper-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OptlangHelper
-Version: 0.0.1
+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

OptlangHelper-0.0.2/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.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

@@ -0,0 +1,134 @@
+# -*- 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

{OptlangHelper-0.0.1 → OptlangHelper-0.0.2}/setup.py

@@ -7,14 +7,14 @@ with open("README.rst") as f:
 
 setup(
     name="OptlangHelper",
-    version="0.0.1",
+    version="0.0.2",
     description="Python package for building Linear Programming models that are compatible with Optlang",
     long_description_content_type="text/x-rst",
     long_description=readme,
     author="Andrew Freiburger",
     author_email="afreiburger@anl.gov",
     url="https://github.com/Freiburgermsu/OptlangHelper",
-    packages=find_packages(exclude=("docs")),
+    packages=find_packages(),
     classifiers=[
         "Development Status :: 3 - Alpha",
         "Topic :: Scientific/Engineering :: Bio-Informatics",
@@ -26,7 +26,6 @@ setup(
         "Programming Language :: Python :: 3.11",
         "Natural Language :: English",
     ],
-    include_package_data =True,
     install_requires=[
         "optlang",
         # "glpk",

OptlangHelper-0.0.1/OptlangHelper.egg-info/top_level.txt

@@ -1 +0,0 @@
-