def getFromXML(filename): """ Returns the SBMLDocument object from XML file given """ reader = libsbml.SBMLReader() doc = reader.readSBML(filename) check(doc, 'reading from SBML file') return doc
def parse_sbml_file(sbmlf): """Parse a sbml file and return a sbml object""" doc = libsbml.SBMLReader().readSBML(sbmlf) if doc.getNumErrors() > 0: sys.stderr.write("Errors occurred when reading the document\n") sys.exit(1) return doc
def rxn_kegg2sbml(): kict = get_kegg_data() sbml = libsbml.SBMLReader().readSBML("Gthg_2.2 (manual).xml") print('The model has ', sbml.getNumErrors(), ' errors') model = sbml.getModel() hypercount = defaultdict(Counter) for rxn in model.getListOfReactions(): if rxn.getName() in kict: #Also should add: to RDF #http://www.kegg.jp/entry/R01090 details = kict[rxn.getName()] for f in sorted(details): if f != 'ENTRY': #How do I encode <=>? #Unicode? HTML ascii? #https://en.wikipedia.org/wiki/Arrow_(symbol) #encode('ascii','xmlcharrefreplace')) rxn.appendNotes( '<html:p>' + f + ': ' + '; '.join(details[f]).replace("<=>", "\u21cc").replace( '=>', '\u2192').replace('<=', '\u2190') + '</html:p>') #if 'DEFINITION' in details and 'EQUATION' in details: if 'EQUATION' in details: #Match the species. #prods=[model.getElementBySId(rxn.getProduct(n).getSpecies()) for n in range(rxn.getNumProducts())] #reacs=[model.getElementBySId(rxn.getReactant(n).getSpecies()) for n in range(rxn.getNumReactants())] #Split the def and eq lines and zip then #terms=list(zip([[re.search("([CG]\d+)",s2).group(0) for s2 in re.sub('\(.*?\)','',s).split('+')] for s in re.split('<?=>?',list(details['EQUATION'])[0])],[s.split('+') for s in re.split('<?=>?',list(details['DEFINITION'])[0])])) for k in [ re.search("([CG]\d+)", s2).group(0) for s in re.split('<?=>?', list(details['EQUATION'])[0]) for s2 in re.sub('\(.*?\)', '', s).split('+') ]: hypercount[k].update(['Σ'] + [ rxn.getProduct(n).getSpecies() for n in range(rxn.getNumProducts()) ] + [ rxn.getReactant(n).getSpecies() for n in range(rxn.getNumReactants()) ]) else: print('Unknown ', rxn.getName()) #print(hypercount) mapID = hyperwinner(hypercount) print('data:', mapID) for sp in model.getListOfSpecies(): tag = sp.getId().replace('_e', '_c') if tag in mapID: if type(mapID[tag]) is str: sp.appendNotes('<html:p>KEGG: ' + mapID[tag] + '</html:p>') #else: # sp.appendNotes('<html:p>KEGG: either '+' or '.join(mapID[tag])+'</html:p>') else: sp.appendNotes('<html:p>KEGG: !!!!GOGGLE IT</html:p>') print(tag, ' not an id element') libsbml.writeSBMLToFile(sbml, "test enrich.xml")
def main(args): """usage: flattenModel.py [-p] input-filename output-filename -p : list unused ports """ if len(args) != 4 and len(args) != 3: print(main.__doc__) sys.exit(1) leavePorts = False if len(args) == 3: infile = args[1] outfile = args[2] elif len(args) == 4: if args[1] != "-p": print(main.__doc__) sys.exit(1) else: leavePorts = True infile = args[2] outfile = args[3] if not os.path.exists(infile): print("[Error] %s : No such file." % (infile)) sys.exit(1) reader = libsbml.SBMLReader() writer = libsbml.SBMLWriter() sbmldoc = reader.readSBML(infile) if sbmldoc.getNumErrors() > 0: if sbmldoc.getError(0).getErrorId() == libsbml.XMLFileUnreadable: # Handle case of unreadable file here. sbmldoc.printErrors() elif sbmldoc.getError(0).getErrorId() == libsbml.XMLFileOperationError: # Handle case of other file error here. sbmldoc.printErrors() else: # Handle other error cases here. sbmldoc.printErrors() sys.exit(1) # Create the converter options props = libsbml.ConversionProperties() props.addOption("flatten comp", True, "flatten comp") props.addOption("leavePorts", leavePorts, "unused ports should be listed in the flattened model") # do conversion result = sbmldoc.convert(props) if (result != libsbml.LIBSBML_OPERATION_SUCCESS): sbmldoc.printErrors() print("[Error] Conversion failed... (" + str(result) + ")") sys.exit(1) writer.writeSBML(sbmldoc, outfile) print("Flat model written to %s" % (outfile))
def testIsSBMLModel(self): return self.assertFalse(util.isSBMLModel("dummy")) xml = util.getXML(cn.TEST_FILE2) reader = libsbml.SBMLReader() document = reader.readSBMLFromString(xml) util.checkSBMLDocument(document) model = document.getModel() self.assertTrue(util.isSBMLModel(model))
def from_files( sbml_file: str = None, condition_file: str = None, measurement_file: Union[str, Iterable[str]] = None, parameter_file: Union[str, List[str]] = None, visualization_files: Union[str, Iterable[str]] = None, observable_files: Union[str, Iterable[str]] = None) -> 'Problem': """ Factory method to load model and tables from files. Arguments: sbml_file: PEtab SBML model condition_file: PEtab condition table measurement_file: PEtab measurement table parameter_file: PEtab parameter table visualization_files: PEtab visualization tables observable_files: PEtab observables tables """ sbml_model = sbml_document = sbml_reader = None condition_df = measurement_df = parameter_df = visualization_df = None observable_df = None if condition_file: condition_df = conditions.get_condition_df(condition_file) if measurement_file: # If there are multiple tables, we will merge them measurement_df = core.concat_tables( measurement_file, measurements.get_measurement_df) if parameter_file: parameter_df = parameters.get_parameter_df(parameter_file) if sbml_file: sbml_reader = libsbml.SBMLReader() sbml_document = sbml_reader.readSBML(sbml_file) sbml_model = sbml_document.getModel() if visualization_files: # If there are multiple tables, we will merge them visualization_df = core.concat_tables(visualization_files, core.get_visualization_df) if observable_files: # If there are multiple tables, we will merge them observable_df = core.concat_tables(observable_files, observables.get_observable_df) return Problem(condition_df=condition_df, measurement_df=measurement_df, parameter_df=parameter_df, observable_df=observable_df, sbml_model=sbml_model, sbml_document=sbml_document, sbml_reader=sbml_reader, visualization_df=visualization_df)
def main(args): """usage: convertFbcToCobra.py input-filename output-filename """ if len(args) != 3: print(main.__doc__) sys.exit(1) infile = args[1] outfile = args[2] if not os.path.exists(infile): print("[Error] %s : No such file." % infile) sys.exit(1) reader = libsbml.SBMLReader() writer = libsbml.SBMLWriter() sbmldoc = reader.readSBML(infile) if sbmldoc.getNumErrors() > 0: if sbmldoc.getError(0).getErrorId() == libsbml.XMLFileUnreadable: # Handle case of unreadable file here. sbmldoc.printErrors() elif sbmldoc.getError(0).getErrorId() == libsbml.XMLFileOperationError: # Handle case of other file error here. sbmldoc.printErrors() else: # Handle other error cases here. sbmldoc.printErrors() # sys.exit(1) # strip non-FBC plugins for p_ in range(sbmldoc.getNumPlugins()): if sbmldoc.getPlugin(p_).getPackageName() != 'fbc': props = libsbml.ConversionProperties() props.addOption( "stripPackage", True, "Strip SBML Level 3 package constructs from the model") props.addOption("package", sbmldoc.getPlugin(p_).getPackageName(), "Name of the SBML Level 3 package to be stripped") if sbmldoc.convert(props) != libsbml.LIBSBML_OPERATION_SUCCESS: print("[Error] Failed to remove package: {}".format( sbmldoc.getPlugin(p_).getPackageName())) # convert to L2 props = libsbml.ConversionProperties() props.addOption("convert fbc to cobra", True, "Convert FBC model to Cobra model") result = sbmldoc.convert(props) if result != libsbml.LIBSBML_OPERATION_SUCCESS: print("[Error] Conversion failed... (%d)" % result) sys.exit(1) writer.writeSBML(sbmldoc, outfile) print("[OK] converted file %s to %s" % (infile, outfile))
def test_read_MathML_1(self): reader = libsbml.SBMLReader() filename = "../../sbml/math/test/test-data/" filename += "mathML_1-invalid.xml" d = reader.readSBML(filename) if (d == None): pass m = d.getModel() self.assert_(m != None) self.assert_(m.getNumFunctionDefinitions() == 2) self.assert_(m.getNumInitialAssignments() == 1) self.assert_(m.getNumRules() == 2) self.assert_(m.getNumReactions() == 1) fd = m.getFunctionDefinition(0) fd_math = fd.getMath() self.assert_(fd_math.getType() == libsbml.AST_LAMBDA) self.assert_(fd_math.getNumChildren() == 2) self.assert_(("lambda(x, )" == libsbml.formulaToString(fd_math))) self.assert_(fd_math.getParentSBMLObject() == fd) child = fd_math.getRightChild() self.assert_(child.getType() == libsbml.AST_UNKNOWN) self.assert_(child.getNumChildren() == 0) self.assert_(("" == libsbml.formulaToString(child))) fd = m.getFunctionDefinition(1) fd1_math = fd.getMath() self.assert_(fd1_math.getType() == libsbml.AST_LAMBDA) self.assert_(fd1_math.getNumChildren() == 2) self.assert_(("lambda(x, true)" == libsbml.formulaToString(fd1_math))) self.assert_(fd1_math.getParentSBMLObject() == fd) child1 = fd1_math.getRightChild() self.assert_(child1.getType() == libsbml.AST_CONSTANT_TRUE) self.assert_(child1.getNumChildren() == 0) self.assert_(("true" == libsbml.formulaToString(child1))) ia = m.getInitialAssignment(0) ia_math = ia.getMath() self.assert_(ia_math.getType() == libsbml.AST_UNKNOWN) self.assert_(ia_math.getNumChildren() == 0) self.assert_(("" == libsbml.formulaToString(ia_math))) self.assert_(ia_math.getParentSBMLObject() == ia) r = m.getRule(0) r_math = r.getMath() self.assert_(r_math.getType() == libsbml.AST_CONSTANT_TRUE) self.assert_(r_math.getNumChildren() == 0) self.assert_(("true" == libsbml.formulaToString(r_math))) self.assert_(r_math.getParentSBMLObject() == r) r = m.getRule(1) r1_math = r.getMath() self.assert_(r1_math.getType() == libsbml.AST_REAL) self.assert_(r1_math.getNumChildren() == 0) self.assert_(("INF" == libsbml.formulaToString(r1_math))) self.assert_(r1_math.getParentSBMLObject() == r) # kl = m.getReaction(0).getKineticLaw() # kl_math = kl.getMath() # self.assert_( kl_math == None ) d = None pass
def test_file(self, filename): """ Function for returning errors found in an SBML file. """ import libsbml as lb reader = lb.SBMLReader() document = reader.readSBML(filename) if document.getNumErrors() != 0: document.printErrors()
def loadTranslator(fileName, jsonFile): reader = libsbml.SBMLReader() document = reader.readSBMLFromFile('XMLExamples/curated/BIOMD0000000' + fileName + '.xml') parser = libsbml2bngl.SBML2BNGL(document.getModel()) database = structures.Databases() translator = m2c.transformMolecules( parser, database, 'reactionDefinitions/reactionDefinition' + str(jsonFile) + '.json') return translator
def check_for_groups(groups_sbml, sbo_term, group_type): doc = libsbml.SBMLReader().readSBMLFromFile(groups_sbml) groups_plugin = doc.getModel().getPlugin("groups") if groups_plugin: for group in groups_plugin.getListOfGroups(): gr_sbo = group.getSBOTermID() gr_type = next(get_annotations(group, libsbml.BQB_IS_DESCRIBED_BY), None) if sbo_term == gr_sbo and group_type == gr_type: return True return False
def main(fileName): reader = libsbml.SBMLReader() document = reader.readSBMLFromFile(fileName) model = document.getModel() speciesName = [] for species in model.getListOfSpecies(): speciesName.append(species.getName()) return analyzeNamingConventions(speciesName, 'reactionDefinitions/namingConventions.json')
def __setstate__(self, state): # load SBML model from pickled string sbml_string = state.pop('sbml_string', None) if sbml_string: self.sbml_reader = libsbml.SBMLReader() self.sbml_document = \ self.sbml_reader.readSBMLFromString(sbml_string) self.sbml_model = self.sbml_document.getModel() self.__dict__.update(state)
def main(): args = docopt.docopt(__doc__) sbml_file = args["--sbml"] reader = libsbml.SBMLReader() sbml_document = reader.readSBML(sbml_file) for i in range(sbml_document.getNumErrors()): print(sbml_document.getError(i).getMessage()) padmet = PadmetSpec(args["--padmet"]) compare_sbml_padmet.compare_sbml_padmet(sbml_document, padmet)
def main(): if libsbml == None: return parser = OptionParser() parser.add_option( "-i", "--input", dest="input", default='', type="string", #default='/home/proto/Downloads/model.xml',type="string", help="The input SBML file in xml format. Default = 'input.xml'", metavar="FILE") parser.add_option("-o", "--output", dest="output", type="string", help="the output JSON file. Default = <input>.py", metavar="FILE") (options, args) = parser.parse_args() reader = libsbml.SBMLReader() nameStr = options.input if options.output == None: outputFile = nameStr + '.json' else: outputFile = options.output document = reader.readSBMLFromFile(nameStr) if document.getModel() == None: #logging.error('A model with path "{0}" could not be found'.format(nameStr)) return #logging.info('An SBML file was found at {0}.Attempting import'.format(nameStr)) parser = SBML2JSON(document.getModel()) parameters, observables = parser.getParameters() #compartments = parser.getRawCompartments() molecules, release = parser.getMolecules() reactions, release2, molecules2 = parser.getReactions(parameters) molecules.extend(molecules2) release.extend(release2) #release.extend(release2) definition = {} definition['par_list'] = parameters definition['mol_list'] = molecules definition['rxn_list'] = reactions definition['rel_list'] = release definition['obs_list'] = observables #definition['comp_list'] = compartments with open(outputFile, 'w') as f: json.dump(definition, f, sort_keys=True, indent=1, separators=(',', ': '))
def preprocess(inf,species,is_mmod): src_file = r'%s' % (my_constants.species_sbml[species]) reader = libsbml.SBMLReader() doc = reader.readSBML(src_file) go_loaded_model = eval_util.GoLoadedModel(doc.getModel(), species) moredata_loaded_model = eval_util.MoreDataLoadedModel(species) sbml_file = r'%s/dataset/networks/%s' % (my_constants.basePath, my_constants.species_sbml[species]) S, mets, rxns, revs, met_names, rxn_names, biomass, met_comparts \ = importer.sbmlStoichiometricMatrix(sbml_file, True, read_species_compart=True)# remove_biomass=method_conf['remove_biomass'], normalize_stoich=method_conf['normalize_stoich']) go1=compute_coexpression_of_enzymes_aggregate(inf,species,is_mmod,True,S,mets,rxns,revs,go_loaded_model, moredata_loaded_model) return go1
def test_GetMultipleObjects_allElements(self): reader = libsbml.SBMLReader() filename = "../../sbml/test/test-data/" filename += "multiple-ids.xml" d = reader.readSBML(filename) if (d == None): pass list = d.getListOfAllElements() self.assert_(list.getSize() == 37) d = None pass
def testGetXMLFromAntimony(self): try: xml = util.getXMLFromAntimony(ANTIMONY_STG) except exceptions.MissingTelluriumError: return self.assertTrue(isinstance(xml, str)) reader = libsbml.SBMLReader() libsbml_document = reader.readSBMLFromString(xml) util.checkSBMLDocument(libsbml_document) model = libsbml_document.getModel() self.assertTrue('Reaction' in str(type(model.getReaction(0))))
def parse_sbml_file(sbmlfile): """ Parse a sbml file and return a sbml object :param sbmlfile: The file to parse :return: the parsed lbsbml object """ sbml_doc = libsbml.SBMLReader().readSBML(sbmlfile) if sbml_doc.getNumErrors() > 0: sys.stderr.write("Errors occurred when reading the document\n") sys.exit(1) return sbml_doc
def __init__(self, model_reference): """ Initializes instance variables :param str model_reference: string or SBML file """ ##### PUBLIC ##### self.model = None # libsbml object self.reactions = [] # Python wrapper for Reaction self.species = [] # libsbml Species self.assignment_rules = [ ] # rules for defining the values of variables self.initial_assignments = [] # list of initial assignments # Read the model if util.isSBMLModel(model_reference): self.model = model_reference else: xml = util.getXML(model_reference) reader = libsbml.SBMLReader() document = reader.readSBMLFromString(xml) util.checkSBMLDocument(document, model_reference=model_reference) self.model = document.getModel() # Do the initializations self.reactions = [ Reaction(self.model.getReaction(nn)) for nn in range(self.model.getNumReactions()) ] self.species = [ self.model.getSpecies(nn) for nn in range(self.model.getNumSpecies()) ] self.parameters = [ self.model.getParameter(nn) for nn in range(self.model.getNumParameters()) ] for nn in range(self.model.getNumRules()): rule = self.model.getRule(nn) if rule.isAssignment(): self.assignment_rules.append(rule) for nn in range(self.model.getNumInitialAssignments()): initial_assignment = self.model.getInitialAssignment(nn) self.initial_assignments.append(initial_assignment) # map for species -> species ref self.str_species = {} self.str_speciesref = {} # initialization for str_to_species for species in self.species: self.str_species[species.getId()] = species # initialization for str_to_speciesref for reaction in self.reactions: for reactant in reaction.reactants: self.str_speciesref[reactant.species] = reactant for product in reaction.products: self.str_speciesref[product.species] = product
def modifyReleaseNumber(fileName): print('modifying {0}'.format(fileName)) reader = libsbml.SBMLReader() document = reader.readSBMLFromFile(fileName) model = document.getModel() species = model.getSpecies('S4') species.setInitialAmount(species.getInitialConcentration()) species.unsetInitialConcentration() writer = libsbml.SBMLWriter() writer.writeSBMLToFile(document, fileName)
def check_ids(model_metabolic, model_faa, cutoff, verbose=False): """ check if genes ids of model_metabolic = model_faa for a given cutoff faa genes ids are in the first line of each sequence: >GENE_ID .... metabolic netowkrs genes ids are in note section, GENE_ASSOCIATION: gene_id-1 or gene_id-2 Parameters ---------- model_metabolic: str path to sbml file model_faa: str path to fasta faa file cutoff: int cutoff genes ids from model found in faa verbose: bool verbose Returns ------- bool True if same ids, if verbose, print % of genes under cutoff """ reader = libsbml.SBMLReader() document = reader.readSBML(model_metabolic) model = document.getModel() document.getNumErrors() listOfReactions = model.getListOfReactions() #convert to set model_metabolic_ids = set(itertools.chain.from_iterable([sp.parseGeneAssoc(geneAssoc) for geneAssoc in (sp.parseNotes(r).get("GENE_ASSOCIATION",[None])[0] for r in listOfReactions) if geneAssoc is not None])) with open(model_faa, "r") as f: model_faa_ids = set([record.id for record in SeqIO.parse(f, "fasta")]) diff_genes = model_metabolic_ids.difference(model_faa_ids) try: diff_genes_ratio = float(len(diff_genes))/float(len(model_metabolic_ids)) except ZeroDivisionError: raise SystemExit("No genes found in model metabolic") #if all model_metabolic_ids are in model_faa_ids if diff_genes_ratio == 0: if verbose: print("all genes of the model_metabolic are in the model_faa") return True #if not check if the nb is sup-equal to the cutoff elif diff_genes_ratio <= float(1-cutoff): if verbose: print("Only %.2f%% genes of the model_metabolic are not in the model_faa" % (diff_genes_ratio*100)) return True else: if verbose: print("%s%% genes of the model_metabolic are not in the model_faa" % (diff_genes_ratio*100)) print(";".join(diff_genes)) return False
def modelIterator(initial=0, final=1000, data_dir=cn.BIOMODELS_DIR, zip_filename=cn.BIOMODELS_ZIP_FILENAME): """ Iterates across all models in a data directory. :param int initial: initial file to process :param int final: final file to process :param str data_dir: absolute path of the directory containing the xml files :param str zip_filename: name of the zipfile to process. If None, then looks for XML files in the directory. :return IteratorItem: """ # Handle zip vs. XML file if zip_filename is not None: files, zipper = getZipfilePaths(data_dir=data_dir, zip_filename=zip_filename) else: files = [f for f in os.listdir(data_dir) if f[-4:] == ".xml"] # Functions for file types def readXML(filename): path = os.path.join(data_dir, filename) with open(path, 'r') as fd: lines = ''.join(fd.readlines()) return lines def readZip(filename): with zipper.open(filename, 'r') as fid: lines = fid.read() return lines # if zip_filename is not None: read_func = readZip else: read_func = readXML begin_num = max(initial, 0) num = begin_num - 1 end_num = min(len(files), final) for filename in files[begin_num:end_num]: num += 1 lines = read_func(filename) if isinstance(lines, bytes): lines = lines.decode("utf-8") reader = libsbml.SBMLReader() document = reader.readSBMLFromString(lines) model = document.getModel() iterator_item = IteratorItem(filename=filename, model=model, number=num) yield iterator_item
def main(): # command line arguments parser = OptionParser() parser.add_option( "-i", "--input", dest="input", default="bngl2mcell/rec_dim_sbml.xml", type="string", help="The input SBML file in xml format. Default = 'input.xml'", metavar="FILE", ) parser.add_option( "-o", "--output", dest="output", type="string", help="the output JSON file. Default = <input>.py", metavar="FILE", ) (options, args) = parser.parse_args() reader = libsbml.SBMLReader() nameStr = options.input if options.output == None: outputFile = nameStr + ".py" else: outputFile = options.output # libsbml initialization stuff document = reader.readSBMLFromFile(nameStr) if document.getModel() == None: print("No such input file") return # get data parser = SBML2JSON(document.getModel()) parameters = parser.getParameters() molecules, release = parser.getMolecules() reactions = parser.getReactions(parameters) definition = {} definition["par_list"] = parameters definition["mol_list"] = molecules definition["rxn_list"] = reactions definition["rel_list"] = release print("Writing output to {0}".format(outputFile)) # output with open(outputFile, "w") as f: json.dump(definition, f, sort_keys=True, indent=1, separators=(",", ": "))
def readFromString(inputString,reactionDefinitions,useID,speciesEquivalence=None,atomize=False, loggingStream=None): ''' one of the library's main entry methods. Process data from a string ''' console = None if loggingStream: console = logging.StreamHandler(loggingStream) console.setLevel(logging.DEBUG) setupStreamLog(console) reader = libsbml.SBMLReader() document = reader.readSBMLFromString(inputString) parser =SBML2BNGL(document.getModel(),useID) bioGrid = False pathwaycommons = True if bioGrid: loadBioGrid() database = structures.Databases() database.assumptions = defaultdict(set) database.document = document database.forceModificationFlag = True database.reactionDefinitions = reactionDefinitions database.useID = useID database.atomize = atomize database.speciesEquivalence = speciesEquivalence database.pathwaycommons = True database.isConversion = True #if pathwaycommons: # database.pathwaycommons = True namingConventions = resource_path('config/namingConventions.json') if atomize: translator,onlySynDec = mc.transformMolecules(parser,database,reactionDefinitions,namingConventions,speciesEquivalence,bioGrid) database.species = translator.keys() else: translator={} #logging.getLogger().flush() if loggingStream: finishStreamLog(console) returnArray = analyzeHelper(document, reactionDefinitions, useID,'', speciesEquivalence, atomize, translator, database) if atomize and onlySynDec: returnArray = list(returnArray) returnArray = AnalysisResults(*(list(returnArray[0:-2]) + [database] + [returnArray[-1]])) return returnArray
def __read_sbml_model(self): reader = libsbml.SBMLReader() sbml_doc = reader.readSBMLFromFile(self.__path) # This is just to warn user. Not considered as a failure at this point. if sbml_doc.validateSBML() > 0: warnings.warn( "Warning, SBML did not pass validation!\nProceeding anyway.") if sbml_doc.checkConsistency() > 0: warnings.warn( "Warning, SBML did not pass checking of consistency!\nProceeding anyway." ) self.__sbml_model = sbml_doc.getModel() pass
def setUp(self): ''' setup SBtabTable class with files from test directory ''' self.sbml_names = [f for f in os.listdir('python/tests/sbml/') if os.path.isfile(os.path.join('sbml/', f))] self.sbml_docs = [] reader = libsbml.SBMLReader() for i, s in enumerate(self.sbml_names): if s.startswith('_'): continue doc = reader.readSBML('python/tests/sbml/' + s) self.sbml_docs.append(doc)
def size_warning(sbml_file): ''' check whether a given sbml file has more than 250 reactions and then yield a warning message for the online interface ''' reader = libsbml.SBMLReader() sbml = reader.readSBMLFromString(sbml_file) sbml_model = sbml.getModel() if sbml_model.getNumReactions() > 250: return ('Warning: The model has more than 250 reactions, which may'\ ' slow down the computation time significantly. Proceed'\ ' with care.') else: return False
def setUp(self): ''' setup SBtabTable class with files from test directory ''' self.table_names = [ f for f in os.listdir('python/tests/tables/') if os.path.isfile(os.path.join('python/tests/tables/', f)) ] self.doc_names = [ f for f in os.listdir('python/tests/docs/') if os.path.isfile(os.path.join('python/tests/docs/', f)) ] self.sbml_names = [ f for f in os.listdir('python/tests/sbml/') if os.path.isfile(os.path.join('python/tests/sbml/', f)) ] self.sbtabs = [] for t in self.table_names: if not t.startswith('_'): p = open('python/tests/tables/' + t, 'r') p_content = p.read() sbtab = SBtab.SBtabTable(p_content, t) self.sbtabs.append(sbtab) p.close() self.docs = [] for i, d in enumerate(self.doc_names): if not d.startswith('_'): p = open('python/tests/docs/' + d, 'r') p_content = p.read() sbtab = SBtab.SBtabDocument('test_' + str(i), sbtab_init=p_content, filename=d) self.docs.append(sbtab) p.close() self.sbml_docs = [] self.sbml_strings = [] reader = libsbml.SBMLReader() for i, s in enumerate(self.sbml_names): if s.startswith('_'): continue # save SBML objects doc = reader.readSBML('python/tests/sbml/' + s) self.sbml_docs.append(doc) # also save the strings sbml = open('python/tests/sbml/' + s, 'r') self.sbml_strings.append(sbml.read()) sbml.close()
def test_GetMultipleObjects_noUnits(self): reader = libsbml.SBMLReader() filename = "../../sbml/test/test-data/" filename += "multiple-ids.xml" d = reader.readSBML(filename) if (d == None): pass obj = d.getElementBySId("volume") self.assert_(obj == None) obj = d.getElementByMetaId("meta30") self.assert_(obj != None) self.assert_(obj.getTypeCode() == libsbml.SBML_UNIT_DEFINITION) d = None pass