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
