def readFromString(inputString,
reactionDefinitions,
useID,
speciesEquivalence=None,
atomize=False):
'''
one of the library's main entry methods. Process data from a string
'''
try:
reader = libsbml.SBMLReader()
document = reader.readSBMLFromString(inputString)
parser = SBML2BNGL(document.getModel(), useID)
bioGrid = False
if bioGrid:
loadBioGrid()
database = structures.Databases()
namingConventions = resource_path('config/namingConventions.json')
if atomize:
translator, onlySynDec = mc.transformMolecules(
parser, database, reactionDefinitions, namingConventions,
speciesEquivalence, bioGrid)
else:
translator = {}
return analyzeHelper(document, reactionDefinitions, useID, '',
speciesEquivalence, atomize, translator)[-2]
except:
return -5
def obtainSCT(
self,
fileName,
reactionDefinitions,
useID,
namingConventions,
speciesEquivalences=None,
):
"""
one of the library's main entry methods. Process data from a file
to obtain the species composition table, a dictionary describing
the chemical history of different elements in the system
"""
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile(fileName)
parser = SBML2BNGL(document.getModel(), useID)
database = structures.Databases()
database.forceModificationFlag = True
database = mc.createSpeciesCompositionGraph(
parser,
database,
reactionDefinitions,
namingConventions,
speciesEquivalences=speciesEquivalences,
bioGridFlag=False,
)
return database.prunnedDependencyGraph, database, document
def loadTranslator(fileName, jsonFile):
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile('XMLExamples/curated/BIOMD0000000' +
fileName + '.xml')
parser = libsbml2bngl.SBML2BNGL(document.getModel())
database = structures.Databases()
translator = m2c.transformMolecules(
parser, database,
'reactionDefinitions/reactionDefinition' + str(jsonFile) + '.json')
return translator
def analyzeFile(bioNumber,
reactionDefinitions,
useID,
namingConventions,
outputFile,
speciesEquivalence=None,
atomize=False,
bioGrid=False):
'''
one of the library's main entry methods. Process data from a file
'''
logMess.log = []
logMess.counter = -1
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile(bioNumber)
parser = SBML2BNGL(document.getModel(), useID)
database = structures.Databases()
database.forceModificationFlag = True
bioGridDict = {}
if bioGrid:
bioGridDict = loadBioGrid()
#call the atomizer (or not). structured molecules are contained in translator
#onlysyndec is a boolean saying if a model is just synthesis of decay reactions
if atomize:
translator, onlySynDec = mc.transformMolecules(parser, database,
reactionDefinitions,
namingConventions,
speciesEquivalence,
bioGrid)
else:
translator = {}
#process other sections of the sbml file (functions reactions etc.)
returnArray = analyzeHelper(document, reactionDefinitions, useID,
outputFile, speciesEquivalence, atomize,
translator)
with open(outputFile, 'w') as f:
f.write(returnArray[-2])
#with open('{0}.dict'.format(outputFile),'wb') as f:
# pickle.dump(returnArray[-1],f)
if atomize and onlySynDec:
returnArray = list(returnArray)
returnArray[0] = -1
return tuple(returnArray[0:-2])
def obtainSCT(fileName, reactionDefinitions, useID, namingConventions):
'''
one of the library's main entry methods. Process data from a file
'''
logMess.log = []
logMess.counter = -1
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile(fileName)
parser = SBML2BNGL(document.getModel(), useID)
database = structures.Databases()
database.forceModificationFlag = True
sct, database = mc.createSpeciesCompositionGraph(parser,
database,
reactionDefinitions,
namingConventions,
speciesEquivalences=None,
bioGridFlag=False)
return sct, database, document
def extractCompartmentStatistics(bioNumber, useID, reactionDefinitions,
speciesEquivalence):
'''
Iterate over the translated species and check which compartments
are used together, and how.
'''
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile(bioNumber)
parser = SBML2BNGL(document.getModel(), useID)
database = structures.Databases()
#call the atomizer (or not)
#if atomize:
translator, onlySynDec = mc.transformMolecules(parser, database,
reactionDefinitions,
speciesEquivalence)
#else:
# translator={}
compartmentPairs = {}
for element in translator:
temp = extractCompartmentCoIncidence(translator[element])
for element in temp:
if element not in compartmentPairs:
compartmentPairs[element] = temp[element]
else:
compartmentPairs[element].update(temp[element])
finalCompartmentPairs = {}
print '-----'
for element in compartmentPairs:
if element[0][0] not in finalCompartmentPairs:
finalCompartmentPairs[element[0][0]] = {}
finalCompartmentPairs[element[0][0]][tuple(
[element[0][1], element[1][1]])] = compartmentPairs[element]
return finalCompartmentPairs
def analyzeHelper(document,
reactionDefinitions,
useID,
outputFile,
speciesEquivalence,
atomize,
translator,
bioGrid=False):
'''
taking the atomized dictionary and a series of data structure, this method
does the actual string output.
'''
useArtificialRules = False
parser = SBML2BNGL(document.getModel(), useID)
database = structures.Databases()
#translator,log,rdf = m2c.transformMolecules(parser,database,reactionDefinitions,speciesEquivalence)
#try:
#bioGridDict = {}
#if biogrid:
# bioGridDict = biogrid()
#if atomize:
# translator = mc.transformMolecules(parser,database,reactionDefinitions,speciesEquivalence,bioGridDict)
#else:
# translator={}
parser = SBML2BNGL(document.getModel(), useID)
#except:
# print 'failure'
# return None,None,None,None
#translator = {}
param, zparam = parser.getParameters()
molecules, initialConditions, observables, speciesDict = parser.getSpecies(
translator, [x.split(' ')[0] for x in param])
#finally, adjust parameters and initial concentrations according to whatever initialassignments say
param, zparam, initialConditions = parser.getInitialAssignments(
translator, param, zparam, molecules, initialConditions)
compartments = parser.getCompartments()
functions = []
assigmentRuleDefinedParameters = []
reactionParameters, rules, rateFunctions = parser.getReactions(
translator, len(compartments) > 1, atomize=atomize)
functions.extend(rateFunctions)
aParameters, aRules, nonzparam, artificialRules, removeParams, artificialObservables = parser.getAssignmentRules(
zparam, param, molecules)
for element in nonzparam:
param.append('{0} 0'.format(element))
param = [x for x in param if x not in removeParams]
tags = '@{0}'.format(
compartments[0].split(' ')[0]) if len(compartments) == 1 else '@cell'
molecules.extend([x.split(' ')[0] for x in removeParams])
if len(molecules) == 0:
compartments = []
observables.extend('Species {0} {0}'.format(x.split(' ')[0])
for x in removeParams)
for x in removeParams:
initialConditions.append(
x.split(' ')[0] + tags + ' ' + x.split(' ')[1])
##Comment out those parameters that are defined with assignment rules
##TODO: I think this is correct, but it may need to be checked
tmpParams = []
for idx, parameter in enumerate(param):
for key in artificialObservables:
if re.search('^{0}\s'.format(key), parameter) != None:
assigmentRuleDefinedParameters.append(idx)
tmpParams.extend(artificialObservables)
tmpParams.extend(removeParams)
tmpParams = set(tmpParams)
correctRulesWithParenthesis(rules, tmpParams)
for element in assigmentRuleDefinedParameters:
param[element] = '#' + param[element]
deleteMolecules = []
deleteMoleculesFlag = True
for key in artificialObservables:
flag = -1
for idx, observable in enumerate(observables):
if 'Species {0} {0}()'.format(key) in observable:
flag = idx
if flag != -1:
observables.pop(flag)
functions.append(artificialObservables[key])
flag = -1
if '{0}()'.format(key) in molecules:
flag = molecules.index('{0}()'.format(key))
if flag != -1:
if deleteMoleculesFlag:
deleteMolecules.append(flag)
else:
deleteMolecules.append(key)
#result =validateReactionUsage(molecules[flag],rules)
#if result != None:
# logMess('ERROR','Pseudo observable {0} in reaction {1}'.format(molecules[flag],result))
#molecules.pop(flag)
flag = -1
for idx, specie in enumerate(initialConditions):
if ':{0}('.format(key) in specie:
flag = idx
if flag != -1:
initialConditions[flag] = '#' + initialConditions[flag]
for flag in sorted(deleteMolecules, reverse=True):
if deleteMoleculesFlag:
logMess(
'WARNING:Simulation',
'{0} reported as function, but usage is ambiguous'.format(
molecules[flag]))
result = validateReactionUsage(molecules[flag], rules)
if result != None:
logMess(
'ERROR:Simulation',
'Pseudo observable {0} in reaction {1}'.format(
molecules[flag], result))
molecules.pop(flag)
else:
logMess(
'WARNING:Simulation',
'{0} reported as species, but usage is ambiguous.'.format(
flag))
artificialObservables.pop(flag)
functions.extend(aRules)
sbmlfunctions = parser.getSBMLFunctions()
processFunctions(functions, sbmlfunctions, artificialObservables,
rateFunctions)
for interation in range(0, 3):
for sbml2 in sbmlfunctions:
for sbml in sbmlfunctions:
if sbml == sbml2:
continue
if sbml in sbmlfunctions[sbml2]:
sbmlfunctions[sbml2] = writer.extendFunction(
sbmlfunctions[sbml2], sbml, sbmlfunctions[sbml])
functions = reorderFunctions(functions)
functions = changeNames(functions, aParameters)
# print [x for x in functions if 'functionRate60' in x]
functions = unrollFunctions(functions)
rules = changeRates(rules, aParameters)
if len(compartments) > 1 and 'cell 3 1.0' not in compartments:
compartments.append('cell 3 1.0')
#sbml always has the 'cell' default compartment, even when it
#doesn't declare it
elif len(compartments) == 0 and len(molecules) != 0:
compartments.append('cell 3 1.0')
if len(artificialRules) + len(rules) == 0:
logMess('ERROR:Simulation', 'The file contains no reactions')
if useArtificialRules or len(rules) == 0:
rules = ['#{0}'.format(x) for x in rules]
evaluate = evaluation(len(observables), translator)
artificialRules.extend(rules)
rules = artificialRules
else:
artificialRules = ['#{0}'.format(x) for x in artificialRules]
evaluate = evaluation(len(observables), translator)
rules.extend(artificialRules)
commentDictionary = {}
if atomize:
commentDictionary[
'notes'] = "'This is an atomized translation of an SBML model created on {0}.".format(
time.strftime("%d/%m/%Y"))
else:
commentDictionary[
'notes'] = "'This is a plain translation of an SBML model created on {0}.".format(
time.strftime("%d/%m/%Y"))
commentDictionary[
'notes'] += " The original model has {0} molecules and {1} reactions. The translated model has {2} molecules and {3} rules'".format(
parser.model.getNumSpecies(), parser.model.getNumReactions(),
len(molecules), len(set(rules)))
meta = parser.getMetaInformation(commentDictionary)
from collections import OrderedDict
finalString = writer.finalText(meta, param + reactionParameters, molecules,
initialConditions,
list(OrderedDict.fromkeys(observables)),
list(OrderedDict.fromkeys(rules)),
functions, compartments, outputFile)
#print outputFile
logMess(
'INFO:Summary',
'File contains {0} molecules out of {1} original SBML species'.format(
len(molecules), len(observables)))
#store a logfile
try:
if len(logMess.log) > 0:
with open(outputFile + '.log', 'w') as f:
for element in logMess.log:
f.write(element + '\n')
except AttributeError:
print "error"
except IOError:
pass
#print ""
#rate of each classified rule
evaluate2 = 0 if len(
observables) == 0 else len(molecules) * 1.0 / len(observables)
return len(rules), len(observables), evaluate, evaluate2, len(
compartments), parser.getSpeciesAnnotation(), finalString, speciesDict
'''
