omextra 0.0.0.dev471__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

omextra/text/abnf/LICENSE

@@ -0,0 +1,16 @@
+Copyright 2020 Charles Yeomans
+
+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.

omextra/text/abnf/__init__.py

@@ -0,0 +1,79 @@
+"""
+Parser generator for ABNF grammars.
+
+Originally based on library by Charles Yeomans (see LICENSE file):
+
+  https://github.com/declaresub/abnf/tree/561ced67c0a8afc869ad0de5b39dbe4f6e71b0d8/src/abnf
+
+It has however been nearly entirely rewritten.
+
+====
+
+TODO:
+ - cache lol
+ - get greedier
+ - match-powered optimizer
+  - greedily compile regexes
+ - error reporting
+ - codegen
+"""
+
+
+from .base import (  # noqa
+    Match,
+    longest_match,
+
+    Parser,
+
+    Rule,
+    Grammar,
+
+    iter_parse,
+    parse,
+)
+
+from .core import (  # noqa
+    CORE_RULES,
+)
+
+from .errors import (  # noqa
+    AbnfError,
+    AbnfGrammarParseError,
+)
+
+from .meta import (  # noqa
+    META_GRAMMAR_RULES,
+    META_GRAMMAR,
+
+    parse_grammar,
+)
+
+from .parsers import (  # noqa
+    Literal,
+    StringLiteral,
+    CaseInsensitiveStringLiteral,
+    RangeLiteral,
+    literal,
+
+    Concat,
+    concat,
+
+    Repeat,
+    Option,
+    repeat,
+
+    Either,
+    either,
+
+    RuleRef,
+    rule,
+)
+
+from .utils import (  # noqa
+    strip_insignificant_match_rules,
+    only_match_rules,
+
+    parse_rules,
+
+    fix_grammar_ws,
+)

omextra/text/abnf/base.py

@@ -0,0 +1,313 @@
+import abc
+import io
+import itertools
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from .errors import AbnfError
+
+
+with lang.auto_proxy_import(globals()):
+    from . import parsers
+
+
+##
+
+
+@ta.final
+class Match(ta.NamedTuple):
+    parser: 'Parser'
+    start: int
+    end: int
+    children: tuple['Match', ...]
+
+    @property
+    def length(self) -> int:
+        return self.end - self.start
+
+    #
+
+    def __repr__(self) -> str:
+        return (
+            f'{self.__class__.__name__}('
+            f'{self.parser._match_repr()}, '  # noqa
+            f'{self.start}, {self.end}'
+            f'{f", {self.children!r}" if self.children else ""})'
+        )
+
+    def render_to(
+            self,
+            write: ta.Callable[[str], ta.Any],
+            *,
+            indent: int | None = None,
+            _level: int = 0,
+    ) -> None:
+        ix: str | None = (' ' * (indent * _level)) if indent is not None else None
+        if ix:
+            write(ix)
+        p = self.parser
+        if isinstance(p, (parsers.StringLiteral, parsers.CaseInsensitiveStringLiteral)):
+            write(f'literal<{self.start}-{self.end}>({p.value!r})')
+        elif isinstance(p, parsers.RangeLiteral):
+            write(f'literal<{self.start}-{self.end}>({p.value.lo!r}-{p.value.hi!r})')
+        else:
+            write(f'{p.__class__.__name__.lower()}<{self.start}-{self.end}>')
+            if isinstance(p, parsers.RuleRef):
+                write(f':{p.name}')
+            if self.children:
+                write('(')
+                if ix is not None:
+                    write('\n')
+                for i, c in enumerate(self.children):
+                    if i and ix is None:
+                        write(', ')
+                    c.render_to(write, indent=indent, _level=_level + 1)
+                    if ix is not None:
+                        write(',\n')
+                if ix:
+                    write(ix)
+                write(')')
+
+    def render(
+            self,
+            *,
+            indent: int | None = None,
+    ) -> str:
+        sb = io.StringIO()
+        self.render_to(sb.write, indent=indent)
+        return sb.getvalue()
+
+    def __str__(self) -> str:
+        return self.render()
+
+    #
+
+    def map_children(self, fn: ta.Callable[['Match'], 'Match']) -> 'Match':
+        return self._replace(children=tuple(map(fn, self.children)))
+
+    def flat_map_children(self, fn: ta.Callable[['Match'], ta.Iterable['Match']]) -> 'Match':
+        return self._replace(children=tuple(itertools.chain.from_iterable(map(fn, self.children))))
+
+
+def longest_match(ms: ta.Iterable[Match]) -> Match | None:
+    bm: Match | None = None
+    bl = 0
+    for m in ms:
+        l = m.length
+        if bm is None or l > bl:
+            bm, bl = m, l
+    return bm
+
+
+##
+
+
+class Parser(lang.Abstract, lang.PackageSealed):
+    def _match_repr(self) -> str:
+        return f'{self.__class__.__name__}@{id(self)}'
+
+    @abc.abstractmethod
+    def _iter_parse(self, ctx: '_Context', start: int) -> ta.Iterator[Match]:
+        raise NotImplementedError
+
+
+##
+
+
+class Rule(lang.Final):
+    def __init__(
+            self,
+            name: str,
+            parser: Parser,
+            *,
+            insignificant: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._name = check.non_empty_str(name)
+        self._name_f = name.casefold()
+        self._parser = check.isinstance(parser, Parser)
+        self._insignificant = insignificant
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._name!r})'
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def name_f(self) -> str:
+        return self._name_f
+
+    @property
+    def parser(self) -> Parser:
+        return self._parser
+
+    @property
+    def insignificant(self) -> bool:
+        return self._insignificant
+
+
+class Grammar(lang.Final):
+    def __init__(
+            self,
+            *rules: Rule,
+            root: Rule | str | None = None,
+    ) -> None:
+        super().__init__()
+
+        rules_set: set[Rule] = set()
+        rules_by_name: dict[str, Rule] = {}
+        rules_by_name_f: dict[str, Rule] = {}
+        rules_by_parser: dict[Parser, Rule] = {}
+        for gr in rules:
+            check.not_in(gr, rules_set)
+            check.not_in(gr._name, rules_by_name)  # noqa
+            check.not_in(gr._name_f, rules_by_name_f)  # noqa
+            check.not_in(gr._parser, rules_by_parser)  # noqa
+            rules_by_name[gr._name] = gr  # noqa
+            rules_by_name_f[gr._name_f] = gr  # noqa
+            rules_by_parser[gr._parser] = gr  # noqa
+        self._rules = rules_set
+        self._rules_by_name: ta.Mapping[str, Rule] = rules_by_name
+        self._rules_by_name_f: ta.Mapping[str, Rule] = rules_by_name_f
+        self._rules_by_parser: ta.Mapping[Parser, Rule] = rules_by_parser
+
+        if isinstance(root, str):
+            root = rules_by_name_f[root.casefold()]
+        self._root = root
+
+    @property
+    def root(self) -> Rule | None:
+        return self._root
+
+    def rule(self, name: str) -> Rule | None:
+        return self._rules_by_name_f.get(name.casefold())
+
+    def iter_parse(
+            self,
+            source: str,
+            root: Rule | str | None = None,
+            *,
+            start: int = 0,
+            debug: bool = False,
+    ) -> ta.Iterator[Match]:
+        if root is None:
+            if (root := self._root) is None:
+                raise AbnfError('No root or default root specified')
+        else:
+            if isinstance(root, str):
+                root = self._rules_by_name_f[root.casefold()]
+            else:
+                root = check.in_(check.isinstance(root, Rule), self._rules)
+
+        ctx_cls: type[_Context]
+        if debug:
+            ctx_cls = _DebugContext
+        else:
+            ctx_cls = _Context
+        ctx = ctx_cls(self, source)
+
+        return ctx.iter_parse(root._parser, start)  # noqa
+
+    def parse(
+            self,
+            source: str,
+            root: str | None = None,
+            *,
+            start: int = 0,
+            debug: bool = False,
+    ) -> Match | None:
+        return longest_match(self.iter_parse(
+            source,
+            root,
+            start=start,
+            debug=debug,
+        ))
+
+
+##
+
+
+class _Context:
+    def __init__(
+            self,
+            grammar: Grammar,
+            source: str,
+    ) -> None:
+        super().__init__()
+
+        self._grammar = grammar
+        self._source = source
+
+    @property
+    def grammar(self) -> Grammar:
+        return self._grammar
+
+    @property
+    def source(self) -> str:
+        return self._source
+
+    def iter_parse(self, parser: Parser, start: int) -> ta.Iterator[Match]:
+        return parser._iter_parse(self, start)  # noqa
+
+
+class _DebugContext(_Context):
+    _level: int = 0
+
+    def iter_parse(self, parser: Parser, start: int) -> ta.Iterator[Match]:
+        print(f'{"  " * self._level}enter: {parser=} {start=}')
+        try:
+            self._level += 1
+            for m in super().iter_parse(parser, start):  # noqa
+                # print(f'{"  " * (self._level - 1)}match: {parser=} {start=}')
+                yield m
+        finally:
+            self._level -= 1
+            print(f'{"  " * self._level}exit: {parser=} {start=}')
+
+
+##
+
+
+def iter_parse(
+        obj: Grammar | Rule | Parser,
+        src: str,
+        *,
+        root: str | None = None,
+        start: int = 0,
+) -> ta.Iterator[Match]:
+    if isinstance(obj, Grammar):
+        gram = obj
+    elif isinstance(obj, Rule):
+        check.none(root)
+        gram = Grammar(obj, root=obj)
+    elif isinstance(obj, Parser):
+        check.none(root)
+        gram = Grammar(Rule('root', obj), root='root')
+    else:
+        raise TypeError(obj)
+
+    return gram.iter_parse(
+        src,
+        root,
+        start=start,
+    )
+
+
+def parse(
+        obj: Grammar | Rule | Parser,
+        src: str,
+        *,
+        root: str | None = None,
+        start: int = 0,
+) -> Match | None:
+    return longest_match(iter_parse(
+        obj,
+        src,
+        root=root,
+        start=start,
+    ))

omextra/text/abnf/core.py

@@ -0,0 +1,141 @@
+"""
+https://datatracker.ietf.org/doc/html/rfc5234
+"""
+import typing as ta
+
+from .base import Grammar
+from .base import Rule
+from .parsers import concat
+from .parsers import either
+from .parsers import literal
+from .parsers import repeat
+from .parsers import rule
+
+
+##
+
+
+CORE_RULES: ta.Sequence[Rule] = [
+
+    Rule(
+        'ALPHA',
+        either(
+            literal('\x41', '\x5a'),
+            literal('\x61', '\x7a'),
+        ),
+    ),
+
+    Rule(
+        'BIT',
+        either(
+            literal('0'),
+            literal('1'),
+        ),
+    ),
+
+    Rule(
+        'CHAR',
+        literal('\x01', '\x7f'),
+    ),
+
+    Rule(
+        'CTL',
+        either(
+            literal('\x00', '\x1f'),
+            literal('\x7f', case_sensitive=True),
+        ),
+    ),
+
+    Rule(
+        'CR',
+        literal('\x0d', case_sensitive=True),
+        insignificant=True,
+    ),
+
+    Rule(
+        'CRLF',
+        concat(
+            rule('CR'),
+            rule('LF'),
+        ),
+        insignificant=True,
+    ),
+
+    Rule(
+        'DIGIT',
+        literal('\x30', '\x39'),
+    ),
+
+    Rule(
+        'DQUOTE',
+        literal('\x22', case_sensitive=True),
+    ),
+
+    Rule(
+        'HEXDIG',
+        either(
+            rule('DIGIT'),
+            literal('A'),
+            literal('B'),
+            literal('C'),
+            literal('D'),
+            literal('E'),
+            literal('F'),
+        ),
+    ),
+
+    Rule(
+        'HTAB',
+        literal('\x09', case_sensitive=True),
+        insignificant=True,
+    ),
+
+    Rule(
+        'LF',
+        literal('\x0a', case_sensitive=True),
+        insignificant=True,
+    ),
+
+    Rule(
+        'LWSP',
+        repeat(
+            either(
+                rule('WSP'),
+                concat(
+                    rule('CRLF'),
+                    rule('WSP'),
+                ),
+            ),
+        ),
+        insignificant=True,
+    ),
+
+    Rule(
+        'OCTET',
+        literal('\x00', '\xff'),
+    ),
+
+    Rule(
+        'SP',
+        literal('\x20', case_sensitive=True),
+        insignificant=True,
+    ),
+
+    Rule(
+        'VCHAR',
+        literal('\x21', '\x7e'),
+    ),
+
+    Rule(
+        'WSP',
+        either(
+            rule('SP'),
+            rule('HTAB'),
+        ),
+        insignificant=True,
+    ),
+
+]
+
+
+CORE_GRAMMAR = Grammar(*CORE_RULES)

omextra/text/abnf/errors.py

@@ -0,0 +1,10 @@
+class AbnfError(Exception):
+    pass
+
+
+class AbnfIncompleteParseError(AbnfError):
+    pass
+
+
+class AbnfGrammarParseError(AbnfError):
+    pass