def parse_task(domain_pddl, task_pddl):
domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, \
axioms, overalls = parse_domain_pddl(domain_pddl)
frees = dict()
frees = process_is_free_propositions(overalls, actions, predicates,
predicate_dict)
#add_overall_to_start_and_end(overalls, actions, predicates, predicate_dict)
can_be_compressed = analyze_compressible(actions)
actions = merge_actions(actions, can_be_compressed)
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_pddl(
task_pddl, type_dict, predicate_dict, frees)
assert domain_name == task_domain_name
requirements = pddl.Requirements(
sorted(
set(domain_requirements.requirements +
task_requirements.requirements)))
objects = constants + objects
check_for_duplicates(
[o.name for o in objects],
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects]
return pddl.Task(domain_name, task_name, requirements, types, objects,
predicates, functions, init, goal, actions, axioms,
use_metric)
def task_from_domain_problem(domain, problem):
# TODO: prune evaluation that aren't needed in actions
#domain_name, domain_requirements, types, type_dict, constants, \
# predicates, predicate_dict, functions, actions, axioms = domain
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric, problem_pddl = problem
assert domain.name == task_domain_name
requirements = pddl.Requirements(
sorted(
set(domain.requirements.requirements +
task_requirements.requirements)))
objects = domain.constants + objects
check_for_duplicates(
[o.name for o in objects],
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
init.extend(pddl.Atom(EQ, (obj.name, obj.name)) for obj in objects)
# TODO: optimistically evaluate (not (= ?o1 ?o2))
for fd_obj in objects:
obj = obj_from_pddl(fd_obj.name)
if obj.is_unique():
init.append(pddl.Atom(IDENTICAL, (fd_obj.name, fd_obj.name)))
else:
assert obj.is_shared()
task = pddl.Task(domain.name, task_name, requirements, domain.types,
objects, domain.predicates, domain.functions, init, goal,
domain.actions, domain.axioms, use_metric)
normalize.normalize(task)
# task.add_axiom
return task
def task_from_domain_problem(domain, problem, add_identical=True):
# TODO: prune evaluation that aren't needed in actions
#domain_name, domain_requirements, types, type_dict, constants, \
# predicates, predicate_dict, functions, actions, axioms = domain
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric, problem_pddl = problem
assert domain.name == task_domain_name
requirements = pddl.Requirements(
sorted(
set(domain.requirements.requirements +
task_requirements.requirements)))
objects = domain.constants + objects
check_for_duplicates(
[o.name for o in objects],
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
init.extend(pddl.Atom(EQ, (obj.name, obj.name)) for obj in objects)
if add_identical:
init.extend(get_identical_atoms(objects))
#print('{} objects and {} atoms'.format(len(objects), len(init)))
task = pddl.Task(domain.name, task_name, requirements, domain.types,
objects, domain.predicates, domain.functions, init, goal,
domain.actions, domain.axioms, use_metric)
normalize.normalize(task)
# task.add_axiom
return task
def parse_task(domain_pddl, task_pddl):
# if DEBUG:
# print("domain_pddl %s" % domain_pddl)
# print("task_pddl %s" % task_pddl)
domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict,\
functions, actions, axioms = parse_domain_pddl(domain_pddl)
task_name, task_domain_name, task_requirements, objects, init, num_init, goal, metric \
= parse_task_pddl(task_pddl, type_dict, predicate_dict)
# if DEBUG:
# print("Init= %s"% init)
if not domain_name == task_domain_name:
msg = "\nWarning: Domain name in domain file %s differs from domain name in task file %s" % (
domain_name, task_domain_name)
print(msg, file=sys.stderr)
#assert domain_name == task_domain_name
requirements = pddl.Requirements(
sorted(
set(domain_requirements.requirements +
task_requirements.requirements)))
objects = constants + objects
check_for_duplicates( # This will remove duplicates now instead of outright aborting.
objects,
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects]
# print("parsing_funtions parse_task returns num_init", num_init)
# for ini in num_init:
# ini.dump()
# print("parsing_funtions parse_task returns metric", metric)
return pddl.Task(domain_name, task_name, requirements, types, objects,
predicates, functions, init, num_init, goal, actions,
axioms, metric)
def parse_task(domain_pddl, task_pddl):
domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, axioms \
= parse_domain_pddl(domain_pddl)
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_pddl(task_pddl, type_dict, predicate_dict)
assert domain_name == task_domain_name
requirements = pddl.Requirements(sorted(set(
domain_requirements.requirements +
task_requirements.requirements)))
objects = constants + objects
check_for_duplicates(
[o.name for o in objects],
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
# init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects]
return pddl.Task(
domain_name, task_name, requirements, types, objects,
predicates, functions, init, goal, actions, axioms, use_metric)
def task_from_domain_problem(domain, problem):
# TODO: prune eval
domain_name, domain_requirements, types, type_dict, constants, \
predicates, predicate_dict, functions, actions, axioms = domain
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = problem
assert domain_name == task_domain_name
requirements = pddl.Requirements(sorted(set(domain_requirements.requirements +
task_requirements.requirements)))
objects = constants + objects
check_for_duplicates([o.name for o in objects],
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
init.extend(pddl.Atom(EQ, (obj.name, obj.name)) for obj in objects)
task = pddl.Task(domain_name, task_name, requirements, types, objects,
predicates, functions, init, goal, actions, axioms, use_metric)
normalize.normalize(task)
return task
def parse_task(domain_pddl, task_pddl, parser):
if not parser:
domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, axioms \
= parse_domain_pddl(domain_pddl)
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_pddl(
task_pddl, type_dict, predicate_dict)
else:
# set files
parser.set_files(domain_pddl, task_pddl)
domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, axioms \
= parse_domain_custom(parser)
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_custom(
parser, type_dict, predicate_dict)
# remove actions
parser.remove_actions()
# update domain
parser.update_domain()
assert domain_name == task_domain_name
requirements = pddl.Requirements(
sorted(
set(domain_requirements.requirements +
task_requirements.requirements)))
objects = constants + objects
check_for_duplicates(
[o.name for o in objects],
errmsg="error: duplicate object %r",
finalmsg="please check :constants and :objects definitions")
init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects]
return pddl.Task(domain_name, task_name, requirements, types, objects,
predicates, functions, init, goal, actions, axioms,
use_metric)
# static_predicates, reflexive_static_predicates = get_static_predicates(traces, predicates)
### LEARNING PROBLEM
# The objects of the original domain for the learning task
# is the union of all objects in the input traces
objects = list()
for trace in traces:
objects.extend(trace.objects)
objects = list(set(objects))
# Empty initial state for now
init = []
# Empty goal for now
goal = []
original_task = pddl.Task(domain_name, 'learning_problem', domain_requirements, types, objects,
predicates, functions, init, goal, actions, axioms, True)
learning_task = copy.deepcopy(original_task)
learning_task.actions = []
### LEARNING DOMAIN
# Define "modeProg" predicate
learning_task.predicates.append(pddl.predicates.Predicate("modeProg", []))
# Define "test" predicates
for i in range(1, TOTAL_STEPS+2):
learning_task.predicates.append(pddl.predicates.Predicate("test" + str(i), []))
# Define "step" domain type
learning_task.types.append(pddl.pddl_types.Type("step", "None"))
