-
Notifications
You must be signed in to change notification settings - Fork 0
/
Planner.py
128 lines (94 loc) · 3.71 KB
/
Planner.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
# coding: utf-8
# In[1]:
import pyddl
# In[2]:
from collections import namedtuple
# In[3]:
# possible things to add:
# disjunctive goals
# disjunctive action preconditions
# In[4]:
class Predicate(namedtuple('Predicate',
['name', 'arg_names'])):
def __call__(self, *args):
return GroundedPredicate(self, args)
def condition(self, *args):
return ((self.name,)+tuple(args),)
def effect(self, *args):
return ((self.name,)+tuple(args),)
def neg(self):
return NegativePredicate(self.name, self.arg_names)
# In[5]:
class NegativePredicate(namedtuple('NegativePredicate',
['name', 'arg_names'])):
def __call__(self, *args):
return GroundedPredicate(self, args)
def condition(self, *args):
return ()
def effect(self, *args):
return (pyddl.neg(self.neg().effect(*args)[0]),)
def neg(self):
return Predicate(self.name, self.arg_names)
# In[6]:
class DualPredicate(namedtuple('DualPredicate',
['name', 'negative_name', 'arg_names'])):
def __call__(self, *args):
return GroundedPredicate(self, args)
def condition(self, *args):
return ((self.name,)+tuple(args),)
def effect(self, *args):
return (self.condition(*args)[0], pyddl.neg(self.neg().condition(*args)[0]))
def neg(self):
return DualPredicate(self.negative_name, self.name, self.arg_names)
# In[7]:
class PredicateDict:
def __init__(self):
self._predicates = {}
def add(self, predicate):
self._predicates[predicate.name] = predicate
if isinstance(predicate,DualPredicate):
self._predicates[predicate.neg().name] = predicate.neg()
def __getitem__(self, key):
return self._predicates[value]
# In[8]:
class GroundedPredicate(namedtuple('GroundedPredicate',
['predicate', 'parameters'])):
def condition(self):
return self.predicate.condition(*self.parameters)
def effect(self):
return self.predicate.effect(*self.parameters)
def neg(self):
return GroundedPredicate(self.predicate.neg(), self.parameters)
def translate(self):
# Predicate('brain_in',('brain_id','body_id'))('1','2').translate()
# '#[brain_id:1][body_id:2]brain_in#'
return '#{0}{1}#'.format(''.join(['[{0}:#{1}#]'.format(name,value)
for (name, value) in
zip(self.predicate.arg_names, self.parameters)]),
self.predicate.name)
def flatten(self, grammar, fmt='#{0}.capitalize#.', temp_rule='__x__'):
x = self.translate()
grammar.push_rules(temp_rule,x)
nonterminal = fmt.format(temp_rule)
r = grammar.flatten(nonterminal)
grammar.pop_rules(temp_rule)
return r
# In[9]:
def Action(name, parameters=(), preconditions=(), effects=(),
unique=False, no_permute=False):
return pyddl.Action(name=name,
parameters=tuple(parameters),
preconditions=sum((p.condition() for p in preconditions), ()),
effects=sum((e.effect() for e in effects), ()),
unique=unique, no_permute=no_permute)
# In[10]:
def _predicate(self):
return Predicate(name=self.name,
arg_names=self.arg_names)
pyddl.Action.predicate = _predicate
# In[11]:
def Problem(domain, objects, init=(), goal=()):
return pyddl.Problem(domain=domain,
objects=objects,
init=sum((i.condition() for i in init), ()),
goal=sum((g.condition() for g in goal), ()))