def parse_task(domain_pddl, task_pddl): domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, \ axioms, overalls = parse_domain_pddl(domain_pddl) frees = dict() frees = process_is_free_propositions(overalls, actions, predicates, predicate_dict) #add_overall_to_start_and_end(overalls, actions, predicates, predicate_dict) can_be_compressed = analyze_compressible(actions) actions = merge_actions(actions, can_be_compressed) task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_pddl( task_pddl, type_dict, predicate_dict, frees) assert domain_name == task_domain_name requirements = pddl.Requirements( sorted( set(domain_requirements.requirements + task_requirements.requirements))) objects = constants + objects check_for_duplicates( [o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects] return pddl.Task(domain_name, task_name, requirements, types, objects, predicates, functions, init, goal, actions, axioms, use_metric)
def task_from_domain_problem(domain, problem): # TODO: prune evaluation that aren't needed in actions #domain_name, domain_requirements, types, type_dict, constants, \ # predicates, predicate_dict, functions, actions, axioms = domain task_name, task_domain_name, task_requirements, objects, init, goal, use_metric, problem_pddl = problem assert domain.name == task_domain_name requirements = pddl.Requirements( sorted( set(domain.requirements.requirements + task_requirements.requirements))) objects = domain.constants + objects check_for_duplicates( [o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init.extend(pddl.Atom(EQ, (obj.name, obj.name)) for obj in objects) # TODO: optimistically evaluate (not (= ?o1 ?o2)) for fd_obj in objects: obj = obj_from_pddl(fd_obj.name) if obj.is_unique(): init.append(pddl.Atom(IDENTICAL, (fd_obj.name, fd_obj.name))) else: assert obj.is_shared() task = pddl.Task(domain.name, task_name, requirements, domain.types, objects, domain.predicates, domain.functions, init, goal, domain.actions, domain.axioms, use_metric) normalize.normalize(task) # task.add_axiom return task
def task_from_domain_problem(domain, problem, add_identical=True): # TODO: prune evaluation that aren't needed in actions #domain_name, domain_requirements, types, type_dict, constants, \ # predicates, predicate_dict, functions, actions, axioms = domain task_name, task_domain_name, task_requirements, objects, init, goal, use_metric, problem_pddl = problem assert domain.name == task_domain_name requirements = pddl.Requirements( sorted( set(domain.requirements.requirements + task_requirements.requirements))) objects = domain.constants + objects check_for_duplicates( [o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init.extend(pddl.Atom(EQ, (obj.name, obj.name)) for obj in objects) if add_identical: init.extend(get_identical_atoms(objects)) #print('{} objects and {} atoms'.format(len(objects), len(init))) task = pddl.Task(domain.name, task_name, requirements, domain.types, objects, domain.predicates, domain.functions, init, goal, domain.actions, domain.axioms, use_metric) normalize.normalize(task) # task.add_axiom return task
def parse_task(domain_pddl, task_pddl): # if DEBUG: # print("domain_pddl %s" % domain_pddl) # print("task_pddl %s" % task_pddl) domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict,\ functions, actions, axioms = parse_domain_pddl(domain_pddl) task_name, task_domain_name, task_requirements, objects, init, num_init, goal, metric \ = parse_task_pddl(task_pddl, type_dict, predicate_dict) # if DEBUG: # print("Init= %s"% init) if not domain_name == task_domain_name: msg = "\nWarning: Domain name in domain file %s differs from domain name in task file %s" % ( domain_name, task_domain_name) print(msg, file=sys.stderr) #assert domain_name == task_domain_name requirements = pddl.Requirements( sorted( set(domain_requirements.requirements + task_requirements.requirements))) objects = constants + objects check_for_duplicates( # This will remove duplicates now instead of outright aborting. objects, errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects] # print("parsing_funtions parse_task returns num_init", num_init) # for ini in num_init: # ini.dump() # print("parsing_funtions parse_task returns metric", metric) return pddl.Task(domain_name, task_name, requirements, types, objects, predicates, functions, init, num_init, goal, actions, axioms, metric)
def parse_task(domain_pddl, task_pddl): domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, axioms \ = parse_domain_pddl(domain_pddl) task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_pddl(task_pddl, type_dict, predicate_dict) assert domain_name == task_domain_name requirements = pddl.Requirements(sorted(set( domain_requirements.requirements + task_requirements.requirements))) objects = constants + objects check_for_duplicates( [o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") # init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects] return pddl.Task( domain_name, task_name, requirements, types, objects, predicates, functions, init, goal, actions, axioms, use_metric)
def task_from_domain_problem(domain, problem): # TODO: prune eval domain_name, domain_requirements, types, type_dict, constants, \ predicates, predicate_dict, functions, actions, axioms = domain task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = problem assert domain_name == task_domain_name requirements = pddl.Requirements(sorted(set(domain_requirements.requirements + task_requirements.requirements))) objects = constants + objects check_for_duplicates([o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init.extend(pddl.Atom(EQ, (obj.name, obj.name)) for obj in objects) task = pddl.Task(domain_name, task_name, requirements, types, objects, predicates, functions, init, goal, actions, axioms, use_metric) normalize.normalize(task) return task
def parse_task(domain_pddl, task_pddl, parser): if not parser: domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, axioms \ = parse_domain_pddl(domain_pddl) task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_pddl( task_pddl, type_dict, predicate_dict) else: # set files parser.set_files(domain_pddl, task_pddl) domain_name, domain_requirements, types, type_dict, constants, predicates, predicate_dict, functions, actions, axioms \ = parse_domain_custom(parser) task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task_custom( parser, type_dict, predicate_dict) # remove actions parser.remove_actions() # update domain parser.update_domain() assert domain_name == task_domain_name requirements = pddl.Requirements( sorted( set(domain_requirements.requirements + task_requirements.requirements))) objects = constants + objects check_for_duplicates( [o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init += [pddl.Atom("=", (obj.name, obj.name)) for obj in objects] return pddl.Task(domain_name, task_name, requirements, types, objects, predicates, functions, init, goal, actions, axioms, use_metric)
# static_predicates, reflexive_static_predicates = get_static_predicates(traces, predicates) ### LEARNING PROBLEM # The objects of the original domain for the learning task # is the union of all objects in the input traces objects = list() for trace in traces: objects.extend(trace.objects) objects = list(set(objects)) # Empty initial state for now init = [] # Empty goal for now goal = [] original_task = pddl.Task(domain_name, 'learning_problem', domain_requirements, types, objects, predicates, functions, init, goal, actions, axioms, True) learning_task = copy.deepcopy(original_task) learning_task.actions = [] ### LEARNING DOMAIN # Define "modeProg" predicate learning_task.predicates.append(pddl.predicates.Predicate("modeProg", [])) # Define "test" predicates for i in range(1, TOTAL_STEPS+2): learning_task.predicates.append(pddl.predicates.Predicate("test" + str(i), [])) # Define "step" domain type learning_task.types.append(pddl.pddl_types.Type("step", "None"))