gsrap 0.8.1__py3-none-any.whl → 0.8.3__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/getmaps/.ipynb_checkpoints/getmaps-checkpoint.py

@@ -4,6 +4,7 @@ import pickle
 
 
 from .kdown import download_raw_txtfiles
+from .kdown import create_dict_keggorg
 from .kdown import create_dict_ko
 from .kdown import create_dict_c
 from .kdown import create_dict_r
@@ -20,13 +21,19 @@ def do_kdown(logger, outdir, usecache, keeptmp):
     logger.info(f"Respectfully retrieving metabolic information from KEGG. Raw data are being saved into '{outdir}/kdown/'. Be patient, could take a couple of days...")
     os.makedirs(f'{outdir}/kdown/', exist_ok=True)
     
+    
     response = download_raw_txtfiles(logger, outdir, usecache)
     if type(response) == int: return 1
     else: RELEASE_kegg = response
     
+        
     
     logger.info("Parsing downloaded KEGG information...")
-
+    
+    response = create_dict_keggorg(logger, outdir)
+    if type(response) == int: return 1
+    else: dict_keggorg = response
+    
     response = create_dict_ko(logger, outdir)
     if type(response) == int: return 1
     else: dict_ko = response
@@ -49,7 +56,7 @@ def do_kdown(logger, outdir, usecache, keeptmp):
     
     
     # create 'idcollection_dict' and 'summary_dict' dictionaries
-    idcollection_dict = create_idcollection_dict(dict_ko, dict_c, dict_r, dict_map, dict_md)
+    idcollection_dict = create_idcollection_dict(dict_keggorg, dict_ko, dict_c, dict_r, dict_map, dict_md)
     summary_dict = create_summary_dict(dict_c, dict_r, dict_map, dict_md)
     
         
@@ -57,7 +64,6 @@ def do_kdown(logger, outdir, usecache, keeptmp):
 
 
 
-
 def main(args, logger):
     
     
@@ -67,7 +73,7 @@ def main(args, logger):
     os.makedirs(f'{args.outdir}/', exist_ok=True)
     
     
-    # KEGG
+    # KEGG download
     response = do_kdown(logger, args.outdir, args.usecache, args.keeptmp)
     if type(response) == int: return 1
     else: RELEASE_kegg, idcollection_dict, summary_dict = response[0], response[1], response[2]
@@ -76,7 +82,9 @@ def main(args, logger):
     # create 'gsrap.maps':
     with open(f'{args.outdir}/gsrap.maps', 'wb') as wb_handler:
         pickle.dump({
-            'RELEASE_kegg': RELEASE_kegg, 'idcollection_dict': idcollection_dict, 'summary_dict': summary_dict,
+            'RELEASE_kegg': RELEASE_kegg, 
+            'idcollection_dict': idcollection_dict, 
+            'summary_dict': summary_dict, 
         }, wb_handler)
     logger.info(f"'{args.outdir}/gsrap.maps' created!")
     
@@ -87,4 +95,5 @@ def main(args, logger):
         logger.info(f"Temporary raw files deleted!")
     
     
+    
     return 0

gsrap/getmaps/.ipynb_checkpoints/kdown-checkpoint.py

@@ -34,6 +34,7 @@ def download_raw_txtfiles(logger, outdir, usecache):
         'orthology',
         'module', 
         'pathway',
+        'organism',
     ]
     for db in databases:
         time.sleep(0.5)
@@ -45,8 +46,9 @@ def download_raw_txtfiles(logger, outdir, usecache):
 
     # mix the items to download to be respectful/compliant
     items_to_download = []
-
     for db in databases:
+        if db == 'organism': 
+            continue   # here we just need the list
         with open(f"{outdir}/kdown/{db}.txt", 'r') as file:
             res_string = file.read()
             rows = res_string.split('\n')
@@ -54,7 +56,6 @@ def download_raw_txtfiles(logger, outdir, usecache):
                 item_id = row.split('\t', 1)[0]
                 if item_id == '': continue
                 items_to_download.append({'db': db, 'id': item_id})
-
     random.shuffle(items_to_download)
 
 
@@ -79,6 +80,51 @@ def download_raw_txtfiles(logger, outdir, usecache):
 
 
 
+def create_dict_keggorg(logger, outdir):
+    
+    organisms_raw = open(f'{outdir}/kdown/organism.txt', 'r').read()
+
+    # create a dataframe listing all organisms in KEGG;
+    # columns are [tnumber, name, domain, kingdom, phylum, classification]
+    df = []  # list fo dicts
+    for line in organisms_raw.strip().split("\n"):
+        fields = line.split("\t")
+        if len(fields) == 4:
+            tnumber, keggorg, name, classification = fields
+            levels = classification.split(";")
+            domain = levels[0]
+            kingdom = levels[1]
+            phylum = levels[2]
+            df.append({
+                'tnumber':tnumber, 
+                'keggorg': keggorg, 
+                'name': name, 
+                'domain': domain, 
+                'kingdom': kingdom,
+                'phylum': phylum,
+                'classification': classification
+            })
+        else: 
+            # never verified during tests!
+            logger.warning(f'Strange number of fields found in this line of "organism.txt": """{line}""".')
+    df = pnd.DataFrame.from_records(df)
+    df = df.set_index('keggorg', drop=True, verify_integrity=True)
+    
+    
+    # convert dataframe to dict
+    dict_keggorg = {}
+    for keggorg, row in df.iterrows(): 
+        dict_keggorg[keggorg] = {
+            'kingdom': row['kingdom'],
+            'phylum': row['phylum'],
+            #'name': row['name'],   # not strictly needed. Commented to save disk space.
+        }
+        
+    if logger != None: logger.info(f'Number of unique items (org): {len(dict_keggorg.keys())}.')
+    return dict_keggorg
+
+
+
 def create_dict_ko(logger, outdir):
     
     dict_ko = {}         # main output
@@ -98,6 +144,7 @@ def create_dict_ko(logger, outdir):
                 'ecs': set(),
                 'cogs': set(),
                 'gos': set(),
+                'keggorgs': set(),
             }   
         else:
             logger.error(f"{ko_id} already included!")
@@ -175,7 +222,13 @@ def create_dict_ko(logger, outdir):
                         gos = content[len('GO: '):].strip().split(' ')
                         for go in gos:
                             dict_ko[ko_id]['gos'].add(go)
-                        
+                            
+                            
+                # parse the organism-specific genes
+                if curr_header == 'GENES       ':
+                    keggorg = content.split(': ',1)[0]
+                    dict_ko[ko_id]['keggorgs'].add(keggorg.lower()) # organism.txt has IDs in lowercase
+                    
                         
                 # parse the reactions
                 if curr_header == 'REACTION    ':
@@ -547,7 +600,7 @@ def create_dict_md(logger, outdir):
 
 
 
-def create_idcollection_dict(dict_ko, dict_c, dict_r, dict_map, dict_md):
+def create_idcollection_dict(dict_keggorg, dict_ko, dict_c, dict_r, dict_map, dict_md):
 
     idcollection_dict = {}
     
@@ -620,6 +673,24 @@ def create_idcollection_dict(dict_ko, dict_c, dict_r, dict_map, dict_md):
         for go in dict_ko[ko_id]['gos']:
             idcollection_dict['ko_to_gos'][ko_id].add(go)
             
+    
+    # creation of 'ko_to_keggorgs' skipped as it takes too much disk space. Replaced with 'ko_to_taxa'. 
+    idcollection_dict['ko_to_taxa'] = {}
+    missing_keggorgs = set()
+    for ko_id in dict_ko.keys():
+        idcollection_dict['ko_to_taxa'][ko_id] = {'kingdom': set(), 'phylum': set()}
+        for keggorg in dict_ko[ko_id]['keggorgs']:
+            try: 
+                kingdom = dict_keggorg[keggorg]['kingdom']
+                phylum = dict_keggorg[keggorg]['phylum']
+            except: 
+                if keggorg not in missing_keggorgs:
+                    missing_keggorgs.add(keggorg)
+                    #print(f"Organism '{keggorg}' appears in 'orthology/' but not in 'organism.txt'.")
+                continue
+            idcollection_dict['ko_to_taxa'][ko_id]['kingdom'].add(kingdom)
+            idcollection_dict['ko_to_taxa'][ko_id]['phylum'].add(phylum)
+
             
     idcollection_dict['map_to_name'] = {}
     for map_id in dict_map.keys():

gsrap/getmaps/getmaps.py

@@ -4,6 +4,7 @@ import pickle
 
 
 from .kdown import download_raw_txtfiles
+from .kdown import create_dict_keggorg
 from .kdown import create_dict_ko
 from .kdown import create_dict_c
 from .kdown import create_dict_r
@@ -20,13 +21,19 @@ def do_kdown(logger, outdir, usecache, keeptmp):
     logger.info(f"Respectfully retrieving metabolic information from KEGG. Raw data are being saved into '{outdir}/kdown/'. Be patient, could take a couple of days...")
     os.makedirs(f'{outdir}/kdown/', exist_ok=True)
     
+    
     response = download_raw_txtfiles(logger, outdir, usecache)
     if type(response) == int: return 1
     else: RELEASE_kegg = response
     
+        
     
     logger.info("Parsing downloaded KEGG information...")
-
+    
+    response = create_dict_keggorg(logger, outdir)
+    if type(response) == int: return 1
+    else: dict_keggorg = response
+    
     response = create_dict_ko(logger, outdir)
     if type(response) == int: return 1
     else: dict_ko = response
@@ -49,7 +56,7 @@ def do_kdown(logger, outdir, usecache, keeptmp):
     
     
     # create 'idcollection_dict' and 'summary_dict' dictionaries
-    idcollection_dict = create_idcollection_dict(dict_ko, dict_c, dict_r, dict_map, dict_md)
+    idcollection_dict = create_idcollection_dict(dict_keggorg, dict_ko, dict_c, dict_r, dict_map, dict_md)
     summary_dict = create_summary_dict(dict_c, dict_r, dict_map, dict_md)
     
         
@@ -57,7 +64,6 @@ def do_kdown(logger, outdir, usecache, keeptmp):
 
 
 
-
 def main(args, logger):
     
     
@@ -67,7 +73,7 @@ def main(args, logger):
     os.makedirs(f'{args.outdir}/', exist_ok=True)
     
     
-    # KEGG
+    # KEGG download
     response = do_kdown(logger, args.outdir, args.usecache, args.keeptmp)
     if type(response) == int: return 1
     else: RELEASE_kegg, idcollection_dict, summary_dict = response[0], response[1], response[2]
@@ -76,7 +82,9 @@ def main(args, logger):
     # create 'gsrap.maps':
     with open(f'{args.outdir}/gsrap.maps', 'wb') as wb_handler:
         pickle.dump({
-            'RELEASE_kegg': RELEASE_kegg, 'idcollection_dict': idcollection_dict, 'summary_dict': summary_dict,
+            'RELEASE_kegg': RELEASE_kegg, 
+            'idcollection_dict': idcollection_dict, 
+            'summary_dict': summary_dict, 
         }, wb_handler)
     logger.info(f"'{args.outdir}/gsrap.maps' created!")
     
@@ -87,4 +95,5 @@ def main(args, logger):
         logger.info(f"Temporary raw files deleted!")
     
     
+    
     return 0

gsrap/getmaps/kdown.py

@@ -34,6 +34,7 @@ def download_raw_txtfiles(logger, outdir, usecache):
         'orthology',
         'module', 
         'pathway',
+        'organism',
     ]
     for db in databases:
         time.sleep(0.5)
@@ -45,8 +46,9 @@ def download_raw_txtfiles(logger, outdir, usecache):
 
     # mix the items to download to be respectful/compliant
     items_to_download = []
-
     for db in databases:
+        if db == 'organism': 
+            continue   # here we just need the list
         with open(f"{outdir}/kdown/{db}.txt", 'r') as file:
             res_string = file.read()
             rows = res_string.split('\n')
@@ -54,7 +56,6 @@ def download_raw_txtfiles(logger, outdir, usecache):
                 item_id = row.split('\t', 1)[0]
                 if item_id == '': continue
                 items_to_download.append({'db': db, 'id': item_id})
-
     random.shuffle(items_to_download)
 
 
@@ -79,6 +80,51 @@ def download_raw_txtfiles(logger, outdir, usecache):
 
 
 
+def create_dict_keggorg(logger, outdir):
+    
+    organisms_raw = open(f'{outdir}/kdown/organism.txt', 'r').read()
+
+    # create a dataframe listing all organisms in KEGG;
+    # columns are [tnumber, name, domain, kingdom, phylum, classification]
+    df = []  # list fo dicts
+    for line in organisms_raw.strip().split("\n"):
+        fields = line.split("\t")
+        if len(fields) == 4:
+            tnumber, keggorg, name, classification = fields
+            levels = classification.split(";")
+            domain = levels[0]
+            kingdom = levels[1]
+            phylum = levels[2]
+            df.append({
+                'tnumber':tnumber, 
+                'keggorg': keggorg, 
+                'name': name, 
+                'domain': domain, 
+                'kingdom': kingdom,
+                'phylum': phylum,
+                'classification': classification
+            })
+        else: 
+            # never verified during tests!
+            logger.warning(f'Strange number of fields found in this line of "organism.txt": """{line}""".')
+    df = pnd.DataFrame.from_records(df)
+    df = df.set_index('keggorg', drop=True, verify_integrity=True)
+    
+    
+    # convert dataframe to dict
+    dict_keggorg = {}
+    for keggorg, row in df.iterrows(): 
+        dict_keggorg[keggorg] = {
+            'kingdom': row['kingdom'],
+            'phylum': row['phylum'],
+            #'name': row['name'],   # not strictly needed. Commented to save disk space.
+        }
+        
+    if logger != None: logger.info(f'Number of unique items (org): {len(dict_keggorg.keys())}.')
+    return dict_keggorg
+
+
+
 def create_dict_ko(logger, outdir):
     
     dict_ko = {}         # main output
@@ -98,6 +144,7 @@ def create_dict_ko(logger, outdir):
                 'ecs': set(),
                 'cogs': set(),
                 'gos': set(),
+                'keggorgs': set(),
             }   
         else:
             logger.error(f"{ko_id} already included!")
@@ -175,7 +222,13 @@ def create_dict_ko(logger, outdir):
                         gos = content[len('GO: '):].strip().split(' ')
                         for go in gos:
                             dict_ko[ko_id]['gos'].add(go)
-                        
+                            
+                            
+                # parse the organism-specific genes
+                if curr_header == 'GENES       ':
+                    keggorg = content.split(': ',1)[0]
+                    dict_ko[ko_id]['keggorgs'].add(keggorg.lower()) # organism.txt has IDs in lowercase
+                    
                         
                 # parse the reactions
                 if curr_header == 'REACTION    ':
@@ -547,7 +600,7 @@ def create_dict_md(logger, outdir):
 
 
 
-def create_idcollection_dict(dict_ko, dict_c, dict_r, dict_map, dict_md):
+def create_idcollection_dict(dict_keggorg, dict_ko, dict_c, dict_r, dict_map, dict_md):
 
     idcollection_dict = {}
     
@@ -620,6 +673,24 @@ def create_idcollection_dict(dict_ko, dict_c, dict_r, dict_map, dict_md):
         for go in dict_ko[ko_id]['gos']:
             idcollection_dict['ko_to_gos'][ko_id].add(go)
             
+    
+    # creation of 'ko_to_keggorgs' skipped as it takes too much disk space. Replaced with 'ko_to_taxa'. 
+    idcollection_dict['ko_to_taxa'] = {}
+    missing_keggorgs = set()
+    for ko_id in dict_ko.keys():
+        idcollection_dict['ko_to_taxa'][ko_id] = {'kingdom': set(), 'phylum': set()}
+        for keggorg in dict_ko[ko_id]['keggorgs']:
+            try: 
+                kingdom = dict_keggorg[keggorg]['kingdom']
+                phylum = dict_keggorg[keggorg]['phylum']
+            except: 
+                if keggorg not in missing_keggorgs:
+                    missing_keggorgs.add(keggorg)
+                    #print(f"Organism '{keggorg}' appears in 'orthology/' but not in 'organism.txt'.")
+                continue
+            idcollection_dict['ko_to_taxa'][ko_id]['kingdom'].add(kingdom)
+            idcollection_dict['ko_to_taxa'][ko_id]['phylum'].add(phylum)
+
             
     idcollection_dict['map_to_name'] = {}
     for map_id in dict_map.keys():

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

@@ -41,8 +41,12 @@ 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
 
@@ -103,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'}
@@ -114,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
 
 
@@ -142,12 +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
 
 
@@ -155,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)
 
 
     
@@ -165,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!")