def __init__(self, expr):
expr = normalize_expr(expr)
super(Condition, self).__init__(all_fields=expr.all_fields)
if expr.get_type() is not Boolean:
raise RuleEngineError(
'Condition must be of boolean type. Got "{}", which is {}'.
format(expr, expr.get_type()))
self.expr = expr
def __init__(self, expr):
expr = normalize_expr(expr)
super(Condition, self).__init__(all_fields=expr.all_fields)
if expr.get_type() is not Boolean:
raise RuleEngineError(
'Condition must be of boolean type. Got "{}", which is {}'.format(expr, expr.get_type())
)
self.expr = expr
def add_variable(self, *exprs):
free_value = None
matching_var_names = set()
for expr in sorted(exprs, key=str):
if isinstance(expr, (FieldExpr, FactExpr)):
try:
matching_var_names.add(self.variable_map[expr].var_name)
except KeyError:
pass
else:
expr = normalize_expr(expr)
if free_value is None:
free_value = expr
elif free_value != expr:
raise ValueError(
'Conflicting unbound values: {}, {}'.format(
free_value, expr))
if not matching_var_names:
var_name = self.general_varnames.next()
if exprs[0].get_type() is Multifield:
var_name = '$' + var_name
else:
var_names = sorted(matching_var_names)
var_name = var_names[0]
for prev_var_name in var_names[1:]:
self._replace_variable(prev_var_name, var_name)
for expr in exprs:
if isinstance(expr, FactExpr):
self.set_premise(expr.fact)
if free_value is not None:
raise ValueError('Type mismatch: {}, {}'.format(
expr, free_value))
elif isinstance(expr, FieldExpr):
self.set_premise(expr.container).add(expr, var_name)
self.variable_map[expr] = VariableExpr(var_name,
expr.get_type())
if free_value is not None:
self.variable_values[var_name] = free_value.to_lisp()
return var_name
def add_variable(self, *exprs):
free_value = None
matching_var_names = set()
for expr in sorted(exprs, key=str):
if isinstance(expr, (FieldExpr, FactExpr)):
try:
matching_var_names.add(self.variable_map[expr].var_name)
except KeyError:
pass
else:
expr = normalize_expr(expr)
if free_value is None:
free_value = expr
elif free_value != expr:
raise ValueError('Conflicting unbound values: {}, {}'.format(free_value, expr))
if not matching_var_names:
var_name = self.general_varnames.next()
if exprs[0].get_type() is Multifield:
var_name = '$' + var_name
else:
var_names = sorted(matching_var_names)
var_name = var_names[0]
for prev_var_name in var_names[1:]:
self._replace_variable(prev_var_name, var_name)
for expr in exprs:
if isinstance(expr, FactExpr):
self.set_premise(expr.fact)
if free_value is not None:
raise ValueError('Type mismatch: {}, {}'.format(expr, free_value))
elif isinstance(expr, FieldExpr):
self.set_premise(expr.container).add(expr, var_name)
self.variable_map[expr] = VariableExpr(var_name, expr.get_type())
if free_value is not None:
self.variable_values[var_name] = free_value.to_lisp()
return var_name
def __init__(self, **data):
super(AssertOrUpdate, self).__init__()
self.data = {
key: normalize_expr(value)
for key, value in data.iteritems()
}
def replace_fields(self, field_map):
return type(self)(self.expr.replace_fields(field_map))
def __str__(self):
return "Condition <{}>".format(self.expr)
class UnaryOperator(BaseExpr):
def __init__(self, expr, op):
super(UnaryOperator, self).__init__(all_fields=expr.all_fields)
self.expr = expr
self.op = op
def get_type(self):
return self.expr.get_type()
def to_lisp(self):
return LispExpr(self.op, self.expr.to_lisp())
def replace_fields(self, field_map):
return type(self)(expr=self.expr.replace_fields(field_map), op=self.op)
def __str__(self):
return "({} {})".format(self.op, self.expr)
or_ = lambda *args: BooleanBinaryOperator("or", *(normalize_expr(arg) for arg in args))
and_ = lambda *args: BooleanBinaryOperator("and", *(normalize_expr(arg) for arg in args))
not_ = lambda expr: UnaryOperator(normalize_expr(expr), op="not")
def __init__(self, func_name, return_type, *args):
self.func_name = func_name
self.return_type = return_type
self.args = [normalize_expr(arg) for arg in args]
all_fields = reduce(set.union, (arg.all_fields for arg in self.args), set())
super(ClipsFuncExpr, self).__init__(all_fields=all_fields)
def prepare_rule(self, rule):
self.data.update({key : normalize_expr(value) for key, value in rule.groupby.iteritems()})
self.data[UNIQUE_INDEX_FIELD] = gensym()
super(AssertAggregate, self).prepare_rule(rule)
self._create_reduce_rule(rule)
return type(self)(self.expr.replace_fields(field_map))
def __str__(self):
return 'Condition <{}>'.format(self.expr)
class UnaryOperator(BaseExpr):
def __init__(self, expr, op):
super(UnaryOperator, self).__init__(all_fields=expr.all_fields)
self.expr = expr
self.op = op
def get_type(self):
return self.expr.get_type()
def to_lisp(self):
return LispExpr(self.op, self.expr.to_lisp())
def replace_fields(self, field_map):
return type(self)(expr=self.expr.replace_fields(field_map), op=self.op)
def __str__(self):
return '({} {})'.format(self.op, self.expr)
or_ = lambda *args: BooleanBinaryOperator(
'or', *(normalize_expr(arg) for arg in args))
and_ = lambda *args: BooleanBinaryOperator(
'and', *(normalize_expr(arg) for arg in args))
not_ = lambda expr: UnaryOperator(normalize_expr(expr), op='not')
def __init__(self, **data):
super(AssertOrUpdate, self).__init__()
self.data = {key: normalize_expr(value) for key, value in data.iteritems()}
