kodjo/Sheerka-Old
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Logger is now an attribute of the execution context

Browse Source
This commit is contained in:
Kodjo Sossouvi
2020-02-18 16:31:55 +01:00
parent 86c2ff58d4
commit 87f232b527
27 changed files with 213 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/builtin_helpers.py
+7 -8
View File
@@ -32,13 +32,12 @@ def is_same_success(sheerka, return_values):
return True
def expect_one(context, return_values, logger=None):
def expect_one(context, return_values):
"""
Checks if there is at least one success return value
If there is more than one, check if it's the same value
:param context:
:param return_values:
:param logger:
:return:
"""
@@ -75,10 +74,10 @@ def expect_one(context, return_values, logger=None):
successful_results[0].value,
parents=return_values)
else:
if logger and logger.isEnabledFor(logging.DEBUG):
context.log(logger, f"Too many successful results found by expect_one()", context.who)
if context.logger and context.logger.isEnabledFor(logging.DEBUG):
context.log(f"Too many successful results found by expect_one()", context.who)
for s in successful_results:
context.log(logger, f"-> {s}", context.who)
context.log(f"-> {s}", context.who)
return sheerka.ret(
context.who,
False,
@@ -86,10 +85,10 @@ def expect_one(context, return_values, logger=None):
parents=return_values)
# only errors, i cannot help you
if logger and logger.isEnabledFor(logging.DEBUG):
context.log(logger, f"Too many errors found by expect_one()", context.who)
if context.logger and context.logger.isEnabledFor(logging.DEBUG):
context.log(f"Too many errors found by expect_one()", context.who)
for s in successful_results:
context.log(logger, f"-> {s}", context.who)
context.log(f"-> {s}", context.who)
if len(return_values) == 1:
return sheerka.ret(
src/core/sheerka/ExecutionContext.py
+33 -12
View File
@@ -3,8 +3,8 @@ import time
from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept
from core.sheerka_logger import get_logger
from sdp.sheerkaDataProvider import Event
from sheerkapickle.SheerkaPickler import SheerkaPickler
DEBUG_TAB_SIZE = 4
@@ -21,6 +21,8 @@ PROPERTIES_TO_SERIALIZE = ("_id",
"concepts")
class ExecutionContext:
"""
To keep track of the execution of a request
@@ -41,6 +43,7 @@ class ExecutionContext:
event: Event,
sheerka,
desc: str = None,
logger=None,
**kwargs):
self._parent = None
@@ -56,6 +59,7 @@ class ExecutionContext:
self.desc = desc # human description of what is going on
self.children = []
self.preprocess = None
self.logger = logger
self.inputs = {} # what was the parameters of the execution context
self.values = {} # what was produced by the execution context
@@ -66,6 +70,9 @@ class ExecutionContext:
for k, v in kwargs.items():
self._bag[k] = v
self.stat_log = get_logger("stats")
self.show_stats = False
@property
def elapsed(self):
if self._start == 0:
@@ -91,10 +98,13 @@ class ExecutionContext:
def __enter__(self):
self._start = time.time_ns()
self.log_new()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._stop = time.time_ns()
if self.show_stats:
self.stat_log.debug(f"[{self._id:2}]" + self._tab + "Execution time: " + self.elapsed_str)
def __repr__(self):
msg = f"ExecutionContext(who={self.who}, id={self._id}"
@@ -103,6 +113,11 @@ class ExecutionContext:
msg += ")"
return msg
def __str__(self):
msg = self.desc or "New Context"
msg += f", who={self.who}, id={self.id}"
return msg
def __eq__(self, other):
if id(self) == id(other):
return True
@@ -183,8 +198,9 @@ class ExecutionContext:
return self.sheerka.new(key, **kwargs)
def push(self, who=None, desc=None, **kwargs):
def push(self, who=None, desc=None, logger=None, **kwargs):
who = who or self.who
logger = logger or self.logger
_kwargs = {"obj": self.obj, "concepts": self.concepts}
_kwargs.update(self._bag)
_kwargs.update(kwargs)
@@ -193,6 +209,7 @@ class ExecutionContext:
self.event,
self.sheerka,
desc,
logger,
**_kwargs,
)
new._parent = self
@@ -202,25 +219,29 @@ class ExecutionContext:
self.children.append(new)
return new
def log_new(self, logger):
logger.debug(f"[{self._id:2}]" + self._tab + str(self))
def log_new(self):
if self.logger and not self.logger.disabled:
self.logger.debug(f"[{self._id:2}]" + self._tab + str(self))
self.show_stats = True
def log(self, logger, message, who=None):
logger.debug(f"[{self._id:2}]" + self._tab + (f"[{who}] " if who else "") + str(message))
def log(self, message, who=None):
if self.logger and not self.logger.disabled:
self.logger.debug(f"[{self._id:2}]" + self._tab + (f"[{who}] " if who else "") + str(message))
def log_error(self, logger, message, who=None):
logger.exception(f"[{self._id:2}]" + self._tab + (f"[{who}] " if who else "") + str(message))
def log_error(self, message, who=None):
if self.logger and not self.logger.disabled:
self.logger.exception(f"[{self._id:2}]" + self._tab + (f"[{who}] " if who else "") + str(message))
def log_result(self, logger, return_values):
if not logger.isEnabledFor(logging.DEBUG):
def log_result(self, return_values):
if not self.logger or not self.logger.isEnabledFor(logging.DEBUG):
return
if len(return_values) == 0:
logger.debug(self._tab + "No return value")
self.logger.debug(self._tab + "No return value")
for r in return_values:
to_str = self.return_value_to_str(r)
logger.debug(f"[{self._id:2}]" + self._tab + "-> " + to_str)
self.logger.debug(f"[{self._id:2}]" + self._tab + "-> " + to_str)
def get_parent(self):
return self._parent
src/core/sheerka/Services/SheerkaCreateNewConcept.py
+2 -5
View File
@@ -14,7 +14,7 @@ class SheerkaCreateNewConcept:
self.sheerka = sheerka
self.logger_name = self.create_new_concept.__name__
def create_new_concept(self, context, concept: Concept, logger=None):
def create_new_concept(self, context, concept: Concept):
"""
Adds a new concept to the system
:param context:
@@ -23,8 +23,6 @@ class SheerkaCreateNewConcept:
:return: digest of the new concept
"""
logger = logger or self.sheerka.log
concept.init_key()
concepts_definitions = None
init_ret_value = None
@@ -52,7 +50,6 @@ class SheerkaCreateNewConcept:
concept_lexer_parser = self.sheerka.parsers[CONCEPT_LEXER_PARSER_CLASS]()
with context.push(self.sheerka.name, desc=f"Initializing concept definition for {concept}") as sub_context:
sub_context.concepts[concept.key] = concept # the concept is not in the real cache yet
sub_context.log_new(logger)
init_ret_value = concept_lexer_parser.initialize(sub_context, concepts_definitions)
sub_context.add_values(return_values=init_ret_value)
if not init_ret_value.status:
@@ -83,7 +80,7 @@ class SheerkaCreateNewConcept:
use_ref=True)
self.sheerka.concepts_definitions_cache = None # invalidate cache
except SheerkaDataProviderDuplicateKeyError as error:
context.log_error(logger, "Failed to create a new concept.", who=self.logger_name)
context.log_error("Failed to create a new concept.", who=self.logger_name)
return self.sheerka.ret(
self.logger_name,
False,
src/core/sheerka/Services/SheerkaDump.py
+5
View File
@@ -58,6 +58,11 @@ class SheerkaDump:
self.sheerka.log.info(f"body : {c.metadata.body}")
if eval:
self.sheerka.log.info(f"value : {value}")
for p in c.props:
self.sheerka.log.info(f"{p}: {c.get_prop(p)}")
else:
self.sheerka.log.info("No property")
self.sheerka.log.info(f"digest : {c.get_digest()}")
if self.sheerka.isaset(context, c):
src/core/sheerka/Services/SheerkaEvaluateConcept.py
+14 -20
View File
@@ -62,7 +62,7 @@ class SheerkaEvaluateConcept:
False,
self.sheerka.new(BuiltinConcepts.CHICKEN_AND_EGG, body=concepts_found))
def initialize_concept_asts(self, context, concept: Concept, logger=None):
def initialize_concept_asts(self, context, concept: Concept):
"""
Updates the codes of the newly created concept
Basically, it runs the parsers on all parts
@@ -84,11 +84,10 @@ class SheerkaEvaluateConcept:
concept.compiled[part_key] = DoNotResolve(source)
else:
with context.push(desc=f"Initializing compiled for {part_key}") as sub_context:
sub_context.log_new(logger)
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, logger)
res = self.sheerka.execute(sub_context, to_parse, steps)
concept.compiled[part_key] = res
sub_context.add_values(return_values=res)
@@ -103,7 +102,6 @@ class SheerkaEvaluateConcept:
concept.compiled[prop] = DoNotResolve(default_value)
else:
with context.push(desc=f"Initializing AST for property {prop}") as sub_context:
sub_context.log_new(logger)
sub_context.add_inputs(source=default_value)
to_parse = self.sheerka.ret(context.who, True,
self.sheerka.new(BuiltinConcepts.USER_INPUT, body=default_value))
@@ -120,7 +118,7 @@ class SheerkaEvaluateConcept:
else:
self.sheerka.cache_by_key[concept.key].compiled = concept.compiled
def resolve(self, context, to_resolve, current_prop, current_concept, logger):
def resolve(self, context, to_resolve, current_prop, current_concept):
if isinstance(to_resolve, DoNotResolve):
return to_resolve.value
@@ -128,20 +126,18 @@ class SheerkaEvaluateConcept:
if self.infinite_recursion_detected(context, current_concept):
with context.push(desc="Infinite recursion detected", obj=current_concept) as sub_context:
# I create a sub context in order to log what happened
sub_context.log_new(logger)
ret_val = self.manage_infinite_recursion(context)
sub_context.add_values(return_values=ret_val)
return ret_val.body
desc = f"Evaluating {current_prop} (concept={current_concept})"
context.log(logger, desc, self.logger_name)
context.log(desc, self.logger_name)
with context.push(desc=desc, obj=current_concept) as sub_context:
sub_context.log_new(logger)
# when it's a concept, evaluate it
if isinstance(to_resolve, Concept) and \
not context.sheerka.isinstance(to_resolve, BuiltinConcepts.RETURN_VALUE):
evaluated = self.evaluate_concept(sub_context, to_resolve, logger)
evaluated = self.evaluate_concept(sub_context, to_resolve)
sub_context.add_values(return_values=evaluated)
if evaluated.key == to_resolve.key:
return evaluated
@@ -151,7 +147,7 @@ class SheerkaEvaluateConcept:
# otherwise, execute all return values to find out what is the value
else:
use_copy = [r for r in to_resolve] if hasattr(to_resolve, "__iter__") else to_resolve
r = self.sheerka.execute(sub_context, use_copy, CONCEPT_EVALUATION_STEPS, logger)
r = self.sheerka.execute(sub_context, use_copy, CONCEPT_EVALUATION_STEPS)
one_r = core.builtin_helpers.expect_one(context, r)
sub_context.add_values(return_values=one_r)
if one_r.status:
@@ -165,7 +161,7 @@ class SheerkaEvaluateConcept:
concept=current_concept,
property_name=current_prop)
def resolve_list(self, context, list_to_resolve, current_prop, current_concept, logger):
def resolve_list(self, context, list_to_resolve, current_prop, current_concept):
"""When dealing with a list, there are two possibilities"""
# It may be a list of ReturnValueConcept to execute (always the case for metadata)
# or a list of single values (may be the case for properties)
@@ -174,7 +170,7 @@ class SheerkaEvaluateConcept:
return []
if self.sheerka.isinstance(list_to_resolve[0], BuiltinConcepts.RETURN_VALUE):
return self.resolve(context, list_to_resolve, current_prop, current_concept, logger)
return self.resolve(context, list_to_resolve, current_prop, current_concept)
res = []
for to_resolve in list_to_resolve:
@@ -185,14 +181,14 @@ class SheerkaEvaluateConcept:
concept=current_concept,
property_name=current_prop)
r = self.resolve(context, to_resolve, current_prop, current_concept, logger)
r = self.resolve(context, to_resolve, current_prop, current_concept)
if self.sheerka.isinstance(r, BuiltinConcepts.CONCEPT_EVAL_ERROR):
return r
res.append(r)
return res
def evaluate_concept(self, context, concept: Concept, logger=None):
def evaluate_concept(self, context, concept: Concept):
"""
Evaluation a concept
It means that if the where clause is True, will evaluate the body
@@ -202,8 +198,6 @@ class SheerkaEvaluateConcept:
:return: value of the evaluation or error
"""
logger = logger or self.sheerka.log
if concept.metadata.is_evaluated:
return concept
@@ -211,7 +205,7 @@ class SheerkaEvaluateConcept:
# TODO : Validate the PRE condition
#
self.initialize_concept_asts(context, concept, logger)
self.initialize_concept_asts(context, concept)
# to make sure of the order, it don't use ConceptParts.get_parts()
# props must be evaluated first, body must be evaluated before where
@@ -224,10 +218,10 @@ class SheerkaEvaluateConcept:
if isinstance(prop_ast, list):
# Do not send the current concept for the properties
resolved = self.resolve_list(context, prop_ast, prop_name, None, logger)
resolved = self.resolve_list(context, prop_ast, prop_name, None)
else:
# Do not send the current concept for the properties
resolved = self.resolve(context, prop_ast, prop_name, None, logger)
resolved = self.resolve(context, prop_ast, prop_name, None)
if isinstance(resolved, Concept) and not context.sheerka.is_success(resolved):
resolved.set_prop("concept", concept) # since current concept was not sent
return resolved
@@ -243,7 +237,7 @@ class SheerkaEvaluateConcept:
if part_key in concept.compiled and concept.compiled[part_key] is not None:
metadata_ast = concept.compiled[part_key]
resolved = self.resolve(context, metadata_ast, part_key, concept, logger)
resolved = self.resolve(context, metadata_ast, part_key, concept)
if isinstance(resolved, Concept) and not context.sheerka.is_success(resolved):
return resolved
else:
src/core/sheerka/Services/SheerkaExecute.py
+9 -15
View File
@@ -10,7 +10,7 @@ class SheerkaExecute:
def __init__(self, sheerka):
self.sheerka = sheerka
def call_parsers(self, execution_context, return_values, logger=None):
def call_parsers(self, execution_context, return_values):
# return_values must be a list
if not isinstance(return_values, list):
@@ -35,8 +35,6 @@ class SheerkaExecute:
instantiated_parsers = [parser(sheerka=self.sheerka) for parser in self.sheerka.parsers.values()]
grouped_parsers = {}
for parser in [p for p in instantiated_parsers if p.enabled]:
if logger:
parser.log = logger
grouped_parsers.setdefault(parser.priority, []).append(parser)
sorted_priorities = sorted(grouped_parsers.keys(), reverse=True)
@@ -56,9 +54,9 @@ class SheerkaExecute:
# if self.sheerka.log.isEnabledFor(logging.DEBUG):
# debug_text = "'" + to_parse + "'" if isinstance(to_parse, str) \
# else "'" + BaseParser.get_text_from_tokens(to_parse) + "' as tokens"
# execution_context.log(logger or self.sheerka.log, f"Parsing {debug_text}")
# execution_context.log(f"Parsing {debug_text}")
with execution_context.push(desc=f"Parsing using {parser.name}") as sub_context:
with execution_context.push(desc=f"Parsing using {parser.name}", logger=parser.verbose_log) as sub_context:
sub_context.add_inputs(to_parse=to_parse)
res = parser.parse(sub_context, to_parse)
if res is not None:
@@ -92,7 +90,7 @@ class SheerkaExecute:
result = core.utils.remove_list_from_list(result, user_inputs)
return result
def call_evaluators(self, execution_context, return_values, process_step, evaluation_context=None, logger=None):
def call_evaluators(self, execution_context, return_values, process_step, evaluation_context=None):
# return_values must be a list
if not isinstance(return_values, list):
@@ -122,8 +120,6 @@ class SheerkaExecute:
instantiated_evaluators = self._preprocess_evaluators(execution_context, instantiated_evaluators)
for evaluator in [e for e in instantiated_evaluators if e.enabled and process_step in e.steps]:
if logger:
evaluator.log = logger
grouped_evaluators.setdefault(evaluator.priority, []).append(evaluator)
# order the groups by priority, the higher first
@@ -145,7 +141,7 @@ class SheerkaExecute:
evaluator = self._preprocess_evaluators(execution_context, evaluator.__class__()) # fresh copy
sub_context_desc = f"Evaluating using {evaluator.name} ({priority=})"
with iteration_context.push(desc=sub_context_desc) as sub_context:
with iteration_context.push(desc=sub_context_desc, logger=evaluator.verbose_log) as sub_context:
sub_context.add_inputs(return_values=original_items)
# process evaluators that work on one simple return value at the time
@@ -206,28 +202,26 @@ class SheerkaExecute:
return_values = core.utils.remove_list_from_list(return_values, evaluation_return_values)
return return_values
def execute(self, execution_context, return_values, execution_steps, logger=None):
def execute(self, execution_context, return_values, execution_steps):
"""
Executes process for all initial contexts
:param execution_context:
:param return_values:
:param execution_steps:
:param logger: logger to use (if not directly called by sheerka)
:return:
"""
for step in execution_steps:
copy = return_values[:] if hasattr(return_values, "__iter__") else [return_values]
with execution_context.push(step=step, iteration=0, desc=f"{step=}") as sub_context:
sub_context.log(logger or self.sheerka.log, f"{step=}, context='{sub_context}'")
if step == BuiltinConcepts.PARSING:
return_values = self.call_parsers(sub_context, return_values, logger)
return_values = self.call_parsers(sub_context, return_values)
else:
return_values = self.call_evaluators(sub_context, return_values, step, None, logger)
return_values = self.call_evaluators(sub_context, return_values, step, None)
if copy != return_values:
sub_context.log_result(logger or self.sheerka.log, return_values)
sub_context.log_result(return_values)
sub_context.add_values(return_values=return_values)
src/core/sheerka/Services/SheerkaModifyConcept.py
+1 -2
View File
@@ -6,8 +6,7 @@ class SheerkaModifyConcept:
self.sheerka = sheerka
self.logger_name = self.modify_concept.__name__
def modify_concept(self, context, concept, logger=None):
logger = logger or self.sheerka.log
def modify_concept(self, context, concept):
self.sheerka.sdp.modify(context.event.get_digest(), self.sheerka.CONCEPTS_ENTRY, concept.key, concept)
src/core/sheerka/Services/SheerkaSetsManager.py
+18 -29
View File
@@ -11,42 +11,38 @@ class SheerkaSetsManager:
self.sheerka = sheerka
self.logger_name = self.add_concept_to_set.__name__
def set_isa(self, context, concept, concept_set, logger=None):
def set_isa(self, context, concept, concept_set):
"""
Defines that concept a is b is another concept
:param context:
:param concept:
:param concept_set:
:param logger:
:return:
"""
logger = logger or self.sheerka.log
context.log(logger, f"Setting that concept {concept} is a {concept_set}", who=self.logger_name)
context.log(f"Setting that concept {concept} is a {concept_set}", who=self.logger_name)
isa = [] if BuiltinConcepts.ISA not in concept.props else concept.get_prop(BuiltinConcepts.ISA)
if concept_set not in isa:
isa.append(concept_set)
concept.set_prop(BuiltinConcepts.ISA, isa)
res = self.sheerka.modify_concept(context, concept, logger)
res = self.sheerka.modify_concept(context, concept)
if not res.status:
return res
return self.add_concept_to_set(context, concept, concept_set, logger)
return self.add_concept_to_set(context, concept, concept_set)
def add_concept_to_set(self, context, concept, concept_set, logger=None):
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:
:param logger:
:return:
"""
logger = logger or self.sheerka.log
context.log(logger, f"Adding concept {concept} to set {concept_set}", who=self.logger_name)
context.log(f"Adding concept {concept} to set {concept_set}", who=self.logger_name)
assert concept.id
assert concept_set.id
@@ -61,14 +57,13 @@ class SheerkaSetsManager:
else:
return self.sheerka.ret(self.logger_name, True, self.sheerka.new(BuiltinConcepts.SUCCESS))
except Exception as error:
context.log_error(logger, "Failed to add to set.", who=self.logger_name)
context.log_error("Failed to add to set.", who=self.logger_name)
return self.sheerka.ret(self.logger_name, False, ErrorConcept(error), error.args[0])
def add_concepts_to_set(self, context, concepts, concept_set, logger=None):
def add_concepts_to_set(self, context, concepts, concept_set):
"""Adding multiple concepts at the same time"""
logger = logger or self.sheerka.log
context.log(logger, f"Adding concepts {concepts} to set {concept_set}", who=self.logger_name)
context.log(f"Adding concepts {concepts} to set {concept_set}", who=self.logger_name)
previous = self.sheerka.sdp.get_safe(GROUP_PREFIX + concept_set.id)
new_ids = [c.id for c in concepts] if previous is None else previous + [c.id for c in concepts]
@@ -76,21 +71,18 @@ class SheerkaSetsManager:
self.sheerka.sdp.set(context.event.get_digest(), GROUP_PREFIX + concept_set.id, new_ids)
return self.sheerka.ret(self.logger_name, True, self.sheerka.new(BuiltinConcepts.SUCCESS))
except Exception as error:
context.log_error(logger, "Failed to add to set.", who=self.logger_name)
context.log_error("Failed to add to set.", who=self.logger_name)
return self.sheerka.ret(self.logger_name, False, ErrorConcept(error), error.args[0])
def get_set_elements(self, context, concept, logger=None):
def get_set_elements(self, context, concept):
"""
Concept is supposed to be a set
Returns all elements if the set
:param context:
:param concept:
:param logger:
:return:
"""
logger = logger or self.sheerka.log
# noinspection PyShadowingNames
def _get_set_elements(context, concept, sub_concept):
if not (isinstance(sub_concept, Concept) and sub_concept.id):
@@ -105,13 +97,13 @@ class SheerkaSetsManager:
else:
# 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
concepts = self._get_concepts(context, ids, True, logger)
concepts = self._get_concepts(context, ids, True)
globals_ = {"xx__concepts__xx": concepts, "sheerka": self.sheerka}
locals_ = {}
exec(new_condition, globals_, locals_)
return locals_["result"]
else:
return self._get_concepts(context, ids, False, logger)
return self._get_concepts(context, ids, False)
# it may be a concept that references a set
if not sub_concept.metadata.is_evaluated:
@@ -160,30 +152,27 @@ class SheerkaSetsManager:
return False
def isaset(self, context, concept, logger=None):
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:
:param logger:
:return:
"""
""""""
logger = logger or self.sheerka.log
if not (isinstance(concept, Concept) and concept.id):
return None
# it may be a concept that references a set
if not concept.metadata.is_evaluated:
with context.push(desc=f"Evaluating concept {concept}") as sub_context:
evaluated = self.sheerka.evaluate_concept(sub_context, concept, logger)
evaluated = self.sheerka.evaluate_concept(sub_context, concept)
if evaluated.key != concept.key:
return False
if concept.body:
return self.isaset(context, concept.body, logger)
return self.isaset(context, concept.body)
res = self.sheerka.sdp.get_safe(GROUP_PREFIX + concept.id)
return res is not None
@@ -211,7 +200,7 @@ for x in xx__concepts__xx:
"""
return expression
def _get_concepts(self, context, ids, evaluate, logger):
def _get_concepts(self, context, ids, evaluate):
"""
Gets concepts from a list of concepts ids
:param ids:
@@ -229,7 +218,7 @@ for x in xx__concepts__xx:
with context.push(desc=f"Evaluating concepts of a set") as sub_context:
for element_id in ids:
concept = self.sheerka.get_by_id(element_id)
evaluated = self.sheerka.evaluate_concept(context, concept, logger)
evaluated = self.sheerka.evaluate_concept(context, concept)
result.append(evaluated)
return result
src/core/sheerka/Sheerka.py
+34 -29
View File
@@ -40,6 +40,7 @@ class Sheerka(Concept):
def __init__(self, skip_builtins_in_db=False, debug=False, loggers=None):
self.init_logging(debug, loggers)
self.loggers = loggers
super().__init__(BuiltinConcepts.SHEERKA, True, True, BuiltinConcepts.SHEERKA)
self.log.debug("Starting Sheerka.")
@@ -110,17 +111,18 @@ class Sheerka(Concept):
event = Event("Initializing Sheerka.", user=self.name)
self.sdp.save_event(event)
exec_context = ExecutionContext(self.key, event, self)
with ExecutionContext(self.key, event, self, "Initializing Sheerka.", self.init_log) as exec_context:
self.initialize_builtin_concepts()
self.initialize_builtin_parsers()
self.initialize_builtin_evaluators()
self.initialize_concepts_definitions(exec_context)
res = ReturnValueConcept(self, True, self)
self.initialize_builtin_concepts()
self.initialize_builtin_parsers()
self.initialize_builtin_evaluators()
self.initialize_concepts_definitions(exec_context)
res = ReturnValueConcept(self, True, self)
exec_context.add_values(return_values=res)
if not self.skip_builtins_in_db:
self.sdp.save_result(exec_context)
exec_context.add_values(return_values=res)
if not self.skip_builtins_in_db:
self.sdp.save_result(exec_context)
self.init_log.debug(f"Sheerka successfully initialized")
except IOError as e:
res = ReturnValueConcept(self, False, self.get(BuiltinConcepts.ERROR), e)
@@ -191,8 +193,7 @@ class Sheerka(Concept):
self.evaluators.append(evaluator)
def initialize_concepts_definitions(self, execution_context):
self.init_log.debug("Initializing concepts definitions")
# definitions = self.sdp.get_safe(self.CONCEPTS_DEFINITIONS_ENTRY, load_origin=False)
self.init_log.debug("Initializing concepts grammars.")
definitions = self.get_concepts_definitions(execution_context)
if definitions is None:
@@ -234,7 +235,7 @@ class Sheerka(Concept):
evt_digest = self.sdp.save_event(event)
self.log.debug(f"{evt_digest=}")
with ExecutionContext(self.key, event, self, f"Evaluating '{text}'") as execution_context:
with ExecutionContext(self.key, event, self, f"Evaluating '{text}'", self.log) as execution_context:
user_input = self.ret(self.name, True, self.new(BuiltinConcepts.USER_INPUT, body=text, user_name=user_name))
reduce_requested = self.ret(self.name, True, self.new(BuiltinConcepts.REDUCE_REQUESTED))
@@ -261,7 +262,7 @@ class Sheerka(Concept):
return ret
def execute(self, execution_context, return_values, execution_steps, logger=None):
def execute(self, execution_context, return_values, execution_steps):
"""
Executes process for all initial contexts
:param execution_context:
@@ -270,7 +271,7 @@ class Sheerka(Concept):
:param logger: logger to use (if not directly called by sheerka)
:return:
"""
return self.execute_handler.execute(execution_context, return_values, execution_steps, logger)
return self.execute_handler.execute(execution_context, return_values, execution_steps)
def set_id_if_needed(self, obj: Concept, is_builtin: bool):
"""
@@ -287,7 +288,7 @@ class Sheerka(Concept):
obj.metadata.id = self.sdp.get_next_key(entry)
self.log.debug(f"Setting id '{obj.metadata.id}' to concept '{obj.metadata.name}'.")
def create_new_concept(self, context, concept: Concept, logger=None):
def create_new_concept(self, context, concept: Concept):
"""
Adds a new concept to the system
:param context:
@@ -296,12 +297,12 @@ class Sheerka(Concept):
:return: digest of the new concept
"""
return self.create_new_concept_handler.create_new_concept(context, concept, logger)
return self.create_new_concept_handler.create_new_concept(context, concept)
def modify_concept(self, context, concept: Concept, logger):
return self.modify_concept_handler.modify_concept(context, concept, logger)
def modify_concept(self, context, concept: Concept):
return self.modify_concept_handler.modify_concept(context, concept)
def add_concept_to_set(self, context, concept, concept_set, logger=None):
def add_concept_to_set(self, context, concept, concept_set):
"""
Add an entry in sdp to tell that concept isa concept_set
:param context:
@@ -310,9 +311,9 @@ class Sheerka(Concept):
:param logger:
:return:
"""
return self.sets_handler.add_concept_to_set(context, concept, concept_set, logger)
return self.sets_handler.add_concept_to_set(context, concept, concept_set)
def set_isa(self, context, concept, concept_set, logger=None):
def set_isa(self, context, concept, concept_set):
"""
:param context:
@@ -321,7 +322,7 @@ class Sheerka(Concept):
:param logger:
:return:
"""
return self.sets_handler.set_isa(context, concept, concept_set, logger)
return self.sets_handler.set_isa(context, concept, concept_set)
def get_set_elements(self, context, concept):
"""
@@ -334,7 +335,7 @@ class Sheerka(Concept):
return self.sets_handler.get_set_elements(context, concept)
def evaluate_concept(self, context, concept: Concept, logger=None):
def evaluate_concept(self, context, concept: Concept):
"""
Evaluation a concept
It means that if the where clause is True, will evaluate the body
@@ -343,7 +344,7 @@ class Sheerka(Concept):
:param logger:
:return: value of the evaluation or error
"""
return self.evaluate_concept_handler.evaluate_concept(context, concept, logger)
return self.evaluate_concept_handler.evaluate_concept(context, concept)
def add_in_cache(self, concept: Concept):
"""
@@ -424,18 +425,20 @@ class Sheerka(Concept):
return result
def get_concepts_definitions(self, context):
if self.concepts_definitions_cache:
return self.concepts_definitions_cache
encoded = self.sdp.get_safe(
encoded_bnf = self.sdp.get_safe(
self.CONCEPTS_DEFINITIONS_ENTRY,
load_origin=False) or {}
self.concepts_definitions_cache = {}
bnf_parser = self.parsers[BNF_PARSER_CLASS]()
for k, v in encoded.items():
for k, v in encoded_bnf.items():
key, id_ = core.utils.unstr_concept(k)
concept = self.new((key, id_))
context.log(f"Parsing BNF definition for {concept}", context.who)
rule_result = bnf_parser.parse(context, v)
if rule_result.status:
self.concepts_definitions_cache[concept] = rule_result.value.value
@@ -681,10 +684,12 @@ class Sheerka(Concept):
@staticmethod
def init_logging(debug, loggers):
core.sheerka_logger.set_enabled(loggers)
core.sheerka_logger.init_config(loggers)
if debug:
# log_format = "%(asctime)s %(name)s [%(levelname)s] %(message)s"
log_format = "%(asctime)s [%(levelname)s] %(message)s"
log_format = "%(asctime)s"
if "show-name" in loggers:
log_format += " %(name)s"
log_format += " [%(levelname)s] %(message)s"
log_level = logging.DEBUG
else:
log_format = "%(message)s"
src/core/sheerka_logger.py
+19 -8
View File
@@ -2,21 +2,32 @@ import logging
import sys
enabled = []
disabled = ["init", "sdp", "parsers", "evaluators", "verbose"]
disabled = ["init", "sdp", "parsers", "evaluators", "verbose", "stats"]
console_handler = logging.StreamHandler(sys.stdout)
all_loggers = {}
def set_enabled(to_enable):
if to_enable is None:
def init_config(loggers):
if loggers is None:
return
if not hasattr(to_enable, "__iter__"):
to_enable = [to_enable]
if not hasattr(loggers, "__iter__"):
loggers = [loggers]
enabled.extend(to_enable)
if "all" in loggers:
disabled.clear()
for logger in loggers:
if logger == "all":
continue
if logger.startswith("-"):
disabled.append(logger[1:])
elif logger.startswith("+"):
enabled.append(logger[1:])
else:
enabled.append(logger)
def to_discard(logger_class):
@@ -40,7 +51,7 @@ def get_logger(logger_name):
all_loggers[logger_name] = logger
for d in disabled:
if logger_name.startswith(d + ".") and to_discard(d):
if (logger_name == d or logger_name.startswith(d + ".")) and to_discard(d):
logger.disabled = True
for e in enabled: