def __init__(self, predicate, arguments, *args):
"""
:param predicate:
:param arguments:
:param args:
:return:
"""
super(Literal, self).__init__()
self.predicate = predicate
self.arguments = tuple(arguments)
if len(args) == 0:
from spf.mr.lambda_.logic_language_services import LogicLanguageServices
type_comparator = LogicLanguageServices.get_type_comparator()
type_repository = LogicLanguageServices.get_type_repository()
elif len(args) == 2:
type_comparator = args[0]
type_repository = args[1]
else:
raise RuntimeError("Wrong number of arguments")
if not predicate.get_type().is_complex():
raise LogicalExpressionRuntimeError("Predicate must have a complex type, not %s" % predicate.get_type())
literal_typing = Literal.compute_literal_typing(
self.predicate.get_type(), [arg.get_type() for arg in self.arguments], type_comparator, type_repository
)
self.type_ = None if literal_typing is None else literal_typing[0]
def __init__(self, argument, body, type_repository=None):
super(Lambda, self).__init__()
if type_repository is None:
from spf.mr.lambda_.logic_language_services import LogicLanguageServices
type_repository = LogicLanguageServices.get_type_repository()
self.argument = argument
self.body = body
self.type_ = type_repository.get_type_create_if_needed(self.body.get_type(), self.argument.get_type())
def read(string, type_repository=None):
if type_repository is None:
from spf.mr.lambda_.logic_language_services import LogicLanguageServices
type_repository = LogicLanguageServices.get_type_repository()
split = string.split(Term.TYPE_SEPARATOR)
if len(split) != 2:
raise LogicalExpressionRuntimeError('Constant syntax error: %s' % string)
type_ = type_repository.get_type(split[1])
if type_ is None:
type_ = type_repository.get_type_create_if_needed(split[1])
if type_ is None:
raise LogicalExpressionRuntimeError('Unknown type for: %s' % string)
return LogicalConstant.create(string, type_)
def read(cls, string, mapping=None, type_repository=None, type_comparator=None):
if mapping is None:
mapping = {}
if type_repository is None:
type_repository = LogicLanguageServices.get_type_repository()
if type_comparator is None:
type_comparator = LogicLanguageServices.get_type_comparator()
flat_string = cls.WHITE_SPACE.sub(string, " ")
try:
for reader in cls.readers:
if reader.is_valid(flat_string):
return reader.read(flat_string, mapping, type_repository, type_comparator, cls)
raise AttributeError("Invalid logical expression syntax: %s" % string)
except Exception, e:
cls.LOG.error("Logic expression syntax error: %s" % flat_string)
raise e
def verify_arg_type(self, signature_type, arg_type):
return arg_type.is_extending_or_extended_by(
LogicLanguageServices.get_type_repository().generalize_type(signature_type))
def do_is_factorable(cls, constant):
return not LogicLanguageServices.is_coordination_predicate(constant) and \
not LogicLanguageServices.is_array_index_predicate(constant) and \
not LogicLanguageServices.is_array_sub_predicate(constant) and \
LogicLanguageServices.get_type_repository().get_index_type() != constant.get_type() and \
constant not in cls.unfactored_constants
def is_valid_name(cls, name):
from spf.mr.lambda_.logic_language_services import LogicLanguageServices
split = name.split(':', 2)
type_repository = LogicLanguageServices.get_type_repository()
return cls.REGEXP_NAME_PATTERN.match(split[0]) is not None and \
type_repository.get_type_create_if_needed(split[1]) is not None
def get_signature(constants):
return [LogicLanguageServices.get_type_repository().generalize_type(constant.get_type())
for constant in constants]
