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()}