def solve(self, domain, problem):
# Parser
parser = PDDL_Parser()
parser.parse_domain(domain)
parser.parse_problem(problem)
# Parsed data
actions = parser.actions
state = parser.state
goal_pos = parser.positive_goals
goal_not = parser.negative_goals
# Do nothing
if self.applicable(state, goal_pos, goal_not):
return []
# Search
visited = [state]
fringe = [state, None]
while fringe:
state = fringe.pop(0)
plan = fringe.pop(0)
for act in actions:
if self.applicable(state, act.positive_preconditions,
act.negative_preconditions):
new_state = self.apply(state, act.add_effects,
act.del_effects)
if new_state not in visited:
if self.applicable(new_state, goal_pos, goal_not):
full_plan = [act]
while plan:
act, plan = plan
full_plan.insert(0, act)
return full_plan
visited.append(new_state)
fringe.append(new_state)
fringe.append((act, plan))
return None
def __init__(self, filename, domainName='reconstructed'):
self.domainName = domainName
self.parser = PDDL_Parser()
self.tokens = self.parser.scan_tokens(filename)
pprint.pprint(self.tokens)
print('=== Objects ===')
self.parseObjects(self.tokens[1])
pprint.pprint(self.types2objs)
print('=== States ===')
self.parseStates(self.tokens)
pprint.pprint(self.states)
print('=== Predicates ===')
pprint.pprint(self.predicates)
print('=== Actions ===')
self.parseActions(self.tokens)
# print(self.tokens[3])
# p, n = self.actions[0].assignPrecons(self.tokens[3][1][1:])
# print('Grounded Positive preconditions')
# print(p)
# print('Grounded Negative preconditions')
# print(n)
# print('Before State')
# print(self.states[0])
# self.actions[0].prunePrecons(self.states[0], self.tokens[3][1][1:])
# print(self.actions[0])
self.refineActions(self.tokens)
pprint.pprint(self.actions)
self.genTypeclasses()
def constraints(domain, problem):
clause_list = []
# Parser
parser = PDDL_Parser()
parser.parse_domain(domain)
parser.parse_problem(problem)
state = parser.state
# Initial state clauses:
initial_clauses = list(state)
#print(initial_clauses)
goal_pos = parser.positive_goals
goal_not = parser.negative_goals
goal_clauses = [goal_pos, goal_not]
action_list = []
# Grounding process
ground_actions = []
for action in parser.actions:
for act in action.groundify(parser.objects):
ground_actions.append(act)
# Appending grounded actions:
for act in ground_actions:
action_list.append(act)
#print(act)
action_list.append(Action('noop', (), [], [], [], []))
# Appending to one list:
clause_list.append(initial_clauses)
clause_list.append(goal_clauses)
clause_list.extend(action_list)
return clause_list
def test_scan_tokens_domain(self):
parser = PDDL_Parser()
self.assertEqual(parser.scan_tokens('examples/dinner/dinner.pddl'), [
'define', ['domain', 'dinner'], [':requirements', ':strips'],
[
':predicates', ['clean'], ['dinner'], ['quiet'], ['present'],
['garbage']
],
[
':action', 'cook', ':precondition', ['clean'], ':effect',
['dinner']
],
[
':action', 'wrap', ':precondition', ['quiet'], ':effect',
['present']
],
[
':action', 'carry', ':precondition', ['garbage'], ':effect',
['and', ['not', ['garbage']], ['not', ['clean']]]
],
[
':action', 'dolly', ':precondition', ['garbage'], ':effect',
['and', ['not', ['garbage']], ['not', ['quiet']]]
]
])
def test_parse_predicates(self):
parser = PDDL_Parser()
parser.predicates = {}
parser.parse_predicates(
[['untyped_pred', '?v1', '?v2', '?v3'],
[
'typed_pred', '?v1', '-', 'type1', '?v2', '-', 'type1', '?v3',
'-', 'object'
], ['shared_type_pred', '?v1', '?v2', '-', 'type1', '?v3']])
self.assertEqual(
parser.predicates, {
'untyped_pred': {
'?v1': 'object',
'?v2': 'object',
'?v3': 'object'
},
'typed_pred': {
'?v1': 'type1',
'?v2': 'type1',
'?v3': 'object'
},
'shared_type_pred': {
'?v1': 'type1',
'?v2': 'type1',
'?v3': 'object'
}
})
def test_scan_tokens_problem(self):
parser = PDDL_Parser()
self.assertEqual(parser.scan_tokens('examples/dinner/pb1.pddl'), [
'define', ['problem', 'pb1'], [':domain', 'dinner'],
[':init', ['garbage'], ['clean'], ['quiet']],
[':goal', ['and', ['dinner'], ['present'], ['not', ['garbage']]]]
])
def test_parse_undefined_types(self):
parser = PDDL_Parser()
parser.types = {}
parser.parse_types(['location', 'pile', 'robot', 'crane', 'container'])
self.assertEqual(
parser.types,
{'object': ['location', 'pile', 'robot', 'crane', 'container']})
def test_parse_problem(self):
parser = PDDL_Parser()
parser.parse_domain('examples/dinner/dinner.pddl')
parser.parse_problem('examples/dinner/pb1.pddl')
self.assertEqual(parser.problem_name, 'pb1')
self.assertEqual(parser.objects, {})
self.assertEqual(parser.state, [['garbage'],['clean'],['quiet']])
self.assertEqual(parser.positive_goals, [['dinner'], ['present']])
self.assertEqual(parser.negative_goals, [['garbage']])
def __init__(self, domainfile, problemfile):
self.parser_help = PDDL_Parser()
self.parser_help.parse_domain(domainfile)
self.parser_help.parse_problem(problemfile)
self.domprob = DomainProblem(domainfile, problemfile)
self.current_state = None # State object
self.pos_goal = None # tuple of literals that need to be true at goal
self.neg_goal = None # tuple of literals that need to be false at goal
self.action_dic = None # list of actions
self.objects = None # list of world objects
self.reversed_objects = None # for type of object, list of instances
self.parser()
def test_parse_defined_types(self):
parser = PDDL_Parser()
parser.types = {}
parser.parse_types([
'place', 'locatable', 'level', '-', 'object', 'depot', 'market',
'-', 'place', 'truck', 'goods', '-', 'locatable'
])
self.assertEqual(
parser.types, {
'object': ['place', 'locatable', 'level'],
'place': ['depot', 'market'],
'locatable': ['truck', 'goods']
})
def test_parse_domain(self):
parser = PDDL_Parser()
parser.parse_domain('dinner/dinner.pddl')
self.assertEqual(parser.domain_name, 'dinner')
self.assertEqual(parser.requirements, [':strips'])
self.assertEqual(parser.types, [])
self.assertEqual(parser.actions, [
Action('cook', [], [['clean']], [], [['dinner']], []),
Action('wrap', [], [['quiet']], [], [['present']], []),
Action('carry', [], [['garbage']], [], [],
[['garbage'], ['clean']]),
Action('dolly', [], [['garbage']], [], [],
[['garbage'], ['quiet']])
])
def test_parse_problem(self):
def frozenset_of_tuples(data):
return frozenset([tuple(t) for t in data])
parser = PDDL_Parser()
parser.parse_domain('examples/dinner/dinner.pddl')
parser.parse_problem('examples/dinner/pb1.pddl')
self.assertEqual(parser.problem_name, 'pb1')
self.assertEqual(parser.objects, {})
self.assertEqual(
parser.state,
frozenset_of_tuples([['garbage'], ['clean'], ['quiet']]))
self.assertEqual(parser.positive_goals,
frozenset_of_tuples([['dinner'], ['present']]))
self.assertEqual(parser.negative_goals,
frozenset_of_tuples([['garbage']]))
def __init__(self, domain, problem, logfile='/dev/null'):
# Parser
self.parser = PDDL_Parser()
self.parser.parse_domain(domain)
self.parser.parse_problem(problem)
# Parsed data
self.state = self.parser.state
self.goal_pos = self.parser.positive_goals
self.goal_not = self.parser.negative_goals
self.history = []
self.movelog = []
self.logfile = logfile
self.planner = Planner()
# Do nothing
if self.planner.applicable(self.state, self.goal_pos, self.goal_not):
print('Puzzle is already solved! Double-check your problem file!')
def constraints(domain, problem):
gate_list = []
# Parser
parser = PDDL_Parser()
parser.parse_domain(domain)
parser.parse_problem(problem)
state = parser.state
# Initial state gate:
initial_gate = list(state)
#initial_gate = refine_gate(initial_gate)
#print(initial_gate)
goal_pos = parser.positive_goals
goal_not = parser.negative_goals
goal_gate = [goal_pos, goal_not]
#goal_gate = [refine_gate(goal_pos), refine_gate(goal_not)]
#print(goal_gate)
#for act in parser.actions:
# #print(act)
# act.positive_preconditions = refine_gate(act.positive_preconditions)
# act.negative_preconditions = refine_gate(act.negative_preconditions)
# act.add_effects = refine_gate(act.add_effects)
# act.del_effects = refine_gate(act.del_effects)
# #print(act)
action_list = []
# Grounding process
ground_actions = []
for action in parser.actions:
for act in action.groundify(parser.objects):
ground_actions.append(act)
# Appending grounded actions:
for act in ground_actions:
action_list.append(act)
#print(act)
# Appending to one list:
gate_list.append(initial_gate)
gate_list.append(goal_gate)
gate_list.extend(action_list)
return gate_list
def test_parse_objects(self):
parser = PDDL_Parser()
parser.types = {}
parser.objects = {}
parser.parse_types(
['airplane', 'segment', 'direction', 'airplanetype', 'a'])
parser.parse_objects([
'b', '-', 'a', 'a', '-', 'a', 'north', 'south', '-', 'direction',
'light', 'medium', 'heavy', '-', 'airplanetype', 'element1', '-',
'object', 'seg_pp_0_60', 'seg_ppdoor_0_40', '-', 'segment',
'airplane_CFBEG', '-', 'airplane', 'element2'
], 'test')
self.assertEqual(
parser.objects, {
'a': ['b', 'a'],
'object': ['element1', 'element2'],
'direction': ['north', 'south'],
'airplanetype': ['light', 'medium', 'heavy'],
'segment': ['seg_pp_0_60', 'seg_ppdoor_0_40'],
'airplane': ['airplane_CFBEG']
})
def construct(self, domain, problem):
# Parser
parser = PDDL_Parser()
parser.parse_domain(domain)
parser.parse_problem(problem)
# Parsed data
state = parser.state
initial_state = convert(state)
goal_pos = parser.positive_goals
goal_not = parser.negative_goals
# Do nothing
if self.applicable(state, goal_pos, goal_not):
return []
# Grounding process
ground_actions = []
for action in parser.actions:
for act in action.groundify(parser.objects):
ground_actions.append(act)
# Search
visited = [state]
need_visit = [state]
transitions = dict()
while need_visit:
state = need_visit.pop(0)
transitions[convert(state)] = dict()
for act in ground_actions:
if self.applicable(state, act.positive_preconditions,
act.negative_preconditions):
new_state = self.apply(state, act.add_effects,
act.del_effects)
if new_state not in visited:
visited.append(new_state)
need_visit.append(new_state)
transitions[convert(state)][act.name] = convert(
new_state)
return [transitions, initial_state]
