def parse_task(task_pddl):
iterator = iter(task_pddl)
assert iterator.next() == "define"
problem_line = iterator.next()
assert problem_line[0] == "problem" and len(problem_line) == 2
yield problem_line[1]
domain_line = iterator.next()
assert domain_line[0] == ":domain" and len(domain_line) == 2
yield domain_line[1]
objects_opt = iterator.next()
if objects_opt[0] == ":objects":
yield pddl_types.parse_typed_list(objects_opt[1:])
init = iterator.next()
else:
yield []
init = objects_opt
assert init[0] == ":init"
initial = []
for fact in init[1:]:
if fact[0] == "=":
if conditions.is_function_comparison(fact): # numeric function
initial.append(f_expression.parse_assignment(fact))
else: # object function
function = conditions.parse_term(fact[1])
terms = function.args
terms.append(conditions.parse_term(fact[2]))
atomname = conditions.function_predicate_name(function.name)
initial.append(conditions.Atom(atomname, terms))
else:
initial.append(
conditions.Atom(
fact[0],
[conditions.parse_term(term) for term in fact[1:]]))
yield initial
goal = iterator.next()
assert goal[0] == ":goal" and len(goal) == 2
yield conditions.parse_condition(goal[1])
metric_defined = False
for entry in iterator:
if entry[0] == ":metric":
metric_defined = True
# if entry[2][0] in ["total-time", "total-cost"] :
metric = (entry[1], entry[2])
yield metric
if not metric_defined:
metric = ()
yield metric
def instantiate(self, var_mapping, init_facts, fluent_facts,
fluent_functions, init_function_vals, task,
new_constant_axioms):
# The comments for Action.instantiate apply accordingly.
arg_list = [
var_mapping[conditions.Variable(par.name)].name
for par in self.parameters
]
name = "(%s %s)" % (self.name, " ".join(arg_list))
condition = []
try:
self.condition.instantiate(var_mapping, init_facts, fluent_facts,
init_function_vals, fluent_functions,
task, new_constant_axioms, condition)
except conditions.Impossible:
return None
effect_args = [
var_mapping.get(conditions.Variable(arg.name),
conditions.Variable(arg.name))
for arg in self.parameters
]
effect = conditions.Atom(self.name, effect_args)
return PropositionalAxiom(name, condition, effect)
def parse_task(task_pddl):
iterator = iter(task_pddl)
assert iterator.next() == "define"
problem_line = iterator.next()
assert problem_line[0] == "problem" and len(problem_line) == 2
yield problem_line[1]
domain_line = iterator.next()
assert domain_line[0] == ":domain" and len(domain_line) == 2
yield domain_line[1]
objects_opt = iterator.next()
if objects_opt[0] == ":objects":
yield pddl_types.parse_typed_list(objects_opt[1:])
init = iterator.next()
else:
yield []
init = objects_opt
assert init[0] == ":init"
initial = []
for fact in init[1:]:
if fact[0] == "=":
try:
initial.append(f_expression.parse_assignment(fact))
except ValueError, e:
raise SystemExit("Error in initial state specification\n" +
"Reason: %s." % e)
else:
initial.append(conditions.Atom(fact[0], fact[1:]))
def parse(domain_pddl, task_pddl):
domain_name, requirements, types, constants, predicates, functions, actions, axioms \
= parse_domain(domain_pddl)
task_name, task_domain_name, objects, init, goal, use_metric = parse_task(task_pddl)
assert domain_name == task_domain_name
objects = constants + objects
init += [conditions.Atom("=", (obj.name, obj.name)) for obj in objects]
return Task(domain_name, task_name, requirements, types, objects,
predicates, functions, init, goal, actions, axioms, use_metric)
def parse(domain_pddl, task_pddl):
domain_name, requirements, constants, predicates, types, functions, actions, durative_actions, axioms \
= parse_domain(domain_pddl)
task_name, task_domain_name, objects, init, goal, metric = parse_task(task_pddl)
assert domain_name == task_domain_name
objects = constants + objects
init += [conditions.Atom("=", (conditions.parse_term(obj.name), conditions.parse_term(obj.name)))
for obj in objects]
return Task(domain_name, task_name, requirements, types, objects,
predicates, init, goal, metric, actions, durative_actions, axioms, Task.FUNCTION_SYMBOLS)
def parse(domain_pddl, task_pddl):
domain_name, requirements, oplinit, constants, predicates, types, functions, actions, durative_actions, axioms, modules, subplan_generators \
= parse_domain(domain_pddl)
task_name, task_domain_name, module_inits, module_exits, objects, init, goal = parse_task(
task_pddl)
assert domain_name == task_domain_name
objects = constants + objects
init += [
conditions.Atom("=", (conditions.parse_term(
obj.name), conditions.parse_term(obj.name))) for obj in objects
]
return Task(domain_name, task_name, requirements, oplinit, types,
objects, modules, predicates, init, goal, actions,
durative_actions, axioms, Task.FUNCTION_SYMBOLS,
subplan_generators, module_inits, module_exits)
def parse_task(task_pddl):
iterator = iter(task_pddl)
assert iterator.next() == "define"
problem_line = iterator.next()
assert problem_line[0] == "problem" and len(problem_line) == 2
yield problem_line[1]
domain_line = iterator.next()
assert domain_line[0] == ":domain" and len(domain_line) == 2
yield domain_line[1]
objects_opt = iterator.next()
if objects_opt[0] == ":objects":
yield pddl_types.parse_typed_list(objects_opt[1:])
init = iterator.next()
else:
yield []
init = objects_opt
assert init[0] == ":init"
initial = []
for fact in init[1:]:
if fact[0] == "=":
initial.append(f_expression.parse_assignment(fact))
else:
initial.append(conditions.Atom(fact[0], fact[1:]))
yield initial
goal = iterator.next()
assert goal[0] == ":goal" and len(goal) == 2
yield conditions.parse_condition(goal[1])
use_metric = False
for entry in iterator:
if entry[0] == ":metric":
if entry[1]=="minimize" and entry[2][0] == "total-cost":
use_metric = True
else:
assert False, "Unknown metric."
yield use_metric
for entry in iterator:
assert False, entry
def instantiate(self, var_mapping, init_facts, fluent_facts):
# The comments for Action.instantiate apply accordingly.
arg_list = [self.name] + [
var_mapping[par.name]
for par in self.parameters[:self.num_external_parameters]
]
name = "(%s)" % " ".join(arg_list)
condition = []
try:
self.condition.instantiate(var_mapping, init_facts, fluent_facts,
condition)
except conditions.Impossible:
return None
effect_args = [
var_mapping.get(arg.name, arg.name)
for arg in self.parameters[:self.num_external_parameters]
]
effect = conditions.Atom(self.name, effect_args)
return PropositionalAxiom(name, condition, effect)
def parse(domain_pddl, task_pddl):
domain_name, domain_requirements, types, constants, predicates, functions, actions, axioms \
= parse_domain(domain_pddl)
task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task(
task_pddl)
assert domain_name == task_domain_name
requirements = 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 += [conditions.Atom("=", (obj.name, obj.name)) for obj in objects]
return Task(domain_name, task_name, requirements, types, objects,
predicates, functions, init, goal, actions, axioms,
use_metric)
def normalize(self, time, results):
used_variables = list(self.head.free_variables()
| self.value.free_variables())
typed1, conjunction_parts1, term1 = self.head.compile_objectfunctions_aux(
used_variables)
typed2, conjunction_parts2, term2 = self.value.compile_objectfunctions_aux(
used_variables)
assert isinstance(term1, conditions.Variable)
add_params = set(
[typed
for typed in typed1 if not typed.name == term1.name] + typed2)
del_params = set(typed1 + typed2)
add_conjunction_parts = conjunction_parts1[1:] + conjunction_parts2
del_conjunction_parts = conjunction_parts1 + conjunction_parts2
del_conjunction_parts = conjunction_parts1[1:] + conjunction_parts2
# conjunctive_parts1[0] is left out because we do not need the condition
# that the atom in the del effect hast been true before
# These conjunction parts are sufficient under the add-after-delete semantics.
# Under the consistent effect semantics we need a further condition
# that prevents deleting the added predicate.
del_param = conjunction_parts1[0].args[-1]
del_conjunction_parts.append(
conditions.NegatedAtom("=", [del_param, term2]))
del_effect = ConjunctiveEffect([
conjunction_parts1[0].negate(),
])
atom_name = conjunction_parts1[0].predicate
atom_parts = list(conjunction_parts1[0].args)
atom_parts[-1] = term2
add_effect = ConjunctiveEffect([
conditions.Atom(atom_name, atom_parts),
], time)
add_conjunction = conditions.Conjunction(add_conjunction_parts)
del_conjunction = conditions.Conjunction(del_conjunction_parts)
if time == "start":
del_condition = [
del_conjunction,
conditions.Truth(),
conditions.Truth()
]
add_condition = [
add_conjunction,
conditions.Truth(),
conditions.Truth()
]
elif time == "end":
add_condition = [
conditions.Truth(),
conditions.Truth(), add_conjunction
]
del_condition = [
conditions.Truth(),
conditions.Truth(), del_conjunction
]
else:
add_condition = add_conjunction
del_condition = del_conjunction
if len(add_conjunction_parts) > 0:
add_effect = ConditionalEffect(add_condition, add_effect, time)
del_effect = ConditionalEffect(del_condition, del_effect)
if len(add_params) > 0:
add_effect = UniversalEffect(add_params, add_effect, time)
del_effect = UniversalEffect(del_params, del_effect, time)
results.append(add_effect)
results.append(del_effect)
# value "undefined" must be treated specially because it has not the type
# required in del_params
if term2.name != "undefined":
del_undef_params = set([
typed for typed in del_params
if not typed.name == del_param.name
])
atom_parts = list(conjunction_parts1[0].args)
atom_parts[-1] = conditions.ObjectTerm("undefined")
del_undef_effect = ConjunctiveEffect([
conditions.NegatedAtom(atom_name, atom_parts),
], time)
del_undef_conjunction_parts = del_conjunction_parts[:-1]
del_undef_conjunction = conditions.Conjunction(
del_undef_conjunction_parts)
if time == "start":
del_undef_condition = [
del_undef_conjunction,
conditions.Truth(),
conditions.Truth()
]
elif time == "end":
del_undef_condition = [
conditions.Truth(),
conditions.Truth(), del_undef_conjunction
]
else:
del_undef_condition = del_undef_conjunction
if len(del_undef_conjunction_parts) > 0:
del_undef_effect = ConditionalEffect(del_undef_condition,
del_undef_effect, time)
if len(del_undef_params) > 0:
del_undef_effect = UniversalEffect(del_undef_params,
del_undef_effect, time)
results.append(del_undef_effect)
def to_untyped_strips(self):
return conditions.Atom(self.type, [self.name])
def parse_task(task_pddl):
iterator = iter(task_pddl)
assert iterator.next() == "define"
problem_line = iterator.next()
assert problem_line[0] == "problem" and len(problem_line) == 2
yield problem_line[1]
domain_line = iterator.next()
assert domain_line[0] == ":domain" and len(domain_line) == 2
yield domain_line[1]
module_opt = iterator.next()
if module_opt[0] == ":moduleoptions":
yield [modules.ModuleInit.parse(mi) for mi in module_opt[1:]]
module_exit_opt = iterator.next()
else:
yield []
module_exit_opt = module_opt
if module_exit_opt[0] == ":moduleexitoptions":
yield [modules.ModuleExit.parse(mi) for mi in module_exit_opt[1:]]
objects_opt = iterator.next()
else:
yield []
objects_opt = module_exit_opt
if objects_opt[0] == ":objects":
yield pddl_types.parse_typed_list(objects_opt[1:])
init = iterator.next()
else:
yield []
init = objects_opt
assert init[0] == ":init"
initial = []
for fact in init[1:]:
if fact[0] == "=":
if conditions.is_function_comparison(fact): # numeric function
initial.append(f_expression.parse_assignment(fact))
else: # object function
function = conditions.parse_term(fact[1])
terms = function.args
terms.append(conditions.parse_term(fact[2]))
atomname = conditions.function_predicate_name(function.name)
initial.append(conditions.Atom(atomname, terms))
else:
initial.append(
conditions.Atom(
fact[0],
[conditions.parse_term(term) for term in fact[1:]]))
yield initial
goal = iterator.next()
assert goal[0] == ":goal" and len(goal) == 2
yield conditions.parse_condition(goal[1])
for entry in iterator:
if entry[0] == ":metric" and entry[1] == "minimize":
if entry[2][0] in ["total-time", "total-cost"]:
continue
assert False, "Can only minimize total-time or total-cost, got: " + str(
entry)
def parse_task(task_pddl):
iterator = iter(task_pddl)
define_tag = next(iterator)
assert define_tag == "define"
problem_line = next(iterator)
assert problem_line[0] == "problem" and len(problem_line) == 2
yield problem_line[1]
domain_line = next(iterator)
assert domain_line[0] == ":domain" and len(domain_line) == 2
yield domain_line[1]
requirements_opt = next(iterator)
if requirements_opt[0] == ":requirements":
requirements = requirements_opt[1:]
objects_opt = next(iterator)
else:
requirements = []
objects_opt = requirements_opt
yield Requirements(requirements)
if objects_opt[0] == ":objects":
yield pddl_types.parse_typed_list(objects_opt[1:])
init = next(iterator)
else:
yield []
init = objects_opt
assert init[0] == ":init"
initial = []
initial_true = set()
initial_false = set()
initial_assignments = dict()
for fact in init[1:]:
if fact[0] == "=":
try:
assignment = f_expression.parse_assignment(fact)
except ValueError as e:
raise SystemExit("Error in initial state specification\n" +
"Reason: %s." % e)
if not isinstance(assignment.expression,
f_expression.NumericConstant):
raise SystemExit("Illegal assignment in initial state " +
"specification:\n%s" % assignment)
if assignment.fluent in initial_assignments:
prev = initial_assignments[assignment.fluent]
if assignment.expression == prev.expression:
print("Warning: %s is specified twice" % assignment,
"in initial state specification")
else:
raise SystemExit("Error in initial state specification\n" +
"Reason: conflicting assignment for " +
"%s." % assignment.fluent)
else:
initial_assignments[assignment.fluent] = assignment
initial.append(assignment)
elif fact[0] == "not":
atom = conditions.Atom(fact[1][0], fact[1][1:])
check_atom_consistency(atom, initial_false, initial_true, False)
initial_false.add(atom)
else:
atom = conditions.Atom(fact[0], fact[1:])
check_atom_consistency(atom, initial_true, initial_false)
initial_true.add(atom)
initial.extend(initial_true)
yield initial
goal = next(iterator)
assert goal[0] == ":goal" and len(goal) == 2
yield conditions.parse_condition(goal[1])
use_metric = False
for entry in iterator:
if entry[0] == ":metric":
if entry[1] == "minimize" and entry[2][0] == "total-cost":
use_metric = True
else:
assert False, "Unknown metric."
yield use_metric
for entry in iterator:
assert False, entry
