def parse_problem(problem, stream_info={}, constraints=None, unit_costs=False, unit_efforts=False):
# TODO: just return the problem if already written programmatically
#reset_globals() # Prevents use of satisfaction.py
domain_pddl, constant_map, stream_pddl, stream_map, init, goal = problem
domain = parse_domain(domain_pddl)
#domain = domain_pddl
if not isinstance(domain, Domain):
#assert isinstance(domain, str) # raw PDDL is returned
obj_from_constant = {name: Object(value, name=name)
for name, value in constant_map.items()}
streams = parse_stream_pddl(stream_pddl, stream_map, stream_info=stream_info,
unit_costs=unit_costs, unit_efforts=unit_efforts)
evaluations = evaluations_from_init(init)
goal_exp = obj_from_value_expression(goal)
return evaluations, goal_exp, domain, streams
if len(domain.types) != 1:
raise NotImplementedError('Types are not currently supported')
if unit_costs:
set_unit_costs(domain)
obj_from_constant = parse_constants(domain, constant_map)
streams = parse_stream_pddl(stream_pddl, stream_map, stream_info=stream_info,
unit_costs=unit_costs, unit_efforts=unit_efforts)
check_problem(domain, streams, obj_from_constant)
evaluations = evaluations_from_init(init)
goal_exp = obj_from_value_expression(goal)
#normalize_domain_goal(domain, goal_expression)
goal_exp = add_plan_constraints(constraints, domain, evaluations, goal_exp)
parse_goal(goal_exp, domain) # Just to check that it parses
# TODO: refactor the following?
compile_to_exogenous(evaluations, domain, streams)
enforce_simultaneous(domain, streams)
compile_fluent_streams(domain, streams)
return evaluations, goal_exp, domain, streams
def parse_problem(problem, stream_info={}):
# TODO: just return the problem if already written programmatically
domain_pddl, constant_map, stream_pddl, stream_map, init, goal = problem
domain = parse_domain(domain_pddl)
if len(domain.types) != 1:
raise NotImplementedError('Types are not currently supported')
obj_from_constant = parse_constants(domain, constant_map)
streams = parse_stream_pddl(stream_pddl, stream_map, stream_info)
evaluations = OrderedDict(
(evaluation_from_fact(obj_from_value_expression(f)),
INITIAL_EVALUATION) for f in init)
goal_expression = obj_from_value_expression(goal)
check_problem(domain, streams, obj_from_constant)
parse_goal(goal_expression, domain) # Just to check that it parses
#normalize_domain_goal(domain, goal_expression)
# TODO: refactor the following?
compile_to_exogenous(evaluations, domain, streams)
compile_fluent_streams(domain, streams)
enforce_simultaneous(domain, streams)
return evaluations, goal_expression, domain, streams
def parse_problem(problem, stream_info={}):
domain_pddl, constant_map, stream_pddl, stream_map, init, goal = problem
domain = parse_domain(domain_pddl)
if len(domain.types) != 1:
raise NotImplementedError('Types are not currently supported')
parse_constants(domain, constant_map)
stream_name, streams = parse_stream_pddl(stream_pddl, stream_map,
stream_info)
#evaluations = set(evaluations_from_init(init))
evaluations = OrderedDict((e, None) for e in evaluations_from_init(init))
goal_expression = obj_from_value_expression(goal)
return evaluations, goal_expression, domain, stream_name, streams
def parse_problem(problem,
stream_info={},
constraints=None,
unit_costs=False,
unit_efforts=False):
# TODO: just return the problem if already written programmatically
#reset_globals() # Prevents use of satisfaction.py
domain_pddl, constant_map, stream_pddl, stream_map, init, goal = problem
domain = parse_domain(domain_pddl) # TODO: normalize here
#domain = domain_pddl
if len(domain.types) != 1:
raise NotImplementedError('Types are not currently supported')
if unit_costs:
set_unit_costs(domain)
if not has_costs(domain):
# TODO: set effort_weight to 1 if no costs
print(
'Warning! All actions have no cost. Recommend setting unit_costs=True'
)
obj_from_constant = parse_constants(
domain, constant_map) # Keep before parse_stream_pddl
streams = parse_stream_pddl(stream_pddl,
stream_map,
stream_info=stream_info,
unit_costs=unit_costs,
unit_efforts=unit_efforts)
check_problem(domain, streams, obj_from_constant)
evaluations = evaluations_from_init(init)
goal_exp = obj_from_value_expression(goal)
if isinstance(domain, SimplifiedDomain):
#assert isinstance(domain, str) # raw PDDL is returned
_ = {
name: Object(value, name=name)
for name, value in constant_map.items()
}
return evaluations, goal_exp, domain, streams
goal_exp = add_plan_constraints(constraints, domain, evaluations, goal_exp)
parse_goal(goal_exp, domain) # Just to check that it parses
normalize_domain_goal(domain,
goal_exp) # TODO: does not normalize goal_exp
compile_to_exogenous(evaluations, domain, streams)
return evaluations, goal_exp, domain, streams
def parse_problem(problem, stream_info={}, constraints=None, unit_costs=False, unit_efforts=False):
# TODO: just return the problem if already written programmatically
domain_pddl, constant_map, stream_pddl, stream_map, init, goal = problem
domain = parse_domain(domain_pddl)
if len(domain.types) != 1:
raise NotImplementedError('Types are not currently supported')
set_unit_costs(domain, unit_costs)
obj_from_constant = parse_constants(domain, constant_map)
streams = parse_stream_pddl(stream_pddl, stream_map, stream_info=stream_info, unit_efforts=unit_efforts)
check_problem(domain, streams, obj_from_constant)
evaluations = evaluations_from_init(init)
goal_exp = obj_from_value_expression(goal)
#normalize_domain_goal(domain, goal_expression)
goal_exp = add_plan_constraints(constraints, domain, evaluations, goal_exp)
parse_goal(goal_exp, domain) # Just to check that it parses
# TODO: refactor the following?
compile_to_exogenous(evaluations, domain, streams)
compile_fluent_streams(domain, streams)
enforce_simultaneous(domain, streams)
return evaluations, goal_exp, domain, streams
def evaluations_from_init(init):
evaluations = OrderedDict()
for raw_fact in init:
fact = obj_from_value_expression(raw_fact)
add_fact(evaluations, fact, result=INIT_EVALUATION, complexity=0)
return evaluations