def plan_streams(evaluations, goal_expression, domain, all_results, negative, effort_weight, max_effort,
simultaneous=False, reachieve=True, replan_actions=set(), **kwargs):
# TODO: alternatively could translate with stream actions on real opt_state and just discard them
# TODO: only consider axioms that have stream conditions?
#reachieve = reachieve and not using_optimizers(all_results)
#for i, result in enumerate(all_results):
# print(i, result, result.get_effort())
applied_results, deferred_results = partition_results(
evaluations, all_results, apply_now=lambda r: not (simultaneous or r.external.info.simultaneous))
stream_domain, deferred_from_name = add_stream_actions(domain, deferred_results)
if reachieve and not using_optimizers(all_results):
achieved_results = {n.result for n in evaluations.values() if isinstance(n.result, Result)}
init_evaluations = {e for e, n in evaluations.items() if n.result not in achieved_results}
applied_results = achieved_results | set(applied_results)
evaluations = init_evaluations # For clarity
# TODO: could iteratively increase max_effort
node_from_atom = get_achieving_streams(evaluations, applied_results, # TODO: apply to all_results?
max_effort=max_effort)
opt_evaluations = {evaluation_from_fact(f): n.result for f, n in node_from_atom.items()}
if UNIVERSAL_TO_CONDITIONAL or using_optimizers(all_results):
goal_expression = add_unsatisfiable_to_goal(stream_domain, goal_expression)
temporal = isinstance(stream_domain, SimplifiedDomain)
optimistic_fn = solve_optimistic_temporal if temporal else solve_optimistic_sequential
instantiated, action_instances, temporal_plan, cost = optimistic_fn(
domain, stream_domain, applied_results, all_results, opt_evaluations,
node_from_atom, goal_expression, effort_weight, **kwargs)
if action_instances is None:
return FAILED, FAILED, cost
action_instances, axiom_plans = recover_axioms_plans(instantiated, action_instances)
# TODO: extract out the minimum set of conditional effects that are actually required
#simplify_conditional_effects(instantiated.task, action_instances)
stream_plan, action_instances = recover_simultaneous(
applied_results, negative, deferred_from_name, action_instances)
action_plan = transform_plan_args(map(pddl_from_instance, action_instances), obj_from_pddl)
replan_step = min([step+1 for step, action in enumerate(action_plan)
if action.name in replan_actions] or [len(action_plan)+1]) # step after action application
stream_plan, opt_plan = recover_stream_plan(evaluations, stream_plan, opt_evaluations, goal_expression, stream_domain,
node_from_atom, action_instances, axiom_plans, negative, replan_step)
if temporal_plan is not None:
# TODO: handle deferred streams
assert all(isinstance(action, Action) for action in opt_plan.action_plan)
opt_plan.action_plan[:] = temporal_plan
return stream_plan, opt_plan, cost
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