Source code for synbiopython.genbabel.sbmlgen.simplesbml

# pylint: disable=C0330,C0103,C0116,R0201,R0912,R0913,R0914,R0915,R0904
This module is the simplesbml package from
with minor modifications to include more unit definitions


import warnings

# try to import tesbml or libsbml
# if both of these fail, libsbml cannot be imported - cannot continue
    import tesbml as libsbml
except ImportError:
    import libsbml

from math import isnan
from re import sub

__version__ = "1.2.2"

[docs]class sbmlModel: """Class to generate sbml model file using libsbml method."""
[docs] def check(self, value, message): """Return value to string using libsbml.""" if value is None: raise SystemExit("LibSBML returned a null value trying to " + message + ".") if isinstance(value, int): if value == libsbml.LIBSBML_OPERATION_SUCCESS: return err_msg = ( "Error trying to " + message + "." + "LibSBML returned error code " + str(value) + ': "' + libsbml.OperationReturnValue_toString(value).strip() + '"' ) raise RuntimeError(err_msg) return
def __init__( self, time_units="second", extent_units="mole", sub_units="mole", level=3, version=1, ): if level == 1: raise SystemExit("Error: SimpleSBML does not support SBML level 1") try: self.document = libsbml.SBMLDocument(level, version) except ValueError: raise SystemExit("Could not create SBMLDocument object") self.model = self.document.createModel() self.check(self.model, "create model") if self.document.getLevel() == 3: self.check(self.model.setTimeUnits(time_units), "set model-wide time units") self.check( self.model.setExtentUnits(extent_units), "set model units of extent" ) self.check( self.model.setSubstanceUnits(sub_units), "set model substance units" ) per_second = self.model.createUnitDefinition() self.check(per_second, "create unit definition") self.check(per_second.setId("per_second"), "set unit definition id") unit = per_second.createUnit() self.check(unit, "create unit on per_second") self.check(unit.setKind(libsbml.UNIT_KIND_SECOND), "set unit kind") self.check(unit.setExponent(-1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(1), "set unit multiplier") per_min = self.model.createUnitDefinition() self.check(per_min, "create unit definition") self.check(per_min.setId("per_min"), "set unit definition id") unit = per_min.createUnit() self.check(unit, "create unit on per_min") self.check(unit.setKind(libsbml.UNIT_KIND_SECOND), "set unit kind") self.check(unit.setExponent(-1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(60), "set unit multiplier") molperLmin = self.model.createUnitDefinition() self.check(molperLmin, "create unit definition") self.check(molperLmin.setId("molperLmin"), "set unit definition id") unit = molperLmin.createUnit() self.check(unit, "create unit on per_second") self.check(unit.setKind(libsbml.UNIT_KIND_MOLE), "set unit kind") self.check(unit.setExponent(1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(1), "set unit multiplier") unit = molperLmin.createUnit() self.check(unit, "create unit on per_second") self.check(unit.setKind(libsbml.UNIT_KIND_LITRE), "set unit kind") self.check(unit.setExponent(-1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(1), "set unit multiplier") unit = molperLmin.createUnit() self.check(unit, "create unit on per_second") self.check(unit.setKind(libsbml.UNIT_KIND_SECOND), "set unit kind") self.check(unit.setExponent(-1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(60), "set unit multiplier") molperL = self.model.createUnitDefinition() self.check(molperL, "create unit definition") self.check(molperL.setId("molperL"), "set unit definition id") unit = molperL.createUnit() self.check(unit, "create unit") self.check(unit.setKind(libsbml.UNIT_KIND_MOLE), "set unit kind") self.check(unit.setExponent(1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(1), "set unit multiplier") unit = molperL.createUnit() self.check(unit, "create unit") self.check(unit.setKind(libsbml.UNIT_KIND_LITRE), "set unit kind") self.check(unit.setExponent(-1), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(1), "set unit multiplier") Dimension_less = self.model.createUnitDefinition() self.check(Dimension_less, "create unit definition") self.check(Dimension_less.setId("Dimension_less"), "set unit definition id") unit = Dimension_less.createUnit() self.check(unit, "create unit") self.check(unit.setKind(libsbml.UNIT_KIND_DIMENSIONLESS), "set unit kind") self.check(unit.setExponent(0), "set unit exponent") self.check(unit.setScale(0), "set unit scale") self.check(unit.setMultiplier(0), "set unit multiplier") self.addCompartment()
[docs] def addCompartment(self, vol=1, comp_id=""): """Create compartment of volume litres to the model. :param vol: volume of compartment in L :type vol: float :param comp_id: compartment id :type comp_id: str """ c1 = self.model.createCompartment() self.check(c1, "create compartment") if len(comp_id) == 0: comp_id = "c" + str(self.model.getNumCompartments()) self.check(c1.setId(comp_id), "set compartment id") self.check(c1.setConstant(True), 'set compartment "constant"') self.check(c1.setSpatialDimensions(3), "set compartment dimensions") self.check(c1.setSize(vol), 'set compartment "size"') self.check(c1.setUnits("litre"), "set compartment size units") return c1
[docs] def addSpecies(self, species_id, amt, comp="c1"): """Create Species with the provided amount. :param species_id: id or name of the species. :type species_id: str :param amt: initial amount. :type amt: float :param comp: compartment id :type comp: str """ s1 = self.model.createSpecies() self.check(s1, "create species s1") self.check(s1.setCompartment(comp), "set species s1 compartment") if species_id[0] == "[" and species_id[len(species_id) - 1] == "]": self.check( s1.setInitialConcentration(amt), "set initial concentration for s1" ) species_id = species_id[1 : (len(species_id) - 1)] else: self.check(s1.setInitialAmount(amt), "set initial amount for s1") self.check( s1.setSubstanceUnits(self.model.getSubstanceUnits()), "set substance units for s1", ) if species_id[0] == "$": self.check(s1.setBoundaryCondition(True), 'set "boundaryCondition" on s1') self.check(s1.setConstant(False), 'set "constant" attribute on s1') self.check(s1.setId(species_id[1 : len(species_id)]), "set species s1 id") else: self.check(s1.setBoundaryCondition(False), 'set "boundaryCondition" on s1') self.check(s1.setConstant(False), 'set "constant" attribute on s1') self.check(s1.setId(species_id), "set species s1 id") self.check( s1.setHasOnlySubstanceUnits(False), 'set "hasOnlySubstanceUnits" on s1' ) return s1
[docs] def addParameter(self, param_id, val, units="per_second"): """Add Parameter with value and unit. :param param_id: parameter id/name :type param_id: str :param val: value for the parameter :type val: float :param units: unit for the parameter :type units: str """ k = self.model.createParameter() self.check(k, "create parameter k") self.check(k.setId(param_id), "set parameter k id") self.check(k.setConstant(True), 'set parameter k "not constant"') self.check(k.setValue(val), "set parameter k value") self.check(k.setUnits(units), "set parameter k units") return k
[docs] def addReaction( self, reactants, products, expression, local_params=None, rxn_id="" ): """Create reaction provided with reactants and products in lists :param reactants: list of species id for reactants :type reactants: list :param products: list of species id for products :type products: list :param expression: reaction rate expression :type expression: str :param local_params: keys are the param id and values are their respective values :type local_params: dict :param rxn_id: id for the reaction :type rxn_id: str, optional """ r1 = self.model.createReaction() self.check(r1, "create reaction") if len(rxn_id) == 0: rxn_id = "v" + str(self.model.getNumReactions()) self.check(r1.setId(rxn_id), "set reaction id") self.check(r1.setReversible(False), "set reaction reversibility flag") self.check(r1.setFast(False), 'set reaction "fast" attribute') for re in reactants: if re is not None and "$" in re: re.translate(None, "$") re_split = re.split() if len(re_split) == 1: sto = 1.0 re_id = re elif len(re_split) == 2 and re_split[0].isdigit(): sto = float(re_split[0]) re_id = re_split[1] else: err_msg = ( "Error: reactants must be listed in format 'S' or '(float)' S'" ) raise SystemExit(err_msg) s1 = self.model.getSpecies(re_id) species_ref1 = r1.createReactant() self.check(species_ref1, "create reactant") self.check(species_ref1.setSpecies(s1.getId()), "assign reactant species") self.check( species_ref1.setStoichiometry(sto), "assign reactant stoichiometry" ) if self.document.getLevel() == 3: self.check( species_ref1.setConstant(True), 'set "constant" on species ref 1' ) for pro in products: if pro is not None and "$" in pro: pro.translate(None, "$") pro_split = pro.split() if len(pro_split) == 1: sto = 1.0 pro_id = pro elif len(pro_split) == 2: sto = float(pro_split[0]) pro_id = pro_split[1] else: err_msg = "Error: products must be listed in format 'S' or '(float)' S'" raise SystemExit(err_msg) s2 = self.model.getSpecies(pro_id) species_ref2 = r1.createProduct() self.check(species_ref2, "create product") self.check(species_ref2.setSpecies(s2.getId()), "assign product species") self.check(species_ref2.setStoichiometry(sto), "set product stoichiometry") if self.document.getLevel() == 3: self.check( species_ref2.setConstant(True), 'set "constant" on species ref 2' ) math_ast = libsbml.parseL3Formula(expression) self.check(math_ast, "create AST for rate expression") kinetic_law = r1.createKineticLaw() self.check(kinetic_law, "create kinetic law") self.check(kinetic_law.setMath(math_ast), "set math on kinetic law") if local_params is not None: for param in local_params.keys(): val = local_params.get(param) if self.document.getLevel() == 3: p = kinetic_law.createLocalParameter() else: p = kinetic_law.createParameter() self.check(p, "create local parameter") self.check(p.setId(param), "set id of local parameter") self.check(p.setValue(val), "set value of local parameter") return r1
[docs] def addEvent( self, trigger, assignments, persistent=True, initial_value=False, priority=0, delay=0, event_id="", ): """Add event supplied with when an event is triggered and what happens using assignments in a dictionary. :param trigger: define when an event is triggered (logical expression) :type trigger: str :param assignments: keys are the variables to be modified and the values are the new values :type assignments: dict :param persistent: determine if the event will still be executed if trigger turns from True to False :type persistent: boolean :param initial_value: value of trigger before t=0 :type initial_value: boolean :param priority: determine which event is executed, event with larger priority is executed :type priority: float :param delay: time between when the event is triggered and the assignment is implemented :type delay: float :param event_id: id of the event :type event_id: str """ e1 = self.model.createEvent() self.check(e1, "create event") if len(event_id) == 0: event_id = "e" + str(self.model.getNumEvents()) self.check(e1.setId(event_id), "add id to event") if self.document.getLevel() == 3 or ( self.document.getLevel() == 2 and self.document.getVersion() == 4 ): self.check( e1.setUseValuesFromTriggerTime(True), "set use values from trigger time" ) tri = e1.createTrigger() self.check(tri, "add trigger to event") tri_ast = libsbml.parseL3Formula(trigger) self.check(tri.setMath(tri_ast), "add formula to trigger") if self.document.getLevel() == 3: self.check(tri.setPersistent(persistent), "set persistence of trigger") self.check( tri.setInitialValue(initial_value), "set initial value of trigger" ) de = e1.createDelay() if self.document.getLevel() == 3: k = self.addParameter(event_id + "Delay", delay, self.model.getTimeUnits()) else: k = self.addParameter(event_id + "Delay", delay, "time") self.check(de, "add delay to event") delay_ast = libsbml.parseL3Formula(k.getId()) self.check(de.setMath(delay_ast), "set formula for delay") for a in assignments.keys(): assign = e1.createEventAssignment() self.check(assign, "add event assignment to event") self.check(assign.setVariable(a), "add variable to event assignment") val_ast = libsbml.parseL3Formula(assignments.get(a)) self.check(assign.setMath(val_ast), "add value to event assignment") if self.document.getLevel() == 3: pri = e1.createPriority() pri_ast = libsbml.parseL3Formula(str(priority)) self.check(pri.setMath(pri_ast), "add priority to event") return e1
[docs] def addAssignmentRule(self, var, math): """To assign a state variable with an expression. :param var: id of the state variable :type var: str :param math: expression in str :type math: str """ r = self.model.createAssignmentRule() self.check(r, "create assignment rule r") self.check(r.setVariable(var), "set assignment rule variable") math_ast = libsbml.parseL3Formula(math) self.check(r.setMath(math_ast), "set assignment rule equation") return r
[docs] def addRateRule(self, var, math, rr_id=""): """Describe the derivative of the state variable wrt time as an expression. :param var: id of the state variable :type var: str :param math: expression in str :type math: str :param rr_id: id for the reaction rate :type rr_id: str, optional """ r = self.model.createRateRule() self.check(r, "create rate rule r") if len(rr_id) == 0: rr_id = "Rate" + str(self.model.getNumRules()) r.setIdAttribute(rr_id) # print("rr_id=", r.getIdAttribute()) # self.check(r.setId(rr_id), 'set rate rule id') self.check(r.setVariable(var), "set rate rule variable") math_ast = libsbml.parseL3Formula(math) self.check(r.setMath(math_ast), "set rate rule equation") return r
[docs] def addInitialAssignment(self, symbol, math): """Describe the initial value of the variable in terms of other variables or parameters. :param symbol: id of the variable :type symbol: str :param math: expression :type math: str """ if self.document.getLevel() == 2 and self.document.getVersion() == 1: raise SystemExit( "Error: InitialAssignment does not exist for \ this level and version." ) a = self.model.createInitialAssignment() self.check(a, "create initial assignment a") self.check(a.setSymbol(symbol), "set initial assignment a symbol") math_ast = libsbml.parseL3Formula(math) self.check(a.setMath(math_ast), "set initial assignment a math") return a
[docs] def setLevelAndVersion(self, level, version): """Set the level and version of the SBML. :param level: level of the sbml :type level: int :param version: version of the sbml :type version: int """ if level == 2 and version == 1: self.check( self.document.checkL2v1Compatibility(), "convert to level 2 version 1" ) elif level == 2 and version == 2: self.check( self.document.checkL2v2Compatibility(), "convert to level 2 version 2" ) elif level == 2 and version == 3: self.check( self.document.checkL2v3Compatibility(), "convert to level 2 version 3" ) elif level == 2 and version == 4: self.check( self.document.checkL2v4Compatibility(), "convert to level 2 version 4" ) elif level == 3 and version == 1: self.check( self.document.checkL3v1Compatibility(), "convert to level 3 version 1" ) else: raise SystemExit("Invalid level/version combination") isSet = self.document.setLevelAndVersion(level, version) self.check(isSet, "convert to level " + str(level) + " version " + str(version))
[docs] def getDocument(self): """Return document.""" return self.document
[docs] def getModel(self): """Return Model.""" return self.model
[docs] def getSpecies(self, species_id): """Return Species.""" return self.model.getSpecies(species_id)
[docs] def getListOfSpecies(self): """Return list of species.""" return self.model.getListOfSpecies()
[docs] def getParameter(self, param_id): """Return parameter.""" return self.model.getParameter(param_id)
[docs] def getListOfParameters(self): """Return list of parameters.""" return self.model.getListOfParameters()
[docs] def getReaction(self, rxn_id): """Return Reaction.""" return self.model.getReaction(rxn_id)
[docs] def getListOfReactions(self): """Return list of reactions.""" return self.model.getListOfReactions()
[docs] def getCompartment(self, comp_id): """Return compartment.""" return self.model.getCompartment(comp_id)
[docs] def getListOfEvents(self): """Return list of events.""" return self.model.getListOfEvents()
[docs] def getEvent(self, event_id): """Return event.""" return self.model.getEvent(event_id)
[docs] def getListOfCompartments(self): """Return list of compartments.""" return self.model.getListOfCompartments()
[docs] def getRule(self, var): """Return rule.""" return self.model.getRule(var)
[docs] def getListOfRules(self): """Return list of rules.""" return self.model.getListOfRules()
[docs] def getInitialAssignment(self, var): """Return initial assignment.""" return self.model.getInitialAssignment(var)
[docs] def getListOfInitialAssignments(self): """Return list of initial assignments.""" return self.model.getListOfInitialAssignments()
[docs] def toSBML(self): """Return the model in SBML format as strings.""" errors = self.document.checkConsistency() if errors > 0: for i in range(errors): print( self.document.getError(i).getSeverityAsString(), ": ", self.document.getError(i).getMessage(), ) return libsbml.writeSBMLToString(self.document)
def __repr__(self): return self.toSBML()
[docs]def writeCode(doc): """Return string containing calls to functions that reproduce the model in SBML doc. """ comp_template = "model.addCompartment(vol=%s, comp_id='%s');" species_template = "model.addSpecies(species_id='%s', amt=%s, comp='%s');" param_template = "model.addParameter(param_id='%s', val=%s, units='%s');" rxn_template = ( "model.addReaction(reactants=%s, products=%s, " "expression='%s', local_params=%s, rxn_id='%s');" ) event_template = ( "model.addEvent(trigger='%s', assignments=%s, persistent=%s, " "initial_value=%s, priority=%s, delay=%s, event_id='%s');" ) event_defaults = [True, False, "0", 0] assignrule_template = "model.addAssignmentRule(var='%s', math='%s');" raterule_template = "model.addRateRule(var='%s', math='%s', rr_id='%s');" initassign_template = "model.addInitialAssignment(symbol='%s', math='%s')" init_template = ( "import simplesbml\nmodel = simplesbml.sbmlModel(time_units='%s', " "extent_units='%s', sub_units='%s', level=%s, version=%s);" ) init_defaults = ["min", "Molar", "Molar", 3, 1] command_list = [] if doc.getLevel() == 1: warnings.warn("Warning: SimpleSBML does not support SBML Level 1.") props = libsbml.ConversionProperties() props.addOption("flatten comp", True) result = doc.convert(props) if result != libsbml.LIBSBML_OPERATION_SUCCESS: raise SystemExit("Conversion failed: (" + str(result) + ")") mod = doc.getModel() comps = mod.getListOfCompartments() species = mod.getListOfSpecies() params = mod.getListOfParameters() rxns = mod.getListOfReactions() events = mod.getListOfEvents() rules = mod.getListOfRules() print("rules", rules) inits = [] if doc.getLevel() == 3 or (doc.getLevel() == 2 and doc.getVersion() > 1): inits = mod.getListOfInitialAssignments() timeUnits = "min" # second substanceUnits = "Molar" # mole extentUnits = "Molar" # mole if doc.getLevel() == 3: timeUnits = mod.getTimeUnits() extentUnits = mod.getExtentUnits() substanceUnits = mod.getSubstanceUnits() level = mod.getLevel() version = mod.getVersion() init_list = [timeUnits, extentUnits, substanceUnits, level, version] for i in range(0, 5): if init_list[i] == init_defaults[i]: init_list[i] = "del" command_list.append( init_template % (init_list[0], init_list[1], init_list[2], init_list[3], init_list[4]) ) for comp in comps: if comp.getId() != "c1": if comp.getId()[0] == "c" and comp.getId()[1 : len(comp.getId())].isdigit(): if comp.getSize() == 1e-15: command_list.append(comp_template % ("del", "del")) else: command_list.append(comp_template % (comp.getSize(), "del")) else: if comp.getSize() == 1e-15: command_list.append(comp_template % ("del", comp.getId())) else: command_list.append(comp_template % (comp.getSize(), comp.getId())) for s in species: conc = s.getInitialConcentration() amt = s.getInitialAmount() sid = s.getId() if s.getCompartment() == "c1": comp = "del" else: comp = s.getCompartment() bc = s.getBoundaryCondition() if bc: sid = "$" + sid if isnan(conc) or amt > conc: command_list.append(species_template % (sid, str(amt), comp)) else: command_list.append(species_template % ("[" + sid + "]", str(conc), comp)) for p in params: val = p.getValue() pid = p.getId() if p.getUnits() == "per_second": units = "del" else: units = p.getUnits() isDelay = pid.find("Delay") if isDelay == -1: command_list.append(param_template % (pid, str(val), str(units))) for v in rxns: vid = v.getId() if vid[0] == "v" and vid[1 : len(vid)].isdigit(): vid = "del" reactants = [] for r in v.getListOfReactants(): reactants.append( (str(r.getStoichiometry()) + " " + r.getSpecies()).replace("1.0 ", "") ) products = [] for p in v.getListOfProducts(): products.append( (str(p.getStoichiometry()) + " " + p.getSpecies()).replace("1.0 ", "") ) expr = libsbml.formulaToString(v.getKineticLaw().getMath()) local_params = {} local_ids = [] local_values = [] for k in v.getKineticLaw().getListOfParameters(): local_ids.append(k.getId()) local_values.append(k.getValue()) local_params = dict(zip(local_ids, local_values)) if len(local_params) == 0: local_params = "del" command_list.append( rxn_template % (str(reactants), str(products), expr, str(local_params), vid) ) for e in events: persistent = True initialValue = False priority = "0" eid = e.getId() if len(eid) == 0 or (eid[0] == "e" and eid[1 : len(eid)].isdigit()): eid = "del" if doc.getLevel() == 3: persistent = e.getTrigger().getPersistent() initialValue = e.getTrigger().getInitialValue() priority = e.getPriority() if isinstance(priority, libsbml.Priority): priority = libsbml.formulaToL3String(priority.getMath()) else: priority = "0" tri = libsbml.formulaToL3String(e.getTrigger().getMath()) did = e.getDelay() if isinstance(did, libsbml.Delay): delay = libsbml.formulaToL3String(did.getMath()) else: delay = "0" assigns = e.getListOfEventAssignments() var = [] values = [] for assign in assigns: var.append(assign.getVariable()) values.append(libsbml.formulaToL3String(assign.getMath())) assigns = dict(zip(var, values)) event_list = [persistent, initialValue, priority, delay] for i in range(0, 4): if event_list[i] == event_defaults[i]: event_list[i] = "del" command_list.append( event_template % ( tri, str(assigns), event_list[0], event_list[1], event_list[2], event_list[3], eid, ) ) for r in rules: rid = r.getId() print("rid") # if rid[0] == 'Rate' and rid[1:len(rid)].isdigit(): # rid = 'del' sym = r.getVariable() math = libsbml.formulaToL3String(r.getMath()) if r.getTypeCode() == libsbml.SBML_ASSIGNMENT_RULE: command_list.append(assignrule_template % (sym, math)) elif r.getTypeCode() == libsbml.SBML_RATE_RULE: command_list.append(raterule_template % (sym, math, rid)) else: pass for i in inits: sym = i.getSymbol() math = libsbml.formulaToL3String(i.getMath()) command_list.append(initassign_template % (sym, math)) commands = "\n".join(command_list) commands = sub(r"\w+='?del'?(?=[,)])", "", commands) commands = sub(r"\((, )+", "(", commands) commands = sub(r"(, )+\)", ")", commands) commands = sub("(, )+", ", ", commands) return commands
[docs]def writeCodeFromFile(filename): """Read the SBML format model and returns strings containing calls to functions to reproduce the model in an sbmlModel object. """ reader = libsbml.SBMLReader() doc = reader.readSBMLFromFile(filename) if doc.getNumErrors() > 0: raise SystemExit(doc.getError(0)) return writeCode(doc)
[docs]def writeCodeFromString(sbmlstring): """Read sbmlstring as the SBML format model and return strings containing calls to functions to reproduce the model in an sbmlModel object. """ reader = libsbml.SBMLReader() doc = reader.readSBMLFromString(sbmlstring) return writeCode(doc)