gsrap 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

gsrap/commons/memoteutils.py

@@ -0,0 +1,132 @@
+import os
+import contextlib
+import importlib.metadata 
+
+
+
+import memote
+
+
+
+
+def get_memote_results_dict(logger, model):
+    
+    
+    logger.info(f"Running selected modules of MEMOTE v{importlib.metadata.metadata('memote')['Version']}...")
+
+
+    # launch memote (only relevant modules)        
+    with open(os.devnull, 'w') as devnull:
+        with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
+            try: memote_report = memote.suite.api.test_model(model, exclusive=[
+                'test_annotation', 
+                'test_sbo',
+                'test_stoichiometric_consistency',
+                'test_reaction_mass_balance',
+                'test_reaction_charge_balance',
+                'test_find_disconnected',
+                'test_find_reactions_unbounded_flux_default_condition'], results=True)
+            except ValueError: memote_report = None
+            
+
+    # parse memote's results
+    results_dict = {}
+    results_dict['version'] = importlib.metadata.version("memote")
+    test_results = dict(memote_report[1])['tests']
+    sections = {
+        'consistency': [
+            ('test_stoichiometric_consistency', 3),
+            ('test_reaction_mass_balance', 1),
+            ('test_reaction_charge_balance', 1),
+            ('test_find_disconnected', 1),
+            ('test_find_reactions_unbounded_flux_default_condition', 1)
+        ],
+        'annotation_M': [
+            ('test_metabolite_annotation_presence', 1),
+            ('test_metabolite_annotation_overview', 1),
+            ('test_metabolite_annotation_wrong_ids', 1),
+            ('test_metabolite_id_namespace_consistency', 1),
+        ],
+        'annotation_R': [
+            ('test_reaction_annotation_presence', 1),
+            ('test_reaction_annotation_overview', 1),
+            ('test_reaction_annotation_wrong_ids', 1),
+            ('test_reaction_id_namespace_consistency', 1),
+        ],
+        'annotation_G': [
+            ('test_gene_product_annotation_presence', 1),
+            ('test_gene_product_annotation_overview', 1),
+            ('test_gene_product_annotation_wrong_ids', 1),
+        ],
+        'annotation_SBO': [
+            ('test_metabolite_sbo_presence', 1),
+            ('test_metabolite_specific_sbo_presence', 1),
+            ('test_reaction_sbo_presence', 1),
+            ('test_metabolic_reaction_specific_sbo_presence', 1),
+            ('test_transport_reaction_specific_sbo_presence', 1),
+            ('test_exchange_specific_sbo_presence', 1),
+            ('test_demand_specific_sbo_presence', 1),
+            ('test_sink_specific_sbo_presence', 1),
+            ('test_gene_sbo_presence', 1),
+            ('test_gene_specific_sbo_presence', 1),
+            ('test_biomass_specific_sbo_presence', 1),
+        ],
+    }
+    section_multipliers = {
+        'consistency': 3,
+        'annotation_M': 1,
+        'annotation_R': 1,
+        'annotation_G': 1,
+        'annotation_SBO': 2,
+    }
+    
+    
+    numerator_total = 0
+    denominator_total = 0
+    for section, metrics in sections.items(): 
+        numerator = 0
+        denominator = 0
+        results_dict[section] = {}
+        
+        
+        # iterate metrics of this section: 
+        for metric, metric_multiplier in metrics:
+            metric_raw = test_results[metric]['metric']
+            
+            
+            # no subcategories here: 
+            if type(metric_raw) == float: 
+                metric_percentage = ((1- metric_raw ) *100)
+                numerator = numerator + (metric_percentage * metric_multiplier)
+                denominator = denominator + metric_multiplier
+                results_dict[section][metric] = round(metric_percentage, 1)
+                                
+            
+            # there are subcategories (like in the case of M/R/G/SBO annots)
+            else:   
+                results_dict[section][metric] = {}
+                for key, value in metric_raw.items():
+                    n_subcategories = len(metric_raw)
+                    multiplier_corrected = metric_multiplier / n_subcategories
+                    metric_percentage = ((1- value ) *100)
+                    numerator = numerator + (metric_percentage * multiplier_corrected)
+                    denominator = denominator + multiplier_corrected
+                    results_dict[section][metric][key] = round(metric_percentage, 1)
+                    
+                    
+        # compute the subtotal:
+        sub_total = numerator / denominator
+        results_dict[section]['sub_total'] = int(round(sub_total, 0))
+        
+        
+        # compute the total:
+        denominator_total = denominator_total + section_multipliers[section] *denominator
+        numerator_total = numerator_total + section_multipliers[section] *numerator 
+    total = numerator_total / denominator_total
+    results_dict['total'] = int(round(total, 0))
+
+
+    logger.info(f"Done! MEMOTE Total Score: {results_dict['total']}%.")
+    
+    
+    return results_dict

gsrap/mkmodel/.ipynb_checkpoints/mkmodel-checkpoint.py

@@ -41,8 +41,15 @@ from ..commons import log_unbalances
 from ..commons import format_expansion
 from ..commons import comparative_table
 from ..commons import download_keggorg
+from ..commons import initialize_model
+from ..commons import get_memote_results_dict
+
 
 from ..runsims.biosynth import biosynthesis_on_media
+from ..runsims.simplegrowth import grow_on_media
+
+from ..parsedb.cycles import verify_egc_all
+
 
 
 
@@ -100,7 +107,7 @@ def create_model_incore(params):
 
     ###### GAPFILLING
     # force inclusion of reactions:  
-    include_forced(logger, model, universe, args.force_inclusion)
+    include_forced(logger, model, universe, args.include)
 
     # remove missing conditional precursors + get the 'cond_col_dict' dict.
     # 'cond_col_dict' is str-to-str: {'pheme_c': 'M00868: 1/8; M00121: 2/12;', 'hemeO_c': 'gr_HemeO: 0/1'}
@@ -111,15 +118,15 @@ def create_model_incore(params):
     if response == 1: return 1
 
     # gap-fill based on media:
-    df_B = gapfill_on_media(logger, model, universe, dbexp, args.gap_fill, cond_col_dict, args.exclude_orphans)
+    df_B = gapfill_on_media(logger, model, universe, dbexp, args.gapfill, cond_col_dict, args.excludeorp)
     if type(df_B)==int: return 1
 
     # force removal of reactions
-    setattr(args, 'force_removal', '-')  # experimental feature, not public. It's main purpose was to test gap-filling in biolog_on_media().
-    remove_forced(logger, model, universe, args.force_removal)
+    setattr(args, 'remove', '-')  # experimental feature, not public. It's main purpose was to test gap-filling in biolog_on_media().
+    remove_forced(logger, model, universe, args.remove)
 
     # perform Biolog(R) curation based on media
-    df_P = biolog_on_media(logger, model, universe, dbexp, args.gap_fill, args.biolog, args.exclude_orphans, args.cnps)
+    df_P = biolog_on_media(logger, model, universe, dbexp, args.gapfill, args.biolog, args.excludeorp, args.cnps)
     if type(df_P)==int: return 1
 
 
@@ -139,9 +146,12 @@ def create_model_incore(params):
 
 
     
-    ###### CHECKS
+    ###### CHECKS 1
+    # check erroneous EGCs
+    verify_egc_all(logger, model, args.outdir)
+    
     # check blocked metabolites / dead-ends
-    df_S = biosynthesis_on_media(logger, model, dbexp, args.gap_fill, args.biosynth)
+    df_S = biosynthesis_on_media(logger, model, dbexp, args.gapfill, args.biosynth)
     if type(df_S)==int: return 1
 
 
@@ -149,6 +159,16 @@ def create_model_incore(params):
     ###### POLISHING 3
     # reset growth environment befor saving the model
     gempipe.reset_growth_env(model)
+    
+    # initialize model
+    response = initialize_model(logger, model, dbexp, args.initialize, args.gapfill)
+    if response==1: return 1
+
+
+
+    ###### CHECKS 2
+    # compute Memote metrics
+    memote_results_dict = get_memote_results_dict(logger, model)
 
 
     
@@ -159,7 +179,7 @@ def create_model_incore(params):
     cobra.io.write_sbml_model(model, f'{args.outdir}/{model.id}.xml')        # SBML   # groups are saved only to SBML
     logger.info(f"'{args.outdir}/{model.id}.xml' created!")
     force_id_on_sbml(f'{args.outdir}/{model.id}.xml', model.id)   # force introduction of the 'id=""' field
-    sheets_dict = write_excel_model(model, f'{args.outdir}/{model.id}.mkmodel.xlsx', args.nofigs, None, df_B, df_P, df_S)  
+    sheets_dict = write_excel_model(model, f'{args.outdir}/{model.id}.mkmodel.xlsx', args.nofigs, memote_results_dict, None, df_B, df_P, df_S)  
     logger.info(f"'{args.outdir}/{model.id}.mkmodel.xlsx' created!")
         
         

gsrap/mkmodel/mkmodel.py

@@ -41,8 +41,15 @@ from ..commons import log_unbalances
 from ..commons import format_expansion
 from ..commons import comparative_table
 from ..commons import download_keggorg
+from ..commons import initialize_model
+from ..commons import get_memote_results_dict
+
 
 from ..runsims.biosynth import biosynthesis_on_media
+from ..runsims.simplegrowth import grow_on_media
+
+from ..parsedb.cycles import verify_egc_all
+
 
 
 
@@ -100,7 +107,7 @@ def create_model_incore(params):
 
     ###### GAPFILLING
     # force inclusion of reactions:  
-    include_forced(logger, model, universe, args.force_inclusion)
+    include_forced(logger, model, universe, args.include)
 
     # remove missing conditional precursors + get the 'cond_col_dict' dict.
     # 'cond_col_dict' is str-to-str: {'pheme_c': 'M00868: 1/8; M00121: 2/12;', 'hemeO_c': 'gr_HemeO: 0/1'}
@@ -111,15 +118,15 @@ def create_model_incore(params):
     if response == 1: return 1
 
     # gap-fill based on media:
-    df_B = gapfill_on_media(logger, model, universe, dbexp, args.gap_fill, cond_col_dict, args.exclude_orphans)
+    df_B = gapfill_on_media(logger, model, universe, dbexp, args.gapfill, cond_col_dict, args.excludeorp)
     if type(df_B)==int: return 1
 
     # force removal of reactions
-    setattr(args, 'force_removal', '-')  # experimental feature, not public. It's main purpose was to test gap-filling in biolog_on_media().
-    remove_forced(logger, model, universe, args.force_removal)
+    setattr(args, 'remove', '-')  # experimental feature, not public. It's main purpose was to test gap-filling in biolog_on_media().
+    remove_forced(logger, model, universe, args.remove)
 
     # perform Biolog(R) curation based on media
-    df_P = biolog_on_media(logger, model, universe, dbexp, args.gap_fill, args.biolog, args.exclude_orphans, args.cnps)
+    df_P = biolog_on_media(logger, model, universe, dbexp, args.gapfill, args.biolog, args.excludeorp, args.cnps)
     if type(df_P)==int: return 1
 
 
@@ -139,9 +146,12 @@ def create_model_incore(params):
 
 
     
-    ###### CHECKS
+    ###### CHECKS 1
+    # check erroneous EGCs
+    verify_egc_all(logger, model, args.outdir)
+    
     # check blocked metabolites / dead-ends
-    df_S = biosynthesis_on_media(logger, model, dbexp, args.gap_fill, args.biosynth)
+    df_S = biosynthesis_on_media(logger, model, dbexp, args.gapfill, args.biosynth)
     if type(df_S)==int: return 1
 
 
@@ -149,6 +159,16 @@ def create_model_incore(params):
     ###### POLISHING 3
     # reset growth environment befor saving the model
     gempipe.reset_growth_env(model)
+    
+    # initialize model
+    response = initialize_model(logger, model, dbexp, args.initialize, args.gapfill)
+    if response==1: return 1
+
+
+
+    ###### CHECKS 2
+    # compute Memote metrics
+    memote_results_dict = get_memote_results_dict(logger, model)
 
 
     
@@ -159,7 +179,7 @@ def create_model_incore(params):
     cobra.io.write_sbml_model(model, f'{args.outdir}/{model.id}.xml')        # SBML   # groups are saved only to SBML
     logger.info(f"'{args.outdir}/{model.id}.xml' created!")
     force_id_on_sbml(f'{args.outdir}/{model.id}.xml', model.id)   # force introduction of the 'id=""' field
-    sheets_dict = write_excel_model(model, f'{args.outdir}/{model.id}.mkmodel.xlsx', args.nofigs, None, df_B, df_P, df_S)  
+    sheets_dict = write_excel_model(model, f'{args.outdir}/{model.id}.mkmodel.xlsx', args.nofigs, memote_results_dict, None, df_B, df_P, df_S)  
     logger.info(f"'{args.outdir}/{model.id}.mkmodel.xlsx' created!")
         
         

gsrap/parsedb/.ipynb_checkpoints/cycles-checkpoint.py

@@ -0,0 +1,128 @@
+import warnings 
+import os
+import logging
+
+
+import cobra
+import gempipe
+
+
+from ..commons import fba_no_warnings
+from ..commons import get_optthr
+
+
+
+def verify_egc(logger, model, mid, outdir): 
+
+    
+    # changes as not permament: 
+    found_egc = False
+    with model: 
+        
+        # close (0; 0) all the exchange reactions: 
+        gempipe.close_boundaries(model)
+        
+                
+        # create a dissipation reaction: 
+        dissip = cobra.Reaction(f'__dissip__{mid}')
+        model.add_reactions([dissip])
+        dissip = model.reactions.get_by_id(f'__dissip__{mid}')
+        
+        
+        # define the dissipation reaction:
+        modeled_mids = [m.id for m in model.metabolites]
+        if   mid == 'atp':
+            dissip_string = 'atp_c + h2o_c --> adp_c + pi_c + h_c'
+        elif mid == 'ctp':
+            dissip_string = 'ctp_c + h2o_c --> cdp_c + pi_c + h_c'
+        elif mid == 'gtp':
+            dissip_string = 'gtp_c + h2o_c --> gdp_c + pi_c + h_c'
+        elif mid == 'utp':
+            dissip_string = 'utp_c + h2o_c --> udp_c + pi_c + h_c'
+        elif mid == 'itp':
+            dissip_string = 'itp_c + h2o_c --> idp_c + pi_c + h_c'
+        elif mid == 'nadh':
+            dissip_string = 'nadh_c --> nad_c + h_c'
+        elif mid == 'nadph':
+            dissip_string = 'nadph_c --> nadp_c + h_c'
+        elif mid == 'fadh2':
+            dissip_string = 'fadh2_c --> fad_c + 2.0 h_c'
+        elif mid == 'accoa':
+            dissip_string = 'accoa_c + h2o_c --> ac_c + coa_c + h_c'
+        elif mid == 'glu__L':
+            dissip_string = 'glu__L_c + h2o_c --> akg_c + nh4_c + 2.0 h_c'
+        elif mid == 'q8h2':
+            dissip_string = 'q8h2_c --> q8_c + 2.0 h_c'
+        dissip.build_reaction_from_string(dissip_string)
+        
+        
+        # set the objective and optimize: 
+        model.objective = f'__dissip__{mid}'
+        res, obj_value, status = fba_no_warnings(model)
+        
+        
+        # apply the threshold:
+        obj_value = res.objective_value
+        status = res.status
+        if status == 'optimal' and obj_value >= get_optthr():
+            found_egc = True
+                
+
+            # get suspect !=0 fluxes 
+            fluxes = res.fluxes
+            # get interesting fluxes (get_optthr() tries to take into account the approximation in glpk and cplex solvers)
+            fluxes_interesting = fluxes[(fluxes > get_optthr()) | (fluxes < -get_optthr())]
+            
+
+            # create a model for escher, remove Rs not beloning to the cycle
+            model_copy = model.copy()
+            all_rids = [r.id for r in model_copy.reactions]
+            to_delete = set(all_rids) - set(fluxes_interesting.index)
+
+
+            # trick to avoid the WARNING "cobra/core/group.py:147: UserWarning: need to pass in a list" 
+            # triggered when trying to remove reactions that are included in groups. 
+            with warnings.catch_warnings():  # temporarily suppress warnings for this block
+                warnings.simplefilter("ignore")  # ignore all warnings
+                cobra_logger = logging.getLogger("cobra.util.solver")
+                old_level = cobra_logger.level
+                cobra_logger.setLevel(logging.ERROR)   
+                
+                # triggering code
+                model_copy.remove_reactions(to_delete)  # should work also with IDs
+
+                # restore original behaviour: 
+                cobra_logger.setLevel(old_level) 
+                
+                
+            # save JSON to direct import in Escher:
+            outfile = os.path.join(outdir, f'EGC_{mid}.json')
+            cobra.io.save_json_model(model_copy, outfile)
+
+
+            # log some messages
+            rid_labels = []
+            for rid, flux in fluxes_interesting.to_dict().items():
+                rid_label = "'" + rid + "'" 
+                # mark reversible reactions composing the cycle:
+                r = model.reactions.get_by_id(rid)
+                if r.lower_bound < 0 and r.upper_bound > 0:
+                    rid_label = rid_label + '(<=>)'
+                rid_labels.append(rid_label)
+            logger.warning(f"Found erroneous EGC (N={len(model_copy.reactions)}) for '{mid}' (f={obj_value}): [{', '.join(rid_labels)}]. EGC saved to '{outfile}' to be inspected with Escher-FBA.")
+            
+            
+    return found_egc
+
+
+
+def verify_egc_all(logger, model, outdir='./', mids_to_check=['atp','ctp','gtp','utp','itp','nadh','nadph','fadh2','accoa','glu__L','q8h2']):
+
+    
+    all_results = []
+    for mid in mids_to_check:
+        all_results.append(verify_egc(logger, model, mid, outdir))
+    if any(all_results)==False:
+        logger.info("Found 0 erroneous energy-generating cycles (EGCs).")
+        
+        

gsrap/parsedb/.ipynb_checkpoints/introduce-checkpoint.py

@@ -287,15 +287,7 @@ def introduce_transporters(logger, db, model, idcollection_dict, kegg_reaction_t
         r = model.reactions.get_by_id(f'EX_{mid_e}')
         r.name = f"Exchange for {model.metabolites.get_by_id(mid_e).name}"
         r.build_reaction_from_string(f'{mid_e} --> ')
-        if mid_e in [
-            # basics:
-            'glc__D_e', 'nh4_e', 'pi_e', 'so4_e', 'h2o_e', 'h_e', 'o2_e', 'co2_e',
-            # metals: 
-            'cu2_e', 'mobd_e', 'fe2_e', 'cobalt2_e',
-        ]:
-            r.bounds = (-1000, 1000)
-        else:
-            r.bounds = (0, 1000)
+        r.bounds = (0, 1000)
             
         # add SBO annotation
         r.annotation['sbo'] = ['SBO:0000627']  # exchange reaction    

gsrap/parsedb/.ipynb_checkpoints/manual-checkpoint.py

@@ -19,6 +19,33 @@ def get_rids_with_mancheck_gpr():
     return rids_mancheck_gpr
 
 
+def get_rids_with_mancheck_balancing():
+    rids_mancheck_bal = [  # same reactions involving ATP can be reversible
+        
+        # SECTION "reversible both in KEGG and MetaCyc"
+        'PGK', 'SUCOAS', 'ADK1', 'GK1', 'NNATr', 'CYTK1', 'ACKr',
+        'DGK1', 'PPAKr', 'ATPSr', 'NDPK10',
+        
+        ### SECTION "reversible in KEGG but not in MetaCyc" ###
+        'CYTK2',  # clearly reversible in KEGG but not in MetaCyc (RXN-7913)
+        'DADK',  # clearly reversible in KEGG but not in MetaCyc (DEOXYADENYLATE-KINASE-RXN)
+        'UMPK',  # clearly reversible in KEGG but not in MetaCyc (RXN-12002)
+        'NDPK1',  # clearly reversible in KEGG but not in MetaCyc (GDPKIN-RXN)
+        'NDPK2',  # clearly reversible in KEGG but not in MetaCyc (UDPKIN-RXN)  
+        'NDPK3',  # clearly reversible in KEGG but not in MetaCyc (CDPKIN-RXN)
+        'NDPK4',  # clearly reversible in KEGG but not in MetaCyc (DTDPKIN-RXN)
+        'NDPK5',  # clearly reversible in KEGG but not in MetaCyc (DGDPKIN-RXN)
+        'NDPK6',  # clearly reversible in KEGG but not in MetaCyc (DUDPKIN-RXN)
+        'NDPK7',  # clearly reversible in KEGG but not in MetaCyc (DCDPKIN-RXN)
+        'NDPK8',  # clearly reversible in KEGG but not in MetaCyc (DADPKIN-RXN)
+        'NDPK9',  # clearly reversible in KEGG but not in MetaCyc (RXN-14120) 
+        
+        ### SECTION "missing reversibility info" ###
+        'LPHERA',  
+    ]
+    return rids_mancheck_bal
+
+
 
 def get_manual_sinks():
     

gsrap/parsedb/.ipynb_checkpoints/parsedb-checkpoint.py

@@ -18,6 +18,9 @@ from ..commons import adjust_biomass_precursors
 from ..commons import count_undrawn_rids
 from ..commons import format_expansion
 from ..commons import download_keggorg
+from ..commons import initialize_model
+from ..commons import get_memote_results_dict
+
 
 from .introduce import introduce_metabolites
 from .introduce import introduce_reactions
@@ -35,6 +38,8 @@ from ..runsims.biosynth import biosynthesis_on_media
 
 from ..mkmodel.polishing import remove_disconnected
 
+from .cycles import verify_egc_all
+
 
 
 
@@ -173,41 +178,59 @@ def main(args, logger):
     
     
     ###### CHECKS 2
-    # check growth on minmal media
-    df_G = grow_on_media(logger, universe, dbexp, args.media, '-', True)
-    if type(df_G)==int: return 1
+    # check erroneous EGCs
+    verify_egc_all(logger, universe, args.outdir)
+    
     
-    # check blocked biomass precursors
-    cond_col_dict = adjust_biomass_precursors(logger, universe, universe, 1.0)
-    df_E = precursors_on_media(logger, universe, universe, dbexp, args.media, cond_col_dict, args.precursors)
-    if type(df_E)==int: return 1
+    if not args.justparse:
+        
+        
+        ###### CHECKS 3
+        # check growth on minmal media
+        df_G = grow_on_media(logger, universe, dbexp, args.media, '-', True)
+        if type(df_G)==int: return 1
 
-    # check blocked metabolites / dead-ends
-    df_S = biosynthesis_on_media(logger, universe, dbexp, args.media, args.biosynth)
-    if type(df_S)==int: return 1
+        # check blocked biomass precursors
+        cond_col_dict = adjust_biomass_precursors(logger, universe, universe, 1.0)
+        df_E = precursors_on_media(logger, universe, universe, dbexp, args.media, cond_col_dict, args.precursors)
+        if type(df_E)==int: return 1
+
+        # check blocked metabolites / dead-ends
+        df_S = biosynthesis_on_media(logger, universe, dbexp, args.media, args.biosynth)
+        if type(df_S)==int: return 1
 
 
     
-    ###### POLISHING 2
-    # reset growth environment befor saving the model
-    gempipe.reset_growth_env(universe)
-    
+        ###### POLISHING 2
+        # reset growth environment befor saving the model
+        gempipe.reset_growth_env(universe)
+
+        # initialize model
+        response = initialize_model(logger, universe, dbexp, args.initialize, args.media)
+        if response==1: return 1
+
+
+
+        ###### CHECKS 4
+        # compute Memote metrics
+        memote_results_dict = get_memote_results_dict(logger, universe)
+
 
 
-    # output the universe
-    logger.info("Writing universal model...")
-    cobra.io.save_json_model(universe, f'{args.outdir}/universe.json')
-    logger.info(f"'{args.outdir}/universe.json' created!")
-    cobra.io.write_sbml_model(universe, f'{args.outdir}/universe.xml')   # groups are saved only to SBML 
-    logger.info(f"'{args.outdir}/universe.xml' created!")
-    force_id_on_sbml(f'{args.outdir}/universe.xml', 'universe')   # force introduction of the 'id=""' field
-    sheets_dict = write_excel_model(universe, f'{args.outdir}/universe.parsedb.xlsx', args.nofigs, df_E, None, None, df_S, df_C)  
-    logger.info(f"'{args.outdir}/universe.parsedb.xlsx' created!")
+        # output the universe
+        logger.info("Writing universal model...")
+        cobra.io.save_json_model(universe, f'{args.outdir}/universe.json')
+        logger.info(f"'{args.outdir}/universe.json' created!")
+        cobra.io.write_sbml_model(universe, f'{args.outdir}/universe.xml')   # groups are saved only to SBML 
+        logger.info(f"'{args.outdir}/universe.xml' created!")
+        force_id_on_sbml(f'{args.outdir}/universe.xml', 'universe')   # force introduction of the 'id=""' field
+        sheets_dict = write_excel_model(universe, f'{args.outdir}/universe.parsedb.xlsx', args.nofigs, memote_results_dict, df_E, None, None, df_S, df_C)  
+        logger.info(f"'{args.outdir}/universe.parsedb.xlsx' created!")
 
 
     
-    ###### CHECKS 3
-    # check if universal escher map os updated:
+    ###### CHECKS 4
+    # check if universal escher map is updated:
     count_undrawn_rids(logger, universe, lastmap)
     
     

gsrap/parsedb/.ipynb_checkpoints/repeating-checkpoint.py

@@ -4,6 +4,7 @@ import cobra
 
 from .manual import get_deprecated_kos
 from .manual import get_rids_with_mancheck_gpr
+from .manual import get_rids_with_mancheck_balancing
 
 
 
@@ -138,6 +139,14 @@ def add_reaction(logger, model, rid, row, kr_ids, kegg_reaction_to_others, addty
         return 1    
     
     
+    # check if reversible and using ATP
+    if r.lower_bound < 0 and r.upper_bound > 0:
+        for m in r.metabolites: 
+            if m.id.rsplit('_', 1)[0] == 'atp':
+                if rid not in get_rids_with_mancheck_balancing():
+                    logger.warning(f"Reaction '{rid}' involves ATP and is reversible: are you sure?")
+    
+    
     return 0