Expression utility class for C++ solvers

[jtcooper10]

Upcoming SBML features (function definitions and events, especially) will require more advanced conversions from Python expressions to C++ expressions, in particular for language constructs like boolean operators. This utility class is used to convert a valid Python expression into a valid C++ expression, within reason.

Expression Class

Create an expression context with namespace (dictionary of mappings, the keys of which are expected to be valid names in the namespace) and blacklist (a list of operators which are not allowed). Once created, the Expression#getexpr_cpp and Expression#getexpr_python can be called to extract C++ and Python expressions, respectively. If Expression is constructed with sanitize=True, then the identifiers in the expression will be substituted with the identifiers provided in the namespace dict.

Additionally, the Expression#validate method may be used to verify that the provided expression is, indeed, a valid Python expression, given the provided namespace and blacklist. A standard SyntaxError will be raised if the expression cannot be parsed.

from gillespy2.solvers.cpp.build.expression import Expression

expr = Expression(namespace={ "x": "S1", "y": "S2" }, blacklist=["="])
expr.validate("x + y")
> True
expr.validate("x = y")
> False
expr.validate("y + z")
> False
try:
    expr.validate("x++")
except SyntaxError:
    print("Syntax Error")
> Syntax Error
expr.getexpr_cpp("x > 0 and y < 10")
> (x>0) && (y<10)

Intended Use

The template_gen methods have been updated to use the new Expression class for sanitizing and validating expressions. This allows us to inform the user of syntax errors prior to the solver's compile step. The user will see a friendlier Python error message, instead of a massive C++ compiler exception.

Additionally, this will be used to create a variety of C++ expressions to be used for upcoming SBML features, many of which require different syntax for Python and C++ solvers. For example, the boolean expression x > 0 and y**2 < 10 is valid in Python, but must be converted to x > 0 && pow(y, 2) < 10 for C.

Supported Operators

Currently, only basic operators are supported: arithmetic operators, boolean operators (and and or), and comparison operators. It doesn't seem like there's much point in implementing more than that at the moment, as this will likely be limited to propensity functions and basic SBML features.

However, if for any reason additional operations are to be supported, they can be added simply by implementing the parser logic using that operator's corresponding visit_* method (such as visit_Add for the + operator), and adding that operator to the operator_map along with its corresponding AST class.

Note that the use of unsupported operators is currently undefined behavior, likely resulting in a failure to compile or bizarre output.

[ethangreen-dev]

Looks great!