pddl-pyvalidator 0.1.0__tar.gz

pddl_pyvalidator-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SPL@BGU
+
+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.

pddl_pyvalidator-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pddl-pyvalidator
+Version: 0.1.0
+Summary: Pure Python PDDL plan validator
+License-Expression: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: unified-planning>=1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: copilot
+Requires-Dist: pddl-plus-parser; extra == "copilot"
+Dynamic: license-file

pddl_pyvalidator-0.1.0/pddl_pyvalidator.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pddl-pyvalidator
+Version: 0.1.0
+Summary: Pure Python PDDL plan validator
+License-Expression: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: unified-planning>=1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: copilot
+Requires-Dist: pddl-plus-parser; extra == "copilot"
+Dynamic: license-file

pddl_pyvalidator-0.1.0/pddl_pyvalidator.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+pyproject.toml
+pddl_pyvalidator.egg-info/PKG-INFO
+pddl_pyvalidator.egg-info/SOURCES.txt
+pddl_pyvalidator.egg-info/dependency_links.txt
+pddl_pyvalidator.egg-info/entry_points.txt
+pddl_pyvalidator.egg-info/requires.txt
+pddl_pyvalidator.egg-info/top_level.txt
+pyval/__init__.py
+pyval/cli.py
+pyval/diagnostics.py
+pyval/models.py
+pyval/numeric_tracker.py
+pyval/plan_simulator.py
+pyval/report_formatter.py
+pyval/syntax_checker.py
+pyval/validator.py
+tests/test_cli.py
+tests/test_integration.py
+tests/test_plan_simulator.py
+tests/test_report_formatter.py
+tests/test_syntax_checker.py
+tests/test_validator.py

pddl_pyvalidator-0.1.0/pddl_pyvalidator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pddl_pyvalidator-0.1.0/pddl_pyvalidator.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyval = pyval.cli:main

pddl_pyvalidator-0.1.0/pddl_pyvalidator.egg-info/requires.txt

@@ -0,0 +1,7 @@
+unified-planning>=1.1.0
+
+[copilot]
+pddl-plus-parser
+
+[dev]
+pytest>=7.0

pddl_pyvalidator-0.1.0/pddl_pyvalidator.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyval

pddl_pyvalidator-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pddl-pyvalidator"
+version = "0.1.0"
+description = "Pure Python PDDL plan validator"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "unified-planning>=1.1.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+copilot = ["pddl-plus-parser"]
+
+[project.scripts]
+pyval = "pyval.cli:main"

pddl_pyvalidator-0.1.0/pyval/__init__.py

@@ -0,0 +1,21 @@
+"""PyVAL — Pure Python PDDL plan validator."""
+
+from pyval.models import (
+    GoalResult,
+    NumericChange,
+    PreconditionFailure,
+    StateSnapshot,
+    StepResult,
+    ValidationResult,
+)
+from pyval.validator import PDDLValidator
+
+__all__ = [
+    "PDDLValidator",
+    "ValidationResult",
+    "StepResult",
+    "NumericChange",
+    "PreconditionFailure",
+    "GoalResult",
+    "StateSnapshot",
+]

pddl_pyvalidator-0.1.0/pyval/cli.py

@@ -0,0 +1,78 @@
+"""CLI entry point — mirrors VAL's Validate interface."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from pyval.report_formatter import format_json, format_plain_text, format_trajectory
+from pyval.validator import PDDLValidator
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="pyval",
+        description="PyVAL — Pure Python PDDL plan validator",
+    )
+    parser.add_argument(
+        "files",
+        nargs="+",
+        metavar="FILE",
+        help="PDDL files: domain [problem [plan]]",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Verbose output"
+    )
+    parser.add_argument(
+        "--json", action="store_true", help="Output as structured JSON"
+    )
+    parser.add_argument(
+        "--trajectory", action="store_true", help="Output numeric fluent trajectory"
+    )
+    parser.add_argument(
+        "--track",
+        action="append",
+        metavar="FLUENT",
+        help="Track specific numeric fluent (repeatable)",
+    )
+    parser.add_argument(
+        "--version", action="version", version="pyval 0.1.0"
+    )
+
+    args = parser.parse_args()
+    files = args.files
+
+    if len(files) > 3:
+        parser.error("Expected 1-3 files: domain [problem [plan]]")
+
+    validator = PDDLValidator()
+
+    if len(files) == 1:
+        result = validator.validate_syntax(domain_path=files[0])
+    elif len(files) == 2:
+        result = validator.validate_syntax(
+            domain_path=files[0], problem_path=files[1]
+        )
+    else:
+        result = validator.validate(
+            domain_path=files[0],
+            problem_path=files[1],
+            plan_path=files[2],
+            tracked_fluents=args.track,
+        )
+
+    # Output
+    import json
+
+    if args.json:
+        print(json.dumps(format_json(result), indent=2))
+    elif args.trajectory:
+        print(format_trajectory(result, tracked=args.track))
+    else:
+        print(format_plain_text(result, verbose=args.verbose))
+
+    sys.exit(0 if result.is_valid else 1)
+
+
+if __name__ == "__main__":
+    main()

pddl_pyvalidator-0.1.0/pyval/diagnostics.py

@@ -0,0 +1,253 @@
+"""Diagnostic message generation — precondition decomposition and goal checking."""
+
+from __future__ import annotations
+
+from unified_planning.model import FNode, OperatorKind
+
+from pyval.models import GoalResult, PreconditionFailure
+
+
+def decompose_preconditions(
+    action, parameters: tuple, state, problem
+) -> list[PreconditionFailure]:
+    """Walk action preconditions, evaluate each against state, return failures.
+
+    Parameters are the grounded objects substituted into the action schema.
+    """
+    failures: list[PreconditionFailure] = []
+    param_map = dict(zip(action.parameters, parameters))
+
+    for prec in action.preconditions:
+        _evaluate_expr(prec, state, param_map, failures)
+
+    return failures
+
+
+def check_goals(problem, state) -> list[GoalResult]:
+    """Evaluate all goals against a state, return results for each."""
+    results: list[GoalResult] = []
+    for goal in problem.goals:
+        _evaluate_goal(goal, state, results)
+    return results
+
+
+def _evaluate_expr(
+    expr: FNode,
+    state,
+    param_map: dict,
+    failures: list[PreconditionFailure],
+) -> None:
+    """Recursively evaluate a precondition expression, collecting failures."""
+    node_type = expr.node_type
+
+    if node_type == OperatorKind.AND:
+        for arg in expr.args:
+            _evaluate_expr(arg, state, param_map, failures)
+        return
+
+    if node_type == OperatorKind.OR:
+        # Check if any disjunct is satisfied
+        sub_failures: list[PreconditionFailure] = []
+        for arg in expr.args:
+            _evaluate_expr(arg, state, param_map, sub_failures)
+        if len(sub_failures) == len(expr.args):
+            # None satisfied — report the OR as failed
+            failures.append(PreconditionFailure(
+                expression=_expr_to_pddl(expr, param_map),
+                type="boolean",
+                current_values={},
+                explanation="None of the disjuncts are satisfied",
+            ))
+        return
+
+    if node_type == OperatorKind.NOT:
+        inner = expr.args[0]
+        grounded = _substitute(inner, param_map)
+        try:
+            val = state.get_value(grounded)
+            if val.is_true():
+                failures.append(PreconditionFailure(
+                    expression=_expr_to_pddl(expr, param_map),
+                    type="boolean",
+                    current_values={_expr_to_pddl(inner, param_map): True},
+                    explanation=f"{_expr_to_pddl(inner, param_map)} is true but should be false",
+                ))
+        except Exception:
+            pass
+        return
+
+    # Comparison operators: LE, LT, EQUALS (UPF normalizes >= to <= with swapped args)
+    if node_type in (OperatorKind.LE, OperatorKind.LT, OperatorKind.EQUALS):
+        _evaluate_comparison(expr, state, param_map, failures)
+        return
+
+    # Fluent expression (boolean)
+    if expr.is_fluent_exp():
+        grounded = _substitute(expr, param_map)
+        try:
+            val = state.get_value(grounded)
+            if val.is_false():
+                failures.append(PreconditionFailure(
+                    expression=_expr_to_pddl(expr, param_map),
+                    type="boolean",
+                    current_values={_expr_to_pddl(expr, param_map): False},
+                    explanation=f"{_expr_to_pddl(expr, param_map)} is not true in the current state",
+                ))
+        except Exception:
+            failures.append(PreconditionFailure(
+                expression=_expr_to_pddl(expr, param_map),
+                type="boolean",
+                current_values={},
+                explanation=f"Could not evaluate {_expr_to_pddl(expr, param_map)}",
+            ))
+        return
+
+
+def _evaluate_comparison(
+    expr: FNode,
+    state,
+    param_map: dict,
+    failures: list[PreconditionFailure],
+) -> None:
+    """Evaluate a numeric comparison, report failure with deficit."""
+    left_expr, right_expr = expr.args[0], expr.args[1]
+    left_grounded = _substitute(left_expr, param_map)
+    right_grounded = _substitute(right_expr, param_map)
+
+    try:
+        left_val = state.get_value(left_grounded).constant_value()
+        right_val = state.get_value(right_grounded).constant_value()
+    except Exception:
+        failures.append(PreconditionFailure(
+            expression=_expr_to_pddl(expr, param_map),
+            type="numeric",
+            current_values={},
+            explanation=f"Could not evaluate numeric comparison",
+        ))
+        return
+
+    op = expr.node_type
+    satisfied = _check_comparison(op, left_val, right_val)
+
+    if not satisfied:
+        current_values = {}
+        if left_expr.is_fluent_exp():
+            current_values[_expr_to_pddl(left_expr, param_map)] = left_val
+        if right_expr.is_fluent_exp():
+            current_values[_expr_to_pddl(right_expr, param_map)] = right_val
+
+        deficit = _compute_deficit(op, left_val, right_val)
+        op_symbol = _op_symbol(op)
+
+        failures.append(PreconditionFailure(
+            expression=_expr_to_pddl(expr, param_map),
+            type="numeric",
+            current_values=current_values,
+            explanation=(
+                f"Required: {_expr_to_pddl(left_expr, param_map)} "
+                f"{op_symbol} {_expr_to_pddl(right_expr, param_map)}"
+            ),
+            deficit=deficit,
+        ))
+
+
+def _check_comparison(op: OperatorKind, left: float, right: float) -> bool:
+    eps = 1e-6
+    if op == OperatorKind.LE:
+        return left <= right + eps
+    if op == OperatorKind.LT:
+        return left < right
+    if op == OperatorKind.EQUALS:
+        return abs(left - right) < eps
+    return False
+
+
+def _compute_deficit(op: OperatorKind, left: float, right: float) -> float:
+    if op == OperatorKind.LE:
+        return left - right
+    if op == OperatorKind.LT:
+        return left - right
+    if op == OperatorKind.EQUALS:
+        return abs(left - right)
+    return 0.0
+
+
+def _op_symbol(op: OperatorKind) -> str:
+    return {
+        OperatorKind.LE: "<=",
+        OperatorKind.LT: "<",
+        OperatorKind.EQUALS: "=",
+    }.get(op, "?")
+
+
+def _evaluate_goal(expr: FNode, state, results: list[GoalResult]) -> None:
+    """Evaluate a single goal expression, decomposing ANDs."""
+    if expr.node_type == OperatorKind.AND:
+        for arg in expr.args:
+            _evaluate_goal(arg, state, results)
+        return
+
+    try:
+        val = state.get_value(expr)
+        if val.is_bool_constant():
+            satisfied = val.is_true()
+            results.append(GoalResult(
+                expression=str(expr),
+                satisfied=satisfied,
+                current_values={str(expr): satisfied},
+            ))
+        else:
+            # Numeric goal (comparison)
+            satisfied = val.is_true() if val.is_bool_constant() else False
+            results.append(GoalResult(
+                expression=str(expr),
+                satisfied=satisfied,
+                current_values={str(expr): val.constant_value() if not val.is_bool_constant() else satisfied},
+            ))
+    except Exception:
+        # For complex expressions (comparisons), try to evaluate directly
+        satisfied = _evaluate_goal_expr(expr, state)
+        results.append(GoalResult(
+            expression=str(expr),
+            satisfied=satisfied,
+            current_values={},
+        ))
+
+
+def _evaluate_goal_expr(expr: FNode, state) -> bool:
+    """Evaluate a goal expression that may be a comparison."""
+    if expr.node_type in (OperatorKind.LE, OperatorKind.LT, OperatorKind.EQUALS):
+        try:
+            left_val = state.get_value(expr.args[0]).constant_value()
+            right_val = state.get_value(expr.args[1]).constant_value()
+            return _check_comparison(expr.node_type, left_val, right_val)
+        except Exception:
+            return False
+
+    if expr.node_type == OperatorKind.NOT:
+        inner = expr.args[0]
+        try:
+            val = state.get_value(inner)
+            return val.is_false()
+        except Exception:
+            return False
+
+    try:
+        val = state.get_value(expr)
+        return val.is_true()
+    except Exception:
+        return False
+
+
+def _substitute(expr: FNode, param_map: dict) -> FNode:
+    """Substitute action parameters with grounded objects in an expression."""
+    if not param_map:
+        return expr
+    return expr.substitute(param_map)
+
+
+def _expr_to_pddl(expr: FNode, param_map: dict | None = None) -> str:
+    """Convert an FNode expression to a PDDL-like string."""
+    if param_map:
+        expr = _substitute(expr, param_map)
+    return str(expr)

pddl_pyvalidator-0.1.0/pyval/models.py

@@ -0,0 +1,67 @@
+"""Data models for PyVAL validation results."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+
+@dataclass
+class NumericChange:
+    before: float
+    after: float
+
+
+@dataclass
+class PreconditionFailure:
+    expression: str
+    type: Literal["boolean", "numeric"]
+    current_values: dict[str, Any]
+    explanation: str
+    deficit: float | None = None
+
+
+@dataclass
+class GoalResult:
+    expression: str
+    satisfied: bool
+    current_values: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class StateSnapshot:
+    step: int
+    action: str | None
+    boolean_fluents: dict[str, bool] = field(default_factory=dict)
+    numeric_fluents: dict[str, float] = field(default_factory=dict)
+
+
+@dataclass
+class StepResult:
+    index: int
+    action: str
+    status: Literal["OK", "FAILED"]
+    boolean_changes: dict[str, bool] = field(default_factory=dict)
+    numeric_changes: dict[str, NumericChange] = field(default_factory=dict)
+    unsatisfied: list[PreconditionFailure] = field(default_factory=list)
+
+
+@dataclass
+class ValidationResult:
+    status: Literal["VALID", "INVALID", "SYNTAX_ERROR", "STRUCTURE_ERROR"]
+    is_valid: bool
+    phases: dict = field(default_factory=dict)
+    steps: list[StepResult] = field(default_factory=list)
+    trajectory: list[StateSnapshot] = field(default_factory=list)
+    numeric_trajectory: dict[str, list] = field(default_factory=dict)
+    failed_step: int | None = None
+    unsatisfied_goals: list[GoalResult] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+    def report(self, verbose: bool = False) -> str:
+        from pyval.report_formatter import format_plain_text
+        return format_plain_text(self, verbose=verbose)
+
+    def to_json(self) -> dict:
+        from pyval.report_formatter import format_json
+        return format_json(self)

pddl_pyvalidator-0.1.0/pyval/numeric_tracker.py

@@ -0,0 +1,77 @@
+"""Numeric fluent value tracking across plan steps."""
+
+from __future__ import annotations
+
+from unified_planning.model import Problem
+
+from pyval.models import StateSnapshot
+
+
+class NumericTracker:
+    """Tracks numeric (and boolean) fluent values across plan execution steps."""
+
+    def __init__(
+        self, problem: Problem, tracked_fluents: list[str] | None = None
+    ):
+        self._problem = problem
+        self._snapshots: list[StateSnapshot] = []
+
+        # Identify all fluent expressions from initial values
+        self._boolean_exprs = []
+        self._numeric_exprs = []
+        for fluent_expr, val in problem.initial_values.items():
+            if val.is_bool_constant():
+                self._boolean_exprs.append(fluent_expr)
+            else:
+                self._numeric_exprs.append(fluent_expr)
+
+        # Filter numeric fluents if tracking specific ones
+        if tracked_fluents is not None:
+            tracked_set = set(tracked_fluents)
+            self._numeric_exprs = [
+                e for e in self._numeric_exprs
+                if _fluent_display_name(e) in tracked_set
+            ]
+
+    def record(self, step: int, action: str | None, state) -> StateSnapshot:
+        """Record a state snapshot at a given step."""
+        boolean_fluents = {}
+        for expr in self._boolean_exprs:
+            val = state.get_value(expr)
+            boolean_fluents[str(expr)] = val.is_true()
+
+        numeric_fluents = {}
+        for expr in self._numeric_exprs:
+            val = state.get_value(expr)
+            numeric_fluents[str(expr)] = float(val.constant_value())
+
+        snapshot = StateSnapshot(
+            step=step,
+            action=action,
+            boolean_fluents=boolean_fluents,
+            numeric_fluents=numeric_fluents,
+        )
+        self._snapshots.append(snapshot)
+        return snapshot
+
+    def get_numeric_trajectory(self) -> dict[str, list[float]]:
+        """Return {fluent_name: [val_step0, val_step1, ...]}."""
+        if not self._snapshots:
+            return {}
+
+        # Use the first snapshot's numeric keys as the canonical set
+        keys = list(self._snapshots[0].numeric_fluents.keys())
+        trajectory: dict[str, list[float]] = {k: [] for k in keys}
+        for snap in self._snapshots:
+            for k in keys:
+                trajectory[k].append(snap.numeric_fluents.get(k, 0.0))
+        return trajectory
+
+
+def _fluent_display_name(expr) -> str:
+    """Extract a display name like 'fuel truck1' from a fluent expression."""
+    if expr.is_fluent_exp():
+        name = expr.fluent().name
+        args = " ".join(str(a) for a in expr.args)
+        return f"{name} {args}".strip() if args else name
+    return str(expr)