Added SyaNodeParser (finally, after one month)

src/core/sheerka/Services/SheerkaExecute.py

@@ -33,6 +33,8 @@ class SheerkaExecute:
 
         # group the parsers by priorities
         instantiated_parsers = [parser(sheerka=self.sheerka) for parser in self.sheerka.parsers.values()]
+        instantiated_parsers = self.preprocess(execution_context, instantiated_parsers)
+
         grouped_parsers = {}
         for parser in [p for p in instantiated_parsers if p.enabled]:
             grouped_parsers.setdefault(parser.priority, []).append(parser)
@@ -44,7 +46,6 @@ class SheerkaExecute:
 
             for parser in grouped_parsers[priority]:
 
-                return_value_success_found = False
                 for return_value in inputs_for_this_group:
 
                     to_parse = return_value.body.body \
@@ -67,22 +68,23 @@ class SheerkaExecute:
                                     r.parents = [return_value]
                                     result.append(r)
                                     if self.sheerka.isinstance(r.body, BuiltinConcepts.PARSER_RESULT):
+                                        # if a ParserResultConcept is returned, it will be used by the parsers
+                                        # of the following groups
                                         to_process.append(r)
                                     if r.status:
-                                        return_value_success_found = True
+                                        stop_processing = True
 
                             else:
                                 res.parents = [return_value]
                                 result.append(res)
                                 if self.sheerka.isinstance(res.body, BuiltinConcepts.PARSER_RESULT):
+                                    # if a ParserResultConcept is returned, it will be used by the parsers
+                                    # of the following groups
                                     to_process.append(res)
                                 if res.status:
-                                    return_value_success_found = True
+                                    stop_processing = True
                         sub_context.add_values(return_values=res)
 
-                    if return_value_success_found:
-                        stop_processing = True
-                        break  # Stop the other return_values (but not the other parsers with the same priority)
 
             if stop_processing:
                 break  # Do not try the other priorities if a match is found
@@ -102,7 +104,7 @@ class SheerkaExecute:
         instantiated_evaluators = [e_class() for e_class in self.sheerka.evaluators]
 
         # pre-process evaluators if needed
-        instantiated_evaluators = self._preprocess_evaluators(execution_context, instantiated_evaluators)
+        instantiated_evaluators = self.preprocess(execution_context, instantiated_evaluators)
 
         for evaluator in [e for e in instantiated_evaluators if e.enabled and process_step in e.steps]:
             grouped_evaluators.setdefault(evaluator.priority, []).append(evaluator)
@@ -123,7 +125,7 @@ class SheerkaExecute:
                     evaluated_items = []
                     to_delete = []
                     for evaluator in grouped_evaluators[priority]:
-                        evaluator = self._preprocess_evaluators(execution_context, evaluator.__class__())  # fresh copy
+                        evaluator = self.preprocess(execution_context, evaluator.__class__())  # fresh copy
 
                         sub_context_desc = f"Evaluating using {evaluator.name} ({priority=})"
                         with iteration_context.push(desc=sub_context_desc, logger=evaluator.verbose_log) as sub_context:
@@ -215,22 +217,29 @@ class SheerkaExecute:
 
         return return_values
 
-    def _preprocess_evaluators(self, context, evaluators):
+    def preprocess(self, context, parsers_or_evaluators):
         if not context.preprocess:
-            return evaluators
+            return parsers_or_evaluators
 
-        if not hasattr(evaluators, "__iter__"):
+        if not hasattr(parsers_or_evaluators, "__iter__"):
             single_one = True
-            evaluators = [evaluators]
+            parsers_or_evaluators = [parsers_or_evaluators]
         else:
             single_one = False
 
         for preprocess in context.preprocess:
-            for e in evaluators:
-                if preprocess.props["name"].value == e.name:
+            for e in parsers_or_evaluators:
+                if self.matches(e.name, preprocess.get_prop("name")):
                     for prop, value in preprocess.props.items():
                         if prop == "name":
                             continue
                         if hasattr(e, prop):
                             setattr(e, prop, value.value)
-        return evaluators[0] if single_one else evaluators
+        return parsers_or_evaluators[0] if single_one else parsers_or_evaluators
+
+    @staticmethod
+    def matches(parser_or_evaluator_name, preprocessor_name):
+        if preprocessor_name.endswith("*"):
+            return parser_or_evaluator_name.startswith(preprocessor_name[:-1])
+        else:
+            return parser_or_evaluator_name == preprocessor_name