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()
database.pathwaycommons = False
#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 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
pathwaycommons = False
if bioGrid:
loadBioGrid()
database = structures.Databases()
database.forceModificationFlag = True
database.pathwaycommons = False
if pathwaycommons:
database.pathwaycommons = True
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 readFromString(inputString,reactionDefinitions,useID,speciesEquivalence=None,atomize=False, loggingStream=None):
'''
one of the library's main entry methods. Process data from a string
'''
console = None
if loggingStream:
console = logging.StreamHandler(loggingStream)
console.setLevel(logging.DEBUG)
setupStreamLog(console)
reader = libsbml.SBMLReader()
document = reader.readSBMLFromString(inputString)
parser =SBML2BNGL(document.getModel(),useID)
bioGrid = False
pathwaycommons = True
if bioGrid:
loadBioGrid()
database = structures.Databases()
database.assumptions = defaultdict(set)
database.document = document
database.forceModificationFlag = True
database.reactionDefinitions = reactionDefinitions
database.useID = useID
database.atomize = atomize
database.speciesEquivalence = speciesEquivalence
database.pathwaycommons = True
database.isConversion = True
#if pathwaycommons:
# database.pathwaycommons = True
namingConventions = resource_path('config/namingConventions.json')
if atomize:
translator,onlySynDec = mc.transformMolecules(parser,database,reactionDefinitions,namingConventions,speciesEquivalence,bioGrid)
database.species = translator.keys()
else:
translator={}
#logging.getLogger().flush()
if loggingStream:
finishStreamLog(console)
returnArray = analyzeHelper(document, reactionDefinitions,
useID,'', speciesEquivalence, atomize, translator, database)
if atomize and onlySynDec:
returnArray = list(returnArray)
returnArray = AnalysisResults(*(list(returnArray[0:-2]) + [database] + [returnArray[-1]]))
return returnArray
def analyzeFile(bioNumber,reactionDefinitions,useID,namingConventions,outputFile,
speciesEquivalence=None,atomize=False,bioGrid=False,pathwaycommons=False):
'''
one of the library's main entry methods. Process data from a file
'''
'''
import cProfile, pstats, StringIO
pr = cProfile.Profile()
pr.enable()
'''
logMess.log = []
logMess.counter = -1
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile(bioNumber)
parser =SBML2BNGL(document.getModel(),useID)
database = structures.Databases()
database.forceModificationFlag = True
database.pathwaycommons = pathwaycommons
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.)
'''
pr.disable()
s = StringIO.StringIO()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats(10)
print s.getvalue()
'''
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 analyzeFile(bioNumber, reactionDefinitions, useID, namingConventions, outputFile,
speciesEquivalence=None, atomize=False, bioGrid=False, pathwaycommons=False, ignore=False, noConversion=False):
'''
one of the library's main entry methods. Process data from a file
'''
'''
import cProfile, pstats, StringIO
pr = cProfile.Profile()
pr.enable()
'''
setupLog(outputFile + '.log', logging.DEBUG)
logMess.log = []
logMess.counter = -1
reader = libsbml.SBMLReader()
document = reader.readSBMLFromFile(bioNumber)
if document.getModel() == None:
print 'File {0} could not be recognized as a valid SBML file'.format(bioNumber)
return
parser =SBML2BNGL(document.getModel(),useID)
parser.setConversion(not noConversion)
database = structures.Databases()
database.assumptions = defaultdict(set)
database.forceModificationFlag = True
database.pathwaycommons = pathwaycommons
database.ignore = ignore
database.assumptions = defaultdict(set)
bioGridDict = {}
if bioGrid:
bioGridDict = loadBioGrid()
translator = {}
# 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
try:
if atomize:
translator, onlySynDec = mc.transformMolecules(parser, database, reactionDefinitions,
namingConventions, speciesEquivalence, bioGrid)
except TranslationException as e:
print "Found an error in {0}. Check log for more details. Use -I to ignore translation errors".format(e.value)
if len(logMess.log) > 0:
with open(outputFile + '.log', 'w') as f:
for element in logMess.log:
f.write(element + '\n')
return
# process other sections of the sbml file (functions reactions etc.)
'''
pr.disable()
s = StringIO.StringIO()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats(10)
print s.getvalue()
'''
database.document = document
database.reactionDefinitions = reactionDefinitions
database.useID = useID
database.speciesEquivalence = speciesEquivalence
database.atomize = atomize
database.isConversion = not noConversion
returnArray = analyzeHelper(document, reactionDefinitions, useID, outputFile, speciesEquivalence, atomize, translator, database)
with open(outputFile, 'w') as f:
f.write(returnArray.finalString)
#with open('{0}.dict'.format(outputFile),'wb') as f:
# pickle.dump(returnArray[-1],f)
if atomize and onlySynDec:
returnArray = list(returnArray)
#returnArray.translator = -1
returnArray = AnalysisResults(*(list(returnArray[0:-2]) + [database] + [returnArray[-1]]))
return returnArray
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()
rawSpecies = {}
for species in parser.model.getListOfSpecies():
rawtemp = parser.getRawSpecies(species,[x.split(' ')[0] for x in param])
rawSpecies[rawtemp['identifier']] = rawtemp
parser.reset()
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,rawSpecies,observables)
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))
#since we are considering it an observable delete it from the molecule and
#initial conditions list
#s = molecules.pop(flag)
#initialConditions = [x for x in initialConditions if '$' + s not in x]
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
'''
