def id_html(item: libsbml.SBase) -> str:
"""Create info from id and metaid.
:param item: SBML object for which info is to be generated
:return: HTML code fragment enclosing info for item
"""
sid = item.getId()
meta = metaid_html(item)
if sid:
display_sid = sid
if isinstance(item, libsbml.RateRule) and item.isSetVariable():
display_sid = "d {}/dt".format(item.getVariable())
info = f"""
<td id="{sid}" class="active">
<span class="package">{display_sid}</span> {meta}
"""
else:
if meta:
info = f'<td class="active">{meta}'
else:
info = f'<td class="active">{empty_html()}'
# create modal information
info += xml_modal(item)
return info
def _create_hash_id(sbase: libsbml.SBase) -> str:
if sbase and hasattr(sbase, "getId") and sbase.isSetId():
hash_key = sbase.getId()
else:
# hash the xml_node
xml_node = sbase.toXMLNode() # type: libsbml.XMLNode
xml_str = xml_node.toString().encode("utf-8")
hash_key = hashlib.md5(xml_str).hexdigest()
return hash_key
def _get_pk(sbase: libsbml.SBase) -> str:
"""Calculate primary key."""
if not hasattr(sbase, "pk"):
pk: str = f"{SBMLDocumentInfo._sbml_type(sbase)}:"
if sbase.isSetId():
pk += sbase.getId()
elif sbase.isSetMetaId():
pk += sbase.getMetaId()
else:
xml = sbase.toSBML()
pk += SBMLDocumentInfo._uuid(xml)
sbase.pk = pk
return pk
def sbase_dict(cls, 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
"""
pk = cls._get_pk(sbase)
d = {
"pk": pk,
"sbmlType": cls._sbml_type(sbase),
"id": sbase.getId() if sbase.isSetId() else None,
"metaId": sbase.getMetaId() if sbase.isSetMetaId() else None,
"name": sbase.getName() if sbase.isSetName() else None,
"sbo": sbase.getSBOTermID() if sbase.isSetSBOTerm() else None,
"cvterms": cls.cvterms(sbase),
"history": cls.model_history(sbase),
"notes": sbase.getNotesString() if sbase.isSetNotes() else None,
}
# TODO: add the ports information
if sbase.getTypeCode() in {libsbml.SBML_DOCUMENT, libsbml.SBML_MODEL}:
d["xml"] = None
else:
d["xml"] = sbase.toSBML()
# 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()
d["replacedBy"] = {
"submodelRef": submodel_ref,
"replacedBySbaseref": cls._sbaseref(replaced_by),
}
else:
d["replacedBy"] = None
# ListOfReplacedElements
if item_comp.getNumReplacedElements() > 0:
replaced_elements = []
for rep_el in item_comp.getListOfReplacedElements():
submodel_ref = rep_el.getSubmodelRef()
replaced_elements.append({
"submodelRef":
submodel_ref,
"replacedElementSbaseref":
cls._sbaseref(rep_el),
})
d["replacedElements"] = replaced_elements
else:
d["replacedElements"] = None
# distrib
sbml_distrib: libsbml.DistribSBasePlugin = sbase.getPlugin("distrib")
if sbml_distrib and isinstance(sbml_distrib,
libsbml.DistribSBasePlugin):
d["uncertainties"] = []
for uncertainty in sbml_distrib.getListOfUncertainties():
u_dict = SBMLDocumentInfo.sbase_dict(uncertainty)
u_dict["uncertaintyParameters"] = []
upar: libsbml.UncertParameter
for upar in uncertainty.getListOfUncertParameters():
param_dict = {
"var":
upar.getVar() if upar.isSetVar() else None,
"value":
upar.getValue() if upar.isSetValue() else None,
"units":
upar.getUnits() if upar.isSetUnits() else None,
"type":
upar.getTypeAsString() if upar.isSetType() else None,
"definitionURL":
upar.getDefinitionURL()
if upar.isSetDefinitionURL() else None,
"math":
astnode_to_latex(upar.getMath())
if upar.isSetMath() else None,
}
u_dict["uncertaintyParameters"].append(param_dict)
d["uncertainties"].append(u_dict)
return d
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