Ejemplo n.º 1
0
def parse_domain(domain_pddl):
  iterator = iter(domain_pddl)

  the_functions = []
  the_axioms = []
  the_actions = []
  the_durative_actions = []

  assert iterator.next() == "define"
  domain_line = iterator.next()
  assert domain_line[0] == "domain" and len(domain_line) == 2
  yield domain_line[1]

  opt_requirements = iterator.next()
  if opt_requirements[0] == ":requirements":
    yield Requirements(opt_requirements[1:])
    opt_types = iterator.next()
  else:
    yield Requirements([":strips"])
    opt_types = opt_requirements

  the_types = [pddl_types.Type("object")]
  if opt_types[0] == ":types":
    the_types.extend(pddl_types.parse_typed_list(opt_types[1:],
                                                 constructor=pddl_types.Type))
    opt_constants = iterator.next()
  else:
    opt_constants = opt_types

  if opt_constants[0] == ":constants":
    yield pddl_types.parse_typed_list(opt_constants[1:],types=the_types)
    pred = iterator.next()
  else:
    yield []
    pred = opt_constants

  the_predicates = []
  if pred[0] == ":predicates":
    the_predicates =  ([predicates.Predicate.parse(entry) for entry in pred[1:]] +
         [predicates.Predicate("=",
                               [pddl_types.TypedObject("?x", "object"),
                                pddl_types.TypedObject("?y", "object")])])
  else:
    the_predicates = [predicates.Predicate("=",
                                [pddl_types.TypedObject("?x", "object"),
                                 pddl_types.TypedObject("?y", "object")])]
    parse_domain_structure(pred,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)

  for entry in iterator:
    parse_domain_structure(entry,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)

  pddl_types.set_supertypes(the_types)
  the_types = [type for type in the_types if type.supertype_names != [] or type.name == "object"]
  yield the_predicates
  yield the_types
  yield the_functions
  yield the_actions
  yield the_durative_actions
  yield the_axioms
Ejemplo n.º 2
0
def parse_domain(domain_pddl):
  iterator = iter(domain_pddl)
  
  the_functions = []
  the_axioms = []
  the_actions = []
  the_durative_actions = []

  assert iterator.next() == "define"
  domain_line = iterator.next()
  assert domain_line[0] == "domain" and len(domain_line) == 2
  yield domain_line[1]

  opt_requirements = iterator.next()
  if opt_requirements[0] == ":requirements":
    yield Requirements(opt_requirements[1:])
    opt_types = iterator.next()
  else:
    yield Requirements([":strips"])
    opt_types = opt_requirements

  the_types = [pddl_types.Type("object")]
  if opt_types[0] == ":types":
    the_types.extend(pddl_types.parse_typed_list(opt_types[1:],
                                                 constructor=pddl_types.Type))
    opt_constants = iterator.next()
  else:
    opt_constants = opt_types

  if opt_constants[0] == ":constants":
    yield pddl_types.parse_typed_list(opt_constants[1:],types=the_types)
    pred = iterator.next()
  else:
    yield []
    pred = opt_constants

  the_predicates = []
  if pred[0] == ":predicates":
    the_predicates =  ([predicates.Predicate.parse(entry) for entry in pred[1:]] +
         [predicates.Predicate("=",
                               [pddl_types.TypedObject("?x", "object"),
                                pddl_types.TypedObject("?y", "object")])])
  else:
    the_predicates = [predicates.Predicate("=",
                                [pddl_types.TypedObject("?x", "object"),
                                 pddl_types.TypedObject("?y", "object")])]
    parse_domain_structure(pred,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)

  for entry in iterator:
    parse_domain_structure(entry,the_functions,the_axioms,the_actions,the_durative_actions,the_types,the_predicates)

  pddl_types.set_supertypes(the_types)
  the_types = [type for type in the_types if type.supertype_names != [] or type.name == "object"]
  yield the_predicates
  yield the_types
  yield the_functions
  yield the_actions
  yield the_durative_actions
  yield the_axioms
Ejemplo n.º 3
0
def parse_domain(domain_pddl):
  iterator = iter(domain_pddl)

  assert iterator.next() == "define"
  domain_line = iterator.next()
  assert domain_line[0] == "domain" and len(domain_line) == 2
  yield domain_line[1]

  opt_requirements = iterator.next()
  if opt_requirements[0] == ":requirements":
    yield Requirements(opt_requirements[1:])
    opt_types = iterator.next()
  else:
    yield Requirements([":strips"])
    opt_types = opt_requirements

  the_types = [pddl_types.Type("object")]
  if opt_types[0] == ":types":
    the_types.extend(pddl_types.parse_typed_list(opt_types[1:],
                                                 constructor=pddl_types.Type))
    opt_constants = iterator.next()
  else:
    opt_constants = opt_types
  pddl_types.set_supertypes(the_types)
  # for type in the_types:
  #   print repr(type), type.supertype_names
  yield the_types

  if opt_constants[0] == ":constants":
    yield pddl_types.parse_typed_list(opt_constants[1:])
    pred = iterator.next()
  else:
    yield []
    pred = opt_constants

  assert pred[0] == ":predicates"
  print pred
  yield ([predicates.Predicate.parse(entry) for entry in pred[1:]] +
         [predicates.Predicate("=",
                               [pddl_types.TypedObject("?x", "object"),
                                pddl_types.TypedObject("?y", "object")])])
  
  opt_functions = iterator.next() #action costs enable restrictive version of fluents
  if opt_functions[0] == ":functions":
    the_functions = pddl_types.parse_typed_list(opt_functions[1:],
                                                constructor=functions.Function.parse_typed, functions=True)
    for function in the_functions:
      Task.FUNCTION_SYMBOLS[function.name] = function.type
    yield the_functions
    first_action = iterator.next()
  else:
    yield []
    first_action = opt_functions
  entries = [first_action] + [entry for entry in iterator]
  the_axioms = []
  the_actions = []
  for entry in entries:
    if entry[0] == ":derived":
      axiom = axioms.Axiom.parse(entry)
      the_axioms.append(axiom)
    else:
      action = actions.Action.parse(entry)
      the_actions.append(action)
  yield the_actions
  yield the_axioms
Ejemplo n.º 4
0
def parse_domain(domain_pddl):
    iterator = iter(domain_pddl)

    assert iterator.next() == "define"
    domain_line = iterator.next()
    assert domain_line[0] == "domain" and len(domain_line) == 2
    yield domain_line[1]

    ## We allow an arbitrary order of the requirement, types, constants,
    ## predicates and functions specification. The PDDL BNF is more strict on
    ## this, so we print a warning if it is violated.
    requirements = Requirements([":strips"])
    the_types = [pddl_types.Type("object")]
    constants, the_predicates, the_functions = [], [], []
    correct_order = [
        ":requirements", ":types", ":constants", ":predicates", ":functions"
    ]
    seen_fields = []
    for opt in iterator:
        field = opt[0]
        if field not in correct_order:
            first_action = opt
            break
        if field in seen_fields:
            raise SystemExit("Error in domain specification\n" +
                             "Reason: two '%s' specifications." % field)
        if (seen_fields and correct_order.index(seen_fields[-1]) >
                correct_order.index(field)):
            msg = "\nWarning: %s specification not allowed here (cf. PDDL BNF)" % field
            print >> sys.stderr, msg
        seen_fields.append(field)
        if field == ":requirements":
            requirements = Requirements(opt[1:])
        elif field == ":types":
            the_types.extend(
                pddl_types.parse_typed_list(opt[1:],
                                            constructor=pddl_types.Type))
        elif field == ":constants":
            constants = pddl_types.parse_typed_list(opt[1:])
        elif field == ":predicates":
            the_predicates = [
                predicates.Predicate.parse(entry) for entry in opt[1:]
            ]
            the_predicates += [
                predicates.Predicate("=", [
                    pddl_types.TypedObject("?x", "object"),
                    pddl_types.TypedObject("?y", "object")
                ])
            ]
        elif field == ":functions":
            the_functions = pddl_types.parse_typed_list(
                opt[1:],
                constructor=functions.Function.parse_typed,
                functions=True)
            for function in the_functions:
                Task.FUNCTION_SYMBOLS[function.name] = function.type
    pddl_types.set_supertypes(the_types)
    # for type in the_types:
    #   print repr(type), type.supertype_names
    yield requirements
    yield the_types
    yield constants
    yield the_predicates
    yield the_functions

    entries = [first_action] + [entry for entry in iterator]
    the_axioms = []
    the_actions = []
    for entry in entries:
        if entry[0] == ":derived":
            axiom = axioms.Axiom.parse(entry)
            the_axioms.append(axiom)
        else:
            action = actions.Action.parse(entry)
            the_actions.append(action)
    yield the_actions
    yield the_axioms