omextra 0.0.0.dev497__py3-none-any.whl → 0.0.0.dev499__py3-none-any.whl

omextra/text/abnf/__init__.py

@@ -13,10 +13,37 @@ TODO:
  - opto
  - error reporting
  - codegen?
+ - | as either(first_match=True)
+ - optional auto SPACE channel for ALL-UPCASE-RULE-NAMES
  - fix_ws problem
   - auto? no, need to keep lines / offsets accurate for errors
   - relax CRLF rule by default?
   - grammar transform? helper kwarg?
+ - kwarg to mark uppercase rules insignificant
+ - ebnf mode?
+ - peg / lalr engines?
+  - must always keep true abnf mode
+ - optionally separate lexing step
+
+====
+
+| Feature                   | EBNF           | ABNF             |
+| ------------------------- | -------------- | ---------------- |
+| Rule terminator           | `;`            | none             |
+| Alternation               | `|`            | `/`              |
+| Optional                  | `[a]` or `a?`  | `[a]`            |
+| Zero or more              | `a*`           | `*a`             |
+| One or more               | `a+`           | `1*a`            |
+| Bounded repetition        | `1..5 a`       | `1*5a`           |
+| Character ranges          | sometimes:     | `%xNN-NN`        |
+|                           | `"0" .. "9"`   |                  |
+| Literal chars             | `'a'` or `"a"` | `"a"` only       |
+| Case-insensitive literals | no             | `%i"..."`        |
+| Comments                  | `(* *)` or     | `;`              |
+|                           | `/* */` or     |                  |
+|                           | `-- `          |                  |
+| Rule names                | case-sensitive | case-insensitive |
+
 """
 from omlish import dataclasses as _dc  # noqa
 
@@ -31,16 +58,7 @@ _dc.init_package(
 
 
 from .base import (  # noqa
-    Match,
-    longest_match,
-
     Op,
-
-    Rule,
-    Grammar,
-
-    iter_parse,
-    parse,
 )
 
 from .core import (  # noqa
@@ -52,6 +70,21 @@ from .errors import (  # noqa
     AbnfGrammarParseError,
 )
 
+from .grammars import (  # noqa
+    Channel,
+    Rule,
+    RulesCollection,
+
+    Grammar,
+)
+
+from .matches import (  # noqa
+    Match,
+
+    longest_match,
+    filter_matches,
+)
+
 from .meta import (  # noqa
     META_GRAMMAR_RULES,
     META_GRAMMAR,
@@ -80,15 +113,13 @@ from .ops import (  # noqa
     rule,
 )
 
-from .opto import (  # noqa
-    optimize_op,
+from .parsing import (  # noqa
+    iter_parse,
+    parse,
 )
 
 from .utils import (  # noqa
-    strip_insignificant_match_rules,
     only_match_rules,
 
-    parse_rules,
-
     fix_ws,
 )

omextra/text/abnf/_dataclasses.py

@@ -39,6 +39,8 @@ def _register(**kwargs):
     cls_names=(
         ('omextra.text.abnf', 'MetaGrammarRuleMatchVisitor.QuotedString'),
         ('omextra.text.abnf', 'MetaGrammarRuleMatchVisitor.RuleName'),
+        ('omextra.text.abnf', '_CaseInsensitiveStringLiteralRegexItem'),
+        ('omextra.text.abnf', '_StringLiteralRegexItem'),
     ),
 )
 def _process_dataclass__30a5dd74853303d917aae5f67d4e7189615d1440():
@@ -436,3 +438,247 @@ def _process_dataclass__3dce49e08774c707abbc7a6513e35ccdc43001c9():
         setattr(__dataclass__cls, '__init__', __init__)
 
     return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=()), EqPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), Ha"
+        "shPlan(action='add', fields=(), cache=False), InitPlan(fields=(), self_param='self', std_params=(), kw_only_pa"
+        "rams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(), i"
+        "d=False, terse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='e1f7edfe11f2b721d6a656c46e698fedc95461bb',
+    op_ref_idents=(),
+    cls_names=(
+        ('omextra.text.abnf', '_RegexItem'),
+    ),
+)
+def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls()  # noqa
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return True
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash(())
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+        ) -> __dataclass__None:
+            pass
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('ps',)), EqPlan(fields=('ps',)), FrozenPlan(fields=('ps',), allow_dynamic_dunder_a"
+        "ttrs=False), HashPlan(action='add', fields=('ps',), cache=False), InitPlan(fields=(InitPlan.Field(name='ps', a"
+        "nnotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=Fals"
+        "e, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_param"
+        "s=('ps',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), "
+        "ReprPlan(fields=(ReprPlan.Field(name='ps', kw_only=False, fn=None),), id=False, terse=False, default_fn=None))"
+        ")"
+    ),
+    plan_repr_sha1='f7dc3147180d5d4dc248e9c0d94aa0f1e503c4c7',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+    ),
+    cls_names=(
+        ('omextra.text.abnf', '_RegexRegexItem'),
+    ),
+)
+def _process_dataclass__f7dc3147180d5d4dc248e9c0d94aa0f1e503c4c7():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                ps=self.ps,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.ps == other.ps
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'ps',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'ps',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self.ps,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            ps: __dataclass__init__fields__0__annotation,
+        ) -> __dataclass__None:
+            __dataclass__object_setattr(self, 'ps', ps)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            parts.append(f"ps={self.ps!r}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass

omextra/text/abnf/base.py

@@ -1,109 +1,11 @@
 import abc
-import io
-import itertools
 import typing as ta
 
 from omlish import check
 from omlish import lang
 
-from .errors import AbnfError
-from .errors import AbnfIncompleteParseError
 
-
-with lang.auto_proxy_import(globals()):
-    from . import internal
-    from . import ops
-    from . import parsing
-
-
-##
-
-
-@ta.final
-class Match(ta.NamedTuple):
-    op: 'Op'
-    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.op._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,
-            _depth: int = 0,
-    ) -> None:
-        ix: str | None = (' ' * (indent * _depth)) if indent is not None else None
-        if ix:
-            write(ix)
-        o = self.op
-        if isinstance(o, (ops.StringLiteral, ops.CaseInsensitiveStringLiteral)):
-            write(f'literal<{self.start}-{self.end}>({o.value!r})')
-        elif isinstance(o, ops.RangeLiteral):
-            write(f'literal<{self.start}-{self.end}>({o.value.lo!r}-{o.value.hi!r})')
-        elif isinstance(o, internal.Regex):
-            write(f'regex<{self.start}-{self.end}>({o.pat.pattern!r})')
-        else:
-            write(f'{o.__class__.__name__.lower()}<{self.start}-{self.end}>')
-            if isinstance(o, ops.RuleRef):
-                write(f':{o.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, _depth=_depth + 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
+OpTuple: ta.TypeAlias = tuple['Op', ...]
 
 
 ##
@@ -127,7 +29,11 @@ class CompositeOp(Op, lang.Abstract):
 
     @property
     @abc.abstractmethod
-    def children(self) -> ta.Sequence[Op]:
+    def children(self) -> OpTuple:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def replace_children(self, *children: Op) -> Op:
         raise NotImplementedError
 
 
@@ -136,182 +42,3 @@ class LeafOp(Op, lang.Abstract):
         super().__init_subclass__(**kwargs)
 
         check.not_issubclass(cls, CompositeOp)
-
-
-##
-
-
-class Rule(lang.Final):
-    def __init__(
-            self,
-            name: str,
-            op: Op,
-            *,
-            insignificant: bool = False,
-    ) -> None:
-        super().__init__()
-
-        self._name = check.non_empty_str(name)
-        self._op = check.isinstance(op, Op)
-        self._insignificant = insignificant
-
-        self._name_f = name.casefold()
-
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}({self._name!r})'
-
-    def replace_op(self, op: Op) -> 'Rule':
-        return Rule(
-            self._name,
-            op,
-            insignificant=self._insignificant,
-        )
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def name_f(self) -> str:
-        return self._name_f
-
-    @property
-    def op(self) -> Op:
-        return self._op
-
-    @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_op: dict[Op, Rule] = {}
-        for gr in rules:
-            check.isinstance(gr, Rule)
-            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._op, rules_by_op)  # noqa
-            rules_set.add(gr)
-            rules_by_name[gr._name] = gr  # noqa
-            rules_by_name_f[gr._name_f] = gr  # noqa
-            rules_by_op[gr._op] = 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_op: ta.Mapping[Op, Rule] = rules_by_op
-
-        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: int = 0,
-            **kwargs: ta.Any,
-    ) -> 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)
-
-        return parsing._iter_parse(  # noqa
-            self,
-            source,
-            root._op,  # noqa
-            start,
-            debug=debug,
-            **kwargs,
-        )
-
-    def parse(
-            self,
-            source: str,
-            root: str | None = None,
-            *,
-            start: int = 0,
-            complete: bool = False,
-            debug: int = 0,
-            **kwargs: ta.Any,
-    ) -> Match | None:
-        if (match := longest_match(self.iter_parse(
-            source,
-            root,
-            start=start,
-            debug=debug,
-            **kwargs,
-        ))) is None:
-            return None
-
-        if complete and (match.start, match.end) != (start, len(source)):
-            raise AbnfIncompleteParseError
-
-        return match
-
-
-##
-
-
-def iter_parse(
-        obj: Grammar | Rule | Op,
-        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, Op):
-        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 | Op,
-        src: str,
-        *,
-        root: str | None = None,
-        start: int = 0,
-) -> Match | None:
-    return longest_match(iter_parse(
-        obj,
-        src,
-        root=root,
-        start=start,
-    ))