252 lines
9.1 KiB
Python
252 lines
9.1 KiB
Python
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, ensure_concept
|
|
from core.sheerka.services.sheerka_service import BaseService
|
|
|
|
GROUP_PREFIX = 'All_'
|
|
|
|
|
|
class SheerkaSetsManager(BaseService):
|
|
NAME = "SetsManager"
|
|
CONCEPTS_GROUPS_ENTRY = "Concepts_Groups"
|
|
|
|
def __init__(self, sheerka):
|
|
super().__init__(sheerka)
|
|
|
|
def initialize(self):
|
|
self.sheerka.bind_service_method(self.set_isa)
|
|
self.sheerka.bind_service_method(self.get_set_elements)
|
|
self.sheerka.bind_service_method(self.add_concept_to_set)
|
|
self.sheerka.bind_service_method(self.isinset)
|
|
self.sheerka.bind_service_method(self.isa)
|
|
self.sheerka.bind_service_method(self.isaset)
|
|
|
|
cache = SetCache(default=lambda k: self.sheerka.sdp.get(self.CONCEPTS_GROUPS_ENTRY, k))
|
|
self.sheerka.cache_manager.register_cache(self.CONCEPTS_GROUPS_ENTRY, cache)
|
|
|
|
def set_isa(self, context, concept, concept_set):
|
|
"""
|
|
Defines that concept a is b is another concept
|
|
:param context:
|
|
:param concept:
|
|
:param concept_set:
|
|
:return:
|
|
"""
|
|
|
|
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(
|
|
self.NAME,
|
|
False,
|
|
self.sheerka.new(BuiltinConcepts.CONCEPT_ALREADY_IN_SET, body=concept, concept_set=concept_set))
|
|
|
|
concept.add_prop(BuiltinConcepts.ISA, concept_set)
|
|
|
|
res = self.sheerka.modify_concept(context, concept)
|
|
if not res.status:
|
|
return res
|
|
|
|
return self.add_concept_to_set(context, concept, concept_set)
|
|
|
|
def add_concept_to_set(self, context, concept, concept_set):
|
|
"""
|
|
Add an entry in sdp to tell that concept isa concept_set
|
|
:param context:
|
|
:param concept:
|
|
:param concept_set:
|
|
:return:
|
|
"""
|
|
|
|
context.log(f"Adding concept {concept} to set {concept_set}", who=self.NAME)
|
|
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:
|
|
return self.sheerka.ret(
|
|
self.NAME,
|
|
False,
|
|
self.sheerka.new(BuiltinConcepts.CONCEPT_ALREADY_IN_SET, body=concept, concept_set=concept_set))
|
|
|
|
self.sheerka.cache_manager.put(self.CONCEPTS_GROUPS_ENTRY, concept_set.id, concept.id)
|
|
return self.sheerka.ret(self.NAME, True, self.sheerka.new(BuiltinConcepts.SUCCESS))
|
|
|
|
def add_concepts_to_set(self, context, concepts, concept_set):
|
|
"""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)
|
|
if self.sheerka.isinstance(res.body, BuiltinConcepts.CONCEPT_ALREADY_IN_SET):
|
|
already_in_set.append(res.body.body)
|
|
|
|
if already_in_set:
|
|
body = self.sheerka.new(BuiltinConcepts.CONCEPT_ALREADY_IN_SET,
|
|
body=already_in_set,
|
|
concept_set=concept_set)
|
|
else:
|
|
body = self.sheerka.new(BuiltinConcepts.SUCCESS)
|
|
|
|
return self.sheerka.ret(self.NAME, len(already_in_set) != len(concepts), body)
|
|
|
|
def get_set_elements(self, context, concept):
|
|
"""
|
|
Concept is supposed to be a set
|
|
Returns all elements if the set
|
|
:param context:
|
|
:param concept:
|
|
: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)
|
|
|
|
# first, try to see if sub_context has it's own group entry
|
|
ids = self.sheerka.cache_manager.get(self.CONCEPTS_GROUPS_ENTRY, sub_concept.id)
|
|
concepts = self._get_concepts(context, ids, True)
|
|
|
|
# aggregate with en entries from its body
|
|
sub_concept = core.builtin_helpers.ensure_evaluated(context, sub_concept)
|
|
if not self.sheerka.is_success(sub_concept):
|
|
return sub_concept
|
|
|
|
if self.isaset(context, sub_concept.body):
|
|
other_concepts = _get_set_elements(sub_concept.body)
|
|
if not self.sheerka.is_success(other_concepts):
|
|
return other_concepts
|
|
concepts.extend(other_concepts)
|
|
|
|
# apply the where clause if any
|
|
if sub_concept.metadata.where:
|
|
new_condition = self._validate_where_clause(sub_concept)
|
|
if not new_condition:
|
|
return self.sheerka.new(BuiltinConcepts.WHERE_CLAUSE_FAILED, body=sub_concept)
|
|
|
|
# This methods sucks, but I don't have enough tools (like proper AST manipulation functions)
|
|
# to do it properly now. It will be enhanced later
|
|
globals_ = {"xx__concepts__xx": concepts, "sheerka": self.sheerka}
|
|
locals_ = {}
|
|
exec(new_condition, globals_, locals_)
|
|
concepts = locals_["result"]
|
|
|
|
return concepts
|
|
|
|
return _get_set_elements(concept)
|
|
|
|
def isinset(self, a, b):
|
|
"""
|
|
return true if the concept a is a b
|
|
Will handle when the keyword isa will be implemented
|
|
:param a:
|
|
:param b:
|
|
:return:
|
|
"""
|
|
|
|
if isinstance(a, BuiltinConcepts): # common KSI error ;-)
|
|
raise SyntaxError("Remember that the first parameter of isinstance MUST be a concept")
|
|
|
|
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):
|
|
return False
|
|
|
|
group_elements = self.sheerka.cache_manager.get(self.CONCEPTS_GROUPS_ENTRY, b.id)
|
|
return group_elements and a.id in group_elements
|
|
|
|
def isa(self, a, b):
|
|
|
|
ensure_concept(a, b)
|
|
if BuiltinConcepts.ISA not in a.metadata.props:
|
|
return False
|
|
|
|
for c in a.metadata.props[BuiltinConcepts.ISA]:
|
|
if c == b:
|
|
return True
|
|
if self.isa(c, b):
|
|
return True
|
|
|
|
return False
|
|
|
|
def isaset(self, context, concept):
|
|
"""
|
|
True if exists All_<concept_id> in sdp or if concept references to a concept that has all_<concept_id>
|
|
:param context:
|
|
:param concept:
|
|
:return:
|
|
"""
|
|
""""""
|
|
|
|
if not (isinstance(concept, Concept) and concept.id):
|
|
return False
|
|
|
|
# check if it has a group
|
|
# TODO: use cache instead of directly requesting sdp
|
|
if self.sheerka.cache_manager.get(self.CONCEPTS_GROUPS_ENTRY, concept.id):
|
|
return True
|
|
|
|
# it may be a concept that references a set
|
|
concept = core.builtin_helpers.ensure_evaluated(context, concept)
|
|
if not context.sheerka.is_success(concept):
|
|
return False
|
|
|
|
return self.isaset(context, concept.body)
|
|
|
|
def _validate_where_clause(self, concept):
|
|
python_parser_result = [r for r in concept.compiled[ConceptParts.WHERE] if r.who == "parsers.Python"]
|
|
if not python_parser_result or not python_parser_result[0].status:
|
|
return None
|
|
|
|
ast_ = python_parser_result[0].body.body.ast_
|
|
ast_as_concepts = python_to_concept(ast_)
|
|
names = core.builtin_helpers.get_names(self.sheerka, ast_as_concepts)
|
|
if len(names) != 1 or names[0] != concept.metadata.body:
|
|
return None
|
|
|
|
condition = concept.metadata.where.replace(concept.metadata.body, "sheerka.objvalue(x)")
|
|
expression = f"""
|
|
result=[]
|
|
for x in xx__concepts__xx:
|
|
try:
|
|
if {condition}:
|
|
result.append(x)
|
|
except Exception:
|
|
pass
|
|
"""
|
|
return expression
|
|
|
|
def _get_concepts(self, context, ids, evaluate):
|
|
"""
|
|
Gets concepts from a list of concepts ids
|
|
:param ids:
|
|
:param evaluate: if True, all the elements are evaluated before returned
|
|
:return:
|
|
"""
|
|
|
|
if not ids:
|
|
return []
|
|
|
|
if not evaluate:
|
|
return [self.sheerka.get_by_id(element_id) for element_id in ids]
|
|
|
|
result = []
|
|
with context.push(desc=f"Evaluating concepts of a set") as sub_context:
|
|
sub_context.add_inputs(ids=ids)
|
|
sub_context.local_hints.add(BuiltinConcepts.EVAL_BODY_REQUESTED)
|
|
for element_id in ids:
|
|
concept = self.sheerka.get_by_id(element_id)
|
|
evaluated = self.sheerka.evaluate_concept(sub_context, concept)
|
|
result.append(evaluated)
|
|
sub_context.add_inputs(return_value=result)
|
|
return result
|