gsrap 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

gsrap/mkmodel/mkmodel.py

@@ -64,6 +64,7 @@ def create_model_incore(params):
     # remove universal orphans
     model = remove_universal_orphans(logger, model)
 
+    
 
     ###### PRUNING
     logger.info("Reading provided eggnog-mapper annotation...")
@@ -77,6 +78,7 @@ def create_model_incore(params):
     translate_remaining_kos(logger, model, eggnog_ko_to_gids)
     restore_gene_annotations(logger, model, universe, eggonog_gid_to_kos)
 
+    
 
     ###### GAPFILLING
     # force inclusion of reactions:  
@@ -103,30 +105,35 @@ def create_model_incore(params):
     if type(df_P)==int: return 1
 
 
-    ###### POLISHING 2
-    # remove disconnected metabolites
-    model = remove_disconnected(logger, model)
 
+    ###### POLISHING 2
     # remove unsed sinks and demands
     model = remove_sinks_demands(logger, model)  
+    
+    # remove disconnected metabolites
+    model = remove_disconnected(logger, model)
 
+    
 
     # # # # #   DERIVATION ENDS HERE   # # # # #
     log_metrics(logger, model)
     log_unbalances(logger, model)
 
 
+    
     ###### CHECKS
     # check blocked metabolites / dead-ends
     df_S = biosynthesis_on_media(logger, model, dbexp, args.gap_fill, args.biosynth)
     if type(df_S)==int: return 1
 
 
+
     ###### POLISHING 3
     # reset growth environment befor saving the model
     gempipe.reset_growth_env(model)
 
 
+    
     # output the model:
     logger.info("Writing strain-specific model...")
     cobra.io.save_json_model(model, f'{args.outdir}/{model.id}.json')        # JSON
@@ -134,7 +141,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', None, df_B, df_P, df_S)  
+    sheets_dict = write_excel_model(model, f'{args.outdir}/{model.id}.mkmodel.xlsx', args.nofigs, None, df_B, df_P, df_S)  
     logger.info(f"'{args.outdir}/{model.id}.mkmodel.xlsx' created!")
         
         

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

@@ -66,6 +66,9 @@ def translate_annotate_genes(logger, model, idcollection_dict):
             g.annotation['ec'] = list(ko_to_ecs[ko])
             g.annotation['cog'] = list(ko_to_cogs[ko])
             g.annotation['go'] = list(ko_to_gos[ko])
+            
+        # add SBO annotation
+        g.annotation['sbo'] = ['SBO:0000243']  # demand reaction 
         
     
         

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

@@ -1,3 +1,6 @@
+from pathlib import Path
+
+
 import pandas as pnd
 
 
@@ -33,7 +36,7 @@ def parse_eggnog(model, eggnog, idcollection_dict):
     
     
     
-def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, idcollection_dict, summary_dict): 
+def check_completeness(logger, model, progress, module, focus, eggnog, idcollection_dict, summary_dict): 
     # check KEGG annotations in the universe model to get '%' of completeness per pathway/module.
     
             
@@ -43,10 +46,10 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
         for eggfile in eggnog:
             eggset = parse_eggnog(model, eggfile, idcollection_dict)
             kr_uni = kr_uni.union(eggset)
-        kr_uni_label = f"'{len(eggnog)} eggnog annotations'"
+        kr_uni_label = f"{len(eggnog)} eggnog annotations"
     else: 
         kr_uni = idcollection_dict['kr']
-        kr_uni_label = "'whole KEGG'"
+        kr_uni_label = "whole KEGG"
     
     
     # get all the 'kr' annotations in the model
@@ -55,7 +58,22 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
         if 'kegg.reaction' in r.annotation.keys():
             for kr_id in r.annotation['kegg.reaction']:
                 kr_ids_modeled.add(kr_id)
-    logger.info(f"Universe coverage for {kr_uni_label}: {round(len(kr_ids_modeled.intersection(kr_uni))/len(kr_uni)*100, 0)}%!")
+    kr_uni_missing = kr_uni - kr_ids_modeled
+    kr_uni_coverage = len(kr_ids_modeled.intersection(kr_uni)) / len(kr_uni) * 100
+    logger.info(f"Coverage for '{kr_uni_label}': {round(kr_uni_coverage, 0)}% ({len(kr_uni_missing)} missing).")
+    
+    
+    # define the map?????, containing krs not included in maps
+    krs_in_maps = set()
+    for i in summary_dict: krs_in_maps = krs_in_maps.union(i['kr_ids']) 
+    krs_not_in_maps = idcollection_dict['kr'] - krs_in_maps
+    summary_dict.append({
+        'map_id': 'map?????',
+        'map_name': 'Not included in maps',
+        'kr_ids': krs_not_in_maps,
+        'cnt_r': len(krs_not_in_maps),
+        'mds': []
+    })    
     
     
     # get all the map / md codes:
@@ -109,52 +127,77 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
             missing_logger = (map_id, missing)
 
         
+        # put the map in the right bucket:
         if missing == set() and map_krs != set():
             maps_finished.add(map_id)
-            
         elif map_krs == set():
             maps_noreac.add(map_id)
-            
         elif missing == map_krs:
             maps_missing.add(map_id)
-            
-            if zeroes:
-                list_coverage.append({
-                    'map_id': map_id,
-                    'map_name_short': map_name_short, 
-                    'perc_completeness': 0,
-                    'perc_completeness_str': ' 0',
-                    'present': present,
-                    'missing': missing,
-                    'md_ids': [j['md_id'] for j in i['mds']],
-                })
-            
         elif len(missing) < len(map_krs):
             maps_partial.add(map_id)
             
-            # get '%' of completeness:
-            perc_completeness = len(present)/len(map_krs)*100
-            perc_completeness_str = str(round(perc_completeness))   # version to be printed
-            if len(perc_completeness_str)==1: 
-                perc_completeness_str = ' ' + perc_completeness_str
-                
-            list_coverage.append({
-                'map_id': map_id,
-                'map_name_short': map_name_short, 
-                'perc_completeness': perc_completeness,
-                'perc_completeness_str': perc_completeness_str,
-                'present': present,
-                'missing': missing,
-                'md_ids': [j['md_id'] for j in i['mds']],
-            })
-                
             
-    # order list by '%' of completness and print:
+        # get '%' of completeness:
+        if len(map_krs) != 0: perc_completeness = len(present)/len(map_krs)*100
+        else: perc_completeness = 100   # for maps_noreac
+        perc_completeness_str = str(round(perc_completeness))   # version to be printed
+        if len(perc_completeness_str)==1: 
+            perc_completeness_str = ' ' + perc_completeness_str
+
+            
+        # append map to list:
+        list_coverage.append({
+            'map_id': map_id,
+            'map_name_short': map_name_short, 
+            'perc_completeness': perc_completeness,
+            'perc_completeness_str': perc_completeness_str,
+            'present': present,
+            'missing': missing,
+            'md_ids': [j['md_id'] for j in i['mds']],
+        })
+        
+        
+    
+    # create coverage dataframe
+    if eggnog != '-' and len(eggnog) >= 2:  
+        df_coverage = {}
+        for i in list_coverage:
+            for kr in i['present'].union(i['missing']):
+                if kr not in df_coverage.keys(): 
+                    df_coverage[kr] = {'map_ids': set()}
+                df_coverage[kr]['map_ids'].add(i['map_id'])
+        df_coverage = pnd.DataFrame.from_records(df_coverage).T
+        df_coverage['modeled'] = False
+        for kr, row in df_coverage.iterrows():
+            if kr in kr_ids_modeled:
+                df_coverage.loc[kr, 'modeled'] = True
+        # build strain columns all at once
+        df_strains = []  # list of small DataFrames
+        for eggfile in eggnog:
+            strain = Path(eggfile).stem
+            eggset = parse_eggnog(model, eggfile, idcollection_dict)
+            col = df_coverage.index.to_series().isin(eggset).astype(int)
+            df_strains.append(col.rename(strain))
+        df_strains = pnd.concat(df_strains, axis=1)
+        # sort rows: upper rows are present in more strains
+        df_strains = df_strains.loc[df_strains.sum(axis=1).sort_values(ascending=False).index]
+        df_coverage = df_coverage.loc[df_strains.index]
+        df_coverage = pnd.concat([df_coverage, df_strains], axis=1)
+        # split in 2: modeled above, non-modeled below:
+        df_coverage = pnd.concat([df_coverage[df_coverage['modeled']==True], df_coverage[df_coverage['modeled']==False]])
+    else:  # not interesting in a super-long table without strains in column
+        df_coverage = None
+    
+           
+            
+    # order list by '%' of completness and print if needed:
     list_coverage = sorted(list_coverage, key=lambda x: x['perc_completeness'], reverse=True)
     for i in list_coverage:
         if progress:
             if focus=='-' or focus in i['md_ids'] or focus==i['map_id']:
-                logger.info(f"{i['map_id']}: {i['map_name_short']} {i['perc_completeness_str']}% completed, {len(i['present'])} added, {len(i['missing'])} missing.")
+                if i['map_id'] in maps_missing or i['map_id'] in maps_partial:
+                    logger.info(f"{i['map_id']}: {i['map_name_short']} {i['perc_completeness_str']}% completed, {len(i['present'])} added, {len(i['missing'])} missing.")
         
         
         # get the correspondent pathway element of the 'summary_dict'
@@ -196,50 +239,43 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
                 missing_logger = (md_id, missing)
             
             
+            # put the map in the right bucket:
             if missing == set() and md_krs != set():
                 mds_completed.add(md_id)
-
             elif md_krs == set():
                 mds_noreac.add(md_id)
-
             elif missing == md_krs:
                 mds_missing.add(md_id)
-                
-                if zeroes:
-                    list_coverage_md.append({
-                        'md_id': md_id,
-                        'md_name_short': md_name_short, 
-                        'perc_completeness': 0,
-                        'perc_completeness_str': ' 0',
-                        'present': present,
-                        'missing': missing,
-                    })
-                
             elif len(missing) < len(md_krs):
                 mds_partial.add(md_id)
 
-                # get '%' of completeness:
-                perc_completeness = len(present)/len(md_krs)*100
-                perc_completeness_str = str(round(perc_completeness))   # version to be printed
-                if len(perc_completeness_str)==1: 
-                    perc_completeness_str = ' ' + perc_completeness_str
+                
+            # get '%' of completeness:
+            if len(md_krs) != 0: perc_completeness = len(present)/len(md_krs)*100
+            else: perc_completeness = 100   # for mds_noreac
+            perc_completeness_str = str(round(perc_completeness))   # version to be printed
+            if len(perc_completeness_str)==1: 
+                perc_completeness_str = ' ' + perc_completeness_str
 
-                list_coverage_md.append({
-                    'md_id': md_id,
-                    'md_name_short': md_name_short, 
-                    'perc_completeness': perc_completeness,
-                    'perc_completeness_str': perc_completeness_str,
-                    'present': present,
-                    'missing': missing,
-                })
+                
+            # append md to list:
+            list_coverage_md.append({
+                'md_id': md_id,
+                'md_name_short': md_name_short, 
+                'perc_completeness': perc_completeness,
+                'perc_completeness_str': perc_completeness_str,
+                'present': present,
+                'missing': missing,
+            })
                
             
-        # order list by '%' of completness and print:
+        # order list by '%' of completness and print if needed:
         list_coverage_md = sorted(list_coverage_md, key=lambda x: x['perc_completeness'], reverse=True)
         for z in list_coverage_md:
             if module:
                 if focus=='-' or focus==z['md_id']:
-                    logger.info(f"{spacer}{z['md_id']}: {z['md_name_short']} {z['perc_completeness_str']}% completed, {len(z['present'])} added, {len(z['missing'])} missing.")
+                    if z['md_id'] in mds_missing or z['md_id'] in mds_partial:
+                        logger.info(f"{spacer}{z['md_id']}: {z['md_name_short']} {z['perc_completeness_str']}% completed, {len(z['present'])} added, {len(z['missing'])} missing.")
         
         
         # print summary:
@@ -251,6 +287,6 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
         logger.info(f"Maps: finished {len(maps_finished)} - partial {len(maps_partial)} - missing {len(maps_missing)} - noreac {len(maps_noreac)}")
             
         
-    return 0     
+    return df_coverage     
 
 

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

@@ -141,6 +141,10 @@ def introduce_metabolites(logger, db, model, idcollection_dict, kegg_compound_to
         # save as list: 
         for ankey in ankeys:
             m.annotation[ankey] = list(m.annotation[ankey])
+            
+            
+        # add SBO annotation
+        m.annotation['sbo'] = ['SBO:0000247']  # generic metabolite
    
         
     
@@ -264,7 +268,8 @@ def introduce_transporters(logger, db, model, idcollection_dict, kegg_reaction_t
         m_e.name = m_c.name
         m_e.formula = m_c.formula
         m_e.charge = m_c.charge
-        m_e.annotation = m_c.annotation
+        
+        m_e.annotation = m_c.annotation   # transfer all annotations, including SBO!
             
     
     def add_exchange_reaction(model, mid_e):
@@ -283,6 +288,10 @@ def introduce_transporters(logger, db, model, idcollection_dict, kegg_reaction_t
             r.bounds = (-1000, 1000)
         else:
             r.bounds = (0, 1000)
+            
+        # add SBO annotation
+        r.annotation['sbo'] = ['SBO:0000627']  # exchange reaction    
+        
     
     
     
@@ -418,6 +427,9 @@ def introduce_sinks_demands(logger, model):
         r.name = f"Sink for {model.metabolites.get_by_id(f'{puremid}_c').name}"
         r.build_reaction_from_string(f'{puremid}_c <=> ')
         r.bounds = (-1000, 1000)
+        
+        # add SBO annotation
+        r.annotation['sbo'] = ['SBO:0000632']  # sink reaction 
     
     
     for puremid in demands: 
@@ -427,6 +439,9 @@ def introduce_sinks_demands(logger, model):
         r.name = f"Demand for {model.metabolites.get_by_id(f'{puremid}_c').name}"
         r.build_reaction_from_string(f'{puremid}_c --> ')
         r.bounds = (0, 1000)
+        
+        # add SBO annotation
+        r.annotation['sbo'] = ['SBO:0000628']  # demand reaction 
     
     
     return model

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

@@ -113,7 +113,7 @@ def main(args, logger):
     
     ###### RECONSTRUCTION
     # create the model
-    universe = cobra.Model('newuni')   
+    universe = cobra.Model('universe')   
     logger.info("Parsing gsrap database...")
     
     # introduce M / R / T
@@ -153,9 +153,8 @@ def main(args, logger):
     
     ###### CHECKS 1
     # check universe completness
-    setattr(args, 'zeroes', True)  # old parameter, forced to True from v0.6.1
-    response = check_completeness(logger, universe, args.progress, args.module, args.focus, args.eggnog, args.zeroes, idcollection_dict, summary_dict)
-    if response==1: return 1
+    df_C = check_completeness(logger, universe, args.progress, args.module, args.focus, args.eggnog, idcollection_dict, summary_dict)
+    if type(df_C)==int: return 1
 
 
 
@@ -194,7 +193,7 @@ def main(args, logger):
     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', df_E, None, None, df_S)  
+    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!")
 
 

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

@@ -125,6 +125,13 @@ def add_reaction(logger, model, rid, row, kr_ids, kegg_reaction_to_others, addty
         r.annotation[ankey] = list(r.annotation[ankey])
         
         
+    # add SBO annotation
+    if addtype=='R':
+        r.annotation['sbo'] = ['SBO:0000176']  # metabolic reaction
+    else:
+        r.annotation['sbo'] = ['SBO:0000185']  # transport reaction
+        
+        
     # check if unbalanced
     if r.check_mass_balance() != {}: 
         logger.error(f"{itemtype} '{r.id}' is unbalanced: {r.check_mass_balance()}.")

gsrap/parsedb/annotation.py

@@ -66,6 +66,9 @@ def translate_annotate_genes(logger, model, idcollection_dict):
             g.annotation['ec'] = list(ko_to_ecs[ko])
             g.annotation['cog'] = list(ko_to_cogs[ko])
             g.annotation['go'] = list(ko_to_gos[ko])
+            
+        # add SBO annotation
+        g.annotation['sbo'] = ['SBO:0000243']  # demand reaction 
         
     
         

gsrap/parsedb/completeness.py

@@ -1,3 +1,6 @@
+from pathlib import Path
+
+
 import pandas as pnd
 
 
@@ -33,7 +36,7 @@ def parse_eggnog(model, eggnog, idcollection_dict):
     
     
     
-def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, idcollection_dict, summary_dict): 
+def check_completeness(logger, model, progress, module, focus, eggnog, idcollection_dict, summary_dict): 
     # check KEGG annotations in the universe model to get '%' of completeness per pathway/module.
     
             
@@ -43,10 +46,10 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
         for eggfile in eggnog:
             eggset = parse_eggnog(model, eggfile, idcollection_dict)
             kr_uni = kr_uni.union(eggset)
-        kr_uni_label = f"'{len(eggnog)} eggnog annotations'"
+        kr_uni_label = f"{len(eggnog)} eggnog annotations"
     else: 
         kr_uni = idcollection_dict['kr']
-        kr_uni_label = "'whole KEGG'"
+        kr_uni_label = "whole KEGG"
     
     
     # get all the 'kr' annotations in the model
@@ -55,7 +58,22 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
         if 'kegg.reaction' in r.annotation.keys():
             for kr_id in r.annotation['kegg.reaction']:
                 kr_ids_modeled.add(kr_id)
-    logger.info(f"Universe coverage for {kr_uni_label}: {round(len(kr_ids_modeled.intersection(kr_uni))/len(kr_uni)*100, 0)}%!")
+    kr_uni_missing = kr_uni - kr_ids_modeled
+    kr_uni_coverage = len(kr_ids_modeled.intersection(kr_uni)) / len(kr_uni) * 100
+    logger.info(f"Coverage for '{kr_uni_label}': {round(kr_uni_coverage, 0)}% ({len(kr_uni_missing)} missing).")
+    
+    
+    # define the map?????, containing krs not included in maps
+    krs_in_maps = set()
+    for i in summary_dict: krs_in_maps = krs_in_maps.union(i['kr_ids']) 
+    krs_not_in_maps = idcollection_dict['kr'] - krs_in_maps
+    summary_dict.append({
+        'map_id': 'map?????',
+        'map_name': 'Not included in maps',
+        'kr_ids': krs_not_in_maps,
+        'cnt_r': len(krs_not_in_maps),
+        'mds': []
+    })    
     
     
     # get all the map / md codes:
@@ -109,52 +127,77 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
             missing_logger = (map_id, missing)
 
         
+        # put the map in the right bucket:
         if missing == set() and map_krs != set():
             maps_finished.add(map_id)
-            
         elif map_krs == set():
             maps_noreac.add(map_id)
-            
         elif missing == map_krs:
             maps_missing.add(map_id)
-            
-            if zeroes:
-                list_coverage.append({
-                    'map_id': map_id,
-                    'map_name_short': map_name_short, 
-                    'perc_completeness': 0,
-                    'perc_completeness_str': ' 0',
-                    'present': present,
-                    'missing': missing,
-                    'md_ids': [j['md_id'] for j in i['mds']],
-                })
-            
         elif len(missing) < len(map_krs):
             maps_partial.add(map_id)
             
-            # get '%' of completeness:
-            perc_completeness = len(present)/len(map_krs)*100
-            perc_completeness_str = str(round(perc_completeness))   # version to be printed
-            if len(perc_completeness_str)==1: 
-                perc_completeness_str = ' ' + perc_completeness_str
-                
-            list_coverage.append({
-                'map_id': map_id,
-                'map_name_short': map_name_short, 
-                'perc_completeness': perc_completeness,
-                'perc_completeness_str': perc_completeness_str,
-                'present': present,
-                'missing': missing,
-                'md_ids': [j['md_id'] for j in i['mds']],
-            })
-                
             
-    # order list by '%' of completness and print:
+        # get '%' of completeness:
+        if len(map_krs) != 0: perc_completeness = len(present)/len(map_krs)*100
+        else: perc_completeness = 100   # for maps_noreac
+        perc_completeness_str = str(round(perc_completeness))   # version to be printed
+        if len(perc_completeness_str)==1: 
+            perc_completeness_str = ' ' + perc_completeness_str
+
+            
+        # append map to list:
+        list_coverage.append({
+            'map_id': map_id,
+            'map_name_short': map_name_short, 
+            'perc_completeness': perc_completeness,
+            'perc_completeness_str': perc_completeness_str,
+            'present': present,
+            'missing': missing,
+            'md_ids': [j['md_id'] for j in i['mds']],
+        })
+        
+        
+    
+    # create coverage dataframe
+    if eggnog != '-' and len(eggnog) >= 2:  
+        df_coverage = {}
+        for i in list_coverage:
+            for kr in i['present'].union(i['missing']):
+                if kr not in df_coverage.keys(): 
+                    df_coverage[kr] = {'map_ids': set()}
+                df_coverage[kr]['map_ids'].add(i['map_id'])
+        df_coverage = pnd.DataFrame.from_records(df_coverage).T
+        df_coverage['modeled'] = False
+        for kr, row in df_coverage.iterrows():
+            if kr in kr_ids_modeled:
+                df_coverage.loc[kr, 'modeled'] = True
+        # build strain columns all at once
+        df_strains = []  # list of small DataFrames
+        for eggfile in eggnog:
+            strain = Path(eggfile).stem
+            eggset = parse_eggnog(model, eggfile, idcollection_dict)
+            col = df_coverage.index.to_series().isin(eggset).astype(int)
+            df_strains.append(col.rename(strain))
+        df_strains = pnd.concat(df_strains, axis=1)
+        # sort rows: upper rows are present in more strains
+        df_strains = df_strains.loc[df_strains.sum(axis=1).sort_values(ascending=False).index]
+        df_coverage = df_coverage.loc[df_strains.index]
+        df_coverage = pnd.concat([df_coverage, df_strains], axis=1)
+        # split in 2: modeled above, non-modeled below:
+        df_coverage = pnd.concat([df_coverage[df_coverage['modeled']==True], df_coverage[df_coverage['modeled']==False]])
+    else:  # not interesting in a super-long table without strains in column
+        df_coverage = None
+    
+           
+            
+    # order list by '%' of completness and print if needed:
     list_coverage = sorted(list_coverage, key=lambda x: x['perc_completeness'], reverse=True)
     for i in list_coverage:
         if progress:
             if focus=='-' or focus in i['md_ids'] or focus==i['map_id']:
-                logger.info(f"{i['map_id']}: {i['map_name_short']} {i['perc_completeness_str']}% completed, {len(i['present'])} added, {len(i['missing'])} missing.")
+                if i['map_id'] in maps_missing or i['map_id'] in maps_partial:
+                    logger.info(f"{i['map_id']}: {i['map_name_short']} {i['perc_completeness_str']}% completed, {len(i['present'])} added, {len(i['missing'])} missing.")
         
         
         # get the correspondent pathway element of the 'summary_dict'
@@ -196,50 +239,43 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
                 missing_logger = (md_id, missing)
             
             
+            # put the map in the right bucket:
             if missing == set() and md_krs != set():
                 mds_completed.add(md_id)
-
             elif md_krs == set():
                 mds_noreac.add(md_id)
-
             elif missing == md_krs:
                 mds_missing.add(md_id)
-                
-                if zeroes:
-                    list_coverage_md.append({
-                        'md_id': md_id,
-                        'md_name_short': md_name_short, 
-                        'perc_completeness': 0,
-                        'perc_completeness_str': ' 0',
-                        'present': present,
-                        'missing': missing,
-                    })
-                
             elif len(missing) < len(md_krs):
                 mds_partial.add(md_id)
 
-                # get '%' of completeness:
-                perc_completeness = len(present)/len(md_krs)*100
-                perc_completeness_str = str(round(perc_completeness))   # version to be printed
-                if len(perc_completeness_str)==1: 
-                    perc_completeness_str = ' ' + perc_completeness_str
+                
+            # get '%' of completeness:
+            if len(md_krs) != 0: perc_completeness = len(present)/len(md_krs)*100
+            else: perc_completeness = 100   # for mds_noreac
+            perc_completeness_str = str(round(perc_completeness))   # version to be printed
+            if len(perc_completeness_str)==1: 
+                perc_completeness_str = ' ' + perc_completeness_str
 
-                list_coverage_md.append({
-                    'md_id': md_id,
-                    'md_name_short': md_name_short, 
-                    'perc_completeness': perc_completeness,
-                    'perc_completeness_str': perc_completeness_str,
-                    'present': present,
-                    'missing': missing,
-                })
+                
+            # append md to list:
+            list_coverage_md.append({
+                'md_id': md_id,
+                'md_name_short': md_name_short, 
+                'perc_completeness': perc_completeness,
+                'perc_completeness_str': perc_completeness_str,
+                'present': present,
+                'missing': missing,
+            })
                
             
-        # order list by '%' of completness and print:
+        # order list by '%' of completness and print if needed:
         list_coverage_md = sorted(list_coverage_md, key=lambda x: x['perc_completeness'], reverse=True)
         for z in list_coverage_md:
             if module:
                 if focus=='-' or focus==z['md_id']:
-                    logger.info(f"{spacer}{z['md_id']}: {z['md_name_short']} {z['perc_completeness_str']}% completed, {len(z['present'])} added, {len(z['missing'])} missing.")
+                    if z['md_id'] in mds_missing or z['md_id'] in mds_partial:
+                        logger.info(f"{spacer}{z['md_id']}: {z['md_name_short']} {z['perc_completeness_str']}% completed, {len(z['present'])} added, {len(z['missing'])} missing.")
         
         
         # print summary:
@@ -251,6 +287,6 @@ def check_completeness(logger, model, progress, module, focus, eggnog, zeroes, i
         logger.info(f"Maps: finished {len(maps_finished)} - partial {len(maps_partial)} - missing {len(maps_missing)} - noreac {len(maps_noreac)}")
             
         
-    return 0     
+    return df_coverage