gillespy2.solvers.cpp.build package

Submodules

gillespy2.solvers.cpp.build.build_engine module

class gillespy2.solvers.cpp.build.build_engine.BuildEngine(debug: bool = False, output_dir: Optional[str] = None)

Bases: object

build_cache(cache_dir: str, force_rebuild: bool = False)

Build object dependencies and cache into directory for later use.

Parameters:

• cache_dir (str) – The directory to use as a cache.

• force_rebuild (bool) – Delete and rebuild the cache directory.

build_simulation(simulation_name: str, definitions: dict[str, str] = None) → str

Build the solver to the temp directory.

Parameters:

• simulation_name (str) – The name of the simulation to build. For example, ODESimulation.

• definitions – Dictionary of environment variables to be overriden when the Makefile is invoked.

Intended for use when running through a debugger environment or profiler. :type definitions: dict[str, str]

Returns:

The path of the newly build solver executable.

clean()

Delete the output directory and all other associated build artifacts.

get_executable_path() → str

Resolves the filepath of the simulation executable. Only valid after the simulation has been built.

Returns:

String containing path to executable. None if no executable exists.

classmethod get_missing_dependencies() → list[str]

Determine which dependencies are missing on the system, if any.

Returns:

A list of missing dependencies.

prepare(model: Union[Model, SanitizedModel], variable=False) → str

Prepare the template directory for compilation. The following operations will be performed:

1. If no cached object files are found, prebuild them.

2. Copy the C++ template directory into a new temp directory.

3. Remove the sample template_definitions.h file.

4. Generate and write a template_definitions.h file from the model.

Parameters:

• model (gillespy2.Model) – A GillesPy2 model who’s template definitions will be generated.

• variable (bool) – A template_gen argument requirement which enables support for non-constant param values.

Returns:

The path of the output directory.

template_definitions_name = 'template_definitions.h'

template_options_name = 'template_opts.h'

gillespy2.solvers.cpp.build.expression module

class gillespy2.solvers.cpp.build.expression.CppConverter(tree: AST)

Bases: ExpressionConverter

class CppExpressionTransformer

Bases: NodeTransformer

visit_BinOp(node: BinOp)

get_str() → str

visit_And(node: And)

visit_Or(node: Or)

class gillespy2.solvers.cpp.build.expression.Expression(blacklist: Union[list[str], dict[ast.operator, str]] = None, namespace: dict[str, any] = None, sanitize=False)

Bases: object

Accepts an expression string to validate and convert. Allows for pre-flight syntax and namespace validations, as well as converting between Python and C++ expressions.

class ValidationVisitor(namespace: dict[str, str] = None, blacklist: dict[ast.operator, str] = None, sanitize=False)

Bases: NodeTransformer

check_blacklist(operator)

visit_Assign(node: Assign)

visit_BinOp(node: BinOp)

visit_BoolOp(node: BoolOp)

visit_Call(node: Call)

visit_Compare(node: Compare)

visit_Name(node: Name)

visit_UnaryOp(node: UnaryOp)

getexpr_cpp(statement: str) → Optional[str]

Converts the expression object into a C++ expression string. Raises a SyntaxError if conversion to a C++ string is impossible.

Raises:

SyntaxError

Returns:

C++ expression string

getexpr_python(statement: str) → Optional[str]

Converts the expression object into a Python expression string. Raises a SyntaxError if conversion to a Python string is impossible.

Raises:

SyntaxError

Returns:

Python expression string, if valid. Returns None if validation fails.

classmethod map_operator(operator: Union[str, list[str]])

operator_map = {'!': <class '_ast.Not'>, '!=': <class '_ast.NotEq'>, '%': <class '_ast.Mod'>, '&': <class '_ast.BitAnd'>, '*': <class '_ast.Mult'>, '**': <class '_ast.Pow'>, '+': <class '_ast.Add'>, '-': <class '_ast.Sub'>, '/': <class '_ast.Div'>, '//': <class '_ast.FloorDiv'>, ':=': <class '_ast.Assign'>, '<': <class '_ast.Lt'>, '<<': <class '_ast.LShift'>, '<=': <class '_ast.LtE'>, '=': <class '_ast.Assign'>, '==': <class '_ast.Eq'>, '>': <class '_ast.Gt'>, '>=': <class '_ast.GtE'>, '>>': <class '_ast.RShift'>, '@': <class '_ast.MatMult'>, '^': <class '_ast.BitXor'>, 'and': <class '_ast.And'>, 'or': <class '_ast.Or'>, '|': <class '_ast.BitOr'>}

validate(statement: str) → ExpressionResults

Using the information provided so far, ensure that the given Python expression is valid. The Python expression is parsed, raising a SyntaxError if it is an invalid Python expression. The expression is then checked against the given properties, such as namespace and operator blacklist. Additionally, the expression is rejected if it is not a single rvalue expression.

Raises:

SyntaxError – The statement is not a valid Python expression.

Returns:

True if the statement is valid, otherwise returns false.

with_blacklist(blacklist: list[str] = None) → Expression

Create a new duplicate of the current expression, with a different operator blacklist. Overrides operator handling behavior when converting or validating the expression.

Parameters:

blacklist (list[ast.operator]) – List of operators which are not allowed.

Returns:

List of operators which, based on the given parameters, are not valid.

An empty list indicates that no invalid operators were found.

with_namespace(namespace: dict[str, any] = None) → Expression

Create a new duplicate of the current expression, with a different namespace. Any identifiers present in the expression which are not listed in the namespace will cause the expression to be flagged as an invalid namespace during validation.

Parameters:

namespace – A dictionary containing the namespace mappings for the expression.

The keys of the dict are expected to be the “only” valid identifiers. The values of the namespace are what the keys map to during sanitization, if used. :type namespace: dict[str, str]

Returns:

New expression containing the given namespace.

The returned expression is a copy of the current expression. :rtype: Expression

class gillespy2.solvers.cpp.build.expression.ExpressionConverter(tree: AST)

Bases: NodeVisitor

classmethod convert_str(expression: str)

get_str() → str

parse_comparison(comparator: str)

parse_logical(operator: str)

parse_operator(operator: str)

visit_Add(node: Add)

visit_BinOp(node: BinOp)

visit_BoolOp(node: BoolOp)

visit_Bytes(node: Bytes)

visit_Call(node: Call)

visit_Compare(node: Compare)

visit_Constant(node: Constant)

visit_Div(node: Div)

visit_Ellipsis(node: Ellipsis)

visit_Eq(node: Eq)

visit_Gt(node: Gt)

visit_GtE(node: GtE)

visit_Lt(node: Lt)

visit_LtE(node: LtE)

visit_Mult(node: Mult)

visit_Name(node: Name)

visit_NameConstant(node: NameConstant)

visit_NotEq(node: NotEq)

visit_Num(node: Num)

visit_Pow(node: Pow)

visit_Str(node: Str)

visit_Sub(node: Sub)

visit_USub(node: USub)

visit_UnaryOp(node: UnaryOp)

class gillespy2.solvers.cpp.build.expression.ExpressionResults(invalid_names: set[str] = None, invalid_operators: set[str] = None, is_valid=True)

Bases: object

Container struct for returning the results of expression validation. Any expression items which indicate an invalid expression are listed on an ExpressionResults instance. Empty lists indicate that the expression is valid.

class gillespy2.solvers.cpp.build.expression.PythonConverter(tree: AST)

Bases: ExpressionConverter

visit_And(node: And)

visit_Or(node: Or)

gillespy2.solvers.cpp.build.make module

class gillespy2.solvers.cpp.build.make.Make(makefile: str, output_dir: str, obj_dir: Optional[str] = None, template_dir: Optional[str] = None)

Bases: object

build_simulation(simulation_name: str, **kwargs)

prebuild()

gillespy2.solvers.cpp.build.template_gen module

class gillespy2.solvers.cpp.build.template_gen.SanitizedModel(model: Model, variable=False)

Bases: object

Utility class for preparing a model to be passed to a C++ solver. Ensures that any sanitized mappings are consistent between different mappings. Wraps around an existing GillesPy2 model to provide sanitized mappings.

Parameters:

model (gillespy2.Model) – GillesPy2 model to produce sanitized mappings of.

function_map = {'abs': 'abs', 'round': 'round'}

get_options() → Optional[dict[str, str]]

Creates a dictionary of C++ macro definitions for optional parameters of the model. The keys of the dictionary contain the name of the macro definition. The values of the dictionary are the values their corresponding macro should be defined to.

Returns:

Dictionary of fully-formatted macro definitions.

Return type:

dict[str, str]

get_template() → dict[str, str]

Creates a dictionary of C++ macro definitions from the given model. The keys of the dictionary contain the name of the macro definition. The values of the dictionary are the values their corresponding macro should be defined to.

Parameters:

variable (bool) – Set to true to allow for non-constant parameter values.

Returns:

Dictionary of fully-formatted macro definitions.

Return type:

dict[str, str]

reserved_names = {'t': 't'}

use_propensity(reaction: Reaction, ode=False)

Populates the given reaction’s propensities into the sanitized model. Expression conversion and sanitization are automatically applied.

Parameters:

• reaction (gillespy2.Reaction) – Reaction to generate propensities from.

• ode – Determines whether the stochastic propensity or ODE mass-action rate is used.

If set to true, the mass-action rate is used instead of the propensity.

use_rate_rule(rate_rule: RateRule) → SanitizedModel

Attach the given rate rule to the sanitized model. The rate rule will automatically be validated and sanitized before being applied.

Parameters:

rate_rule (gillespy2.RateRule) – GillesPy2 RateRule object to attach to the sanitized model.

Returns:

Pass-through of sanitized model object.

Return type:

SanitizedModel

use_reaction(reaction: Reaction) → SanitizedModel

Adds the given reaction to the sanitized model. Populates the name and stoichiometry matrix into the model.

Parameters:

reaction (gillespy2.Reaction) – Reaction to add to the sanitized model.

gillespy2.solvers.cpp.build.template_gen.get_model_defines(model: Model, variable=False) → dict[str, str]

Creates a dictionary of C++ macro definitions from the given model. The keys of the dictionary contain the name of the macro definition. The values of the dictionary are the values their corresponding macro should be defined to.

Parameters:

• model (gillespy2.Model) – Model to get the macro definitions of.

• variable (bool) – Set to true to allow for non-constant parameter values.

Returns:

Dictionary of fully-formatted macro definitions.

gillespy2.solvers.cpp.build.template_gen.template_def_propensities(model: SanitizedModel, ode=False) → dict[str, str]

Formats the given list of pre-sorted, pre-sanitized propensities.

Parameters:

model (SanitizedModel) – Sanitized model containing runtime definitions.

Returns:

Dictionary containing propensity macro definitions.

gillespy2.solvers.cpp.build.template_gen.template_def_rate_rules(model: SanitizedModel) → dict[str, str]

Generates template definitions for SBML rate rules.

gillespy2.solvers.cpp.build.template_gen.template_def_reactions(model: SanitizedModel, ode=False) → dict[str, str]

Passed dictionaries/lists are assumed to be sanitized and sorted. Formats the relevant reactions and propensities to be passed to a C++ simulation template.

Parameters:

model (SanitizedModel) – Sanitized model containing runtime definitions.

Returns:

Dictionary of macro definitions for reactions.

gillespy2.solvers.cpp.build.template_gen.template_def_species(model: SanitizedModel) → dict[str, str]

Passed dictionaries/lists are assumed to be sanitized and sorted. Formats the relevant species data to be passed to a C++ simulation template.

Parameters:

model (SanitizedModel) – Sanitized model containing runtime definitions.

Returns:

Dictionary of macro definitions for species and data related to species.

gillespy2.solvers.cpp.build.template_gen.template_def_variables(model: SanitizedModel, variable=False) → dict[str, str]

Formats the relevant parameters to be passed to a C++ simulation template. Passed dictionaries/lists are assumed to be sanitized and sorted.

Parameters:

• model (SanitizedModel) – Sanitized model containing runtime definitions.

• variable (bool) – Indicates whether the model’s variables should be modifiable at runtime.

Returns:

The result as a list of tuples containing key-value pairs to be templated.

gillespy2.solvers.cpp.build.template_gen.update_model_options(model: SanitizedModel, definitions: dict[str, str] = None) → dict[str, str]

Generate the solver-specific options of the SanitizedModel with the given definitions. This includes both solver-defined custom definitions, as well as SBML features.

Parameters:

model – Sanitized model to populate the options into.

The model itself is not modified. :type model: SanitizedModel

Parameters:

definitions (dict[str, str]) – Dictionary of macro definition key-value pairs to pass to the model.

Returns:

Updated dictionary of macro definitions.

Includes both solver-specific definitions provided and SBML features on the model. :rtype: dict[str, str]

gillespy2.solvers.cpp.build.template_gen.write_definitions(path: str, defines: dict[str, str])

Write the given key-value pairs as a C/C++ template file. Contents of the given defines dict are written as #define {key} {value} format.

Parameters:

• path (str) – Absolute filepath of the header file to create (including the .h extension.

• defines (dict[str, str]) – Dictionary of key-value pairs representing macro definitions to create.

gillespy2.solvers.cpp.build.template_gen.write_template(path: str, model: Model, variable=False)

Write template definitions to a specified path. If the file does not exist, one is created. Definitions are written in #define KEY VALUES format.

Parameters:

• model (gillespy2.Model) – Model to get the macro definitions of.

• variable (bool) – Set to true to allow for non-constant parameter values.

Module contents