def info_events(self) -> List[Dict[str, Any]]:
"""Information dictionaries for Events.
:return: list of info dictionaries for Events
"""
data = []
for event in self.model.getListOfEvents(): # type: libsbml.Event
info = self.info_sbase(event)
trigger = event.getTrigger()
info["trigger"] = f"""
{math(trigger, self.math_render)}
<br />initialValue = {trigger.initial_value}
<br /> persistent = {trigger.persistent}
"""
priority = empty_html()
if event.isSetPriority():
priority = event.getPriority()
info["priority"] = priority
delay = empty_html()
if event.isSetDelay():
delay = event.getDelay()
info["delay"] = delay
assignments = ""
for eva in event.getListOfEventAssignments():
assignments += f"{eva.getId()} = {math(eva, self.math_render)}<br />"
if len(assignments) == 0:
assignments = empty_html()
info["assignments"] = assignments
data.append(info)
return data
def info_submodels(self) -> List[Dict[str, Any]]:
"""Information dictionaries for comp:Submodels.
:return: list of info dictionaries for comp:Submodels
"""
data = []
model_comp = self.model.getPlugin("comp")
if model_comp:
for submodel in model_comp.getListOfSubmodels(
): # type: libsbml.Submodel
info = self.info_sbase(submodel)
info["model_ref"] = submodel.getModelRef()
deletions = []
for deletion in submodel.getListOfDeletions():
deletions.append(sbaseref(deletion))
if len(deletions) == 0:
deletions_combined = empty_html()
else:
deletions_combined = "<br />".join(deletions)
info["deletions"] = deletions_combined
time_conversion = empty_html()
if submodel.isSetTimeConversionFactor():
time_conversion = submodel.getTimeConversionFactor()
info["time_conversion"] = time_conversion
extent_conversion = empty_html()
if submodel.isSetExtentConversionFactor():
extent_conversion = submodel.getExtentConversionFactor()
info["extent_conversion"] = extent_conversion
data.append(info)
return data
def info_species(self) -> List[Dict[str, Any]]:
"""Information dictionaries for Species.
:return: list of info dictionaries for Species
"""
data = []
for s in self.model.getListOfSpecies(): # type: libsbml.Species
info = self.info_sbase(s)
info["compartment"] = s.compartment
info["has_only_substance_units"] = boolean(
s.has_only_substance_units)
info["boundary_condition"] = boolean(s.boundary_condition)
info["constant"] = boolean(s.constant)
if s.isSetInitialAmount():
initial_amount = s.initial_amount
else:
initial_amount = empty_html()
info["initial_amount"] = initial_amount
if s.isSetInitialConcentration():
initial_concentration = s.initial_concentration
else:
initial_concentration = empty_html()
info["initial_concentration"] = initial_concentration
info["units"] = s.getUnits()
info["substance_units"] = s.substance_units
info["derived_units"] = derived_units(s)
if s.isSetConversionFactor():
cf_sid = s.getConversionFactor()
cf_p = self.model.getParameter(
cf_sid) # type: libsbml.Parameter
cf_value = cf_p.getValue()
cf_units = cf_p.getUnits()
info["conversion_factor"] = f"{cf_sid}={cf_value} [{cf_units}]"
else:
info["conversion_factor"] = empty_html()
# fbc
sfbc = s.getPlugin("fbc")
if sfbc:
if sfbc.isSetChemicalFormula():
info["fbc_formula"] = sfbc.getChemicalFormula()
if sfbc.isSetCharge():
c = sfbc.getCharge()
if c != 0:
info["fbc_charge"] = f"({sfbc.getCharge()})"
if ("fbc_formula" in info) or ("fbc_charge" in info):
info["fbc"] = f"""
<br />
<code>
{info.get('fbc_formula', '')}{info.get('fbc_charge', '')}
</code>
"""
data.append(info)
return data
def info_reactions(self) -> List[Dict[str, Any]]:
"""Information dictionaries for ListOfReactions.
:return: list of info dictionaries for Reactions
"""
data = []
for r in self.model.getListOfReactions(): # type: libsbml.Reaction
info = self.info_sbase(r)
if r.reversible:
reversible = '<td class ="success">⇆</td>'
else:
reversible = '<td class ="danger">➞</td>'
info["reversible"] = reversible
info["equation"] = formating.equationStringFromReaction(r)
modifiers = [mod.getSpecies() for mod in r.getListOfModifiers()]
if modifiers:
modifiers_html = "<br />".join(modifiers)
else:
modifiers_html = empty_html()
info["modifiers"] = modifiers_html
klaw = r.getKineticLaw()
info["formula"] = math(klaw, self.math_render)
info["derived_units"] = derived_units(klaw)
# fbc
info["fbc_bounds"] = formating.boundsStringFromReaction(
r, self.model)
info[
"fbc_gpa"] = formating.geneProductAssociationStringFromReaction(
r)
data.append(info)
return data
def info_compartments(
self, assignment_map: Dict[str, str]) -> List[Dict[str, Any]]:
"""Information dictionaries for Compartments.
:param assignment_map: map of assignments for symbols
:return: list of info dictionaries for Compartments
"""
data = []
for c in self.model.getListOfCompartments(
): # type: libsbml.Compartment
info = self.info_sbase(c)
info["units"] = c.units
if c.isSetSpatialDimensions():
spatial_dimensions = c.spatial_dimensions
else:
spatial_dimensions = empty_html()
info["spatial_dimensions"] = spatial_dimensions
info["constant"] = boolean(c.constant)
info["derived_units"] = derived_units(c)
if c.isSetSize():
size = c.size
else:
size = math(assignment_map.get(c.id, ""), self.math_render)
info["size"] = size
data.append(info)
return data
def info_gene_products(self) -> List[Dict[str, Any]]:
"""Information dictionaries for GeneProducts.
:return: list of info dictionaries for Reactions
"""
data = []
mfbc = self.model.getPlugin("fbc")
if mfbc:
for gp in mfbc.getListOfGeneProducts(
): # type: libsbml.GeneProduct
info = self.info_sbase(gp)
info["label"] = gp.label
associated_species = empty_html()
if gp.isSetAssociatedSpecies():
associated_species = gp.associated_species
info["associated_species"] = associated_species
data.append(info)
return data
def info_sbase(sbase: libsbml.SBase) -> Dict[str, Any]:
"""Info dictionary for SBase.
:param sbase: SBase instance for which info dictionary is to be created
:return info dictionary for item
"""
info = {
"object": sbase,
"id": sbase.getId(),
"metaId": metaid_html(sbase),
"sbo": sbo(sbase),
"cvterm": cvterm(sbase),
"notes": notes(sbase),
"annotation": annotation_html(sbase),
}
if sbase.isSetName():
name = sbase.name
else:
name = empty_html()
info["name"] = name
info["id_html"] = id_html(sbase)
# comp
item_comp = sbase.getPlugin("comp")
if item_comp and type(item_comp) == libsbml.CompSBasePlugin:
# ReplacedBy
if item_comp.isSetReplacedBy():
replaced_by = item_comp.getReplacedBy()
submodel_ref = replaced_by.getSubmodelRef()
info["replaced_by"] = f"""
<br /><i class="fa fa-arrow-circle-right" aria-hidden="true"></i>
<code>ReplacedBy {submodel_ref}:{sbaseref(replaced_by)}</code>
"""
# ListOfReplacedElements
if item_comp.getNumReplacedElements() > 0:
replaced_elements = []
for rep_el in item_comp.getListOfReplacedElements():
submodel_ref = rep_el.getSubmodelRef()
replaced_elements.append(f"""
<br /><i class="fa fa-arrow-circle-left" aria-hidden="true"></i>
<code>ReplacedElement {submodel_ref}:{sbaseref(rep_el)}</code>
""")
if len(replaced_elements) == 0:
replaced_elements_combined = ""
else:
replaced_elements_combined = "".join(replaced_elements)
info["replaced_elements"] = replaced_elements_combined
# distrib
sbml_distrib: libsbml.DistribSBasePlugin = sbase.getPlugin("distrib")
if sbml_distrib and isinstance(sbml_distrib,
libsbml.DistribSBasePlugin):
info["uncertainties"] = []
info["uncert_strings"] = []
for uncertainty in sbml_distrib.getListOfUncertainties():
u_dict = SBMLModelInfo.info_sbase(uncertainty)
u_dict["uncert_parameters"] = []
u_dict["uncert_params_strings"] = []
upar: libsbml.UncertParameter
for upar in uncertainty.getListOfUncertParameters():
param_dict = {}
param_str = ""
if upar.isSetVar():
param_dict["var"] = upar.getVar()
param_str += f"{param_dict['var']}, "
if upar.isSetValue():
param_dict["value"] = upar.getValue()
param_str += f"{param_dict['value']}, "
if upar.isSetUnits():
param_dict["units"] = upar.getUnits()
param_str += f"{param_dict['units']}, "
if upar.isSetType():
param_dict["type"] = upar.getTypeAsString()
param_str += f"{param_dict['type']}, "
if upar.isSetDefinitionURL():
param_dict["definition_url"] = f"""
<a href='{upar.getDefinitionURL()}'>
{upar.getDefinitionURL()}</a>
"""
param_str += param_dict["definition_url"]
if upar.isSetMath():
param_dict["math"] = formating.math(upar.getMath())
param_str += f"{param_dict['math']}, "
# create param info string
param_str = "<li>"
for key in param_dict.keys():
param_str += f"{key}:{param_dict.get(key, '')}, "
param_str += "</li>"
u_dict["uncert_parameters"].append(param_dict)
u_dict["uncert_params_strings"].append(param_str)
info["uncertainties"].append(u_dict)
return info