def test_CVTerm_createFromNode(self):
qual_triple = libsbml.XMLTriple("is", "", "bqbiol")
bag_triple = libsbml.XMLTriple()
li_triple = libsbml.XMLTriple()
att = libsbml.XMLAttributes()
att.add("", "This is my resource")
att1 = libsbml.XMLAttributes()
li_token = libsbml.XMLToken(li_triple, att)
bag_token = libsbml.XMLToken(bag_triple, att1)
qual_token = libsbml.XMLToken(qual_triple, att1)
li = libsbml.XMLNode(li_token)
bag = libsbml.XMLNode(bag_token)
node = libsbml.XMLNode(qual_token)
bag.addChild(li)
node.addChild(bag)
term = libsbml.CVTerm(node)
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(term.getBiologicalQualifierType() == libsbml.BQB_IS)
xa = term.getResources()
self.assert_(xa.getLength() == 1)
self.assert_(("rdf:resource" == xa.getName(0)))
self.assert_(("This is my resource" == xa.getValue(0)))
_dummyList = [qual_triple]
_dummyList[:] = []
del _dummyList
_dummyList = [bag_triple]
_dummyList[:] = []
del _dummyList
_dummyList = [li_triple]
_dummyList[:] = []
del _dummyList
_dummyList = [li_token]
_dummyList[:] = []
del _dummyList
_dummyList = [bag_token]
_dummyList[:] = []
del _dummyList
_dummyList = [qual_token]
_dummyList[:] = []
del _dummyList
_dummyList = [att]
_dummyList[:] = []
del _dummyList
_dummyList = [att1]
_dummyList[:] = []
del _dummyList
_dummyList = [term]
_dummyList[:] = []
del _dummyList
_dummyList = [node]
_dummyList[:] = []
del _dummyList
_dummyList = [bag]
_dummyList[:] = []
del _dummyList
_dummyList = [li]
_dummyList[:] = []
del _dummyList
pass
def reactionAnnotationsToSBML(sbmlDocument, annotationDict):
'''
Receives a series of annotations associated with their associated species
and fills in a corresponding sbmlDocument with this information
'''
for reaction in sbmlDocument.getModel().getListOfReactions():
transformedName = reaction.getName()
if len(annotationDict[transformedName]) == 0:
continue
for element in annotationDict[transformedName]:
term = libsbml.CVTerm()
if element.startswith('BQB'):
term.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
term.setBiologicalQualifierType(bioqual.index(element))
else:
term.setQualifierType(libsbml.MODEL_QUALIFIER)
term.setModelQualifierType(modqual.index(element))
for annotation in annotationDict[transformedName][element]:
term.addResource(annotation)
reaction.addCVTerm(term)
annotation = libsbml.RDFAnnotationParser.createAnnotation()
cvterms = libsbml.RDFAnnotationParser.createCVTerms(reaction)
rdfAnnotation = libsbml.RDFAnnotationParser.createRDFAnnotation()
rdfAnnotation.addChild(cvterms)
annotation.addChild(rdfAnnotation)
reaction.setAnnotation(annotation)
def test_CVTerm_setBiolQualifierType(self):
term = libsbml.CVTerm(libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(term.getModelQualifierType() == libsbml.BQM_UNKNOWN)
self.assert_(term.getBiologicalQualifierType() == libsbml.BQB_UNKNOWN)
i = term.setBiologicalQualifierType(libsbml.BQB_IS)
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
self.assert_(term.getQualifierType() == libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(term.getBiologicalQualifierType() == libsbml.BQB_IS)
self.assert_(term.getModelQualifierType() == libsbml.BQM_UNKNOWN)
i = term.setQualifierType(libsbml.MODEL_QUALIFIER)
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
self.assert_(term.getModelQualifierType() == libsbml.BQM_UNKNOWN)
self.assert_(term.getBiologicalQualifierType() == libsbml.BQB_UNKNOWN)
i = term.setBiologicalQualifierType(libsbml.BQB_IS)
self.assert_(i == libsbml.LIBSBML_INVALID_ATTRIBUTE_VALUE)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
self.assert_(term.getModelQualifierType() == libsbml.BQM_UNKNOWN)
self.assert_(term.getBiologicalQualifierType() == libsbml.BQB_UNKNOWN)
_dummyList = [term]
_dummyList[:] = []
del _dummyList
pass
def annotate_sbase(sbase: libsbml.SBase, annotation: Annotation):
""" Annotate SBase based on given annotation data
:param sbase: libsbml.SBase
:param annotation: Annotation
:return:
"""
qualifier, resource = annotation.qualifier.value, annotation.resource
cv = libsbml.CVTerm() # type: libsbml.CVTerm
# set correct type of qualifier
if qualifier.startswith("BQB"):
cv.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
sbml_qualifier = ModelAnnotator.get_SBMLQualifier(qualifier)
cv.setBiologicalQualifierType(sbml_qualifier)
elif qualifier.startswith('BQM'):
cv.setQualifierType(libsbml.MODEL_QUALIFIER)
sbml_qualifier = ModelAnnotator.get_SBMLQualifier(qualifier)
cv.setModelQualifierType(sbml_qualifier)
else:
LOGGER.error('Unsupported qualifier: {}'.format(qualifier))
cv.addResource(resource)
# meta id has to be set
if not sbase.isSetMetaId():
sbase.setMetaId(utils.create_metaid(sbase))
success = sbase.addCVTerm(cv)
if success != 0:
LOGGER.error("RDF not written: ", success)
LOGGER.error(libsbml.OperationReturnValue_toString(success))
LOGGER.error("{}, {}, {}".format(object, qualifier, resource))
def speciesAnnotationsToSBML(sbmlDocument, annotationDict, speciesNameDict):
"""
Receives a series of annotations associated with their associated species
and fills in a corresponding sbmlDocument with this information
"""
for species in sbmlDocument.getModel().getListOfSpecies():
transformedName = speciesNameDict[species.getName()]
if len(annotationDict[transformedName]) == 0:
species.unsetCVTerms()
continue
for element in annotationDict[transformedName]:
term = libsbml.CVTerm()
if element.startswith("BQB"):
term.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
term.setBiologicalQualifierType(bioqual.index(element))
else:
term.setQualifierType(libsbml.MODEL_QUALIFIER)
term.setModelQualifierType(modqual.index(element))
for annotation in annotationDict[transformedName][element]:
term.addResource(annotation)
species.addCVTerm(term)
annotation = libsbml.RDFAnnotationParser.createAnnotation()
cvterms = libsbml.RDFAnnotationParser.createCVTerms(species)
rdfAnnotation = libsbml.RDFAnnotationParser.createRDFAnnotation()
if cvterms:
rdfAnnotation.addChild(cvterms)
else:
print(species)
annotation.addChild(rdfAnnotation)
species.setAnnotation(annotation)
def set_annotation(self, element, annotation, urn, elementtype):
'''
Set an annotation for a given SBML element.
Parameters
----------
element : libsbml object
Element that needs to be annotated.
annotation : str
The identifier part of the annotation string.
urn : str
URN that links to the external web resource.
elementtype : str
What kind of element needs to be annotated? Model or Biological?
'''
element.setMetaId(element.getId() + "_meta")
cv_term = libsbml.CVTerm()
if elementtype == 'Model':
cv_term.setQualifierType(0)
cv_term.setModelQualifierType(libsbml.BQB_IS)
else:
cv_term.setQualifierType(1)
cv_term.setBiologicalQualifierType(libsbml.BQB_IS)
resource_term = "http://identifiers.org/" + urn + '/' + annotation
cv_term.addResource(resource_term)
return cv_term
def test_CVTerm_create(self):
term = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
_dummyList = [term]
_dummyList[:] = []
del _dummyList
pass
def test_CVTerm_copyConstructor(self):
CVTerm1 = libsbml.CVTerm(libsbml.BIOLOGICAL_QUALIFIER)
CVTerm1.addResource("http://www.geneontology.org/#GO:0005892")
self.assert_(
CVTerm1.getQualifierType() == libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(CVTerm1.getResources().getLength() == 1)
self.assert_(CVTerm1.getResources().getValue(0) ==
"http://www.geneontology.org/#GO:0005892")
CVTerm2 = libsbml.CVTerm(CVTerm1)
self.assert_(
CVTerm2.getQualifierType() == libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(CVTerm2.getResources().getLength() == 1)
self.assert_(CVTerm2.getResources().getValue(0) ==
"http://www.geneontology.org/#GO:0005892")
CVTerm2 = None
CVTerm1 = None
pass
def add_annotation_for_rxn(rxn, ecs):
rxn.metaid = rxn.id
for ec in ecs:
cv = libsbml.CVTerm()
cv.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
cv.setBiologicalQualifierType(libsbml.BQB_IS)
cv.addResource("http://identifiers.org/ec-code/" + ec)
rxn.addCVTerm(cv)
def add_elem_dblinks(elem, dblinks):
if dblinks.strip() == "":
return
for dblink in dblinks.split("#"):
cv = libsbml.CVTerm()
cv.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
cv.setBiologicalQualifierType(libsbml.BQB_IS)
cv.addResource("http://identifiers.org/" + dblink)
elem.addCVTerm(cv)
def annotate_sbase(sbase: libsbml.SBase, annotation: Annotation) -> None:
"""Annotate SBase based on given annotation data.
:param sbase: libsbml.SBase
:param annotation: Annotation
:return:
"""
qualifier, resource = annotation.qualifier.value, annotation.resource
cv: libsbml.CVTerm = libsbml.CVTerm()
# set correct type of qualifier
if isinstance(qualifier, str):
if qualifier.startswith("BQB"):
cv.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
sbml_qualifier = ModelAnnotator.get_SBMLQualifier(qualifier)
success = check(
cv.setBiologicalQualifierType(str(sbml_qualifier)),
f"Set biological qualifier: '{sbml_qualifier}'",
)
if success != 0:
logger.error(
f"Could not set biological qualifier: {qualifier}")
elif qualifier.startswith("BQM"):
cv.setQualifierType(libsbml.MODEL_QUALIFIER)
sbml_qualifier = ModelAnnotator.get_SBMLQualifier(qualifier)
success = check(
cv.setModelQualifierType(str(sbml_qualifier)),
f"Set model qualifier: '{sbml_qualifier}'",
)
if success != 0:
logger.error(f"Could not set model qualifier: {qualifier}")
else:
logger.error(f"Unsupported qualifier: '{qualifier}'")
else:
msg = (f"qualifier is not a string, but: '{qualifier}' of type "
f"'{type(qualifier)}'.")
logger.error(msg)
raise ValueError(msg)
success = check(cv.addResource(resource),
f"Add resource: '{resource}'")
if success != 0:
logger.error(f"Could not add resource: {resource}")
# meta id has to be set
if not sbase.isSetMetaId():
sbase.setMetaId(utils.create_metaid(sbase))
success = sbase.addCVTerm(cv)
if success != 0:
logger.error(
f"Annotation RDF for CVTerm could not be written: {cv}")
logger.error(libsbml.OperationReturnValue_toString(success))
logger.error(f"{sbase}, {qualifier}, {resource}")
def test_Validation_CVTerm1(self):
cv = libsbml.CVTerm()
self.assert_(cv != None)
self.assertEqual(False, (cv.hasRequiredAttributes()))
cv.setQualifierType(libsbml.MODEL_QUALIFIER)
self.assertEqual(False, (cv.hasRequiredAttributes()))
cv.setModelQualifierType(libsbml.BQM_IS)
self.assertEqual(False, (cv.hasRequiredAttributes()))
cv.addResource("ggg")
self.assertEqual(True, (cv.hasRequiredAttributes()))
cv = None
pass
def test_Validation_CVTerm2(self):
cv = libsbml.CVTerm()
self.assert_(cv != None)
self.assertEqual(False, (cv.hasRequiredAttributes()))
cv.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
self.assertEqual(False, (cv.hasRequiredAttributes()))
cv.setBiologicalQualifierType(libsbml.BQB_IS)
self.assertEqual(False, (cv.hasRequiredAttributes()))
cv.addResource("ggg")
self.assertEqual(True, (cv.hasRequiredAttributes()))
cv = None
pass
def test_CVTerm_addResource(self):
term = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
resource = "GO6666"
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
term.addResource(resource)
xa = term.getResources()
self.assert_(xa.getLength() == 1)
self.assert_(("rdf:resource" == xa.getName(0)))
self.assert_(("GO6666" == xa.getValue(0)))
_dummyList = [term]
_dummyList[:] = []
del _dummyList
pass
def test_CVTerm_getResources(self):
term = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
resource = "GO6666"
resource1 = "OtherURI"
term.addResource(resource)
term.addResource(resource1)
number = term.getNumResources()
self.assert_(number == 2)
self.assert_(("GO6666" == term.getResourceURI(0)))
self.assert_(("OtherURI" == term.getResourceURI(1)))
_dummyList = [term]
_dummyList[:] = []
del _dummyList
pass
def test_RDFAnnotation_testMissingMetaId(self):
doc = libsbml.SBMLDocument(3, 1)
model = doc.createModel()
self.assert_(model != None)
model.setId("test1")
term = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
term.addResource("testResource")
term.setModelQualifierType(libsbml.BQM_IS)
model.setMetaId("t1")
model.addCVTerm(term)
model.setMetaId("")
test = model.toSBML()
self.assert_(test == "<model id=\"test1\"/>")
pass
def find_or_add_cv_term(terms,
type=libsbml.BIOLOGICAL_QUALIFIER,
bio_type=libsbml.BQB_IS):
term = None
if terms:
for t in terms:
if t.getQualifierType() == type and t.getBiologicalQualifierType(
) == bio_type:
term = t
break
if term == None:
term = libsbml.CVTerm()
term.setQualifierType(type)
term.setBiologicalQualifierType(bio_type)
return term
def test_CVTerm_set_get(self):
term = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
term.setModelQualifierType(libsbml.BQM_IS)
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
self.assert_(term.getModelQualifierType() == libsbml.BQM_IS)
term.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
term.setBiologicalQualifierType(libsbml.BQB_IS)
self.assert_(term.getQualifierType() == libsbml.BIOLOGICAL_QUALIFIER)
self.assert_(term.getBiologicalQualifierType() == libsbml.BQB_IS)
_dummyList = [term]
_dummyList[:] = []
del _dummyList
pass
def test_RDFAnnotation2_modelWithHistoryAndCVTerms(self):
h = libsbml.ModelHistory()
c = libsbml.ModelCreator()
c.setFamilyName("Keating")
c.setGivenName("Sarah")
h.addCreator(c)
d = libsbml.Date(2008, 11, 17, 18, 37, 0, 0, 0, 0)
h.setCreatedDate(d)
h.setModifiedDate(d)
self.m2.unsetModelHistory()
self.m2.setModelHistory(h)
cv = libsbml.CVTerm()
cv.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
cv.setBiologicalQualifierType(libsbml.BQB_IS_VERSION_OF)
cv.addResource("http://www.geneontology.org/#GO:0005892")
self.m2.addCVTerm(cv)
ann = libsbml.RDFAnnotationParser.parseModelHistory(self.m2)
expected = wrapString(
"<annotation>\n" +
" <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:dcterms=\"http://purl.org/dc/terms/\" xmlns:vCard=\"http://www.w3.org/2001/vcard-rdf/3.0#\" xmlns:bqbiol=\"http://biomodels.net/biology-qualifiers/\" xmlns:bqmodel=\"http://biomodels.net/model-qualifiers/\">\n"
+ " <rdf:Description rdf:about=\"#_000001\">\n" +
" <dc:creator rdf:parseType=\"Resource\">\n" +
" <rdf:Bag>\n" +
" <rdf:li rdf:parseType=\"Resource\">\n" +
" <vCard:N rdf:parseType=\"Resource\">\n" +
" <vCard:Family>Keating</vCard:Family>\n" +
" <vCard:Given>Sarah</vCard:Given>\n" +
" </vCard:N>\n" + " </rdf:li>\n" +
" </rdf:Bag>\n" + " </dc:creator>\n" +
" <dcterms:created rdf:parseType=\"Resource\">\n" +
" <dcterms:W3CDTF>2008-11-17T18:37:00Z</dcterms:W3CDTF>\n" +
" </dcterms:created>\n" +
" <dcterms:modified rdf:parseType=\"Resource\">\n" +
" <dcterms:W3CDTF>2008-11-17T18:37:00Z</dcterms:W3CDTF>\n" +
" </dcterms:modified>\n" + " <bqbiol:isVersionOf>\n" +
" <rdf:Bag>\n" +
" <rdf:li rdf:resource=\"http://www.geneontology.org/#GO:0005892\"/>\n"
+ " </rdf:Bag>\n" + " </bqbiol:isVersionOf>\n" +
" </rdf:Description>\n" + " </rdf:RDF>\n" + "</annotation>")
if (ann != None):
self.assertEqual(True, self.equals(expected, ann.toXMLString()))
pass
pass
pass
def write_annotations_to_sbml( sbml_model, annotation_df ):
for le in sbml_elements:
for elem in getattr(sbml_model, 'getListOf'+le)():
if not elem.isSetMetaId():
# libsbml does not set annotation if no meta-id is set
elem.setMetaId(elem.getId())
elem_annos = annotation_df[annotation_df['ID']==elem.getId()]
for qtype in ['Biological', 'Model']:
libsbml_qtype = qtype.upper() + '_QUALIFIER'
for quali in elem_annos[elem_annos['qualifier_type']==libsbml_qtype]['qualifier'].unique():
cv = libsbml.CVTerm()
cv.setQualifierType( qualifier_type_2_sbml[ libsbml_qtype ] )
libsbml_qualifier_code = globals()[ qtype.lower()+'_qualifier_2_sbml' ][ quali ]
getattr( cv, 'set%sQualifierType' %qtype )( libsbml_qualifier_code )
for index,anno in elem_annos[ (elem_annos['qualifier_type']==libsbml_qtype) & (elem_annos['qualifier']==quali)].iterrows():
cv.addResource( anno['URI'] )
elem.addCVTerm(cv)
return sbml_model
def test_CVTerm_removeResource(self):
term = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
resource = "GO6666"
self.assert_(term != None)
self.assert_(term.getQualifierType() == libsbml.MODEL_QUALIFIER)
term.addResource(resource)
xa = term.getResources()
self.assert_(xa.getLength() == 1)
i = term.removeResource("CCC")
self.assert_(i == libsbml.LIBSBML_INVALID_ATTRIBUTE_VALUE)
xa = term.getResources()
self.assert_(xa.getLength() == 1)
i = term.removeResource(resource)
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
xa = term.getResources()
self.assert_(xa.getLength() == 0)
_dummyList = [term]
_dummyList[:] = []
del _dummyList
pass
def sbml_rdf_fixer():
__doc__ = 'Too hard to workout. Abbanded.'
sbml = libsbml.SBMLReader().readSBML("Gthg_2.4.xml")
error_check(sbml)
model = sbml.getModel()
for sp in model.getListOfSpecies():
if not sp.getCVTerms():
print(
sp.addCVTerm(libsbml.CVTerm(libsbml.BIOLOGICAL_QUALIFIER),
True))
bag = sp.getCVTerm(0)
notes = sp.getNotesString()
regexmatch = re.search('CHEBI:\s+(.*?)[<;]', notes)
if regexmatch:
name = regexmatch.group(1)
bag.addResource("urn:miriam:chebi:CHEBI%3A" + name)
regexmatch = re.search('KEGG:\s+(.*?)[<;]', notes)
if regexmatch:
name = regexmatch.group(1)
bag.addResource("urn:miriam:kegg.compound:" + name)
libsbml.writeSBMLToFile(sbml, "test enrich.xml")
def uncertainty() -> libsbml.SBMLDocument:
"""Create uncertainty with UncertParameter."""
doc: libsbml.SBMLDocument = _distrib_doc()
model: libsbml.Model = doc.createModel()
# parameter
p: libsbml.Parameter = _create_parameter("p1", model=model)
p_distrib: libsbml.DistribSBasePlugin = p.getPlugin("distrib")
# --------------------------------------------
# Build generic uncertainty for parameter
# --------------------------------------------
# 5.0 (mean) +- 0.3 (std) [2.0 - 8.0]
uncertainty: libsbml.Uncertainty = p_distrib.createUncertainty()
uncertainty.setName("Basic example: 5.0 +- 0.3 [2.0 - 8.0]")
unit = libsbml.UnitKind_toString(libsbml.UNIT_KIND_MOLE)
up_mean: libsbml.UncertParameter = uncertainty.createUncertParameter()
up_mean.setType(libsbml.DISTRIB_UNCERTTYPE_MEAN)
up_mean.setValue(5.0)
up_mean.setUnits(unit)
up_sd: libsbml.UncertParameter = uncertainty.createUncertParameter()
up_sd.setType(libsbml.DISTRIB_UNCERTTYPE_STANDARDDEVIATION)
up_sd.setValue(0.3)
up_sd.setUnits(unit)
up_range = libsbml.UncertSpan()
up_range.setType(libsbml.DISTRIB_UNCERTTYPE_RANGE)
up_range.setValueLower(2.0)
up_range.setValueUpper(8.0)
up_range.setUnits(unit)
check(uncertainty.addUncertParameter(up_range), "add the span")
check(
uncertainty.setAnnotation(
"""
<body xmlns='http://www.w3.org/1999/xhtml'>
<p>Experimental data from study</p>
</body>
"""
),
"set annotations",
)
# add an annotation with SBO terms
uncertainty.setMetaId("meta_uncertainty1")
cv1 = libsbml.CVTerm()
cv1.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
cv1.setBiologicalQualifierType(6) # "BQB_IS_DESCRIBED_BY"
cv1.addResource("https://identifiers.org/pubmed/123456")
check(uncertainty.addCVTerm(cv1), "add cv term")
cv2 = libsbml.CVTerm()
cv2.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
cv2.setBiologicalQualifierType(10) # "BQB_HAS_PROPERTY"
cv2.addResource("http://purl.obolibrary.org/obo/ECO_0006016")
check(uncertainty.addCVTerm(cv2), "add cv term")
# --------------------------------------------
# Set of all UncertParameters
# --------------------------------------------
# create second uncertainty which contains all the individual uncertainties
uncertainty = p_distrib.createUncertainty()
uncertainty.setName("UncertParameter example")
for k, parameter_type in enumerate(
[
libsbml.DISTRIB_UNCERTTYPE_COEFFIENTOFVARIATION,
libsbml.DISTRIB_UNCERTTYPE_KURTOSIS,
libsbml.DISTRIB_UNCERTTYPE_MEAN,
libsbml.DISTRIB_UNCERTTYPE_MEDIAN,
libsbml.DISTRIB_UNCERTTYPE_MODE,
libsbml.DISTRIB_UNCERTTYPE_SAMPLESIZE,
libsbml.DISTRIB_UNCERTTYPE_SKEWNESS,
libsbml.DISTRIB_UNCERTTYPE_STANDARDDEVIATION,
libsbml.DISTRIB_UNCERTTYPE_STANDARDERROR,
libsbml.DISTRIB_UNCERTTYPE_VARIANCE,
]
):
up: libsbml.UncertParameter = uncertainty.createUncertParameter()
up.setType(parameter_type)
up.setValue(k)
up.setUnits(unit)
# --------------------------------------------
# Set of all UncertSpans
# --------------------------------------------
uncertainty = p_distrib.createUncertainty()
uncertainty.setName("UncertSpan example")
for k, parameter_type in enumerate(
[
libsbml.DISTRIB_UNCERTTYPE_CONFIDENCEINTERVAL,
libsbml.DISTRIB_UNCERTTYPE_CREDIBLEINTERVAL,
libsbml.DISTRIB_UNCERTTYPE_INTERQUARTILERANGE,
libsbml.DISTRIB_UNCERTTYPE_RANGE,
]
):
up_range = libsbml.UncertSpan()
up_range.setType(parameter_type)
up_range.setValueLower(k - 1.0)
up_range.setValueUpper(k + 1.0)
up_range.setUnits(unit)
check(uncertainty.addUncertParameter(up_range), "add the span")
# --------------------------------------------
# Use math for distribution definition
# --------------------------------------------
# 5.0 dimensionless * normal(1.0 mole, 3.0 mole)
uncertainty = p_distrib.createUncertainty()
uncertainty.setName("math example: 5.0 dimensionless * normal(1.0 mole, 3.0 mole)")
up = uncertainty.createUncertParameter()
up.setType(libsbml.DISTRIB_UNCERTTYPE_DISTRIBUTION)
up.setDefinitionURL("http://www.sbml.org/sbml/symbols/distrib/normal")
ast = libsbml.parseL3FormulaWithModel(
"5.0 dimensionless * normal(1.0 mole, 3.0 mole)", model
)
if not ast:
raise ValueError
up.setMath(ast)
# --------------------------------------------
# Use externalParameter
# --------------------------------------------
# https://sites.google.com/site/probonto/
uncertainty = p_distrib.createUncertainty()
uncertainty.setName("ExternalParameter example")
up = uncertainty.createUncertParameter()
up.setType(libsbml.DISTRIB_UNCERTTYPE_EXTERNALPARAMETER)
up.setName("skewness")
up.setValue(0.25)
up.setUnits(unit)
up.setDefinitionURL("http://purl.obolibrary.org/obo/STATO_0000068")
# --------------------------------------------
# Use external distribution definition
# --------------------------------------------
uncertainty = p_distrib.createUncertainty()
uncertainty.setName("External distribution example")
up = uncertainty.createUncertParameter()
up.setType(libsbml.DISTRIB_UNCERTTYPE_DISTRIBUTION)
up.setName("Geometric 1")
up.setDefinitionURL("http://www.probonto.org/ontology#PROB_k0000782")
up.setUnits(unit)
# success probability of Geometric-1
up_mean_geo1 = up.createUncertParameter()
up_mean_geo1.setType(libsbml.DISTRIB_UNCERTTYPE_EXTERNALPARAMETER)
up_mean_geo1.setName("success probability of Geometric 1")
up_mean_geo1.setValue(0.4)
up_mean_geo1.setDefinitionURL("http://www.probonto.org/ontology#PROB_k0000789")
return doc
def add_cvterm(term):
controlled_vocab = libsbml.CVTerm()
controlled_vocab.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
controlled_vocab.setBiologicalQualifierType(libsbml.BQB_IS)
controlled_vocab.addResource(term)
return controlled_vocab
doc = libsbml.SBMLDocument(3, 2) # type: libsbml.SBMLDocument
model = doc.createModel() # type: libsbml.Model
p = model.createParameter() # type: libsbml.Parameter
p.setId("p")
check(
p.setAnnotation("""
<body xmlns='http://www.w3.org/1999/xhtml'>
<p>First annotation</p>
</body>
"""), "set annotations")
# add an annotation with SBO terms
p.setMetaId("meta_uncertainty1")
cv1 = libsbml.CVTerm()
cv1.setQualifierType(libsbml.BIOLOGICAL_QUALIFIER)
cv1.setBiologicalQualifierType(6) # "BQB_IS_DESCRIBED_BY"
cv1.addResource("https://identifiers.org/pubmed/123456")
check(p.addCVTerm(cv1), "add cv term")
sbml = libsbml.writeSBMLToString(doc)
print("-" * 80)
print(sbml)
print("-" * 80)
check(
p.setAnnotation("""
<body xmlns='http://www.w3.org/1999/xhtml'>
<p>New annotation.</p>
</body>
import libsbml as sbml
doc = sbml.SBMLDocument(3, 2)
model = doc.createModel()
model.setMetaId("META_MODEL")
cvt = sbml.CVTerm()
cvt.setQualifierType(sbml.BIOLOGICAL_QUALIFIER)
cvt.setBiologicalQualifierType(sbml.BQB_IS)
cvt.addResource("www.some.reference.de/bug/annotation")
print(sbml.writeSBMLToString(doc))
model.addCVTerm(cvt)
print(sbml.writeSBMLToString(doc))
model.unsetAnnotation()
ann = "<test><other/></test>"
model.appendAnnotation(ann)
print(sbml.writeSBMLToString(doc))
model.unsetAnnotation()
model.appendAnnotation(ann)
model.addCVTerm(cvt)
print(sbml.writeSBMLToString(doc))
model.unsetAnnotation()
model.addCVTerm(cvt)
print(sbml.writeSBMLToString(doc))
model.appendAnnotation(ann)
def test_RDFAnnotation_parseCVTerms(self):
node = libsbml.RDFAnnotationParser.parseCVTerms(
self.m.getCompartment(0))
self.assert_(node.getNumChildren() == 1)
rdf = node.getChild(0)
self.assert_(("RDF" == rdf.getName()))
self.assert_(("rdf" == rdf.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == rdf.getURI()))
self.assert_(rdf.getNumChildren() == 1)
desc = rdf.getChild(0)
self.assert_(("Description" == desc.getName()))
self.assert_(("rdf" == desc.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == desc.getURI()))
self.assert_(desc.getNumChildren() == 1)
is1 = desc.getChild(0)
self.assert_(("is" == is1.getName()))
self.assert_(("bqbiol" == is1.getPrefix()))
self.assert_(is1.getNumChildren() == 1)
Bag = is1.getChild(0)
self.assert_(("Bag" == Bag.getName()))
self.assert_(("rdf" == Bag.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == Bag.getURI()))
self.assert_(Bag.getNumChildren() == 4)
li = Bag.getChild(0)
self.assert_(("li" == li.getName()))
self.assert_(("rdf" == li.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == li.getURI()))
self.assert_(li.getNumChildren() == 0)
li1 = Bag.getChild(1)
self.assert_(("li" == li1.getName()))
self.assert_(("rdf" == li1.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == li1.getURI()))
self.assert_(li1.getNumChildren() == 0)
li2 = Bag.getChild(2)
self.assert_(("li" == li2.getName()))
self.assert_(("rdf" == li2.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == li2.getURI()))
self.assert_(li2.getNumChildren() == 0)
li3 = Bag.getChild(3)
self.assert_(("li" == li3.getName()))
self.assert_(("rdf" == li3.getPrefix()))
self.assert_(
("http://www.w3.org/1999/02/22-rdf-syntax-ns#" == li3.getURI()))
self.assert_(li3.getNumChildren() == 0)
node = None
node1 = libsbml.RDFAnnotationParser.parseCVTerms(None)
self.assert_(node1 == None)
node1 = libsbml.RDFAnnotationParser.createCVTerms(None)
self.assert_(node1 == None)
node1 = libsbml.RDFAnnotationParser.parseCVTerms(
self.m.getCompartment(2))
self.assert_(node1 == None)
node1 = libsbml.RDFAnnotationParser.createCVTerms(
self.m.getCompartment(2))
self.assert_(node1 == None)
node1 = libsbml.RDFAnnotationParser.parseCVTerms(self.m)
self.assert_(node1 == None)
node1 = libsbml.RDFAnnotationParser.createCVTerms(self.m)
self.assert_(node1 == None)
c = libsbml.Compartment(3, 1)
c.setMetaId("_002")
node1 = libsbml.RDFAnnotationParser.parseCVTerms(c)
self.assert_(node1 == None)
node1 = libsbml.RDFAnnotationParser.createCVTerms(c)
self.assert_(node1 == None)
cv = libsbml.CVTerm(libsbml.BIOLOGICAL_QUALIFIER)
cv.setBiologicalQualifierType(23)
cv.addResource("http://myres")
c.addCVTerm(cv)
node1 = libsbml.RDFAnnotationParser.createCVTerms(c)
self.assert_(node1 == None)
c = None
m1 = libsbml.Model(3, 1)
m1.setMetaId("_002")
cv = libsbml.CVTerm(libsbml.MODEL_QUALIFIER)
cv.setModelQualifierType(23)
cv.addResource("http://myres")
m1.addCVTerm(cv)
node1 = libsbml.RDFAnnotationParser.createCVTerms(m1)
self.assert_(node1 == None)
pass
