Beispiel #1
0
    def sched_timeout(self):
        #start timer operations after the filter has started actual filtering
        self.start_timer_event.wait()
        while True:
            #wait
            time.sleep(self.config.timeout)
            #wait for signal from main thread: the signal is send if the specified no. of packets is met
            self.notif_timer_event.wait()
            if self.config.rules_count < Rule.num_of_rules():
                with self.lock:
                    self.config.incr_rules_count = 	\
                     self.config.incr_rules_count if((Rule.num_of_rules() - self.config.rules_count) > self.config.incr_rules_count) \
                      else (Rule.num_of_rules() - self.config.rules_count)

                    self.config.update()
                    #clear event
                    self.notif_timer_event.clear()
                    #reset pkt_count
                    self.pkt_count = 0

                    if self.config.rules_count == Rule.num_of_rules():
                        print("    # all rules defined have been added.")
                        #stop timer incase all rules have been added to self._rules

                    #resume capture
                    print('    # resuming capture.\n')
                    print("    ", end="")
                    print("src".ljust(20) + "dst".ljust(20) + "protocol".ljust(10) + "ttl".ljust(10) + "action".ljust(15) + \
                     "memory(MBs)".ljust(15) + "cummulative cpu time(secs)")
                    print("    ", end="")
                    print(('-' * 116))
            else:
                #stop timer, all defined rules have been added
                break
Beispiel #2
0
 def __init__(self, rules_db):
     Rule.__init__(
         self, [],
         expression_from_list(
             [rules_db.add_constant_by_name("atom"),
              Variable("X")]), rules_db.add_constant_by_name("atom_rule"),
         "(built-in)", rules_db)
def get_mode_one_config(parser, p_result):

    issues = ''
    if not p_result.rules_count:
        issues += "    - no. of rules not provided.\n"

    if not p_result.rule_nums:
        issues += "    - rule numbers (comma-seperated) not provided.\n"

    if issues:
        print('[-] issues:\n' + issues)
        parser.print_usage()
        sys.exit(0)

    if p_result.rules_count == 'all':
        p_result.rules_count = Rule.num_of_rules()
        p_result.rules = list(Rule.get_all_rules().keys())

    else:
        p_result.rule_nums = [
            int(i) for i in p_result.rule_nums.split(',') if i
        ]
        p_result.rules_count = len(p_result.rule_nums)
        print('    # initializing rules', end='')
        p_result.rules = Rule.get_rules_from_nums(p_result.rule_nums)

    return ModeOneFilterConfig(p_result)
    def update_rules(self):
        """
		create a new list of random rules.
		"""
        self.rule_nums = Rule.get_rules_randomly(self.rules_count)
        print('    # initializing rules.', end=' ')
        self.rules = Rule.get_rules_from_nums(self.rule_nums)
Beispiel #5
0
    def execute(self):
        ListRules().execute()
        operator = input(
            "Choose operator to apply to rules(number).\n1. Any \n2. All\nChoose: "
        )
        try:
            operator = int(operator)
        except ValueError:
            print("Choose numbers\n 1. Any \n2. All\n ")

        rules_to_apply = []
        while True:
            ListRules().execute()
            rule = input(
                "Rule Name to apply or done in case you wish to execute now: ")
            rule = rule.strip()
            if rule == "done":
                break

            if self.fetch_rule(rule):
                if rule not in rules_to_apply:
                    rules_to_apply.append(rule)
            else:
                print("Could not find rule")

        ListAction().execute()
        action_name = input("Action to apply. Choose by name: ")
        action_types = [
            action.action_name for action in ActionType.__subclasses__()
        ]
        if action_name not in action_types:
            print("Could not find the action")

        if action_name == 'move':
            move_folder = input("Where should I move the emails: ")
        else:
            move_folder = None

        result_ids = set()
        for rule in rules_to_apply:
            rule = Rule(rule)
            rule.from_json(rule.rule_file)
            result = rule.fetch_for_rule()
            new_result_ids = set([message.gmail_id for message in result])
            if operator == 1:
                result_ids.union(new_result_ids)
            else:
                if len(result_ids) == 0:
                    result_ids = new_result_ids
                else:
                    result_ids.intersection(new_result_ids)

        actions = [
            action for action in ActionType.__subclasses__()
            if action.action_name == action_name
        ]
        action = actions[0]
        action().apply(result_ids, move_folder=move_folder)
Beispiel #6
0
def backup(args):
    with open(args.config) as config_file:
        config = json.load(config_file)
    rule = Rule(config)
    if args.dryrun:
        # dryrun does not work anymore ('it is dry-run now)
        raise NotImplementedError('dryrun does not work anymore (it is dry-run now)')
    rule.options.dryrun = args.dryrun

    now = datetime.datetime.now()
    rsync_command = ['rsync'] + rule.get_optional_args(now) + rule.get_positional_args(now)

    # create dirs fro log files
    success_filepath = rule.log.get_sucess_filepath(now)
    if not args.debug and success_filepath:
        make_dirpath(success_filepath)

    progress_filepath = rule.log.get_progress_filepath(now)
    if args.verbose or args.debug or not progress_filepath:
        progress_file = sys.stdout
    else:
        make_dirpath(progress_filepath)
        progress_file = open(progress_filepath, "w")

    error_filepath = rule.log.get_error_filepath(now)
    if args.verbose or args.debug or not error_filepath:
        error_file = sys.stderr
    else:
        make_dirpath(error_filepath)
        error_file = open(error_filepath, 'w') if error_filepath else PIPE

    # process
    if args.debug:
        print(' '.join(rsync_command))
    else:
        rsync_process = Popen(rsync_command, stdout=progress_file, stderr=error_file)
        rsync_process.wait()

    # some cleaning
    if progress_filepath and exists(progress_filepath):
        remove(progress_filepath)

    if error_filepath and exists(error_filepath):
        is_errors = not stat(error_filepath).st_size == 0
        if not is_errors:
            remove(error_filepath)
            user_message = 'sucessfull save of {}.'.format(rule.source.dirpath)
        else:
            with open(error_filepath, 'r') as error_file:
                last_error = error_file.readlines()[-1].decode()
                user_message = 'finished with errors on save of {}: {}'.format(rule.source.dirpath, last_error)
    else:
        user_message = 'done'

    notify_command = ['synodsmnotify', '@administrators', 'Backup {}'.format(basename(realpath(rule.source.dirpath))), user_message]
    call(notify_command)

    logging.debug('done')
Beispiel #7
0
        class Test(object):
            # default
            f1 = Rule("f1", to_field="__f1", required=False, allowed_none=True)

            f2 = Rule("f2",
                      to_field="__f2",
                      required=False,
                      allowed_none=False)
            f3 = Rule("f3", to_field="__f3", required=True, allowed_none=False)
            f4 = Rule("f4", to_field="__f4", required=True, allowed_none=True)
def get_mode_four_config(parser, p_result):

    issues = ''

    if not p_result.rules_count_range:
        issues += '    - rules count range not provided.\n'
    else:
        try:
            nr = [int(i) for i in p_result.rules_count_range.split('-')]
            if nr[0] < 1 or nr[1] > Rule.num_of_rules():
                issues += '    - invalid rules count range.\n'
            else:
                # set ranges
                p_result.rules_count_range = tuple(nr)

        except ValueError:
            issues += '    - invalid rules count range.\n'

    if not p_result.timeout_range:
        issues += '    - timeout range not provided.\n'
    else:
        try:
            tr = [int(i) for i in p_result.timeout_range.split('-')]
            if tr[0] < 1:
                issues += '    - invalid timeout range.\n'
            else:
                # set ranges
                p_result.timeout_range = tuple(tr)

        except ValueError:
            issues += '    - invalid timeout range.\n'

    if issues:
        print('[-] issues:\n' + issues)
        parser.print_usage()
        sys.exit(0)

    # initial timeout
    print('    # generating random timeout.')
    p_result.timeout = random.randint(p_result.timeout_range[0],
                                      p_result.timeout_range[1])
    # initial rules count - random from range
    print('    # generating random rules count (no. of rules).')
    p_result.rules_count = random.randint(p_result.rules_count_range[0],
                                          p_result.rules_count_range[1])
    # initial rule numbers
    print('    # generating rule numbers randomly.')
    p_result.rule_nums = Rule.get_rules_randomly(p_result.rules_count)
    # adds a new member variable
    # initial list of rules
    print('    # initializing rules.', end=' ')
    p_result.rules = Rule.get_rules_from_nums(p_result.rule_nums)

    return ModeFourFilterConfig(p_result)
    def update_rules(self):
        """
		Set rules count to a new random value and create a new list
		of random rules.
		"""
        print('    # generating new rules count.')
        self.rules_count = random.randint(self.rules_count_range[0],
                                          self.rules_count_range[1])
        #print('    # generating %d r')
        self.rule_nums = Rule.get_rules_randomly(self.rules_count)
        print('    # initializing rules.', end=' ')
        self.rules = Rule.get_rules_from_nums(self.rule_nums)
Beispiel #10
0
    def execute(self):
        list_rule = ListRules()
        print("The list of rules to choose from, Please choose the name:")
        list_rule.execute()
        rule = input("Describe the rule: ")
        rule_file = rule + '.json'

        if not os.path.isfile(rule_file):
            print("Could not find the rule by the name {}".format(rule))
            exit()

        rule = Rule(rule).from_json(rule_file)
        print(rule.render())
Beispiel #11
0
def update_rules(message):
    global rules
    rules = message
    rules_given_id.clear()
    print("update rules given id {}".format(rules_given_id))
    for r in rules:
        print(r)
        rule = Rule(r, enabled=r['enabled'])
        print(rule.root)
        print(rule.evaluate())
        rule.execute()
    print('updating rules')
    print(rules)
    update_admin() # to send the new rules status
Beispiel #12
0
    def __init__(self, list_of_players):
        '''
			@param: list_of_players: a list of players
			@return: none
		'''
        self.lastgame_round_players = list_of_players
        self.players = list_of_players
        self.rule_checker = Rule()
        self.board = Board([], [])
        self.loser = []
        self.log = []
        if len(list_of_players) > 5 or len(list_of_players) < 3:
            raise Exception("Incorrect number of players")
        colors = ["white", "black", "red", "green", "blue"]
        self.avatar_player = {}
        for i in range(len(list_of_players)):
            self.avatar_player[list_of_players[i]] = Avatar(colors[i], None)
    def __init__(self, rules: list, implications: list, membership_function: dict, domain: tuple):
        self.implication = implications
        self.membership_function = membership_function
        self.domain = domain

        AggregationMethods.__init__(self, Mamdani.consequent_filter)
        self.rules = [Rule(item.split(), max, min, lambda x: 1-x)
                      for item in rules]
Beispiel #14
0
 def __init__(self, learning_rate, no_rules, max_iter):
     self.learning_rate = learning_rate
     self.max_iter = max_iter
     self.rules = [Rule() for _ in range(no_rules)]
     self.samples = [
         SampleDataFunction(x, y) for x in range(-4, 4)
         for y in range(-4, 4)
     ]
     self.sum_w = self.sum_wz = 0
Beispiel #15
0
 def generate_rules(self):
     '''Generate rules from frequent itemsets'''
     
     # start from 2-elements itemsets
     for level in self.itemsets[1:]:
         for itemset in level:
             subsets = Rule.get_subsets(itemset)
             for antecedent in subsets: 
                 consequent = itemset.difference(antecedent)
                 if antecedent and consequent:
                     rule_support = self.support[itemset]
                     rule_confidence = rule_support / self.support[antecedent]
                     if rule_confidence > self.min_confidence:
                         self.rules.append(Rule(antecedent, 
                                                consequent, 
                                                rule_support, 
                                                rule_confidence))
     self.rules.sort(key=lambda rule: rule.confidence)
def get_mode_three_config(parser, p_result):

    issues = ''

    if not p_result.timeout:
        issues += '    - filter timeout not provided.\n'

    if not p_result.rules_count:
        issues += '    - initial no. of rules not provided.\n'
    else:
        p_result.rules_count = int(p_result.rules_count)

    if not p_result.proto:
        issues += '    - protocol not provided.\n'
    elif not p_result.proto in PROTOCOLS.keys():
        issues += '    - invalid protocol.\n'
    else:
        pass

    if not p_result.max_pkts_count:
        issues += '    - max. packet count before incrementing rules not provided.\n'

    if not p_result.incr_rules_count:
        issues += '    - no. of rules to be incremented after timeout not provided.\n'
    elif p_result.rules_count:
        if p_result.incr_rules_count > (Rule.num_of_rules() -
                                        p_result.rules_count):
            issues += '    - no. of increment rules too high.\n'
        else:
            pass

    if issues:
        print('[-] issues:\n' + issues)
        parser.print_usage()
        sys.exit(0)

    print('    # generating random rule numbers.')
    p_result.rule_nums = Rule.get_rules_randomly(p_result.rules_count)
    # adds a new member variable
    print('    # initializing rules', end=' ')
    p_result.rules = Rule.get_rules_from_nums(p_result.rule_nums)
    p_result.proto = PROTOCOLS[p_result.proto]

    return ModeThreeFilterConfig(p_result)
Beispiel #17
0
    def test_metaclass(self):
        rule = Rule("Field")

        class Test(object):
            __metaclass__ = MetaRules
            field = rule

        self.assertTrue(hasattr(Test, "_fields"))
        self.assertEqual(Test._fields, {'field': rule})
        self.assertEqual(Test()._fields, {'field': rule})
Beispiel #18
0
    def get_rules(self):
        '''Generate association rules from frequent itemsets'''

        rules = []
        for itemset in self.itemsets:
            # if itemset is one-element, then antecedent or consequent
            # will be empty, so skip
            if len(itemset) > 1:
                subsets = Rule.get_subsets(itemset)
                for antecedent in subsets:
                    consequent = itemset.difference(antecedent)
                    if antecedent and consequent:
                        rule_support = self.get_support(itemset)
                        rule_confidence = rule_support / self.get_support(
                            antecedent)
                        if rule_confidence > self.min_confidence:
                            rules.append(
                                Rule(antecedent, consequent, rule_support,
                                     rule_confidence))
        rules.sort(key=lambda rule: rule.confidence)
        return rules
Beispiel #19
0
    def _load_rules(self, path):
        rules = []

        with open(path, encoding="utf-8") as f:
            for line in f:
                if line.isspace():
                    continue

                rule = Rule.from_string(line)
                rules.append(rule)

        return RuleSet(rules)
Beispiel #20
0
    def __initialize_rules(self):
        self.rules = []
        rules = []

        try:
            with open("rules.json") as rules_file:
                rules = json.loads(rules_file.read())
        except:
            pass

        for rule in rules:
            self.rules.append(Rule(rule))
def get_mode_five_config(parser, p_result):
    issues = ''
    if not p_result.t_win_trig:
        issues += "    - THRESHOLD_WIN_TRIG not specified.\n"
    if not p_result.win_size:
        issues += "    - WINDOW_SIZE not specified.\n"
    if not p_result.inactive_cp:
        issues += "    - INACTIVE_CHECKED% not specified.\n"

    if issues:
        print('[-] issues:\n' + issues)
        parser.print_usage()
        sys.exit(0)

    p_result.active_p = random.randint(1, (100 - p_result.inactive_cp))
    p_result.active_set = Rule.get_rules_randomly(
        round(float(Rule.num_of_rules()) * p_result.active_p / 100.0))
    print('    # initializing ACTIVE rules.', end=' ')
    rtmp = Rule.get_rules_from_nums(p_result.active_set)
    p_result.active_rules = {}
    for num, rule in zip(p_result.active_set, rtmp):
        p_result.active_rules[num] = rule

    p_result.inactive_set   = Rule.get_new_rules_randomly(\
     round(float(Rule.num_of_rules()) * p_result.inactive_cp/100.0), p_result.active_set)
    print('    # initializing INACTIVE_CHECKED rules.', end=' ')
    rtmp = Rule.get_rules_from_nums(p_result.inactive_set)
    p_result.inactive_rules = {}
    for num, rule in zip(p_result.inactive_set, rtmp):
        p_result.inactive_rules[num] = rule

    return ModeFiveFilterConfig(p_result)
def get_mode_two_config(parser, p_result):

    issues = ''

    if not p_result.timeout:
        issues += '    - filter timeout not provided.\n'

    if not p_result.rules_count:
        issues += '    - no. of rules not provided.\n'

    if issues:
        print('[-] issues:\n' + issues)
        parser.print_usage()
        sys.exit(0)

    p_result.rules_count = int(p_result.rules_count)
    p_result.rule_nums = Rule.get_rules_randomly(p_result.rules_count)
    # adds a new member variable
    print('    # initializing rules', end=' ')
    p_result.rules = Rule.get_rules_from_nums(p_result.rule_nums)

    return ModeTwoFilterConfig(p_result)
Beispiel #23
0
def add_builtins(rules_db):
    rules_db.add_rule(
        Rule([],
             expression_from_list([
                 Variable("X"),
                 rules_db.add_constant_by_name("is"),
                 Variable("X")
             ]), rules_db.add_constant_by_name("is_rule"), "(built-in)",
             rules_db))

    rules_db.add_rule(RuleIsNot(rules_db))
    rules_db.add_rule(RuleAtom(rules_db))
    rules_db.add_rule(RuleNewAtom(rules_db))
Beispiel #24
0
def test(definitions):
    from rules import Rule

    definitions.set_attribute('Plus', 'Flat')
    definitions.set_attribute('Plus', 'Orderless')
    definitions.set_attribute('g', 'Orderless')

    eval = Evaluation(Symbol('unused'), definitions)

    #expr = 'Plus[a,b,c,d,e,f,g,h,i,1,2,3]'
    #expr = 'a+b+a+e+a+b+a+e+a+b+a+e+a+b+a+e+f'
    #expr = 'a+b+c+d+e+f+g+h+i+j+k+l+a+b'
    #pattern = 'x_+x_+b+c+d+e+f+g+h+i+j+k+l'
    #expr = 'a+b+c+d+e+f+g+h+i+j+k+l+a+b+b+1+2+3'
    #pattern = 'x_+x_+c+d+e+f+g+h+i+j+k+l'
    #pattern = 'Plus[x_]'
    #expr = 'g[a+b+c+d+e,b,e,d,c,a]'
    #pattern = 'g[x__+y_,y_,x__]'
    #expr = 'g[a+b+c+d+e,b]'
    #pattern = 'g[x__+y_,y_]'
    #expr = 'a+a+b'
    #pattern = 'x__+x__'
    #expr = 'a+b+c'
    #pattern = 'x_+y_'
    expr = 'Format[a+b]'
    pattern = 'Format[Plus[items__]]'

    #expr = 'a*b+c*d+e*f+g*h+i*j+k*l+m*n'
    #pattern = 'a_*x_+b_*x_+a_*x_+b_*x_'

    expr = parse(expr).evaluate(eval)
    pattern = parse(pattern).evaluate(eval)
    print expr
    print pattern
    rule = Rule(pattern, parse('3'))
    #evaluation = Evaluation(Expression)
    print '%s' % rule.apply(expr, eval)
Beispiel #25
0
def test(definitions):
    from rules import Rule
    
    definitions.set_attribute('Plus', 'Flat')
    definitions.set_attribute('Plus', 'Orderless')
    definitions.set_attribute('g', 'Orderless')
    
    eval = Evaluation(Symbol('unused'), definitions)
    
    #expr = 'Plus[a,b,c,d,e,f,g,h,i,1,2,3]'
    #expr = 'a+b+a+e+a+b+a+e+a+b+a+e+a+b+a+e+f'
    #expr = 'a+b+c+d+e+f+g+h+i+j+k+l+a+b'
    #pattern = 'x_+x_+b+c+d+e+f+g+h+i+j+k+l'
    #expr = 'a+b+c+d+e+f+g+h+i+j+k+l+a+b+b+1+2+3'
    #pattern = 'x_+x_+c+d+e+f+g+h+i+j+k+l'
    #pattern = 'Plus[x_]'
    #expr = 'g[a+b+c+d+e,b,e,d,c,a]'
    #pattern = 'g[x__+y_,y_,x__]'
    #expr = 'g[a+b+c+d+e,b]'
    #pattern = 'g[x__+y_,y_]'
    #expr = 'a+a+b'
    #pattern = 'x__+x__'
    #expr = 'a+b+c'
    #pattern = 'x_+y_'
    expr = 'Format[a+b]'
    pattern = 'Format[Plus[items__]]'
    
    #expr = 'a*b+c*d+e*f+g*h+i*j+k*l+m*n'
    #pattern = 'a_*x_+b_*x_+a_*x_+b_*x_'
    
    expr = parse(expr).evaluate(eval)
    pattern = parse(pattern).evaluate(eval)
    print expr
    print pattern
    rule = Rule(pattern, parse('3'))
    #evaluation = Evaluation(Expression)
    print '%s' % rule.apply(expr, eval)
    def update_rules(self):

        print('\n    ' + '#' * 90)
        new_rule_nums = Rule.get_new_rules_randomly(\
         self.incr_rules_count, self.rule_nums)

        #new_rule_nums.sort()

        #add new rule numbers to self._rule_nums
        print("    # adding", self.incr_rules_count, " more rule(s)")

        #instantiate new rules, add them to self._rules
        [self.rule_nums.append(rn) for rn in new_rule_nums]
        print('    # initializing rules.', end=' ')
        [self.rules.append(r) for r in Rule.get_rules_from_nums(new_rule_nums)]

        self.rule_nums.sort()
        self.rules_count = len(self.rule_nums)

        #self._rule_nums.sort()
        print("    # rules added ==> ", ' '.join(map(str, new_rule_nums)))
        print("    # new rules list ==> %s" %
              ' '.join(map(str, self.rule_nums)))
        print("    # new rules count ==> %d" % self.rules_count)
Beispiel #27
0
def update_admin():
    devices = [{'id': x,
                'state': device.get_state(),
                'state_label': device.get_state_label(),
                'is_actuator': isinstance(device, Actuator),
                'type': device.type
                } for x, device in device_ids.items()]
    builder_rules = []
    for device in device_ids.values():
        builder_rules.append(device.build_rule())
    from state import device_names
    for r in rules:
        r['status'] = Rule(r, enabled=r['enabled']).evaluate()
    for admin_id in app.admin_id:
        emit('update',
             {'devices': devices, 'builder_rules': builder_rules, 'rules': rules, 'device_names': device_names},
             room=admin_id)
Beispiel #28
0
def result():
    delete_target_dir('./static')
    os.mkdir('./static')

    # 清洗数据
    if not os.path.exists('./datas/1.xlsx'):
        data = {'code': 0, 'info': '未上传excel'}
        return jsonify(data)
    from clean_data import Duty

    duty = Duty()
    datas = duty.get_duty_datas()
    # pprint(datas)
    with open('./datas/results.json', 'w', encoding='utf-8') as f:
        f.write(json.dumps(datas, ensure_ascii=False))

    # 执行规则
    from rules import Rule
    Rule()

    # 返回api结果
    data = {'code': 1, 'info': 'http://192.168.10.129:5000/static/考勤结果.xlsx'}
    print('执行完毕')
    return jsonify(data)
Beispiel #29
0
 def __init__(self, response):
     self._response = self.convert_proxy_response(response)
     if not self._rule:
         self._rule = Rule.get_url_match(Url({'_id': self._response.url}))
Beispiel #30
0
            params['moves_amount'] = len(solution)
            end_time = time.time()
            delta = end_time - start_time
            print(str(solution))
            print('time complexity=', _open.time_complexity)
            print('size complexity=', params.get('size_complexity'))
            print(f'Moves: {params.get("moves_amount")}')
            print('seconds: ', delta)
            try:
                solution.to_file('res.json')
            except:
                pass
            exit()

        _close.append(min_state)
        neighbours = Rule.neighbours(min_state)

        for neighbour in neighbours:
            if neighbour in _close:
                continue

            g = min_state.g + Rule.distance(args.greedy)

            if neighbour not in _open:
                neighbour.parent = min_state
                neighbour.set_metrics(g=g, heuristic=heuristics.get_total_h)
                _open.put_nowait(neighbour)
            elif g <= neighbour.g:
                i = _open.queue.index(neighbour)
                neighbour = _open.queue[i]
                neighbour.parent = min_state
Beispiel #31
0
 class TestRules(Rules):
     id_field = Rule("Id", required=True)
Beispiel #32
0
    def set_ownvalue(self, name, value):
        from expression import Symbol
        from rules import Rule

        self.add_rule(name, Rule(Symbol(name), value))
Beispiel #33
0
def learn_one_rule(records, attributes, clss):
	"""
	Determine a rule that best covers the input.

	Returns the rule.

	Input:
		records - set of records that the rule should try to cover best;
		attributes - set of records' attributes;
		clss - the class the rule should precdict.
	"""

	def aux_nominal(name, value):
		"""
		Creates the condition for a nominal attribute.

		Returns a function from record to boolean representing the condition.

		Input:
			name - name of the attribute;
			value - value for the attribute.
		"""

		return lambda r: r[name] == value	# name's value is equal to value


	def aux_continuous(name, value):
		"""
		Creates the condition for a continuous attribute.

		Returns a function from record to boolean representing the condition.

		Input:
			name - name of the attribute;
			value - value for the attribute.
		"""

		return lambda r: r[name] < value	# name's value is less than value

	k = len( attribute_ocurrences(records, CLASS)[0] )	# number of classes
	rule = Rule(clss)	# the generated rule
	conditions = []	# all desired attribute value relations
	strings = []	# the textual representation each element in conditions

	for name, cont, values in attributes:	# each attribute
		if cont:	# continuous attribute
			values = attribute_ocurrences(records, name)[0]	
			# the different values assumed by this attribute in records
			values.sort()	# sort the values in ascending order
			values = [ (values[i - 1] + values[i]) / 2 for i in range(1, len(values)) ]
			# replace values with the average of each consecutive pair of elements

			for value in values:	# each average
				strings.append(name + ' < ' + str(value))
				# add the text of this name to strings
				conditions.append( aux_continuous(name, value) )
				# add a continuous condition

		else:
			for value in values:	# each value
				value = value[:]	# value is a copy of an attribute value
				strings.append(name + ' = ' + str(value))
				# add the text of this name to strings
				conditions.append( aux_nominal(name, value) )
				# add a nominal condition

	better = True	# adding the best condition improved rule
	covered = records	# the records covered by the current rule
	current = 0	# the laplace of rule's current form

	while better:
		best = None	# index of the best condition
		laplace = 0	# laplace if the best condition were to be added

		for i, condition in enumerate(conditions):	# each conjunct and its index
			matches = filter(condition, covered)
			# the covered records matched by this condition

			if matches != []:	# some records in covered matches condition
				correct = len( filter(lambda r: r[CLASS] == clss, matches) )
				# number of covered records correctly classified
				total = len(matches)	# number of covered records

				l = float(correct + 1) / (total + k) # laplace with this condition

				if l >= laplace:
					best = i	# update best
					laplace = l	# update laplace

		better = laplace > current # update better

		if better:	# a best condition was found and improves laplace
			rule.add_conjunct(conditions[best], strings[best])
			# add the best condition to rule
			c = conditions.pop(best) # remove the best condition
			strings.pop(best) # remove the best condition's string
			covered = filter(c, covered)	# covered keeps records that match c
			current = laplace	# update current

	return rule