def assert_called_with(expression, *args):
called_with = []
def evaluator(symbols):
called_with.append(symbols)
for symbol in symbols:
if symbol == 'False':
return False
return True
interpret(expression, evaluator=evaluator)
assert called_with == list(args)
def assert_symbol_map(exp, *args):
for case in args:
symbol_map = sym_gen(case[0])
def evaluator(symbols):
for symbol in symbols:
if not symbol_map.get(symbol):
return False
return True
assert compare_lists(
interpret(exp, evaluator=evaluator),
case[1],
)
def bac_map(expression, symbol_map):
return lambda : interpret(
expression,
symbol_map=symbol_map,
)
def bac_eval(expression, evaluator):
return lambda : interpret(
expression,
evaluator=evaluator,
)
expression_a = '[["tomato", "lemon", "hotdog_bun", "hotdog"]]'
# We need a tomato, and a lemon OR lime OR nothing.
expression_b = '[["tomato", ["lemon", "lime", "null"]]]'
# We need 2 tomatos AND 1 lemon AND ((1 hotdog_bun AND 1 hotdog) OR (1 hamburger_bun AND 1 hamburger))
expression_c = '[["tomato", "tomato", "lime", [[["hotdog_bun", "hotdog"]], [["hamburger_bun", "hamburger"]]]]]'
# If harry_peters is open, try to get 1 tomato AND 1 lemon AND 1 lime AND 1 hotdog_bun and 1 hotdog
# OR go to food_leopard and get 1 tomato AND 1 lime AND 1 hamburger_bun AND 1 hamburger
expression_d = '[ [["harry_peters", "tomato", "lemon", "lime", "hotdog_bun", "hotdog"]], [["food_leopard", "tomato", "lime", "hamburger_bun", "hamburger"]] ]'
# Solutions to our constraints given static data
result_a = interpret(
expression_a,
symbol_map=get_food_leopard_data(),
)
print(result_a)
result_b = interpret(
expression_b,
symbol_map=get_harry_peters_data(),
)
print(result_b)
result_c = interpret(
expression_c,
symbol_map=get_harry_peters_data(),
)
print(result_c)
def assert_evaluator(exp, *args):
for case in args:
assert compare_lists(
interpret(exp, symbol_map=sym_gen(case[0])),
case[1],
)
def test_example():
result = interpret(groceries, evaluator=evaluator)
print(result)