Logger is now an attribute of the execution context

src/core/sheerka/Services/SheerkaExecute.py

@@ -10,7 +10,7 @@ class SheerkaExecute:
     def __init__(self, sheerka):
         self.sheerka = sheerka
 
-    def call_parsers(self, execution_context, return_values, logger=None):
+    def call_parsers(self, execution_context, return_values):
 
         # return_values must be a list
         if not isinstance(return_values, list):
@@ -35,8 +35,6 @@ class SheerkaExecute:
         instantiated_parsers = [parser(sheerka=self.sheerka) for parser in self.sheerka.parsers.values()]
         grouped_parsers = {}
         for parser in [p for p in instantiated_parsers if p.enabled]:
-            if logger:
-                parser.log = logger
             grouped_parsers.setdefault(parser.priority, []).append(parser)
         sorted_priorities = sorted(grouped_parsers.keys(), reverse=True)
 
@@ -56,9 +54,9 @@ class SheerkaExecute:
                     # if self.sheerka.log.isEnabledFor(logging.DEBUG):
                     #     debug_text = "'" + to_parse + "'" if isinstance(to_parse, str) \
                     #         else "'" + BaseParser.get_text_from_tokens(to_parse) + "' as tokens"
-                    #     execution_context.log(logger or self.sheerka.log, f"Parsing {debug_text}")
+                    #     execution_context.log(f"Parsing {debug_text}")
 
-                    with execution_context.push(desc=f"Parsing using {parser.name}") as sub_context:
+                    with execution_context.push(desc=f"Parsing using {parser.name}", logger=parser.verbose_log) as sub_context:
                         sub_context.add_inputs(to_parse=to_parse)
                         res = parser.parse(sub_context, to_parse)
                         if res is not None:
@@ -92,7 +90,7 @@ class SheerkaExecute:
         result = core.utils.remove_list_from_list(result, user_inputs)
         return result
 
-    def call_evaluators(self, execution_context, return_values, process_step, evaluation_context=None, logger=None):
+    def call_evaluators(self, execution_context, return_values, process_step, evaluation_context=None):
 
         # return_values must be a list
         if not isinstance(return_values, list):
@@ -122,8 +120,6 @@ class SheerkaExecute:
         instantiated_evaluators = self._preprocess_evaluators(execution_context, instantiated_evaluators)
 
         for evaluator in [e for e in instantiated_evaluators if e.enabled and process_step in e.steps]:
-            if logger:
-                evaluator.log = logger
             grouped_evaluators.setdefault(evaluator.priority, []).append(evaluator)
 
         # order the groups by priority, the higher first
@@ -145,7 +141,7 @@ class SheerkaExecute:
                         evaluator = self._preprocess_evaluators(execution_context, evaluator.__class__())  # fresh copy
 
                         sub_context_desc = f"Evaluating using {evaluator.name} ({priority=})"
-                        with iteration_context.push(desc=sub_context_desc) as sub_context:
+                        with iteration_context.push(desc=sub_context_desc, logger=evaluator.verbose_log) as sub_context:
                             sub_context.add_inputs(return_values=original_items)
 
                             # process evaluators that work on one simple return value at the time
@@ -206,28 +202,26 @@ class SheerkaExecute:
         return_values = core.utils.remove_list_from_list(return_values, evaluation_return_values)
         return return_values
 
-    def execute(self, execution_context, return_values, execution_steps, logger=None):
+    def execute(self, execution_context, return_values, execution_steps):
         """
         Executes process for all initial contexts
         :param execution_context:
         :param return_values:
         :param execution_steps:
-        :param logger: logger to use (if not directly called by sheerka)
         :return:
         """
 
         for step in execution_steps:
             copy = return_values[:] if hasattr(return_values, "__iter__") else [return_values]
             with execution_context.push(step=step, iteration=0, desc=f"{step=}") as sub_context:
-                sub_context.log(logger or self.sheerka.log, f"{step=}, context='{sub_context}'")
 
                 if step == BuiltinConcepts.PARSING:
-                    return_values = self.call_parsers(sub_context, return_values, logger)
+                    return_values = self.call_parsers(sub_context, return_values)
                 else:
-                    return_values = self.call_evaluators(sub_context, return_values, step, None, logger)
+                    return_values = self.call_evaluators(sub_context, return_values, step, None)
 
                 if copy != return_values:
-                    sub_context.log_result(logger or self.sheerka.log, return_values)
+                    sub_context.log_result(return_values)
 
                 sub_context.add_values(return_values=return_values)