Enhanced complex concepts handling

evaluators/PythonEvaluator.py

@@ -40,7 +40,7 @@ class PythonEvaluator(OneReturnValueEvaluator):
                     not_for_me = context.sheerka.new(BuiltinConcepts.NOT_FOR_ME, body=node)
                     return sheerka.ret(self.name, False, not_for_me, parents=[return_value])
 
-            my_locals = self.get_locals(context, node.ast_)
+            my_locals = self.get_locals(context, node)
             context.log(self.verbose_log, f"locals={my_locals}", self.name)
 
             if isinstance(node.ast_, ast.Expression):
@@ -58,7 +58,7 @@ class PythonEvaluator(OneReturnValueEvaluator):
             error = sheerka.new(BuiltinConcepts.ERROR, body=error)
             return sheerka.ret(self.name, False, error, parents=[return_value])
 
-    def get_locals(self, context, ast_):
+    def get_locals(self, context, node):
         my_locals = {"sheerka": context.sheerka}
         if context.obj:
             context.log(self.verbose_log,
@@ -70,30 +70,32 @@ class PythonEvaluator(OneReturnValueEvaluator):
                 else:
                     my_locals[prop_name] = context.sheerka.value(prop_value.value)
 
-        node_concept = core.ast.nodes.python_to_concept(ast_)
+        node_concept = core.ast.nodes.python_to_concept(node.ast_)
         unreferenced_names_visitor = UnreferencedNamesVisitor(context.sheerka)
         unreferenced_names_visitor.visit(node_concept)
 
         for name in unreferenced_names_visitor.names:
             context.log(self.verbose_log, f"Resolving '{name}'.", self.name)
-            return_concept = False
 
-            if name.startswith("__C__") and name.endswith("__C__"):
-                name_resolved = name[5:-5]
-                return_concept = True
+            if name in node.concepts:
+                context.log(self.verbose_log, f"Using value from node.", self.name)
+                concept = node.concepts[name]
+                return_concept = False
+
             else:
-                name_resolved = name
+                concept_key, concept_id, return_concept = self.resolve_name(context, name)
 
-            if name_resolved in my_locals:
-                context.log(self.verbose_log, f"Using value from property.", self.name)
-                continue
+                if concept_key in my_locals:
+                    context.log(self.verbose_log, f"Using value from property.", self.name)
+                    continue
 
-            concept = context.sheerka.new(name_resolved)
-            if context.sheerka.isinstance(concept, BuiltinConcepts.UNKNOWN_CONCEPT):
-                context.log(self.verbose_log, f"'{name_resolved}' is not a concept. Skipping.", self.name)
-                continue
+                context.log(self.verbose_log, f"Instantiating new concept.", self.name)
+                concept = context.sheerka.new((concept_key, concept_id))
+                if context.sheerka.isinstance(concept, BuiltinConcepts.UNKNOWN_CONCEPT):
+                    context.log(self.verbose_log, f"'{concept_key}' is not a concept. Skipping.", self.name)
+                    continue
 
-            context.log(self.verbose_log, f"'{name_resolved}' is a concept. Evaluating.", self.name)
+            context.log(self.verbose_log, f"Evaluating '{concept}'", self.name)
             with context.push(self.name, desc=f"Evaluating '{concept}'", obj=concept) as sub_context:
                 sub_context.log_new(self.verbose_log)
                 evaluated = context.sheerka.evaluate_concept(sub_context, concept, self.verbose_log)
@@ -109,6 +111,58 @@ class PythonEvaluator(OneReturnValueEvaluator):
 
         return my_locals
 
+    def resolve_name(self, context, to_resolve):
+        """
+        Try to match
+        __C__concept_key__C__
+        or
+        __C__concept_key__concept_id__C__
+
+        :param context:
+        :param to_resolve:
+        :return:
+        """
+        if not to_resolve.startswith("__C__"):
+            return to_resolve, None, False
+
+        context.log(self.verbose_log, f"Resolving name '{to_resolve}'.", self.name)
+
+        if len(to_resolve) >= 18 and to_resolve[:18] == "__C__USE_CONCEPT__":
+            use_concept = True
+            index = 18
+        else:
+            use_concept = False
+            index = 5
+
+        try:
+            next_index = to_resolve.index("__", index)
+            if next_index == index:
+                context.log(self.verbose_log, f"Error: no key between '__'.", self.name)
+                return None
+            concept_key = to_resolve[index: next_index]
+        except ValueError:
+            context.log(self.verbose_log, f"Error: Missing trailing '__'.", self.name)
+            return None
+
+        if next_index == len(to_resolve) - 5:
+            context.log(self.verbose_log, f"Recognized concept '{concept_key}'", self.name)
+            return concept_key, None, use_concept
+
+        index = next_index + 2
+        try:
+            next_index = to_resolve.index("__", index)
+            if next_index == index:
+                context.log(self.verbose_log, f"Error: no id between '__'.", self.name)
+                return None
+
+            concept_id = to_resolve[index: next_index]
+        except ValueError:
+            context.log(self.verbose_log, f"Recognized concept '{concept_key}'.", self.name)
+            return concept_key, None, use_concept
+
+        context.log(self.verbose_log, f"Recognized concept '{concept_key}' (id='{concept_id}').", self.name)
+        return concept_key, concept_id, use_concept
+
     @staticmethod
     def expr_to_expression(expr):
         expr.lineno = 0