def reaction_flux_control_by_scenario(model: cobra.Model, output_folder: str,
project_name: str, scenarios):
"""Creates reaction flux control files for the given model in the given folder, and depending on the given scenarios.
Definition of 'reaction flux control file':
A reaction flux control file contains a list of reactions and the realative change of the objective
solution if the protein constraint of the reaction is removed.
Arguments
----------
* model: cobra.Model ~ The metabolic model for which the reaction flux control file shall be created.
* output_folder: str ~ The folder in which the reaction flux control files shall be created
* project_name: str ~ The name of the current project
* scenarios ~ The scenarios for which the reaction control shall be calculated; these scenarios are
applied on the model, one by one
Output
----------
Reaction flux control files in the given folder (see _reaction_flux_control()'s comment for more)
"""
# Standardize output folder
output_folder = standardize_folder(output_folder)
# Go through each given scenario :D
for scenario_key in scenarios.keys():
scenario = scenarios[scenario_key]
objective = scenario["target"]["reaction"]
with model:
model = apply_scenario_on_model(model, scenario)
_reaction_flux_control(model, output_folder, project_name,
scenario_key, objective)
def parse_bigg_metabolites_file(bigg_metabolites_file_path: str, json_output_folder: str) -> None:
"""Parses a BIGG metabolites text file and returns a dictionary for this file.
As of 29/04/2019, a BIGG metabolites list of all BIGG-included metabolites
is retrievable under http://bigg.ucsd.edu/data_access
Arguments
----------
* bigg_metabolites_file_path: str ~ The file path to the BIGG metabolites file.
The usual file name (which has to be included too in this argument) is
bigg_models_metabolites.txt
* output_folder: str ~ The folder in which the JSON including the parsed BIGG
metabolites file data is stored with the name 'bigg_id_name_mapping.json'
Output
----------
* A JSON file with the name 'bigg_id_name_mapping.json' in the given output folder,
with the following structure:
<pre>
{
"$BIGG_ID": "$CHEMICAL_OR_USUAL_NAME",
(...),
"$BIGG_ID": "$BIGG_ID",
(...),
}
</pre>
The BIGG ID <-> BIGG ID mapping is done for models which already use the BIGG IDs.
"""
# Standardize output folder
json_output_folder = standardize_folder(json_output_folder)
# Open the BIGG metabolites file as string list, and remove all newlines
with open(bigg_metabolites_file_path, "r") as f:
lines = f.readlines()
lines = [x.replace("\n", "") for x in lines if len(x) > 0]
# Mapping variable which will store the BIGG ID<->
bigg_id_name_mapping = {}
# Go through each BIGG metabolites file line (which is a tab-separated file)
# and retrieve the BIGG ID and the name (if there is a name for the given BIGG
# ID)
for line in lines:
bigg_id = line.split("\t")[1]
# Exception to check if there is no name :O
try:
name = line.split("\t")[2].lower()
except Exception:
continue
bigg_id_name_mapping[name] = bigg_id
bigg_id_name_mapping[bigg_id] = bigg_id
# Write the JSON in the given folder :D
json_write(json_output_folder+"bigg_id_name_mapping.json", bigg_id_name_mapping)
def get_initial_spreadsheets(model: cobra.Model, project_folder: str, project_name: str) -> None:
"""Creates a number of initially needed XLSX spreadsheets in the given folder.
Output
----------
The following spreadsheets are going to be created (all file names start with project_name+"_"):
* reactions.xlsx ~ A list of all KEGG IDs for each reaction of the model, the user can then select
one of the given KEGG IDs. It is checked (using the KEGG REST API) if a reaction does not occur
in any KEGG pathway, and such reactions are automatically marked as not included.
* metabolites.xlsx ~ A list of all KEGG IDs for each metabolite of the model, the user can then select
one of the given KEGG IDs. It is checked (using the KEGG REST API) if a metabolite does not occur
in any KEGG reaction, and such metabolites are automatically marked as not included.
* compartments.xlsx ~ A list of the model's compartments, which allows the user to set
a pH and ionic strength value for each of them. THis data is used for the calculation of
thermodaynamic data.
* metabolite_concentration.xlsx ~ Allows to set default maximal and minimal metabolite
concentrations (used in THermoFBA or OptMDFPathway in CellNetAnalyzer) for each of the
model's metabolites.
* protein_data.xlsx ~ Allows to set the total protein pool as well as single protein concentrations
of the model's proteins.
* protein_data.xlsx ~ Allows to set the total protein pool as well as single protein concentrations
of the model's proteins.
* enzyme_stoichiometries.xlsx ~ Allows to set the internal stoichiometries for each enzyme of a given reaction.
Arguments
----------
* model: cobra.Model ~ The cobrapy model for which the initial spreadsheets will be created.
* project_folder: str ~ In this folder, all XLSX files will be stored.
* project_name: str ~ This project name is added before each XLSX file name.
"""
# Standardize project folder
project_folder = standardize_folder(project_folder)
# Get basepath for all spreadsheets
basepath = project_folder + project_name
# GET REACTION KEGG IDS AND AMBIGUITIES
reaction_id_kegg_id_mapping: Dict[str, str] = {}
reaction_id_reaction_name_mapping: Dict[str, str] = {}
reaction_id_eligible_ids_mapping: Dict[str, str] = {}
for reaction in model.reactions:
if "kegg.reaction" not in reaction.annotation.keys():
print(f"INFO: Reaction {reaction.id} does not have a KEGG ID annotation")
continue
kegg_ids = reaction.annotation["kegg.reaction"]
if type(kegg_ids) is str: # Single ID :O
kegg_ids = [kegg_ids]
else: # Multiple IDs :O
entries = kegg_rest_get_batch(kegg_ids, batch_size=len(kegg_ids))
i = 0
eligible_ids = []
for entry in entries:
entry_as_str = "".join(entry)
if "PATHWAY" in entry_as_str:
eligible_ids.append(kegg_ids[i])
i += 1
if len(eligible_ids) == 1:
reaction_id_eligible_ids_mapping[reaction.id] = eligible_ids[0]
reaction_id_kegg_id_mapping[reaction.id] = kegg_ids
reaction_id_reaction_name_mapping[reaction.id] = reaction.name
# GET METABOLITE KEGG IDS AND AMBIGUITIES
metabolite_id_kegg_id_mapping: Dict[str, str] = {}
metabolite_id_metabolite_name_mapping: Dict[str, str] = {}
metabolite_name_eligible_ids_mapping: Dict[str, str] = {}
searched_metabolites: List[str] = []
for metabolite in model.metabolites:
if "kegg.compound" not in metabolite.annotation.keys():
print(f"INFO: Metabolite {metabolite.id} does not have a KEGG ID annotation")
continue
kegg_ids = metabolite.annotation["kegg.compound"]
if type(kegg_ids) is str: # Single ID :O
kegg_ids = [kegg_ids]
else: # Multiple IDs :O
if metabolite.name not in searched_metabolites:
entries = kegg_rest_get_batch(kegg_ids, batch_size=len(kegg_ids))
i = 0
eligible_ids = []
for entry in entries:
entry_as_str = "".join(entry)
if "REACTION" in entry_as_str:
eligible_ids.append(kegg_ids[i])
i += 1
if len(eligible_ids) == 1:
metabolite_name_eligible_ids_mapping[metabolite.name] = eligible_ids[0]
searched_metabolites.append(metabolite.name)
metabolite_id_kegg_id_mapping[metabolite.id] = kegg_ids
metabolite_id_metabolite_name_mapping[metabolite.id] = metabolite.name
# Reactions <-> KEGG ID mapping XLSX :D
workbook = xlsxwriter.Workbook(basepath+"_reactions.xlsx")
worksheet = workbook.add_worksheet("Reaction IDs")
yellow = workbook.add_format()
yellow.set_bg_color("#FFFF00")
blue = workbook.add_format()
blue.set_bg_color("#FF00FF")
row = 0
for key in reaction_id_reaction_name_mapping.keys():
worksheet.write(row, 0, key)
worksheet.write(row, 1, reaction_id_reaction_name_mapping[key])
column = 2
kegg_ids = reaction_id_kegg_id_mapping[key]
for kegg_id in kegg_ids:
if len(kegg_ids) == 1:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?rn:"+kegg_id)
worksheet.write(row, column+1, kegg_id)
worksheet.write(row, column+2, "Yes")
else:
if key in reaction_id_eligible_ids_mapping.keys():
if kegg_id == reaction_id_eligible_ids_mapping[key]:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?rn:"+kegg_id, blue)
worksheet.write(row, column+1, kegg_id, blue)
worksheet.write(row, column+2, "Yes")
else:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?rn:"+kegg_id, blue)
worksheet.write(row, column+1, kegg_id, blue)
else:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?rn:"+kegg_id, yellow)
worksheet.write(row, column+1, kegg_id, yellow)
column += 3
row += 1
workbook.close()
# Metabolites<->KEGG ID mapping XLSX :D
workbook = xlsxwriter.Workbook(basepath+"_metabolites.xlsx")
worksheet = workbook.add_worksheet("Metabolite IDs")
yellow = workbook.add_format()
yellow.set_bg_color("#FFFF00")
blue = workbook.add_format()
blue.set_bg_color("#FF00FF")
row = 0
for key in metabolite_id_metabolite_name_mapping.keys():
metabolite_name = metabolite_id_metabolite_name_mapping[key]
worksheet.write(row, 0, key)
worksheet.write(row, 1, metabolite_name)
column = 2
kegg_ids = metabolite_id_kegg_id_mapping[key]
for kegg_id in kegg_ids:
if len(kegg_ids) == 1:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?cpd:"+kegg_id)
worksheet.write(row, column+1, kegg_id)
worksheet.write(row, column+2, "Yes")
else:
if metabolite_name in metabolite_name_eligible_ids_mapping.keys():
if kegg_id == metabolite_name_eligible_ids_mapping[metabolite_name]:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?cpd:"+kegg_id, blue)
worksheet.write(row, column+1, kegg_id, blue)
worksheet.write(row, column+2, "Yes")
else:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?cpd:"+kegg_id, blue)
worksheet.write(row, column+1, kegg_id, blue)
else:
worksheet.write_url(row, column, "https://www.kegg.jp/dbget-bin/www_bget?cpd:"+kegg_id, yellow)
worksheet.write(row, column+1, kegg_id, yellow)
column += 3
row += 1
workbook.close()
# Compartment data XLSX :D
workbook = xlsxwriter.Workbook(basepath+"_compartments.xlsx")
worksheet = workbook.add_worksheet("Compartment pH")
row = 0
for compartment_key in model.compartments.keys():
compartment_name = model.compartments[compartment_key]
worksheet.write(row, 0, compartment_key)
worksheet.write(row, 1, compartment_name)
worksheet.write(row, 2, "NA")
worksheet.write(row, 3, "NA")
row += 1
workbook.close()
# Protein data XLSX :D
print("NOTE: "+project_name+"_protein_data.xlsx has as default value for the enzyme pool P 0.095 mmol/gDW.")
print("Please adjust the value accordingly for your model!")
workbook = xlsxwriter.Workbook(basepath+"_protein_data.xlsx")
worksheet = workbook.add_worksheet("Total protein data")
worksheet.write(0, 0, "Total protein content [g/gDW]:")
worksheet.write(0, 1, .095)
worksheet.write(1, 0, "Fraction of masses of model-included enzymes in comparison to all enzymes (0.0 to 1.0):")
worksheet.write(1, 1, 1.0)
worksheet.write(2, 0, "Average saturation level (0.0 to 1.0):")
worksheet.write(2, 1, 1.0)
worksheet2 = workbook.add_worksheet("Single protein data")
worksheet2.write(0, 0, "Protein ID (as in SBML model)")
worksheet2.write(0, 1, "Protein concentration [mmol/gDW]")
workbook.close()
# Metabolite concentrations XLSX :D
workbook = xlsxwriter.Workbook(basepath+"_metabolite_concentrations.xlsx")
worksheet = workbook.add_worksheet("Default data")
worksheet.write(0, 0, "Default minimal metabolite concentration [M]:")
worksheet.write(1, 0, "Default maximal metabolite concentration [M]:")
worksheet2 = workbook.add_worksheet("Single metabolite data")
worksheet2.write(0, 0, "Metabolite ID (as in SBML model)")
worksheet2.write(0, 1, "Minimal metabolite concentration [M]")
worksheet2.write(0, 2, "Maximal metabolite concentration [M]")
workbook.close()
# Enzyme stoichiometry XLSX :D
# Get gene rule <-> Reaction ID mapping
reaction_id_gene_rules_mapping = {}
for reaction in model.reactions:
listed_gene_rules = _gene_rule_as_list(reaction.gene_reaction_rule)
if listed_gene_rules != ['']:
reaction_id_gene_rules_mapping[reaction.id] = listed_gene_rules
# Write XLSX
workbook = xlsxwriter.Workbook(basepath+"_enzyme_stoichiometries.xlsx")
# Gene stoichiometry worksheets
worksheet_stoichiometry = workbook.add_worksheet("Stoichiometries of complexes")
line = 0
for reaction_id in reaction_id_gene_rules_mapping.keys():
gene_rule = reaction_id_gene_rules_mapping[reaction_id]
if gene_rule == [""]:
continue
worksheet_stoichiometry.write(line, 0, reaction_id)
row = 1
for or_part in gene_rule:
worksheet_stoichiometry.write(line, row, str(or_part))
if type(or_part) is str:
default_stoichiometry = "1"
else:
default_stoichiometry = ";".join(["1" for _ in range(len(or_part))])
worksheet_stoichiometry.write(line, row+1, default_stoichiometry)
row += 2
line += 1
workbook.close()
def create_gecko_model_reaction_wise(model: cobra.Model, output_sbml_name: str,
project_folder: str, project_name: str, excluded_reactions: List[str]) -> cobra.Model:
"""Creates a GECKO model as described in
<i>
Sánchez, B. J., Zhang, C., Nilsson, A., Lahtvee, P. J., Kerkhoven, E. J., & Nielsen, J. (2017).
Improving the phenotype predictions of a yeast genome‐scale metabolic model by incorporating enzymatic
constraints. Molecular systems biology, 13(8).
</i>
Arguments
----------
* model: cobra.Model ~ A cobra Model representation of the metabolic network. This model will
be changed using cobrapy functions in order to add the proteomic constraints.
* output_sbml_name: str ~ The base name of the created SBML.
* project_folder: str ~ The folder in which the spreadsheets and JSONs with the model's supplemental
data can be found.
* project_name: str ~ The sMOMENTed model creation's name, which will be added at the beginning
of the created SBML's name.
* excluded_reactions: List[str] ~ A string list of reaction IDs (the 'reverse' and 'forward'
name additions must not be added, i.e. for 'ACALD_forward' just 'ACALD' has to be given) to
which no kcat shall be added. Typically used for gas exchange reactions such as 'CO2tex'.
"""
# Standardize project folder
project_folder = standardize_folder(project_folder)
# This base path is the location were the generated files wil be stored
basepath: str = project_folder + project_name
# READ REACTIONS<->KEGG ID XLSX
protein_id_mass_mapping: Dict[str, float] = json_load(basepath+"_protein_id_mass_mapping.json")
# LOAD XLSX WITH PROTEIN DATA
# Load protein data XLSX
protein_id_concentration_mapping, p_total, unmeasured_protein_fraction, mean_saturation = \
read_protein_data_xlsx(basepath)
# Read enzyme kinetics xlsx
reaction_id_gene_rules_mapping, reaction_id_gene_rules_protein_stoichiometry_mapping = \
read_enzyme_stoichiometries_xlsx(basepath)
# Read reaction <-> kcat mapping :D
reactions_kcat_mapping_database = json_load(basepath + "_reactions_kcat_mapping_combined.json")
all_kcats = [x["forward"] for x in reactions_kcat_mapping_database.values()] + \
[x["reverse"] for x in reactions_kcat_mapping_database.values()]
all_kcats = [x for x in all_kcats if not math.isnan(x)]
default_kcat = statistics.median(all_kcats)
print(f"Default kcat is: {default_kcat}")
# GECKO :D #
# This ID addition will be added to all reactions which are modified by this method
id_addition = "_TG_"
# Calculate p_measured
p_measured = get_p_measured(protein_id_concentration_mapping, protein_id_mass_mapping)
# Make model irreversible
model = get_irreversible_model(model, id_addition)
# Add prot_pool reaction
model, prot_pool_metabolite = add_prot_pool_reaction(model, id_addition, p_total, p_measured,
unmeasured_protein_fraction, mean_saturation)
# Add enzyme source reaction for every unmeasured protein
for protein_id in list(protein_id_mass_mapping.keys()):
if protein_id in list(protein_id_concentration_mapping.keys()): # Measured
eu = cobra.Reaction(id=id_addition+"EU_"+protein_id,
name=f"Enzyme usage reaction of measured protein {protein_id}",
subsystem="AutoPACMEN")
enzyme = cobra.Metabolite(id=protein_id+"_met",
name=f"Protein {protein_id}",
compartment="AutoPACMEN")
eu.add_metabolites({enzyme: 1.0})
eu.lower_bound = 0
eu.upper_bound = protein_id_concentration_mapping[protein_id]
model.add_reactions([eu])
else: # Unmeasured
er = cobra.Reaction(id=id_addition+"ER_"+protein_id,
name=f"Enzyme usage reaction of unmeasured protein {protein_id}",
subsystem="AutoPACMEN")
enzyme = cobra.Metabolite(id=protein_id+"_met",
name=f"Protein {protein_id}",
compartment="AutoPACMEN")
molecular_weight = protein_id_mass_mapping[protein_id] / 1000 # Mapping is in Da, GECKO uses kDa (g/mmol)
er.add_metabolites({prot_pool_metabolite: -molecular_weight,
enzyme: 1})
er.lower_bound = 0
er.upper_bound = 1000.0
model.add_reactions([er])
# Add enzymes to reactions
current_arm_reaction = 1
model_reaction_ids = [x.id for x in model.reactions]
for model_reaction_id in model_reaction_ids:
reaction = model.reactions.get_by_id(model_reaction_id)
splitted_id = reaction.id.split(id_addition)
# If the reaction has no name, ignore it
if splitted_id[0] == "":
continue
# Take the reaction ID from the first part of the split
reaction_id = splitted_id[0]
# If the reaction has no associated enzyme stoichiometries, ignore it
if reaction_id not in list(reaction_id_gene_rules_mapping.keys()):
continue
# If the reaction has no gene rule, ignore it
gene_rule = reaction_id_gene_rules_mapping[reaction_id]
if gene_rule == [""]:
continue
# If the reaction is manually excluded, ignore it
if reaction_id in excluded_reactions:
continue
all_available = True
for enzyme in gene_rule:
if type(enzyme) == str:
try:
model.metabolites.get_by_id(enzyme+"_met")
except Exception:
all_available = False
break
else:
for enzyme_id in enzyme:
try:
model.metabolites.get_by_id(enzyme_id+"_met")
except Exception:
all_available = False
break
if not all_available:
continue
# Retrieve the reaction's forward and reverse kcats from the given reaction<->kcat database
if reaction_id in reactions_kcat_mapping_database.keys():
forward_kcat = reactions_kcat_mapping_database[reaction_id]["forward"]
reverse_kcat = reactions_kcat_mapping_database[reaction_id]["reverse"]
# If the reaction is not in the database, set the default kcat
else:
forward_kcat = default_kcat
reverse_kcat = default_kcat
# If the given reaction<->kcat database contains math.nan as the reaction's kcat,
# set the default kcat as math.nan means that no kcat could be found.
if math.isnan(forward_kcat):
forward_kcat = default_kcat
if math.isnan(reverse_kcat):
reverse_kcat = default_kcat
# Add the given forward or reverse kcat is the reaction was
# splitted due to its reversibility.
# If the reaction is not splitted, add the forward kcat (this
# is the only possible direction for non-splitted=non-reversible
# reactions)
if model_reaction_id.endswith(id_addition + "forward"):
reaction_kcat = forward_kcat
elif model_reaction_id.endswith(id_addition + "reverse"):
reaction_kcat = reverse_kcat
else:
reaction_kcat = forward_kcat
# Add arm reaction if isozymes occur
if len(gene_rule) > 1: # Isozymes occur :O
arm_reaction_id = id_addition+f"arm_reaction_{current_arm_reaction}"
arm_reaction_name = f"Arm reaction no. {current_arm_reaction} for gene rule {str(gene_rule)}"
arm_reaction = cobra.Reaction(id=arm_reaction_id,
name=arm_reaction_name,
subsystem="AutoPACMEN")
arm_reaction_metabolites = {}
for metabolite in list(reaction.metabolites.keys()):
stoichiometry = reaction.metabolites[metabolite]
if stoichiometry < 0: # Educt
arm_reaction_metabolites[metabolite] = stoichiometry
reaction.add_metabolites({metabolite: -stoichiometry})
im_id = f"im_{current_arm_reaction}"
im_name = f"Intermediate metabolite of arm reaction {current_arm_reaction}"
intermediate_metabolite = cobra.Metabolite(id=im_id,
name=im_name,
compartment="AutoPACMEN")
arm_reaction_metabolites[intermediate_metabolite] = 1
arm_reaction.add_metabolites(arm_reaction_metabolites)
reaction.add_metabolites({intermediate_metabolite: -1})
arm_reaction.lower_bound = 0
arm_reaction.upper_bound = reaction.upper_bound
model.add_reactions([arm_reaction])
current_arm_reaction += 1
# Add reactions depending on isozyme complex presence
new_reactions = []
i = 1
for isozyme_id in gene_rule:
new_reaction = copy.deepcopy(reaction)
new_reaction.id = new_reaction.id + id_addition + str(i)
protein_ids = []
if type(isozyme_id) is str: # No complex :O
protein = model.metabolites.get_by_id(isozyme_id+"_met")
reaction_id = reaction_id.split("_TG_")[0]
stoichiometry = reaction_id_gene_rules_protein_stoichiometry_mapping[reaction_id][isozyme_id][isozyme_id]
stoichiometry /= (reaction_kcat * 3600)
stoichiometry *= -1
metabolites = {}
metabolites[protein] = stoichiometry
protein_ids.append(isozyme_id)
new_reaction.add_metabolites(metabolites)
else: # Complex :O
metabolites = {}
isozyme_id = tuple(isozyme_id)
for single_id in isozyme_id:
protein = model.metabolites.get_by_id(single_id+"_met")
reaction_id = reaction_id.split("_TG_")[0]
stoichiometry = reaction_id_gene_rules_protein_stoichiometry_mapping[reaction_id][isozyme_id][single_id]
stoichiometry /= (reaction_kcat * 3600)
stoichiometry *= -1
metabolites[protein] = stoichiometry
protein_ids.append(single_id)
new_reaction.add_metabolites(metabolites)
gene_reaction_rule = " and ".join(protein_ids)
new_reaction.gene_reaction_rule = gene_reaction_rule
new_reactions.append(new_reaction)
i += 1
model.add_reactions(new_reactions)
model.remove_reactions([reaction])
cobra.io.write_sbml_model(model, project_folder+output_sbml_name)
return model
def get_reactions_kcat_mapping(sbml_path: str, project_folder: str,
project_name: str, organism: str,
kcat_database_path: str,
protein_kcat_database_path: str,
type_of_kcat_selection: str) -> None:
"""Returns a reaction<->kcat mapping for the given model :D
The selection of kcats is depending on the affected metabolites of the reaction direction (one
kcat is given for each the forward and reverse direction), and on the organism (the kcats
from the taxonomically nearest organism is prefered).
Arguments
----------
*sbml_path: str ~ Te SBML path to the model
*project_folder: str ~ The folder in which the model data files are sored
*project_name: str ~ The name of the used project
*organism: str ~ The organism's name
*kcat_database_path: str ~ A path to an already created EC number<->kcats database
*protein_kcat_database_path: str ~ A path to the custom protein<->kcat database
*type_of_kcat_selection: str ~ Can be "mean", "median" or "random". Refers to the selection of found kcats of a reaction.
Is "mean" by default.
Output
----------
A JSON in the given project folder with the name $project_name+'_reactions_kcat_mapping_combined.json' and
the following structure:
<pre>
{
"$REACTION_NAME": {
"forward": $forward_kcat,
"reverse": $reverse_kcat
},
(...)
}
</pre>
"""
# Standardize project folder
project_folder = standardize_folder(project_folder)
# Set the path for the output JSON
basepath = project_folder + project_name
# Load the combined, EC-number-dependent kcat database :D
kcat_database = json_load(kcat_database_path)
# If given, load the protein-dependent kcat database :D
if protein_kcat_database_path != "none":
protein_kcat_database = json_load(protein_kcat_database_path)
else:
protein_kcat_database = {}
# Load the given stoichiometric model
model = cobra.io.read_sbml_model(sbml_path)
# Set-up dictionary which will be the content of the output JSON
reactions_kcat_mapping: Dict[str, Dict[str, float]] = {}
# Go through each reaction in order to assign kcats for it :D
for reaction in model.reactions:
# If no EC number is given in the reaction's annotations,
# the protein-dependent database is read out in order to
# find a kcat. This only works if at least one of the assigned
# enzymes of the reaction's gene rule has a kcat in the
# protein-dependent database.
if "ec-code" not in reaction.annotation.keys():
# 0 means that no kcat can be assigned
forward_kcat: Any = 0
reverse_kcat: Any = 0
if protein_kcat_database != {}:
# Retrieve the kcats from the protein-dependent database :D
forward_kcat = _get_kcat_from_protein_kcat_database(
"forward", reaction, protein_kcat_database)
reverse_kcat = _get_kcat_from_protein_kcat_database(
"reverse", reaction, protein_kcat_database)
# If no kcat could be assigned, set the kcat to math.nan
# which indicates this case
if forward_kcat == 0.0:
forward_kcat = math.nan
if reverse_kcat == 0.0:
reverse_kcat = math.nan
# Add the retrieved forward and reverse kcats to the reaction<->kcat mapping dictionary :D
reactions_kcat_mapping[reaction.id] = {}
reactions_kcat_mapping[reaction.id]["forward"] = forward_kcat
reactions_kcat_mapping[reaction.id]["reverse"] = reverse_kcat
# Print the assigned kcats
_print_assigned_kcats(reaction.id, forward_kcat, reverse_kcat)
continue
# Retrieve the reaction's associated EC numbers
reaction_ids = reaction.annotation["ec-code"]
# If only one EC number is given, set the EC number string to
# a list in order to make it work with the following code lines
if type(reaction_ids) is str:
reaction_ids = [reaction_ids]
# Get all EC numbers which do not contain a - wildcard, such as
# in 2.1.1.-
# These wildcarded EC numbers are in general too permissive in order
# to get useful kcats
eligible_reaction_ids = [x for x in reaction_ids if "-" not in x]
if len(eligible_reaction_ids) == 0:
eligible_reaction_ids = [x for x in reaction_ids]
# Create a 'complete entry' from all eligible (i.e., non-wildcarded)
# EC numbers. This complete entry contains - for every organism
# and substrate given in the EC number kcat entries - all kcats
# of all eligible EC numbers. In addition, the pseudo-substrate
# "ALL" is added which contains all organisms. "ALL" is used
# later if no fitting substrate can be found.
complete_entry: Dict[str, Any] = {}
complete_entry["ALL"] = {}
# Go through each reaction ID :D
for reaction_id in eligible_reaction_ids:
# If the EC number could not be found in the given EC number<->kcat
# database, print it and proceed with the next eligible EC number
if reaction_id not in kcat_database.keys():
print(f"INFO: No entry for EC number {reaction_id}")
print("")
continue
# Otherwise, get the reaction ID entry from the given database :D
reaction_id_entry = kcat_database[reaction_id]
# Exclude all kcat entries which come from a wildcard search
# with *
if reaction_id_entry["WILDCARD"]:
continue
# Go trough each metabolite in the EC number<->kcat database entries
for metabolite_key in reaction_id_entry.keys():
# Ignore the keys which show additional information
# about the nature of the kcat data
if metabolite_key in ("WILDCARD", "SOURCE", "TRANSFER"):
continue
# Add the metabolite to the complete entry if it does not already occur
if metabolite_key not in complete_entry:
complete_entry[metabolite_key] = {}
# Go throudh each species in the currently analyzed EC number
for species_key in reaction_id_entry[metabolite_key]:
# Add the species to the metabolite entry if it does not already occur
if species_key not in complete_entry[metabolite_key]:
complete_entry[metabolite_key][species_key] = []
# ...and do the same for the pseudo-metabolite "ALL"
if species_key not in complete_entry["ALL"].keys():
complete_entry["ALL"][species_key] = []
# Add the list of kcats of the currently analyzed EC number to the current species
# and the current metabolite, and for "ALL"
complete_entry[metabolite_key][
species_key] += reaction_id_entry[metabolite_key][
species_key]
complete_entry["ALL"][species_key] += reaction_id_entry[
metabolite_key][species_key]
# If no entries with kcats could be found for any of the eligible EC numbers, continue with the next reaction.
if complete_entry["ALL"] == {}:
continue
# Get the BIGG IDs of the educts and products uusing the SBML's BIGG ID annotation
educt_bigg_ids: List[str] = []
for reactant in reaction.reactants:
if "bigg.metabolite" in reactant.annotation.keys():
educt_bigg_ids.append(reactant.annotation["bigg.metabolite"])
product_bigg_ids: List[str] = []
for product in reaction.products:
if "bigg.metabolite" in product.annotation.keys():
product_bigg_ids.append(product.annotation["bigg.metabolite"])
# If no bigg IDs could be found in the SBML, add the pseudo-metabolite "X"
# which indicated that "ALL" should be used later.
if len(educt_bigg_ids) == 0:
educt_bigg_ids = ["X"]
if len(product_bigg_ids) == 0:
product_bigg_ids = ["X"]
# Get the metabolites which are used in the subsequent forward kcat search
searched_educts = _get_searched_metabolites(complete_entry,
educt_bigg_ids)
# Get the forward kcat depending on the educts and the organism
forward_kcat = _get_kcat(searched_educts, complete_entry, organism,
"forward", reaction, protein_kcat_database,
type_of_kcat_selection)
# Get the metabolites which are used in the subsequent forward kcat search
searched_products = _get_searched_metabolites(complete_entry,
product_bigg_ids)
# Get the reverse kcat depending on the products and the organism
reverse_kcat = _get_kcat(searched_products, complete_entry, organism,
"reverse", reaction, protein_kcat_database,
type_of_kcat_selection)
# Set the found out kcats in the reactions<->kcat mapping :D
reactions_kcat_mapping[reaction.id] = {}
reactions_kcat_mapping[reaction.id]["forward"] = forward_kcat
reactions_kcat_mapping[reaction.id]["reverse"] = reverse_kcat
# display the found out kcats for this reaction \o/
_print_assigned_kcats(reaction.id, forward_kcat, reverse_kcat)
# Export the kcat mapping results as JSON :D
json_write(basepath + "_reactions_kcat_mapping_combined.json",
reactions_kcat_mapping)
def get_protein_mass_mapping(model: cobra.Model, project_folder: str,
project_name: str) -> None:
"""Returns a JSON with a mapping of protein IDs as keys, and as values the protein mass in kDa.
The protein masses are calculated using the amino acid sequence from UniProt (retrieved using
UniProt's REST API).
Arguments
----------
* model: cobra.Model ~ The model in the cobrapy format
* project_folder: str ~ The folder in which the JSON shall be created
* project_name: str ~ The beginning of the JSON's file name
Output
----------
A JSON file with the path project_folder+project_name+'_protein_id_mass_mapping.json'
and the following structure:
<pre>
{
"$PROTEIN_ID": $PROTEIN_MASS_IN_KDA,
(...),
}
</pre>
"""
# Standardize project folder
project_folder = standardize_folder(project_folder)
# The beginning of the created JSON's path :D
basepath: str = project_folder + project_name
# GET UNIPROT ID - PROTEIN MAPPING
uniprot_id_protein_id_mapping: Dict[str, List[str]] = {}
for gene in model.genes:
# Without a UniProt ID, no mass mapping can be found
if "uniprot" not in gene.annotation:
continue
uniprot_id = gene.annotation["uniprot"]
if uniprot_id in uniprot_id_protein_id_mapping.keys():
uniprot_id_protein_id_mapping[uniprot_id].append(gene.id)
else:
uniprot_id_protein_id_mapping[uniprot_id] = [gene.id]
# GET UNIPROT ID<->PROTEIN MASS MAPPING
uniprot_id_protein_mass_mapping: Dict[str, float] = {}
# The cache stored UniProt masses for already searched
# UniProt IDs (each file in the cache folder has the name
# of the corresponding UniProt ID). This prevents searching
# UniProt for already found protein masses. :-)
cache_basepath = "./_cache/uniprot/"
ensure_folder_existence("./_cache/")
ensure_folder_existence(cache_basepath)
cache_files = get_files(cache_basepath)
# Go through each batch of UniProt IDs (multiple UniProt IDs
# are searched at once in order to save an amount of UniProt API calls)
# and retrieve the amino acid sequences and using these sequences, their
# masses.
uniprot_ids = list(uniprot_id_protein_id_mapping.keys())
batch_size = 5
batch_start = 0
while batch_start < len(uniprot_ids):
# Create the batch with all UniProt IDs
prebatch = uniprot_ids[batch_start:batch_start + batch_size]
batch = []
# Remove all IDs which are present in the cache (i.e.,
# which were searched for already).
# The cache consists of pickled protein mass floats, each
# onein a file with the name of the associated protein.
for uniprot_id in prebatch:
if uniprot_id not in cache_files:
batch.append(uniprot_id)
else:
cache_filepath = cache_basepath + uniprot_id
uniprot_id_protein_mass_mapping[uniprot_id] = pickle_load(
cache_filepath)
print(uniprot_id + ":",
uniprot_id_protein_mass_mapping[uniprot_id])
# If all IDs could be found in the cache, continue with the next batch.
if len(batch) == 0:
batch_start += batch_size
continue
# Create the UniProt query for the batch
# With 'OR', all given IDs are searched, and subsequently in this script,
# the right associated masses are being picked.
query = " OR ".join(batch)
uniprot_query_url = f"https://www.uniprot.org/uniprot/?query={query}&format=tab&columns=id,sequence"
# Call UniProt's API :-)
uniprot_data = requests.get(uniprot_query_url).text.split("\n")
# Wait in order to cool down their server :-)
time.sleep(2.0)
# Read out the API-returned lines
for line in uniprot_data[1:]:
if line == "":
continue
uniprot_id = line.split("\t")[0]
sequence = line.split("\t")[1]
# Get the protein mass using biopython's associated function for amino acid sequences
mass = ProteinAnalysis(sequence,
monoisotopic=False).molecular_weight()
uniprot_id_protein_mass_mapping[uniprot_id] = float(mass)
# Create the pickled cache files for the searched protein masses
for uniprot_id in batch:
cache_filepath = cache_basepath + uniprot_id
pickle_write(cache_filepath,
uniprot_id_protein_mass_mapping[uniprot_id])
# Continue with the next batch :D
batch_start += batch_size
# Create the final protein ID <-> mass mapping
protein_id_mass_mapping: Dict[str, float] = {}
for uniprot_id in list(uniprot_id_protein_mass_mapping.keys()):
try:
protein_ids = uniprot_id_protein_id_mapping[uniprot_id]
except Exception:
print(f"No mass found for {uniprot_id}!")
continue
for protein_id in protein_ids:
protein_id_mass_mapping[
protein_id] = uniprot_id_protein_mass_mapping[uniprot_id]
# Write protein mass list JSON :D
json_write(basepath + "_protein_id_mass_mapping.json",
protein_id_mass_mapping)
def create_smoment_model_reaction_wise(
model: cobra.Model,
output_sbml_name: str,
project_folder: str,
project_name: str,
excluded_reactions: List[str],
type_of_default_kcat_selection: str = "median") -> None:
"""Adds proteomic constraints according to sMOMENT to the given stoichiometric model and stores it as SBML.
Arguments
----------
* model: cobra.Model ~ A cobra Model representation of the metabolic network. This model will
be changed using cobrapy functions in order to add the proteomic constraints.
* output_sbml_name: str ~ The base name of the created SBML.
* project_folder: str ~ The folder in which the spreadsheets and JSONs with the model's supplemental
data can be found.
* project_name: str ~ The sMOMENTed model creation's name, which will be added at the beginning
of the created SBML's name.
* excluded_reactions: List[str] ~ A string list of reaction IDs (the 'reverse' and 'forward'
name additions must not be added, i.e. for 'ACALD_forward' just 'ACALD' has to be given) to
which no kcat shall be added. Typically used for gas exchange reactions such as 'CO2tex'.
* type_of_default_kcat_selection: str ~ The type of selection of default kcat values. Can be "mean",
"median" or "random". Is "median" by default.
Output
----------
An SBML in the given folder with the given name, which describes the given stoichiometric model
enhanced by the protein constraint introduction with this function.
"""
# Standardize project folder
project_folder = standardize_folder(project_folder)
# Set folder path for newly created SBML and name for the reaction ID addition (added at the end,
# and used in order to have a programatically convinient way to separate additions such as 'reverse'
# from the 'actual' reaction ID).
basepath: str = project_folder + project_name
id_addition: str = "_TG_"
# READ REACTIONS<->KEGG ID XLSX
protein_id_mass_mapping: Dict[str, float] = json_load(
basepath + "_protein_id_mass_mapping.json")
# Load protein data XLSX
protein_id_concentration_mapping, p_total, unmeasured_protein_fraction, mean_saturation = \
read_protein_data_xlsx(basepath)
# Read enzyme stoichiometries xlsx
reaction_id_gene_rules_mapping, reaction_id_gene_rules_protein_stoichiometry_mapping = \
read_enzyme_stoichiometries_xlsx(basepath)
# Calculate p_measured
p_measured = get_p_measured(protein_id_concentration_mapping,
protein_id_mass_mapping)
# Split reactions with measured enzymes
model, reaction_id_gene_rules_mapping, reaction_id_gene_rules_protein_stoichiometry_mapping = \
get_model_with_separated_measured_enzyme_reactions(model,
protein_id_concentration_mapping,
reaction_id_gene_rules_mapping,
reaction_id_gene_rules_protein_stoichiometry_mapping,
excluded_reactions,
protein_id_mass_mapping)
# Make model irreversible, separating all reversible reactions to which a gene rule is given
# in order to save some reactions.
model = get_irreversible_model(model, id_addition)
# Add prot_pool reaction according to the given protein pool values
model, prot_pool_metabolite = add_prot_pool_reaction(
model, id_addition, p_total, p_measured, unmeasured_protein_fraction,
mean_saturation)
# Read reaction <-> kcat mapping :-)
reactions_kcat_mapping_database = json_load(
basepath + "_reactions_kcat_mapping_combined.json")
# sMOMENT :D
# Get all kcats which are not math.nan and calculate the median of them, which will be used as default kcat
all_kcats = [x["forward"] for x in reactions_kcat_mapping_database.values()] + \
[x["reverse"] for x in reactions_kcat_mapping_database.values()]
all_kcats = [x for x in all_kcats if not math.isnan(x)]
if type_of_default_kcat_selection == "median":
default_kcat = statistics.median(all_kcats)
elif type_of_default_kcat_selection == "mean":
default_kcat = statistics.mean(all_kcats)
elif type_of_default_kcat_selection == "random":
default_kcat = random.choice(all_kcats)
else:
print(
'ERROR: Argument type_of_default_kcat_selection must be either "median", "mean" or "random".'
)
sys.exit(-1)
print(f"Default kcat is: {default_kcat}")
# Get all reaction IDs of the given model
model_reaction_ids = [x.id for x in model.reactions]
# Add measured enzyme pseudo-metabolites and pseudo-reactions
for protein_id in protein_id_concentration_mapping.keys():
new_metabolite = cobra.Metabolite(
id="ENZYME_" + protein_id,
name="Pseudo-metabolite of protein " + protein_id,
compartment="sMOMENT")
max_protein_concentration = protein_id_concentration_mapping[
protein_id]
new_reaction = cobra.Reaction(
id="ENZYME_DELIVERY_" + protein_id,
name="Delivery reaction of pseudo-metabolite " + protein_id,
lower_bound=0,
upper_bound=max_protein_concentration)
new_reaction.add_metabolites({new_metabolite: 1})
model.add_reactions([new_reaction])
# Main loop :D, add enzyme constraints to reactions \o/
for model_reaction_id in model_reaction_ids:
# Get the reaction and split the ID at the ID addition
reaction = model.reactions.get_by_id(model_reaction_id)
splitted_id = reaction.id.split(id_addition)
# If the reaction has no name, ignore it
if splitted_id[0] == "":
continue
# Take the reaction ID from the first part of the split
reaction_id = splitted_id[0]
# Remove GPRSPLIT name addition from reactions with measured protein concentrations
if "_GPRSPLIT_" in reaction_id:
reaction_id = reaction_id.split("_GPRSPLIT_")[0]
# If the reaction has no associated enzyme stoichiometries, ignore it
if reaction_id not in list(reaction_id_gene_rules_mapping.keys()):
continue
# If the reaction has no gene rule, ignore it
gene_rule = reaction_id_gene_rules_mapping[reaction_id]
if gene_rule == [""]:
continue
# If the reaction is manually excluded, ignore it
if reaction_id in excluded_reactions:
continue
# Check if all proteins in the reaction's gene rule have a found mass
# This is not the case for e.g. spontaneous reactions which often get the pseudo-enzyme 's0001'
all_available = True
for enzyme in gene_rule:
if type(enzyme) == str:
if enzyme not in list(protein_id_mass_mapping.keys()):
print(enzyme)
all_available = False
break
else:
for enzyme_id in enzyme:
if enzyme_id not in list(protein_id_mass_mapping.keys()):
all_available = False
break
# If not all of the mass-checked enzymes have a found mass, ignore this reaction
if not all_available:
continue
# Retrieve the reaction's forward and reverse kcats from the given reaction<->kcat database
if reaction_id in reactions_kcat_mapping_database.keys():
forward_kcat = reactions_kcat_mapping_database[reaction_id][
"forward"]
reverse_kcat = reactions_kcat_mapping_database[reaction_id][
"reverse"]
# If the reaction is not in the database, set the default kcat
else:
forward_kcat = default_kcat
reverse_kcat = default_kcat
# If the given reaction<->kcat database contains math.nan as the reaction's kcat,
# set the default kcat as math.nan means that no kcat could be found.
if math.isnan(forward_kcat):
forward_kcat = default_kcat
if math.isnan(reverse_kcat):
reverse_kcat = default_kcat
# Add the given forward or reverse kcat is the reaction was
# splitted due to its reversibility.
# If the reaction is not splitted, add the forward kcat (this
# is the only possible direction for non-splitted=non-reversible
# reactions)
if model_reaction_id.endswith(id_addition + "forward"):
reaction_kcat = forward_kcat
elif model_reaction_id.endswith(id_addition + "reverse"):
reaction_kcat = reverse_kcat
else:
reaction_kcat = forward_kcat
# Add protein pool pseudo-metabolite depending on isozyme complex presence
stoichiometries: List[float] = [
] # List of selectable MW/kcat stoichiometries (the most conservative constraint will be chosen)
stoichiometry_enzyme_name_list: List[str] = [
] # List of enzyme names and stoichiometries (semicolon-separated) for a console report
for isozyme_id in gene_rule:
# If it's not a complex :O...
if type(isozyme_id) is str:
# ...get the reaction ID without the additions...
reaction_id = reaction_id.split("_TG_")[0]
# ...get the number of units for this protein...
number_units = reaction_id_gene_rules_protein_stoichiometry_mapping[
reaction_id][isozyme_id][isozyme_id]
stoichiometry = number_units
# ...and determine the protein pool stoichiometry by
# 1) Multiplying the number of units for this protein with its mass (converted from kDa to mDa, since the reaction
# flux is defined for mmol/(gDW*h) and not mol/(gDW*h))
stoichiometry *= (protein_id_mass_mapping[isozyme_id] / 1000)
# 2) Dividing it with the reaction's kcat (converted from 1/s to 1/h)
stoichiometry /= (reaction_kcat * 3600)
# 3) Setting the right direction (educt)
stoichiometry *= -1
stoichiometries.append(stoichiometry)
stoichiometry_enzyme_name_list.append(isozyme_id + ";" +
str(number_units))
# Add proteomics constraints
if isozyme_id in protein_id_concentration_mapping.keys():
enzyme_pseudo_metabolite = model.metabolites.get_by_id(
"ENZYME_" + isozyme_id)
stoichiometry = reaction_id_gene_rules_protein_stoichiometry_mapping[
reaction_id][isozyme_id][isozyme_id]
stoichiometry *= 1 / (reaction_kcat * 3600)
stoichiometry *= -1
reaction.add_metabolites(
{enzyme_pseudo_metabolite: stoichiometry})
# If it is a complex :O...
else:
# ...convert the complex IDs to a hashable tuple (used for the stoichiometry selection)...
isozyme_id = tuple(isozyme_id)
stoichiometry = 0
# ...go through each single ID of the complex...
stoichiometry_enzyme_name_list.append("")
for single_id in isozyme_id:
# ...get the reaction ID without additions...
reaction_id = reaction_id.split("_TG_")[0]
# ...get the number of units for this protein...
number_units = reaction_id_gene_rules_protein_stoichiometry_mapping[
reaction_id][isozyme_id][single_id]
single_stoichiometry = number_units
# ...and determine the protein pool stoichiometry addition by
# 1) Multiplying the number of units for this protein with its mass (converted from kDa to Da)
single_stoichiometry *= (
protein_id_mass_mapping[single_id] / 1000)
# 2) Dividing it with the reaction's kcat (converted from 1/s to 1/h)
single_stoichiometry /= (reaction_kcat * 3600)
# 3) Setting the right direction (educt)
single_stoichiometry *= -1
# 4) and add it to the complex's stoichiometry
stoichiometry += single_stoichiometry
# Add name of current single ID
stoichiometry_enzyme_name_list[
-1] += single_id + ";" + str(number_units) + " "
stoichiometry_enzyme_name_list[
-1] = stoichiometry_enzyme_name_list[-1].rstrip()
# Add to list of stoichiometries
stoichiometries.append(stoichiometry)
# Add proteomics constraints
for single_id in isozyme_id:
if single_id in protein_id_concentration_mapping.keys():
enzyme_pseudo_metabolite = model.metabolites.get_by_id(
"ENZYME_" + single_id)
stoichiometry = reaction_id_gene_rules_protein_stoichiometry_mapping[
reaction_id][isozyme_id][single_id]
stoichiometry *= 1 / (reaction_kcat * 3600)
stoichiometry *= -1
reaction.add_metabolites(
{enzyme_pseudo_metabolite: stoichiometry})
# Take the maximal stoichiometry (i.e., the one with the least cost since this one will usually be prefered
# anyway in an FBA).
metabolites = {}
max_stoichiometry = max(stoichiometries)
metabolites[prot_pool_metabolite] = max_stoichiometry
reaction.add_metabolites(metabolites)
selected_enzyme = stoichiometry_enzyme_name_list[stoichiometries.index(
max_stoichiometry)]
# Print report of selected kcat and molecular weight for this reaction
print("Reaction: ", model_reaction_id)
print("Selected kcat: ", reaction_kcat)
print("Selected molecular weight (kDa): ", end="")
if " " in selected_enzyme: # Multiple enzymes
mass_sum = .0
for single_enzyme in selected_enzyme.split(" "):
enzyme_name = single_enzyme.split(";")[0]
enzyme_unit_number = float(single_enzyme.split(";")[1])
mass_sum += protein_id_mass_mapping[
enzyme_name] * enzyme_unit_number
print(mass_sum)
else: # Single enzyme
enzyme_name = selected_enzyme.split(";")[0]
enzyme_unit_number = float(selected_enzyme.split(";")[1])
print(protein_id_mass_mapping[enzyme_name] * enzyme_unit_number)
# Output as SBML (without constraints due to cobrapy limitations)
cobra.io.write_sbml_model(model, project_folder + output_sbml_name)
def parse_brenda_textfile(brenda_textfile_path: str,
bigg_metabolites_json_folder: str,
json_output_path: str) -> None:
"""Goes through a BRENDA database textfile and converts it into a machine-readable JSON.
The JSON includes kcats for found organisms and substrates.
As of 29/04/2019, the BRENDA database can be downloaded as textfile under
https://www.brenda-enzymes.org/download_brenda_without_registration.php
The BRENDA database is not in a completely standardized format, so that this functions
contains many convoluted checks and circumventions of non-standardized data.
kcats from mutated enzymes are excluded.
Arguments
----------
* brenda_textfile_path: str ~ The BRENDA database text file path
* bigg_metabolites_json_folder: str ~ The folder in which the BIGG metabolites
database is stored (it has to have the name 'bigg_id_name_mapping.json').
* json_output_path: str ~ The path of the JSON that shall be created
Output
----------
* A JSON containing the BRENDA textfile kcat data in a machine-readable format:
<pre>
{
"$EC_NUMBER": {
"$SUBSTRATE_WITH_BIGG_ID_1": {
"$ORGANISM_1": [
$kcat_1,
(...)
$kcat_n,
]
},
(...),
"REST": {
"$ORGANISM_1": [
$kcat_1,
(...)
$kcat_n,
]
}
}
(...),
}
</pre>
'REST' stands for a substrate without found BIGG ID.
"""
# Standardize output folder
bigg_metabolites_json_folder = standardize_folder(
bigg_metabolites_json_folder)
# Load BIGG ID <-> metabolite name mapping :D
bigg_id_name_mapping: Dict[str,
str] = json_load(bigg_metabolites_json_folder +
"bigg_id_name_mapping.json")
# Load BRENDA textfile as list of strings without newlines :D
with open(brenda_textfile_path, "r", encoding="utf-8") as f:
lines = f.readlines()
lines = [x.replace("\n", "") for x in lines]
# Go through each line and collect the organism lines and kcat lines for each EC number
in_turnover_numbers = False
in_organism_reference = False
ec_number_kcat_lines_mapping: Dict[str, List[str]] = {}
ec_number_organsism_lines_mapping: Dict[str, List[str]] = {}
current_ec_number = ""
organism_lines: List[str] = []
kcat_lines: List[str] = []
i = 0
while i < len(lines):
line = lines[i]
if line.startswith("ID\t"):
if current_ec_number != "":
ec_number_organsism_lines_mapping[
current_ec_number] = organism_lines
ec_number_kcat_lines_mapping[current_ec_number] = kcat_lines
current_ec_number = line.replace("ID\t", "").replace(" ()", "")
organism_lines = []
kcat_lines = []
if len(line) == 0:
in_turnover_numbers = False
in_organism_reference = False
elif line.startswith("PROTEIN"):
in_organism_reference = True
i += 1
line = lines[i]
elif line.startswith("TURNOVER_NUMBER"):
in_turnover_numbers = True
i += 1
line = lines[i]
if in_organism_reference:
if line.startswith("PR"):
organism_lines.append("")
if len(organism_lines[-1]) > 0:
organism_lines[-1] += " "
organism_lines[-1] += " " + line
elif in_turnover_numbers:
if line.startswith("TN"):
kcat_lines.append("")
if len(kcat_lines[-1]) > 0:
kcat_lines[-1] += " "
kcat_lines[-1] += line
if len(line) == 0:
in_turnover_numbers = False
in_organism_reference = False
i += 1
# Create the BRENDA database dictionary using the collected kcat and organism lines
# of each EC number :D
ec_numbers = list(ec_number_kcat_lines_mapping.keys())
brenda_kcat_database: Dict[str, Any] = {}
for ec_number in ec_numbers:
if "(transferred to " in ec_number:
actual_ec_number = ec_number.split(" (transferred")[0]
try:
brenda_kcat_database[actual_ec_number] = {}
brenda_kcat_database[actual_ec_number]["TRANSFER"] = \
ec_number.lower().replace(" ", " ").split("(transferred to ec")[1].replace(")", "").lstrip()
except Exception:
# Some transfers go to general subgroups instead of single EC numbers so that
# no kcat database can be built from it D:
print("WARNING: BRENDA text file line " + ec_number +
" is not interpretable!")
continue
brenda_kcat_database[ec_number] = {}
reference_number_organism_mapping = {}
organism_lines = ec_number_organsism_lines_mapping[ec_number]
for organism_line in organism_lines:
reference_number = organism_line.split("#")[1]
organism_line_split_first_part = organism_line.split("# ")[1]
organism_line_split = organism_line_split_first_part.split(" ")
organism_line_split = [
x for x in organism_line_split if len(x) > 0
]
end = 1
for part in organism_line_split:
# Some organism names contain their SwissProt or UniProt ID,
# since we don't nned them they are excluded
if ("swissprot" in part.lower()) or \
(part.lower() == "and") or \
("uniprot" in part.lower()) or \
("genbank" in part.lower()) or \
("trembl" in part.lower()):
end -= 2
break
if ("<" in part) or ("(" in part):
end -= 1
break
end += 1
organism_name = " ".join(organism_line_split[:end])
reference_number_organism_mapping[reference_number] = organism_name
kcat_lines = ec_number_kcat_lines_mapping[ec_number]
for kcat_line in kcat_lines:
kcat_line = kcat_line
# Exclude kcats of mutated/changed proteins since
# they may not have a biological relevance
if ("mutant" in kcat_line.lower()) or ("mutated"
in kcat_line.lower()):
continue
reference_number = kcat_line.split("#")[1].split(",")[0]
organism = reference_number_organism_mapping[reference_number]
kcat_str = "".join(
kcat_line.split("#")[2]).split("{")[0].lstrip().rstrip()
kcat = max([float(x) for x in kcat_str.split("-") if len(x) > 0])
substrate = "".join(kcat_line.split("{")[1]).split("}")[0]
substrate = substrate.lower()
if substrate in bigg_id_name_mapping.keys():
substrate = bigg_id_name_mapping[substrate]
else:
substrate = "REST"
if substrate not in brenda_kcat_database[ec_number].keys():
brenda_kcat_database[ec_number][substrate] = {}
if organism not in brenda_kcat_database[ec_number][substrate].keys(
):
brenda_kcat_database[ec_number][substrate][organism] = []
brenda_kcat_database[ec_number][substrate][organism].append(kcat)
# Write final BRENDA kcat database :D
json_write(json_output_path, brenda_kcat_database)
