Improved PythonEvaluator when dealing with concept class

src/core/concept.py

@@ -248,7 +248,7 @@ class Concept:
             if token.value in variables:
                 key += VARIABLE_PREFIX + str(variables.index(token.value))
             else:
-                #value = token.value[1:-1] if token.type == TokenKind.STRING else token.value
+                # value = token.value[1:-1] if token.type == TokenKind.STRING else token.value
                 key += token.value
             first = False
 
@@ -490,6 +490,16 @@ class InfiniteRecursionResolved:
         return self.value
 
 
+def ensure_concept(*concepts):
+    if hasattr(concepts, "__iter__"):
+        for concept in concepts:
+            if not isinstance(concept, Concept):
+                raise TypeError(f"'{concept}' must be a concept")
+    else:
+        if not isinstance(concepts, Concept):
+            raise TypeError(f"'{concepts}' must be a concept")
+
+
 # ################################
 #
 # Class created for tests purpose

src/core/sheerka/Sheerka.py

@@ -13,6 +13,7 @@ from core.builtin_concepts import BuiltinConcepts, ErrorConcept, ReturnValueConc
 from core.concept import Concept, ConceptParts, PROPERTIES_FOR_NEW
 from core.sheerka.ExecutionContext import ExecutionContext
 from core.sheerka_logger import console_handler
+from core.tokenizer import Token, TokenKind
 from printer.SheerkaPrinter import SheerkaPrinter
 from sdp.sheerkaDataProvider import SheerkaDataProvider, Event
 
@@ -489,6 +490,37 @@ class Sheerka(Concept):
         metadata = [(index_name, key), ("id", concept_id)] if concept_id else (index_name, key)
         return self._get_unknown(metadata)
 
+    def resolve(self, concept):
+        if concept is None:
+            return concept
+
+        # if the entry is a concept token, use its values.
+        if isinstance(concept, Token):
+            if concept.type != TokenKind.CONCEPT:
+                return None
+            concept = concept.value
+
+        # 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
+            elif concept[0]:
+                return found if self.is_known(found := self.get_by_name(concept[0])) else None
+            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
+
+        return None
+
     def has_id(self, concept_id):
         """
         Returns True if a concept with this id exists in cache

src/core/sheerka/services/SheerkaComparisonManager.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from cache.Cache import Cache
 from cache.ListCache import ListCache
 from core.builtin_concepts import BuiltinConcepts
+from core.concept import ensure_concept
 from core.sheerka.services.sheerka_service import ServiceObj, BaseService
 
 
@@ -105,6 +106,7 @@ class SheerkaComparisonManager(BaseService):
         :return:
         """
         context.log(f"Setting concept {concept_a} is greater than {concept_b}", who=self.NAME)
+        ensure_concept(concept_a, concept_b)
 
         event_digest = context.event.get_digest()
         comparison_obj = ComparisonObj(event_digest, prop_name, concept_a.id, concept_b.id, ">", comparison_context)
@@ -121,6 +123,7 @@ class SheerkaComparisonManager(BaseService):
         :return:
         """
         context.log(f"Setting concept {concept_a} is less than {concept_b}", who=self.NAME)
+        ensure_concept(concept_a, concept_b)
 
         event_digest = context.event.get_digest()
         comparison_obj = ComparisonObj(event_digest, prop_name, concept_a.id, concept_b.id, "<", comparison_context)

src/core/sheerka/services/SheerkaCreateNewConcept.py

@@ -1,6 +1,6 @@
 import core.utils
 from core.builtin_concepts import BuiltinConcepts, ErrorConcept
-from core.concept import Concept
+from core.concept import Concept, DEFINITION_TYPE_DEF, ensure_concept
 from core.sheerka.services.sheerka_service import BaseService
 from sdp.sheerkaDataProvider import SheerkaDataProviderDuplicateKeyError
 
@@ -30,6 +30,8 @@ class SheerkaCreateNewConcept(BaseService):
         :return: digest of the new concept
         """
 
+        ensure_concept(concept)
+
         sheerka = self.sheerka
 
         concept.init_key()
@@ -49,24 +51,29 @@ class SheerkaCreateNewConcept(BaseService):
         # set id before saving in db
         sheerka.set_id_if_needed(concept, False)
 
-        # update the dictionary of concepts by first key
+        # compute new concepts_by_first_keyword
         init_ret_value = self.bnp.get_concepts_by_first_keyword(context, [concept], True)
         if not init_ret_value.status:
             return sheerka.ret(self.NAME, False, ErrorConcept(init_ret_value.value))
         concepts_by_first_keyword = init_ret_value.body
 
-        # update resolved dictionary
+        # computes resolved concepts_by_first_keyword
         init_ret_value = self.bnp.resolve_concepts_by_first_keyword(context, concepts_by_first_keyword)
         if not init_ret_value.status:
             return sheerka.ret(self.NAME, False, ErrorConcept(init_ret_value.value))
         resolved_concepts_by_first_keyword = init_ret_value.body
 
-        concept.freeze_definition_hash()
+        # if everything is fine
 
+        concept.freeze_definition_hash()
         cache_manager.add_concept(concept)
         cache_manager.put(sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, False, concepts_by_first_keyword)
         cache_manager.put(sheerka.RESOLVED_CONCEPTS_BY_FIRST_KEYWORD_ENTRY, False, resolved_concepts_by_first_keyword)
 
+        if concept.metadata.definition_type == DEFINITION_TYPE_DEF and concept.metadata.definition != concept.name:
+            # allow search by definition when definition relevant
+            cache_manager.put(self.sheerka.CONCEPTS_BY_NAME_ENTRY, concept.metadata.definition, concept)
+
         if concept.bnf and init_bnf_ret_value is not None and init_bnf_ret_value.status:
             sheerka.cache_manager.clear(sheerka.CONCEPTS_GRAMMARS_ENTRY)
 

src/core/sheerka/services/SheerkaModifyConcept.py

@@ -41,6 +41,7 @@ class SheerkaModifyConcept(BaseService):
         # TODO : update concept by first keyword
         # TODO : update resolved by first keyword
         # TODO : update concepts grammars
+        # TODO : update when definition_type = DEFINITION_TYPE_DEF
 
         ret = self.sheerka.ret(self.NAME, True, self.sheerka.new(BuiltinConcepts.NEW_CONCEPT, body=concept))
         return ret

src/core/sheerka/services/SheerkaSetsManager.py

@@ -2,7 +2,7 @@ import core.builtin_helpers
 from cache.SetCache import SetCache
 from core.ast.nodes import python_to_concept
 from core.builtin_concepts import BuiltinConcepts
-from core.concept import Concept, ConceptParts
+from core.concept import Concept, ConceptParts, ensure_concept
 from core.sheerka.services.sheerka_service import BaseService
 
 GROUP_PREFIX = 'All_'
@@ -36,6 +36,7 @@ class SheerkaSetsManager(BaseService):
         """
 
         context.log(f"Setting concept {concept} is a {concept_set}", who=self.NAME)
+        ensure_concept(concept, concept_set)
 
         if BuiltinConcepts.ISA in concept.metadata.props and concept_set in concept.metadata.props[BuiltinConcepts.ISA]:
             return self.sheerka.ret(
@@ -61,9 +62,7 @@ class SheerkaSetsManager(BaseService):
         """
 
         context.log(f"Adding concept {concept} to set {concept_set}", who=self.NAME)
-
-        assert concept.id
-        assert concept_set.id
+        ensure_concept(concept, concept_set)
 
         set_elements = self.sheerka.cache_manager.get(self.CONCEPTS_GROUPS_ENTRY, concept_set.id)
         if set_elements and concept.id in set_elements:
@@ -79,6 +78,7 @@ class SheerkaSetsManager(BaseService):
         """Adding multiple concepts at the same time"""
 
         context.log(f"Adding concepts {concepts} to set {concept_set}", who=self.NAME)
+        ensure_concept(concept_set)
         already_in_set = []
         for concept in concepts:
             res = self.add_concept_to_set(context, concept, concept_set)
@@ -103,6 +103,8 @@ class SheerkaSetsManager(BaseService):
         :return:
         """
 
+        ensure_concept(concept)
+
         def _get_set_elements(sub_concept):
             if not self.isaset(context, sub_concept):
                 return self.sheerka.new(BuiltinConcepts.NOT_A_SET, body=concept)
@@ -151,8 +153,9 @@ class SheerkaSetsManager(BaseService):
         if isinstance(a, BuiltinConcepts):  # common KSI error ;-)
             raise SyntaxError("Remember that the first parameter of isinstance MUST be a concept")
 
-        if not (isinstance(a, Concept) and isinstance(b, Concept)):
-            return False
+        ensure_concept(a, b)
+        # if not (isinstance(a, Concept) and isinstance(b, Concept)):
+        #     return False
 
         # TODO, first check the 'isa' property of a
         if not (a.id and b.id):
@@ -163,6 +166,7 @@ class SheerkaSetsManager(BaseService):
 
     def isa(self, a, b):
 
+        ensure_concept(a, b)
         if BuiltinConcepts.ISA not in a.metadata.props:
             return False
 

src/core/utils.py

@@ -363,7 +363,7 @@ def unstr_concept(concept_repr):
     return key if key != "" else None, id if id != "" else None
 
 
-def encode_concept(t, use_concept=False):
+def encode_concept(t):
     """
     Given a tuple of concept id, concept id
     Create a valid Python identifier that can be parsed back
@@ -371,15 +371,13 @@ def encode_concept(t, use_concept=False):
     >>> assert encode_concept(("key", "id")) == "__C__KEY_key__ID_id__C__"
     >>> assert encode_concept((None, "id")) == "__C__KEY_00None00__ID_id__C__"
     >>> assert encode_concept(("key", None)) == "__C__KEY_key__ID_00None00__C__"
-    >>> assert encode_concept(("key", "id"), True) == "__C__USE_CONCEPT__KEY_key__ID_id__C__"
 
     :param t:
-    :param use_concept:
     :return:
     """
 
     key, id_ = (t[0], t[1]) if isinstance(t, tuple) else (t.key, t.id)
-    prefix = "__C__USE_CONCEPT" if use_concept else "__C"
+    prefix = "__C"
     sanitized_key = "".join(c if c.isalnum() else "0" for c in key) if key else "00None00"
     return prefix + f"__KEY_{sanitized_key}__ID_{id_ or '00None00'}__C__"
 
@@ -393,15 +391,14 @@ def decode_concept(text):
     :param text:
     :return:
     """
-    use_concept = text.startswith("__C__USE_CONCEPT")
     m = decode_regex.search(text)
     lookup = {"00None00": None}
     if m:
         key = lookup.get(m.group(1), m.group(1))
         id_ = lookup.get(m.group(2), m.group(2))
-        return key, id_, use_concept
+        return key, id_
 
-    return None, None, None
+    return None, None
 
 
 def tokens_index(tokens, sub_tokens, skip=0):