def is_solution(domain, evaluations, action_plan, goal_expression):
task = task_from_domain_problem(
domain,
get_problem(evaluations, goal_expression, domain, unit_costs=True))
action_instances = get_action_instances(
task, action_plan) + [get_goal_instance(task.goal)]
#original_init = task.init
task.init = set(task.init)
for instance in action_instances:
axiom_plan = extract_axiom_plan(task,
instance,
negative_from_name={},
static_state=task.init)
if axiom_plan is None:
return False
#substitute_derived(axiom_plan, instance)
#if not is_applicable(task.init, instance):
# return False
apply_action(task.init, instance)
return True
def get_combined_orders(evaluations, stream_plan, action_plan, domain):
if not is_plan(action_plan):
return action_plan
# TODO: could just do this within relaxed
# TODO: do I want to strip the fluents and just do the partial ordering?
stream_instances = get_stream_instances(stream_plan)
negative_results = filter(
lambda r: isinstance(r, PredicateResult) and (r.value == False),
stream_plan)
negative_init = set(
fd_from_evaluation(evaluation_from_fact(f)) for r in negative_results
for f in r.get_certified())
#negated_from_name = {r.instance.external.name for r in negative_results}
opt_evaluations = evaluations_from_stream_plan(evaluations, stream_plan)
goal_expression = And()
task = task_from_domain_problem(
domain,
get_problem(opt_evaluations, goal_expression, domain, unit_costs=True))
action_instances = get_action_instances(task, action_plan)
replace_derived(task, negative_init, action_instances)
#combined_instances = stream_instances + action_instances
orders = set()
for i, a1 in enumerate(action_plan):
for a2 in action_plan[i + 1:]:
orders.add((a1, a2))
# TODO: just store first achiever here
for i, instance1 in enumerate(stream_instances):
for j in range(i + 1, len(stream_instances)):
effects = {e for _, e in instance1.add_effects}
if effects & set(stream_instances[j].precondition):
orders.add((stream_plan[i], stream_plan[j]))
for i, instance1 in enumerate(stream_instances):
for j, instance2 in enumerate(action_instances):
effects = {e for _, e in instance1.add_effects} | \
{e.negate() for _, e in instance1.del_effects}
if effects & set(instance2.precondition):
orders.add((stream_plan[i], action_plan[j]))
return orders
def apply_actions(domain, state, plan, unit_costs=False):
# Goal serialization just assumes the tail of the plan includes an abstract action to achieve each condition
static_state, _ = partition_facts(domain, state)
print('Static:', static_state)
# TODO: might need properties that involve an object that aren't useful yet
evaluations = evaluations_from_init(state)
#goal_exp = obj_from_value_expression(goal)
goal_exp = None
problem = get_problem(evaluations, goal_exp, domain, unit_costs)
task = task_from_domain_problem(domain, problem)
task.init = set(task.init)
for instance in get_action_instances(
task, transform_plan_args(plan, Object.from_value)):
apply_action(task.init, instance)
fluents = get_fluents(domain)
fluent_state = [
value_from_evaluation(evaluation_from_fd(atom)) for atom in task.init
if isinstance(atom, pddl.Atom) and atom.predicate in fluents
]
print('Fluent:', fluent_state)
state = static_state + fluent_state
return state
def recover_opt_stream_plan(evaluations, action_plan, task):
plan_instances = get_action_instances(task, action_plan) + [get_goal_instance(task.goal)]
replace_derived(task, set(), plan_instances)
preimage = filter(lambda a: not a.negated, plan_preimage(plan_instances, []))
opt_stream_plan = []
opt_from_obj = {}
for stream_result in extract_order(evaluations, preimage):
input_objects = tuple(opt_from_obj.get(o, o) for o in stream_result.instance.input_objects)
instance = stream_result.instance.external.get_instance(input_objects)
#instance.opt_index = stream_result.instance.opt_index
#assert(instance.opt_index == 0)
instance.opt_index = 0
#assert(not instance.disabled)
instance.disabled = False
opt_results = instance.next_optimistic()
if not opt_results:
continue
opt_result = opt_results[0]
opt_stream_plan.append(opt_result)
for obj, opt in zip(stream_result.output_objects, opt_result.output_objects):
opt_from_obj[obj] = opt
return opt_stream_plan, opt_from_obj