def test_createMergeModels(self): rpsbml = rpSBML.rpSBML('test', None, os.path.abspath('../cache')) rpsbml.genericModel('RetroPath_heterologous_pathway', 'rp_model', compXref) for meta in set([i for step in steps for lr in ['left', 'right'] for i in step[lr]]): try: inchi = rp_inchi[meta] except KeyError: inchi = None try: smiles = rp_smiles[meta] except KeyError: smiles = None rpsbml.createSpecies(meta, chemXref, None, inchi, smiles, 'MNXC3', 0, '') rp_pathway = rpsbml.createPathway(path_id) #reactions step_id = 0 for stepNum in range(len(steps)): rpsbml.createReaction('RP_'+str(stepNum), 'B_999999', 'B__999999', steps[stepNum], reaction_smiles[stepNum], reacXref, 'testRid', 0.0, None, rpsbml.hetero_group, None) step_id += 1 #other model document = libsbml.readSBML(os.path.join(os.path.abspath('test_models'), 'bigg_iMM904.COBRA-sbml3.xml')) model = document.getModel() rpsbml.mergeModels(model) inModel = libsbml.readSBML(os.path.join(os.path.abspath('test_models'), 'test_mergeModels.sbml')) assert self.compareModels(inModel.getModel(), model)==True
def test_WriteL3SBML_zip(self): file = [] file.append("../../../examples/sample-models/from-spec/level-3/algebraicrules.xml") file.append("../../../examples/sample-models/from-spec/level-3/assignmentrules.xml") file.append("../../../examples/sample-models/from-spec/level-3/boundarycondition.xml") file.append("../../../examples/sample-models/from-spec/level-3/delay.xml") file.append("../../../examples/sample-models/from-spec/level-3/dimerization.xml") file.append("../../../examples/sample-models/from-spec/level-3/enzymekinetics.xml") file.append("../../../examples/sample-models/from-spec/level-3/events.xml") file.append("../../../examples/sample-models/from-spec/level-3/functiondef.xml") file.append("../../../examples/sample-models/from-spec/level-3/multicomp.xml") file.append("../../../examples/sample-models/from-spec/level-3/overdetermined.xml") file.append("../../../examples/sample-models/from-spec/level-3/twodimensional.xml") file.append("../../../examples/sample-models/from-spec/level-3/units.xml") zipfile = "test.xml.zip" for f in file: d = libsbml.readSBML(f) self.assert_( d != None ) if not libsbml.SBMLWriter.hasZlib(): self.assert_( libsbml.writeSBML(d,zipfile) == 0 ) d = None continue result = libsbml.writeSBML(d,zipfile) self.assertEqual( 1, result ) dg = libsbml.readSBML(zipfile) self.assert_( dg != None ) self.assert_( ( dg.toSBML() != d.toSBML() ) == False ) d = None dg = None pass
def getTimeCourse(iModel, iFile): # important paths BioModels_path = './BioModelsDatabase_models' xml_path = './sedml_models/' + iModel + '/sbml_models/' + iFile + '.xml' sedml_path = './sedml_models/' + iModel + '/' + iModel + '.sedml' sbml_path = './sedml_models/' + iModel + '/sbml_models/' + iFile + '.sbml' # get time curse depending on type of model if os.path.exists(BioModels_path + '/' + iModel): sim_start_time, sim_end_time, sim_num_time_points, y_bound = timePointsBioModels(iModel) xml_model = libsbml.readSBML(xml_path) model_name = xml_model.getModel().getName() else: sedml_file = libsedml.readSedML(sedml_path) sbml_file = libsbml.readSBML(sbml_path) model_name = sbml_file.getModel().getName() for iTask in range(0, sedml_file.getNumTasks()): all_tasks = sedml_file.getTask(iTask) tsk_Id = all_tasks.getId() task_name = all_tasks.getName() task_modRef = all_tasks.getModelReference() task_simReference = all_tasks.getSimulationReference() # time courses try: all_simulations = sedml_file.getSimulation(iTask) sim_Id = all_simulations.getId() except: # need 'except' clause if more models have same time period if all_simulations == None: all_simulations = sedml_file.getSimulation(0) sim_Id = all_simulations.getId() try: while task_simReference != sim_Id: iTask = iTask + 1 all_simulations = sedml_file.getSimulation(iTask) sim_Id = all_simulations.getId() except: iTask = 0 while task_simReference != sim_Id: all_simulations = sedml_file.getSimulation(iTask) sim_Id = all_simulations.getId() iTask = iTask + 1 sim_start_time = all_simulations.getOutputStartTime() sim_end_time = all_simulations.getOutputEndTime() sim_num_time_points = all_simulations.getNumberOfPoints() # replace 'sim_num_time_points' by default value 100 for trajectory comparison in the end sim_num_time_points = 100 return model_name, sim_start_time, sim_end_time, sim_num_time_points
def _check_biomodels_model( sedml_model, sbml_path, model_name, model_year, model_info): # only one sbml file, a benchmark model on its own. sedml_path = '' sbml_model = (libsbml.readSBML(sbml_path)).getModel() n_species = len(sbml_model.getListOfSpecies()) n_reactions = len(sbml_model.getListOfReactions()) # get the simulation times and write them to csv file out_start, out_end, n_timepoints, _ = \ timePointsBioModels(sedml_model) if out_start is None: # Tf the model is not found, timePointsBioModels issues a warning. # We want to treat this case as a failure return model_info model_info.append({ 'name': model_name, 'year': model_year, 'n_species': n_species, 'n_reactions': n_reactions, 'long_id': (model_name, model_year, n_species, n_reactions), 'short_id': '', 'sbml_path': sbml_path, 'sedml_path': sedml_path, 'regrouped_path': '', # to be filled later 'start_time': out_start, 'end_time': out_end, 'n_timepoints': n_timepoints, 'sedml_task': '', }) return model_info
def get_submodel_copasi(submodel_path: str, model_info: pd.DataFrame): """ This function loads a copasi file, if the (relative) path to the folder with this Copasi model is provided. It extracts the respective sbml file from the list and returns it alongside with the model, if any postprecessing of the Copasi results is necessary """ # load the amici model if str(submodel_path) in ('', 'nan', 'NaN'): return None, None copasi_file = os.path.join(DIR_MODELS, submodel_path) # if the amici import did not work, we don't want to consider this model if 'amici_path_final' in model_info.keys(): model_row = model_info.loc[model_info['copasi_path_final'] == submodel_path] elif 'amici_path' in model_info.keys(): model_row = model_info.loc[model_info['copasi_path'] == submodel_path] else: return None, None id = int(model_row.index.values) # import the sbml model sbml_path = os.path.join(DIR_MODELS, model_row.loc[id, 'regrouped_path']) sbml_model = (libsbml.readSBML(sbml_path)).getModel() return copasi_file, sbml_model
def modelica_varnames(variables, amounts, concentrations, sbml): doc = readSBML(sbml) m = doc.getModel() varnames = list() for var in variables: o = m.getParameter(var) if o is not None: varnames.append('Params.elmt_{0}'.format(var)) continue o = m.getCompartment(var) if o is not None: varnames.append("elmt_{0}.elmt_{0}".format(var)) continue o = m.getSpecies(var) if o is not None: if var in amounts: varnames.append('elmt_{0}.elmt_{1}_amount'.format( o.getCompartment(), var)) if var in concentrations: varnames.append('elmt_{0}.elmt_{1}_conc'.format( o.getCompartment(), var)) continue o = m.getReaction(var) if o is not None: varnames.append('Reacs.elmt_{}'.format(var)) continue for r in m.GetListOfReactions(): if r.getReactant(var) or r.getProduct(var): varnames.append('Reacs.elmt_{}'.format(var)) return varnames
def load_sbml(filename): """ Load a model from a SBML file. Parameters ---------- filename : str The input SBML filename. Returns ------- model : NetworkModel or ODENetworkModel y0 : dict Initial condition. volume : Real or Real3, optional A size of the simulation volume. """ import libsbml document = libsbml.readSBML(filename) document.validateSBML() num_errors = (document.getNumErrors(libsbml.LIBSBML_SEV_ERROR) + document.getNumErrors(libsbml.LIBSBML_SEV_FATAL)) if num_errors > 0: messages = "The generated document is not valid." messages += " {} errors were found:\n".format(num_errors) for i in range(document.getNumErrors(libsbml.LIBSBML_SEV_ERROR)): err = document.getErrorWithSeverity(i, libsbml.LIBSBML_SEV_ERROR) messages += "{}: {}\n".format(err.getSeverityAsString(), err.getShortMessage()) for i in range(document.getNumErrors(libsbml.LIBSBML_SEV_FATAL)): err = document.getErrorWithSeverity(i, libsbml.LIBSBML_SEV_FATAL) messages += "{}: {}\n".format(err.getSeverityAsString(), err.getShortMessage()) raise RuntimeError(messages) return import_sbml(document)
def check_sbml(filepath, name=None, log_errors=True, units_consistency=True, modeling_practice=True, internal_consistency=True): """ Checks the given SBML filepath or string. :param doc: SBMLDocument to check :param name: identifier or path for report :param units_consistency: boolean flag units consistency :param modeling_practice: boolean flag modeling practise :param internal_consistency: boolean flag internal consistency :param log_errors: boolean flag of errors should be logged :return: Nall, Nerr, Nwarn (number of all warnings/errors, errors and warnings) """ if name is None: filepath = os.path.abspath(filepath) if len(filepath) < 100: name = filepath else: name = filepath[0:99] + '...' doc = libsbml.readSBML(filepath) return check_doc(doc, name=name, log_errors=log_errors, units_consistency=units_consistency, modeling_practice=modeling_practice, internal_consistency=internal_consistency)
def load_sbml(filename): """ Load a model from a SBML file. Parameters ---------- filename : str The input SBML filename. Returns ------- model : NetworkModel y0 : dict Initial condition. volume : Real or Real3, optional A size of the simulation volume. """ import libsbml document = libsbml.readSBML(filename) document.validateSBML() num_errors = (document.getNumErrors(libsbml.LIBSBML_SEV_ERROR) + document.getNumErrors(libsbml.LIBSBML_SEV_FATAL)) if num_errors > 0: messages = "The generated document is not valid." messages += " {} errors were found:\n".format(num_errors) for i in range(document.getNumErrors(libsbml.LIBSBML_SEV_ERROR)): err = document.getErrorWithSeverity(i, libsbml.LIBSBML_SEV_ERROR) messages += "{}: {}\n".format(err.getSeverityAsString(), err.getShortMessage()) for i in range(document.getNumErrors(libsbml.LIBSBML_SEV_FATAL)): err = document.getErrorWithSeverity(i, libsbml.LIBSBML_SEV_FATAL) messages += "{}: {}\n".format(err.getSeverityAsString(), err.getShortMessage()) raise RuntimeError(messages) return import_sbml(document)
def read_sbml(mn_file): """ Read a SBML file and yield ASP atoms """ def make_reaction(reaction): yield f'reaction("{reaction.getId()}").' if reaction.getReversible() == True: yield f'reversible("{reaction.getId()}").' for reactant in reaction.getListOfReactants(): yield f'reactant("{reactant.getSpecies()}","{reaction.getId()}").' for product in reaction.getListOfProducts(): yield f'product("{product.getSpecies()}","{reaction.getId()}").' document = readSBML(mn_file) if document.getNumErrors() > 0: logger.critical("Encountered the following SBML errors:") logger.critical(document.printErrors()) return 1 # level = document.getLevel() # version = document.getVersion() model = document.getModel() for rxn in model.getListOfReactions(): yield from make_reaction(rxn)
def main (args): """Usage: evaluateCustomMath formula [model containing values] """ if len(args) < 2: print("Usage: evaluateCustomMath formula [model containing values]") return 1; formula = args[1]; filename = None if (len(args) > 2): filename = args[2] math = libsbml.parseFormula(formula); if (math == None): print("Invalid formula, aborting."); return 1; doc = None; if filename != None: doc = libsbml.readSBML(filename); if doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0: print("The models contains errors, please correct them before continuing."); doc.printErrors(); return 1; # the following maps a list of ids to their corresponding model values # this makes it possible to evaluate expressions involving SIds. libsbml.SBMLTransforms.mapComponentValues(doc.getModel()); else: # create dummy document doc = libsbml.SBMLDocument(3, 1); result = libsbml.SBMLTransforms.evaluateASTNode(math, doc.getModel()); print("{0} = {1}".format(formula, result));
def main(args): """Usage: evaluateCustomMath formula [model containing values] """ if len(args) < 2: print("Usage: evaluateCustomMath formula [model containing values]") return 1 formula = args[1] filename = None if (len(args) > 2): filename = args[2] math = libsbml.parseFormula(formula) if (math == None): print("Invalid formula, aborting.") return 1 doc = None if filename != None: doc = libsbml.readSBML(filename) if doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0: print( "The models contains errors, please correct them before continuing." ) doc.printErrors() return 1 # the following maps a list of ids to their corresponding model values # this makes it possible to evaluate expressions involving SIds. libsbml.SBMLTransforms.mapComponentValues(doc.getModel()) else: # create dummy document doc = libsbml.SBMLDocument(3, 1) result = libsbml.SBMLTransforms.evaluateASTNode(math, doc.getModel()) print("{0} = {1}".format(formula, result))
def test_read_l1v1_minimal(self): filename = "../../sbml/test/test-data/l1v1-minimal.xml" d = libsbml.readSBML(filename) if (d == None): pass self.assert_( d.getLevel() == 1 ) self.assert_( d.getVersion() == 1 ) m = d.getModel() self.assert_( m.getNumCompartments() == 1 ) c = m.getCompartment(0) self.assert_(( "x" == c.getName() )) self.assert_( m.getNumSpecies() == 1 ) s = m.getSpecies(0) self.assert_(( "y" == s.getName() )) self.assert_(( "x" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 1 ) self.assert_( s.getBoundaryCondition() == False ) self.assert_( m.getNumReactions() == 1 ) r = m.getReaction(0) self.assert_(( "r" == r.getName() )) self.assert_( r.getReversible() != False ) self.assert_( r.getFast() == False ) self.assert_( r.getNumReactants() == 1 ) self.assert_( r.getNumProducts() == 1 ) sr = r.getReactant(0) self.assert_(( "y" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) sr = r.getProduct(0) self.assert_(( "y" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) _dummyList = [ d ]; _dummyList[:] = []; del _dummyList pass
def template_sync_species(apps, instance): """ Task parses an SBML document, then creates MetaboliteSpecies and MetaboliteExchange records for every species and single-reactant reaction in the model. """ doc = libsbml.readSBML(instance.sbml_file.file.file.name) model = doc.getModel() # filter to only those for the updated template MetaboliteSpecies = apps.get_model("main", "MetaboliteSpecies") MetaboliteExchange = apps.get_model("main", "MetaboliteExchange") species_qs = MetaboliteSpecies.objects.filter(sbml_template=instance) exchange_qs = MetaboliteExchange.objects.filter(sbml_template=instance) exist_species = set(species_qs.values_list("species", flat=True)) exist_exchange = set(exchange_qs.values_list("exchange_name", flat=True)) # creating any records not in the database for species in map(lambda s: s.getId(), model.getListOfSpecies()): if species not in exist_species: MetaboliteSpecies.objects.get_or_create(sbml_template=instance, species=species) else: exist_species.discard(species) reactions = map(lambda r: (r.getId(), r.getListOfReactants()), model.getListOfReactions()) for reaction, reactants in reactions: if len(reactants) == 1 and reaction not in exist_exchange: MetaboliteExchange.objects.get_or_create( sbml_template=instance, exchange_name=reaction, reactant_name=reactants[0].getSpecies(), ) else: exist_exchange.discard(reaction) # removing any records in the database not in the template document species_qs.filter(species__in=exist_species).delete() exchange_qs.filter(exchange_name__in=exist_exchange).delete()
def loadSBML( self, aSBMLDocument ): if type( aSBMLDocument ) == str: self.theSBMLDocument = libsbml.readSBML( aSBMLDocument ) elif type( self.theSBMLDocument ) == file: self.theSBMLDocument = libsbml.readSBMLFromString( aSBMLDocument.read() ) else: self.theSBMLDocument = aSBMLDocument if self.theSBMLDocument.getLevel() != 2: self.theSBMLDocument.setLevel( 2 ) aXMLNamespaceList = self.theSBMLDocument.getNamespaces() anURI = aXMLNamespaceList.getURI( ECELL_XML_NAMESPACE_PREFIX ) if anURI != ECELL_XML_NAMESPACE_URI: if anURI == '': aXMLNamespaceList.add( ECELL_XML_NAMESPACE_PREFIX, \ ECELL_XML_NAMESPACE_URI ) else: raise SBMLConvertError, 'Wrong URI [%s] is already assinged to xmlns:%s. Remove or correct it by yourself' % ( anURI, ECELL_XML_NAMESPACE_PREFIX ) if self.theSBMLDocument.getNumFatals() > 0: fatalerrorList = [] for i in range( self.theSBMLDocument.getNumFatals() ): fatalerrorList.append( self.theSBMLDocument.getFatal( i ).getMessage() ) self.theSBMLDocument = None raise SBMLConvertError, \ 'This SBML document is invalid:\n %s' \ % ( ', '.join( fatalerrorList ) ) if not self.theSBMLDocument.getModel(): self.theSBMLDocument.createModel() self.__createIdDict()
def test_writeSBML(self): rpsbml = rpSBML.rpSBML('test', None, os.path.abspath('../cache')) rpsbml.genericModel('RetroPath_heterologous_pathway', 'rp_model', compXref) rpsbml.modelName = 'test_writeSBML' rpsbml.writeSBML(os.path.abspath('test_models')) inModel = libsbml.readSBML(os.path.join(os.path.abspath('test_models'), 'test_writeSBML.sbml')) assert self.compareModels(inModel.getModel(), rpsbml.model)==True
def _adapt_sbml_file(sbml_file): # create temporary filename for an adapted sbml file for Copasi temp = sbml_file.split('.') temp_file_name = temp[0] + '_deleteme.xml' # get the sbml model, adapt it for Copasi sbml_model = (libsbml.readSBML(sbml_file)).getModel() sbml_model_name = sbml_model.getName() if sbml_model_name == '': sbml_model_name = (sbml_file.split('.')[0]).split('/')[-1] sbml_model.setName(sbml_model_name) output_table = [] for compartment in sbml_model.getListOfCompartments(): # Copasi prioritizes species names over IDs # We have to remove them to user IDs as identifiers in Copasi compartment.unsetName() for species in sbml_model.getListOfSpecies(): # Copasi prioritizes species names over IDs # We have to remove them to user IDs as identifiers in Copasi species.unsetMetaId() species.unsetName() output_table.append((species.getCompartment(), species.getId())) # save changed sbml files and the accompaniying sedml file libsbml.writeSBMLToFile(sbml_model.getSBMLDocument(), temp_file_name) return temp_file_name, sbml_model_name, output_table
def getSimTable(iModel, iFile): # important paths sbml_path = './sedml_models/' + iModel + '/sbml_models/' + iFile + '.sbml' biomodels_path = './sedml_models/' + iModel + '/sbml_models/' + iFile + '.xml' # check for type of model and open sbml/xml file if os.path.exists(sbml_path): sbml_file = libsbml.readSBML(sbml_path) elif os.path.exists(biomodels_path): sbml_file = libsbml.readSBML(biomodels_path) else: print('Something with the paths went wrong!') sys.exit() # get compartments num_comp = sbml_file.getModel().getNumCompartments() comp_and_type = [] for iComp in range(0, num_comp): if not sbml_file.getModel().getCompartment(iComp).getName() == '': comp_and_type.append([sbml_file.getModel().getCompartment(iComp).getId(), sbml_file.getModel().getCompartment(iComp).getName()]) else: comp_and_type.append([sbml_file.getModel().getCompartment(iComp).getId(), sbml_file.getModel().getCompartment(iComp).getId()]) # get species that use one of the compartments above num_spec = sbml_file.getModel().getNumSpecies() spec_and_type = [] for iSpec in range(0, num_spec): spec_comp = sbml_file.getModel().getSpecies(iSpec).getCompartment() for iComp in range(0, len(comp_and_type)): if spec_comp == comp_and_type[iComp][0]: if not sbml_file.getModel().getSpecies(iSpec).getName() == '': spec_and_type.append([comp_and_type[iComp][1], sbml_file.getModel().getSpecies(iSpec).getName(), 'Concentration']) else: spec_and_type.append([comp_and_type[iComp][1], sbml_file.getModel().getSpecies(iSpec).getId(), 'Concentration']) ''' # get parameters that are not constant num_par = sbml_file.getModel().getNumParameters() par_and_type = [] for iPar in range(0, num_par): par_constant = sbml_file.getModel().getParameter(iPar).getConstant() if par_constant == False: if not sbml_file.getModel().getParameter(iPar).getName() == '': par_and_type.append([sbml_file.getModel().getParameter(iPar).getName(), 'Value']) else: par_and_type.append([sbml_file.getModel().getParameter(iPar).getId(), 'Value']) ''' return spec_and_type#, par_and_type
def ParseSBMLFile(filePath): """ Parameters ---------- filePath : string File path of the SBML model to be parsed Returns ------- ModelData An object containing the model's components and their properties. """ doc = libsbml.readSBML(filePath) assert (doc.getNumErrors() == 0) model = doc.getModel() modelData = sbmltoodepy.dataclasses.ModelData() # outputFile = open(outputPath, "w") # outputFile.write("Parameters"+ "\n") for i in range(model.getNumParameters()): newParameter = ParseParameterAssignment(i, model.getParameter(i)) modelData.parameters[newParameter.Id] = newParameter # outputFile.write("Compartments" + "\n") for i in range(model.getNumCompartments()): newCompartment = ParseCompartment(i, model.getCompartment(i)) modelData.compartments[newCompartment.Id] = newCompartment # outputFile.write("Species"+ "\n") for i in range(model.getNumSpecies()): newSpecies = ParseSpecies(i, model.getSpecies(i)) modelData.species[newSpecies.Id] = newSpecies # outputFile.write("Functions" + "\n") for i in range(model.getNumFunctionDefinitions()): newFunction = ParseFunction(i, model.getFunctionDefinition(i)) modelData.functions[newFunction.Id] = newFunction # outputFile.write("Rules"+ "\n") for i in range(model.getNumRules()): newRule = ParseRule(i, model.getRule(i)) if type(newRule) == sbmltoodepy.dataclasses.AssignmentRuleData: modelData.assignmentRules[newRule.Id] = newRule elif type(newRule) == sbmltoodepy.dataclasses.RateRuleData: modelData.rateRules[newRule.Id] = newRule # outputFile.write("Reactions"+ "\n") for i in range(model.getNumReactions()): newReaction = ParseReaction(i, model.getReaction(i)) modelData.reactions[newReaction.Id] = newReaction for i in range(model.getNumInitialAssignments()): newAssignment = ParseInitialAssignment(i, model.getInitialAssignment(i)) modelData.initialAssignments[newAssignment.Id] = newAssignment #print(model.getNumSpecies()) return modelData
def _check_sedml_submodels(sedml_file, sbml_files, model_name, model_year, model_info): """Checks which sbml models of one sedml group belong together""" sedml_path = os.path.abspath(sedml_file) sedml_doc = libsedml.readSedML(sedml_file) sedml_task_models = [task.getModelReference() for task in sedml_doc.getListOfTasks()] for sbml_file in sbml_files: # we want to find a simulation task for this SBML model # first, get the name of the file (identifier in SED-ML) sbml_path = os.path.abspath(sbml_file) sbml_file_short = (sbml_file.split('/')[-1]).split('.')[0] # Find the first task for this model (and warn if no task was found) try: task_number = sedml_task_models.index(sbml_file_short) except ValueError: print('SBML file not found in list of tasks: ' + sbml_file_short) return model_info # get the corresponding simulation setting current_sim = sedml_doc.getSimulation(sedml_doc.getTask( task_number).getSimulationReference()) # remember simulation settings # out_start = current_sim.getOutputStartTime() out_end = current_sim.getOutputEndTime() # n_timepoints = current_sim.getNumberOfPoints() # get info about the SBML file sbml_model = libsbml.readSBML(sbml_file).getModel() if sbml_model is None: # check for SBML model print(f'No sbml model found for file {sbml_file}, ' f'in model name f{model_name}, ' f'model year {model_year}') return model_info n_species = len(sbml_model.getListOfSpecies()) n_reactions = len(sbml_model.getListOfReactions()) # add model information to the list model_info.append({ 'name': model_name, 'year': model_year, 'n_species': n_species, 'n_reactions': n_reactions, 'sbml_path': sbml_path, 'sedml_path': sedml_path, 'regrouped_path': '', # to be filled later 'start_time': 0, # will only use t_end to have a rough timeframe 'end_time': out_end, 'n_timepoints': 101, # will only use t_end to have a rough timeframe 'long_id': (model_name, model_year, n_species, n_reactions), 'short_id': '', 'sedml_task': task_number, }) return model_info
def test_createUnit(self): rpsbml = rpSBML.rpSBML('test', None, os.path.abspath('../cache')) rpsbml.createModel('RetroPath_heterologous_pathway', 'rp_model') unitDef = rpsbml.createUnitDefinition('mmol_per_gDW_per_hr') rpsbml.createUnit(unitDef, libsbml.UNIT_KIND_MOLE, 1, -3, 1) rpsbml.createUnit(unitDef, libsbml.UNIT_KIND_GRAM, 1, 0, 1) rpsbml.createUnit(unitDef, libsbml.UNIT_KIND_SECOND, 1, 0, 3600) inModel = libsbml.readSBML(os.path.join(os.path.abspath('test_models'), 'test_createUnit.sbml')) assert self.compareModels(inModel.getModel(), rpsbml.model)==True
def load( self, filepath ): self.filepath = filepath try: self.sbml = libsbml.readSBML( self.filepath ) except Exception as e: logging.error( 'Failed to load %s' % self.filepath ) logging.error( '\tError was %s' % e ) quit( -1 ) logging.info( "SBML is loaded" )
def parseSBML(self): if not hasattr(self, '_sbml_document'): # self.sbml_file = ForeignKey # self.sbml_file.file = FileField on Attachment # self.sbml_file.file.file = File object on FileField # self.sbml_file.file.file.name = path to file import libsbml self._sbml_document = libsbml.readSBML(self.sbml_file.file.file.name) return self._sbml_document
def __init__(self, path, rprefix='', rsuffix='', cprefix='', csuffix=''): super(SBMLParser, self).__init__() self.sbml_document = libsbml.readSBML(path) if self.sbml_document.getNumErrors() > 0: raise Exception, "libsbml function getNumErrors return value greater 0!" self.model = self.sbml_document.getModel() self.rprefix = rprefix self.rsuffix = rsuffix self.cprefix = cprefix self.csuffix = csuffix
def main( filename ): sbmlDocument = libsbml.readSBML( filename ) aSBMLIdManager = sbmlsupport.SBMLIdManager( sbmlDocument ) print aSBMLIdManager.compartmentDict print aSBMLIdManager.speciesDict print aSBMLIdManager.parameterDict print aSBMLIdManager.reactionDict print aSBMLIdManager.ruleDict
def main(filename): sbmlDocument = libsbml.readSBML(filename) aSBMLIdManager = sbmlsupport.SBMLIdManager(sbmlDocument) print aSBMLIdManager.compartmentDict print aSBMLIdManager.speciesDict print aSBMLIdManager.parameterDict print aSBMLIdManager.reactionDict print aSBMLIdManager.ruleDict
def add_boundary_species(candidates): asansm_sbml = "fbc/iPAE1146_Amino_sugar_and_nucleotide_sugar_metabolism_fbc_squeezed.xml" pm_sbml = "fbc/iPAE1146_Pyrimidine_metabolism_fbc_squeezed.xml" lb_sbml = "fbc/iPAE1146_Lipopolysaccharide_biosynthesis_fbc_squeezed.xml" combined_sbml = "fbc/iPAE1146_Combined_Subsystems_fbc_squeezed.xml" asansm_libsbml_doc = libsbml.readSBML(asansm_sbml) asansm_libsbml = asansm_libsbml_doc.getModel() set_boundary_species( asansm_libsbml, candidates["Amino sugar and nucleotide sugar metabolism"]) libsbml.writeSBMLToFile( asansm_libsbml_doc, "xml/iPAE1146_Amino_sugar_and_nucleotide_sugar_metabolism_fbc_squeezed_with_boundaries.xml" ) pm_libsbml_doc = libsbml.readSBML(pm_sbml) pm_libsbml = pm_libsbml_doc.getModel() set_boundary_species(pm_libsbml, candidates["Pyrimidine metabolism"]) libsbml.writeSBMLToFile( pm_libsbml_doc, "xml/iPAE1146_Pyrimidine_metabolism_fbc_squeezed_with_boundaries.xml") lb_libsbml_doc = libsbml.readSBML(lb_sbml) lb_libsbml = lb_libsbml_doc.getModel() set_boundary_species(lb_libsbml, candidates["Lipopolysaccharide biosynthesis"]) libsbml.writeSBMLToFile( lb_libsbml_doc, "xml/iPAE1146_Lipopolysaccharide_biosynthesis_fbc_squeezed_with_boundaries.xml" ) combined_libsbml_doc = libsbml.readSBML(combined_sbml) combined_libsbml = combined_libsbml_doc.getModel() boundary_species = set() for candidate_list in candidates.values(): for species in candidate_list: boundary_species.add(species) set_boundary_species(combined_libsbml, candidates["Combined"]) libsbml.writeSBMLToFile( combined_libsbml_doc, "xml/iPAE1146_Combined_Subsystems_fbc_squeezed_with_boundaries.xml")
def _get_active_objective_from_fbc(sbml): """ Read the active objective from fbc model. """ obj_coefs = {} doc = readSBML(sbml) if doc.getPlugin("fbc") != None: model_sbml = doc.getModel() mplugin = model_sbml.getPlugin("fbc") # read the active objective objective = mplugin.getActiveObjective() for fluxobj in objective.getListOfFluxObjectives(): obj_coefs[fluxobj.getReaction()] = fluxobj.getCoefficient() return obj_coefs
def read_gene_associations_from_fbc(sbml): """ Reading all the GeneAssociations from FBC. """ doc = libsbml.readSBML(sbml) if doc.getPlugin("fbc") is not None: model_sbml = doc.getModel() mplugin = model_sbml.getPlugin("fbc") for ga in mplugin.getListOfGeneAssociations(): ass = ga.getAssociation() infix = ass.toInfix() # get the rule string for cobray print(infix, ':', ass.toSBML())
def readSBMLModel(sbml_model): try: sbml = getRoadrunnerSBML(sbml_model) except TypeError: if os.path.exists(sbml_model) and os.path.isfile(sbml_model): # it's a file path if os.path.splitext(sbml_model)[1] == '.sb': # it's an Antimony file with open(sbml_model) as f: return libsbml.readSBML(antimonyConverter.antimonyToSBML(f.read())) elif os.path.splitext(sbml_model)[1] == '.txt': raise RuntimeError('File ending in ".txt" is ambiguous - pass an SBML file (.xml) or an Antimony file (.sb).') else: return libsbml.readSBMLFromFile(sbml_model) else: # check if it's Antimony source try: return libsbml.readSBML(antimonyConverter.antimonyToSBML(sbml_model)) except: # it better be SBML # this will throw if it's not SBML return libsbml.readSBML(model)
def main(argc, argv): test_dir = os.path.join(argv[1], argv[2]) out_dir = os.path.join(argv[3], argv[2]) settings = os.path.join(argv[1], argv[2], "{}-settings.txt".format(argv[2])) model = os.path.join(argv[1], argv[2], "{}-model.m".format(argv[2])) sbml = os.path.join( argv[1], argv[2], "{0}-sbml-l{1}v{2}.xml".format(argv[2], argv[4], argv[5])) print(test_dir, sbml, out_dir) doc = readSBML(sbml) m = doc.getModel() modelica_id = m.getIdAttribute() with open(model, 'r') as fp: mcont = fp.read().splitlines() for line in mcont: if line.startswith('testType'): if 'TimeCourse' not in line: exit(1) if line.startswith('packagesPresent'): if line.replace(" ", "") != 'packagesPresent:': exit(1) with open(settings, 'r') as fp: scont = fp.read().splitlines() start = scont[0].replace(" ", "").split(":")[1] horizon = scont[1].replace(" ", "").split(":")[1] step_size = str( float(horizon) / float(scont[2].replace(" ", "").split(":")[1])) variables = scont[3].replace(" ", "").split(":")[1].split(",") if type(variables) is str: variables = [variables] amnt = scont[6].replace(" ", "").split(":")[1].split(",") if type(amnt) is str: amnt = [amnt] conc = scont[7].replace(" ", "").split(":")[1].split(",") if type(conc) is str: conc = [conc] print( os.system('{0} {1} {2} --log {3}'.format(sbml2modelica, sbml, out_dir, log_file))) compile_modelica(out_dir, modelica_id, start, horizon, step_size) simulate(out_dir, modelica_id) #print modelica_varnames(variables, amnt, conc, sbml) save_results(out_dir, modelica_id, argv[2], variables, modelica_varnames(variables, amnt, conc, sbml), float(step_size))
def __init__(self, sbml, reaction_index, species_index, enzymes_index, substrateIndexs, state): ''' In the end the full calculation has to be possible solely based on the given SBML. ''' # necessary to have the species/reaction/enzymes to index mapping for lookup # and mapping between ids and indices # this will later be created from the sbml self.r_index = reaction_index self.s_index = species_index self.e_index = enzymes_index self.substrateIndexs = substrateIndexs self.s_acp_index = 570 # handle Acetyl-Carrier Protein doc = readSBML(sbml) self.model = doc.getModel() self.protein_reactions = self.find_protein_reactions() # set reused attributes from state dict # the complete information should be parsed from the SBML # TODO: step by step reduce the state dependency. for key in [ # in SBML 'fbaReactionCatalysisMatrix', 'fbaReactionBounds', 'fbaEnzymeBounds', # get the right reactions (TODO: code type in SBML) 'fbaReactionIndexs_metabolicConversion', 'fbaReactionIndexs_metaboliteInternalExchange', 'fbaReactionIndexs_biomassExchange', 'fbaReactionIndexs_biomassProduction', 'fbaReactionIndexs_metaboliteExternalExchange', 'fbaReactionIndexs_metaboliteInternalLimitedExchange', 'compartmentIndexs_cytosol', 'compartmentIndexs_extracellular', # substrate for reactions (in SBML) 'substrateIndexs_externalExchangedMetabolites', 'substrateIndexs_internalExchangedLimitedMetabolites', 'substrateIndexs_limitableProteins', ]: setattr(self, key, state[key]) # self.Nr = self.fbaReactionBounds.shape[0] # 504 reactions (lower and upper for every necessary) self.Nr = len(self.model.getListOfReactions()) # TODO: set as parameter and read self.stepSizeSec = 1
def main(args): """Usage: replaceOneFD filename functionDefinitionId reactionId outfile """ if (len(args) != 5): print( "Usage: replaceOneFD filename functionDefinitionId reactionId outfile" ) return 1 filename = args[1] outFile = args[4] functionDefinitionId = args[2] reactionId = args[3] document = libsbml.readSBML(filename) if (document.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0): print( "The models contains errors, please correct them before continuing." ) document.printErrors() return 1 model = document.getModel() functionDefinition = model.getFunctionDefinition(functionDefinitionId) if (functionDefinition == None): print() print("No functiondefinition with the given id can be found.") return 1 reaction = model.getReaction(reactionId) if (reaction == None): print() print("No reaction with the given id can be found.") return 1 if (reaction.isSetKineticLaw() == False or reaction.getKineticLaw().isSetMath() == False): print() print("The reaction has no math set. ") return 1 # Until here it was all setup, all we needed was an ASTNode, in which we wanted to # replace calls to a function definition, with the function definitions content. # libsbml.SBMLTransforms.replaceFD(reaction.getKineticLaw().getMath(), functionDefinition) # finally write to file libsbml.writeSBML(document, outFile)
def test_createSpecies(self): rpsbml = rpSBML.rpSBML('test', None, os.path.abspath('../cache')) rpsbml.genericModel('RetroPath_heterologous_pathway', 'rp_model', compXref) for meta in set([i for step in steps for lr in ['left', 'right'] for i in step[lr]]): try: inchi = rp_inchi[meta] except KeyError: inchi = None try: smiles = rp_smiles[meta] except KeyError: smiles = None rpsbml.createSpecies(meta, chemXref, None, inchi, smiles, 'MNXC3', 0, '') inModel = libsbml.readSBML(os.path.join(os.path.abspath('test_models'), 'test_createSpecies.sbml')) assert self.compareModels(inModel.getModel(), rpsbml.model)==True
def init(self): assert self.sbml_file_path, "SBML file not set" self.document = readSBML(self.sbml_file_path); if os.path.exists(self.filter_filename): with open(self.filter_filename, "r") as filter_file: self.filter_list = [x.split("\t")[0].strip() for x in filter_file.read().lower().splitlines()] else: self.filter_list = [] # errors = self.document.getNumErrors(); # if (errors > 0): # _log.error(str(errors)) # raise ("Encountered the following SBML errors:" + str(errors)) self.model = self.document.getModel();
def test_sbml_export_conversion(self): try: import libsbml except ImportError: return tmp = tempfile.NamedTemporaryFile(delete=False) model = create_robust_model() path = export_SBML(model, filename=tmp.name) document = libsbml.readSBML(path) if document.getNumErrors() > 0: error_id = document.getError(0).getErrorId() file_errors = [ libsbml.XMLFileUnreadable, libsbml.XMLFileOperationError ] assert error_id not in file_errors
def check_sbml(filepath, name=None, ucheck=True, show_errors=True): """ Checks the given SBML file path or String for validation errors. :param filepath: path of SBML file :param ucheck: boolen if unit checks should be performed :return: number of errors """ # FIXME: check if this is also working for SBML strings if name is None: if len(filepath) < 100: name = filepath else: name = filepath[0:99] + '...' doc = libsbml.readSBML(filepath) return check_doc(doc, name=name, ucheck=ucheck, show_errors=show_errors)
def annotate_sbml_file(f_sbml, f_annotations, f_sbml_annotated): """ Annotate a given SBML file with the provided annotations. :param f_sbml: SBML to annotation :param f_annotations: csv file with annotations :param f_sbml_annotated: annotated file """ # read SBML model doc = libsbml.readSBML(f_sbml) # read annotations annotations = ModelAnnotator.annotations_from_file(f_annotations) doc = annotate_sbml_doc(doc, annotations) # Save libsbml.writeSBMLToFile(doc, f_sbml_annotated)
def loadSBML(self, aSBMLDocument): if type(aSBMLDocument) == str: self.theSBMLDocument = libsbml.readSBML(aSBMLDocument) elif type(aSBMLDocument) == file: self.theSBMLDocument = libsbml.readSBMLFromString(aSBMLDocument.read()) else: self.theSBMLDocument = aSBMLDocument if self.theSBMLDocument.getLevel() != 2: self.theSBMLDocument.setLevel(2) if self.theSBMLDocument.getNumFatals() > 0: fatalerrorList = [] for i in range(self.theSBMLDocument.getNumFatals()): fatalerrorList.append(self.theSBMLDocument.getFatal(i)) self.theSBMLDocument = None raise SBMLConvertError, "This SBML document is invalid: %s" % (", ".join(fatalerrorList))
def main (args): """Usage: replaceOneFD filename functionDefinitionId reactionId outfile """ if (len(args) != 5): print("Usage: replaceOneFD filename functionDefinitionId reactionId outfile"); return 1; filename = args[1]; outFile = args[4]; functionDefinitionId = args[2]; reactionId = args[3]; document = libsbml.readSBML(filename); if (document.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0): print("The models contains errors, please correct them before continuing."); document.printErrors(); return 1; model = document.getModel(); functionDefinition = model.getFunctionDefinition(functionDefinitionId); if (functionDefinition == None): print(); print("No functiondefinition with the given id can be found."); return 1; reaction = model.getReaction(reactionId); if (reaction == None): print(); print("No reaction with the given id can be found."); return 1; if (reaction.isSetKineticLaw() == False or reaction.getKineticLaw().isSetMath()== False): print(); print("The reaction has no math set. "); return 1; # Until here it was all setup, all we needed was an ASTNode, in which we wanted to # replace calls to a function definition, with the function definitions content. # libsbml.SBMLTransforms.replaceFD(reaction.getKineticLaw().getMath(), functionDefinition); # finally write to file libsbml.writeSBML(document, outFile);
def load_cobra_model(path, notifications): """Load a COBRA model with meta information from an SBML document.""" doc = libsbml.readSBML(path) fbc = doc.getPlugin("fbc") sbml_ver = doc.getLevel(), doc.getVersion(), fbc if fbc is None else \ fbc.getVersion() with catch_warnings(record=True) as warnings: simplefilter("always") try: model = read_sbml_model(path) except Exception as err: notifications['errors'].append(str(err)) model = None validate = True else: validate = False notifications['warnings'].extend([str(w.message) for w in warnings]) if validate: run_sbml_validation(doc, notifications) return model, sbml_ver
def main (args): """Usage: addCustomValidator filename """ if len(args) != 2: print(main.__doc__) sys.exit(1) # read the file name document = libsbml.readSBML(args[1]); # add a custom validator document.addValidator(MyCustomValidator()); # check consistency like before numErrors = document.checkConsistency(); # print errors and warnings document.printErrors(); # return number of errors return numErrors;
def main (args): """Usage: printNotes filename """ if (len(args) != 3): print("Usage: inlineInitialAssignments filename outFile"); return 1; filename = args[1]; outFile = args[2]; document = libsbml.readSBML(filename); if (document.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0): print("The models contains errors, please correct them before continuing."); document.printErrors(); return 1; model = document.getModel(); libsbml.SBMLTransforms.expandInitialAssignments(model); libsbml.writeSBML(document, outFile);
def create_sbml_report(sbml_path, out_dir, template='report.html', promote=False, validate=True): """ Creates the SBML report in the out_dir :param validate: :param promote: :param template: :param sbml_path: :param doc: :param out_dir: :return: :rtype: """ # check if sbml_file exists if not os.path.exists(sbml_path): warnings.warn('SBML file does not exist: {}'.format(sbml_path)) # check sbml file if validate: check_sbml(sbml_path) # read sbml doc = libsbml.readSBML(sbml_path) if promote: promote_local_variables(doc) # write sbml to output folder basename = os.path.basename(sbml_path) tokens = basename.split('.') name = '.'.join(tokens[:-1]) f_sbml = os.path.join(out_dir, basename) libsbml.writeSBMLToFile(doc, f_sbml) # write html (unicode) html = _create_html(doc, basename, html_template=template) f_html = codecs.open(os.path.join(out_dir, '{}.html'.format(name)), encoding='utf-8', mode='w') f_html.write(html) f_html.close()
def to_SBML_l2v1(from_name, to_name): """ Convert an SBML file to level 2, version 1 using lisbml. from_name Name of file to read SBML from. to_name File to output SBML to. """ doc = libsbml.readSBML(os.path.abspath(from_name)) if isinstance(doc, int): logger.critical('Fatal Errors reading SBML from file %s!' % from_name) _print_sbml_fatals(doc) errors = doc.setLevel(2) if errors: logger.critical('Fatal Errors converting %f to level 2!' % from_name) _print_sbml_fatals(doc) errors = doc.setVersion(1) if errors: logger.critical('Fatal Errors converting %f to level 2, version 1!' % from_name) _print_sbml_fatals(doc) success = libsbml.writeSBML(doc, to_name) if not success: logger.critical('Error writing to %s' % to_name)
def validate(self, file): if not os.path.exists(file): print("[Error] %s : No such file." % (infile)) self.numinvalid += 1 return start = time.time() sbmlDoc = libsbml.readSBML(file) stop = time.time() timeRead = (stop - start)*1000 errors = sbmlDoc.getNumErrors() seriousErrors = False numReadErr = 0 numReadWarn = 0 errMsgRead = "" if errors > 0: for i in range(errors): severity = sbmlDoc.getError(i).getSeverity() if (severity == libsbml.LIBSBML_SEV_ERROR) or (severity == libsbml.LIBSBML_SEV_FATAL): seriousErrors = True numReadErr += 1 else: numReadWarn += 1 errMsgRead = sbmlDoc.getErrorLog().toString() # If serious errors are encountered while reading an SBML document, it # does not make sense to go on and do full consistency checking because # the model may be nonsense in the first place. numCCErr = 0 numCCWarn = 0 errMsgCC = "" skipCC = False; timeCC = 0.0 if seriousErrors: skipCC = True; errMsgRead += "Further consistency checking and validation aborted." self.numinvalid += 1; else: sbmlDoc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY, self.ucheck) start = time.time() failures = sbmlDoc.checkConsistency() stop = time.time() timeCC = (stop - start)*1000 if failures > 0: isinvalid = False; for i in range(failures): severity = sbmlDoc.getError(i).getSeverity() if (severity == libsbml.LIBSBML_SEV_ERROR) or (severity == libsbml.LIBSBML_SEV_FATAL): numCCErr += 1 isinvalid = True; else: numCCWarn += 1 if isinvalid: self.numinvalid += 1; errMsgCC = sbmlDoc.getErrorLog().toString() # # print results # print(" filename : %s" % (file)) print(" file size (byte) : %d" % (os.path.getsize(file))) print(" read time (ms) : %f" % (timeRead)) if not skipCC : print( " c-check time (ms) : %f" % (timeCC)) else: print( " c-check time (ms) : skipped") print( " validation error(s) : %d" % (numReadErr + numCCErr)) if not skipCC : print( " (consistency error(s)): %d" % (numCCErr)) else: print( " (consistency error(s)): skipped") print( " validation warning(s) : %d" % (numReadWarn + numCCWarn)) if not skipCC : print( " (consistency warning(s)): %d" % (numCCWarn)) else: print( " (consistency warning(s)): skipped") if errMsgRead or errMsgCC: print() print( "===== validation error/warning messages =====\n") if errMsgRead : print( errMsgRead) if errMsgCC : print( "*** consistency check ***\n") print( errMsgCC)
def _writeSBMLToDBModel(conn, database_path, sbml_input_path, use_species_name_attribute, print_warnings): c = conn.cursor() # read file if not os.path.exists(sbml_input_path): raise Exception("[Error] {0} : no such file.\n".format(sbml_input_path)) # try to parse SBML document try: document = libsbml.readSBML(sbml_input_path) except libsbml.SBMLError as e: raise Exception("[Error] writeSBMLToDBModel; {0} : File not readable by method libsbml.readSBML(), aborting model import.\n {1}".format(sbml_input_path, e.value)) # check SBML level if not (document.getLevel() == 3 and document.getVersion() == 1) and print_warnings: print("[Warning] writeSBMLToDBModel; {0} : SBML file has level {0}.{1}. This tool was written for SBML Level 3.1.\n".format(document.getLevel(), document.getVersion())) # check if qualitative model if not document.getPkgRequired("qual") and print_warnings: print("[Warning] writeSBMLToDBModel; {0} : \"qual\"-package is not set as required for this SBML file.\n".format(sbml_input_path)) # check model consistency (document.checkConsistency() is called automatically by libsbml.readSBML) errors = document.getNumErrors() seriousErrors = False if errors > 0: for i in range(errors): severity = document.getError(i).getSeverity() if (severity == libsbml.LIBSBML_SEV_ERROR) or (severity == libsbml.LIBSBML_SEV_FATAL): seriousErrors = True if seriousErrors: raise Exception("[Error] writeSBMLToDBModel; {0} : SBML file invalid or inconsistant (fatal errors), aborting model import.\n Error Log from libSBML:\n{1}".format(sbml_input_path, document.getErrorLog().toString())) elif print_warnings: print("[Warning] writeSBMLToDBModel; {0} : SBML file inconsistancies (non-fatal errors).\n Error Log from libSBML:\n{1}".format(sbml_input_path, document.getErrorLog().toString())) # create a model object model = document.getModel() # get a QualModelPlugin object plugged into the model object (enables qualSBML interface). mplugin = model.getPlugin("qual") # Selection and checks of species names to be used for the TREMPPI database: # Since the SBML exporter tool (db2sbmp.py) does not work with component names with underscores "_" and the QualitativeSpecies:Name attribute is not guaranteed to be unique, # the existance and uniqueness of the names to be used internally by TREMPPI has to be checked. species_id_name_dict = {} # dictionary with {SBML QS:Id:(Name for TREMPPI)} pairs for database inserts. Unmodified Id is still used by the function internally, since SBML FunctionTerms use QS:Id as species identifiers. species_modNames = [] # Names (SBML QS:Name or SBML QS:Id) without underscores # for all qualitativeSpecies for qs in mplugin.getListOfQualitativeSpecies(): # if name attribute should be used, remove name underscores and fill Id:name dictionary if use_species_name_attribute and qs.isSetName(): species_modNames.append(re.sub('_+', '', qs.getName())) species_id_name_dict.update({qs.getId():re.sub('_+', '', qs.getName())}) # if names should be used but are not all set, throw an exception elif use_species_name_attribute: raise Exception("[Error] writeSBMLToDBModel; {0} : SBML Qualitative species name attributes are not set for all species, aborting model import.\n\tTry using species Ids instead by setting use_species_name_attributes=False.".format(sbml_input_path)) # if Ids should be used, remove Id underscores and fill Id:(Id without underscores) dictionary else: species_modNames.append(re.sub('_+', '', qs.getId())) species_id_name_dict.update({qs.getId():re.sub('_+', '', qs.getId())}) # if selected names are not unique, throw an exception if use_species_name_attribute and len(set(species_modNames)) != len(species_modNames): raise Exception("[Error] writeSBMLToDBModel; {0} : SBML Qualitative species name attributes are not unique without underscores, aborting model import.\n\tTry using species Ids instead by setting use_species_name_attributes=False.".format(sbml_input_path)) elif len(set(species_modNames)) != len(species_modNames): raise Exception("[Error] writeSBMLToDBModel; {0} : SBML Qualitative species Id attributes are not unique without underscores, aborting model import.\n\tTry using species names instead by setting use_species_name_attributes=True.".format(sbml_input_path)) # Check if maximum activity level is set for each species in SBML. If not, a boolean model is assumed. # Also fill two dictionaries with MaxActivity by Name and Id MA_is_set = True species_Id_maxActivity_dict = {} # used by function computeThresholds species_Name_maxActivity_dict = {} # used to order Name - MaxActivity pairs by Name (necessary if Id attributes are not alphabetically ordered or the qual. species name attribute is used) for qs in mplugin.getListOfQualitativeSpecies(): # Use Name or Id as component name if use_species_name_attribute: Name = re.sub('_+', '', qs.getName()) else: Name = re.sub('_+', '', qs.getId()) # Use maxLevel or 1 as MaxActivity if qs.isSetMaxLevel(): MaxActivity = qs.getMaxLevel() else: MaxActivity = 1 MA_is_set = False species_Id_maxActivity_dict.update({qs.getId():MaxActivity}) species_Name_maxActivity_dict.update({Name:MaxActivity}) if not MA_is_set and print_warnings: print("[Warning] writeSBMLToDBModel; {0} : Maximum activity level not set in SBML file for at least one species. Assuming max. level = 1.\n".format(sbml_input_path)) # Table Components c.execute('CREATE TABLE Components (Name TEXT, MaxActivity INTEGER)') # fill table Components in alphabetical order for Name in sorted(species_Name_maxActivity_dict.keys()): c.execute('INSERT INTO Components VALUES (?,?)', (Name, species_Name_maxActivity_dict[Name])) # Create temporary table Regulations, needs to be ordered later. c.execute('CREATE TABLE TmpRegulations (Source TEXT, Target TEXT, Threshold INTEGER)') # Fill table Regulations and extract regulatory contexts and target values from qualSBML transitions input_transition_effect_is_OK = True # qualitative models should have specific input and output transition effect values output_transition_effect_is_OK = True context_list = [] # list for regulatory context string representations (e.g. 'K_raf_01') target_value_list = [] # list for corresponding context target values # for each qualSBML transition t: for t in mplugin.getListOfTransitions(): # sources and targets of this transition (2 lists of RefID strings == Qalitative species names == TREMPPI component names) target_list = [] source_list = [] target_name_list = [] source_name_list = [] # get targets for table Regulations, order by target name for output in t.getListOfOutputs(): target_list.append(output.getQualitativeSpecies()) # returns RefID (Qual. species Id) if use_species_name_attribute: target_name_list.append(species_id_name_dict[output.getQualitativeSpecies()]) else: target_name_list.append(re.sub('_+', '', output.getQualitativeSpecies())) if output.getTransitionEffect() != 1: # logical/multivalued models should have "assignmentLevel" == 1 (see qualSBML doc.) output_transition_effect_is_OK = False # order target list by internal TREMPPI names target_list = [target for target_name, target in sorted(zip(target_name_list, target_list))] # get sources for table Regulations, order by source name for input in t.getListOfInputs(): source_list.append(input.getQualitativeSpecies()) # returns RefID (Qual. species Id) if use_species_name_attribute: source_name_list.append(species_id_name_dict[input.getQualitativeSpecies()]) else: source_name_list.append(re.sub('_+', '', input.getQualitativeSpecies())) if input.getTransitionEffect() != 0: # logical/multivalued models should have "none" == 0 (see qualSBML doc.) input_transition_effect_is_OK = False # order source list by internal TREMPPI names source_list = [source for source_name, source in sorted(zip(source_name_list, source_list))] # dictionary for storage of thresholds for each source species in this transition source_threshold_dict = {s:[] for s in source_list} # e.g. {raf:[1,3], rafB:[1]} # find thresholds of sources for the TREMPPI regulations which are encoded in this qualSBML transition's function terms for f in t.getListOfFunctionTerms(): # get the ASTNode tree of the SBML mathML definition of the function term # getMath() returns the top ASTNode of the tree math_AST = f.getMath() try: # source_threshold_dict is progressively filled/updated with information from each SBML FunctionTerm element computeThresholds(math_AST, source_threshold_dict, species_Id_maxActivity_dict) except ParseASTError as e: raise Exception("[Error] writeSBMLToDBModel; {0} : Couldn't compute Thresholds for FunctionTerm of target {1} (SBML document, line {2}). Aborting model import. \n{3}".format(sbml_input_path, target_list[0], f.getLine(), e.value)) # fill table TmpRegulations with regulations from this libsbml.Transition for target in target_list: for source in source_list: for threshold in source_threshold_dict[source]: c.execute('INSERT INTO TmpRegulations VALUES (?,?,?)', (species_id_name_dict[source], species_id_name_dict[target], threshold)) # create regulatory context definitions and evaluate libsbml.FunctionTerm math for context threshold states for target in target_list: # build a list of lists, where each sublist contains 0 and all thresholds for one input/source species thresholds_list_with_lower_zeros = [[0] + source_threshold_dict[s] for s in source_list] # create a list of all possible source threshold state combinations for this transition # e.g. CompA thresholds = [1], CompB thresholds = [1,2] -> context_threshold_states = [ [0,0], [0,1], [0,2], [1,0], [1,1], [1,2] ] context_threshold_states = list(itertools.product(*thresholds_list_with_lower_zeros)) # for each context threshold state for cts in context_threshold_states: # get the target name to be used for this TREMPPI context definition (name attribute or Id without underscores) target_db_name = species_id_name_dict[target] # build the TREMPPI regulatory context definition (e.g. K_Raf_01) and append to context list context = 'K_{0}_{1}'.format(target_db_name, ''.join([str(t) for t in cts])) context_list.append(context) # get the target value for this context: # initialize the target value with the libsbml.Transition.DefaultTerm resultLevel target_value = t.getDefaultTerm().getResultLevel() # create a dictionary with pairs source:(source threshold state) for this context threshold state (cts) source_ts_dict = {source:threshold_state for (source, threshold_state) in zip(source_list, cts)} # Call evaluateContext for each FunctionTerm until a function evaluates to true for this context or all FunctionTerms have been evaluated. # If a FunctionTerm evaluates to true, use its result level as the target value for this context. # If none evaluates to true, keep the DefaultTerm result level as the target value. for ft in t.getListOfFunctionTerms(): try: if evaluateContext(source_ts_dict, ft.getMath()): target_value = ft.getResultLevel() break except ParseASTError as e: raise Exception("[Error] writeSBMLToDBModel; {0} : Couldn't evaluate context for FunctionTerm of target {1}. \n{2}".format(sbml_input_path, target_list[0], e.value)) # store the target values in order of regulatory contexts target_value_list.append(target_value) # warn if transition effect attributes were set to unexpected values if not output_transition_effect_is_OK and print_warnings: print("[Warning] writeSBMLToDBModel; {0} : At least one Transition output species has the transitionEffect attribute set to 'production' (0). Should be 'assignment level' (1) for logical/multi-valued models.\n".format(sbml_input_path)) if not input_transition_effect_is_OK and print_warnings: print("[Warning] writeSBMLToDBModel; {0} : At least one Transition input species has the transitionEffect attribute set to 'consumption' (1). Should be 'none' (0) for logical/multi-valued models.\n".format(sbml_input_path)) # Create final table Regulations, ordered by Target(1), Source(2), Threshold(3) and discard temporary table c.execute('CREATE TABLE Regulations (Source TEXT, Target TEXT, Threshold INTEGER)') c.execute('INSERT INTO Regulations SELECT * FROM TmpRegulations ORDER BY Target, Source, Threshold') c.execute('DROP TABLE TmpRegulations') # Table Parametrizations # build string for definition of column names (context names) column_def_string = ' INTEGER, '.join(sorted(context_list)) + ' INTEGER' # build string for context target values, ordered by context names target_value_string = ', '.join([str(t) for c, t in sorted(zip(context_list, target_value_list))]) # create table and insert target values c.execute('CREATE TABLE Parametrizations ({0})'.format(column_def_string)) c.execute('INSERT INTO Parametrizations VALUES ({0})'.format(target_value_string)) # commit database changes conn.commit() #end writeSBMLToDBModel ## Example models # SBML to DB import example 1: Cortical Area Development #writeSBMLToDBModel("./data/databases/modelDB.sqlite", "./data/sbml/CorticalAreaDevelopment_cellCollective_boolean.sbml") #writeSBMLToDBModel("./data/databases/modelDB.sqlite", "./data/sbml/CorticalAreaDevelopment_cellCollective_boolean.sbml", use_species_name_attribute=True) # SBML to DB import example 2: Mammalian Cellcycle #writeSBMLToDBModel("./data/databases/modelDB.sqlite", "./data/sbml/MammalianCellCycle_cellCollective_boolean.sbml") #writeSBMLToDBModel("./data/databases/modelDB.sqlite", "./data/sbml/MammalianCellCycle_cellCollective_boolean.sbml", use_species_name_attribute=True) # SBML to DB import example 3: Notch Pathway #writeSBMLToDBModel("./data/databases/modelDB.sqlite", "./data/sbml/NotchPathway_ginsim_multiValued.sbml", use_species_name_attribute=False) # The notch Pathway model does not have Species name Attributes set, as such running the tool with this line will fail and throw an exception. #writeSBMLToDBModel("./data/databases/modelDB.sqlite", "./data/sbml/NotchPathway_ginsim_multiValued.sbml", use_species_name_attribute=True) # read from last output file of the export function "writeDBModelToSBML" #writeSBMLToDBModel("./data/databases/modelDB2.sqlite", "./data/sbml/db2sbml_output.sbml")
def parse_SBML(cursor): sys.stderr.write("Parsing the SBML model file ... ") fname = '../data/thermodynamics/yeast_4.02.xml' if (not os.path.exists(fname)): sys.stderr.write("Please download the yeast SBML from http://www.comp-sys-bio.org/yeastnet/ and place in at: %s\n" % fname) sys.exit(-1) yeast_SBML = libsbml.readSBML(fname) yeast_model = yeast_SBML.getModel() cursor.execute("DROP TABLE IF EXISTS yeast_reaction") cursor.execute("CREATE TABLE yeast_reaction (reaction_id TEXT, name TEXT)") cursor.execute("DROP INDEX IF EXISTS yeast_reaction_idx") cursor.execute("CREATE UNIQUE INDEX yeast_reaction_idx ON yeast_reaction (reaction_id);") cursor.execute("DROP TABLE IF EXISTS yeast_reaction2species") cursor.execute("CREATE TABLE yeast_reaction2species (reaction_id TEXT, species_id TEXT, stoichiometry REAL)") cursor.execute("DROP INDEX IF EXISTS yeast_reaction2species_idx1") cursor.execute("CREATE INDEX yeast_reaction2species_idx1 ON yeast_reaction2species (reaction_id);") cursor.execute("DROP INDEX IF EXISTS yeast_reaction2species_idx2") cursor.execute("CREATE INDEX yeast_reaction2species_idx2 ON yeast_reaction2species (species_id);") for reaction in yeast_model.getListOfReactions(): cursor.execute("INSERT INTO yeast_reaction VALUES(?,?)", [reaction.getId(), reaction.getName()]) for sp_ref in reaction.getListOfReactants(): cursor.execute("INSERT INTO yeast_reaction2species VALUES(?,?,?)", \ [reaction.getId(), sp_ref.getSpecies(), -sp_ref.getStoichiometry()]) for sp_ref in reaction.getListOfProducts(): cursor.execute("INSERT INTO yeast_reaction2species VALUES(?,?,?)", \ [reaction.getId(), sp_ref.getSpecies(), sp_ref.getStoichiometry()]) cursor.execute("DROP TABLE IF EXISTS yeast_species") cursor.execute("CREATE TABLE yeast_species (species_id TEXT, name TEXT, compartment_id TEXT, species_type_id TEXT)") cursor.execute("DROP INDEX IF EXISTS yeast_species_idx") cursor.execute("CREATE UNIQUE INDEX yeast_species_idx ON yeast_species (species_id);") for species in yeast_model.getListOfSpecies(): cursor.execute("INSERT INTO yeast_species VALUES(?,?,?,?)", \ [species.getId(), species.getName(), species.getCompartment(), species.getSpeciesType()]) cursor.execute("DROP TABLE IF EXISTS yeast_species_type") cursor.execute("CREATE TABLE yeast_species_type (species_type_id TEXT, name TEXT, ann_name TEXT, ann_value TEXT)") cursor.execute("DROP INDEX IF EXISTS yeast_species_type_idx") cursor.execute("CREATE INDEX yeast_species_type_idx ON yeast_species_type (species_type_id);") cursor.execute("DROP TABLE IF EXISTS yeast_species_type2chebi") cursor.execute("CREATE TABLE yeast_species_type2chebi (species_type_id TEXT, chebi_id INT)") cursor.execute("DROP INDEX IF EXISTS yeast_species_type2chebi_idx1") cursor.execute("CREATE UNIQUE INDEX yeast_species_type2chebi_idx1 ON yeast_species_type2chebi (species_type_id);") cursor.execute("DROP INDEX IF EXISTS yeast_species_type2chebi_idx2") cursor.execute("CREATE INDEX yeast_species_type2chebi_idx2 ON yeast_species_type2chebi (chebi_id);") for type in yeast_model.getListOfSpeciesTypes(): for (name, value) in parse_MIRIAM_annotation(type.getAnnotation()): cursor.execute("INSERT INTO yeast_species_type VALUES(?,?,?,?)", \ [type.getId(), type.getName(), name, value]) if (name == 'obo.chebi'): for chebi_id in re.findall('CHEBI%3A(\d+)', value): cursor.execute("INSERT INTO yeast_species_type2chebi VALUES(?,?)", \ [type.getId(), chebi_id]) cursor.execute("DROP TABLE IF EXISTS yeast_compartment") cursor.execute("CREATE TABLE yeast_compartment (compartment_id TEXT, name TEXT)") cursor.execute("DROP INDEX IF EXISTS yeast_compartment_idx") cursor.execute("CREATE UNIQUE INDEX yeast_compartment_idx ON yeast_compartment (compartment_id);") for compartment in yeast_model.getListOfCompartments(): cursor.execute("INSERT INTO yeast_compartment VALUES(?,?)", \ [compartment.getId(), compartment.getName()]) sys.stderr.write("[DONE]\n")
def setUp(self): filename = "../../sbml/annotation/test/test-data/annotationL3.xml" self.d = libsbml.readSBML(filename) self.m = self.d.getModel() self.c = self.m.getCompartment(0) pass
def mooseReadSBML(filepath, loadpath, solver="ee"): global foundLibSBML_ if not foundLibSBML_: print('No python-libsbml found.' '\nThis module can be installed by following command in terminal:' '\n\t easy_install python-libsbml' '\n\t apt-get install python-libsbml' ) return None if not os.path.isfile(filepath): print('%s is not found ' % filepath) return None with open(filepath, "r") as filep: filep = open(filepath, "r") document = libsbml.readSBML(filepath) tobecontinue = False tobecontinue = validateModel(document) if tobecontinue: level = document.getLevel() version = document.getVersion() print(("\n" + "File: " + filepath + " (Level " + str(level) + ", version " + str(version) + ")")) model = document.getModel() if (model is None): print("No model present.") return moose.element('/') else: print((" model: " + str(model))) print(("functionDefinitions: " + str(model.getNumFunctionDefinitions()))) print((" unitDefinitions: " + str(model.getNumUnitDefinitions()))) print((" compartmentTypes: " + str(model.getNumCompartmentTypes()))) print((" specieTypes: " + str(model.getNumSpeciesTypes()))) print((" compartments: " + str(model.getNumCompartments()))) print((" species: " + str(model.getNumSpecies()))) print((" parameters: " + str(model.getNumParameters()))) print((" initialAssignments: " + str(model.getNumInitialAssignments()))) print((" rules: " + str(model.getNumRules()))) print((" constraints: " + str(model.getNumConstraints()))) print((" reactions: " + str(model.getNumReactions()))) print((" events: " + str(model.getNumEvents()))) print("\n") if (model.getNumCompartments() == 0): return moose.element('/') else: baseId = moose.Neutral(loadpath) basePath = baseId # All the model will be created under model as # a thumbrule basePath = moose.Neutral(baseId.path + '/model') # Map Compartment's SBML id as key and value is # list of[ Moose ID and SpatialDimensions ] global comptSbmlidMooseIdMap global warning warning = " " global msg msg = " " comptSbmlidMooseIdMap = {} #print(("modelPath:" + basePath.path)) globparameterIdValue = {} modelAnnotaInfo = {} mapParameter(model, globparameterIdValue) errorFlag = createCompartment( basePath, model, comptSbmlidMooseIdMap) if errorFlag: specInfoMap = {} errorFlag,warning = createSpecies( basePath, model, comptSbmlidMooseIdMap, specInfoMap, modelAnnotaInfo) #print(errorFlag,warning) if errorFlag: errorFlag = createRules( model, specInfoMap, globparameterIdValue) if errorFlag: errorFlag, msg = createReaction( model, specInfoMap, modelAnnotaInfo, globparameterIdValue) getModelAnnotation( model, baseId, basePath) if not errorFlag: print(msg) # Any time in the middle if SBML does not read then I # delete everything from model level This is important # as while reading in GUI the model will show up untill # built which is not correct print "Deleted rest of the # model" moose.delete(basePath) basePath = moose.Shell('/') return basePath else: print("Validation failed while reading the model.") return moose.element('/')
def get_substr_term(s): term = self._get_substrate_term(s) term = term[:term.rfind(')') + 1] term = 'sqrt(%s)' % term return term text = ' * '.join([get_substr_term(s) for s in misc.get_participants(reaction)]) return '(%s)' % text class KineticizerRP(Kineticizer): ''' mass action implementation ''' _kinetic_law_sbo = 531 def _get_denominator(self, reaction, mode): return '(1)' if __name__ == '__main__': d = libsbml.readSBML(sys.argv[1]) m = d.getModel() sbtab = libSBtab.Table.KineticDataTable() sbtab.fromTSVFile(sys.argv[2]) KineticizerRP(m, sbtab, mode='cat') print('<?xml version="1.0" encoding="UTF-8"?>\n' + d.toSBML())
def write_left_nullspace_to_file(M, filepath, species_names): # pass rownames of corresponding S as species_names M_df = pd.DataFrame([[round(x, 4) for x in line] for line in M], columns=species_names) with open(filepath, "w") as outfile: outfile.write(M_df.to_csv(sep="\t")) def write_eigenvalues_to_file(model, filepath, species_names): M_df = pd.DataFrame([model.getFullEigenValues()], columns=species_names) with open(filepath, "w") as outfile: outfile.write(M_df.to_csv(sep="\t")) # We start with the smallest subsystem: Amino Sugar and Nucleotide Sugar Metabolism asansm_libsbml_doc = libsbml.readSBML(asansm_sbml) asansm_libsbml = asansm_libsbml_doc.getModel() asansm_model = te.loadSBMLModel(asansm_sbml) S_asansm = asansm_model.getFullStoichiometryMatrix() S_asansm.colnames = get_reaction_names(asansm_libsbml.getListOfReactions(), S_asansm.colnames) S_asansm.rownames = get_metabolite_names(asansm_libsbml.getListOfSpecies(), S_asansm.rownames) asansm_right_nullspace = Matrix(S_asansm).nullspace() asansm_left_nullspace = Matrix(S_asansm.T).nullspace() asansm_rank = Matrix(S_asansm).rank() # Next subsystem: Pyrimidine Metabolism # This one is a little special because Matrix().nullspace computes an empty right nullspace here, but there is one! # So we do it the pedestrian way... pm_libsbml_doc = libsbml.readSBML(pm_sbml) pm_libsbml = pm_libsbml_doc.getModel() pm_model = te.loadSBMLModel(pm_sbml)
def setUp(self): filename = "../../sbml/annotation/test/test-data/annotation.xml" self.d = libsbml.readSBML(filename) self.m = self.d.getModel() pass
def convert(filename, modelName = None, gillespy_model=None): try: import libsbml except ImportError: raise ImportError('libsbml is required to convert SBML files for GillesPy.') document = libsbml.readSBML(filename) errors = [] errorCount = document.getNumErrors() if errorCount > 0: for i in range(errorCount): error = document.getError(i) converterCode = 0 converterCode = -10 errors.append(["SBML {0}, code {1}, line {2}: {3}".format(error.getSeverityAsString(), error.getErrorId(), error.getLine(), error.getMessage()), converterCode]) if min([code for error, code in errors] + [0]) < 0: return None, errors model = document.getModel() numOfTabs = 0 if modelName == None: modelName = model.getName() if gillespy_model==None: gillespy_model = gillespy.Model(name = modelName) gillespy_model.units = "concentration" for i in range(model.getNumSpecies()): species = model.getSpecies(i) if species.getId() == 'EmptySet': errors.append(["EmptySet species detected in model on line {0}. EmptySet is not an explicit species in gillespy".format(species.getLine()), 0]) continue name = species.getId() if species.isSetInitialAmount(): value = species.getInitialAmount() elif species.isSetInitialConcentration(): value = species.getInitialConcentration() else: rule = model.getRule(species.getId()) if rule: msg = "" if rule.isAssignment(): msg = "assignment " elif rule.isRate(): msg = "rate " elif rule.isAlgebraic(): msg = "algebraic " msg += "rule" errors.append(["Species '{0}' does not have any initial conditions. Associated {1} '{2}' found, but {1}s are not supported in gillespy. Assuming initial condition 0".format(species.getId(), msg, rule.getId()), 0]) else: errors.append(["Species '{0}' does not have any initial conditions or rules. Assuming initial condition 0".format(species.getId()), 0]) value = 0 if value < 0.0: errors.append(["Species '{0}' has negative initial condition ({1}). gillespy does not support negative initial conditions. Assuming initial condition 0".format(species.getId(), value), -5]) value = 0 gillespySpecies = gillespy.Species(name = name, initial_value = value) gillespy_model.add_species([gillespySpecies]) for i in range(model.getNumParameters()): parameter=model.getParameter(i) name=parameter.getId() value=parameter.getValue() gillespyParameter = gillespy.Parameter(name = name, expression = value) gillespy_model.add_parameter([gillespyParameter]) for i in range(model.getNumCompartments()): compartment=model.getCompartment(i) name=compartment.getId() value=compartment.getSize() gillespyParameter = gillespy.Parameter(name = name, expression = value) gillespy_model.add_parameter([gillespyParameter]) #local parameters for i in range(model.getNumReactions()): reaction = model.getReaction(i) kineticLaw = reaction.getKineticLaw() for j in range(kineticLaw.getNumParameters()): parameter = kineticLaw.getParameter(j) name = parameter.getId() value = parameter.getValue() gillespyParameter = gillespy.Parameter(name = name, expression = value) gillespy_model.add_parameter([gillespyParameter]) #reactions for i in range(model.getNumReactions()): reaction = model.getReaction(i) name = reaction.getId() reactants = {} products = {} for j in range(reaction.getNumReactants()): species = reaction.getReactant(j) if species.getSpecies() == "EmptySet": errors.append(["EmptySet species detected as reactant in reaction '{0}' on line {1}. EmptySet is not an explicit species in gillespy".format(reaction.getId(), species.getLine()), 0]) else: reactants[species.getSpecies()] = species.getStoichiometry() #get products for j in range(reaction.getNumProducts()): species=reaction.getProduct(j) if species.getSpecies() == "EmptySet": errors.append(["EmptySet species detected as product in reaction '{0}' on line {1}. EmptySet is not an explicit species in gillespy".format(reaction.getId(), species.getLine()), 0]) else: products[species.getSpecies()] = species.getStoichiometry() #propensity kineticLaw = reaction.getKineticLaw() propensity = kineticLaw.getFormula() gillespyReaction = gillespy.Reaction(name = name, reactants = reactants, products = products, propensity_function = propensity) gillespy_model.add_reaction([gillespyReaction]) for i in range(model.getNumRules()): rule = model.getRule(i) t = [] if rule.isCompartmentVolume(): t.append('compartment') if rule.isParameter(): t.append('parameter') elif rule.isAssignment(): t.append('assignment') elif rule.isRate(): t.append('rate') elif rule.isAlgebraic(): t.append('algebraic') if len(t) > 0: t[0] = t[0].capitalize() msg = ", ".join(t) msg += " rule" else: msg = "Rule" errors.append(["{0} '{1}' found on line '{2}' with equation '{3}'. gillespy does not support SBML Rules".format(msg, rule.getId(), rule.getLine(), libsbml.formulaToString(rule.getMath())), -5]) for i in range(model.getNumCompartments()): compartment = model.getCompartment(i) errors.append(["Compartment '{0}' found on line '{1}' with volume '{2}' and dimension '{3}'. gillespy assumes a single well-mixed, reaction volume".format(compartment.getId(), compartment.getLine(), compartment.getVolume(), compartment.getSpatialDimensions()), -5]) for i in range(model.getNumConstraints()): constraint = model.getConstraint(i) errors.append(["Constraint '{0}' found on line '{1}' with equation '{2}'. gillespy does not support SBML Constraints".format(constraint.getId(), constraint.getLine(), libsbml.formulaToString(constraint.getMath())), -5]) for i in range(model.getNumEvents()): event = model.getEvent(i) errors.append(["Event '{0}' found on line '{1}' with trigger equation '{2}'. gillespy does not support SBML Events".format(event.getId(), event.getLine(), libsbml.formulaToString(event.getTrigger().getMath())), -5]) for i in range(model.getNumFunctionDefinitions()): function = model.getFunctionDefinition(i) errors.append(["Function '{0}' found on line '{1}' with equation '{2}'. gillespy does not support SBML Function Definitions".format(function.getId(), function.getLine(), libsbml.formulaToString(function.getMath())), -5]) return gillespy_model, errors
def mooseReadSBML(filepath,loadpath,solver="ee"): try: filep = open(filepath, "r") document = libsbml.readSBML(filepath) num_errors = document.getNumErrors() if ( num_errors > 0 ): print("Encountered the following SBML errors:" ); document.printErrors(); return moose.element('/'); else: level = document.getLevel(); version = document.getVersion(); print(("\n" + "File: " + filepath + " (Level " + str(level) + ", version " + str(version) + ")" )); model = document.getModel(); if (model == None): print("No model present." ); return moose.element('/'); else: print((" model: " +str(model))); print(("functionDefinitions: " + str(model.getNumFunctionDefinitions()) )); print((" unitDefinitions: " + str(model.getNumUnitDefinitions()) )); print((" compartmentTypes: " + str(model.getNumCompartmentTypes()) )); print((" specieTypes: " + str(model.getNumSpeciesTypes()) )); print((" compartments: " + str(model.getNumCompartments()) )); print((" species: " + str(model.getNumSpecies()) )); print((" parameters: " + str(model.getNumParameters()) )); print((" initialAssignments: " + str(model.getNumInitialAssignments()) )); print((" rules: " + str(model.getNumRules()) )); print((" constraints: " + str(model.getNumConstraints()) )); print((" reactions: " + str(model.getNumReactions()) )); print((" events: " + str(model.getNumEvents()) )); print("\n"); if (model.getNumCompartments() == 0): return moose.element('/') else: baseId = moose.Neutral(loadpath) #All the model will be created under model as a thumbrule basePath = moose.Neutral(baseId.path+'/model') #Map Compartment's SBML id as key and value is list of[ Moose ID and SpatialDimensions ] global comptSbmlidMooseIdMap global warning warning = " " comptSbmlidMooseIdMap = {} print(("modelPath:" + basePath.path)) globparameterIdValue = {} modelAnnotaInfo = {} mapParameter(model,globparameterIdValue) errorFlag = createCompartment(basePath,model,comptSbmlidMooseIdMap) if errorFlag: specInfoMap = {} errorFlag = createSpecies(basePath,model,comptSbmlidMooseIdMap,specInfoMap,modelAnnotaInfo) if errorFlag: errorFlag = createRules(model,specInfoMap,globparameterIdValue) if errorFlag: errorFlag,msg = createReaction(model,specInfoMap,modelAnnotaInfo,globparameterIdValue) getModelAnnotation(model,baseId,basePath) if not errorFlag: print(msg) #Any time in the middle if SBML does not read then I delete everything from model level #This is important as while reading in GUI the model will show up untill built which is not correct #print "Deleted rest of the model" moose.delete(basePath) return baseId; except IOError: print("File " ,filepath ," does not exist.") return moose.element('/')
def test_read_l1v1_rules(self): filename = "../../sbml/test/test-data/l1v1-rules.xml" d = libsbml.readSBML(filename) if (d == None): pass self.assert_( d.getLevel() == 1 ) self.assert_( d.getVersion() == 1 ) m = d.getModel() self.assert_( m.getNumCompartments() == 1 ) c = m.getCompartment(0) self.assert_(( "cell" == c.getName() )) self.assert_( c.getVolume() == 1 ) self.assert_( m.getNumSpecies() == 6 ) s = m.getSpecies(0) self.assert_(( "s1" == s.getName() )) self.assert_(( "cell" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 4 ) self.assert_( s.getBoundaryCondition() == False ) s = m.getSpecies(1) self.assert_(( "s2" == s.getName() )) self.assert_(( "cell" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 2 ) self.assert_( s.getBoundaryCondition() == False ) s = m.getSpecies(2) self.assert_(( "x0" == s.getName() )) self.assert_(( "cell" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 1 ) self.assert_( s.getBoundaryCondition() == False ) s = m.getSpecies(3) self.assert_(( "x1" == s.getName() )) self.assert_(( "cell" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 0 ) self.assert_( s.getBoundaryCondition() == False ) s = m.getSpecies(4) self.assert_(( "x2" == s.getName() )) self.assert_(( "cell" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 1 ) self.assert_( s.getBoundaryCondition() == False ) s = m.getSpecies(5) self.assert_(( "x3" == s.getName() )) self.assert_(( "cell" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 0 ) self.assert_( s.getBoundaryCondition() == False ) self.assert_( m.getNumParameters() == 7 ) p = m.getParameter(0) self.assert_(( "k1" == p.getName() )) self.assert_( p.getValue() == 1.2 ) p = m.getParameter(1) self.assert_(( "k2" == p.getName() )) self.assert_( p.getValue() == 1000 ) p = m.getParameter(2) self.assert_(( "k3" == p.getName() )) self.assert_( p.getValue() == 3000 ) p = m.getParameter(3) self.assert_(( "k4" == p.getName() )) self.assert_( p.getValue() == 4.5 ) self.assert_( m.getNumRules() == 4 ) pr = m.getRule(0) self.assert_(( "t" == pr.getVariable() )) self.assert_(( "s1 + s2" == pr.getFormula() )) ud = pr.getDerivedUnitDefinition() self.assert_( ud.getNumUnits() == 2 ) self.assert_( ud.getUnit(0).getKind() == libsbml.UNIT_KIND_MOLE ) self.assert_( ud.getUnit(0).getExponent() == 1 ) self.assert_( ud.getUnit(1).getKind() == libsbml.UNIT_KIND_LITRE ) self.assert_( ud.getUnit(1).getExponent() == -1 ) self.assert_( pr.containsUndeclaredUnits() == False ) pr = m.getRule(1) self.assert_(( "k" == pr.getVariable() )) self.assert_(( "k3/k2" == pr.getFormula() )) ud = pr.getDerivedUnitDefinition() self.assert_( ud.getNumUnits() == 0 ) self.assert_( pr.containsUndeclaredUnits() == True ) scr = m.getRule(2) self.assert_(( "x2" == scr.getVariable() )) self.assert_(( "k * (s1+s2)/(1 + k)" == scr.getFormula() )) scr = m.getRule(3) self.assert_(( "x3" == scr.getVariable() )) self.assert_(( "p*(t - s2)" == scr.getFormula() )) self.assert_( m.getNumReactions() == 2 ) r = m.getReaction(0) self.assert_(( "j1" == r.getName() )) self.assert_( r.getReversible() != False ) self.assert_( r.getFast() == False ) r = m.getReaction(1) self.assert_(( "j3" == r.getName() )) self.assert_( r.getReversible() != False ) self.assert_( r.getFast() == False ) r = m.getReaction(0) self.assert_( r.getNumReactants() == 1 ) self.assert_( r.getNumProducts() == 1 ) sr = r.getReactant(0) self.assert_(( "x0" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) sr = r.getProduct(0) self.assert_(( "s1" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) kl = r.getKineticLaw() self.assert_(( "k1 * x0" == kl.getFormula() )) r = m.getReaction(1) self.assert_( r.getNumReactants() == 1 ) self.assert_( r.getNumProducts() == 1 ) sr = r.getReactant(0) self.assert_(( "s2" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) sr = r.getProduct(0) self.assert_(( "x1" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) kl = r.getKineticLaw() self.assert_(( "k4 * s2" == kl.getFormula() )) _dummyList = [ d ]; _dummyList[:] = []; del _dummyList pass
def create_cobra_model_from_sbml_file(sbml_filename, old_sbml=False, legacy_metabolite=False, print_time=False, use_hyphens=False): """convert an SBML XML file into a cobra.Model object. Supports SBML Level 2 Versions 1 and 4. The function will detect if the SBML fbc package is used in the file and run the converter if the fbc package is used. sbml_filename: String. old_sbml: Boolean. Set to True if the XML file has metabolite formula appended to metabolite names. This was a poorly designed artifact that persists in some models. legacy_metabolite: Boolean. If True then assume that the metabolite id has the compartment id appended after an underscore (e.g. _c for cytosol). This has not been implemented but will be soon. print_time: deprecated use_hyphens: Boolean. If True, double underscores (__) in an SBML ID will be converted to hyphens """ __default_lower_bound = -1000 __default_upper_bound = 1000 __default_objective_coefficient = 0 # Ensure that the file exists if not isfile(sbml_filename): raise IOError('Your SBML file is not found: %s'%sbml_filename) #Expressions to change SBML Ids to Palsson Lab Ids metabolite_re = re.compile('^M_') reaction_re = re.compile('^R_') compartment_re = re.compile('^C_') if print_time: warn("print_time is deprecated") model_doc = readSBML(sbml_filename) if (model_doc.getPlugin("fbc") != None): from libsbml import ConversionProperties, LIBSBML_OPERATION_SUCCESS conversion_properties = ConversionProperties() conversion_properties.addOption("convert fbc to cobra", True, "Convert FBC model to Cobra model") result = model_doc.convert(conversion_properties) if result != LIBSBML_OPERATION_SUCCESS: raise(Exception("Conversion of SBML+fbc to COBRA failed")) sbml_model = model_doc.getModel() sbml_model_id = sbml_model.getId() sbml_species = sbml_model.getListOfSpecies() sbml_reactions = sbml_model.getListOfReactions() sbml_compartments = sbml_model.getListOfCompartments() compartment_dict = dict([(compartment_re.split(x.getId())[-1], x.getName()) for x in sbml_compartments]) if legacy_metabolite: #Deal with the palsson lab appending the compartment id to the metabolite id new_dict = {} for the_id, the_name in compartment_dict.items(): if the_name == '': new_dict[the_id[0].lower()] = the_id else: new_dict[the_id] = the_name compartment_dict = new_dict legacy_compartment_converter = dict([(v,k) for k, v in compartment_dict.items()]) cobra_model = Model(sbml_model_id) metabolites = [] metabolite_dict = {} #Convert sbml_metabolites to cobra.Metabolites for sbml_metabolite in sbml_species: #Skip sbml boundary species if sbml_metabolite.getBoundaryCondition(): continue if (old_sbml or legacy_metabolite) and \ sbml_metabolite.getId().endswith('_b'): #Deal with incorrect sbml from bigg.ucsd.edu continue tmp_metabolite = Metabolite() metabolite_id = tmp_metabolite.id = sbml_metabolite.getId() tmp_metabolite.compartment = compartment_re.split(sbml_metabolite.getCompartment())[-1] if legacy_metabolite: if tmp_metabolite.compartment not in compartment_dict: tmp_metabolite.compartment = legacy_compartment_converter[tmp_metabolite.compartment] tmp_metabolite.id = parse_legacy_id(tmp_metabolite.id, tmp_metabolite.compartment, use_hyphens=use_hyphens) if use_hyphens: tmp_metabolite.id = metabolite_re.split(tmp_metabolite.id)[-1].replace('__','-') else: #Just in case the SBML ids are ill-formed and use - tmp_metabolite.id = metabolite_re.split(tmp_metabolite.id)[-1].replace('-','__') tmp_metabolite.name = sbml_metabolite.getName() tmp_formula = '' tmp_metabolite.notes = parse_legacy_sbml_notes(sbml_metabolite.getNotesString()) if sbml_metabolite.isSetCharge(): tmp_metabolite.charge = sbml_metabolite.getCharge() if "CHARGE" in tmp_metabolite.notes: note_charge = tmp_metabolite.notes["CHARGE"][0] try: note_charge = float(note_charge) if note_charge == int(note_charge): note_charge = int(note_charge) except: warn("charge of %s is not a number (%s)" % (tmp_metabolite.id, str(note_charge))) else: if tmp_metabolite.charge is None or tmp_metabolite.charge == note_charge: tmp_metabolite.notes.pop("CHARGE") else: # tmp_metabolite.charge != note_charge msg = "different charges specified for %s (%d and %d)" msg = msg % (tmp_metabolite.id, tmp_metabolite.charge, note_charge) warn(msg) # Chances are a 0 note charge was written by mistake. We # will default to the note_charge in this case. if tmp_metabolite.charge == 0: tmp_metabolite.charge = note_charge for the_key in tmp_metabolite.notes.keys(): if the_key.lower() == 'formula': tmp_formula = tmp_metabolite.notes.pop(the_key)[0] break if tmp_formula == '' and old_sbml: tmp_formula = tmp_metabolite.name.split('_')[-1] tmp_metabolite.name = tmp_metabolite.name[:-len(tmp_formula)-1] tmp_metabolite.formula = tmp_formula metabolite_dict.update({metabolite_id: tmp_metabolite}) metabolites.append(tmp_metabolite) cobra_model.add_metabolites(metabolites) #Construct the vectors and matrices for holding connectivity and numerical info #to feed to the cobra toolbox. #Always assume steady state simulations so b is set to 0 cobra_reaction_list = [] for sbml_reaction in sbml_reactions: if use_hyphens: #Change the ids to match conventions used by the Palsson lab. reaction = Reaction(reaction_re.split(sbml_reaction.getId())[-1].replace('__','-')) else: #Just in case the SBML ids are ill-formed and use - reaction = Reaction(reaction_re.split(sbml_reaction.getId())[-1].replace('-','__')) cobra_reaction_list.append(reaction) #reaction.exchange_reaction = 0 reaction.name = sbml_reaction.getName() cobra_metabolites = {} #Use the cobra.Metabolite class here for sbml_metabolite in sbml_reaction.getListOfReactants(): tmp_metabolite_id = sbml_metabolite.getSpecies() #This deals with boundary metabolites if tmp_metabolite_id in metabolite_dict: tmp_metabolite = metabolite_dict[tmp_metabolite_id] cobra_metabolites[tmp_metabolite] = -sbml_metabolite.getStoichiometry() for sbml_metabolite in sbml_reaction.getListOfProducts(): tmp_metabolite_id = sbml_metabolite.getSpecies() #This deals with boundary metabolites if tmp_metabolite_id in metabolite_dict: tmp_metabolite = metabolite_dict[tmp_metabolite_id] # Handle the case where the metabolite was specified both # as a reactant and as a product. if tmp_metabolite in cobra_metabolites: warn("%s appears as a reactant and product %s" % (tmp_metabolite_id, reaction.id)) cobra_metabolites[tmp_metabolite] += sbml_metabolite.getStoichiometry() # if the combined stoichiometry is 0, remove the metabolite if cobra_metabolites[tmp_metabolite] == 0: cobra_metabolites.pop(tmp_metabolite) else: cobra_metabolites[tmp_metabolite] = sbml_metabolite.getStoichiometry() # check for nan for met, v in iteritems(cobra_metabolites): if isnan(v) or isinf(v): warn("invalid value %s for metabolite '%s' in reaction '%s'" % (str(v), met.id, reaction.id)) reaction.add_metabolites(cobra_metabolites) #Parse the kinetic law info here. parameter_dict = {} #If lower and upper bounds are specified in the Kinetic Law then #they override the sbml reversible attribute. If they are not #specified then the bounds are determined by getReversible. if not sbml_reaction.getKineticLaw(): if sbml_reaction.getReversible(): parameter_dict['lower_bound'] = __default_lower_bound parameter_dict['upper_bound'] = __default_upper_bound else: #Assume that irreversible reactions only proceed from left to right. parameter_dict['lower_bound'] = 0 parameter_dict['upper_bound'] = __default_upper_bound parameter_dict['objective_coefficient'] = __default_objective_coefficient else: for sbml_parameter in sbml_reaction.getKineticLaw().getListOfParameters(): parameter_dict[sbml_parameter.getId().lower()] = sbml_parameter.getValue() if 'lower_bound' in parameter_dict: reaction.lower_bound = parameter_dict['lower_bound'] elif 'lower bound' in parameter_dict: reaction.lower_bound = parameter_dict['lower bound'] elif sbml_reaction.getReversible(): reaction.lower_bound = __default_lower_bound else: reaction.lower_bound = 0 if 'upper_bound' in parameter_dict: reaction.upper_bound = parameter_dict['upper_bound'] elif 'upper bound' in parameter_dict: reaction.upper_bound = parameter_dict['upper bound'] else: reaction.upper_bound = __default_upper_bound if 'objective_coefficient' in parameter_dict: reaction.objective_coefficient = parameter_dict['objective_coefficient'] elif 'objective coefficient' in parameter_dict: reaction.objective_coefficient = parameter_dict['objective coefficient'] else: reaction.objective_coefficient = __default_objective_coefficient # ensure values are not set to nan or inf if isnan(reaction.lower_bound) or isinf(reaction.lower_bound): reaction.lower_bound = __default_lower_bound if isnan(reaction.upper_bound) or isinf(reaction.upper_bound): reaction.upper_bound = __default_upper_bound reaction_note_dict = parse_legacy_sbml_notes(sbml_reaction.getNotesString()) #Parse the reaction notes. #POTENTIAL BUG: DEALING WITH LEGACY 'SBML' THAT IS NOT IN A #STANDARD FORMAT #TODO: READ IN OTHER NOTES AND GIVE THEM A reaction_ prefix. #TODO: Make sure genes get added as objects if 'GENE ASSOCIATION' in reaction_note_dict: rule = reaction_note_dict['GENE ASSOCIATION'][0] try: rule.encode('ascii') except (UnicodeEncodeError, UnicodeDecodeError): warn("gene_reaction_rule '%s' is not ascii compliant" % rule) if rule.startswith(""") and rule.endswith("""): rule = rule[6:-6] reaction.gene_reaction_rule = rule if 'GENE LIST' in reaction_note_dict: reaction.systematic_names = reaction_note_dict['GENE LIST'][0] elif 'GENES' in reaction_note_dict and \ reaction_note_dict['GENES'] != ['']: reaction.systematic_names = reaction_note_dict['GENES'][0] elif 'LOCUS' in reaction_note_dict: gene_id_to_object = dict([(x.id, x) for x in reaction._genes]) for the_row in reaction_note_dict['LOCUS']: tmp_row_dict = {} the_row = 'LOCUS:' + the_row.lstrip('_').rstrip('#') for the_item in the_row.split('#'): k, v = the_item.split(':') tmp_row_dict[k] = v tmp_locus_id = tmp_row_dict['LOCUS'] if 'TRANSCRIPT' in tmp_row_dict: tmp_locus_id = tmp_locus_id + '.' + tmp_row_dict['TRANSCRIPT'] if 'ABBREVIATION' in tmp_row_dict: gene_id_to_object[tmp_locus_id].name = tmp_row_dict['ABBREVIATION'] if 'SUBSYSTEM' in reaction_note_dict: reaction.subsystem = reaction_note_dict.pop('SUBSYSTEM')[0] reaction.notes = reaction_note_dict #Now, add all of the reactions to the model. cobra_model.id = sbml_model.getId() #Populate the compartment list - This will be done based on cobra.Metabolites #in cobra.Reactions in the future. cobra_model.compartments = compartment_dict cobra_model.add_reactions(cobra_reaction_list) #cobra_model.update_rules() return cobra_model
def test_read_l1v1_branch(self): filename = "../../sbml/test/test-data/l1v1-branch.xml" d = libsbml.readSBML(filename) if (d == None): pass self.assert_( d.getLevel() == 1 ) self.assert_( d.getVersion() == 1 ) m = d.getModel() self.assert_(( "Branch" == m.getName() )) self.assert_( m.getNumCompartments() == 1 ) c = m.getCompartment(0) self.assert_(( "compartmentOne" == c.getName() )) self.assert_( c.getVolume() == 1 ) ud = c.getDerivedUnitDefinition() self.assert_( ud.getNumUnits() == 1 ) self.assert_( ud.getUnit(0).getKind() == libsbml.UNIT_KIND_LITRE ) self.assert_( m.getNumSpecies() == 4 ) s = m.getSpecies(0) self.assert_(( "S1" == s.getName() )) self.assert_(( "compartmentOne" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 0 ) self.assert_( s.getBoundaryCondition() == False ) ud = s.getDerivedUnitDefinition() self.assert_( ud.getNumUnits() == 2 ) self.assert_( ud.getUnit(0).getKind() == libsbml.UNIT_KIND_MOLE ) self.assert_( ud.getUnit(0).getExponent() == 1 ) self.assert_( ud.getUnit(1).getKind() == libsbml.UNIT_KIND_LITRE ) self.assert_( ud.getUnit(1).getExponent() == -1 ) s = m.getSpecies(1) self.assert_(( "X0" == s.getName() )) self.assert_(( "compartmentOne" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 0 ) self.assert_( s.getBoundaryCondition() == True ) s = m.getSpecies(2) self.assert_(( "X1" == s.getName() )) self.assert_(( "compartmentOne" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 0 ) self.assert_( s.getBoundaryCondition() == True ) s = m.getSpecies(3) self.assert_(( "X2" == s.getName() )) self.assert_(( "compartmentOne" == s.getCompartment() )) self.assert_( s.getInitialAmount() == 0 ) self.assert_( s.getBoundaryCondition() == True ) self.assert_( m.getNumReactions() == 3 ) r = m.getReaction(0) self.assert_(( "reaction_1" == r.getName() )) self.assert_( r.getReversible() == False ) self.assert_( r.getFast() == False ) ud = r.getKineticLaw().getDerivedUnitDefinition() self.assert_( ud.getNumUnits() == 2 ) self.assert_( ud.getUnit(0).getKind() == libsbml.UNIT_KIND_MOLE ) self.assert_( ud.getUnit(0).getExponent() == 1 ) self.assert_( ud.getUnit(1).getKind() == libsbml.UNIT_KIND_LITRE ) self.assert_( ud.getUnit(1).getExponent() == -1 ) self.assert_( r.getKineticLaw().containsUndeclaredUnits() == True ) r = m.getReaction(1) self.assert_(( "reaction_2" == r.getName() )) self.assert_( r.getReversible() == False ) self.assert_( r.getFast() == False ) r = m.getReaction(2) self.assert_(( "reaction_3" == r.getName() )) self.assert_( r.getReversible() == False ) self.assert_( r.getFast() == False ) r = m.getReaction(0) self.assert_( r.getNumReactants() == 1 ) self.assert_( r.getNumProducts() == 1 ) sr = r.getReactant(0) self.assert_(( "X0" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) sr = r.getProduct(0) self.assert_(( "S1" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) kl = r.getKineticLaw() self.assert_(( "k1 * X0" == kl.getFormula() )) self.assert_( kl.getNumParameters() == 1 ) p = kl.getParameter(0) self.assert_(( "k1" == p.getName() )) self.assert_( p.getValue() == 0 ) r = m.getReaction(1) self.assert_( r.getNumReactants() == 1 ) self.assert_( r.getNumProducts() == 1 ) sr = r.getReactant(0) self.assert_(( "S1" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) sr = r.getProduct(0) self.assert_(( "X1" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) kl = r.getKineticLaw() self.assert_(( "k2 * S1" == kl.getFormula() )) self.assert_( kl.getNumParameters() == 1 ) p = kl.getParameter(0) self.assert_(( "k2" == p.getName() )) self.assert_( p.getValue() == 0 ) r = m.getReaction(2) self.assert_( r.getNumReactants() == 1 ) self.assert_( r.getNumProducts() == 1 ) sr = r.getReactant(0) self.assert_(( "S1" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) sr = r.getProduct(0) self.assert_(( "X2" == sr.getSpecies() )) self.assert_( sr.getStoichiometry() == 1 ) self.assert_( sr.getDenominator() == 1 ) kl = r.getKineticLaw() self.assert_(( "k3 * S1" == kl.getFormula() )) self.assert_( kl.getNumParameters() == 1 ) p = kl.getParameter(0) self.assert_(( "k3" == p.getName() )) self.assert_( p.getValue() == 0 ) _dummyList = [ d ]; _dummyList[:] = []; del _dummyList pass
def create_cobra_model_from_sbml_file(sbml_filename, old_sbml=False, legacy_metabolite=False, print_time=False, use_hyphens=False): """convert an SBML XML file into a cobra.Model object. Supports SBML Level 2 Versions 1 and 4 sbml_filename: String. old_sbml: Boolean. Set to True if the XML file has metabolite formula appended to metabolite names. This was a poorly designed artifact that persists in some models. legacy_metabolite: Boolean. If True then assume that the metabolite id has the compartment id appended after an underscore (e.g. _c for cytosol). This has not been implemented but will be soon. print_time: Boolean. Print the time requirements for different sections use_hyphens: Boolean. If True, double underscores (__) in an SBML ID will be converted to hyphens """ # Ensure that the file exists if not isfile(sbml_filename): raise IOError('Your SBML file is not found: %s'%sbml_filename) #Expressions to change SBML Ids to Palsson Lab Ids metabolite_re = re.compile('^M_') reaction_re = re.compile('^R_') compartment_re = re.compile('^C_') if print_time: start_time = time() model_doc = readSBML(sbml_filename) if print_time: print 'Loading %s took %1.2f seconds'%(sbml_filename, time()-start_time) sbml_model = model_doc.getModel() sbml_model_id = sbml_model.getId() sbml_species = sbml_model.getListOfSpecies() sbml_reactions = sbml_model.getListOfReactions() sbml_compartments = sbml_model.getListOfCompartments() compartment_dict = dict([(compartment_re.split(x.getId())[-1], x.getName()) for x in sbml_compartments]) if legacy_metabolite: #Deal with the palsson lab appending the compartment id to the metabolite id new_dict = {} for the_id, the_name in compartment_dict.items(): if the_name == '': new_dict[the_id[0].lower()] = the_id else: new_dict[the_id] = the_name compartment_dict = new_dict legacy_compartment_converter = dict([(v,k) for k, v in compartment_dict.items()]) if print_time: start_time = time() metabolite_dict = {} #Convert sbml_metabolites to cobra.Metabolites for sbml_metabolite in sbml_species: #Skip sbml boundary species if sbml_metabolite.getBoundaryCondition(): continue if (old_sbml or legacy_metabolite) and \ sbml_metabolite.getId().endswith('_b'): #Deal with incorrect sbml from bigg.ucsd.edu continue tmp_metabolite = Metabolite() metabolite_id = tmp_metabolite.id = sbml_metabolite.getId() tmp_metabolite.compartment = compartment_re.split(sbml_metabolite.getCompartment())[-1] if legacy_metabolite: if tmp_metabolite.compartment not in compartment_dict: tmp_metabolite.compartment = legacy_compartment_converter[tmp_metabolite.compartment] tmp_metabolite.id = parse_legacy_id(tmp_metabolite.id, tmp_metabolite.compartment, use_hyphens=use_hyphens) if use_hyphens: tmp_metabolite.id = metabolite_re.split(tmp_metabolite.id)[-1].replace('__','-') else: #Just in case the SBML ids are ill-formed and use - tmp_metabolite.id = metabolite_re.split(tmp_metabolite.id)[-1].replace('-','__') tmp_metabolite.name = sbml_metabolite.getName() tmp_formula = '' tmp_metabolite.charge = sbml_metabolite.getCharge() tmp_metabolite.notes = parse_legacy_sbml_notes(sbml_metabolite.getNotesString()) for the_key in tmp_metabolite.notes.keys(): if the_key.lower() == 'formula': tmp_formula = tmp_metabolite.notes.pop(the_key)[0] break if tmp_formula == '' and old_sbml: tmp_formula = tmp_metabolite.name.split('_')[-1] tmp_metabolite.name = tmp_metabolite.name[:-len(tmp_formula)-1] tmp_metabolite.formula = Formula(tmp_formula) metabolite_dict.update({metabolite_id: tmp_metabolite}) if print_time: print 'Parsing %s took %1.2f seconds'%('metabolites', time()-start_time) if print_time: start_time = time() #Construct the vectors and matrices for holding connectivity and numerical info #to feed to the cobra toolbox. #Always assume steady state simulations so b is set to 0 cobra_reaction_list = [] for sbml_reaction in sbml_reactions: if use_hyphens: #Change the ids to match conventions used by the Palsson lab. reaction = Reaction(reaction_re.split(sbml_reaction.getId())[-1].replace('__','-')) else: #Just in case the SBML ids are ill-formed and use - reaction = Reaction(reaction_re.split(sbml_reaction.getId())[-1].replace('-','__')) cobra_reaction_list.append(reaction) reaction.exchange_reaction = 0 reaction.name = sbml_reaction.getName() cobra_metabolites = {} #Use the cobra.Metabolite class here for sbml_metabolite in sbml_reaction.getListOfReactants(): tmp_metabolite_id = sbml_metabolite.getSpecies() #This deals with boundary metabolites if tmp_metabolite_id in metabolite_dict: tmp_metabolite = deepcopy(metabolite_dict[tmp_metabolite_id]) cobra_metabolites[tmp_metabolite] = -sbml_metabolite.getStoichiometry() else: reaction.boundary = 'system_boundary' for sbml_metabolite in sbml_reaction.getListOfProducts(): tmp_metabolite_id = sbml_metabolite.getSpecies() #This deals with boundary metabolites if tmp_metabolite_id in metabolite_dict: tmp_metabolite = deepcopy(metabolite_dict[tmp_metabolite_id]) cobra_metabolites[tmp_metabolite] = sbml_metabolite.getStoichiometry() else: reaction.boundary = 'system_boundary' #Parse the kinetic law info here. parameter_dict = {} # if isinstance(the_reaction.getKineticLaw(), NoneType): if not sbml_reaction.getKineticLaw(): parameter_dict['lower_bound'] = -1000 parameter_dict['upper_bound'] = 1000 parameter_dict['objective_coefficient'] = 0 else: for sbml_parameter in sbml_reaction.getKineticLaw().getListOfParameters(): parameter_dict[sbml_parameter.getId().lower()] = sbml_parameter.getValue() if 'lower_bound' in parameter_dict: the_key = 'lower_bound' elif 'lower bound' in parameter_dict: the_key = 'lower bound' reaction.lower_bound = parameter_dict[the_key] if 'upper_bound' in parameter_dict: the_key = 'upper_bound' elif 'upper bound' in parameter_dict: the_key = 'upper bound' reaction.upper_bound = parameter_dict[the_key] if 'objective_coefficient' in parameter_dict: the_key = 'objective_coefficient' elif 'objective coefficient' in parameter_dict: the_key = 'objective coefficient' reaction.objective_coefficient = parameter_dict[the_key] reaction_note_dict = parse_legacy_sbml_notes(sbml_reaction.getNotesString()) #Parse the reaction notes. #POTENTIAL BUG: DEALING WITH LEGACY 'SBML' THAT IS NOT IN A #STANDARD FORMAT #TODO: READ IN OTHER NOTES AND GIVE THEM A reaction_ prefix. #TODO: Make sure genes get added as objects if reaction_note_dict.has_key('GENE ASSOCIATION'): reaction.gene_reaction_rule = reaction_note_dict['GENE ASSOCIATION'][0] reaction.parse_gene_association() if reaction_note_dict.has_key('GENE LIST'): reaction.systematic_names = reaction_note_dict['GENE LIST'][0] elif reaction_note_dict.has_key('GENES') and \ reaction_note_dict['GENES'] != ['']: reaction.systematic_names = reaction_note_dict['GENES'][0] elif reaction_note_dict.has_key('LOCUS'): gene_id_to_object = dict([(x.id, x) for x in reaction._genes]) for the_row in reaction_note_dict['LOCUS']: tmp_row_dict = {} the_row = 'LOCUS:' + the_row.lstrip('_').rstrip('#') for the_item in the_row.split('#'): try: k, v = the_item.split(':') tmp_row_dict[k] = v except ValueError, e: print the_item raise e tmp_locus_id = tmp_row_dict['LOCUS'] if 'TRANSCRIPT' in tmp_row_dict: tmp_locus_id = tmp_locus_id + '.' + tmp_row_dict['TRANSCRIPT'] gene_id_to_object[tmp_locus_id].name = tmp_row_dict['ABBREVIATION'] if reaction_note_dict.has_key('SUBSYSTEM'): reaction.subsystem = reaction_note_dict['SUBSYSTEM'][0] reaction.reversibility = int(sbml_reaction.getReversible()) #TODO: Use the cobra.metabolite objects here. reaction.add_metabolites(cobra_metabolites)