def parse_domain(domain_pddl):
iterator = iter(domain_pddl)
the_functions = []
the_axioms = []
the_actions = []
the_durative_actions = []
assert iterator.next() == "define"
domain_line = iterator.next()
assert domain_line[0] == "domain" and len(domain_line) == 2
yield domain_line[1]
opt_requirements = iterator.next()
if opt_requirements[0] == ":requirements":
yield Requirements(opt_requirements[1:])
opt_types = iterator.next()
else:
yield Requirements([":strips"])
opt_types = opt_requirements
the_types = [pddl_types.Type("object")]
if opt_types[0] == ":types":
the_types.extend(pddl_types.parse_typed_list(opt_types[1:],
constructor=pddl_types.Type))
opt_constants = iterator.next()
else:
opt_constants = opt_types
if opt_constants[0] == ":constants":
yield pddl_types.parse_typed_list(opt_constants[1:],types=the_types)
pred = iterator.next()
else:
yield []
pred = opt_constants
the_predicates = []
if pred[0] == ":predicates":
the_predicates = ([predicates.Predicate.parse(entry) for entry in pred[1:]] +
[predicates.Predicate("=",
[pddl_types.TypedObject("?x", "object"),
pddl_types.TypedObject("?y", "object")])])
else:
the_predicates = [predicates.Predicate("=",
[pddl_types.TypedObject("?x", "object"),
pddl_types.TypedObject("?y", "object")])]
parse_domain_structure(pred,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)
for entry in iterator:
parse_domain_structure(entry,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)
pddl_types.set_supertypes(the_types)
the_types = [type for type in the_types if type.supertype_names != [] or type.name == "object"]
yield the_predicates
yield the_types
yield the_functions
yield the_actions
yield the_durative_actions
yield the_axioms
def parse_domain(domain_pddl):
iterator = iter(domain_pddl)
the_functions = []
the_axioms = []
the_actions = []
the_durative_actions = []
assert iterator.next() == "define"
domain_line = iterator.next()
assert domain_line[0] == "domain" and len(domain_line) == 2
yield domain_line[1]
opt_requirements = iterator.next()
if opt_requirements[0] == ":requirements":
yield Requirements(opt_requirements[1:])
opt_types = iterator.next()
else:
yield Requirements([":strips"])
opt_types = opt_requirements
the_types = [pddl_types.Type("object")]
if opt_types[0] == ":types":
the_types.extend(pddl_types.parse_typed_list(opt_types[1:],
constructor=pddl_types.Type))
opt_constants = iterator.next()
else:
opt_constants = opt_types
if opt_constants[0] == ":constants":
yield pddl_types.parse_typed_list(opt_constants[1:],types=the_types)
pred = iterator.next()
else:
yield []
pred = opt_constants
the_predicates = []
if pred[0] == ":predicates":
the_predicates = ([predicates.Predicate.parse(entry) for entry in pred[1:]] +
[predicates.Predicate("=",
[pddl_types.TypedObject("?x", "object"),
pddl_types.TypedObject("?y", "object")])])
else:
the_predicates = [predicates.Predicate("=",
[pddl_types.TypedObject("?x", "object"),
pddl_types.TypedObject("?y", "object")])]
parse_domain_structure(pred,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)
for entry in iterator:
parse_domain_structure(entry,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)
pddl_types.set_supertypes(the_types)
the_types = [type for type in the_types if type.supertype_names != [] or type.name == "object"]
yield the_predicates
yield the_types
yield the_functions
yield the_actions
yield the_durative_actions
yield the_axioms
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":action"
name = iterator.next()
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
precondition_tag_opt = iterator.next()
else:
parameters = []
precondition_tag_opt = parameters_tag_opt
if precondition_tag_opt == ":precondition":
precondition = conditions.parse_condition(iterator.next())
precondition = precondition.simplified()
effect_tag = iterator.next()
else:
precondition = conditions.Conjunction([])
effect_tag = precondition_tag_opt
assert effect_tag == ":effect"
effect_list = iterator.next()
eff = []
try:
cost = effects.parse_effects(effect_list, eff)
except ValueError, e:
raise SystemExit("Error in Action %s\nReason: %s." % (name, e))
def parse(alist):
iterator = iter(alist)
action_tag = next(iterator)
assert action_tag == ':action'
name = next(iterator)
parameters_tag_opt = next(iterator)
if parameters_tag_opt == ':parameters':
parameters = pddl_types.parse_typed_list(next(iterator),
only_variables=True)
precondition_tag_opt = next(iterator)
else:
parameters = []
precondition_tag_opt = parameters_tag_opt
if precondition_tag_opt == ':precondition':
precondition_list = next(iterator)
if not precondition_list:
# Note that :precondition () is allowed in PDDL.
precondition = conditions.Conjunction([])
else:
precondition = \
conditions.parse_condition(precondition_list)
precondition = precondition.simplified()
effect_tag = next(iterator)
else:
precondition = conditions.Conjunction([])
effect_tag = precondition_tag_opt
assert effect_tag == ':effect'
effect_list = next(iterator)
try:
cost_eff_pairs = effects.parse_effects(effect_list)
if 1 == len(cost_eff_pairs):
cost_eff_pairs = [(cost_eff_pairs[0][0], cost_eff_pairs[0][1],
'')]
else:
# Convert floats to fractions to output
# TODO : Benchmark this fraction conversion
all_fractions = []
for cep in cost_eff_pairs:
all_fractions.append(
fractions.Fraction(cep[2]).limit_denominator())
lcm = reduce(lambda a, b: a * b / fractions.gcd(a, b),
[f.denominator for f in all_fractions], 1)
# Use the fractions and lcm to build the weights
#for i in range(len(cost_eff_pairs)):
# for j in range(len(cost_eff_pairs[i])):
# print(cost_eff_pairs[i][j])
cost_eff_pairs = [(cost_eff_pairs[i][0], cost_eff_pairs[i][1],
'_DETDUP_%d_WEIGHT_%d_%d' %
(i, all_fractions[i].numerator,
all_fractions[i].denominator))
for i in range(len(cost_eff_pairs))]
except ValueError, e:
raise SystemExit('Error in Action %s\nReason: %s.' % (name, e))
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(alist):
iterator = iter(alist)
assert iterator.next() == ":action"
name = iterator.next()
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
precondition_tag_opt = iterator.next()
else:
parameters = []
precondition_tag_opt = parameters_tag_opt
if precondition_tag_opt == ":precondition":
precondition = conditions.parse_condition(iterator.next())
effect_tag = iterator.next()
else:
precondition = conditions.Conjunction([])
effect_tag = precondition_tag_opt
assert effect_tag == ":effect"
effect_list = iterator.next()
eff = []
cost = effects.parse_effects(effect_list, eff)
for rest in iterator:
assert False, rest
return Action(name, parameters, precondition, eff, cost)
def parse_condition_aux(alist, negated):
"""Parse a PDDL condition. The condition is translated into NNF on the fly."""
tag = alist[0]
if tag in ("and", "or", "not", "imply"):
args = alist[1:]
if tag == "imply":
assert len(args) == 2
if tag == "not":
assert len(args) == 1
return parse_condition_aux(args[0], not negated)
elif tag in ("forall", "exists"):
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
elif negated:
return NegatedAtom(alist[0], alist[1:])
else:
return Atom(alist[0], alist[1:])
if tag == "imply":
parts = [parse_condition_aux(args[0], not negated),
parse_condition_aux(args[1], negated)]
tag = "or"
else:
parts = [parse_condition_aux(part, negated) for part in args]
if tag == "and" and not negated or tag == "or" and negated:
return Conjunction(parts)
elif tag == "or" and not negated or tag == "and" and negated:
return Disjunction(parts)
elif tag == "forall" and not negated or tag == "exists" and negated:
return UniversalCondition(parameters, parts)
elif tag == "exists" and not negated or tag == "forall" and negated:
return ExistentialCondition(parameters, parts)
def parse_condition_aux(alist, negated):
"""Parse a PDDL condition. The condition is translated into NNF on the fly."""
tag = alist[0]
if tag in ("and", "or", "not", "imply"):
args = alist[1:]
if tag == "imply":
assert len(args) == 2
if tag == "not":
assert len(args) == 1
return parse_condition_aux(args[0], not negated)
elif tag in ("forall", "exists"):
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
elif negated:
return NegatedAtom(alist[0], alist[1:])
else:
return Atom(alist[0], alist[1:])
if tag == "imply":
parts = [
parse_condition_aux(args[0], not negated),
parse_condition_aux(args[1], negated)
]
tag = "or"
else:
parts = [parse_condition_aux(part, negated) for part in args]
if tag == "and" and not negated or tag == "or" and negated:
return Conjunction(parts)
elif tag == "or" and not negated or tag == "and" and negated:
return Disjunction(parts)
elif tag == "forall" and not negated or tag == "exists" and negated:
return UniversalCondition(parameters, parts)
elif tag == "exists" and not negated or tag == "forall" and negated:
return ExistentialCondition(parameters, parts)
def parse_effect(alist, durative=False):
tag = alist[0]
if tag == "and":
return TmpEffect([parse_effect(eff, durative) for eff in alist[1:]])
elif tag == "forall":
assert len(alist) == 3
return UniversalEffect(pddl_types.parse_typed_list(alist[1]),
parse_effect(alist[2], durative))
elif tag == "when":
assert len(alist) == 3
if durative:
condition = conditions.parse_durative_condition(alist[1])
effect = parse_timed_effect(alist[2])
else:
condition = conditions.parse_condition(alist[1])
effect = parse_cond_effect(alist[2])
return ConditionalEffect(condition, effect)
elif tag == "at" and durative:
return parse_timed_effect(alist)
elif tag == "change":
assert durative
new_alist = [
"and", ["at", "start", ["assign", alist[1], "undefined"]],
["at", "end", ["assign", alist[1], alist[2]]]
]
return parse_effect(new_alist, durative)
else:
return parse_cond_effect(alist)
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":action"
name = iterator.next()
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
precondition_tag_opt = iterator.next()
else:
parameters = []
precondition_tag_opt = parameters_tag_opt
if precondition_tag_opt == ":precondition":
precondition = conditions.parse_condition(iterator.next())
effect_tag = iterator.next()
else:
precondition = conditions.Conjunction([])
effect_tag = precondition_tag_opt
assert effect_tag == ":effect"
effect_list = iterator.next()
eff = []
try:
cost = effects.parse_effects(effect_list, eff)
except ValueError, e:
raise SystemExit("Error in Action %s\nReason: %s." % (name, e))
def parse_domain_structure(entry, the_functions, the_axioms, the_actions,
the_durative_actions, the_types, the_predicates):
if entry[0] == ":derived":
axiom = axioms.Axiom.parse(entry)
the_axioms.append(axiom)
elif entry[0] == ":durative-action":
action = actions.DurativeAction.parse(entry)
the_durative_actions.append(action)
elif entry[0] == ":functions":
the_functions.extend(
pddl_types.parse_typed_list(
entry[1:],
constructor=functions.Function.parse_typed,
functions=True,
types=the_types))
for function in the_functions:
Task.FUNCTION_SYMBOLS[function.name] = function.type
if function.type != "number":
the_predicates.append(
predicates.Predicate(
conditions.function_predicate_name(function.name),
function.arguments +
[pddl_types.TypedObject("?val", function.type)]))
elif entry[0] == ":action":
action = actions.Action.parse(entry)
the_actions.append(action)
else:
assert False, "unknown entity"
def parse_effect(alist):
tag = alist[0]
if tag == "and":
return [
ConjunctiveEffect(conjuncts) for conjuncts in cartesian_product(
*[parse_effect(eff) for eff in alist[1:]])
]
elif tag == "forall":
assert len(alist) == 3
parameters = pddl_types.parse_typed_list(alist[1])
effects = parse_effect(alist[2])
assert 1 == len(
effects
), "Error: Cannot embed non-determinism inside of a forall (for now)."
return [UniversalEffect(parameters, effect) for effect in effects]
elif tag == "when":
assert len(alist) == 3
condition = conditions.parse_condition(alist[1])
effects = parse_effect(alist[2])
return [ConditionalEffect(condition, effect) for effect in effects]
elif tag == "increase":
assert len(alist) == 3
assert alist[1] == ['total-cost']
assignment = f_expression.parse_assignment(alist)
return [CostEffect(assignment)]
elif tag == "oneof":
options = []
for eff in alist[1:]:
options.extend(parse_effect(eff))
return options
else:
return [SimpleEffect(conditions.parse_literal(alist))]
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":action"
name = iterator.next()
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
precondition_tag_opt = iterator.next()
else:
parameters = []
precondition_tag_opt = parameters_tag_opt
if precondition_tag_opt == ":precondition":
precondition = conditions.parse_condition(iterator.next())
effect_tag = iterator.next()
else:
precondition = conditions.Conjunction([])
effect_tag = precondition_tag_opt
assert effect_tag == ":effect"
effect_list = iterator.next()
eff = []
effects.parse_effects(effect_list,eff)
for rest in iterator:
assert False, rest
return Action(name, parameters, precondition, eff)
def parse_effect(alist,durative=False):
tag = alist[0]
if tag == "and":
return TmpEffect([parse_effect(eff,durative) for eff in alist[1:]])
elif tag == "forall":
assert len(alist)==3
return UniversalEffect(pddl_types.parse_typed_list(alist[1]),
parse_effect(alist[2],durative))
elif tag == "when":
assert len(alist)==3
if durative:
condition = conditions.parse_durative_condition(alist[1])
effect = parse_timed_effect(alist[2])
else:
condition = conditions.parse_condition(alist[1])
effect = parse_cond_effect(alist[2])
return ConditionalEffect(condition,effect)
elif tag == "at" and durative:
return parse_timed_effect(alist)
elif tag == "change":
assert durative
new_alist = ["and", ["at", "start", ["assign", alist[1], "undefined"]],
["at", "end", ["assign", alist[1], alist[2]]]]
return parse_effect(new_alist,durative)
else:
return parse_cond_effect(alist)
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_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 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 = []
timed_initial = []
for fact in init[1:]:
if fact[0] == "at" and len(fact) == 3 and f_expression.isFloat(fact[1]):
timed_initial.append(timed_initials.TimedInitial(float(fact[1]),fact[2]))
else:
initial.append(parse_init_fact(fact))
yield initial
yield timed_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_condition_aux(alist, negated):
"""Parse a PDDL condition. The condition is translated into NNF on the fly."""
tag = alist[0]
if is_function_comparison(alist):
args = [f_expression.parse_expression(arg) for arg in alist[1:]]
assert len(args) == 2, args
if negated:
return NegatedFunctionComparison(tag, args, True)
else:
return FunctionComparison(tag, args, True)
elif tag in ("and", "or", "not", "imply"):
args = alist[1:]
if tag == "imply":
assert len(args) == 2
if tag == "not":
assert len(args) == 1
return parse_condition_aux(args[0], not negated)
elif tag in ("forall", "exists"):
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
elif tag == "[":
assert not negated
assert alist[-1] == "]"
alist = alist[1:-1] # strip [ and ]
# where go the type checks here? parameter should match the module...
# somewhere check the "nestedness" as we want them at the top only?
# Perhaps later in translate meckern
return ModuleCall(alist[0], [parse_term(term) for term in alist[1:]])
elif negated:
return NegatedAtom(alist[0], [parse_term(term) for term in alist[1:]])
else:
return Atom(alist[0], [parse_term(term) for term in alist[1:]])
if tag == "imply":
parts = [
parse_condition_aux(args[0], not negated),
parse_condition_aux(args[1], negated)
]
tag = "or"
else:
parts = [parse_condition_aux(part, negated) for part in args]
if tag == "and" and not negated or tag == "or" and negated:
return Conjunction(parts)
elif tag == "or" and not negated or tag == "and" and negated:
return Disjunction(parts)
elif tag == "forall" and not negated or tag == "exists" and negated:
return UniversalCondition(parameters, parts)
elif tag == "exists" and not negated or tag == "forall" and negated:
return ExistentialCondition(parameters, parts)
def parse_condition_aux(alist, negated):
"""Parse a PDDL condition. The condition is translated into NNF on the fly."""
tag = alist[0]
if is_function_comparison(alist):
args = [f_expression.parse_expression(arg) for arg in alist[1:]]
assert len(args) == 2, args
if negated:
return NegatedFunctionComparison(tag, args, True)
else:
return FunctionComparison(tag, args, True)
elif tag in ("and", "or", "not", "imply"):
args = alist[1:]
if tag == "imply":
assert len(args) == 2
if tag == "not":
assert len(args) == 1
return parse_condition_aux(args[0], not negated)
elif tag in ("forall", "exists"):
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
elif tag == "[":
assert not negated
assert alist[-1] == "]"
alist = alist[1:-1] # strip [ and ]
# where go the type checks here? parameter should match the module...
# somewhere check the "nestedness" as we want them at the top only?
# Perhaps later in translate meckern
return ModuleCall(alist[0], [parse_term(term) for term in alist[1:]])
elif negated:
return NegatedAtom(alist[0], [parse_term(term) for term in alist[1:]])
else:
return Atom(alist[0],[parse_term(term) for term in alist[1:]])
if tag == "imply":
parts = [parse_condition_aux(args[0], not negated),
parse_condition_aux(args[1], negated)]
tag = "or"
else:
parts = [parse_condition_aux(part, negated) for part in args]
if tag == "and" and not negated or tag == "or" and negated:
return Conjunction(parts)
elif tag == "or" and not negated or tag == "and" and negated:
return Disjunction(parts)
elif tag == "forall" and not negated or tag == "exists" and negated:
return UniversalCondition(parameters, parts)
elif tag == "exists" and not negated or tag == "forall" and negated:
return ExistentialCondition(parameters, parts)
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":durative-action"
name = iterator.next()
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
duration_tag = iterator.next()
else:
parameters = []
duration_tag = parameters_tag_opt
assert duration_tag == ":duration"
duration_list = iterator.next()
if duration_list[0] == "and":
duration_list = duration_list[1:]
else:
duration_list = [duration_list]
duration_start = []
duration_end = []
for item in duration_list: # each item is a simple-duration-constraint
duration = duration_start
if item[0] == "at":
if item[1] == "end":
duration = duration_end
item = item[2]
assert item[0] in ("<=", ">=", "=")
assert len(item) == 3
assert item[1] == "?duration"
op = item[0]
value = f_expression.parse_expression(item[2])
duration += [(op, value)]
condition_tag = iterator.next()
if condition_tag == ":condition":
condition = conditions.parse_durative_condition(iterator.next())
effect_tag = iterator.next()
else:
condition = conditions.parse_durative_condition([])
effect_tag = condition_tag
assert effect_tag == ":effect"
effect_list = iterator.next()
effect = [[], []]
effects.parse_durative_effects(effect_list, effect)
for rest in iterator:
assert False, rest
return DurativeAction(name, parameters, (duration_start, duration_end),
condition, effect)
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":durative-action"
name = iterator.next()
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
duration_tag = iterator.next()
else:
parameters = []
duration_tag = parameters_tag_opt
assert duration_tag == ":duration"
duration_list = iterator.next()
if duration_list[0] == "and":
duration_list = duration_list[1:]
else:
duration_list = [duration_list]
duration_start = []
duration_end = []
for item in duration_list: # each item is a simple-duration-constraint
duration = duration_start
if item[0] == "at":
if item[1] == "end":
duration = duration_end
item = item[2]
assert item[0] in ("<=",">=","=")
assert len(item) == 3
assert item[1] == "?duration"
op = item[0]
value = f_expression.parse_expression(item[2])
duration += [(op,value)]
condition_tag = iterator.next()
if condition_tag == ":condition":
condition = conditions.parse_durative_condition(iterator.next())
effect_tag = iterator.next()
else:
condition = conditions.parse_durative_condition([])
effect_tag = condition_tag
assert effect_tag == ":effect"
effect_list = iterator.next()
effect = [[],[]]
effects.parse_durative_effects(effect_list, effect)
for rest in iterator:
assert False, rest
return DurativeAction(name, parameters, (duration_start,duration_end), condition, effect)
def parse_condition_aux(alist, negated):
"""Parse a PDDL condition. The condition is translated into NNF on the fly."""
tag = alist[0]
if is_function_comparison(alist):
args = [f_expression.parse_expression(arg) for arg in alist[1:]]
assert len(args) == 2, args
if negated:
return NegatedFunctionComparison(tag, args, True)
else:
return FunctionComparison(tag, args, True)
elif tag in ("and", "or", "not", "imply"):
args = alist[1:]
if tag == "imply":
assert len(args) == 2
if tag == "not":
assert len(args) == 1
return parse_condition_aux(args[0], not negated)
elif tag in ("forall", "exists"):
import __builtin__
__builtin__.containsQuantifiedConditions = True
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
elif negated:
return NegatedAtom(alist[0], [parse_term(term) for term in alist[1:]])
else:
return Atom(alist[0], [parse_term(term) for term in alist[1:]])
if tag == "imply":
parts = [
parse_condition_aux(args[0], not negated),
parse_condition_aux(args[1], negated)
]
tag = "or"
else:
parts = [parse_condition_aux(part, negated) for part in args]
if tag == "and" and not negated or tag == "or" and negated:
return Conjunction(parts)
elif tag == "or" and not negated or tag == "and" and negated:
return Disjunction(parts)
elif tag == "forall" and not negated or tag == "exists" and negated:
return UniversalCondition(parameters, parts)
elif tag == "exists" and not negated or tag == "forall" and negated:
return ExistentialCondition(parameters, parts)
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])
for entry in iterator:
if entry[0] == ":metric" and entry[1]=="minimize":
if entry[2][0] in ["total-time", "total-cost"] :
continue
assert False, entry
def parse_durative_condition(alist):
"""Parse a durative PDDL condition. i
The condition is translated into NNF on the fly.
Returns triple [start condition, over all condition, end condition]"""
if len(alist) == 0:
return [Truth(), Truth(), Truth()]
tag = alist[0]
if tag == "and":
args = alist[1:]
parts = [parse_durative_condition(part) for part in args]
parts_begin = [part[0] for part in parts]
parts_end = [part[1] for part in parts]
parts_all = [part[2] for part in parts]
return [
Conjunction(parts_begin),
Conjunction(parts_end),
Conjunction(parts_all)
]
elif tag == "forall":
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
parts = [parse_durative_condition(part) for part in args]
parts_begin = [part[0] for part in parts]
parts_end = [part[1] for part in parts]
parts_all = [part[2] for part in parts]
return [
UniversalCondition(parameters, parts_begin),
UniversalCondition(parameters, parts_end),
UniversalCondition(parameters, parts_all)
]
elif tag == "at":
assert len(alist) == 3
assert alist[1] in ("start", "end")
condition = parse_condition_aux(alist[2], False)
if alist[1] == "start":
return [condition, Truth(), Truth()]
else:
return [Truth(), Truth(), condition]
elif tag == "over":
assert alist[1] == "all"
assert len(alist) == 3
condition = parse_condition_aux(alist[2], False)
return [Truth(), condition, Truth()]
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 parse_domain_structure(entry,the_functions,the_axioms,the_actions,the_durative_actions,
the_types, the_predicates):
if entry[0] == ":derived":
axiom = axioms.Axiom.parse(entry)
the_axioms.append(axiom)
elif entry[0] == ":durative-action":
action = actions.DurativeAction.parse(entry)
the_durative_actions.append(action)
elif entry[0] == ":functions":
the_functions = pddl_types.parse_typed_list(entry[1:],
constructor=functions.Function.parse_typed, functions=True, types=the_types)
for function in the_functions:
Task.FUNCTION_SYMBOLS[function.name] = function.type
if function.type != "number":
the_predicates.append(
predicates.Predicate(conditions.function_predicate_name(function.name),
function.arguments + [pddl_types.TypedObject("?val", function.type)]))
else:
action = actions.Action.parse(entry)
the_actions.append(action)
def parse_effect(alist):
tag = alist[0]
if tag == "and":
return ConjunctiveEffect([parse_effect(eff) for eff in alist[1:]])
elif tag == "forall":
assert len(alist) == 3
parameters = pddl_types.parse_typed_list(alist[1])
effect = parse_effect(alist[2])
return UniversalEffect(parameters, effect)
elif tag == "when":
assert len(alist) == 3
condition = conditions.parse_condition(alist[1])
effect = parse_effect(alist[2])
return ConditionalEffect(condition, effect)
elif tag == "increase":
assert len(alist) == 3
assert alist[1] == ['total-cost']
assignment = f_expression.parse_assignment(alist)
return CostEffect(assignment)
else:
return SimpleEffect(conditions.parse_literal(alist))
def parse_effect(alist):
tag = alist[0]
if tag == "and":
return ConjunctiveEffect([parse_effect(eff) for eff in alist[1:]])
elif tag == "forall":
assert len(alist) == 3
parameters = pddl_types.parse_typed_list(alist[1])
effect = parse_effect(alist[2])
return UniversalEffect(parameters, effect)
elif tag == "when":
assert len(alist) == 3
condition = conditions.parse_condition(alist[1])
effect = parse_effect(alist[2])
return ConditionalEffect(condition, effect)
elif tag == "increase":
assert len(alist) == 3
assert alist[1] == ['total-cost']
assignment = f_expression.parse_assignment(alist)
return CostEffect(assignment)
else:
return SimpleEffect(conditions.parse_literal(alist))
def parse(alist):
assert len(alist) >= 3
name = alist[0]
# effects might contain (set) functions here like (x ?a)
parameterList = [
someParam for someParam in alist[1:-2]
if not isinstance(someParam, list)
]
functionParamList = [
someParam for someParam in alist[1:-2]
if isinstance(someParam, list)
]
parameters = pddl_types.parse_typed_list(parameterList)
effects = [
f_expression.parse_expression(entry) for entry in functionParamList
]
#effects = [functions.Function.parse_typed(entry, "number") for entry in functionParamList]
modulecall = alist[-1]
type = alist[-2]
return Module(name, parameters, type, modulecall, effects)
def parse(alist):
iterator = iter(alist)
action_tag = next(iterator)
assert action_tag == ":action"
name = next(iterator)
parameters_tag_opt = next(iterator)
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(next(iterator),
only_variables=True)
precondition_tag_opt = next(iterator)
else:
parameters = []
precondition_tag_opt = parameters_tag_opt
if precondition_tag_opt == ":precondition":
precondition_list = next(iterator)
if not precondition_list:
# Note that :precondition () is allowed in PDDL.
precondition = conditions.Conjunction([])
else:
precondition = conditions.parse_condition(precondition_list)
precondition = precondition.simplified()
effect_tag = next(iterator)
else:
precondition = conditions.Conjunction([])
effect_tag = precondition_tag_opt
assert effect_tag == ":effect"
effect_list = next(iterator)
try:
cost_eff_pairs = effects.parse_effects(effect_list)
if 1 == len(cost_eff_pairs):
cost_eff_pairs = [(cost_eff_pairs[0][0], cost_eff_pairs[0][1], '')]
else:
cost_eff_pairs = [(cost_eff_pairs[i][0], cost_eff_pairs[i][1], "_DETDUP_%d" % i) for i in range(len(cost_eff_pairs))]
except ValueError as e:
raise SystemExit("Error in Action %s\nReason: %s." % (name, e))
for rest in iterator:
assert False, rest
return [Action(name + suffix, parameters, len(parameters), precondition, eff, cost) for (cost, eff, suffix) in cost_eff_pairs]
def parse_durative_condition(alist):
"""Parse a durative PDDL condition. i
The condition is translated into NNF on the fly.
Returns triple [start condition, over all condition, end condition]"""
if len(alist)==0:
return [Truth(), Truth(),Truth()]
tag = alist[0]
if tag == "and":
args = alist[1:]
parts = [parse_durative_condition(part) for part in args]
parts_begin = [part[0] for part in parts]
parts_end = [part[1] for part in parts]
parts_all = [part[2] for part in parts]
return [Conjunction(parts_begin),Conjunction(parts_end),Conjunction(parts_all)]
elif tag == "forall":
parameters = pddl_types.parse_typed_list(alist[1])
args = alist[2:]
assert len(args) == 1
parts = [parse_durative_condition(part) for part in args]
parts_begin = [part[0] for part in parts]
parts_end = [part[1] for part in parts]
parts_all = [part[2] for part in parts]
return [UniversalCondition(parameters, parts_begin),
UniversalCondition(parameters, parts_end),
UniversalCondition(parameters, parts_all)]
elif tag == "at":
assert len(alist) == 3
assert alist[1] in ("start", "end")
condition = parse_condition_aux(alist[2], False)
if alist[1] == "start":
return [condition, Truth(), Truth()]
else:
return [Truth(), Truth(), condition]
elif tag == "over":
assert alist[1] == "all"
assert len(alist) == 3
condition = parse_condition_aux(alist[2], False)
return [Truth(), condition, Truth()]
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"
oneofs = []
initial = []
ors = []
belief_state = [set()]
skip_loop = False
for fact in init[1:]:
if fact[0] == "=":
initial.append(f_expression.parse_assignment(fact))
elif fact[0] == "oneof":
oneofs.append(conditions.parse_condition(fact))
elif fact[0] == "or":
ors.append(conditions.parse_condition(fact))
else:
initial.append(conditions.Atom(fact[0], fact[1:]))
if ors != []:
for oneof in oneofs:
tmp_state = []
oneof.dump()
for i in range(0,len(oneof.parts)):
for j in range(0,len(belief_state)):
state_set = belief_state[j]
tmp_state_set = set()
for x in state_set:
tmp_state_set.add(x)
tmp_state_set.add(oneof.parts[i])
tmp_state.append(tmp_state_set)
for i in range(0,len(belief_state)):
belief_state.pop()
'''print "belief after cartesian product"'''
for x in tmp_state:
'''print "state"
for atom in x:
print atom'''
belief_state.append(x)
index_to_remove = []
for i in range(0,len(belief_state)):
remove = False
tmp_state_set = belief_state[i]
'''print "checking state"
for atom in tmp_state_set:
print atom'''
for orclause in ors:
'''print "using or"
orclause.dump()'''
skip = False
for k in range(0,len(orclause.parts)):
if isinstance(orclause.parts[k], conditions.Atom):
skip = True
break
if skip == True:
continue
else:
remove = True
for k in range(0,len(orclause.parts)):
if orclause.parts[k].negate() not in tmp_state_set:
remove = False
break
if remove == True:
if tmp_state_set in belief_state:
'''print "remove state"
for atom in tmp_state_set:
print atom
print "because"
orclause.dump()'''
index_to_remove.insert(0,i)
break
if remove == False:
for oneof in oneofs:
skip = False
for part in oneof.parts:
if part in tmp_state_set:
for other_part in oneof.parts:
if other_part != part and other_part in tmp_state_set:
skip = True
if tmp_state_set in belief_state:
index_to_remove.insert(0,i)
break
if skip == True:
break
if skip == True:
break
if skip == True:
break
for i in range(0, len(index_to_remove)):
belief_state.pop(index_to_remove[i])
print "size of belief state"
print len(belief_state)
print "we are here"
'''print "belief after removing invalid state"
for x in belief_state:
print "state"
for atom in x:
print atom'''
index_to_remove = []
for i in range(0,len(belief_state)):
tmp_state_set = belief_state[i]
for orclause in ors:
remove = False
stop = False
for k in range(0,len(orclause.parts)):
if isinstance(orclause.parts[k], conditions.Atom):
print orclause.parts[k]
if orclause.parts[k] in tmp_state_set:
stop = True
break
elif isinstance(orclause.parts[k], conditions.NegatedAtom):
if orclause.parts[k].negate() not in tmp_state_set:
stop = True
break
if stop == False:
remove = True
if remove == True:
if tmp_state_set in belief_state:
index_to_remove.insert(0,i)
'''print "remove state"
for atom in tmp_state_set:
print atom
print "because"
orclause.dump()'''
break
for i in range(0, len(index_to_remove)):
belief_state.pop(index_to_remove[i])
print "size of belief state"
print len(belief_state)
'''for tmp_state_set in belief_state:
print "state"
for atom in tmp_state_set:
print atom'''
if len(belief_state) > 0:
state_set = belief_state[0]
for atom in state_set:
initial.append(atom)
'''oneofsize = 1
for oneof in oneofs:
oneofsize = oneofsize * len(oneof.parts)
belief_state = {}
exclude_list = []
for n in range(0,oneofsize):
for i in range(0,len(oneofs)):
bucketsize = 1
for j in range(i+1,len(oneofs)):
bucketsize = bucketsize * len(oneofs[j].parts)
index_i = (n / bucketsize) % len(oneofs[i].parts)
oneof_valuename = oneofs[i].print_atom(index_i)
oneof_valuename_str = str(oneof_valuename)
skip_loop = false
for var_no, var_key in enumerate(translation_key):
for value, value_name in enumerate(var_key):
if oneof_valuename_str.find(value_name) != -1:
if var_no in belief_state:
if belief_state[var_no] = value:
print >> belief_file, "var%d \n" % var_no,
print >> belief_file, "%d \n" % value,
print >> belief_file, "END_BELIEF"'''
else:
for oneof in oneofs:
atoms = set()
atoms = oneof.get_atoms()
for atom in atoms:
atom.dump(),
initial.append(atom)
yield initial
yield oneofs
yield ors
yield belief_state
goal = iterator.next()
assert goal[0] == ":goal" and len(goal) == 2
yield conditions.parse_condition(goal[1])
originalgoal = conditions.parse_condition(goal[1])
yield originalgoal
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 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
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":durative-action"
name = iterator.next()
print "Parsing durative-action", name
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
grounding_tag = iterator.next()
else:
parameters = []
grounding_tag = parameters_tag_opt
if grounding_tag == ":grounding":
grounding_list = iterator.next()
grounding_call = conditions.parse_condition(grounding_list)
duration_tag = iterator.next()
else:
grounding_call = None
duration_tag = grounding_tag
assert duration_tag == ":duration"
duration_list = iterator.next()
if duration_list[0] == "and":
duration_list = duration_list[1:]
else:
duration_list = [duration_list]
duration_start = []
duration_end = []
for item in duration_list: # each item is a simple-duration-constraint
duration = duration_start
if item[0] == "at":
if item[1] == "end":
duration = duration_end
item = item[2]
assert item[0] in ("<=", ">=", "=")
if len(item) == 3: # = ?duration 1
assert item[1] == "?duration"
op = item[0]
value = f_expression.parse_expression(item[2])
duration += [(op, value)]
else: # should be module: = ?duration [module]
assert item[1] == "?duration"
op = item[0]
mod_list = item[2:]
#print "Modlist:", mod_list
value = conditions.parse_condition(mod_list)
#print "parse to ", value
duration += [(op, value)]
pass
condition_tag = iterator.next()
if condition_tag == ":condition":
condition = conditions.parse_durative_condition(iterator.next())
effect_tag = iterator.next()
else:
condition = conditions.parse_durative_condition([])
effect_tag = condition_tag
assert effect_tag == ":effect"
effect_list = iterator.next()
effect = [[], []]
effects.parse_durative_effects(effect_list, effect)
for rest in iterator:
assert False, rest
return DurativeAction(name, parameters, grounding_call,
(duration_start, duration_end), condition,
effect)
def parse_domain(domain_pddl):
iterator = iter(domain_pddl)
assert iterator.next() == "define"
domain_line = iterator.next()
assert domain_line[0] == "domain" and len(domain_line) == 2
yield domain_line[1]
## We allow an arbitrary order of the requirement, types, constants,
## predicates and functions specification. The PDDL BNF is more strict on
## this, so we print a warning if it is violated.
requirements = Requirements([":strips"])
the_types = [pddl_types.Type("object")]
constants, the_predicates, the_functions = [], [], []
correct_order = [
":requirements", ":types", ":constants", ":predicates", ":functions"
]
seen_fields = []
for opt in iterator:
field = opt[0]
if field not in correct_order:
first_action = opt
break
if field in seen_fields:
raise SystemExit("Error in domain specification\n" +
"Reason: two '%s' specifications." % field)
if (seen_fields and correct_order.index(seen_fields[-1]) >
correct_order.index(field)):
msg = "\nWarning: %s specification not allowed here (cf. PDDL BNF)" % field
print >> sys.stderr, msg
seen_fields.append(field)
if field == ":requirements":
requirements = Requirements(opt[1:])
elif field == ":types":
the_types.extend(
pddl_types.parse_typed_list(opt[1:],
constructor=pddl_types.Type))
elif field == ":constants":
constants = pddl_types.parse_typed_list(opt[1:])
elif field == ":predicates":
the_predicates = [
predicates.Predicate.parse(entry) for entry in opt[1:]
]
the_predicates += [
predicates.Predicate("=", [
pddl_types.TypedObject("?x", "object"),
pddl_types.TypedObject("?y", "object")
])
]
elif field == ":functions":
the_functions = pddl_types.parse_typed_list(
opt[1:],
constructor=functions.Function.parse_typed,
functions=True)
for function in the_functions:
Task.FUNCTION_SYMBOLS[function.name] = function.type
pddl_types.set_supertypes(the_types)
# for type in the_types:
# print repr(type), type.supertype_names
yield requirements
yield the_types
yield constants
yield the_predicates
yield the_functions
entries = [first_action] + [entry for entry in iterator]
the_axioms = []
the_actions = []
for entry in entries:
if entry[0] == ":derived":
axiom = axioms.Axiom.parse(entry)
the_axioms.append(axiom)
else:
action = actions.Action.parse(entry)
the_actions.append(action)
yield the_actions
yield the_axioms
def parse(alist):
name = alist[0]
arguments = pddl_types.parse_typed_list(alist[1:], only_variables=True)
return Predicate(name, arguments)
def parse(alist):
name = alist[0]
arguments = pddl_types.parse_typed_list(alist[1:], functions=True)
return Function(name, arguments)
def parse(alist):
name = alist[0]
arguments = pddl_types.parse_typed_list(alist[1:], only_variables=True)
return Predicate(name, arguments)
def parse(alist):
iterator = iter(alist)
assert iterator.next() == ":durative-action"
name = iterator.next()
print "Parsing durative-action", name
parameters_tag_opt = iterator.next()
if parameters_tag_opt == ":parameters":
parameters = pddl_types.parse_typed_list(iterator.next(),
only_variables=True)
grounding_tag = iterator.next()
else:
parameters = []
grounding_tag = parameters_tag_opt
if grounding_tag == ":grounding":
grounding_list = iterator.next()
grounding_call = conditions.parse_condition(grounding_list)
duration_tag = iterator.next()
else:
grounding_call = None
duration_tag = grounding_tag
assert duration_tag == ":duration"
duration_list = iterator.next()
if duration_list[0] == "and":
duration_list = duration_list[1:]
else:
duration_list = [duration_list]
duration_start = []
duration_end = []
for item in duration_list: # each item is a simple-duration-constraint
duration = duration_start
if item[0] == "at":
if item[1] == "end":
duration = duration_end
item = item[2]
assert item[0] in ("<=",">=","=")
if len(item) == 3: # = ?duration 1
assert item[1] == "?duration"
op = item[0]
value = f_expression.parse_expression(item[2])
duration += [(op,value)]
else: # should be module: = ?duration [module]
assert item[1] == "?duration"
op = item[0]
mod_list = item[2:]
#print "Modlist:", mod_list
value = conditions.parse_condition(mod_list)
#print "parse to ", value
duration += [(op,value)]
pass
condition_tag = iterator.next()
if condition_tag == ":condition":
condition = conditions.parse_durative_condition(iterator.next())
effect_tag = iterator.next()
else:
condition = conditions.parse_durative_condition([])
effect_tag = condition_tag
assert effect_tag == ":effect"
effect_list = iterator.next()
effect = [[],[]]
effects.parse_durative_effects(effect_list, effect)
for rest in iterator:
assert False, rest
return DurativeAction(name, parameters, grounding_call, (duration_start,duration_end), condition, effect)
def parse(alist):
name = alist[0]
arguments = pddl_types.parse_typed_list(alist[1:], functions=True)
return Function(name, arguments)
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(cls, alist, type):
name = alist[0]
arguments = pddl_types.parse_typed_list(alist[1:])
return cls(name, arguments, type)
def parse_domain(domain_pddl):
iterator = iter(domain_pddl)
assert iterator.next() == "define"
domain_line = iterator.next()
assert domain_line[0] == "domain" and len(domain_line) == 2
yield domain_line[1]
opt_requirements = iterator.next()
if opt_requirements[0] == ":requirements":
yield Requirements(opt_requirements[1:])
opt_types = iterator.next()
else:
yield Requirements([":strips"])
opt_types = opt_requirements
the_types = [pddl_types.Type("object")]
if opt_types[0] == ":types":
the_types.extend(pddl_types.parse_typed_list(opt_types[1:],
constructor=pddl_types.Type))
opt_constants = iterator.next()
else:
opt_constants = opt_types
pddl_types.set_supertypes(the_types)
# for type in the_types:
# print repr(type), type.supertype_names
yield the_types
if opt_constants[0] == ":constants":
yield pddl_types.parse_typed_list(opt_constants[1:])
pred = iterator.next()
else:
yield []
pred = opt_constants
assert pred[0] == ":predicates"
print pred
yield ([predicates.Predicate.parse(entry) for entry in pred[1:]] +
[predicates.Predicate("=",
[pddl_types.TypedObject("?x", "object"),
pddl_types.TypedObject("?y", "object")])])
opt_functions = iterator.next() #action costs enable restrictive version of fluents
if opt_functions[0] == ":functions":
the_functions = pddl_types.parse_typed_list(opt_functions[1:],
constructor=functions.Function.parse_typed, functions=True)
for function in the_functions:
Task.FUNCTION_SYMBOLS[function.name] = function.type
yield the_functions
first_action = iterator.next()
else:
yield []
first_action = opt_functions
entries = [first_action] + [entry for entry in iterator]
the_axioms = []
the_actions = []
for entry in entries:
if entry[0] == ":derived":
axiom = axioms.Axiom.parse(entry)
the_axioms.append(axiom)
else:
action = actions.Action.parse(entry)
the_actions.append(action)
yield the_actions
yield the_axioms
