pddl

pddl aims to be an unquestionable and complete parser for PDDL 3.1.

Install

• from source (master branch):

pip install git+https://github.com/whitemech/pddl.git

• or, clone the repository and install:

git clone https://github.com/whitemech/pddl.git
cd pddl
pip install .

Quickstart

You can use the pddl package in two ways: as a library, and as a CLI tool.

As a library

This is an example of how you can build a PDDL domain or problem programmatically:

from pddl.logic import Predicate, constants, variables
from pddl.core import Domain, Problem, Action, Requirements
from pddl.formatter import domain_to_string, problem_to_string

# set up variables and constants
x, y, z = variables("x y z", types=["type_1"])
a, b, c = constants("a b c", types=["type_1"])

# define predicates
p1 = Predicate("p1", x, y, z)
p2 = Predicate("p2", x, y)

# define actions
a1 = Action(
    "action-1",
    parameters=[x, y, z],
    precondition=p1(x, y, z) & ~p2(y, z),
    effect=p2(y, z)
)

# define the domain object.
requirements = [Requirements.STRIPS, Requirements.TYPING]
domain = Domain("my_domain",
       requirements=requirements,
       types=["type_1"],
       constants=[a, b, c],
       predicates=[p1, p2],
       actions=[a1])

print(domain_to_string(domain))

that gives:

(define (domain my_domain)
    (:requirements :strips :typing)
    (:types type_1)
    (:constants a b c)
    (:predicates (p1 ?x ?y ?z) (p2 ?x ?y))
    (:actions
        (action-1
            :parameters (?x ?y ?z)
            :precondition (and (p1 ?x ?y ?z) (not (p2 ?y ?z)))
            :effect (p2 ?y ?z)
        )
    )
)

As well as a PDDL problem:

problem = Problem(
    "problem-1",
    domain=domain,
    requirements=requirements,
    objects=[a, b, c],
    init=[p1(a, b, c), ~p2(b, c)],
    goal=p2(b, c)
)
print(problem_to_string(problem))

Output:

(define (problem problem-1)
    (:domain my_domain)
    (:requirements :strips :typing)
    (:objects a b c)
    (:init (not (p2 b c)) (p1 a b c))
    (:goal (p2 b c))
)

As CLI tool

The package can also be used as a CLI tool. Supported commands are:

• pddl domain FILE: validate a PDDL domain file, and print it formatted.
• pddl problem FILE: validate a PDDL problem file, and print it formatted.

Features

Supported PDDL 3.1 requirements:

• :strips
• :typing
• :negative-preconditions
• :disjunctive-preconditions
• :equality
• :existential-preconditions
• :universal-preconditions
• :quantified-preconditions
• :conditional-effects
• :fluents
• :numeric-fluents
• :non-deterministic (see 6th IPC: Uncertainty Part)
• :adl
• :durative-actions
• :duration-inequalities
• :derived-predicates
• :timed-initial-literals
• :preferences
• :constraints
• :action-costs

Development

If you want to contribute, here's how to set up your development environment.

• Install Pipenv
• Clone the repository: git clone https://github.com/whitemech/pddl.git && cd pddl
• Install development dependencies: pipenv shell --python 3.7 && pipenv install --dev

Tests

To run tests: tox

To run only the code tests: tox -e py37

To run only the code style checks: tox -e flake8

Docs

To build the docs: mkdocs build

To view documentation in a browser: mkdocs serve and then go to http://localhost:8000

Authors

• Marco Favorito
• Francesco Fuggitti

License

pddl is released under the GNU Lesser General Public License v3.0 or later (LGPLv3+).

Copyright 2021 WhiteMech

Change Log

0.1.0 (2021-06-21)

The first official release of pddl.

Main features:

• Specify PDDL domains and problems programmatically.
• Parsing for PDDL domains and problems.

0.0.1 (2020-07-30)

• First commit on the package.