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 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 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 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 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'))