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

seed2lp/reasoning.py

@@ -5,14 +5,15 @@ import clyngor
 from time import time
 from .network import Network
 from .reasoninghybrid import HybridReasoning
-from . import color, logger
+from . import color
+from .logger import print_log
 
 
 ###################################################################
 ############ Class Reasoning : herit HybridReasoning ############## 
 ###################################################################
 class Reasoning(HybridReasoning):
-    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, 
@@ -37,7 +38,7 @@ class Reasoning(HybridReasoning):
             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, community_mode, all_transfers)
 
@@ -47,7 +48,7 @@ class Reasoning(HybridReasoning):
             f"                   {color.bold}REASONING{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._set_clingo_constant()
         self._set_temp_result_file()
 
@@ -58,8 +59,8 @@ class Reasoning(HybridReasoning):
         """Prepare ASP constant command for resolution
         """
         self.init_const()
-        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, f"Time limit: {self.time_limit_minute} minutes", "info")
+        print_log(self.logger,  f"Solution number limit: {self.number_solution}", "info")
     ########################################################  
 
 
@@ -92,10 +93,12 @@ class Reasoning(HybridReasoning):
                 self.search_subsetmin(timer, 'filter')
 
             if self.run_solve == "guess_check" or self.run_solve ==  "all":
+                self.diversity=False
                 self.get_message('guess_check')
                 self.search_subsetmin(timer, 'guess_check')
 
             if self.run_solve == "guess_check_div" or self.run_solve ==  "all":
+                self.diversity=True
                 self.get_message('guess_check_div')
                 self.search_subsetmin(timer, 'guess_check_div')
 
@@ -104,7 +107,7 @@ class Reasoning(HybridReasoning):
             self.get_message('minimize')
             if self.network.is_subseed:
                 self.asp_files.append(self.asp.ASP_SRC_MAXIMIZE_PRODUCED_TARGET)
-                logger.print_log('POSSIBLE SEED: Given\n  A subset of possible seed is search \n  maximising the number of produced target', 'info')
+                print_log(self.logger, 'POSSIBLE SEED: Given\n  A subset of possible seed is search \n  maximising the number of produced target', 'info')
                 self.clingo_constant.append('-c')
                 self.clingo_constant.append('subseed=1') 
             self.asp_files.append(self.asp.ASP_SRC_MINIMIZE)
@@ -143,7 +146,7 @@ class Reasoning(HybridReasoning):
             asp_files (list): List of ASP files, included th network asp file saved in temp directory
         """
         timer = dict()
-        logger.print_log('self.groundING...', 'info')
+        print_log(self.logger, 'GROUNDING...', 'info')
         time_ground = time()
         const_option = ""
         const_option = ' '.join(self.clingo_constant)
@@ -167,21 +170,21 @@ class Reasoning(HybridReasoning):
         seeds = list()
         
         if self.optimum is None:
-            logger.print_log('\tNo seed found', 'info')
+            print_log(self.logger, '\tNo seed found', 'info')
         else: 
             self.get_separate_optimum()
-            logger.print_log(f"Optimum found.", "info") 
+            print_log(self.logger, f"Optimum found.", "info") 
             if self.network.is_subseed:
-                logger.print_log((f"Number of producible targets: {- self.opt_prod_tgt}"), 'info')
-            logger.print_log(f"Minimal size of seed set is {self.opt_size}\n", 'info')
+                print_log(self.logger, (f"Number of producible targets: {- self.opt_prod_tgt}"), 'info', self.verbose)
+            print_log(self.logger, f"Minimal size of seed set is {self.opt_size}\n", 'info', self.verbose)
             if self.opt_size > 0:
                 seeds = [args[0] for args in one_model.get('seed', ())]
                 seeds=list(sorted(seeds))
             else:
                 seeds = []
                 if self.network.keep_import_reactions:
-                    logger.print_log("Try with the option remove import reactions.", 'info')
-            #logger.print_log(f"\nOne solution:\n{', '.join(map(str, seeds))}\n", 'info')
+                    print_log(self.logger, "Try with the option remove import reactions.", 'info', self.verbose)
+            #print_log(self.logger, f"\nOne solution:\n{', '.join(map(str, seeds))}\n", 'info')
             solution_list['model_one_solution'] = ["size", self.opt_size] + \
                                     ["Set of seeds", seeds]
 
@@ -195,7 +198,7 @@ class Reasoning(HybridReasoning):
             timer (dict): Timer dictionnary containing grouding time
             step (str, optional): step solving mode (classic, filter, guess_check, guess_check_div). Defaults to "classic".
         """
-        logger.print_log("Finding optimum...", "info")
+        print_log(self.logger, "Finding optimum...", "info")
         self.solve("minimize-one-model", timer, self.asp_files, step, True)
 
         if not self.optimum_found:
@@ -211,7 +214,7 @@ class Reasoning(HybridReasoning):
                 self.solve("minimize-intersection", timer, self.asp_files, step)
             else:
                 self.get_message('intersection')
-                logger.print_log(f"\nNot computed: {opti_message}", "error") 
+                print_log(self.logger, f"\nNot computed: {opti_message}", "error") 
             
         if self.union:       
             if ok_opti:
@@ -219,7 +222,7 @@ class Reasoning(HybridReasoning):
                 self.solve("minimize-union", timer, self.asp_files, step)
             else:
                 self.get_message('union')
-                logger.print_log(f"\nNot computed: {opti_message}", "error") 
+                print_log(self.logger, f"\nNot computed: {opti_message}", "error") 
 
         if self.enumeration: 
             if ok_opti:
@@ -227,7 +230,7 @@ class Reasoning(HybridReasoning):
                 self.solve("minimize-enumeration", timer, self.asp_files, step)
             else:
                 self.get_message('enumeration') 
-                logger.print_log(f"\nNot computed: {opti_message}", "error")
+                print_log(self.logger, f"\nNot computed: {opti_message}", "error")
 
 
     def search_subsetmin(self, timer:dict, step:str="classic"):
@@ -247,7 +250,7 @@ class Reasoning(HybridReasoning):
 
         if self.intersection: 
             self.get_message('intersection')
-            logger.print_log("SOLVING...\n", "info")
+            print_log(self.logger, "SOLVING...\n", "info")
             self.solve("submin-intersection", timer, self.asp_files, step)
         
 
@@ -282,7 +285,7 @@ class Reasoning(HybridReasoning):
             is_one_model (bool, optional): Define if it is the minimizing one model we are searching. Defaults to False.
         """
 
-        logger.print_log("SOLVING...\n", "info")
+        print_log(self.logger, "SOLVING...\n", "info")
         results = dict()
         one_model = None
         number_rejected = None
@@ -305,7 +308,7 @@ class Reasoning(HybridReasoning):
                                     time_limit=self.time_limit).discard_quotes.by_predicate
                 time_solve = time() - time_solve
                 self.get_message("command")
-                logger.print_log(f'{models.command}', 'debug')
+                print_log(self.logger, f'{models.command}', 'debug')
                 for model, opt, optimum_found in models.by_arity.with_optimality:
                     if optimum_found:
                         self.optimum_found = True
@@ -318,7 +321,7 @@ class Reasoning(HybridReasoning):
                             else:
                                 self.optimum = 0
                 if not self.optimum_found:
-                    logger.print_log('Optimum not found', "error") 
+                    print_log(self.logger, 'Optimum not found', "error") 
                 else:
                     solution_list, seeds = self.write_one_model_solution(one_model)
                     self.network.add_result_seeds('REASONING', search_mode, model_type, len(seeds), seeds)
@@ -340,7 +343,7 @@ class Reasoning(HybridReasoning):
                                     time_limit=self.time_limit).discard_quotes.by_predicate
                 time_solve = time() - time_solve
                 self.get_message("command")
-                logger.print_log(f'{models.command}', 'debug')
+                print_log(self.logger, f'{models.command}', 'debug')
                 has_solution=False
                 for model in models:
                     has_solution=True
@@ -357,7 +360,7 @@ class Reasoning(HybridReasoning):
                     solution_list, _ = self.complete_solutions(solution_list, 'model_'+ model_type, len(seeds), seeds)
                     self.network.add_result_seeds('REASONING', search_mode, model_type, len(seeds), seeds)
                 else:
-                    logger.print_log('Unsatisfiable problem', "error") 
+                    print_log(self.logger, 'Unsatisfiable problem', "error") 
 
             # FILTER OR GUESS-CHECK mode
             #TODO redo intersection and union mode
@@ -401,7 +404,7 @@ class Reasoning(HybridReasoning):
             models = clyngor.solve(files=asp_files, options=construct_option, 
                                 time_limit=self.time_limit, nb_model=self.number_solution).discard_quotes.by_predicate
         self.get_message("command")
-        logger.print_log(f'{models.command}', 'debug')
+        print_log(self.logger, f'{models.command}', 'debug')
         idx = 1
         m = models
         models_list = list(m).copy()
@@ -428,7 +431,7 @@ class Reasoning(HybridReasoning):
                 self.network.add_result_seeds('REASONING', search_mode, 'model_'+str(idx), size, seeds, transferred_list=trans_solution_list)
                 idx += 1
         else:
-            logger.print_log('Unsatisfiable problem', "error")
+            print_log(self.logger, 'Unsatisfiable problem', "error")
         return solution_list
 
 

seed2lp/reasoningcom.py

@@ -6,7 +6,7 @@ from . import color, logger
 from multiprocessing import Process, Queue
 from os import path
 from json import loads
-
+from .logger import init_logger, print_log
 
 USE_MULTIPROCESSING=True
 
@@ -14,7 +14,7 @@ USE_MULTIPROCESSING=True
 ################# Class Reasoning : herit Solver ################## 
 ###################################################################
 class ComReasoning(Reasoning):
-    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, 
@@ -39,7 +39,7 @@ class ComReasoning(Reasoning):
             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, run_solve, network,
+        super().__init__(run_mode, run_solve, network, log_path,
                         time_limit_minute, number_solution, 
                         clingo_configuration, clingo_strategy, 
                         intersection, union, 
@@ -114,6 +114,9 @@ class ComReasoning(Reasoning):
         Returns:
             solution_list (dict): a dictionnary of all found solutions
         """
+
+        # Init logger for child process
+        init_logger(self.log_path, self.verbose)
        
         cobra_flux=None
         # Guess_check or Guess_check diversity mode   
@@ -197,12 +200,12 @@ class ComReasoning(Reasoning):
                             res = self.network.check_seeds(seeds, trans_solution_list)
                             if res[0]:
                                 # valid solution
-                                logger.print_log(f'CHECK Solution {size_seeds} seeds -> OK\n', 'debug')
+                                print_log(self.logger, f'CHECK Solution {size_seeds} seeds -> OK\n', 'debug', verbose=self.verbose)
                                 cobra_flux=res[1]
                                 self.network.add_result_seeds(mode, "Community bisteps", 'model_'+str(idx), size_seeds, seeds, flux_cobra=cobra_flux, transferred_list=trans_solution_list)
                                 keep_solution=True
                             else:
-                                logger.print_log(f'CHECK Solution {size_seeds} seeds -> KO\n', 'debug')
+                                print_log(self.logger, f'CHECK Solution {size_seeds} seeds -> KO\n', 'debug', verbose=self.verbose)
                                 number_rejected +=1
                                 keep_solution=False
                                 current_timer = time() - start_time
@@ -240,12 +243,12 @@ class ComReasoning(Reasoning):
     
 
         if step != "classic":
-            logger.print_log(f'Rejected solution during process: {number_rejected} \n', "info")
+            print_log(self.logger, f'Rejected solution during process: {number_rejected} \n', "info", verbose=self.verbose)
         else:
             number_rejected=None
 
         if not any(solution_list): 
-            logger.print_log('Unsatisfiable problem', "error")
+            print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose)
             
         if USE_MULTIPROCESSING:
             queue.put([self, solution_list, None, current_timer, number_rejected])
@@ -336,15 +339,19 @@ class ComReasoning(Reasoning):
 
         Args:
             full_option (list): All Clingo option 
-            solution_list (dict): _description_
+            solution_list (dict): Dictionnary containg the solutions
             step (str): step solving mode (classic, filter, guess_check, guess_check_div).
             asp_files (list):  List of needed ASP files to solve ASP (Clingo package)
             queue (Queue, optional): Queue for multiprocessing program (managing time limit). Defaults to None.
             full_path (str, optional):  Full path of temporary solution file. Defaults to None.
 
         Returns:
-            _type_: _description_
+            list, int: List of solutions and numer of rejected solutions
         """
+
+        # Init logger for child process
+        init_logger(self.log_path, self.verbose)
+
         all_time_solve = 0
         all_time_ground = 0
         dict_by_size_seeds=dict()
@@ -396,11 +403,11 @@ class ComReasoning(Reasoning):
                         res = self.network.check_seeds(seeds, trans_solution_list)
                         if res[0]:
                             # valid solution
-                            logger.print_log(f'CHECK Solution {size} seeds -> OK\n', 'debug')
+                            print_log(self.logger, f'CHECK Solution {size} seeds -> OK\n', 'debug', verbose=self.verbose)
                             cobra_flux=res[1]
                             keep_solution=True
                         else:
-                            logger.print_log(f'CHECK Solution {size} seeds -> KO\n', 'debug')
+                            print_log(self.logger, f'CHECK Solution {size} seeds -> KO\n', 'debug', verbose=self.verbose)
                             number_rejected +=1
                             keep_solution=False
                             current_timer = time() - start_time
@@ -477,7 +484,7 @@ class ComReasoning(Reasoning):
             solution_list = self.add_print_solution(solution_list, dict_by_size_seeds, mode, cobra_flux)
 
         if step != "classic":
-            logger.print_log(f'Rejected solution during process: {number_rejected} \n', "info")
+            print_log(self.logger, f'Rejected solution during process: {number_rejected} \n', "info", verbose=self.verbose)
         else:
             number_rejected=None
 
@@ -590,13 +597,13 @@ class ComReasoning(Reasoning):
                     number_rejected = solution[3]
 
             except Exception as e:
-                logger.print_log(f"An error occured while reading temporary file\n {full_path}:\n {e}", 'error')
+                print_log(self.logger, f"An error occured while reading temporary file\n {full_path}:\n {e}", 'error', self.verbose)
 
             if any(solution_list):
                 solution_list = self.add_print_solution(solution_list, dict_by_size_seeds, mode, flux_cobra) 
 
             if step != "classic":
-                logger.print_log(f'Rejected solution during process: at least {number_rejected} \n', 'info')
+                print_log(self.logger, f'Rejected solution during process: at least {number_rejected} \n', 'info', self.verbose)
 
         delete(full_path)
         return solution_list, number_rejected
@@ -642,7 +649,7 @@ class ComReasoning(Reasoning):
             else:
                 time_out = True
             if time_out:
-                logger.print_log(f'Time out: {self.time_limit_minute} min expired', "error")
+                print_log(self.logger, f'Time out: {self.time_limit_minute} min expired', "error", verbose=self.verbose)
 
             match step:
                 case "classic":
@@ -659,7 +666,7 @@ class ComReasoning(Reasoning):
         queue.close()
 
         if not any(solution_list): 
-            logger.print_log('Unsatisfiable problem', "error")
+            print_log(self.logger, 'Unsatisfiable problem', "error", verbose=self.verbose)
 
         if time_ground != None:
             if time_ground != -1:
@@ -694,10 +701,10 @@ class ComReasoning(Reasoning):
                 match search_mode, step:
                     # CLASSIC MODE (NO FILTER, NO GUESS-CHECK)   
                     case "minimize-enumeration" | "minimize-one-model", _:
-                        logger.print_log("No minimisation in community", "warning")
+                        print_log(self.logger, "No minimisation in community", "warning", verbose=self.verbose)
 
                     case "submin-enumeration", _:
-                        logger.print_log("SOLVING...\n", "info")
+                        print_log(self.logger, "SOLVING...\n", "info", verbose=self.verbose)
                         if USE_MULTIPROCESSING:
                             self.run_multiprocess(full_option, solution_list, step, asp_files, timer, output_type, suffix, search_mode)
                         else :
@@ -727,13 +734,13 @@ class ComReasoning(Reasoning):
                 match search_mode, step:
                     # CLASSIC MODE (NO FILTER, NO GUESS-CHECK)   
                     case "minimize-enumeration" | "minimize-one-model", _:
-                        logger.print_log("No minimisation in community", "warning")
+                        print_log(self.logger, "No minimisation in community", "warning", verbose=self.verbose)
 
                     # Because of specific analyse of solution with "manual deletion of previous superset"
                     # All solving mode are in one function (classic, filter, guess check and gues check div)
                     # unlike all other community modes (or signle network modes)
                     case "submin-enumeration", "classic" | "filter" | "guess_check" | "guess_check_div":
-                        logger.print_log("SOLVING...\n", "info")
+                        print_log(self.logger, "SOLVING...\n", "info", verbose=self.verbose)
                         
                         # Time limit may not work well if no solutions found within time limit
                         # But save time from writting into temporary file

seed2lp/reasoninghybrid.py

@@ -3,7 +3,8 @@ from .network import Network
 from multiprocessing import Process, Queue
 from .file import save, delete, write_instance_file, load_tsv, existing_file
 import clingo
-from . import color, logger
+from . import color
+from .logger import init_logger, print_log
 from os import path
 import random
 from time import time
@@ -13,7 +14,7 @@ from json import loads
 ############# Class HybridReasoning : herit Solver ################ 
 ###################################################################
 class HybridReasoning(Solver):
-    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, 
@@ -37,7 +38,7 @@ class HybridReasoning(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, community_mode)
         
@@ -76,7 +77,7 @@ class HybridReasoning(Solver):
             ctrl.ground([("diversity",[])])
 
         self.get_message("command")
-        logger.print_log('clingo ' + ' '.join(full_option) + ' ' + ' '.join(asp_files), 'debug')
+        print_log(self.logger, 'clingo ' + ' '.join(full_option) + ' ' + ' '.join(asp_files), 'debug', verbose=self.verbose)
         return ctrl
     
 
@@ -385,9 +386,9 @@ class HybridReasoning(Solver):
                                 solution_list[solution[0]] = sol
                             #get the last occurence pf rejected solutions number
                             number_rejected = solution[3]
-                    logger.print_log(f'Rejected solution during process: at least {number_rejected} \n', 'info')
+                    print_log(self.logger, f'Rejected solution during process: at least {number_rejected} \n', 'info', verbose=self.verbose)
                 except Exception as e:
-                    logger.print_log(f"An error occured while reading temporary file\n {full_path}:\n {e}", 'error')
+                    print_log(self.logger, f"An error occured while reading temporary file\n {full_path}:\n {e}", 'error', verbose=self.verbose)
 
                 if any(solution_list):
                     for name in solution_list:
@@ -453,7 +454,7 @@ class HybridReasoning(Solver):
             else:
                 time_out = True
             if time_out:
-                logger.print_log(f'Time out: {self.time_limit_minute} min expired', "error")
+                print_log(self.logger, f'Time out: {self.time_limit_minute} min expired', "error", self.verbose)
             
             solution_list, number_rejected = self.get_solution_from_temp(unsat, is_one_model, full_path, suffix, search_mode)
         p.terminate()
@@ -461,10 +462,10 @@ class HybridReasoning(Solver):
 
         if is_one_model:
             if not self.optimum_found:
-                logger.print_log('Optimum not found', "error") 
+                print_log(self.logger, 'Optimum not found', "error", self.verbose) 
         else:
             if not any(solution_list): 
-                logger.print_log('Unsatisfiable problem', "error")
+                print_log(self.logger, 'Unsatisfiable problem', "error", self.verbose)
 
         return time_solve, time_ground, solution_list, number_rejected
     
@@ -528,6 +529,9 @@ class HybridReasoning(Solver):
             is_one_model (bool, optional): Define if the solution we want is to fin the optimum when minimize is used (before enumration).
                                          Defaults to False.
         """
+        # Init logger for child process
+        init_logger(self.log_path, self.verbose)
+
         solution_list = dict()
 
         no_limit_solution = False
@@ -554,7 +558,7 @@ class HybridReasoning(Solver):
                         res = self.network.check_seeds(seeds, trans_solution_list)
                         if res[0]:
                             # valid solution
-                            logger.print_log(f'CHECK Solution {size} seeds -> OK\n', 'debug')
+                            print_log(self.logger, f'CHECK Solution {size} seeds -> OK\n', 'debug', verbose=self.verbose)
                             
                             message = color.cyan_light + f"Answer: {solution_idx}{color.reset} ({size} seeds{transf_short})\n"
                             self.print_answer(message, seeds, seeds_full, trans_complete)
@@ -567,7 +571,7 @@ class HybridReasoning(Solver):
                             self.network.add_result_seeds('REASONING FILTER', search_mode, name, size, seeds, flux_cobra=res[1], transferred_list=trans_solution_list)
                             solution_idx +=1
                         else:
-                            logger.print_log(f'CHECK Solution {size} seeds -> KO\n', 'debug')
+                            print_log(self.logger, f'CHECK Solution {size} seeds -> KO\n', 'debug', verbose=self.verbose)
                             number_rejected +=1
                             current_timer = time() - start_time
                             # write all 100 rejected 
@@ -588,7 +592,7 @@ class HybridReasoning(Solver):
                 else:
                     break
             
-        logger.print_log(f'Rejected solution during process: {number_rejected} \n', "info")
+        print_log(self.logger, f'Rejected solution during process: {number_rejected} \n', "info", verbose=self.verbose)
 
         stats = ctrl.statistics
         total_time = stats["summary"]["times"]["total"]
@@ -598,10 +602,10 @@ class HybridReasoning(Solver):
         # Because it is needed to get all answers from clingo to have optimum, we save it after
         # No minimize in community mode
         if is_one_model and self.optimum_found:
-            logger.print_log(f"Optimum found.", "info") 
+            print_log(self.logger, f"Optimum found.", "info", verbose=self.verbose) 
             if self.network.is_subseed:
-                logger.print_log(f"Number of producible targets: {- self.opt_prod_tgt}", "info")
-            logger.print_log(f"Minimal size of seed set is {self.opt_size}\n", "info")
+                print_log(self.logger, f"Number of producible targets: {- self.opt_prod_tgt}", "info", verbose=self.verbose)
+            print_log(self.logger, f"Minimal size of seed set is {self.opt_size}\n", "info", verbose=self.verbose)
             save(full_path, self.temp_dir, solution_temp, "tsv", True)               
             self.network.add_result_seeds('REASONING FILTER', search_mode, name, size, seeds, flux_cobra=res[1], transferred_list=trans_solution_list) 
 
@@ -662,6 +666,9 @@ class HybridReasoning(Solver):
             is_one_model (bool, optional): Define if the solution we want is to fin the optimum when minimize is used (before enumration).
                                          Defaults to False.
         """
+        # Init logger for child process
+        init_logger(self.log_path, self.verbose)
+
         solution_list = dict()
         avoided = []
         all_time_solve = 0
@@ -724,7 +731,7 @@ class HybridReasoning(Solver):
             all_time_ground += float(time_ground)
             res = self.network.check_seeds(seeds, trans_solution_list)
             if res[0]:
-                logger.print_log(f'CHECK Solution {size} seeds -> OK\n', 'debug')
+                print_log(self.logger, f'CHECK Solution {size} seeds -> OK\n', 'debug', verbose=self.verbose)
                 # valid solution
                 if not is_one_model:
                     message = color.cyan_light + f"Answer: {solution_idx}{color.reset} ({size} seeds{transf_short})\n"
@@ -743,26 +750,24 @@ class HybridReasoning(Solver):
                     name = 'model_one_solution'
                     solution_list, solution_temp = self.complete_solutions(solution_list, name, size, seeds, 
                            trans_solution_list, res[1], number_rejected)
-                    logger.print_log(f"Optimum found.", "info") 
+                    print_log(self.logger, f"Optimum found.", "info", verbose=self.verbose) 
                     self.optimum_found = True
-                    mode = 'REASONING GUESS-CHECK'
+                    mode = self.get_gc_mode()
                     # Do not exclude superset because we will rerun the minimize by set the size
                     # and we want to find back this first minimize found
                     if self.diversity: 
                         ctrl, avoided = self.add_diversity(ctrl, seeds, avoided) 
-                        mode =  'REASONING GUESS-CHECK DIVERSITY'
                     save(full_path, self.temp_dir, solution_temp, "tsv", True)
-
                     self.network.add_result_seeds(mode, search_mode, name, size, seeds, flux_cobra=res[1], transferred_list=trans_solution_list)
                     self.get_separate_optimum()
                     if self.network.is_subseed:
-                        logger.print_log(f"Number of producible targets: {- self.opt_prod_tgt}", "info")
-                    logger.print_log(f"Minimal size of seed set is {self.opt_size}\n", "info")
+                        print_log(self.logger, f"Number of producible targets: {- self.opt_prod_tgt}", "info", verbose=self.verbose)
+                    print_log(self.logger, f"Minimal size of seed set is {self.opt_size}\n", "info", verbose=self.verbose)
                     break
                 
             else:
-                logger.print_log(f'CHECK Solution {size} seeds -> KO\n', 'debug')
-                #logger.print_log(f'{seeds}\n', 'debug')
+                print_log(self.logger, f'CHECK Solution {size} seeds -> KO\n', 'debug', verbose=self.verbose)
+                #print_log(self.logger, f'{seeds}\n', 'debug')
                 
                 ctrl, avoided= self.guess_check_constraints(ctrl, atoms, seeds, avoided)
                 mode = self.get_gc_mode()
@@ -782,7 +787,7 @@ class HybridReasoning(Solver):
 
         if not is_one_model:
             save(full_path, "", solution_temp, "tsv", True)
-            logger.print_log(f'Rejected solution during process: {number_rejected} \n', 'info')
+            print_log(self.logger, f'Rejected solution during process: {number_rejected} \n', 'info', verbose=self.verbose)
 
         ctrl.cleanup()
         ctrl.interrupt()

seed2lp/sbml.py

@@ -1,9 +1,10 @@
 """Routines to extract information from SBML files.
 
 """
+import logging
 import xml.etree.ElementTree as ET
 from re import sub, match, search
-from . import logger
+#from . import logger
 
 def register_all_namespaces(file:str):
     """Get namespaces for rewriting SBML file
@@ -245,6 +246,7 @@ def get_used_metabolites(filename, call_log=False)-> set:
     Returns:
         used_metabolites (set): Set of used metabolites
     """
+    logger = logging.getLogger("s2lp")
     tree = ET.parse(filename)
     sbml = tree.getroot()
     model = get_model(sbml)
@@ -262,7 +264,7 @@ def get_used_metabolites(filename, call_log=False)-> set:
         ubound =  parameters[reaction.attrib.get('{'+fbc+'}upperFluxBound')]
         lbound = parameters[reaction.attrib.get('{'+fbc+'}lowerFluxBound')]
         if float(ubound) == 0 and float(lbound) == 0  and call_log:
-            logger.log.warning(f"Reaction {reaction.attrib['id']} deleted, boudaries [0,0]")
+            logger.warning(f"Reaction {reaction.attrib['id']} deleted, boudaries [0,0]")
             continue
         else:
             reactants,_ = get_listOfReactants(reaction,"",False)