omextra 0.0.0.dev497__tar.gz → 0.0.0.dev498__tar.gz

{omextra-0.0.0.dev497/omextra.egg-info → omextra-0.0.0.dev498}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omextra
-Version: 0.0.0.dev497
+Version: 0.0.0.dev498
 Summary: omextra
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev497
+Requires-Dist: omlish==0.0.0.dev498
 Dynamic: license-file
 
 # Overview

omextra-0.0.0.dev498/omextra/text/abnf/__init__.py

@@ -0,0 +1,125 @@
+"""
+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 entirely rewritten.
+
+====
+
+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
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
+from .base import (  # noqa
+    Op,
+)
+
+from .core import (  # noqa
+    CORE_RULES,
+)
+
+from .errors import (  # noqa
+    AbnfError,
+    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,
+
+    parse_grammar,
+)
+
+from .ops import (  # noqa
+    Literal,
+    StringLiteral,
+    CaseInsensitiveStringLiteral,
+    RangeLiteral,
+    literal,
+
+    Concat,
+    concat,
+
+    Repeat,
+    repeat,
+    option,
+
+    Either,
+    either,
+
+    RuleRef,
+    rule,
+)
+
+from .parsing import (  # noqa
+    iter_parse,
+    parse,
+)
+
+from .utils import (  # noqa
+    only_match_rules,
+
+    fix_ws,
+)

{omextra-0.0.0.dev497 → omextra-0.0.0.dev498}/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-0.0.0.dev498/omextra/text/abnf/base.py

@@ -0,0 +1,44 @@
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+
+OpTuple: ta.TypeAlias = tuple['Op', ...]
+
+
+##
+
+
+class Op(lang.Abstract, lang.PackageSealed):
+    def _match_repr(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}'
+
+
+class CompositeOp(Op, lang.Abstract):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        try:
+            leaf_op_cls = LeafOp
+        except NameError:
+            pass
+        else:
+            check.not_issubclass(cls, leaf_op_cls)
+
+    @property
+    @abc.abstractmethod
+    def children(self) -> OpTuple:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def replace_children(self, *children: Op) -> Op:
+        raise NotImplementedError
+
+
+class LeafOp(Op, lang.Abstract):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.not_issubclass(cls, CompositeOp)

{omextra-0.0.0.dev497 → omextra-0.0.0.dev498}/omextra/text/abnf/core.py

@@ -3,13 +3,15 @@ https://datatracker.ietf.org/doc/html/rfc5234
 """
 import typing as ta
 
-from .base import Grammar
-from .base import Rule
+from .grammars import Channel
+from .grammars import Grammar
+from .grammars import Rule
 from .ops import concat
 from .ops import either
 from .ops import literal
 from .ops import repeat
 from .ops import rule
+from .opto import optimize_grammar
 
 
 ##
@@ -23,6 +25,7 @@ CORE_RULES: ta.Sequence[Rule] = [
             literal('\x41', '\x5a'),
             literal('\x61', '\x7a'),
         ),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
@@ -31,11 +34,13 @@ CORE_RULES: ta.Sequence[Rule] = [
             literal('0'),
             literal('1'),
         ),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
         'CHAR',
         literal('\x01', '\x7f'),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
@@ -44,12 +49,13 @@ CORE_RULES: ta.Sequence[Rule] = [
             literal('\x00', '\x1f'),
             literal('\x7f', case_sensitive=True),
         ),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
         'CR',
         literal('\x0d', case_sensitive=True),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
     Rule(
@@ -58,17 +64,19 @@ CORE_RULES: ta.Sequence[Rule] = [
             rule('CR'),
             rule('LF'),
         ),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
     Rule(
         'DIGIT',
         literal('\x30', '\x39'),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
         'DQUOTE',
         literal('\x22', case_sensitive=True),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
@@ -82,18 +90,19 @@ CORE_RULES: ta.Sequence[Rule] = [
             literal('E'),
             literal('F'),
         ),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
         'HTAB',
         literal('\x09', case_sensitive=True),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
     Rule(
         'LF',
         literal('\x0a', case_sensitive=True),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
     Rule(
@@ -107,23 +116,25 @@ CORE_RULES: ta.Sequence[Rule] = [
                 ),
             ),
         ),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
     Rule(
         'OCTET',
         literal('\x00', '\xff'),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
         'SP',
         literal('\x20', case_sensitive=True),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
     Rule(
         'VCHAR',
         literal('\x21', '\x7e'),
+        channel=Channel.CONTENT,
     ),
 
     Rule(
@@ -132,10 +143,11 @@ CORE_RULES: ta.Sequence[Rule] = [
             rule('SP'),
             rule('HTAB'),
         ),
-        insignificant=True,
+        channel=Channel.SPACE,
     ),
 
 ]
 
 
-CORE_GRAMMAR = Grammar(*CORE_RULES)
+RAW_CORE_GRAMMAR = Grammar(*CORE_RULES)
+CORE_GRAMMAR = optimize_grammar(RAW_CORE_GRAMMAR)