282 lines
8.6 KiB
Python
282 lines
8.6 KiB
Python
from enum import Enum
|
|
|
|
from core.concept import Concept
|
|
|
|
|
|
class BuiltinConcepts(Enum):
|
|
"""
|
|
List of builtin concepts that do no need any specific implementation
|
|
Please note that the value of the enum is informal. It is not used in the system
|
|
For example, the concept 'NODE' DOES NOT have the key, the id or whatever 200
|
|
The key if the name of the concept
|
|
The id is a sequential number given just before the concept is saved in sdp
|
|
|
|
The values of the enum are just a convenient way for me to group the concepts
|
|
"""
|
|
SHEERKA = 1
|
|
SUCCESS = 2
|
|
ERROR = 3
|
|
UNKNOWN_CONCEPT = 4 # the request concept is not recognized
|
|
RETURN_VALUE = 5 # a value is returned
|
|
CONCEPT_TOO_LONG = 6 # concept cannot be processed by exactConcept parser
|
|
NEW_CONCEPT = 7 # when a new concept is added
|
|
UNKNOWN_PROPERTY = 8 # when requesting for a unknown property
|
|
PARSER_RESULT = 9
|
|
TOO_MANY_SUCCESS = 10 # when expecting a limited number of successful return value
|
|
TOO_MANY_ERRORS = 11 # when expecting a limited number of successful return value
|
|
NOT_FOR_ME = 12 # a parser recognize that the entry is not meant for it
|
|
IS_EMPTY = 13 # when a set is empty
|
|
INVALID_RETURN_VALUE = 14 # the return value of an evaluator is not correct
|
|
BEFORE_PARSING = 15 # activated before evaluation by the parsers
|
|
PARSING = 16 # activated during the parsing. It contains the text to parse
|
|
AFTER_PARSING = 17 # after parsing
|
|
BEFORE_EVALUATION = 18 # before evaluation
|
|
EVALUATION = 19 # activated when the parsing process seems to be finished
|
|
AFTER_EVALUATION = 20 # activated when the parsing process seems to be finished
|
|
CONCEPT_ALREADY_DEFINED = 21 # when you try to add the same concept twice
|
|
NOP = 22 # no operation concept. Does nothing
|
|
PROPERTY_EVAL_ERROR = 23 # cannot evaluate a property of a concept
|
|
ENUMERATION = 24 # represents a list or a set
|
|
LIST = 25 # represents a list
|
|
CANNOT_RESOLVE_VALUE_ERROR = 26 # In presence of a concept where the default value is not know
|
|
|
|
NODE = 200
|
|
GENERIC_NODE = 201
|
|
IDENTIFIER_NODE = 202
|
|
|
|
|
|
"""
|
|
Some concepts have a specific implementation
|
|
It's mainly to a have proper __repr__ implementation, or redefine the is_unique attribut
|
|
"""
|
|
|
|
|
|
class SuccessConcept(Concept):
|
|
def __init__(self):
|
|
super().__init__(BuiltinConcepts.SUCCESS, True, True, BuiltinConcepts.SUCCESS)
|
|
|
|
|
|
class ErrorConcept(Concept):
|
|
def __init__(self, error=None):
|
|
super().__init__(BuiltinConcepts.ERROR, True, False, BuiltinConcepts.ERROR, body=error)
|
|
|
|
def __repr__(self):
|
|
return f"({self.id}){self.name}: {self.body}"
|
|
|
|
|
|
class ReturnValueConcept(Concept):
|
|
"""
|
|
This class represents the result of a data flow processing
|
|
It's the main input for the evaluators
|
|
"""
|
|
|
|
def __init__(self, who=None, status=None, value=None, message=None, parents=None):
|
|
super().__init__(BuiltinConcepts.RETURN_VALUE, True, False, BuiltinConcepts.RETURN_VALUE)
|
|
self.set_prop("who", who)
|
|
self.set_prop("status", status)
|
|
self.body = value
|
|
self.set_prop("message", message)
|
|
self.set_prop("parents", parents)
|
|
|
|
@property
|
|
def who(self):
|
|
return self.props["who"].value
|
|
|
|
@who.setter
|
|
def who(self, value):
|
|
self.set_prop("who", value)
|
|
|
|
@property
|
|
def status(self):
|
|
return self.props["status"].value
|
|
|
|
@status.setter
|
|
def status(self, value):
|
|
self.set_prop("status", value)
|
|
|
|
@property
|
|
def value(self):
|
|
return self.body
|
|
|
|
@value.setter
|
|
def value(self, value):
|
|
self.body = value
|
|
|
|
@property
|
|
def message(self):
|
|
return self.props["message"].value
|
|
|
|
@message.setter
|
|
def message(self, value):
|
|
self.set_prop("message", value)
|
|
|
|
@property
|
|
def parents(self):
|
|
return self.props["parents"].value
|
|
|
|
@parents.setter
|
|
def parents(self, value):
|
|
self.set_prop("parents", value)
|
|
|
|
def __repr__(self):
|
|
return f"ReturnValue(who={self.who}, status={self.status}, value={self.value}, message={self.message})"
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, ReturnValueConcept):
|
|
return False
|
|
|
|
return self.who == other.who and \
|
|
self.status == other.status and \
|
|
self.value == other.value and \
|
|
self.message == other.message
|
|
|
|
def __hash__(self):
|
|
return hash((self.who, self.status, self.value))
|
|
|
|
|
|
class UnknownPropertyConcept(Concept):
|
|
"""
|
|
This error is raised when, during sheerka.new(), an unknown property is asked
|
|
"""
|
|
|
|
def __init__(self, property_name=None, concept=None):
|
|
super().__init__(BuiltinConcepts.UNKNOWN_PROPERTY, True, False, BuiltinConcepts.UNKNOWN_PROPERTY)
|
|
self.set_prop("concept", concept)
|
|
self.body = property_name
|
|
|
|
def __repr__(self):
|
|
return f"UnknownProperty(property={self.property_name}, concept={self.concept})"
|
|
|
|
@property
|
|
def concept(self):
|
|
return self.props["concept"].value
|
|
|
|
@property
|
|
def property_name(self):
|
|
return self.body
|
|
|
|
|
|
class ParserResultConcept(Concept):
|
|
"""
|
|
Result of a parsing
|
|
"""
|
|
|
|
def __init__(self, parser=None, source=None, value=None, try_parsed=None):
|
|
super().__init__(BuiltinConcepts.PARSER_RESULT, True, False, BuiltinConcepts.PARSER_RESULT)
|
|
self.set_prop("parser", parser)
|
|
self.set_prop("source", source)
|
|
self.set_prop("try_parsed", try_parsed) # in case of error, what was found before the error
|
|
self.body = value
|
|
|
|
def __repr__(self):
|
|
return f"ParserResult({self.body})"
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, ParserResultConcept):
|
|
return False
|
|
|
|
return self.source == other.source and \
|
|
self.parser == other.parser and \
|
|
self.body == other.body and \
|
|
self.try_parsed == other.try_parsed
|
|
|
|
@property
|
|
def value(self):
|
|
return self.body
|
|
|
|
@property
|
|
def try_parsed(self):
|
|
return self.props["try_parsed"].value
|
|
|
|
@property
|
|
def source(self):
|
|
return self.props["source"].value
|
|
|
|
@property
|
|
def parser(self):
|
|
return self.props["parser"].value
|
|
|
|
|
|
class InvalidReturnValueConcept(Concept):
|
|
"""
|
|
Error returned when an evaluator is not correctly coded
|
|
The accepted return value are
|
|
ReturnValueConcept, list of ReturnValueConcept or None
|
|
"""
|
|
|
|
def __init__(self, return_value=None, evaluator=None):
|
|
super().__init__(BuiltinConcepts.INVALID_RETURN_VALUE, True, False, BuiltinConcepts.INVALID_RETURN_VALUE)
|
|
self.set_prop("evaluator", evaluator)
|
|
self.body = return_value
|
|
|
|
|
|
class BeforeParsingConcept(Concept):
|
|
def __init__(self):
|
|
super().__init__(BuiltinConcepts.BEFORE_PARSING, True, True, BuiltinConcepts.BEFORE_PARSING)
|
|
|
|
|
|
class EvaluationConcept(Concept):
|
|
def __init__(self):
|
|
super().__init__(BuiltinConcepts.EVALUATION, True, True, BuiltinConcepts.EVALUATION)
|
|
|
|
|
|
class AfterEvaluationConcept(Concept):
|
|
def __init__(self):
|
|
super().__init__(BuiltinConcepts.AFTER_EVALUATION, True, True, BuiltinConcepts.AFTER_EVALUATION)
|
|
|
|
|
|
class PropertyEvalError(Concept):
|
|
def __init__(self, property_name=None, concept=None, error=None):
|
|
super().__init__(BuiltinConcepts.PROPERTY_EVAL_ERROR, True, False, BuiltinConcepts.PROPERTY_EVAL_ERROR)
|
|
self.set_prop("concept", concept)
|
|
self.set_prop("error", error)
|
|
self.body = property_name
|
|
|
|
def __repr__(self):
|
|
return f"PropertyEvalError(property={self.property_name}, concept={self.concept}), error={self.error})"
|
|
|
|
@property
|
|
def concept(self):
|
|
return self.props["concept"].value
|
|
|
|
@property
|
|
def error(self):
|
|
return self.props["error"].value
|
|
|
|
@property
|
|
def property_name(self):
|
|
return self.body
|
|
|
|
|
|
class EnumerationConcept(Concept):
|
|
def __init__(self, iteration=None):
|
|
super().__init__(BuiltinConcepts.ENUMERATION, True, False, BuiltinConcepts.ENUMERATION)
|
|
self.body = iteration
|
|
|
|
def __iter__(self):
|
|
return iter(self.body)
|
|
|
|
|
|
class ListConcept(Concept):
|
|
def __init__(self, items=None):
|
|
super().__init__(BuiltinConcepts.LIST, True, False, BuiltinConcepts.LIST)
|
|
self.body = items or []
|
|
|
|
def append(self, obj):
|
|
self.body.append(obj)
|
|
|
|
def __len__(self):
|
|
return len(self.body)
|
|
|
|
def __getitem__(self, key):
|
|
return self.body[key]
|
|
|
|
def __setitem__(self, key, value):
|
|
self.body[key] = value
|
|
|
|
def __iter__(self):
|
|
return iter(self.body)
|
|
|
|
def __contains__(self, item):
|
|
return item in self.body
|