def opposing_model(): """ Generate a toy model with opposing reversible reactions. This toy model ensures that two opposing reversible reactions do not appear as blocked. """ test_model = cobra.Model("opposing") v1 = cobra.Reaction("v1") v2 = cobra.Reaction("v2") v3 = cobra.Reaction("v3") v4 = cobra.Reaction("v4") test_model.add_reactions([v1, v2, v3, v4]) v1.reaction = "-> 2 A" v2.reaction = "A -> C" # Later made reversible via bounds. v3.reaction = "D -> C" # Later made reversible via bounds. v4.reaction = "D ->" v1.bounds = 0.0, 3.0 v2.bounds = -3.0, 3.0 v3.bounds = -3.0, 3.0 v4.bounds = 0.0, 3.0 test_model.objective = v4 return test_model
def create_metamodel(list_of_models, model_id='metamodel'): metamodel = cobra.Model(model_id) for model in list_of_models: metabolites_dictionary = create_metabolites_dictionary(model) for m_id, m_dict in metabolites_dictionary.items(): if m_id in metamodel.metabolites: continue metabolite = create_metabolite_from_dict(m_dict) metamodel.add_metabolites([metabolite]) all_metabolites_dict = {m.id: m for m in metamodel.metabolites} for model in list_of_models: reactions_dictionary = create_reactions_dictionary(model) for r_id, r_dict in reactions_dictionary.items(): if r_id in metamodel.reactions: r = metamodel.reactions.get_by_id(r_id) r.lower_bound = min(r_dict['lower_bound'], r.lower_bound) r.upper_bound = max(r_dict['upper_bound'], r.upper_bound) r.reversibility = max(r_dict['reversibility'], r.reversibility) continue reaction = create_reaction_from_dict(r_dict, all_metabolites_dict) metamodel.add_reaction(reaction) return metamodel
def fusion (bacteries): import cobra import re if type(bacteries) ==list: model = cobra.Model('Communautés') model= bacteries[0].model.copy() for i in range(1,len(bacteries)) : A=bacteries[i].model.copy() for m in A.metabolites: if m.compartment != 'C_e': m.compartment=m.compartment+"_B"+str(i) m.id=m.id+"_B"+str(i) for r in A.reactions: if not re.search("EX_",r.id): r.id = r.id +"_B"+str(i) set_compartiments=r.compartments.copy() r.compartments.clear() for c in set_compartiments : c=c+"_B"+str(i) r.compartments.add(c) model.add_reactions(A.reactions.copy()) exec("model.reactions.Growth_B"+str(i)+".objective_coefficient=1") else : model=bacteries.model return model
def build_universal_model(template_model_file, clean_exchange_reactions=False, compartments=[0]): """ :param template_model_file: path to file where a template model is saved. e.g. templates/GramNegative.json :param compartments: list (usually integers) to be appended to all compounds/reactions indicating model compartments e.g. if compartments = [0], rxn00001_c, rxn00001_c0 will be in the universal model, and will have compounds of the form cpd00001_c, cpd00001_c0 respectively. This is used if your model has multiple compartments or indicates the compartment as 0 e.g. rxn00001_c0 with cpd00001_c0 :param clean_exchange_reactions: If true, re-formats exchange reactions to cobra form (see below) Cleaning Exchange Reactions: if a reaction in the template model uses external compounds to indicate exchange reactions, and the clean_exchange_reactions flag is set to True, then external compounds are removed to indicate exchange implicitly (CobraPy style) Example: "cpd00001_e0 <=> cpd00001_c0" is used to indicate exchange reaction of cpd00001. With the flag, this is changed to " <=> cpd00001_c0" :return: """ universal = cobra.Model("Universal Reactions") template_model = _load_template_file(template_model_file) # Creates a dictionary of the reactions from the tab delimited database, storing their ID and the reaction string for template_rxn in template_model['reactions']: compartments = [str(i) for i in compartments] compartments.extend('') for suffix in compartments: _add_rxn_from_template_rxn( universal, template_rxn, clean_exchange_reactions=clean_exchange_reactions, compartment=suffix) return universal
def to_cobra_model(self): """ Returns an instance of cobra.Model without any of the useful project stuff. Note, uses the same solver :return cobra.Model """ return cobra.Model(id_or_model=self)
def protein_to_gene(WD, model, protein_corres, name): """Function to transform the proteins in gene_reaction_rule into its corresponding genes. It creates a new model that will be rid of all the proteins. ARGS: WD (str) -- the path where to find the model. model (str) -- the model file in json format. protein_corres (str) -- the exact path of the csv file of the correspondance between a protein and its gene. name (str) -- the new name for the new corrected model. """ dico_corres, dico_corres_rev = corres_dico(protein_corres) protein_model = cobra.io.load_json_model(WD + model) gene_model = cobra.Model(protein_model.id) for reaction in protein_model.reactions: genes = [] list_proteins = reaction.gene_reaction_rule.split(" or ") for protein in list( filter(None, [trans.upper() for trans in list_proteins])): try: genes.append(dico_corres_rev[protein]) except KeyError: try: dico_corres[protein] genes.append(protein) except KeyError: print("No match for : ", protein) new_reaction = copy.deepcopy(reaction) new_reaction.gene_reaction_rule = " or ".join(set(genes)) gene_model.add_reactions([new_reaction]) cobra.io.save_json_model(gene_model, WD + name + protein_model.id + ".json")
def createReverseEXmodel(EXreactions): ''' This function takes the list of exchange reactions created using the function totalEXRxns and creates a Model object using cobrapy composed of those reactions with the upper bound flux values of 1000, lower bound flux values of -1000, and objective coefficient of 0, and one metabolite as being produced by the reaction (stoichiometric coefficient of 1). This is a model composed solely of exchange reactions. The metabolite information for these reactions will be used to update the metabolites of the exchange reactions for models A and B. :param EXreactions: list of reactions that are the output of the function totalEXRxns (above) :return exchange_modelRev: cobrapy Model object containing only exchange reactions with the production of their respective metabolites ''' cherrypy.log("Started the function that creates the reverse exchange reactions for the community model") exchange_modelRev = cobra.Model('Model with the exchange reactions only with reversed stoi coefficient') cherrypy.log("Created the base reverse exchange model object") for i in EXreactions: new_i = str(i) new_i = new_i[3:] new_met = cobra.Metabolite(new_i) rxn = cobra.Reaction(i) rxn.lower_bound = -1000.000 rxn.upper_bound = 1000.000 rxn.objective_coefficient = 0.000 rxn.add_metabolites({new_met:1.0}) exchange_modelRev.add_reaction(rxn) cherrypy.log('Finished adding all exchange reactions in reverse exchange model object. There are %d of them' %(len(exchange_modelRev.reactions))) return exchange_modelRev
def createEXmodel(EXreactions): ''' This function takes the list of exchange reactions created using the function totalEXRxns and creates a Model object using cobrapy composed of those reactions with the upper bound flux values of 1000, lower bound flux values of -1000, and objective coefficient of 0, and one metabolite as being uptaken by the reaction (stoichiometric coefficient of -1). This is a model composed solely of exchange reactions and it's the model for the extra compartment created for the full community model :param EXreactions: list of reactions that are the output of the function totalEXRxns (above) :return exchange_model: cobrapy Model object for the compartment that will serve as an extra compartment in the full community model. ''' cherrypy.log("Started the function that creates the exchange reactions for the community model") exchange_model = cobra.Model('Model with the exchange reactions only') cherrypy.log("Created the base exchange model object") for i in EXreactions: new_i = str(i) new_i = new_i[3:] new_met = cobra.Metabolite(new_i) rxn = cobra.Reaction(i) rxn.lower_bound = -1000.000 rxn.upper_bound = 1000.000 rxn.objective_coefficient = 0.000 rxn.add_metabolites({new_met:-1.0}) exchange_model.add_reaction(rxn) cherrypy.log('Finished adding all exchange reactions in exchange model object. There are %d of them' %(len(exchange_model.reactions))) return exchange_model
def drafting(model, dico_genes, model_name): """Creates the new COBRA model for the subject organism. ARGS: model -- the COBRA model used for the reconstruction. dico_genes -- the dictionary containing the correspondance between genes of the model and the subject (See select_genes() for the structure). model_name (str) -- a name for the new model. RETURN: new_model -- the new COBRA model automatically generated. """ new_model = cobra.Model(model_name) ###Browsing the model reactions and associating the subject's genes to them for reac in model.reactions: to_add = [] to_search = reac.gene_reaction_rule.split(" or ") for gene in to_search: try: to_add += dico_genes[gene] except KeyError: pass ###TODO : change the proteins's ID in to_add in corresponding genes string_reaction_rule = " or ".join(to_add) if string_reaction_rule: x = copy.deepcopy(reac) x.gene_reaction_rule = string_reaction_rule new_model.add_reactions([x]) return new_model
def change_model_prefix(model_path, save_model=None, suffix=r"__91__(\w)__93__"): """ Function that translate model extracellular metabolites to other 'languages' """ mod = load_model(model_path) new_model = cobra.Model() new_model.id = mod.id p = re.compile(r"(.+)" + suffix) pb = re.compile(r"biomass", re.I) pdash = re.compile(r"DASH_") for i in mod.reactions: for reactant in i.metabolites: reactant.id = re.sub(pdash, r"", reactant.id) reactant.id = re.sub(p, r"\1[\2]", reactant.id) for react in i.reaction: react = re.sub(p, r"\1[\2]", react) new_model.add_reaction(i) for reac in new_model.reactions: if pb.search(reac.id): new_model.objective = [new_model.reactions.get_by_id(reac.id)] break if save_model != None: cobra.io.write_sbml_model(new_model, save_model) return new_model
def test_notes(tmp_path): """Testing if model notes are written in SBML""" path_to_file = join(str(tmp_path), "model_notes.xml") # making a minimal cobra model to test notes model = cobra.Model("e_coli_core") model.notes["Remark"] = "...Model Notes..." met = cobra.Metabolite("pyr_c", compartment="c") model.add_metabolites([met]) met.notes["Remark"] = "Note with \n newline" rxn = cobra.Reaction("R_ATPM") model.add_reactions([rxn]) rxn.notes["Remark"] = "What about me?" model.objective_direction = "max" model.objective = rxn write_sbml_model(model, path_to_file) # reading the model back model_after_reading = read_sbml_model(path_to_file) met_after_reading = model_after_reading.metabolites.get_by_id("pyr_c") reaction_after_reading = model_after_reading.reactions.get_by_id("R_ATPM") # checking if notes are written to model assert model_after_reading.notes["Remark"] == "...Model Notes..." # checking notes for metabolite and reaction assert met_after_reading.notes["Remark"] == "Note with \n newline" assert reaction_after_reading.notes["Remark"] == "What about me?"
def createEXmodel(EXreactions): import cobra ''' @summary: using the cobrapy package, create a brand new model that will contain the exchange reactions. This is the model we can manipulate when we want to change the nutrients available to the species. We will do this by changing either the upper or lower bounds (I don't remember and have to check). Ultimately we will create a file with a global exchange reactions model that has a different diet associated with it. But this will require going over a whole bunch of models to find all possible exchange reactions, and so I will stick to this approach for now. ''' exchange_model = cobra.Model('Model with the exchange reactions only') for i in EXreactions: new_i = str(i) new_i = new_i[3:] new_met = cobra.Metabolite(new_i) rxn = cobra.Reaction(i) rxn.lower_bound = -1000.000 rxn.upper_bound = 1000.000 rxn.objective_coefficient = 0.000 rxn.add_metabolites({new_met: -1.0}) exchange_model.add_reaction(rxn) return exchange_model
def get_biomass_model(dic_i, observations_list=False): ''' :description : function to get a model contain biomass reactions from a dic :param : dic_i(dic) : {'met_id': [coefficient, 'pool]} eg. {'10-FORMYL-THF': [-0.000367, 'cofactor'], 'AMP': [-0.0046700000000000005, 'cofactor'], 'CPD-12125': [-0.000266, 'cofactor'], 'CDP': [-0.000251, 'cofactor'],} observations_list like: eg. ['dna', 'rna', 'protein', 'lipid', 'carbohydrate', 'cofactor', 'ion', 'other'] :returns: cobra model ''' if observations_list == False: observations_list = [ 'dna', 'rna', 'protein', 'lipid', 'carbohydrate', 'cofactor', 'ion', 'other' ] observations_list = [i + '_c' for i in observations_list] biomass_model = cobra.Model('model') # get a Model # %% <Biomass pool reactions> biomass_reactions = [ cobra.Reaction('Biomass_' + i) for i in observations_list ] [ rxn.add_metabolites({cobra.Metabolite(met): 1}) for rxn, met in zip(biomass_reactions, observations_list) ] biomass_model.add_reactions(biomass_reactions) for k, v in dic_i.items(): # print(k) try: # build metabolites met = biomass_model.metabolites.get_by_id(k) except: met = cobra.Metabolite(k) try: # build reactions reaction_i = biomass_model.reactions.get_by_id('Biomass_' + v[1] + '_c') reaction_i.add_metabolites({met: v[0]}) except: print(k, v, 'Error') # %% <Biomass reaction> Biomass = cobra.Reaction('Biomass') [ Biomass.add_metabolites({biomass_model.metabolites.get_by_id(met): -1}) for met in observations_list ] Biomass.add_metabolites({cobra.Metabolite('Biomass'): 1}) biomass_model.add_reactions([Biomass]) return biomass_model
def setUp(self): self.model = cb.test.create_test_model('salmonella') self.salchs4_e = self.model.metabolites.get_by_id('salchs4_e') self.pglyc_c = self.model.metabolites.get_by_id('2pglyc_c') small_model = cb.Model('small_model') for r in self.salchs4_e.reactions: small_model.add_reaction(r) self.adj = MetabolicAdjMatrix(small_model) unconnected_model = cb.Model('unconnected_model') for r in self.salchs4_e.reactions: unconnected_model.add_reaction(r) for r in self.pglyc_c.reactions: unconnected_model.add_reaction(r) self.unconnected_adj = MetabolicAdjMatrix(unconnected_model)
def __init__(self): self.name = "Unnamed project" self.cobra_py_model = cobra.Model() self.maps = {} self.scen_values: Dict[str, Tuple[float, float]] = {} self.clipboard: Dict[str, Tuple[float, float]] = {} self.comp_values: Dict[str, Tuple[float, float]] = {} self.modes: Dict[str, Tuple[float, float]] = [] self.compute_color_type = 1 self.meta_data = {}
def raw_model(): """Provides a raw model.""" model = cobra.Model(id_or_model='raw_model', name='raw_model') rxn_1 = cobra.Reaction("BIOMASS_TEST") rxn_2 = cobra.Reaction("RXN2") rxn_3 = cobra.Reaction("RXN3") rxn_4 = cobra.Reaction("RXN4") model.add_reactions([rxn_1, rxn_2, rxn_3, rxn_4]) model.objective = rxn_3 return model
def expected_model(): """Provides a model with an objective function according to the config.""" model = cobra.Model(id_or_model='expected_model', name='expected_model') rxn_1 = cobra.Reaction("BIOMASS_TEST") rxn_2 = cobra.Reaction("RXN2") rxn_3 = cobra.Reaction("RXN3") rxn_4 = cobra.Reaction("RXN4") model.add_reactions([rxn_1, rxn_2, rxn_3, rxn_4]) model.objective = rxn_1 return model
def make_cobra_model(met_list, rxn_list, allow_export = True): ''' Given a list of metabolites and reactions, make a COBRApy model representing the corresponding metabolic network If allow_export is True, an extra reaction will be added for every metabolite that consumes the metabolite and produces nothing to simulate secretion of waste products ''' model = cobra.Model('string_chem') # start with the metabolites # we will need to make a dictionary with the COBRA metabolite objects # as keys and stoichiometric coefficients as values, so we'll need a way # to look up the COBRA metabolite objects using their names, since cobra_mets = [cobra.Metabolite(met, compartment = 'c') for met in met_list] met_dict = dict() for met in met_list: met_dict[met] = cobra.Metabolite(met, compartment = 'c') # start working on the reactions # start by making a dictionary to look up species involved in a reaction # using the string notation of that reaction rxn_dict = dict() for rxn in rxn_list: rxn_dict[rxn] = re.split('(\+|\-\>)', rxn)[0::2] # start by just making the COBRA reaction objects then add metabolites cobra_rxns = [ # make all reactions reversible by default cobra.Reaction(rxn, upper_bound = 1000.0, lower_bound = -1000.0) for rxn in rxn_list ] for rxn in cobra_rxns: # find all the COBRA metabolites associated with this reaction c_mets = [met_dict[met] for met in rxn_dict[rxn.id]] # we know the first metabolite in the list is the reactant rxn.add_metabolites({c_mets[0] : -1.0}) # check if reactant splits into two identical products if rxn_dict[rxn.id][1] == rxn_dict[rxn.id][2]: rxn.add_metabolites({c_mets[1] : 2.0}) else: rxn.add_metabolites({c_mets[1] : 1.0, c_mets[2] : 1.0}) # now that the reaction is complete, we can just add it to the model model.add_reaction(rxn) # add in export reactions for all metabolites if specified if allow_export is True: for met in cobra_mets: out_rxn = cobra.Reaction( met.id + '->', upper_bound = 1000.0, # only allow exporting lower_bound = 0.0 ) out_rxn.add_metabolites({met: -1.0}) model.add_reaction(out_rxn) return(model)
def test_load_network_model(self): model = cb.Model() loaded_model = load_network_model(model) self.assertEqual(model, loaded_model) textbook = load_network_model('textbook') self.assertEqual(textbook.id, 'e_coli_core') recon2 = load_network_model('recon2') self.assertGreater(len(recon2.reactions), 1000) self.assertGreater(len(recon2.metabolites), 1000)
def make_plantnetwork(WD, metacycPath, reactionsPath): """Function to create a subnetwork of Metacyc containing only the Viridiplantae taxon. This function revealed itself useless as the output model is way too small, and the TAXONOMIC-RANGE field is not maintained anymore. ARGS: WD (str) -- the path to the working directory where to save the new model. metacycPath (str) -- the exact path and filename of the Metacyc model. reactionsPath (str) the exact path and filename of the reactions.dat file of the organism. """ reactionsFile = tools.read_file(reactionsPath) list_plant = [] for line in reactionsFile: if "UNIQUE-ID" in line: try: unique_id = re.search('(?<=UNIQUE-ID - )[+-]*\w+(.*\w+)*(-*\w+)*', line).group(0).rstrip() except AttributeError: print("No match for : ", line) if "TAXONOMIC-RANGE" in line and "33090" in line: list_plant.append(unique_id) ###Necessary step for the gathering of short/long IDs dico_matching, dico_matching_rev = tools.corres_dico("/home/asa/INRAE/Work/Fusion/MetacycCorresIDs.tsv") ###Transformation of all IDs in short + long to get them from Metacyc new_plant_list = [] for reac in list_plant: try: for long_reac in dico_matching[reac]: new_plant_list.append(long_reac) new_plant_list.append(reac) except KeyError: try: new_plant_list.append(dico_matching_rev[reac]) new_plant_list.append(reac) except KeyError: print("No match for reac : ", reac) ###Fetching the plant reactions metacyc = cobra.io.read_sbml_model(metacycPath) meta_plant = cobra.Model(name="Metacyc Plant") for reac in new_plant_list: try: plant_reac = copy.deepcopy(metacyc.reactions.get_by_id(reac)) meta_plant.add_reactions([plant_reac]) except KeyError: try: plant_reac = copy.deepcopy(metacyc.reactions.get_by_id(reac)) meta_plant.add_reactions([plant_reac]) except KeyError: print("Reaction not found in Metacyc : ", reac) cobra.io.write_sbml_model(meta_plant, WD + "meta_plant.sbml")
def to_cobrapy(model): """ Convert model to a *cobrapy.Model* object Arguments: model (CBModel): constraint-based model Returns: cobrapy.Model """ try: import cobra as cb except ImportError: raise RuntimeError("CobraPy is not installed.") cb_model = cb.Model(model.id) cb_model.compartments = { comp.id: comp.name for comp in model.compartments.values() } cb_mets = [] for met in model.metabolites.values(): cb_met = cb.Metabolite(id=met.id, name=met.name, compartment=met.compartment, formula=met.metadata.get('FORMULA', '')) cb_mets.append(cb_met) cb_model.add_metabolites(cb_mets) cb_rxns = [] for rxn in model.reactions.values(): cb_rxn = cb.Reaction(id=rxn.id, name=rxn.name, lower_bound=rxn.lb, upper_bound=rxn.ub) cb_rxns.append(cb_rxn) cb_model.add_reactions(cb_rxns) for r_id, rxn in model.reactions.items(): cb_rxn = cb_model.reactions.get_by_id(r_id) cb_rxn.add_metabolites(rxn.stoichiometry) if rxn.gpr is not None: cb_rxn.gene_reaction_rule = str(rxn.gpr) cb_model.objective = { cb_model.reactions.get_by_id(r_id): coeff for r_id, coeff in model.get_objective().items() } return cb_model
def bare_mini(): """Define a minimal metabolism with two metabolites.""" model = cobra.Model() met_a = cobra.Metabolite("a_c", name="A", formula="C2") met_b = cobra.Metabolite("b_c", name="B", formula="C2") model.add_metabolites([met_a, met_b]) rxn = cobra.Reaction("FORMB") rxn.add_metabolites({met_a: -1, met_b: 1}) model.add_reactions([rxn]) model.add_boundary(met_a) demand = model.add_boundary(met_b, type="demand") model.objective = demand model.objective_direction = "max" return model
def construct_model_from_mat(N, rxn_names, met_names): model = cobra.Model('test_model') model.add_metabolites( [cobra.Metabolite(id=met_name) for met_name in met_names]) for row, rxn_name in zip(N.T, rxn_names): reaction = cobra.Reaction(id=rxn_name) model.add_reaction(reaction) reaction.add_metabolites({ met_id: float(stoich) for met_id, stoich in zip(met_names, row) if abs(stoich) > 1E-6 }) return model
def make_cobra_model(reaction_dict, metab_dict, reactions_in_model, objective_name): ''' Make a cobra model of all reactions in reactions_in_model, using a reaction class instance and a metab dict containing all metabs used in the reactions. ''' #Make cobra metabolites and reaction objects. cobra_metabs = make_cobra_metabolites(metab_dict) cobra_reactions = [ make_cobra_reaction(reaction_dict, cobra_metabs, e) for e in reactions_in_model ] #Make cobra model. cobra_model = cobra.Model('tempmodel') cobra_model.add_reactions(cobra_reactions) cobra_model.objective = objective_name return cobra_model
def _create_base_model(self, model_list, base_id='ensemble base'): ''' Creates a base model from a list of universal models. Base models contain all reactions present in a list of models. A reaction_diff object is also returned, indicating the bounds for any reaction that is different across any model in the ensemble. ''' base_model = cobra.Model(base_id) for model in model_list: rxns_to_add = [] for reaction in model.reactions: if reaction.id not in [rxn.id for rxn in base_model.reactions]: rxns_to_add.append(reaction.copy()) base_model.add_reactions(rxns_to_add) base_model.repair() return base_model
def mini_with_cofactors(): """Define a minimal metabolism with two metabolites and co-factors.""" model = cobra.Model() met_a = cobra.Metabolite("a_c", name="A", formula="C2") met_b = cobra.Metabolite("b_c", name="B", formula="C2") met_c = cobra.Metabolite("c_c", name="C", formula="O2") met_d = cobra.Metabolite("d_c", name="D", formula="CO") model.add_metabolites([met_a, met_b]) rxn = cobra.Reaction("FORMB") rxn.add_metabolites({met_a: -1, met_b: 1}) model.add_reactions([rxn]) model.add_boundary(met_a) model.add_boundary(met_c) model.add_boundary(met_d) demand = model.add_boundary(met_b, type="demand") model.objective = demand model.objective_direction = "max" return model
def as_pathway_model(self): """ Loads a cobra model with just the reactions present in this design Can be useful for the cobra.Model methods # TODO: add full metabolite info from parent model (optional, as it will be slower) :return: mdl instance of cobra.Model """ if self._p_model is not None: return self._p_model mdl = cobra.Model() mdl.id = '' mdl = self.add_to_model(mdl, add_missing=True) self._p_model = mdl return self._p_model
def test_validator(): """ Check models validate properly """ with FakeProjectContext() as ctx: # Valid model model = ctx.project.model result = validate_model(model) assert len(result['errors']) == 0 # Model that can't grow for re in model.exchanges: re.lower_bound = 0 result = validate_model(model) assert len(result['errors']) == 1 # model without constraints model = cobra.Model() result = validate_model(model) # Should issue warning, this assertion makes sure assert len(result['warnings']) == 1
def make_json_pathways(ref_model): pathway_dict = { "Bafilomycin": create_baf_pathway, "Difficidin": create_difficidin_pathway, "Anabaenopeptin": create_anabaenopeptin_pathway, "Tolaasin": create_tolaasin_pathway, "Leupyrrin": create_leupyrrin_pathway, "Geldanamycin": create_geldanamycin_pathway, "Oocydin": create_oocydin_pathway, "Oxazolomycin": create_oxazolo_pathway } folder = Path("../Data/validation_pathways") folder.mkdir(exist_ok=True) for key, value in pathway_dict.items(): fn = folder / "{0}.json".format(key) model = cobra.Model() reactions = value(ref_model) model.add_reactions(reactions) cobra.io.save_json_model(model, str(fn))
def InitializeMetabacterium(self): #Define LP problem object metabact = cobra.Model('metabacterium') reactions = list() metabolites = list() #Define all metabolites for i in range(len(self.metabolites)): met = self.metabolites[i] metabolites.append( cobra.Metabolite(met)) #Add cobra metabolite object if met == 'crowding_coeff': #the sum of crowding coefficients should be < VProt metabolites[ i]._bound = self.VProt #for all other metabolites, _bound == 0. metabolites[ i]._constraint_sense = "L" # "L" specifies "lower than" #Define all reactions, their stoichiometric coefficients per metabolite, upper bounds, lower bounds #and objective coefficient (z) for i in range(len(self.rxns)): rxn = self.rxns[i] reactions.append(cobra.Reaction(rxn)) #Add cobra reaction object for j in range(len(metabolites)): met = metabolites[j] s_coeff = self.S[self.metabolites[j]][ rxn] #Obtain the stoichiometric coefficients reactions[i].add_metabolites({met: s_coeff }) #Store for every reaction reactions[i].lower_bound = self.rxnBounds[rxn][ 'lb'] #Set reaction lower- (lb) and upper bounds (ub) reactions[i].upper_bound = self.rxnBounds[rxn]['ub'] reactions[i].objective_coefficient = self.Z[ rxn] #Set coefficients of objective function (Z) for every reaction #Currently every index is 0, except for 'biomass_LPL6.0', which is 1. metabact.add_reaction( reactions[i] ) #Add all reactions incl. metabolites to metabact object return (metabact)