def __init__(self, dom_string):
if dom_string is not None:
super().__init__(dom_string)
self.prelude = ""
self.actions = []
for child in self.children:
tokens = re.split(r'\s', child)
identifier = tokens[0]
if identifier == 'domain':
self.name = tokens[1]
elif identifier == ':requirements':
self.requirements = Utils.get_colon_sections(child)[1:]
elif identifier == ':types':
self.type_string = child.replace(":types", "")
elif identifier == ':predicates':
# self.predicates = PDDLPart.PDDLPart(child).children # TODO: Map these to their own objects eventually?
self.predicates = [
fluenttree.AbstractPredicate(ch)
for ch in PDDLPart.PDDLPart(child).children
]
elif identifier == ':action':
self.actions.append(Operator.Operator(child))
self.summary = self.name + "\nPredicates: " + str(
len(self.predicates)) + "\nActions: " + str(len(self.actions))
else: # Blank domain for writing into
super().__init__("")
self.actions = []
self.name = "EMPTY-DOMAIN"
self.requirements = []
self.type_string = ""
self.predicates = []
self.summary = self.name + "\nPredicates: " + str(
len(self.predicates)) + "\nActions: " + str(len(self.actions))
self.prelude = ""
def find_predicates(self):
base_preds = self.base_domain.predicates
bredicates = []
for pred in base_preds:
bredicates.append(
fluenttree.AbstractPredicate(
f"believes_not_{pred.identifier} ?who - character " +
' '.join([
p + ' - ' + t
for p, t in zip(pred.parameters, pred.types)
])))
bredicates.append(
fluenttree.AbstractPredicate(
f"believes_{pred.identifier} ?who - character " +
' '.join([
p + ' - ' + t
for p, t in zip(pred.parameters, pred.types)
])))
return base_preds + bredicates
def __init__(self, to_parse):
if to_parse is not None:
super().__init__(to_parse)
self.base_string = to_parse
self.name = re.split(r'\s', self.base_string)[1]
tokens = Utils.get_colon_sections(self.base_string)
self.agents = []
self.parameters = []
self.precondition = None
self.effect = None
self.fail = None
for token in tokens:
title = token.split()[0]
if title == ":action":
self.name = token.split()[1]
# self.name = fluenttree.first_word(token)
elif title == ":parameters":
# self.parameters = Parameter.parameter_list(Utils.find_child(token)[0])
self.parameters = fluenttree.AbstractPredicate(
"X " + Utils.find_child(token)[0])
self.parameters.identifier = ""
elif title == ":precondition":
self.precondition = fluenttree.FluentTree(
Utils.find_child(token)[0])
elif title == ":effect":
self.effect = fluenttree.FluentTree(
Utils.find_child(token)[0])
elif title == ":fail":
self.fail = fluenttree.FluentTree(
Utils.find_child(token)[0])
elif title == ":agents":
self.agents = Utils.get_question_mark_sections(
Utils.find_child(token)[0])
else:
super().__init__("")
self.base_string = "blank"
self.name = "blank"
self.agents = []
self.parameters = fluenttree.AbstractPredicate("")
self.precondition = None
self.effect = None
self.fail = None
def find_init_state(self):
state = []
for pred in self.base_problem.init_state: #[fluenttree.AbstractPredicate(c) for c in self.base_problem.init_state]:
# if pred.is_belief and not pred.is_not:
# pred = fluenttree.AbstractPredicate(f"believes_{pred.identifier} {' '.join(pred.parameters)}")
# elif pred.is_belief and pred.is_not:
# pred = fluenttree.AbstractPredicate(f"believes_not{pred.identifier} {' '.join(pred.parameters)}")
flatten_beliefs_with_not(pred)
state.append(fluenttree.AbstractPredicate(pred))
return state
def flatten_beliefs(ft):
if ft.is_leaf:
return
else:
new_children = []
for c in ft.child_trees:
if not c.is_belief:
new_children.append(c)
else:
c_predicate_form = fluenttree.AbstractPredicate(c)
new_child = fluenttree.FluentTree(
"believes_" + c_predicate_form.identifier + ' ' +
' '.join(c_predicate_form.parameters))
new_children.append(new_child)
ft.child_trees = new_children
for c in ft.child_trees:
flatten_beliefs(c)
def make_beleaves(
ft, agent): # TODO: Make special cases for "for all" and "when" trees
if ft.is_leaf:
ft.identifier = "believes_" + ft.identifier
ft.words.insert(1, agent)
elif ft.identifier == "not" and len(
ft.child_trees) == 1 and ft.child_trees[0].is_leaf:
leaf_pred = fluenttree.AbstractPredicate(ft.child_trees[0])
ft.identifier = "believes_not_" + leaf_pred.identifier
ft.words = [ft.identifier, agent] + leaf_pred.parameters
ft.child_trees = []
ft.is_leaf = True
else:
# non_belief_children = [c for c in ft.child_trees if not c.is_belief]
for child in ft.child_trees:
if child.is_belief:
flatten_beliefs_with_not(child)
else:
make_beleaves(child, agent)
def flatten_beliefs_with_not(ft):
if ft.is_belief:
if len(ft.child_trees) > 0 and ft.child_trees[0].identifier == "not":
leaf = fluenttree.AbstractPredicate(
ft.child_trees[0].child_trees[0])
upper = fluenttree.AbstractPredicate(ft)
ft.identifier = 'believes_not_' + leaf.identifier
ft.words = [ft.identifier] + [upper.parameters[0]
] + leaf.parameters
else:
ft_pred = fluenttree.AbstractPredicate(ft)
ft.identifier = "believes_" + ft_pred.identifier
ft.words = [ft.identifier] + ft_pred.parameters
ft.is_belief = False
ft.child_trees = []
elif ft.is_leaf:
return
else:
new_children = []
for c in ft.child_trees:
if not c.is_belief:
new_children.append(c)
else:
if len(c.child_trees
) > 0 and c.child_trees[0].identifier == "not":
leaf = fluenttree.AbstractPredicate(
c.child_trees[0].child_trees[0])
upper = fluenttree.AbstractPredicate(c)
new_child = fluenttree.FluentTree(
"believes_not_" + leaf.identifier + ' ' +
' '.join([upper.parameters[0]] + leaf.parameters),
depth=c.depth)
else:
c_predicate_form = fluenttree.AbstractPredicate(c)
new_child = fluenttree.FluentTree(
"believes_" + c_predicate_form.identifier + ' ' +
' '.join(c_predicate_form.parameters),
depth=c.depth)
new_children.append(new_child)
ft.child_trees = new_children
for c in ft.child_trees:
flatten_beliefs_with_not(c)