ExactConceptParser can now recognize concepts by their names

src/core/sheerka/Sheerka.py

@@ -491,8 +491,14 @@ class Sheerka(Concept):
         return self._get_unknown(metadata)
 
     def resolve(self, concept):
+
+        def new_instances(concepts):
+            if hasattr(concepts, "__iter__"):
+                return [self.new_from_template(c, c.key) for c in concepts]
+            return self.new_from_template(concepts, concepts.key)
+
         if concept is None:
-            return concept
+            return None
 
         # if the entry is a concept token, use its values.
         if isinstance(concept, Token):
@@ -500,24 +506,34 @@ class Sheerka(Concept):
                 return None
             concept = concept.value
 
+        if isinstance(concept, str) and \
+            concept.startswith("c:") and \
+            (tmp := core.utils.unstr_concept(concept)) != (None, None):
+            concept = tmp
+
         # if the entry is a tuple
         # concept[0] is the name
         # concept[1] is the id
         if isinstance(concept, tuple):
             if concept[1]:
                 if self.is_known(found := self.get_by_id(concept[1])):
-                    return found
+                    instance = self.new_from_template(found, found.key)
+                    instance.metadata.is_evaluated = True
+                    return instance
             elif concept[0]:
-                return found if self.is_known(found := self.get_by_name(concept[0])) else None
+                if self.is_known(found := self.get_by_name(concept[0])):
+                    instances = new_instances(found)
+                    core.builtin_helpers.set_is_evaluated(instances)
+                    return instances
             else:
                 return None
 
         # otherwise search in db
         if isinstance(concept, str):
-            if self.is_known(found := self.get_by_id(concept)):
-                return found
             if self.is_known(found := self.get_by_name(concept)):
-                return found
+                instances = new_instances(found)
+                core.builtin_helpers.set_is_evaluated(instances)
+                return instances
 
         return None
 

src/core/sheerka/services/SheerkaEvaluateConcept.py

@@ -2,6 +2,7 @@ from core.builtin_concepts import BuiltinConcepts
 from core.builtin_helpers import expect_one, only_successful
 from core.concept import Concept, DoNotResolve, ConceptParts, InfiniteRecursionResolved
 from core.sheerka.services.sheerka_service import BaseService
+from core.utils import unstr_concept
 
 CONCEPT_EVALUATION_STEPS = [
     BuiltinConcepts.BEFORE_EVALUATION,
@@ -14,7 +15,7 @@ class SheerkaEvaluateConcept(BaseService):
 
     def __init__(self, sheerka):
         super().__init__(sheerka)
-        
+
     def initialize(self):
         self.sheerka.bind_service_method(self.evaluate_concept)
 
@@ -73,7 +74,6 @@ class SheerkaEvaluateConcept(BaseService):
         Basically, it runs the parsers on all parts
         :param concept:
         :param context:
-        :param logger:
         :return:
         """
 
@@ -82,6 +82,11 @@ class SheerkaEvaluateConcept(BaseService):
             return context.sheerka.isinstance(r, BuiltinConcepts.RETURN_VALUE) and \
                    context.sheerka.isinstance(r.body, BuiltinConcepts.ONLY_SUCCESSFUL)
 
+        def parse_token_concept(s):
+            if s.startswith("c:") and (identifier := unstr_concept(s)) != (None, None):
+                return self.sheerka.resolve(identifier)
+            return None
+
         steps = [BuiltinConcepts.BEFORE_PARSING, BuiltinConcepts.PARSING, BuiltinConcepts.AFTER_PARSING]
         for part_key in ConceptParts:
             if part_key in concept.compiled:
@@ -94,14 +99,19 @@ class SheerkaEvaluateConcept(BaseService):
             if source.strip() == "":
                 concept.compiled[part_key] = DoNotResolve(source)
             else:
-                with context.push(desc=f"Initializing *compiled* for {part_key}") as sub_context:
-                    sub_context.add_inputs(source=source)
-                    to_parse = self.sheerka.ret(context.who, True,
-                                                self.sheerka.new(BuiltinConcepts.USER_INPUT, body=source))
-                    res = self.sheerka.execute(sub_context, to_parse, steps)
-                    only_success = only_successful(sub_context, res)
-                    concept.compiled[part_key] = only_success.body.body if is_only_successful(only_success) else res
-                    sub_context.add_values(return_values=res)
+                # first case, when the metadata references another concept via c:xxx: keyword
+                if concept_found := parse_token_concept(source):
+                    context.log(f"Recognized concept '{concept_found}'", self.NAME)
+                    concept.compiled[part_key] = concept_found
+                else:
+                    with context.push(desc=f"Initializing *compiled* for {part_key}") as sub_context:
+                        sub_context.add_inputs(source=source)
+                        to_parse = self.sheerka.ret(context.who, True,
+                                                    self.sheerka.new(BuiltinConcepts.USER_INPUT, body=source))
+                        res = self.sheerka.execute(sub_context, to_parse, steps)
+                        only_success = only_successful(sub_context, res)
+                        concept.compiled[part_key] = only_success.body.body if is_only_successful(only_success) else res
+                        sub_context.add_values(return_values=res)
 
         for var_name, default_value in concept.metadata.variables:
             if var_name in concept.compiled:
@@ -113,14 +123,19 @@ class SheerkaEvaluateConcept(BaseService):
             if default_value.strip() == "":
                 concept.compiled[var_name] = DoNotResolve(default_value)
             else:
-                with context.push(desc=f"Initializing *compiled* for property {var_name}") as sub_context:
-                    sub_context.add_inputs(source=default_value)
-                    to_parse = self.sheerka.ret(context.who, True,
-                                                self.sheerka.new(BuiltinConcepts.USER_INPUT, body=default_value))
-                    res = self.sheerka.execute(sub_context, to_parse, steps)
-                    only_success = only_successful(sub_context, res)
-                    concept.compiled[var_name] = only_success.body.body if is_only_successful(only_success) else res
-                    sub_context.add_values(return_values=res)
+                # first case, when the metadata references another concept via c:xxx: keyword
+                if concept_found := parse_token_concept(default_value):
+                    context.log(f"Recognized concept '{concept_found}'", self.NAME)
+                    concept.compiled[var_name] = concept_found
+                else:
+                    with context.push(desc=f"Initializing *compiled* for property {var_name}") as sub_context:
+                        sub_context.add_inputs(source=default_value)
+                        to_parse = self.sheerka.ret(context.who, True,
+                                                    self.sheerka.new(BuiltinConcepts.USER_INPUT, body=default_value))
+                        res = self.sheerka.execute(sub_context, to_parse, steps)
+                        only_success = only_successful(sub_context, res)
+                        concept.compiled[var_name] = only_success.body.body if is_only_successful(only_success) else res
+                        sub_context.add_values(return_values=res)
 
         # Updates the cache of concepts when possible
         if self.sheerka.has_id(concept.id):