def p_json(p): """json : dict | list | empty """ trace('p_json: {}', p[1]) p[0] = p[1]
def _iteration(self) -> str: """Iterates over all n-tuples (n > 1) of known facts and all rules. Tries to apply rules to tuples of facts. If two or more rules are able to be applied this function chooses the most powerful. :raises ValueError: in case of impossibility of reaching any target. """ for target in self._targets: if target in self._memory: return 'Target "{}" reached'.format(target) def apply_rule(rule_to_apply: Rule) -> None: """Helper function - for code compression. """ nonlocal self self._used_rules.add(rule_to_apply.number) self._memory.add(rule_to_apply.production) print('Rule {} used. Got: {}\n'.format(rule_to_apply.number, rule_to_apply.production)) trace('Memory dump: {}', list(self._memory)) # ------ End of helper function ---------------------------------------------------------- matched_rules = [] for count in range(2, self._rules_handler.max_tuple + 1): for tpl in combinations(self._memory, r=count): for rule in self._rules_handler.rules: match_conditions = any([ rule.conditions == list(perm) for perm in permutations(tpl) ]) rule_not_used = rule.number not in self._used_rules if match_conditions and rule_not_used: matched_rules.append(rule) if len(matched_rules) == 1: apply_rule(matched_rules[0]) elif len(matched_rules) > 1: matched_rules.sort(key=lambda item: item.power, reverse=True) print('Collision of {} rules'.format( [rule.number for rule in matched_rules])) apply_rule(matched_rules[0]) else: trace('Memory dump: {}'.format(list(self._memory))) raise ValueError("No production found") return self._iteration()
def apply_rule(rule_to_apply: Rule) -> None: """Helper function - for code compression. """ nonlocal self self._used_rules.add(rule_to_apply.number) self._memory.add(rule_to_apply.production) print('Rule {} used. Got: {}\n'.format(rule_to_apply.number, rule_to_apply.production)) trace('Memory dump: {}', list(self._memory))
def p_list_empty(p): """list : '[' ']' """ trace('p_list_empty') p[0] = []
def p_list_values(p): """list : '[' values ']' """ trace('p_list_values: transform_to_list({})', p[2]) p[0] = transform_to_list(p[2])
def p_dict_empty(p): """dict : '{' '}' """ trace('p_dict_empty') p[0] = {}
def p_dict_pairs(p): """dict : '{' pairs '}' """ trace('p_dict_pairs: transform_to_dict({})', p[2]) p[0] = transform_to_dict(p[2])
def p_pair(p): """pair : key ':' value """ trace('p_pair: ({}, {})', p[1], p[3]) p[0] = (p[1], p[3])
def p_value_id(p): """value : ID """ trace('p_value_id: {}', p[1]) p[0] = p[1]
def p_value_num(p): """value : NUMBER """ trace('p_value_num: {}', p[1]) p[0] = transform_to_number(p[1])
def p_value_str(p): """value : STRING """ trace('p_value_str: {}', p[1]) p[0] = remove_surrounding_quotes(p[1])
def p_value_cont(p): """value : dict | list """ trace('p_value_cont: {}', p[1]) p[0] = p[1]
def p_values_sg(p): """values : value """ trace('p_values_sg: ({}, None)', p[1]) p[0] = (p[1], None)
def p_values_pl(p): """values : value ',' values """ trace('p_values_pl: ({}, {})', p[1], p[3]) p[0] = (p[1], p[3])
def p_key_id(p): """key : ID """ trace('p_key_id: {}', p[1]) p[0] = p[1]
def p_pairs_pl(p): """pairs : pair ',' pairs """ trace('p_pairs_pl: ({}, {})', p[1], p[3]) p[0] = (p[1], p[3])
def p_pairs_sg(p): """pairs : pair """ trace('p_pairs_sg: ({}, None)', p[1]) p[0] = (p[1], None)
def p_value_bool(p): """value : TRUE | FALSE """ trace('p_value_bool') p[0] = transform_to_bool(p[1])
def p_key_str(p): """key : STRING """ trace('p_key_str: {}', p[1]) p[0] = remove_surrounding_quotes(p[1])
def p_empty(p): """empty : """ trace('p_empty') p[0] = None