seed2lp 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

seed2lp/description.py

@@ -7,7 +7,7 @@ import pandas as pd
 import re
 from os import path
 from seed2lp.network import Network     
-from . import flux, logger, color
+from . import flux, color # logger,
 import warnings
 import difflib
 import seed2lp.sbml as SBML
@@ -21,15 +21,15 @@ BISEAU_VIZ = """
 #defined reactant/4.
 #defined product/4.
 #defined reaction/1.
-link(T,R) :- reactant(T,_,R,_).
-link(R,P) :- product(P,_,R,_).
+link(T,R) :- reactant(T,_,R,_,_,_).
+link(R,P) :- product(P,_,R,_,_,_).
 shape(R,rectangle) :- reaction(R).
 obj_property(edge,arrowhead,vee).
 """
 BISEAU_VIZ_NOREACTION = """
-link(M,P) :- product(P,_,R,_) ; reactant(M,_,R,_).
-link(P,P) :- product(P,_,R,_) ; not reactant(_,_,R,_).
-link(M,M) :- reactant(M,_,R,_), not product(_,_,R,_).
+link(M,P) :- product(P,_,R,_,_,_) ; reactant(M,_,R,_,_,_).
+link(P,P) :- product(P,_,R,_,_,_) ; not reactant(_,_,R,_,_,_).
+link(M,M) :- reactant(M,_,R,_,_,_), not product(_,_,R,_,_,_).
 obj_property(edge,arrowhead,vee).
 """
 
@@ -102,7 +102,7 @@ class Description(Network):
     def details_from_lp(self):
         """Get the network description from lp facts and save it
         """
-        logger.log.info("Start Getting Details from LP file")
+        self.logger.info("Start Getting Details from LP file")
         reactions_composition_df = pd.DataFrame(columns=['reaction', 'metabolite', 'type_metabolite', 'stoichiometry'])
         reaction_df = pd.DataFrame(columns=['reaction', 'low_bound', 'up_bound','is_forward', 'is_reverse', 'is_low_set'])
         only_forward=list()
@@ -251,13 +251,13 @@ class Description(Network):
         #print(reaction_without_reactant)
         #print("REACTION WITHOUT PRODUCT")
         #print(reaction_without_product)
-        save(self.lp_details , full_details)
+        self.save(self.lp_details , full_details)
         
 
     def details_from_cobra(self):
         """Get the network description from sbml file by using cobra and save it
         """
-        logger.log.info("Start Getting Details from Cobra file")
+        self.logger.info("Start Getting Details from Cobra file")
         warnings.filterwarnings("error")
         model = flux.get_model(self.file)
         if not self.keep_import_reactions:
@@ -267,14 +267,14 @@ class Description(Network):
             full_details += f"{reaction}\t[{reaction.lower_bound}, {reaction.upper_bound}]\n"
             
         self.cobra_details = path.join(self.out_dir, f"{self.name}_{self.short_option}_details_from_cobra.txt")
-        save(self.cobra_details, full_details)
+        self.save(self.cobra_details, full_details)
 
 
     def details_diff(self):
         """Compare the Network description from cobra and lp facts
         save the diff information into file
         """
-        logger.log.info("Start checking diff between Cobra and LP Network")
+        self.logger.info("Start checking diff between Cobra and LP Network")
         diff = ""
         with open(self.cobra_details) as cobra_details:
             cobra_details_text = cobra_details.readlines()
@@ -292,12 +292,13 @@ class Description(Network):
         lp_details.close()
 
         diff_path = path.join(self.out_dir, f"{self.name}_{self.short_option}_details_diff.txt")
-        save(diff_path, diff)
+        self.save(diff_path, diff)
 
     def render_network(self):
         """From lp facts render the network graph with or without reaction
         """
         import biseau
+        check_graphviz()
         out_file = path.join(self.out_dir, f"{self.name}_{self.short_option}_visu")
 
         print(f"\n\n{color.cyan_dark}############################################")  
@@ -343,10 +344,10 @@ class Description(Network):
         print(f"############################################\n{color.reset}") 
 
         if self.keep_import_reactions:
-            logger.log.warning("IMPORT REACTION KEPT")
+            self.logger.warning("IMPORT REACTION KEPT")
         else:
-            logger.log.warning("IMPORT REACTION REMOVED BY DEFAULT")
-            logger.log.warning("If you want to keep import reaction\nuse option -kir / --keep-import-reactions")
+            self.logger.warning("IMPORT REACTION REMOVED BY DEFAULT")
+            self.logger.warning("If you want to keep import reaction\nuse option -kir / --keep-import-reactions")
         species=self.name
         original_reactions = SBML.get_listOfReactions(self.model[species])
 
@@ -366,7 +367,7 @@ class Description(Network):
             if reaction_name in self.deleted_reactions:
                 self.sbml_remove_reaction(reaction, species)
                 rm_reac_message+=f"\n\t- {reaction_name}"
-                logger.log.info(rm_reac_message)
+                self.logger.info(rm_reac_message)
             else:
                 # Change the reversibility
                 is_modif_rev = self.sbml_review_reversibilty(reaction_name, reaction)
@@ -389,11 +390,11 @@ class Description(Network):
 
         #print and log
         if is_modif_rev_log:
-            logger.log.warning(modif_rev_message)
+            self.logger.warning(modif_rev_message)
         if is_switch_meta_log:
-            logger.log.warning(switch_meta_message)
+            self.logger.warning(switch_meta_message)
         if is_rm_import_log:
-            logger.log.warning(rm_import_message)
+            self.logger.warning(rm_import_message)
 
         # Replace list of parameters because we added new specific parameters for the exchange reactions
         self.sbml_review_parameters(species)
@@ -405,20 +406,30 @@ class Description(Network):
         file_path = path.join(self.out_dir, self.name+".xml") 
         str_model =  self.sbml_first_line+SBML.etree_to_string(self.sbml[species])
         print(f"File saved at: {file_path}")
-        save(file_path, str_model)
+        self.save(file_path, str_model)
 
-    ######################################################## 
 
+    def save(self, out_file:str, data):
+        """Save file of Network description or graphs
 
-######################## FUNCTIONS ########################
-def save(out_file:str, data):
-    """Save file of Network description or graphs
-
-    Args:
-        out_file (str): Output file path
-        data: Graph or Network details data
-    """
-    with open(out_file, 'w') as f:
-        f.write(data)
-    f.close()
-    logger.log.info(f"File saved at: {out_file}")
+        Args:
+            out_file (str): Output file path
+            data: Graph or Network details data
+        """
+        with open(out_file, 'w') as f:
+            f.write(data)
+        f.close()
+        self.logger.info(f"File saved at: {out_file}")
+
+       
+def check_graphviz():
+    import shutil
+    if shutil.which("dot") is None:
+        raise RuntimeError(
+            f"\n\n{color.red_bright}Graphviz is required and missing from your environment.{color.reset}\n"
+            f"First install it with:\n"
+            f"  {color.cyan_dark}conda install -c conda-forge graphviz{color.reset}\n"
+            f"or\n"
+            f"  {color.cyan_dark}sudo apt install graphviz{color.reset}\n"
+            f"Then retry.\n"
+        )

seed2lp/file.py

@@ -1,7 +1,8 @@
+import logging
 from os import path, makedirs, stat, remove
 from json import dump, load
 from csv import writer, reader
-from . import logger
+#from . import logger
 
 
 def existant_path(inpath:str) -> str:
@@ -29,12 +30,13 @@ def is_valid_dir(dirpath):
     Returns:
         bool: True if dir exists, False otherwise
     """
+    logger = logging.getLogger("s2lp")
     if not path.isdir(dirpath):
         try:
             makedirs(dirpath)
             return dirpath
         except OSError as e:
-            logger.log.error(e)
+            logger.error(e)
             return None
     else:
         return dirpath
@@ -64,6 +66,7 @@ def save(filename:str, directory:str, results, type:str, is_result_temp=False):
         type (str): Type of output fils (json or tsv or txt)
     """
 
+    logger = logging.getLogger("s2lp")
     out_file_path = path.join(directory,filename)
     try:
         match type:
@@ -91,7 +94,7 @@ def save(filename:str, directory:str, results, type:str, is_result_temp=False):
                 with open(out_file_path, "w") as f:
                     f.write("\n".join(results))
     except  Exception as e:
-        logger.log.error(f"while saving file: {e}")
+        logger.error(f"while saving file: {e}")
     
 
 

seed2lp/flux.py

@@ -1,8 +1,9 @@
-import cobra
+import cobra, logging
 from re import sub
 from cobra.core import Model
 import warnings
-from . import logger, color
+from . import color #,logger
+from .logger import print_log
 
 def get_model(model_file:str):
     """Get cobra model
@@ -41,7 +42,8 @@ def get_list_fluxes(model:Model, list_objective:list, show_messages:bool=True):
             objective_flux = 0.0
         fluxes_dict[objective_reaction]=objective_flux
     if show_messages:
-        print(fluxes_dict)
+        for reaction, flux in fluxes_dict.items():
+            print(f"'{reaction}': {float(flux)}")
         print('\n')
     return fluxes_dict
 
@@ -79,6 +81,7 @@ def get_flux(model:Model, objective_reaction:str, list_objective:list,
     Returns:
         float, bool: The value of the objective flux, if the model is infeasible or not
     """
+    logger = logging.getLogger("s2lp")
     warnings.filterwarnings("error")
     objective_flux=dict()
     try:
@@ -157,12 +160,12 @@ def get_flux(model:Model, objective_reaction:str, list_objective:list,
             objective = remove_prefix_reaction(obj)
             objective_flux[objective]=0
         infeasible = True
-        logger.log.info("Model infeasible")
+        logger.info("Model infeasible")
         
     return objective_flux, infeasible
 
 
-def get_init(model:Model, list_objective:list, show_messages:bool=True):
+def get_init(model:Model, list_objective:list, logger:logging, show_messages:bool=True):
     """Get initial flux of all objective reactions using cobra
 
     Args:
@@ -179,7 +182,7 @@ def get_init(model:Model, list_objective:list, show_messages:bool=True):
             f"                 {color.bold}CHECK FLUX{color.cyan_light}\n"\
             "############################################\n" \
             "############################################\n"
-        logger.print_log(title_mess, "info", color.cyan_light) 
+        print_log(logger, title_mess, "info", color.cyan_light) 
 
     
         print("---------------- FLUX INIT -----------------\n")
@@ -204,9 +207,11 @@ def stop_flux(model:Model, list_objective:list=None, show_messages:bool=True):
     Returns:
         dic: Dictionnary of objective reaction and their respective fluxes
     """
+    logger = logging.getLogger("s2lp")
+
     if show_messages:
         print("---------- STOP IMPORT FLUX -------------\n") 
-    logger.log.info("Shutting down import flux ...")
+    logger.info("Shutting down import flux ...")
 
     for elem in model.boundary:
         if not elem.reactants and elem.upper_bound > 0:
@@ -218,7 +223,7 @@ def stop_flux(model:Model, list_objective:list=None, show_messages:bool=True):
                 elem.upper_bound = 0
             elem.lower_bound = 0.0
 
-    logger.log.info("... DONE")
+    logger.info("... DONE")
 
     if list_objective is not None:
         fluxes_no_import = get_list_fluxes(model, list_objective, show_messages)
@@ -242,10 +247,11 @@ def calculate(model:Model, list_objective:list, list_seeds:list,
     Returns:
         dict, str: result (containing the data), objective_reaction (chosen, the first having flux)
     """
+    logger = logging.getLogger("s2lp")
     warnings.filterwarnings("error")
-    logger.log.info("Starting calculate Flux...")
+    logger.info("Starting calculate Flux...")
     if not list_objective:
-        logger.log.error("No objective found, abort")
+        logger.error("No objective found, abort")
         return None, None
     
     #cobra.flux_analysis.add_loopless(model)
@@ -266,7 +272,7 @@ def calculate(model:Model, list_objective:list, list_seeds:list,
             meta_exchange_list[str(key)]=reaction.id
 
     created_sinks = []
-    logger.log.info("Opening Import flux from seeds (Exchange) or add Sinks ...")
+    logger.info("Opening Import flux from seeds (Exchange) or add Sinks ...")
     objective_reaction = set_objective(model, list_objective[0])
 
     for seed in list_seeds:
@@ -300,9 +306,9 @@ def calculate(model:Model, list_objective:list, list_seeds:list,
                                         lb=float(-1000))
                 created_sinks.append(f"SK_{seed}")
         
-    logger.log.info("Opening Import flux: Done")
+    logger.info("Opening Import flux: Done")
 
-    logger.log.info("Checking objective flux on seeds ...")
+    logger.info("Checking objective flux on seeds ...")
     
     lp_flux=None
     if not is_community:
@@ -322,9 +328,9 @@ def calculate(model:Model, list_objective:list, list_seeds:list,
     infeasible_demands=None
     if ok_seeds:
         ok_result = True
-        logger.log.info("... OK")
+        logger.info("... OK")
     elif try_demands:
-        logger.log.info("... KO - Checking objective flux on demands ...")
+        logger.info("... KO - Checking objective flux on demands ...")
         # create a demand reaction for all products of the biomass reaction
         products = [m.id for m in model.reactions.get_by_id(objective_reaction).products]
         for m in products:
@@ -349,9 +355,9 @@ def calculate(model:Model, list_objective:list, list_seeds:list,
         
         if ok_demands:
             ok_result = True
-            logger.log.info("... OK")
+            logger.info("... OK")
         else:
-            logger.log.info("... KO")
+            logger.info("... KO")
 
     result = {'id' : species,
             'objective_flux_seeds': objective_flux_seeds,

seed2lp/linear.py

@@ -8,14 +8,15 @@
 
 from seed2lp.network import Network
 from seed2lp.solver import Solver
-from . import clingo_lpx, color, logger
+from . import clingo_lpx, color
+from .logger import print_log
 
 
 ###################################################################
 ################### Class Hybrid : herit Solver ################### 
 ###################################################################
 class Hybrid(Solver):
-    def __init__(self, run_mode:str, run_solve:str, network:Network, 
+    def __init__(self, run_mode:str, run_solve:str, network:Network, log_path:str,
                  time_limit_minute:float=None, number_solution:int=None, 
                  clingo_configuration:str=None, clingo_strategy:str=None, 
                  intersection:bool=False, union:bool=False,
@@ -43,7 +44,7 @@ class Hybrid(Solver):
             short_option (str, optional): Short way to write option on filename. Defaults to None.
             verbose (bool, optional): Set debug mode. Defaults to False.
         """
-        super().__init__(run_mode, network, time_limit_minute, number_solution, clingo_configuration, 
+        super().__init__(run_mode, network, log_path, time_limit_minute, number_solution, clingo_configuration, 
                          clingo_strategy, intersection, union, minimize, subset_minimal, temp_dir, short_option, run_solve, verbose)
         
         self.is_linear = True
@@ -65,7 +66,7 @@ class Hybrid(Solver):
             f"                    {color.bold}HYBRID{color.cyan_light}\n"\
             "############################################\n" \
             "############################################\n"
-        logger.print_log(title_mess, "info", color.cyan_light) 
+        print_log(self.logger, title_mess, "info", color.cyan_light) 
 
     
     def _init_clingo_constant(self):
@@ -74,11 +75,11 @@ class Hybrid(Solver):
         self.init_const()
 
         if self.maximize_flux:
-            logger.print_log('Flux: MAXIMIZATION', "info")
+            print_log(self.logger, 'Flux: MAXIMIZATION', "info", verbose=self.verbose)
         else:
-            logger.print_log('Flux: NO MAXIMIZATION', "info")
-        logger.print_log(f"Time limit: {self.time_limit_minute} minutes", 'info')
-        logger.print_log(f"Solution number limit: {self.number_solution}", 'info')
+            print_log(self.logger, 'Flux: NO MAXIMIZATION', "info")
+        print_log(self.logger, f"Time limit: {self.time_limit_minute} minutes", 'info', verbose=self.verbose)
+        print_log(self.logger, f"Solution number limit: {self.number_solution}", 'info', verbose=self.verbose)
 
 
     def search_seed(self): 
@@ -94,19 +95,19 @@ class Hybrid(Solver):
             files.append(self.asp.ASP_SRC_MAXIMIZE_FLUX)
         if self.subset_minimal:
             self.get_message('subsetmin')
-            #logger.print_log("GROUNDING...", "info")
+            #print_log(self.logger, "GROUNDING...", "info")
             #self.grounded, timer, err_output, error_code, memory = self.ground(files, self.clingo_constant, self.is_linear, self.verbose)
             self.search_subsetmin(files)
         if self.minimize:
             self.get_message('minimize')
             if self.network.is_subseed:
                 files.append(self.asp.ASP_SRC_MAXIMIZE_PRODUCED_TARGET)
-                logger.print_log('POSSIBLE SEED: Given', "info")
-                logger.print_log('  A subset of possible seed is search \n  maximising the number of produced target', "info")
+                print_log(self.logger, 'POSSIBLE SEED: Given', "info", verbose=self.verbose)
+                print_log(self.logger, '  A subset of possible seed is search \n  maximising the number of produced target', "info", verbose=self.verbose)
                 self.clingo_constant.append('-c')
                 self.clingo_constant.append('subseed=1')  
             files.append(self.asp.ASP_SRC_MINIMIZE)
-            #logger.print_log("GROUNDING...", "info")
+            #print_log(self.logger, "GROUNDING...", "info")
             #self.grounded, timer, err_output, error_code, memory = self.ground(files, self.clingo_constant, self.is_linear, self.verbose)
             self.search_minimize(files)
             self.get_message('end')
@@ -115,7 +116,7 @@ class Hybrid(Solver):
     def search_minimize(self, asp_files):
         """Launch seed searching with minimze options
         """
-        logger.print_log("Finding optimum...", "info")
+        print_log(self.logger, "Finding optimum...", "info", verbose=self.verbose)
         self.solve(asp_files, "minimize-one-model")
 
         if self.one_model_unsat:
@@ -134,7 +135,7 @@ class Hybrid(Solver):
                 self.solve(asp_files, "minimize-enumeration")
             else:
                 self.get_message('enumeration')  
-                logger.print_log(f"\nNot computed: {opti_message}", "info") 
+                print_log(self.logger, f"\nNot computed: {opti_message}", "info", verbose=self.verbose) 
 
         if self.intersection:   
             if ok_opti:
@@ -142,7 +143,7 @@ class Hybrid(Solver):
                 self.solve(asp_files, "minimize-intersection")
             else:
                 self.get_message('intersection')
-                logger.print_log(f"\nNot computed: {opti_message}", "info")  
+                print_log(self.logger, f"\nNot computed: {opti_message}", "info", verbose=self.verbose)  
 
 
     def search_subsetmin(self, asp_files):
@@ -153,7 +154,7 @@ class Hybrid(Solver):
             self.solve(asp_files, "submin-enumeration")
         else:
             self.number_solution = 1
-            logger.print_log("\n--------------- One solution ---------------", "info")  
+            print_log(self.logger, "\n--------------- One solution ---------------", "info", verbose=self.verbose)  
             self.solve(asp_files, "submin-enumeration")
             
 
@@ -201,7 +202,7 @@ class Hybrid(Solver):
             asp_files (list, optional): List of ASP files used for sovling. Defaults to [].
             search_mode (str, optional): Describe the launch mode. . Defaults to "".
         """
-        logger.print_log("SOLVING...\n", "info")
+        print_log(self.logger, "SOLVING...\n", "info", verbose=self.verbose)
         results = dict()
         solution_list = dict()
         timer = dict()
@@ -224,35 +225,35 @@ class Hybrid(Solver):
                 proc_output, err, error_code, \
                     memory, is_killed = clingo_lpx.solve(cmd, self.time_limit)
                 self.get_message("command")
-                logger.print_log(f'{cmd_str}', 'debug')
+                print_log(self.logger, f'{cmd_str}', 'debug', verbose=self.verbose)
                 
                 self.get_error(error_code, err)
                 output_full_list, unsatisfiable, self.optimum_found, full_timers, opt = clingo_lpx.result_convert(proc_output,
                                                                                            self.network.objectives, 
                                                                                            "", is_killed, False)
                 if unsatisfiable:
-                    logger.print_log('Unsatisfiable problem', "error") 
+                    print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose) 
 
                 elif self.optimum_found: 
-                    logger.print_log("Optimum Found", "info")
+                    print_log(self.logger, "Optimum Found", "info", verbose=self.verbose)
                     self.one_model_unsat = False
                     one_model_list=output_full_list[list(output_full_list.keys())[-1]]
                     self.optimum=opt
                     self.get_separate_optimum()
                     #TODO Corrects the producible targets count
                     #if self.network.is_subseed:
-                    #    logger.print_log((f"Number of producible targets: {- self.opt_prod_tgt}"), 'info')
+                    #    print_log(self.logger, (f"Number of producible targets: {- self.opt_prod_tgt}"), 'info')
                     #TODO END
-                    logger.print_log(f"Minimal size of seed set is {self.opt_size}\n", 'info')
+                    print_log(self.logger, f"Minimal size of seed set is {self.opt_size}\n", 'info', verbose=self.verbose)
                     if self.optimum is not None and self.network.keep_import_reactions:
-                        logger.print_log("Try with the option remove import reactions.", "info")
+                        print_log(self.logger, "Try with the option remove import reactions.", "info", verbose=self.verbose)
                     solution_list[model_type] = one_model_list
                     #Get obejctives fluxes and add results seeds to network object
                     obj_flux_dict = self.get_objectives_flux(one_model_list[5])
                     self.add_result_seeds(search_mode, model_type, one_model_list[1], one_model_list[3], obj_flux_dict)
                 # Satisfiable probleme but optimum not found in given time
                 else:
-                    logger.print_log('Optimum not found', "error") 
+                    print_log(self.logger, 'Optimum not found', "error", verbose=self.verbose) 
 
             case "minimize-enumeration":
                 cmd = clingo_lpx.command(files=asp_files, options=full_option, nb_model= self.number_solution,
@@ -261,12 +262,12 @@ class Hybrid(Solver):
                 proc_output, err, error_code, \
                     memory, is_killed = clingo_lpx.solve(cmd, self.time_limit)
                 self.get_message("command")
-                logger.print_log(f'{cmd_str}', 'debug')
+                print_log(self.logger, f'{cmd_str}', 'debug', verbose=self.verbose)
                 self.get_error(error_code, err)
                 solution_list, unsatisfiable, _, full_timers, _ = clingo_lpx.result_convert(proc_output,
                                                                             self.network.objectives, "enumeration", is_killed)
                 if unsatisfiable:
-                    logger.print_log('Unsatisfiable problem', "error") 
+                    print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose) 
                 else:
                     for  model_name, solution in solution_list.items():
                         #Get obejctives fluxes and add results seeds to network object
@@ -280,12 +281,12 @@ class Hybrid(Solver):
                 proc_output, err, error_code, \
                     memory, is_killed = clingo_lpx.solve(cmd, self.time_limit)
                 self.get_message("command")
-                logger.print_log(f'{cmd_str}', 'debug')
+                print_log(self.logger, f'{cmd_str}', 'debug', verbose=self.verbose)
                 self.get_error(error_code, err)
                 solution_list, unsatisfiable, _, full_timers,_ = clingo_lpx.result_convert(proc_output,
                                                                             self.network.objectives, "enumeration", is_killed)
                 if unsatisfiable:
-                    logger.print_log('Unsatisfiable problem', "error") 
+                    print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose) 
                 else:
                     for  model_name, solution in solution_list.items():
                         #Get obejctives fluxes and add results seeds to network object
@@ -299,12 +300,12 @@ class Hybrid(Solver):
                 proc_output, err, error_code, \
                     memory, is_killed = clingo_lpx.solve(cmd, self.time_limit)
                 self.get_message("command")
-                logger.print_log(f'{cmd_str}', 'debug')
+                print_log(self.logger, f'{cmd_str}', 'debug', verbose=self.verbose)
                 self.get_error(error_code, err)
                 output_full_list, unsatisfiable, _, full_timers = clingo_lpx.result_convert(proc_output,
                                                                                 self.network.objectives, 'cautious', is_killed)
                 if unsatisfiable:
-                    logger.print_log('Unsatisfiable problem', "error") 
+                    print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose) 
                 elif output_full_list:
                     model = output_full_list[list(output_full_list.keys())[-1]]
                     solution_list[model_type ] = model
@@ -321,12 +322,12 @@ class Hybrid(Solver):
                     memory, is_killed = clingo_lpx.solve(files=asp_files, options=full_option,
                                          time_limit=self.time_limit)
                 self.get_message("command")
-                logger.print_log(f'{cmd_str}', 'debug')
+                print_log(self.logger, f'{cmd_str}', 'debug', verbose=self.verbose)
                 self.get_error(error_code, err)
                 output_full_list, unsatisfiable, _, full_timers = clingo_lpx.result_convert(proc_output,
                                                                                 self.network.objectives, 'cautious', is_killed)
                 if unsatisfiable:
-                    logger.print_log('Unsatisfiable problem', "error") 
+                    print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose) 
                 elif output_full_list:
                     model = output_full_list[list(output_full_list.keys())[-1]]
                     solution_list[model_type] = model
@@ -359,7 +360,7 @@ class Hybrid(Solver):
             print(f'error_code = {error_code}')
             raise ValueError(err.decode())
         elif err:
-            logger.print_log(err.decode(), 'debug')
+            print_log(self.logger, err.decode(), 'debug', verbose=self.verbose)
 
      ######################################################## 
 
@@ -368,7 +369,7 @@ class Hybrid(Solver):
 ##################### Class FBA : herit Hybrid #################### 
 ###################################################################
 class FBA(Hybrid):
-    def __init__(self,  run_mode:str, network:Network, 
+    def __init__(self,  run_mode:str, network:Network, log_path:str, 
                  time_limit_minute:float=None, number_solution:int=None, 
                  clingo_configuration:str=None, clingo_strategy:str=None, 
                  intersection:bool=False, union:bool=False, 
@@ -395,7 +396,7 @@ class FBA(Hybrid):
             short_option (str, optional): Short way to write option on filename. Defaults to None.
             verbose (bool, optional): Set debug mode. Defaults to False.
         """
-        super().__init__(run_mode, None, network, 
+        super().__init__(run_mode, None, network, log_path,
                          time_limit_minute, number_solution, 
                          clingo_configuration, clingo_strategy, 
                          intersection, union, minimize,
@@ -413,7 +414,7 @@ class FBA(Hybrid):
             f"                     {color.bold}FBA{color.cyan_light}\n"\
             "############################################\n" \
             "############################################\n"
-        logger.print_log(title_mess, "info", color.cyan_light) 
+        print_log(self.logger, title_mess, "info", color.cyan_light, self.verbose) 
 
     def add_result_seeds(self, search_mode:str, model_name:str, len:int, seeds:list, flux_list:list):
         """Add a formated resulted set of seeds into the network object

seed2lp/log_conf.yaml

@@ -4,22 +4,22 @@
 
 version: 1
 disable_existing_loggers: False
+
 formatters:
   simple:
     format: '%(levelname)s : %(message)s'
     () : seed2lp.logger.ColoredFormatter
     use_color: true
+
 handlers:
   console:
     class: logging.StreamHandler
     level: WARNING
     formatter: simple
     stream: ext://sys.stdout
+
 loggers:
   s2lp:
     level: DEBUG
     handlers: [console]
-    propagate: no
-root:
-  level: DEBUG
-  handlers: [console]
+    propagate: false