Metadata fbc3 group

src/cobra/core/user_defined_constraints.py

@@ -1,5 +1,22 @@
 # -*- coding: utf-8 -*-
 
+import ast
+from ast import (
+    Add,
+    BinOp,
+    Div,
+    Expression,
+    Mod,
+    Mult,
+    Name,
+    NodeTransformer,
+    Num,
+    Sub,
+    UAdd,
+    UnaryOp,
+    USub,
+    copy_location,
+)
 from warnings import warn
 
 from cobra.core import DictList
@@ -44,6 +61,186 @@ def __init__(self, id=None, name=None, lower_bound: [int, float]=None,
         if const_comps is not None:
             self.add_constraint_comps(const_comps)
 
+    class ComputeNumericNodes(NodeTransformer):
+        """ Compute the value of nodes which are solvable i.e
+        node containing numeric value on both sides.
+        """
+
+        def visit_BinOp(self, node: BinOp):
+            node.left = self.visit(node.left)
+            node.right = self.visit(node.right)
+            if isinstance(node.left, Num) and isinstance(node.right, Num):
+                if isinstance(node.op, Add):
+                    result = Num(n=node.left.n + node.right.n)
+                    return copy_location(result, node)
+                elif isinstance(node.op, Sub):
+                    result = Num(n=node.left.n - node.right.n)
+                    return copy_location(result, node)
+                elif isinstance(node.op, Mult):
+                    result = Num(n=node.left.n * node.right.n)
+                    return copy_location(result, node)
+                elif isinstance(node.op, Div):
+                    result = Num(n=node.left.n / node.right.n)
+                    return copy_location(result, node)
+                elif isinstance(node.op, Mod):
+                    result = Num(n=node.left.n % node.right.n)
+                    return copy_location(result, node)
+            return node
+
+    def add_single_node(self, ast_node, negate=False):
+        """
+        The final node to add constraint component inside constraint.
+
+        Parameters
+        ----------
+        ast_node : AST Node classes
+            Final node representation of a constraint component
+        negate : bool
+            Whether to add a negative sign before this component
+
+        """
+
+        if isinstance(ast_node, Name):
+            coeff = 1
+            if negate:
+                coeff = -1
+            self.add_constraint_comps([ConstraintComponent(coefficient=coeff,
+                                                           variable=ast_node.id,
+                                                           variable_type='linear')])
+        elif isinstance(ast_node, UnaryOp):
+            if isinstance(ast_node.op, UAdd):
+                coeff = 1
+            elif isinstance(ast_node.op, USub):
+                coeff = -1
+            else:
+                raise ValueError("Unsupported Unary Operand: {}".format(ast_node.op))
+            if negate:
+                coeff = -1 * coeff
+            self.add_constraint_comps([ConstraintComponent(coefficient=coeff,
+                                                           variable=ast_node.operand.id,
+                                                           variable_type='linear')])
+        elif isinstance(ast_node, BinOp):
+            if not isinstance(ast_node.op, Mult):
+                raise ValueError("Unsupported operand type between the variables:"
+                                 "{} and {}".format(ast_node.left, ast_node.right))
+            if not isinstance(ast_node.right, Name):
+                raise ValueError("The second argument must be a single variable"
+                                 ": {}".format(ast_node.right))
+            if isinstance(ast_node.left, Num):
+                coeff = ast_node.left.n
+                if negate:
+                    coeff = -1 * coeff
+                var = ast_node.right.id
+                self.add_constraint_comps([ConstraintComponent(coefficient=coeff,
+                                                               variable=var,
+                                                               variable_type='linear')])
+            elif isinstance(ast_node.left, Name):
+                if ast_node.left.id != ast_node.right.id:
+                    raise ValueError("Multiplication of two different variables is not "
+                                     "allowed as per SBML FBC-V3: {} and {}"
+                                     "".format(ast_node.left.id, ast_node.right.id))
+                coeff = 1
+                if negate:
+                    coeff = -1
+                self.add_constraint_comps(
+                    [ConstraintComponent(coefficient=coeff,
+                                         variable=ast_node.right.id,
+                                         variable_type='quadratic')])
+            elif isinstance(ast_node.left, UnaryOp):
+                if isinstance(ast_node.left.operand, Num):
+                    if isinstance(ast_node.left.op, UAdd):
+                        coeff = 1
+                    elif isinstance(ast_node.left.op, USub):
+                        coeff = -1
+                    else:
+                        raise ValueError(
+                            "Unsupported Unary Operand: {}".format(ast_node.left.op))
+                    coeff *= ast_node.left.operand.n
+                    if negate:
+                        coeff = -1 * coeff
+                    comp = ConstraintComponent(coefficient=coeff,
+                                               variable=ast_node.right.id,
+                                               variable_type='linear')
+                    self.add_constraint_comps([comp])
+                elif isinstance(ast_node.left.operand, Name):
+                    if ast_node.left.operand.id != ast_node.right.id:
+                        raise ValueError("Multiplication of two different variables is "
+                                         "not allowed as per SBML FBC-V3: {} and {}"
+                                         "".format(ast_node.left.operand.id,
+                                                   ast_node.right.id))
+                    if isinstance(ast_node.left.op, UAdd):
+                        coeff = 1
+                    elif isinstance(ast_node.left.op, USub):
+                        coeff = -1
+                    else:
+                        raise ValueError(
+                            "Unsupported Unary Operand: {}".format(ast_node.left.op))
+                    if negate:
+                        coeff = -1 * coeff
+                    comp = ConstraintComponent(coefficient=coeff,
+                                               variable=ast_node.left.operand.id,
+                                               variable_type='quadratic')
+                    self.add_constraint_comps([comp])
+            elif isinstance(ast_node.left, BinOp):
+                if ast_node.left.right.id != ast_node.right.id:
+                    raise ValueError("Multiplication of two different variables is not "
+                                     "allowed as per SBML FBC-V3: {} and {}".format(
+                                        ast_node.left.name.id, ast_node.right.id))
+                if isinstance(ast_node.left.left, UnaryOp):
+                    if isinstance(ast_node.left.left.op, USub):
+                        coeff = -1
+                    elif isinstance(ast_node.left.left.op, UAdd):
+                        coeff = 1
+                    else:
+                        raise ValueError("Invalid expression.")
+                    coeff = coeff*ast_node.left.left.operand.n
+                elif isinstance(ast_node.left.left, Num):
+                    coeff = ast_node.left.left.n
+                else:
+                    raise ValueError("Invalid expression.")
+                if negate:
+                    coeff = -1*coeff
+                comp = ConstraintComponent(coefficient=coeff,
+                                           variable=ast_node.right.id,
+                                           variable_type='quadratic')
+                self.add_constraint_comps([comp])
+
+    def add_components_via_ast_nodes(self, ast_node, negate=False):
+        """
+        Add the constraint components to model via ast node
+        representation of constraint expression.
+
+        Parameters
+        ----------
+        ast_node : Expression
+            The ast of the constraint expression
+        negate : bool
+            Whether to add a '-' sign before this node
+
+        """
+
+        if isinstance(ast_node, BinOp):
+            if isinstance(ast_node.op, Add):
+                self.add_components_via_ast_nodes(ast_node.left, negate)
+                self.add_components_via_ast_nodes(ast_node.right, negate)
+            elif isinstance(ast_node.op, Sub):
+                self.add_components_via_ast_nodes(ast_node.left, negate)
+                negate = not negate
+                self.add_components_via_ast_nodes(ast_node.right, negate)
+            elif isinstance(ast_node.op, Mult):
+                self.add_single_node(ast_node, negate)
+            else:
+                raise ValueError("Unsupported operation between variables"
+                                 ": ".format(ast_node))
+        elif isinstance(ast_node, Name):
+            self.add_single_node(ast_node, negate)
+        elif isinstance(ast_node, UnaryOp):
+            self.add_single_node(ast_node, negate)
+        elif isinstance(ast_node, Expression):
+            self.add_components_via_ast_nodes(ast_node.body, negate)
+        else:
+            raise ValueError("Unsupported variable type: ".format(ast_node))
+
     @staticmethod
     def constraint_from_expression(id=None, expression: 'str' = '',
                                    lower_bound=None, upper_bound=None):
@@ -52,47 +249,26 @@ def constraint_from_expression(id=None, expression: 'str' = '',
         type string. Following rules must be followed while making the
         expression:
 
-            1. The coefficient must be added before the variable without
-               parentheses and must have a multiplicative sign (*) only
-               between itself and the variable (without any whitespaces
-               around). The coefficient itself can be an integer, float
-               or a number in fractional form (a/b). Coefficient with any
-               other form is not allowed. For instance:
+            1. The coefficient must be added before the variable and must
+               have a multiplicative sign (*) only between itself and the
+               variable. It can be an expression containing numbers:
 
-                    variable : Allowed
-                    1*variable : Allowed
                     2*variable : Allowed
-                    2 * variable : Not allowed
+                    2 * variable : Allowed
                     2.variable : Not Allowed
                     2.0*variable : Allowed
-                    2/3*variable : Allowed
-                    2*2*variable : Not allowed
-                    (2/4)*variable : Not allowed
+                    (4/2+5%2)*variable : Allowed
+                    (2/4)*variable : Allowed
+                    variable*2 : Not Allowed
 
-            2. The exponent for the variable must be set via the 'caret'
-               operator (^) only. It must also not have whitespaces around
-               it. Also, since only linear and quadratic variables are all-
-               wed, the exponent can be 1 or 2 only. For instance:
+            2. The 'caret' operator must not be used to set the exponent.
+               Use multiplicative sign instead. Also, since only 'linear' and
+               'quadratic' variables are allowed, we will need multiplication
+               of variable at most one (in quadratic case).
 
                     variable : Allowed
-                    variable^1 : Allowed
-                    variable^2 : Allowed
-                    variable^3 : Not allowed
-                    variable ^ 2 : Not allowed
-                    variable*variable : Not allowed
-
-            3. The only possible sign between two or more variables are '+'
-               and '-' (addition and subtraction). These signs must have a
-               single whitespace character on both of its side, with only
-               exception that if the sign comes before very first variable,
-               it may drop the whitespace before it. For instance:
-
-                    variable1 - variable2 : Allowed
-                    variable1+variable2 : Not allowed
-                    - variable1 + variable2 : Allowed
-                     + variable1 - variable2 : Allowed
-                    variable1 * variable2 : Not allowed
-
+                    variable^2 : Not allowed
+                    variable * variable : Allowed
 
         Parameters
         ----------
@@ -116,61 +292,11 @@ def constraint_from_expression(id=None, expression: 'str' = '',
 
         expression = expression.strip()
 
-        expression = expression.replace('+ ', '+')
-        expression = expression.replace('- ', '-')
-
-        variables = expression.split(' ')
-        for variable in variables:
-            ind = variable.find('*')
-            if ind == -1:
-                if variable[0] == '-':
-                    coefficient = -1
-                else:
-                    coefficient = 1
-            else:
-                parts = variable.split('*')
-
-                def convert_to_float(frac_str):
-                    """
-                    Function to convert a numeric string value
-                    to float.
-                    """
-                    try:
-                        return float(frac_str)
-                    except ValueError:
-                        num, denom = frac_str.split('/')
-                        try:
-                            leading, num = num.split(' ')
-                            whole = float(leading)
-                        except ValueError:
-                            whole = 0
-                        frac = float(num) / float(denom)
-                        return whole - frac if whole < 0 else whole + frac
-
-                coefficient = convert_to_float(parts[0])
-                variable = parts[1]
-            ind = variable.find('^')
-            if ind == -1:
-                exponent = '1'
-            else:
-                parts = variable.split('^')
-                exponent = parts[1]
-                variable = parts[0]
-            variable = variable.replace('+', '')
-            variable = variable.replace('-', '')
-            if exponent == '1':
-                variable_type = 'linear'
-            elif exponent == '2':
-                variable_type = 'quadratic'
-            else:
-                raise ValueError("Only 'linear' or 'quadratic' "
-                                 "variables are allowed. Variable"
-                                 " {} is raised to exponent {}"
-                                 ".".format(variable, exponent))
-            const_comp = ConstraintComponent(coefficient=coefficient,
-                                             variable=variable,
-                                             variable_type=variable_type)
-            constraint.add_constraint_comps([const_comp])
+        tree = ast.parse(source=expression, mode='eval')
+        compute_nodes = UserDefinedConstraint.ComputeNumericNodes()
+        tree = compute_nodes.visit(tree)
+        print(ast.dump(tree))
+        constraint.add_components_via_ast_nodes(ast_node=tree)
 
         return constraint