def createElementByType(parameter, decomp, p_type_dict):
if 'character' in parameter.types:
elm = Actor(typ='character', arg_name=parameter.name)
elm.p_types = p_type_dict[parameter]
elif 'actor' in parameter.types:
elm = Actor(typ='actor', arg_name=parameter.name)
elm.p_types = p_type_dict[parameter]
elif 'person' in parameter.types:
elm = Actor(typ='person', arg_name=parameter.name)
elm.p_types = p_type_dict[parameter]
elif 'arg' in p_type_dict[parameter] or 'item' in p_type_dict[
parameter] or 'place' in p_type_dict[parameter]:
arg_type = next(iter(parameter.types))
elm = Argument(typ=arg_type, arg_name=parameter.name)
elm.p_types = p_type_dict[parameter]
elif 'step' in parameter.types or 'step-s' in parameter.types or 'step-d' in parameter.types or 'step-c' in parameter.types:
elm = Operator(arg_name=parameter.name)
elif 'literal' in parameter.types or 'lit' in parameter.types:
elm = Literal(arg_name=parameter.name)
else:
# assume its type object, treat as Argument.
arg_type = next(iter(parameter.types))
elm = Argument(typ=arg_type, arg_name=parameter.name)
elm.p_types = p_type_dict[parameter]
# raise ValueError('parameter {} not story element'.format(parameter.name))
decomp.elements.add(elm)
return
def compile_domain_constants(items, obj_types):
constants = []
for i, const in enumerate(items):
ptypes = [const.typeName] + obj_types[const.typeName]
if const.typeName.lower() in CHAR_TYPES:
obj = Actor(name=const.name, typ=const.typeName, ptypes=ptypes)
else:
obj = Argument(name=const.name, typ=const.typeName, ptypes=ptypes)
constants.append(obj)
return constants
def compile_problem_objs(problem, obj_types):
objs = []
for i, object in enumerate(problem.objects):
ptypes = [object.typeName] + obj_types[object.typeName]
if object.typeName.lower() in CHAR_TYPES:
obj = Actor(name=object.name, typ=object.typeName, ptypes=ptypes)
else:
obj = Argument(name=object.name,
typ=object.typeName,
ptypes=ptypes)
objs.append(obj)
return objs
def convert_params(params, obj_types):
args = []
for i, parameter in enumerate(params):
ptype = parameter.types[0]
ptypes = [ptype] + obj_types[ptype]
# if it's a step-typed variable...
if "step" in ptypes:
arg = Operator(typ=ptype, stepnumber=-1, arg_name=parameter.name)
elif "literal" in ptypes:
arg = Literal(typ=ptype, arg_name=parameter.name, ptypes=ptypes)
elif "person" in ptypes or "character" in ptypes or "actor" in ptypes:
arg = Actor(typ=ptype, arg_name=parameter.name, ptypes=ptypes)
else:
arg = Argument(typ=ptype, arg_name=parameter.name, ptypes=ptypes)
args.append(arg)
return args
def evalActionParams(params, op_graph):
for i, parameter in enumerate(params):
# parameters are list
if 'character' in parameter.types:
arg = Actor(typ='character', arg_name=parameter.name)
op_graph.elements.add(arg)
elif 'actor' in parameter.types:
arg = Actor(typ='actor', arg_name=parameter.name)
op_graph.elements.add(arg)
elif 'person' in parameter.types:
arg = Actor(typ='person', arg_name=parameter.name)
op_graph.elements.add(arg)
else:
arg_type = next(iter(parameter.types))
if arg_type in {'lit', 'literal'}:
arg_type = 'Condition'
arg = Argument(typ=arg_type, arg_name=parameter.name)
op_graph.elements.add(arg)
op_graph.edges.add(Edge(op_graph.root, arg, i))
def problemToGraphs(problem):
"""
Returns a dictionary:
Keys: 'arg', 'init', 'goal'
Values: arg dictionary, (elements, edges), (elements, edges)
"""
Args = {
object.name: Argument(name=object.name, typ=object.typeName)
for object in problem.objects if not object.typeName.lower() in
{'character', 'actor', 'person', 'agent'}
}
Args.update({
object.name: Actor(typ=object.typeName.lower(), name=object.name)
for object in problem.objects if object.typeName.lower() in
{'character', 'actor', 'person', 'agent'}
})
goal_elements, goal_edges = getGoalSet(problem.goal.formula, Args)
goal_op = Operator(name='dummy_goal', stepnumber=1, num_args=0)
goal_graph = Action(name='dummy_goal', root_element=goal_op)
goal_graph.elements.update(goal_elements)
goal_graph.edges.update(goal_edges)
goal_graph.edges.update({
Edge(goal_op, goal_lit, 'precond-of')
for goal_lit in goal_elements if type(goal_lit) is Literal
})
init_op = Operator(name='dummy_init', stepnumber=0, num_args=0)
init_graph = Action(name='dummy_init', root_element=init_op)
for condition in problem.init.predicates:
lit = Literal(name=condition.name,
num_args=len(condition.parameters),
truth=True)
init_graph.elements.add(lit)
init_graph.edges.add(Edge(init_op, lit, 'effect-of'))
for i, p in enumerate(condition.parameters):
init_graph.edges.add(Edge(lit, Args[p], i))
return Args, init_graph, goal_graph
def addNegativeInitStates(formulae, initAction, init_effects, objects,
obj_types):
"""
for each predicate, satisfy arguments with objects. if literal not in initial state, add negation
"""
# collect initial states as tuples
ie_args_collection = [
Condition.subgraph(initAction, init_eff.sink)
for init_eff in init_effects
]
# for init_eff in init_effects:
# ie = Condition.subgraph(initAction, init_eff.sink)
# ie_args
# ie.updateArgs()
#
# ie_args = tuple([ie.name] + [arg.name for arg in ie.Args])
# ie_args_collection.append(ie_args)
# for each predicate formula in domain
for f, p in formulae:
if f.key in [
"distance-between", "arg", "less-than", "play", "play-seg",
"alu", "fol", "dur", "=", "obs-seg", "bel-alu", "obs-alu",
"obs-seg-alu", "obs", "obs-seg-cntg", "cntg", "effect",
"precond", "type", "linked", "linked-by", "<", "has-scale",
"has-angle", "has-fov", "has-orient", "preconds"
]:
continue
# create a predicate schema template
# if it's a step element or a plan element, then we need to consider all literal arguments
literal_template = Condition(
root_element=Literal(name=f.key, num_args=len(p.parameters)))
# get consistent-typed object signatures
cndts = [[obj for obj in objects if pchild.types[0] in obj.p_types]
for pchild in p.parameters]
# create tokens for variables in template
for i, p_arg, in enumerate(p.parameters):
if p_arg.types[0] == "person":
arg_token = Actor(arg_name=p_arg.name, typ=p_arg.types[0])
else:
arg_token = Argument(arg_name=p_arg.name, typ=p_arg.types[0])
literal_template.edges.add(
Edge(literal_template.root, arg_token, i))
literal_template.elements.add(arg_token)
param_tuples = [i for i in itertools.product(*cndts)]
# for each candidate signature
for pt in param_tuples:
# create negative literal to add as negative initial step effect
literal_template_copy = literal_template.deepcopy()
# lit = build_literal(f, initAction)
# literal_template_copy = Condition(root_element=Literal(name=f.key, num_args=len(p.parameters)))
build_literal(f, literal_template_copy)
literal_template_copy.root.truth = True
literal_template_copy.root.ID = uuid4()
literal_template_copy.elements = set(
list(literal_template_copy.elements))
literal_template_copy.edges = set(list(
literal_template_copy.edges))
literal_template_copy.updateArgs()
# swap arguments of template
literal_template_copy.replaceArgs(pt)
in_initial_state = False
for ie in ie_args_collection:
if ie.name != literal_template_copy.name:
continue
if ie.truth != literal_template_copy.truth:
continue
if len(ie.Args) != len(literal_template_copy.Args):
continue
if not has_equal_args(ie.Args, literal_template_copy.Args, ie,
literal_template_copy):
continue
in_initial_state = True
if in_initial_state:
continue
# ignore if discovered in initial state
# ie = tuple([f.key] + [t.name for t in list(pt)])
# if ie in ie_args_collection:
# continue
# now set it false
literal_template_copy.root.truth = False
# update initial Action
print("building ground literal\t{}".format(literal_template_copy))
initAction.elements.update(list(literal_template_copy.elements))
initAction.edges.update(list(literal_template_copy.edges))
initAction.edges.add(
Edge(initAction.root, literal_template_copy.root, 'effect-of'))