strainOptimizer 0.1.0__py3-none-any.whl

strainOptimizer/__init__.py

@@ -0,0 +1,12 @@
+# StrainOptimizer package
+from .strainDesign import (
+    strainOptimizer_engine,
+    WorkflowParameters,
+)
+
+
+__version__ = "0.1.0"
+__all__ = [
+    "strainOptimizer_engine",
+    "WorkflowParameters",
+]

strainOptimizer/analysis/FCC.py

@@ -0,0 +1,109 @@
+from strainOptimizer.simulation import mopa,moma
+
+def calculate_FCC_by_abundance(protID,model,productID,c_source='r_1714_REV', c_uptake=10, growthID='r_2111',objective='r_4046',objective_direction='max',delta_conc=1):
+    """
+    Calculate the flux control coefficient (FCC) for a given product and growth reaction by disturb enzyme abundance.
+
+    Args:
+        model (cobra.Model): The GEM model object.
+        c_source (str): The reaction ID of the carbon source uptake reaction. default is 'r_1714_REV' (glucose uptake).
+        c_uptake (float): The uptake rate of the carbon source.
+        productID (str): The reaction ID of the product output reaction.
+        growthID (str): The reaction ID of the growth reaction.
+        protID (str): The protein ID to calculate FCC for.
+        objective (str): The reaction ID of the objective reaction. default is NGAM (r_4046).
+        objective_direction (str): The direction of the objective reaction. 'max' or 'min'. default is 'max'.
+
+    Returns:
+        tuple: FCCg, FCCp
+    """
+
+    # calculate the reference strain by maximizing NGAM
+    # ref_growth=0.2
+    with model:
+        model.reactions.get_by_id(c_source).bounds = (c_uptake, c_uptake)  # set uptake rate
+        model.objective = growthID
+        model.objective_direction='max'
+        ref_growth=model.slim_optimize()/4  # set growth rate to 25% of max to allow for production
+        model.objective=productID
+        model.objective_direction='max'
+        max_production=model.slim_optimize()
+        ref_production=max_production/4
+        model.reactions.get_by_id(productID).bounds = (ref_production, 1000)
+        model.reactions.get_by_id(growthID).bounds = (ref_growth, 1000)  # set growth reaction bounds
+
+        model.objective = objective  # NGAM maximize as objective
+        model.objective_direction=objective_direction
+        ref_solution= model.optimize()
+
+    # calculate FCCg and FCCp
+    with model:
+        # overexpression for target protein
+        ref_conc=ref_solution.fluxes[protID]
+        new_conc=ref_conc*(1+delta_conc)  # increase protein concentration by delta_conc
+        # set the protein concentration
+        model.reactions.get_by_id(protID).lower_bound= new_conc
+
+        solution=mopa(model,reference_solution=ref_solution,linear=True)
+        # solution=moma(model,reference_solution=ref_solution,linear=False)
+
+        new_growth=solution.fluxes[growthID]
+        new_production=solution.fluxes[productID]
+
+    # FCCg
+    FCCg= ((new_growth-ref_growth)/ref_growth)/delta_conc
+    # calculate FCCp
+    FCCp=((new_production-ref_production)/ref_production)/delta_conc
+    # print('growth:',new_growth,'vs',ref_growth,'production:',new_production,'vs',ref_production)
+
+    return FCCg, FCCp
+
+
+def calculate_FCC_by_kcat(protID,model,productID, c_uptake=10, growthID='r_2111',delta_kcat=1):
+    '''
+    Calculate the flux control coefficient (FCC) for a given product and growth reaction by disturb enzyme kcat.
+    v/kcat<=protein_pool/MW
+    v/(kcat*(1+delta_kcat))<=protein_pool/MW
+    therefore, disturb kcat could be processed by modify the draw protein reaction coefficient
+    v/kcat<=protein_pool*(1+delta_kcat)/MW
+    v/kcat<=protein_pool/(MW/(1+delta_kcat))
+    MW'=MW/(1+delta_kcat)
+
+    Args:
+        model (cobra.Model): The GEM model object.
+        c_uptake (float): The uptake rate of the carbon source.
+        productID (str): The reaction ID of the product output reaction.
+        growthID (str): The reaction ID of the growth reaction.
+        protID (str): The protein ID to calculate FCC for.
+    '''
+    c_source='r_1714_REV'  # glucose uptake reaction
+    model.reactions.get_by_id(c_source).bounds = 0, c_uptake  # set uptake rate
+    with model:
+        model.objective=productID
+        model.objective_direction='max'
+        ref_production=model.slim_optimize()
+        
+        model.objective = growthID
+        model.objective_direction='max'
+        ref_growth=model.slim_optimize()
+    
+    # desturbe kcat
+    with model:
+        prot_pool=model.metabolites.get_by_id('prot_pool[c]')
+        ref_mw=model.reactions.get_by_id(protID).metabolites[prot_pool]
+        model.reactions.get_by_id(protID).metabolites[prot_pool]=ref_mw/(1+delta_kcat)
+
+        model.objective = productID
+        model.objective_direction='max'
+        new_production=model.slim_optimize()
+
+        model.objective = growthID
+        model.objective_direction='max'
+        new_growth=model.slim_optimize()
+
+    FCCg=((new_growth-ref_growth)/ref_growth)/delta_kcat
+    FCCp=((new_production-ref_production)/ref_production)/delta_kcat
+
+    return FCCg,FCCp
+
+    

strainOptimizer/analysis/__init__.py

@@ -0,0 +1,4 @@
+from .ecGEM_utils import prepare_prot_solution_for_ec, prepare_metabolic_solution_for_ec
+from .etfl_utils import prepare_prot_solution_for_etfl, prepare_metabolic_solution_for_etfl
+
+

strainOptimizer/analysis/dataset.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+'''Load standard datasets foe strain design algorithm evaluation
+'''
+
+import pandas as pd
+import os
+# get the path of this file
+FILE_PATH = os.path.dirname(os.path.abspath(__file__))
+def load_experiment_targets(product:str, data_dir=FILE_PATH+'/../../../data/experiment_targets'):
+    '''Load experiment targets for a specific product
+    '''
+    available_products = [f.replace('_exp_targets.tsv','') for f in os.listdir(data_dir) if f.endswith('_exp_targets.tsv')]
+    if product not in available_products:
+        print('Available products:', available_products)
+        raise ValueError('The product %s is not available!' % product)
+    else:
+        df = pd.read_csv(os.path.join(data_dir, product+'_exp_targets.tsv'), sep='\t', index_col=0)
+        return df
+
+
+def calculate_exp_consistency(predict_result, exp_data, show=True, merge_ko_kd=False):
+    '''
+    Calculate the experimental consistency of the prediction results by comparing the predicted gene targets with the experimental gene targets.
+
+    Args:
+        merge_ko_kd: if True, treat KO and KD as one down-regulation category ('KD') before comparison.
+    '''
+    predict_result = predict_result[predict_result['action'].isin(['OE', 'KD', 'KO'])].copy()
+    exp_data = exp_data.copy()
+
+    if merge_ko_kd:
+        predict_result['action'] = predict_result['action'].replace('KO', 'KD')
+        exp_data['action'] = exp_data['action'].replace('KO', 'KD')
+
+    predict_group = predict_result.groupby('action')
+    exp_group = exp_data.groupby('action')
+    exp_consistency = dict()
+    overall_exp_num = 0
+    overall_hit_num = 0
+    overall_predict_num = 0
+    for key in exp_group.groups.keys():
+        exp_geneList = exp_group.get_group(key).index.tolist()
+        try:
+            predict_geneList = predict_group.get_group(key).index.tolist()
+        except:
+            predict_geneList = []
+        hit_geneList = list(set(exp_geneList).intersection(set(predict_geneList)))
+        overall_exp_num += len(exp_geneList)
+        overall_hit_num += len(hit_geneList)
+        overall_predict_num += len(predict_geneList)
+        exp_consistency[key] = {'exp': exp_geneList, 'predict': predict_geneList, 'hit': hit_geneList,
+                                'exp_num': len(exp_geneList), 'hit_num': len(hit_geneList),
+                                'consistency': len(set(exp_geneList).intersection(set(hit_geneList))) / len(
+                                    exp_geneList)}
+    if overall_predict_num==0:
+        return None
+    exp_consistency['overall'] = {'exp_num': overall_exp_num, 'hit_num': overall_hit_num,
+                                  'predict_num': overall_predict_num,
+                                  'consistency': overall_hit_num / overall_exp_num,
+                                  'precision': overall_hit_num / overall_predict_num}
+
+    if show==True:
+        for key in exp_consistency.keys():
+            print(f'{key}:')
+            print(exp_consistency[key])
+
+    return exp_consistency
+
+
+def gene_id_to_name(geneIDlist,annotation_file=FILE_PATH+'/../../../data/s288c_geneNames.csv'):
+    df=pd.read_csv(annotation_file,index_col=0)
+    df_geneName=df[df.index.isin(geneIDlist)]['geneName']
+    return df_geneName

strainOptimizer/analysis/ecGEM_utils.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# date : 2024/3/20 
+# author : wangh
+import pandas as pd
+
+
+def prepare_prot_solution_for_ec(solution, enzymeIDlist=None):
+    '''Extract the protein abundances result from solution for ecGEM model.
+    parameters:
+        solution: Cobra solution
+        enzymeIDlist: a list of enzyme ID(optional)
+    return:
+        prots_solution: pd.Series, the protein abundances result
+        '''
+    prots_solution = pd.Series()
+
+    if enzymeIDlist is None:
+        for id in solution.fluxes.index:
+            if 'draw_prot_' in id:
+                prots_solution[id] = solution.fluxes[id]
+
+    else:
+        for enz in enzymeIDlist:
+            prots_solution[enz] = solution.fluxes[enz]
+
+    return prots_solution
+
+
+def prepare_metabolic_solution_for_ec(solution, rxnList=None):
+    '''Ectract all metabolic fluxes data result from solution for etfl model.
+    parameters:
+        solution: Cobra solution
+        rxnList: a list of reaction ID
+    return:
+        fluxes: pd.Series, the fluxes data
+    '''
+    metabolic_solution = pd.Series()
+    if rxnList is None:
+        for id in solution.fluxes.index:
+            if id.startswith('r_'):
+                metabolic_solution[id] = solution.fluxes[id]
+    else:
+        for rxn in rxnList:
+            if rxn in solution.fluxes.index:
+                metabolic_solution[rxn] = solution.fluxes[rxn]
+
+    return metabolic_solution

strainOptimizer/analysis/enzyme_variety_analysis.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+# date : 2023/3/18 
+# author : wangh
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+from pytfa.analysis.variability import _variability_analysis_element
+from ..etfl.optim.utils import safe_optim
+from cobra.flux_analysis import flux_variability_analysis
+from strainOptimizer.manipulation.constraint.enzyme import saturate_enzymes
+
+
+def etfl_EVA(model,target_id,enzymeIDlist,c_source,c_uptake,fraction_of_optimum=0.99,obj_direction='max'):
+    '''do enzyme variety analysis for ETFL model
+    para:
+        model: ETFL model
+        enzymeIDlist: a list of enzyme ID
+        fraction_of_optimum: Requires that the objective value is at least the
+            fraction times maximum objective value.Must be <= 1.0. (default 0.95)
+    return:
+        a dataframe of FVA result
+        '''
+    with model:
+        # fix substrate uptake
+        model.reactions.get_by_id(c_source).bounds = -c_uptake, -c_uptake
+
+        # 1.Optimize a given objective
+        model.objective = target_id
+        model.objective_direction = obj_direction
+        sol = safe_optim(model)
+        obj_value = sol.objective_value
+
+        # 1.5 saturate the model
+        all_rxnList = [reaction for reaction in model.reactions if type(reaction).__name__ == 'EnzymaticReaction']
+        all_rxnList = [reaction for reaction in all_rxnList if reaction.id.startswith('r_')]
+        rxnList=[]
+        for rxn in all_rxnList:
+            for enz in rxn.enzymes:
+                if enz.id in enzymeIDlist:
+                    rxnList.append(rxn)
+                    break
+        # remove duplicated rxns
+        rxnlist=list(set(rxnList))
+        model=saturate_enzymes(model,rxnList=rxnlist,sol=sol)
+
+        # 2. get all enzyme variable
+        all_enz = model.get_variables_of_type('EnzymeVariable')
+        all_enzIDlist = [enz.id for enz in all_enz]
+        # get the target enzyme list
+        target_enzlist = {}
+        for enzID in enzymeIDlist:
+            if enzID in all_enzIDlist:
+                target_enzlist[enzID] = model.enzymes.get_by_id(enzID).variable
+            else:
+                print(f"can't find Enzyme {enzID} in the {model.name}")
+
+        # 3. fix old objective value and add constraint
+        if model.solver.objective.direction == "max":
+            fva_old_objective = model.problem.Variable(
+                "fva_old_objective",
+                lb=fraction_of_optimum * obj_value,
+            )
+        else:
+            fva_old_objective = model.problem.Variable(
+                "fva_old_objective",
+                ub=fraction_of_optimum * obj_value,
+            )
+        fva_old_obj_constraint = model.problem.Constraint(
+            model.solver.objective.expression - fva_old_objective,
+            lb=0,
+            ub=0,
+            name="fva_old_objective_constraint",
+        )
+        model.add_cons_vars([fva_old_objective, fva_old_obj_constraint])
+        # model.repiar()
+
+        # 5.do enzyme variety analysis
+        results = {'min': {}, 'max': {}}
+        for sense in ['min', 'max']:
+            for k, var in tqdm(target_enzlist.items(), desc=sense + 'imizing'):
+                model.logger.debug(sense + '-' + k)
+                results[sense][k] = _variability_analysis_element(model, var, sense)
+
+        # 6.remove fixed constraint and old objective
+        model.remove_cons_vars([fva_old_objective, fva_old_obj_constraint])
+        # restore old objective
+        model.objective = target_id
+
+    df = pd.DataFrame(results)
+    df.rename(columns={'min': 'minimum', 'max': 'maximum'}, inplace=True)
+
+    return df
+
+
+def ecGEM_EVA(model,target_id,enzymeIDlist,c_source,c_uptake,fraction_of_optimum=1,obj_direction='max'):
+    '''do enzyme variety analysis for ecGEM
+       para:
+           model: ecGEM model
+           enzymeIDlist: a list of enzyme ID
+           fraction_of_optimum: Requires that the objective value is at least the
+               fraction times maximum objective value.Must be <= 1.0. (default 0.95)
+       return:
+           a dataframe of FVA result
+           '''
+    # fix substrate uptake
+    model.reactions.get_by_id(c_source).bounds = c_uptake, c_uptake
+
+    # set the objective function
+    model.objective = target_id
+    model.objective_direction = obj_direction
+
+    df_fva_result=flux_variability_analysis(model=model,reaction_list=enzymeIDlist,fraction_of_optimum=fraction_of_optimum)
+
+    return df_fva_result
+
+
+def enzymeVA(model,target_id,enzymeIDlist,c_source,c_uptake,fraction_of_optimum=0.99,obj_direction='max',model_type='etfl'):
+    '''do enzyme variety analysis for ecGEM/ETFL model
+    para:
+        model: ecGEM/ETFL model
+        target_id: the target reaction ID
+        enzymeIDlist: a list of enzyme ID
+        c_source: the carbon source ID
+        c_uptake: the carbon source uptake rate(default=1 mmol/gDW/h)
+        fraction_of_optimum: Requires that the objective value is at least the
+            fraction times maximum objective value.Must be <= 1.0. (default 0.99)
+        obj_direction: the direction of the objective function(default='max')
+        model_type: the type of the model(default='etfl')
+
+    return:
+        a dataframe of FVA result
+        '''
+
+    if model_type=='etfl':
+        eva_result= etfl_EVA(model=model,target_id=target_id,enzymeIDlist=enzymeIDlist,c_source=c_source,c_uptake=c_uptake,fraction_of_optimum=fraction_of_optimum,obj_direction=obj_direction)
+    elif model_type=='ecGEM':
+        eva_result=ecGEM_EVA(model=model,target_id=target_id,enzymeIDlist=enzymeIDlist,c_source=c_source,c_uptake=c_uptake,fraction_of_optimum=fraction_of_optimum,obj_direction=obj_direction)
+
+    return eva_result

strainOptimizer/analysis/etfl_utils.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# date : 2024/3/20 
+# author : wangh
+import pandas as pd
+
+
+def prepare_prot_solution_for_etfl(solution,enzymeIDlist=None):
+    '''Extract the protein abundances result from solution for ecGEM model.
+    parameters:
+        solution: Cobra solution
+        enzymeIDlist: a list of enzyme ID(optional)
+    return:
+        prots_solution: pd.Series, the protein abundances result
+        '''
+    prots_solution = pd.Series()
+
+    if enzymeIDlist is None:
+        for id in solution.raw.index:
+            if id.startswith('EZ_'):
+                prots_solution[id]=solution.raw[id]
+
+    else:
+        for enz in enzymeIDlist:
+            prots_solution[enz]=solution.raw[enz]
+
+    return prots_solution
+
+
+def prepare_metabolic_solution_for_etfl(solution, rxnList=None, flux_tol=1e-6):
+    '''Extract metabolic fluxes from an ETFL solution for use as MOMA reference.
+
+    Only reactions with |flux| > flux_tol are returned. Filtering out near-zero
+    fluxes avoids over-constraining the MOMA problem when the perturbed model
+    has a slightly different feasible region.
+
+    parameters:
+        solution: pyTFA solution
+        rxnList: a list of reaction IDs (None = all r_ reactions)
+        flux_tol: minimum absolute flux to include (default 1e-6)
+    return:
+        fluxes: pd.Series, the fluxes data
+    '''
+    metabolic_solution = pd.Series(dtype=float)
+    if rxnList is None:
+        for id in solution.fluxes.index:
+            if id.startswith('r_') and abs(solution.fluxes[id]) > flux_tol:
+                metabolic_solution[id] = solution.fluxes[id]
+    else:
+        for rxn in rxnList:
+            if rxn in solution.fluxes.index and abs(solution.fluxes[rxn]) > flux_tol:
+                metabolic_solution[rxn] = solution.fluxes[rxn]
+
+    return metabolic_solution
+

strainOptimizer/analysis/flux_variety_analysis.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-