planning-machine 0.1__py3-none-any.whl

planning_machine/__init__.py

@@ -0,0 +1,4 @@
+from .yaml_parser import YAML2PDDL
+from .report import PlanReport
+from .lib import PlanningMachine
+from .pddl_parser import PDDL2YAML

planning_machine/lib.py

@@ -0,0 +1,148 @@
+import docker
+import tempfile
+import os
+
+from planning_machine import YAML2PDDL
+from planning_machine import PlanReport
+
+class PlanningMachine:
+    def __init__(self, planner: str = 'LAPKT'):
+        """Connect to the local Docker daemon.
+
+        Uses ``docker.from_env()`` to pick up connection details from
+        environment variables (e.g. ``DOCKER_HOST``), then sends a ping
+        to verify that the daemon is responsive.
+
+        Args:
+            planner: the planner docker image to be used in subsequent steps
+        
+        Raises:
+            RuntimeError: If the Docker daemon cannot be reached or the
+                ping fails.
+        """
+        self.planner = planner
+        try:
+            self.docker_client = docker.from_env()
+            self.docker_client.ping()
+        except Exception as e:
+            raise RuntimeError("[ERROR] Docker is not running") from e
+    def solve(self, domain_yaml_path: str, problem_yaml_path: str):
+        """Run the full planning pipeline and return a structured plan.
+
+        The method proceeds through five stages:
+
+        1. **Conversion to PDDL** --
+           A `YAML2PDDL` instance parses the two YAML files and returns
+           domain and problem PDDL strings.
+
+        2. **Temporary file setup** --
+           Both PDDL strings are written to a temporary directory that
+           will be bind-mounted into the Docker containers.
+
+        3. **Planning** --
+           Depending on the choice of planner in "self.planner", the
+           corresponding Docker image is used to solve the problem.
+           This produces a plan.pddl file in the temporary folder.
+
+        4. **Validation (VAL)** --
+           The ``claudiusk/val`` image is run against the domain,
+           problem, and plan files.  It produces a LaTeX report
+           (``report.tex``) that documents each plan step and its
+           effects.  The container is also removed after execution.
+
+        5. **Report extraction** --
+           A `PlanReport` instance parses ``report.tex`` and returns a
+           dictionary containing the plan length and a list of steps,
+           each annotated with its add and delete effects.
+
+        Args:
+            domain_yaml_path:  Path to the YAML domain file.
+            problem_yaml_path: Path to the YAML problem file.
+
+        Returns:
+            A dictionary produced by `PlanReport.report`, containing:
+
+            * ``plan_length`` (*int*) -- total number of plan steps.
+            * ``plan`` (*list*) -- one dict per step with keys ``step``,
+              ``action``, and ``effects`` (itself holding ``add`` and
+              ``del`` lists).
+
+            Returns ``None`` if `PlanReport.report` returns ``None``
+            (e.g. when the report file was not generated).
+        """
+        parser = YAML2PDDL()
+        domain_pddl, problem_pddl = parser.parse(domain_yaml_path, problem_yaml_path)
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            # write PDDL files to a temporary location
+            domain_pddl_path = os.path.join(tmpdirname, "domain.pddl")
+            problem_pddl_path = os.path.join(tmpdirname, "problem.pddl")
+            with open(domain_pddl_path, 'w+') as domain:
+                domain.write(domain_pddl)
+            with open(problem_pddl_path, 'w+') as problem:
+                problem.write(problem_pddl)
+            # Use Fast Downward to find a plan
+            if self.planner == "FD":
+                self.docker_client.containers.run(
+                    image="aibasel/downward",
+                    command=[
+                        "--plan-file", "/work/plan.pddl",
+                        "/work/domain.pddl",
+                        "/work/problem.pddl",
+                        "--search", "astar(blind())"
+                    ],
+                    volumes={
+                        str(tmpdirname): {
+                            "bind": "/work",
+                            "mode": "rw"
+                        }
+                    },
+                    working_dir="/work",
+                    remove=True,
+                )
+            # use LAPKT to find a plan
+            elif self.planner == "LAPKT":
+                self.docker_client.containers.run(
+                    image="lapkt/lapkt-public",
+                    command=[
+                        "bfs_f",
+                        "--domain", "/work/domain.pddl",
+                        "--problem", "/work/problem.pddl",
+                        "--output", "/work/plan.pddl"
+                    ],
+                    volumes={
+                        str(tmpdirname): {
+                            "bind": "/work",
+                            "mode": "rw"
+                        }
+                    },
+                    working_dir="/work",
+                    remove=True,
+                )
+            # use VAL image to extract plan justifications
+            report = self.docker_client.containers.run(
+                image="claudiusk/val",
+                command=[
+                    "-f",
+                    "/work/report",
+                    "/work/domain.pddl",
+                    "/work/problem.pddl",
+                    "/work/plan.pddl"
+                ],
+                volumes={
+                    str(tmpdirname): {
+                        "bind": "/work",
+                        "mode": "rw"
+                    }
+                },
+                working_dir="/work",
+                remove=True,
+            )
+            # post process the report into YAML
+            reporter = PlanReport()
+            report = reporter.report(os.path.join(tmpdirname, "report.tex"))
+            return report
+
+if __name__ == "__main__":
+    planner = PlanningMachine(planner='LAPKT')
+    plan = planner.solve(r"example\satellite\domain.yaml", r"example\satellite\problem.yaml")
+    print(plan)

planning_machine/mcp_server.py

@@ -0,0 +1,68 @@
+import os
+import yaml
+from pathlib import Path
+import sys
+
+from mcp.server import FastMCP
+
+from planning_machine import PlanningMachine
+
+# setting the master prompt
+script_dir = Path(__file__).parent
+instructions = (script_dir / "prompt.txt").read_text()
+
+mcp = FastMCP(
+    name="LogisticsMachine",
+    instructions=instructions,
+    host="0.0.0.0",
+    port=8000,
+    stateless_http=True
+)
+WORKSPACE = Path.home() / "workspace"
+
+@mcp.tool()
+def write_yaml_file(filename: str, content: str) -> str:
+    """Write a YAML planning file (domain or problem) to the workspace.
+
+    Creates or overwrites a file in the configured workspace directory
+    with the provided content. The workspace directory is created
+    automatically if it doesn't already exist.
+
+    Args:
+        filename: Name of the file to create (e.g. "domain.yaml").
+        content: The full YAML content to write to the file.
+    """
+    os.makedirs(WORKSPACE, exist_ok=True)
+    path = os.path.join(WORKSPACE, filename)
+    with open(path, "w") as f:
+        f.write(content)
+    return f"[SUCCESS] Written to {path}"
+
+@mcp.tool()
+def solve_workspace(domain_path: str, problem_path: str) -> str:
+    """Run the planner on a domain/problem pair from the workspace.
+
+    Loads the specified domain and problem YAML files from the workspace
+    directory, invokes the planning engine, and returns the resulting
+    plan serialized as a YAML string.
+
+    Args:
+        domain_path: Filename of the domain definition relative to the
+            workspace (e.g. "domain.yaml").
+        problem_path: Filename of the problem definition relative to the
+            workspace (e.g. "problem.yaml").
+
+    Returns:
+        The solution plan formatted as a YAML string, or an empty YAML
+        document if no plan was found.
+    """
+    planner = PlanningMachine()
+    domain = os.path.join(WORKSPACE, domain_path)
+    problem = os.path.join(WORKSPACE, problem_path)
+    return yaml.dump(planner.solve(domain, problem))
+
+if __name__ == "__main__":
+    if "--http" in sys.argv:
+        mcp.run(transport="streamable-http")
+    else:
+        mcp.run(transport="stdio")

planning_machine/pddl_parser.py

@@ -0,0 +1,129 @@
+from unified_planning.io import PDDLReader
+import yaml
+
+class PDDL2YAML:
+    DOMAIN_NAME = "DomainName"
+    def __init__(self):
+        pass
+    def _parse_domain(self, problem_pddl):
+        domain = {
+            "domain": PDDL2YAML.DOMAIN_NAME,
+            "types": {},
+            "predicates": {},
+            "actions": {},
+        }
+        for t in problem_pddl.user_types:
+            if t.father != None:
+                domain["types"][str(t.name)] = str(t.father)
+            else: 
+                domain["types"][str(t.name)] = "object"
+        for fluent in problem_pddl.fluents:
+            fluent_args = []
+            for param in fluent.signature:
+                fluent_args.append({param.name: param.type.name})
+                domain["predicates"][fluent.name] = fluent_args
+        for action in problem_pddl.actions:
+            result = {}
+            # Parameters
+            params = []
+            for param in action.parameters:
+                params.append({
+                    param.name: param.type.name
+                })
+            result["parameters"] = params
+            # Preconditions
+            prec = {"and": []}
+            for precondition in action.preconditions:
+                if precondition.is_and():
+                    for fluent in precondition.args:
+                        prec["and"].append({
+                            fluent.fluent().name: [str(arg) for arg in fluent.args]
+                        })
+                elif hasattr(precondition, 'fluent'):
+                    # Single atomic precondition (not wrapped in 'and')
+                    prec["and"].append({
+                        precondition.fluent().name: [str(arg) for arg in precondition.args]
+                    })
+            result["precondition"] = prec
+            # Effects
+            effs = {"and": []}
+            for effect in action.effects:
+                if effect.condition.is_true():
+                    # Unconditional effect
+                    if effect.value.is_true():
+                        effs["and"].append({
+                            effect.fluent.fluent().name: [str(arg) for arg in effect.fluent.args]
+                        })
+                    else:
+                        effs["and"].append({
+                            'not': {
+                                effect.fluent.fluent().name: [str(arg) for arg in effect.fluent.args]
+                            }
+                        })                      
+                else:
+                    raise ValueError("Conditional effects are not supported.")
+            result["effect"] = effs
+            domain['actions'][action.name] = result
+        return domain
+    def _parse_problem(self, problem_pddl):
+        problem = {
+            "domain": PDDL2YAML.DOMAIN_NAME,
+            "problem": problem_pddl.name,
+            "objects": {},
+            "init": {},
+            "goal": {}
+        }
+
+        # Goal
+        goal = {}
+        for g in problem_pddl.goals:
+            if g.is_and():
+                for fluent in g.args:
+                    if fluent.fluent().name in goal:
+                        goal[fluent.fluent().name].append([str(arg) for arg in fluent.args])
+                    else:
+                        goal[fluent.fluent().name] = [[str(arg) for arg in fluent.args]]
+            elif hasattr(g, 'fluent'):
+                    # Single atomic goal (not wrapped in 'and')
+                    goal[g.fluent().name] = [[str(arg) for arg in g.args]]
+            else:
+                raise ValueError(f"{g} is not supported.")
+        problem["goal"] = goal
+
+        # Init: group atom args by predicate name
+        init: dict[str, list[list[str]]] = {}
+        for atom in problem_pddl.initial_values:
+            if problem_pddl.initial_values[atom].is_true():
+                pred = atom.fluent().name
+                args = [str(a) for a in atom.args]
+                init.setdefault(pred, []).append(args)
+        problem["init"] = init
+
+        # Objects: grouped by type name
+        objects: dict[str, list[str]] = {}
+        for obj in problem_pddl.all_objects:
+            type_name = str(obj.type.name)
+            objects.setdefault(type_name, []).append(str(obj.name))
+        problem["objects"] = objects
+        return problem
+    def parse(self, domain_path: str, problem_path: str):
+        '''
+        Args:
+            domain_path:  Path to the PDDL domain file.
+            problem_path: Path to the PDDL problem file.
+
+        Returns:
+            A 2-tuple ``(domain_yaml, problem_yaml)`` where each element
+            is a dictionary corresponding to the YAML output.
+        '''
+        reader = PDDLReader()
+        problem_pddl = reader.parse_problem(domain_path, problem_path)
+        return (self._parse_domain(problem_pddl), self._parse_problem(problem_pddl))
+
+if __name__ == "__main__":
+    parser = PDDL2YAML()
+    (domain_yaml, problem_yaml) = parser.parse("workdir/domain.pddl", "workdir/problem.pddl")
+    with open("from_pddl_domain.yaml", 'w+') as f:
+        yaml.safe_dump(domain_yaml, f, sort_keys=False)
+    with open("from_pddl_problem.yaml", 'w+') as f:
+        yaml.safe_dump(problem_yaml, f, sort_keys=False)

planning_machine/report.py

@@ -0,0 +1,94 @@
+import argparse
+import os
+import re
+import yaml
+
+class PlanReport:
+    def __init__(self) -> None:
+        pass
+    def report(self, tex_path: str):
+        """Parse a VAL LaTeX report and return a structured plan dictionary.
+
+        The method performs the following steps:
+
+        1. **Open** the ``.tex`` file and read its full content.
+        2. **Locate** the ``\\subsection{Plan}`` block and extract every
+           ``\\action{...}`` command to obtain the ordered list of plan
+           actions.
+        3. **Locate** the ``\\subsection{Plan Validation}`` block and
+           extract every ``\\atime{n}`` block.  Within each block,
+           ``\\adding{...}`` and ``\\deleting{...}`` commands are
+           collected as the step's positive and negative effects.
+        4. **Build** the result dictionary, replacing LaTeX-escaped
+           underscores (``\\_``) with plain underscores in all action
+           and effect strings.
+
+        Args:
+            tex_path: Filesystem path to the VAL LaTeX report (``.tex``).
+
+        Returns:
+            A dictionary with two keys:
+
+            * ``plan_length`` (*int*) -- the total number of plan steps.
+            * ``plan`` (*List[Dict]*) -- one entry per step, each
+              containing ``step`` (int), ``action`` (str), and
+              ``effects`` (dict with ``add`` and ``del`` string lists).
+
+            Returns ``None`` implicitly if *tex_path* does not point to
+            an existing file.
+
+        Raises:
+            FileNotFoundError: if `tex_path` does not point to a valid address.
+            RuntimeError: If the *Plan* subsection is missing.
+            RuntimeError: If the *Plan Validation* subsection is missing.
+            RuntimeError: If the number of extracted actions does not
+                match the number of effect blocks.
+        """
+        if os.path.isfile(tex_path):
+            with open(tex_path, 'r') as report_file:
+                # open the report file
+                content = report_file.read()
+                # extract content of subsection "Plan"
+                actions = re.search(r'\\subsection\{Plan\}(.*?)(?=\\subsection|\\section)', content, re.DOTALL)
+                # extract content of subsection "Plan Validation"
+                effects = re.search(r'\\subsection\{Plan Validation\}(.*?)(?=\\subsection|\\section)', content, re.DOTALL)
+                if not actions:
+                    raise RuntimeError("Could not find Plan section")
+                if not effects:
+                    raise RuntimeError("Could not find Plan Validation section")
+                else:
+                    # extract plan steps
+                    actions = re.findall(r'\\action\{([^}]+(?:\{[^}]*\}[^}]*)*)\}', actions.group(1))
+                    # extract step effects
+                    effects = re.findall(r'\\atime\{(\d+)\}(.*?)(?=\\atime|\Z)', effects.group(1), re.DOTALL)
+                    if len(actions) != len(effects):
+                        raise RuntimeError("Plan Actions and Effects does not have the same cardinality.")
+                    # Create the output
+                    plan = list()
+                    for action, (step, block) in zip(actions, effects):
+                        del_effs = re.findall(r'\\deleting\{([^}]+)\}', block)
+                        add_effs = re.findall(r'\\adding\{([^}]+)\}', block)
+                        plan.append({
+                                "step": int(step),
+                                "action": action.replace('\\_', '_'),
+                                "effects": {
+                                    "add": [add_eff.replace('\\_', '_') for add_eff in add_effs],
+                                    "del": [del_eff.replace('\\_', '_') for del_eff in del_effs],
+                                }
+                            }
+                        )
+                    result = {
+                        "plan_length": int(len(plan)),
+                        "plan": plan
+                    }
+                    return result
+        else:
+            raise FileNotFoundError
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Extract justification graph from VAL latex report.")
+    parser.add_argument("tex", help="Path to the report file.")
+    args = parser.parse_args()
+    report_generator = PlanReport()
+    report = report_generator.report(args.tex)
+    with open("plan.yaml", 'w+') as f:
+        yaml.dump(report, f, indent=4, sort_keys=False)

planning_machine/yaml_parser.py

@@ -0,0 +1,315 @@
+from collections import OrderedDict
+import yaml
+import argparse
+from unified_planning.model import *
+from unified_planning.shortcuts import *
+from unified_planning.io import PDDLWriter
+
+class YAML2PDDL:
+    """Convert a YAML-encoded planning domain and problem into PDDL."""
+    def __init__(self):
+        self.domain_name = None
+        self.types = None
+        self.predicates = None
+        self.actions = None
+    def _parse_domain(self, path: str) -> None:
+        """Read and parse a YAML domain file.
+
+        This is the top-level domain entry-point.  It opens the file at
+        *path*, deserialises the YAML content, and delegates to the
+        specialised helpers below:
+
+        * `_construct_type_hierarchy` -- optional; skipped if the YAML has
+          no ``types`` key.
+        * `_construct_predicates` -- required.
+        * `_construct_actions` -- required.
+
+        Args:
+            path: Filesystem path to the YAML domain file.
+
+        Raises:
+            SyntaxError: If the ``domain`` key is missing, or if
+                predicates / actions are not defined properly.
+        """
+        print(f"Opening domain {path}")
+        with open(path, 'r', encoding='utf-8') as domain:
+            domain = yaml.safe_load(domain)
+            try:
+                self.domain_name = domain["domain"]
+            except Exception as e:
+                raise SyntaxError("Expected keyword `domain`.") from e
+            # the domain can be untyped
+            if "types" in domain:
+                print("Extracting the type hierarchy...")
+                self._construct_type_hierarchy(domain["types"])
+            try:
+                print("Extracting predicates...")
+                self._construct_predicates(domain["predicates"])
+            except Exception as e:
+                raise SyntaxError("Predicates are not defined properly.") from e
+            try:
+                print("Extracting actions...")
+                self._construct_actions(domain["actions"])
+            except Exception as e:
+                raise SyntaxError("Actions are not defined properly.") from e
+    def _construct_type_hierarchy(self, type_dict: Dict[str, str]) -> None:
+        """Build the type hierarchy from the YAML ``types`` mapping.
+
+        Each key in *type_dict* is a child type name and its value is the
+        parent type name.  Parent types are created on-the-fly if they
+        have not been seen yet, ensuring the hierarchy is built
+        bottom-up regardless of declaration order.
+
+        The resulting mapping is stored in ``self.types``.
+
+        Args:
+            type_dict: A dict whose keys are type names and values are
+                their parent type names.
+                Example: ``{"truck": "vehicle", "vehicle": "object"}``
+        """
+        types = {}
+        for t, f in type_dict.items():
+            if f not in types:
+                types[f] = UserType(f)
+            types[t] = up.shortcuts.UserType(t, types[f])
+        self.types = types
+    # parses the predicates in the domain
+    def _construct_predicates(self, predicate_dict: Dict[str, List[Dict[str, str]]]) -> None:
+        """Build typed predicates from the YAML definition.
+
+        Each predicate is expected as a mapping from the predicate name to
+        a list of argument specs.  Every argument spec is itself a
+        single-entry dict ``{arg_name: arg_type}``.
+
+        The arguments are converted to ``Parameter`` objects (using types
+        from ``self.types``), and a ``Fluent`` with ``BoolType`` return
+        type is created for each predicate.
+
+        The resulting mapping is stored in ``self.predicates``.
+
+        Args:
+            predicate_dict: Mapping of predicate names to their argument
+                lists.
+                Example::
+                    {
+                        "at": [{"obj": "package"}, {"loc": "location"}],
+                        "connected": [{"from": "location"}, {"to": "location"}]
+                    }
+
+        Note:
+            Untyped predicates are not yet supported (see TODO in source).
+        """
+        predicates = {}
+        for predicate in predicate_dict.items():
+            name = predicate[0]
+            args = predicate[1]
+            for i, arg in enumerate(args):
+                arg_name, arg_type = next(iter(arg.items()))
+                args[i] = Parameter(arg_name, self.types[arg_type])
+            fluent = Fluent(name, BoolType(), args)
+            predicates[name] = fluent
+        self.predicates = predicates
+        # TODO: construct untyped predicates
+    def _construct_actions(self, actions_dict: Dict[str, Dict[str, Any]]) -> None:
+        """Build actions from the YAML ``actions`` mapping.
+
+        For every action the method:
+
+        1. Extracts **parameters** -- an ordered mapping of parameter names
+           to their types.
+        2. Extracts **preconditions** -- currently only a top-level ``and``
+           conjunction is supported.  Each conjunct is a predicate applied
+           to the action's parameters.
+        3. Extracts **effects** -- supports two top-level forms:
+           - ``and``: a conjunction of positive or negated predicate
+             assignments.
+           - ``when``: a conditional effect with a ``condition`` /
+             ``then`` structure.
+
+        The resulting mapping is stored in ``self.actions``.
+
+        Args:
+            actions_dict: Mapping of action names to their bodies.  Each
+                body is a dict with keys ``parameters``, and optionally
+                ``precondition`` and ``effect``.
+
+        Raises:
+            AssertionError: If the precondition or effect block does not
+                have exactly one root key (e.g. ``and`` or ``when``).
+        """
+        actions = {}
+        for action_name, action_body in actions_dict.items():
+            params = OrderedDict()
+            for param in action_body["parameters"]:
+                param = next(iter(param.items()))
+                params[param[0]] = self.types[param[1]]
+            action = InstantaneousAction(action_name, params)
+            if "precondition" in action_body:
+                precs = action_body["precondition"]
+                # assert a unique root
+                assert 1 == len(precs)
+                
+                precs = precs["and"]
+                for pre in precs:
+                    predicate = next(iter(pre.items()))
+                    predicate_name = self.predicates[predicate[0]]
+                    predicate_args = [action.parameter(x) for x in predicate[1]]
+                    action.add_precondition(predicate_name(*predicate_args))
+            if "effect" in action_body:
+                effs = action_body["effect"]
+                # assert a unique root
+                assert 1 == len(effs)
+                
+                match next(iter(effs.keys())):
+                    case "and":
+                        for k in effs["and"]:
+                            string = next(iter(k.items()))
+                            if string[0] in self.predicates:
+                                predicate_name = self.predicates[string[0]]
+                                predicate_args = [action.parameter(x) for x in string[1]]
+                                action.add_effect(predicate_name(*predicate_args), True)
+                            elif string[0] == "not":
+                                predicate = next(iter(k["not"].items()))
+                                predicate_name = self.predicates[predicate[0]]
+                                predicate_args = [action.parameter(x) for x in predicate[1]]
+                                action.add_effect(predicate_name(*predicate_args), False)
+                            else:
+                                pass
+                    case "when":
+                        conditions = [
+                            self.predicates[name](*[action.parameter(arg) for arg in args])
+                            for cond in effs["when"]["condition"]
+                            for name, args in cond.items()
+                        ]
+                        cond_effs = effs["when"]["then"]
+                        for cond_eff in cond_effs:
+                            string = next(iter(cond_eff.items()))
+                            if string[0] in self.predicates:
+                                predicate_name = self.predicates[string[0]]
+                                predicate_args = [action.parameter(x) for x in string[1]]
+                                action.add_effect(predicate_name(*predicate_args), True, And(*conditions))
+                            elif string[0] == "not":
+                                predicate = next(iter(string[1].items()))
+                                predicate_name = self.predicates[predicate[0]]
+                                predicate_args = [action.parameter(x) for x in predicate[1]]
+                                action.add_effect(predicate_name(*predicate_args), False, And(*conditions))
+                            else:
+                                pass
+            print(f"\textracted {action_name}")
+            actions[action_name] = action
+        self.actions = actions
+    def reset(self) -> None:
+        """Reset all internal state so the instance can be reused.
+
+        After calling this every attribute is set back to ``None``,
+        exactly as if a fresh ``YAML2PDDL()`` had been constructed.
+        """
+        self.domain_name = None
+        self.types = None
+        self.predicates = None
+        self.actions = None
+    def _parse_problem(self, path: str) -> Problem:
+        """Read and parse a YAML problem file into a ``Problem`` instance.
+
+        The method expects that ``_parse_domain`` has already been called,
+        because it relies on ``self.domain_name``, ``self.types``,
+        ``self.predicates``, and ``self.actions``.
+
+        Parsing proceeds in four stages:
+
+        1. **Validation** -- checks that the ``domain`` key in the YAML problem
+           matches ``self.domain_name``.
+        2. **Objects** -- typed objects are created and added to the
+           problem.  Stored in ``self.objects`` for later reference.
+        3. **Initial state** -- each predicate grounding listed under
+           ``init`` is set to ``True``.
+        4. **Goal** -- each predicate grounding listed under ``goal`` is
+           added as a goal condition.
+
+        Args:
+            path: Path to the YAML problem file.
+
+        Returns:
+            A fully constructed ``Problem`` ready for PDDL serialisation.
+
+        Raises:
+            AssertionError: If the YAML does not contain a ``domain`` key
+                or if the domain name does not match the previously parsed
+                domain.
+        """
+        print(f"Opening problem {path}")
+        with open(path, 'r', encoding='utf-8') as problem_path:
+            problem_dict = yaml.safe_load(problem_path)
+            # assert the domain and problem match
+            assert "domain" in problem_dict
+            assert problem_dict["domain"] == self.domain_name
+            # Construct the UP problem
+            problem = Problem(problem_dict["problem"])
+            for fluent in self.predicates.values():
+                problem.add_fluent(fluent, default_initial_value=False)
+            problem.add_actions(self.actions.values())
+
+            # Extract objects from the problem
+            print("Extracting objects...")
+            if "objects" in problem_dict:
+                result = {}
+                for (type, objects) in problem_dict["objects"].items():
+                    for object in objects:
+                        result[object] = Object(object, self.types[type])
+                        problem.add_object(result[object])
+                self.objects = result
+            # extract the initial values
+            print("Extracting initial values...")
+            if "init" in problem_dict:
+                result = []
+                for (predicate, values) in problem_dict["init"].items():
+                    for value in values:
+                        object_values = [self.objects[o] for o in value] 
+                        problem.set_initial_value(self.predicates[predicate](*object_values), True)
+            # extract the goal condition
+            print("Extracting the goal condition...")
+            if "goal" in problem_dict:
+                for (predicate, values) in problem_dict["goal"].items():
+                    for value in values:
+                        object_values = [self.objects[o] for o in value] 
+                        problem.add_goal(self.predicates[predicate](*object_values))
+            return problem
+    def parse(self, domain_path: str, problem_path: str):
+        """Parse a YAML domain and problem, returning the corresponding PDDL strings.
+
+        This is the main public entry-point.  It:
+
+        1. Resets all internal state via `reset`.
+        2. Parses the domain file.
+        3. Parses the problem file (building a ``Problem`` model).
+        4. Uses ``PDDLWriter`` to serialise the model into two PDDL
+           strings.
+
+        Args:
+            domain_path:  Path to the YAML domain file.
+            problem_path: Path to the YAML problem file.
+
+        Returns:
+            A 2-tuple ``(domain_pddl, problem_pddl)`` where each element
+            is a string containing the corresponding PDDL output.
+        """
+        self.reset()
+        self._parse_domain(domain_path)
+        model = self._parse_problem(problem_path)
+        writer = PDDLWriter(model)
+        domainPDDL = writer.get_domain()
+        problemPDDL = writer.get_problem()
+        return (domainPDDL, problemPDDL)
+
+if __name__ == "__main__":
+    argparser = argparse.ArgumentParser("YAML2PDDL")
+    argparser.add_argument("domain", help="Path to the domain file in YAML")
+    argparser.add_argument("problem", help="Path to the problem file in YAML")
+    args = argparser.parse_args()
+    yaml_parser = YAML2PDDL()
+    (domain, problem) = yaml_parser.parse(args.domain, args.problem)
+    with open('domain.pddl', 'w+') as d_file:
+        d_file.write(domain)
+    with open('problem.pddl', 'w+') as p_file:
+        p_file.write(problem)
+    

planning_machine-0.1.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: planning-machine
+Version: 0.1
+License-File: LICENSE
+Requires-Dist: unified_planning>=1.3.0
+Requires-Dist: PyYAML>=6.0.3
+Requires-Dist: docker>=7.1.0
+Dynamic: license-file
+Dynamic: requires-dist

planning_machine-0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+planning_machine/__init__.py,sha256=n7Xj5dKv3ZhVZyTpls_i5IIHZCoM5vnLk5lstBCdrPg,133
+planning_machine/lib.py,sha256=BwKMTOk7adNNPYE-hH7JryNXZ3rdQBL4bnWXisoxEww,5852
+planning_machine/mcp_server.py,sha256=k9i8X0doP929R_hZBfnsKBw0eqD56NT9wBPxXffCq7w,2126
+planning_machine/pddl_parser.py,sha256=xbYrHVnbfVfDv-FibJa7MVr0UE8u2WxdaF6OhPcX8Vc,5202
+planning_machine/report.py,sha256=Z7PLYnGnuN_F3h8j66Y2NmWyBKipA_oXUuHwRncNfSI,4471
+planning_machine/yaml_parser.py,sha256=B04DfFdeEFAwdQXnOvwwr0k7C3blh1zRUG7CibRw59A,14194
+planning_machine-0.1.dist-info/licenses/LICENSE,sha256=TFXVt8crZDKEALiRIL8zP8QYQ3omIcxpRggpVGIRz4U,1082
+planning_machine-0.1.dist-info/METADATA,sha256=EJyKpcEsTTIY5VJ74USmhMK3FEtPjVC951Ndsz4Kxmg,231
+planning_machine-0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+planning_machine-0.1.dist-info/top_level.txt,sha256=nO3MD2rvLz14hEqPJgf56yYuNct7jOfvQTN09Rab9Rg,17
+planning_machine-0.1.dist-info/RECORD,,

planning_machine-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

planning_machine-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Learning Machines Pty Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

planning_machine-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+planning_machine