parse.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# CAVEAT UTILITOR
#
# This file was automatically generated by Grako.
#
#    https://pypi.python.org/pypi/grako/
#
# Any changes you make to it will be overwritten the next time
# the file is generated.


from __future__ import print_function, division, absolute_import, unicode_literals
from grako.parsing import graken, Parser


__version__ = (2015, 10, 23, 9, 14, 47, 4)

__all__ = [
    'PPDDLsubParser',
    'PPDDLsubSemantics',
    'main'
]


class PPDDLsubParser(Parser):
    def __init__(self, whitespace=None, nameguard=None, **kwargs):
        super(PPDDLsubParser, self).__init__(
            whitespace=whitespace,
            nameguard=nameguard,
            comments_re=None,
            eol_comments_re=None,
            ignorecase=None,
            **kwargs
        )

    @graken()
    def _start_(self):
        self._program_()

    @graken()
    def _program_(self):
        self._token('(define ')
        self._problem_()
        self.ast['problem'] = self.last_node
        with self._optional():
            self._init_()
        self.ast['init'] = self.last_node
        self._goal_()
        self.ast['goal'] = self.last_node
        with self._optional():
            self._goal_reward_()
        self.ast['extra'] = self.last_node

        def block5():
            self._action_()
        self._closure(block5)
        self.ast['actions'] = self.last_node
        self._token(')')

        self.ast._define(
            ['problem', 'init', 'goal', 'extra', 'actions'],
            []
        )

    @graken()
    def _problem_(self):
        self._token('(problem ')
        self._atom_()
        self.ast['problem_name'] = self.last_node
        self._token(')')

        self.ast._define(
            ['problem_name'],
            []
        )

    @graken()
    def _init_(self):
        self._token('(:init ')
        self._negfreeconjunction_()
        self.ast['conjunction'] = self.last_node
        self._token(')')

        self.ast._define(
            ['conjunction'],
            []
        )

    @graken()
    def _goal_(self):
        self._token('(:goal ')
        self._dnf_()
        self.ast['subgoals'] = self.last_node
        self._token(')')

        self.ast._define(
            ['subgoals'],
            []
        )

    @graken()
    def _goal_reward_(self):
        self._token('(:goal-reward ')
        self._value_()
        self.ast['goal_reward'] = self.last_node
        self._token(')')

        self.ast._define(
            ['goal_reward'],
            []
        )

    @graken()
    def _action_(self):
        self._token('(:action ')
        self._atom_()
        self.ast['name'] = self.last_node
        with self._optional():
            self._precondition_()
        self.ast['precondition'] = self.last_node
        with self._optional():
            self._effect_()
        self.ast['effect'] = self.last_node
        self._token(')')

        self.ast._define(
            ['name', 'precondition', 'effect'],
            []
        )

    @graken()
    def _precondition_(self):
        self._token(':precondition ')
        self._dnf_()
        self.ast['args'] = self.last_node

        self.ast._define(
            ['args'],
            []
        )

    @graken()
    def _effect_(self):
        self._token(':effect ')
        with self._group():
            with self._choice():
                with self._option():
                    self._effect_conjunction_()
                with self._option():
                    self._probabilistic_()
                self._error('no available options')
        self.ast['args'] = self.last_node

        self.ast._define(
            ['args'],
            []
        )

    @graken()
    def _probabilistic_(self):
        self._token('(probabilistic ')

        def block1():
            self._prob_effects_()
        self._positive_closure(block1)

        self.ast['prob_effects'] = self.last_node
        self._token(')')

        self.ast._define(
            ['prob_effects'],
            []
        )

    @graken()
    def _prob_effects_(self):
        self._value_()
        self.ast['value'] = self.last_node
        self._effect_conjunction_()
        self.ast['conjunction'] = self.last_node

        self.ast._define(
            ['value', 'conjunction'],
            []
        )

    @graken()
    def _dnf_(self):
        with self._choice():
            with self._option():
                self._conjunction_()
                self.ast.setlist('disjunction', self.last_node)
            with self._option():
                self._token('(or ')

                def block2():
                    self._conjunction_()
                self._closure(block2)
                self.ast['disjunction'] = self.last_node
                self._token(')')
            self._error('expecting one of: (or ')

        self.ast._define(
            ['disjunction'],
            ['disjunction']
        )

    @graken()
    def _effect_conjunction_(self):
        with self._choice():
            with self._option():
                self._effect_term_()
                self.ast.setlist('args', self.last_node)
            with self._option():
                self._token('(and ')

                def block2():
                    self._effect_term_()
                self._closure(block2)
                self.ast['args'] = self.last_node
                self._token(')')
            self._error('expecting one of: (and ')

        self.ast._define(
            ['args'],
            ['args']
        )

    @graken()
    def _effect_term_(self):
        with self._choice():
            with self._option():
                self._predicate_()
            with self._option():
                self._negation_()
            with self._option():
                self._reward_increase_()
            with self._option():
                self._reward_decrease_()
            self._error('no available options')

    @graken()
    def _reward_increase_(self):
        self._token('(increase ')
        self._token('(reward)')
        self._value_()
        self.ast['increase'] = self.last_node
        self._token(')')

        self.ast._define(
            ['increase'],
            []
        )

    @graken()
    def _reward_decrease_(self):
        self._token('(decrease ')
        self._token('(reward)')
        self._value_()
        self.ast['decrease'] = self.last_node
        self._token(')')

        self.ast._define(
            ['decrease'],
            []
        )

    @graken()
    def _conjunction_(self):
        with self._choice():
            with self._option():
                self._term_()
                self.ast.setlist('args', self.last_node)
            with self._option():
                self._token('(and ')

                def block2():
                    self._term_()
                self._closure(block2)
                self.ast['args'] = self.last_node
                self._token(')')
            self._error('expecting one of: (and ')

        self.ast._define(
            ['args'],
            ['args']
        )

    @graken()
    def _negfreeconjunction_(self):
        with self._choice():
            with self._option():
                self._negfreeterm_()
                self.ast.setlist('args', self.last_node)
            with self._option():
                self._token('(and ')

                def block2():
                    self._negfreeterm_()
                self._closure(block2)
                self.ast['args'] = self.last_node
                self._token(')')
            self._error('expecting one of: (and ')

        self.ast._define(
            ['args'],
            ['args']
        )

    @graken()
    def _term_(self):
        with self._choice():
            with self._option():
                self._predicate_()
            with self._option():
                self._negation_()
            self._error('no available options')

    @graken()
    def _negfreeterm_(self):
        self._predicate_()

    @graken()
    def _negation_(self):
        self._token('(not ')

        def block1():
            self._predicate_()
        self._closure(block1)
        self.ast['negation'] = self.last_node
        self._token(')')

        self.ast._define(
            ['negation'],
            []
        )

    @graken()
    def _predicate_(self):
        with self._choice():
            with self._option():
                self._atom_()
                self.ast['atom'] = self.last_node
            with self._option():
                self._token('(')
                self._atom_()
                self.ast['atom'] = self.last_node
                self._token(')')
            self._error('no available options')

        self.ast._define(
            ['atom'],
            []
        )

    @graken()
    def _atom_(self):
        self._pattern(r'[a-zA-Z][a-zA-Z0-9_-]*')

    @graken()
    def _value_(self):
        self._pattern(r'([0-9]+\/[1-9][0-9]*)|([-+]?([0-9]*\.[0-9]+|[0-9]+))')


class PPDDLsubSemantics(object):
    def start(self, ast):
        return ast

    def program(self, ast):
        return ast

    def problem(self, ast):
        return ast

    def init(self, ast):
        return ast

    def goal(self, ast):
        return ast

    def goal_reward(self, ast):
        return ast

    def action(self, ast):
        return ast

    def precondition(self, ast):
        return ast

    def effect(self, ast):
        return ast

    def probabilistic(self, ast):
        return ast

    def prob_effects(self, ast):
        return ast

    def dnf(self, ast):
        return ast

    def effect_conjunction(self, ast):
        return ast

    def effect_term(self, ast):
        return ast

    def reward_increase(self, ast):
        return ast

    def reward_decrease(self, ast):
        return ast

    def conjunction(self, ast):
        return ast

    def negfreeconjunction(self, ast):
        return ast

    def term(self, ast):
        return ast

    def negfreeterm(self, ast):
        return ast

    def negation(self, ast):
        return ast

    def predicate(self, ast):
        return ast

    def atom(self, ast):
        return ast

    def value(self, ast):
        return ast


def main(filename, startrule, trace=False, whitespace=None, nameguard=None):
    import json
    with open(filename) as f:
        text = f.read()
    parser = PPDDLsubParser(parseinfo=False)
    ast = parser.parse(
        text,
        startrule,
        filename=filename,
        trace=trace,
        whitespace=whitespace,
        nameguard=nameguard)
    print('AST:')
    print(ast)
    print()
    print('JSON:')
    print(json.dumps(ast, indent=2))
    print()

if __name__ == '__main__':
    import argparse
    import string
    import sys

    class ListRules(argparse.Action):
        def __call__(self, parser, namespace, values, option_string):
            print('Rules:')
            for r in PPDDLsubParser.rule_list():
                print(r)
            print()
            sys.exit(0)

    parser = argparse.ArgumentParser(description="Simple parser for PPDDLsub.")
    parser.add_argument('-l', '--list', action=ListRules, nargs=0,
                        help="list all rules and exit")
    parser.add_argument('-n', '--no-nameguard', action='store_true',
                        dest='no_nameguard',
                        help="disable the 'nameguard' feature")
    parser.add_argument('-t', '--trace', action='store_true',
                        help="output trace information")
    parser.add_argument('-w', '--whitespace', type=str, default=string.whitespace,
                        help="whitespace specification")
    parser.add_argument('file', metavar="FILE", help="the input file to parse")
    parser.add_argument('startrule', metavar="STARTRULE",
                        help="the start rule for parsing")
    args = parser.parse_args()

    main(
        args.file,
        args.startrule,
        trace=args.trace,
        whitespace=args.whitespace,
        nameguard=not args.no_nameguard
    )