pypddl-datasets 0.0.1__tar.gz

pypddl_datasets-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+dist/
+*.egg-info/
+.venv/
+validate.error.json
+validate.sucess.json

pypddl_datasets-0.0.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: pypddl-datasets
+Version: 0.0.1
+Summary: Download PDDL planning benchmark suites: classical, numeric, profiling, and learning splits.
+Project-URL: Homepage, https://github.com/planning-and-learning/planning-benchmarks
+Author-email: Dominik Drexler <dominik.drexler@liu.se>
+License-Expression: GPL-3.0-or-later
+Requires-Python: >=3.10
+Requires-Dist: pooch>=1.8
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# planning-benchmarks
+
+PDDL planning benchmark suites — classical, numeric, profiling, and generated
+learning splits — published as the [`pypddl-datasets`](https://pypi.org/project/pypddl-datasets/)
+Python package. The package itself is small: benchmark data is downloaded on
+first use from the matching GitHub release and cached locally.
+
+## Usage
+
+```sh
+pip install pypddl-datasets
+```
+
+```python
+import pypddl_datasets as pb
+
+pb.list_suites()          # ['autoscale-agile-strips', ..., 'ipc-optimal-strips', ...]
+
+task = pb.fetch_task("classical/tests/gripper/test-1.pddl")
+task.domain_path          # .../gripper/domain.pddl   (correct also where instances
+task.task_path            # .../gripper/test-1.pddl    carry their own domain files)
+task.domain, task.problem # "classical/tests/gripper", "test-1.pddl" — display names
+
+domain = pb.fetch_domain("classical/downward-benchmarks/gripper")
+domain.path               # the domain directory
+domain.tasks              # list[Task], downloaded once and cached
+
+suite = pb.fetch_suite("ipc-optimal-strips")   # Suite(path, domains)
+for domain in suite.domains:
+    for task in domain.tasks:
+        run_planner(task.domain_path, task.task_path)
+```
+
+Most suites have a `-test` companion (e.g. `"ipc-optimal-strips-test"`) whose
+entries are one representative task per domain — a cheap smoke run before
+committing to a full suite. `pb.export_suite(suite, dest)` materializes a
+suite as a plain directory tree for non-Python tools.
+
+`pb.list_domains()` lists every individually fetchable domain. The cache
+location defaults to the platform cache dir and can be overridden with the
+`PYPDDL_DATASETS_CACHE` environment variable. On machines without internet
+access, set `PYPDDL_DATASETS_DATA` to a local checkout's `data/` directory
+and domains resolve there without downloading.
+
+## Repository layout
+
+- `src/pypddl_datasets/` — the package: fetch API, suite definitions, and the
+  instance generators (including the train/valid/test split configurations).
+- `data/` — all benchmark data, organized as `<formalism>/<collection>/<domain>`
+  (`classical/`, `numeric/`). Not shipped in the package; released as a single
+  archive on `data-v*` GitHub releases, downloaded and unpacked once per
+  machine on first use.
+- `data/classical/generated/<domain>-{train,valid,test}/` — fixed learning
+  splits produced by the generators. These committed instances are the
+  reproducibility contract; regenerate with
+  `python -m pypddl_datasets.generators.classical.<domain>.generate_instances`.
+- `scripts/package_data.py` — turns `data/` into the byte-reproducible
+  `data.tar.gz` release archive.
+- `validate.py` — parses every domain/problem with pypddl; must pass for a
+  data release to go out.
+
+## Releasing
+
+Data and package releases are decoupled; data releases are permanent
+(published package versions pin them by tag).
+
+1. **Data changed?** Tag and push `data-v<N>`. The workflow validates all
+   PDDL (aborting the release on failure), packages `data.tar.gz`, and
+   uploads it to the `data-v<N>` GitHub release. Copy the sha256 it prints
+   into `DATA_SHA256` (and bump `DATA_VERSION`) in
+   `src/pypddl_datasets/__init__.py`.
+2. **Package release:** bump `version` in `pyproject.toml`, tag and push
+   `v<version>`. The workflow verifies the tag matches the version and that
+   the pinned data release exists with the pinned hash, then builds and
+   publishes to PyPI via trusted publishing. No assets are uploaded — code
+   releases cost nothing in storage.
+
+## Contributing data
+
+Clone with Git LFS (large instances are LFS-tracked):
+
+```sh
+git lfs install
+git clone git@github.com:planning-and-learning/planning-benchmarks.git
+cd planning-benchmarks && git lfs pull
+```
+
+Track PDDL files larger than 10 MiB before staging them:
+
+```sh
+find data -type f -name '*.pddl' -size +10M -print0 | xargs -0 git lfs track --filename
+git add .gitattributes data
+```
+
+Domain directories must contain their `.pddl` files directly (that is how
+`scripts/package_data.py` discovers them), and directory names must not
+contain `--`. Run `pytest tests` to check suite definitions stay consistent.

pypddl_datasets-0.0.1/README.md

@@ -0,0 +1,97 @@
+# planning-benchmarks
+
+PDDL planning benchmark suites — classical, numeric, profiling, and generated
+learning splits — published as the [`pypddl-datasets`](https://pypi.org/project/pypddl-datasets/)
+Python package. The package itself is small: benchmark data is downloaded on
+first use from the matching GitHub release and cached locally.
+
+## Usage
+
+```sh
+pip install pypddl-datasets
+```
+
+```python
+import pypddl_datasets as pb
+
+pb.list_suites()          # ['autoscale-agile-strips', ..., 'ipc-optimal-strips', ...]
+
+task = pb.fetch_task("classical/tests/gripper/test-1.pddl")
+task.domain_path          # .../gripper/domain.pddl   (correct also where instances
+task.task_path            # .../gripper/test-1.pddl    carry their own domain files)
+task.domain, task.problem # "classical/tests/gripper", "test-1.pddl" — display names
+
+domain = pb.fetch_domain("classical/downward-benchmarks/gripper")
+domain.path               # the domain directory
+domain.tasks              # list[Task], downloaded once and cached
+
+suite = pb.fetch_suite("ipc-optimal-strips")   # Suite(path, domains)
+for domain in suite.domains:
+    for task in domain.tasks:
+        run_planner(task.domain_path, task.task_path)
+```
+
+Most suites have a `-test` companion (e.g. `"ipc-optimal-strips-test"`) whose
+entries are one representative task per domain — a cheap smoke run before
+committing to a full suite. `pb.export_suite(suite, dest)` materializes a
+suite as a plain directory tree for non-Python tools.
+
+`pb.list_domains()` lists every individually fetchable domain. The cache
+location defaults to the platform cache dir and can be overridden with the
+`PYPDDL_DATASETS_CACHE` environment variable. On machines without internet
+access, set `PYPDDL_DATASETS_DATA` to a local checkout's `data/` directory
+and domains resolve there without downloading.
+
+## Repository layout
+
+- `src/pypddl_datasets/` — the package: fetch API, suite definitions, and the
+  instance generators (including the train/valid/test split configurations).
+- `data/` — all benchmark data, organized as `<formalism>/<collection>/<domain>`
+  (`classical/`, `numeric/`). Not shipped in the package; released as a single
+  archive on `data-v*` GitHub releases, downloaded and unpacked once per
+  machine on first use.
+- `data/classical/generated/<domain>-{train,valid,test}/` — fixed learning
+  splits produced by the generators. These committed instances are the
+  reproducibility contract; regenerate with
+  `python -m pypddl_datasets.generators.classical.<domain>.generate_instances`.
+- `scripts/package_data.py` — turns `data/` into the byte-reproducible
+  `data.tar.gz` release archive.
+- `validate.py` — parses every domain/problem with pypddl; must pass for a
+  data release to go out.
+
+## Releasing
+
+Data and package releases are decoupled; data releases are permanent
+(published package versions pin them by tag).
+
+1. **Data changed?** Tag and push `data-v<N>`. The workflow validates all
+   PDDL (aborting the release on failure), packages `data.tar.gz`, and
+   uploads it to the `data-v<N>` GitHub release. Copy the sha256 it prints
+   into `DATA_SHA256` (and bump `DATA_VERSION`) in
+   `src/pypddl_datasets/__init__.py`.
+2. **Package release:** bump `version` in `pyproject.toml`, tag and push
+   `v<version>`. The workflow verifies the tag matches the version and that
+   the pinned data release exists with the pinned hash, then builds and
+   publishes to PyPI via trusted publishing. No assets are uploaded — code
+   releases cost nothing in storage.
+
+## Contributing data
+
+Clone with Git LFS (large instances are LFS-tracked):
+
+```sh
+git lfs install
+git clone git@github.com:planning-and-learning/planning-benchmarks.git
+cd planning-benchmarks && git lfs pull
+```
+
+Track PDDL files larger than 10 MiB before staging them:
+
+```sh
+find data -type f -name '*.pddl' -size +10M -print0 | xargs -0 git lfs track --filename
+git add .gitattributes data
+```
+
+Domain directories must contain their `.pddl` files directly (that is how
+`scripts/package_data.py` discovers them), and directory names must not
+contain `--`. Run `pytest tests` to check suite definitions stay consistent.

pypddl_datasets-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pypddl-datasets"
+version = "0.0.1"
+description = "Download PDDL planning benchmark suites: classical, numeric, profiling, and learning splits."
+readme = "README.md"
+license = "GPL-3.0-or-later"
+requires-python = ">=3.10"
+authors = [{ name = "Dominik Drexler", email = "dominik.drexler@liu.se" }]
+dependencies = [
+    "pooch>=1.8",
+]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/planning-and-learning/planning-benchmarks"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pypddl_datasets"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src", "scripts", "README.md"]

pypddl_datasets-0.0.1/scripts/package_data.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Package data/ into a single byte-reproducible data.tar.gz for upload as a
+GitHub release asset, and print its sha256 (to pin in the package)."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import tarfile
+from pathlib import Path
+
+LFS_POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1"
+
+
+def discover_domains(data_root: Path) -> list[Path]:
+    """A domain is a maximal directory containing at least one .pddl file directly."""
+    domains: list[Path] = []
+
+    def walk(directory: Path) -> None:
+        if any(child.suffix == ".pddl" for child in directory.iterdir() if child.is_file()):
+            domains.append(directory)
+            return
+        for child in directory.iterdir():
+            if child.is_dir():
+                walk(child)
+
+    walk(data_root)
+    return sorted(domains)
+
+
+def assert_no_lfs_pointers(data_root: Path) -> None:
+    for path in sorted(data_root.rglob("*")):
+        if path.is_file():
+            with path.open("rb") as stream:
+                if stream.read(len(LFS_POINTER_PREFIX)) == LFS_POINTER_PREFIX:
+                    raise SystemExit(f"LFS pointer file at {path}; run 'git lfs pull' first")
+
+
+def write_archive(data_root: Path, domains: list[Path], tar_path: Path) -> None:
+    """Byte-reproducible tar.gz (fixed metadata, no gzip timestamp): re-running
+    produces identical bytes, so the pinned sha256 stays valid. Only files
+    inside domain directories are included, so stray files under the data
+    root (e.g. tool outputs) can never leak into the archive."""
+    files = sorted(path for domain in domains for path in domain.rglob("*") if path.is_file())
+    with open(tar_path, "wb") as out:
+        with gzip.GzipFile(filename="", fileobj=out, mode="wb", mtime=0) as stream:
+            with tarfile.open(fileobj=stream, mode="w") as tar:
+                for path in files:
+                    info = tar.gettarinfo(path, arcname=path.relative_to(data_root).as_posix())
+                    info.uid = info.gid = 0
+                    info.uname = info.gname = ""
+                    info.mtime = 0
+                    info.mode = 0o644
+                    with path.open("rb") as source:
+                        tar.addfile(info, source)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data-root", type=Path, default=Path(__file__).resolve().parents[1] / "data")
+    parser.add_argument("--output", type=Path, default=Path("dist-data/data.tar.gz"))
+    parser.add_argument("--dry-run", action="store_true", help="List domains without writing anything.")
+    args = parser.parse_args()
+
+    domains = discover_domains(args.data_root)
+    if not domains:
+        raise SystemExit("no domains found")
+
+    if args.dry_run:
+        for domain in domains:
+            print(domain.relative_to(args.data_root).as_posix())
+        return 0
+
+    assert_no_lfs_pointers(args.data_root)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    write_archive(args.data_root, domains, args.output)
+    digest = hashlib.sha256(args.output.read_bytes()).hexdigest()
+    print(f"[package-data] {args.output} ({args.output.stat().st_size} bytes, {len(domains)} domains)")
+    print(f"[package-data] sha256: {digest}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pypddl_datasets-0.0.1/src/pypddl_datasets/__init__.py

@@ -0,0 +1,311 @@
+"""Download and cache the planning-benchmarks PDDL suites.
+
+Data is not shipped with this package: the first fetch downloads the pinned
+data release (one archive) and unpacks it into the local cache; every later
+call reuses that extraction. Override the cache location with the
+PYPDDL_DATASETS_CACHE environment variable, or point PYPDDL_DATASETS_DATA at
+a local checkout's data/ directory to use it directly (no download).
+"""
+
+from __future__ import annotations
+
+import functools
+import os
+import re
+import shutil
+from pathlib import Path
+
+import pooch
+
+from .suites import SUITES
+
+__version__ = "0.0.1"
+
+# The pinned data release: updated when a new data-v* release is cut
+# (its workflow prints the archive's sha256). Empty sha256 = development
+# build without a pinned release; only PYPDDL_DATASETS_DATA works then.
+DATA_VERSION = "data-v0.0.1"
+DATA_SHA256 = "54b80e0f8862e6401632a8cc5e7465e25ef7dfacad0823deeb809328aa6e10e3"
+
+_ARCHIVE = "data.tar.gz"  # single asset on the data release
+
+_CACHE = Path(os.environ.get("PYPDDL_DATASETS_CACHE", pooch.os_cache("pypddl-datasets"))) / DATA_VERSION
+
+_POOCH = pooch.create(
+    path=_CACHE,
+    base_url=f"https://github.com/planning-and-learning/planning-benchmarks/releases/download/{DATA_VERSION}/",
+    registry={_ARCHIVE: f"sha256:{DATA_SHA256}"},
+)
+
+
+class Task:
+    """A single planning task of a domain: display names (domain, problem),
+    the domain directory it belongs to, its domain file, and its problem
+    file."""
+
+    def __init__(self, domain: str, problem: str, path: Path, domain_path: Path, task_path: Path) -> None:
+        self._domain = domain
+        self._problem = problem
+        self._path = path
+        self._domain_path = domain_path
+        self._task_path = task_path
+
+    @property
+    def domain(self) -> str:
+        return self._domain
+
+    @property
+    def problem(self) -> str:
+        return self._problem
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    @property
+    def domain_path(self) -> Path:
+        return self._domain_path
+
+    @property
+    def task_path(self) -> Path:
+        return self._task_path
+
+    def __repr__(self) -> str:
+        return f"Task(domain={self._domain!r}, problem={self._problem!r})"
+
+
+class Domain:
+    """A benchmark domain: its directory and all of its tasks, each paired
+    with the correct domain file (which is per-instance in some collections,
+    e.g. airport)."""
+
+    def __init__(self, path: Path, tasks: list[Task]) -> None:
+        self._path = path
+        self._tasks = tasks
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    @property
+    def tasks(self) -> list[Task]:
+        return self._tasks
+
+    def __repr__(self) -> str:
+        return f"Domain(path={self._path!r}, tasks={self._tasks!r})"
+
+
+class Suite:
+    """A named benchmark suite: the root directory its domains live under
+    and the fetched domains themselves."""
+
+    def __init__(self, path: Path, domains: list[Domain]) -> None:
+        self._path = path
+        self._domains = domains
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    @property
+    def domains(self) -> list[Domain]:
+        return self._domains
+
+    def __repr__(self) -> str:
+        return f"Suite(path={self._path!r}, domains={self._domains!r})"
+
+
+def list_suites() -> list[str]:
+    """Names accepted by fetch_suite()."""
+    return sorted(SUITES)
+
+
+def list_domains() -> list[str]:
+    """Domain names accepted by fetch_domain() and fetch_task(); triggers the
+    one-time data download when no local data is configured. A domain is a
+    maximal directory containing .pddl files directly."""
+    root = _data_root()
+    domains: list[str] = []
+
+    def walk(directory: Path) -> None:
+        if any(child.suffix == ".pddl" for child in directory.iterdir() if child.is_file()):
+            domains.append(directory.relative_to(root).as_posix())
+            return
+        for child in directory.iterdir():
+            if child.is_dir():
+                walk(child)
+
+    walk(root)
+    return sorted(domains)
+
+
+def fetch_domain(name: str) -> Domain:
+    """Fetch a domain such as "classical/downward-benchmarks/gripper",
+    downloading it if necessary."""
+    directory = _fetch_directory(name)
+    return Domain(directory, _pair_tasks(name, directory))
+
+
+def fetch_task(name: str) -> Task:
+    """Fetch one task by its full name, e.g.
+    fetch_task("classical/tests/gripper/test-1.pddl"). The split between
+    domain and task file is unambiguous because domains are never nested."""
+    domain, task = _split_task_name(name)
+    directory = _fetch_directory(domain)
+    for candidate in _pair_tasks(domain, directory):
+        if task in (candidate.problem, candidate.task_path.name):
+            return candidate
+    raise KeyError(f"no task {task!r} in domain {domain!r}")
+
+
+def fetch_suite(suite: str) -> Suite:
+    """Fetch all entries of a named suite; see list_suites(). A plain domain
+    entry yields the whole domain; a "<domain>:<instance>" entry (as used by
+    the "-test" suites) yields a Domain restricted to that single task."""
+    if suite not in SUITES:
+        raise KeyError(f"unknown suite {suite!r}; see list_suites()")
+    domains = []
+    for entry in SUITES[suite]:
+        name, _, instance = entry.partition(":")
+        if instance:
+            task = fetch_task(f"{name}/{instance}")
+            domains.append(Domain(task.path, [task]))
+        else:
+            domains.append(fetch_domain(name))
+    return Suite(_data_root(), domains)
+
+
+def export_suite(suite: str, dest: str | Path) -> list[Path]:
+    """Copy all domains of a named suite into dest/<domain path>/, for tools
+    that expect benchmark files in a fixed directory tree."""
+    if suite not in SUITES:
+        raise KeyError(f"unknown suite {suite!r}; see list_suites()")
+    paths = []
+    for entry in SUITES[suite]:
+        name = entry.partition(":")[0]
+        target = Path(dest) / name
+        shutil.copytree(_fetch_directory(name), target, dirs_exist_ok=True)
+        paths.append(target)
+    return paths
+
+
+def _data_root() -> Path:
+    """The root directory the data lives under, downloading and unpacking the
+    pinned data release once if necessary.
+
+    If PYPDDL_DATASETS_DATA is set (e.g. to a local checkout's data/ dir on
+    machines without internet access), it is used directly instead."""
+    local_root = os.environ.get("PYPDDL_DATASETS_DATA")
+    if local_root:
+        return Path(local_root)
+    return _fetched_data_root()
+
+
+@functools.cache
+def _fetched_data_root() -> Path:
+    """Download and unpack the pinned data release; once per machine on disk,
+    and the (re-)verification of the cached archive once per process."""
+    if not DATA_SHA256:
+        raise KeyError(
+            "this pypddl-datasets build has no pinned data release (development "
+            "build); set PYPDDL_DATASETS_DATA to a local checkout's data/ "
+            "directory or install a released version"
+        )
+    _POOCH.fetch(_ARCHIVE, processor=pooch.Untar(extract_dir="data"))
+    return _CACHE / "data"
+
+
+def _split_task_name(name: str) -> tuple[str, str]:
+    """Split "classical/tests/gripper/test-1.pddl" into domain and task part.
+    Unique because domain directories are maximal (never nested)."""
+    root = _data_root()
+    parts = name.split("/")
+    for index in range(1, len(parts)):
+        domain = "/".join(parts[:index])
+        directory = root / domain
+        if directory.is_dir() and any(directory.glob("*.pddl")):
+            return domain, "/".join(parts[index:])
+    raise KeyError(f"no domain found in task name {name!r}; see list_domains()")
+
+
+def _fetch_directory(name: str) -> Path:
+    """The local directory of a domain, downloading the data if necessary."""
+    path = _data_root() / name
+    if not path.is_dir() or not any(path.glob("*.pddl")):
+        raise KeyError(f"unknown domain {name!r}; see list_domains()")
+    return path
+
+
+# Domain/problem pairing, following the same rules as the repository's validate.py.
+
+_DECLARATION = re.compile(r"\(\s*define\s*\(\s*(domain|problem)\s+([^\s()]+)", re.IGNORECASE)
+_DOMAIN_REFERENCE = re.compile(r"\(\s*:domain\s+([^\s()]+)", re.IGNORECASE)
+_HEAD_BYTES = 65536
+_LFS_POINTER_PREFIX = "version https://git-lfs.github.com/spec/v1"
+
+
+def _declaration(path: Path) -> tuple[str, str | None] | None:
+    """("domain"|"problem", declared name), classified by file content."""
+    with path.open("r", encoding="utf-8", errors="replace") as stream:
+        head = stream.read(_HEAD_BYTES)
+        if head.startswith(_LFS_POINTER_PREFIX):
+            # LFS pointer stub (checkout without `git lfs pull`): classify by
+            # file name so pairing matches a full checkout.
+            return ("domain" if "domain" in path.name else "problem", None)
+        text = re.sub(r";[^\n]*", "", head)
+        match = _DECLARATION.search(text)
+        if match is None and stream.read(1):
+            text = re.sub(r";[^\n]*", "", text + stream.read())
+            match = _DECLARATION.search(text)
+    return (match.group(1).lower(), match.group(2)) if match else None
+
+
+def _pair_tasks(domain: str, directory: Path) -> list[Task]:
+    domain_files: dict[Path, str] = {}
+    problem_files: list[Path] = []
+    for path in sorted(directory.rglob("*.pddl")):
+        declared = _declaration(path)
+        if declared is None:
+            continue
+        kind, name = declared
+        if kind == "domain":
+            domain_files[path] = name.lower() if name else ""
+        else:
+            problem_files.append(path)
+    return [
+        Task(
+            domain,
+            problem.relative_to(directory).as_posix(),
+            directory,
+            _resolve_domain(problem, domain_files, directory),
+            problem,
+        )
+        for problem in problem_files
+    ]
+
+
+def _resolve_domain(problem: Path, domain_files: dict[Path, str], root: Path) -> Path:
+    stem = problem.stem
+    candidates = (
+        "domain.pddl",
+        f"{stem}-domain{problem.suffix}",
+        f"{stem[:3]}-domain.pddl",
+        f"domain_{problem.name}",
+        f"domain-{problem.name}",
+    )
+    directory = problem.parent
+    while True:
+        for candidate in candidates:
+            if directory / candidate in domain_files:
+                return directory / candidate
+        if directory == root:
+            break
+        directory = directory.parent
+    if len(domain_files) == 1:
+        return next(iter(domain_files))
+    reference = _DOMAIN_REFERENCE.search(problem.read_text(encoding="utf-8", errors="replace"))
+    if reference:
+        matches = [path for path, name in domain_files.items() if name == reference.group(1).lower()]
+        if len(matches) == 1:
+            return matches[0]
+    raise ValueError(f"cannot resolve domain file for {problem}")

pypddl_datasets-0.0.1/src/pypddl_datasets/generators/README.md

@@ -0,0 +1,18 @@
+# Generators
+
+A fully Python variant of [AI-planning/pddl-generators](https://github.com/AI-Planning/pddl-generators).
+
+# Polynomially Recognizable Deadend Domains
+
+- barman
+- blocks_3
+- childsnack
+- hiking
+- hiking_binary
+- nomystery
+- parcprinter
+- rovers
+- schedule
+- tpp
+- spanner
+- woodworking

pypddl_datasets-0.0.1/src/pypddl_datasets/generators/__init__.py

@@ -0,0 +1 @@
+"""Planning benchmark generators."""

pypddl_datasets-0.0.1/src/pypddl_datasets/generators/classical/__init__.py

@@ -0,0 +1 @@
+"""Classical planning benchmark generators."""