omextra 0.0.0.dev472__py3-none-any.whl → 0.0.0.dev473__py3-none-any.whl

omextra/text/abnf/parsers.py

@@ -0,0 +1,345 @@
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .base import Match
+from .base import Parser
+from .base import _Context
+
+
+##
+
+
+class Literal(Parser, lang.Abstract):
+    def _match_repr(self) -> str:
+        return repr(self)
+
+
+class StringLiteral(Literal):
+    def __init__(self, value: str) -> None:
+        super().__init__()
+
+        self._value = check.non_empty_str(value)
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._value!r})'
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        if start < len(ctx._source):  # noqa
+            source = ctx._source[start : start + len(self._value)]  # noqa
+            if source == self._value:
+                yield Match(self, start, start + len(source), ())
+
+
+class CaseInsensitiveStringLiteral(Literal):
+    def __init__(self, value: str) -> None:
+        super().__init__()
+
+        self._value = check.non_empty_str(value).casefold()
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._value!r})'
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        if start < len(ctx._source):  # noqa
+            source = ctx._source[start : start + len(self._value)].casefold()  # noqa
+            if source == self._value:
+                yield Match(self, start, start + len(source), ())
+
+
+class RangeLiteral(Literal):
+    @dc.dataclass(frozen=True)
+    class Range:
+        lo: str
+        hi: str
+
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.lo)
+            check.non_empty_str(self.hi)
+            check.state(self.hi >= self.lo)
+
+    def __init__(self, value: Range) -> None:
+        super().__init__()
+
+        self._value = check.isinstance(value, RangeLiteral.Range)
+
+    @property
+    def value(self) -> Range:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._value!r})'
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        try:
+            source = ctx._source[start]  # noqa
+        except IndexError:
+            return
+        # ranges are always case-sensitive
+        if (value := self._value).lo <= source <= value.hi:
+            yield Match(self, start, start + 1, ())
+
+
+@ta.overload
+def literal(s: str, *, case_sensitive: bool = False) -> StringLiteral:
+    ...
+
+
+@ta.overload
+def literal(lo: str, hi: str) -> RangeLiteral:
+    ...
+
+
+def literal(*args, case_sensitive=None):
+    if not args:
+        raise TypeError
+    elif len(args) == 1:
+        s = check.isinstance(check.single(args), str)
+        if case_sensitive:
+            return StringLiteral(s)
+        else:
+            return CaseInsensitiveStringLiteral(s)
+    elif len(args) == 2:
+        check.none(case_sensitive)
+        return RangeLiteral(RangeLiteral.Range(*map(check.of_isinstance(str), args)))
+    else:
+        raise TypeError(args)
+
+
+##
+
+
+class Concat(Parser):
+    def __init__(self, *children: Parser) -> None:
+        super().__init__()
+
+        for c in check.not_empty(children):
+            check.isinstance(c, Parser)
+        self._children = children
+
+    @property
+    def children(self) -> ta.Sequence[Parser]:
+        return self._children
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({", ".join(map(repr, self._children))})'
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        i = 0
+        match_tups: list[tuple[Match, ...]] = [()]
+        for cp in self._children:
+            next_match_tups: list[tuple[Match, ...]] = []
+            for mt in match_tups:
+                for cm in ctx.iter_parse(cp, mt[-1].end if mt else start):
+                    next_match_tups.append((*mt, cm))
+                    i += 1
+            if not next_match_tups:
+                return
+            match_tups = next_match_tups
+        if not i:
+            return
+        for mt in sorted(match_tups, key=len, reverse=True):
+            yield Match(self, start, mt[-1].end if mt else start, mt)
+
+
+concat = Concat
+
+
+##
+
+
+class Repeat(Parser):
+    @dc.dataclass(frozen=True)
+    class Times:
+        min: int = 0
+        max: int | None = None
+
+        def __post_init__(self) -> None:
+            if self.max is not None:
+                check.state(self.max >= self.min)
+
+        def __repr__(self) -> str:
+            return f'{self.__class__.__name__}({self.min}{f", {self.max!r}" if self.max is not None else ""})'
+
+    def __init__(self, times: Times, child: Parser) -> None:
+        super().__init__()
+
+        self._times = check.isinstance(times, Repeat.Times)
+        self._child = check.isinstance(child, Parser)
+
+    @property
+    def times(self) -> Times:
+        return self._times
+
+    @property
+    def child(self) -> Parser:
+        return self._child
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._times}, {self._child!r})'
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        match_tup_set: set[tuple[Match, ...]] = set()
+        last_match_tup_set: set[tuple[Match, ...]] = {()}
+        i = 0
+        while True:
+            if self._times.max is not None and i == self._times.max:
+                break
+            next_match_tup_set: set[tuple[Match, ...]] = set()
+            for mt in last_match_tup_set:
+                for cm in ctx.iter_parse(self._child, mt[-1].end if mt else start):
+                    next_match_tup_set.add((*mt, cm))
+            if not next_match_tup_set or next_match_tup_set < match_tup_set:
+                break
+            i += 1
+            match_tup_set |= next_match_tup_set
+            last_match_tup_set = next_match_tup_set
+        if i < self._times.min:
+            return
+        for mt in sorted(match_tup_set or [()], key=len, reverse=True):
+            yield Match(self, start, mt[-1].end if mt else start, mt)  # noqa
+
+
+class Option(Repeat):
+    def __init__(self, child: Parser) -> None:
+        super().__init__(Repeat.Times(0, 1), child)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._child!r})'
+
+
+option = Option
+
+
+@ta.overload
+def repeat(child: Parser) -> Repeat:  # noqa
+    ...
+
+
+@ta.overload
+def repeat(times: Repeat.Times, child: Parser) -> Repeat:  # noqa
+    ...
+
+
+@ta.overload
+def repeat(min: int, child: Parser) -> Repeat:  # noqa
+    ...
+
+
+@ta.overload
+def repeat(min: int, max: int | None, child: Parser) -> Repeat:  # noqa
+    ...
+
+
+def repeat(*args):
+    # !!! FIXME: boneheaded args, repeat(1, c) currently means 1-*, should be exactly 1-1, should explicitly pass
+    #            None for *
+    min: int  # noqa
+    max: int | None  # noqa
+
+    if len(args) < 2:
+        [child] = args
+        min, max = 0, None  # noqa
+
+    elif len(args) > 2:
+        min, max, child = args  # noqa
+
+    else:
+        ti, child = args  # noqa
+
+        if isinstance(ti, Repeat.Times):
+            min, max = ti.min, ti.max  # noqa
+
+        else:
+            min, max = ti, None  # noqa
+
+    if (min, max) == (0, 1):
+        return Option(check.isinstance(child, Parser))
+
+    else:
+        return Repeat(
+            Repeat.Times(
+                check.isinstance(min, int),
+                check.isinstance(max, (int, None)),
+            ),
+            check.isinstance(child, Parser),
+        )
+
+
+##
+
+
+class Either(Parser):
+    def __init__(self, *children: Parser, first_match: bool = False) -> None:
+        super().__init__()
+
+        for c in check.not_empty(children):
+            check.isinstance(c, Parser)
+        self._children = children
+        self._first_match = first_match
+
+    @property
+    def children(self) -> ta.Sequence[Parser]:
+        return self._children
+
+    @property
+    def first_match(self) -> bool:
+        return self._first_match
+
+    def __repr__(self) -> str:
+        return (
+            f'{self.__class__.__name__}@{id(self):x}('
+            f'{", ".join(map(repr, self._children))}'
+            f'{", first_match=True" if self._first_match else ""})'
+        )
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        for cp in self._children:
+            found = False
+            for cm in ctx.iter_parse(cp, start):
+                found = True
+                yield Match(self, start, cm.end, (cm,))
+            if found and self._first_match:
+                return
+
+
+either = Either
+
+
+##
+
+
+class RuleRef(Parser):
+    def __init__(self, name: str) -> None:
+        super().__init__()
+
+        self._name = check.non_empty_str(name)
+        self._name_f = name.casefold()
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._name!r})'
+
+    def _match_repr(self) -> str:
+        return repr(self)
+
+    def _iter_parse(self, ctx: _Context, start: int) -> ta.Iterator[Match]:
+        cp = ctx._grammar._rules_by_name_f[self._name_f].parser  # noqa
+        for cm in ctx.iter_parse(cp, start):
+            yield Match(self, cm.start, cm.end, (cm,))
+
+
+rule = RuleRef

omextra/text/abnf/utils.py

@@ -0,0 +1,68 @@
+import itertools
+import textwrap
+import typing as ta
+
+from omlish import check
+
+from .base import Grammar
+from .base import Match
+from .parsers import RuleRef
+
+
+##
+
+
+def strip_insignificant_match_rules(m: Match, g: Grammar) -> Match:
+    def rec(c: Match) -> Match:
+        return c.flat_map_children(
+            lambda x: (
+                (rec(x),) if not (
+                    isinstance((xp := x.parser), RuleRef) and
+                    check.not_none(g.rule(xp.name)).insignificant
+                ) else ()
+            ),
+        )
+    return rec(m)
+
+
+def only_match_rules(m: Match) -> Match:
+    def rec(c: Match) -> ta.Iterable[Match]:
+        if isinstance(c.parser, RuleRef):
+            return (c.flat_map_children(rec),)
+        else:
+            return itertools.chain.from_iterable(map(rec, c.children))
+    return m.flat_map_children(rec)
+
+
+#
+
+
+def parse_rules(
+        grammar: Grammar,
+        source: str,
+        root: str | None = None,
+        **kwargs: ta.Any,
+) -> Match | None:
+    if (match := grammar.parse(
+            source,
+            root,
+            **kwargs,
+    )) is None:
+        return None
+
+    match = only_match_rules(match)
+    match = strip_insignificant_match_rules(match, grammar)
+
+    return match
+
+
+##
+
+
+def fix_grammar_ws(s: str) -> str:
+    return (
+        textwrap.dedent(s)
+        .rstrip()
+        .replace('\r', '')
+        .replace('\n', '\r\n')
+    ) + '\r\n'

omextra/text/abnf/visitors.py

@@ -0,0 +1,55 @@
+import typing as ta
+
+from omlish import check
+from omlish import collections as col
+from omlish import dispatch
+from omlish import lang
+
+from .base import Match
+from .base import Parser
+from .parsers import RuleRef
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class ParserVisitor(lang.Abstract, ta.Generic[T]):
+    @dispatch.method()
+    def visit_parser(self, p: Parser, m: Match) -> T:
+        raise TypeError(p)
+
+    #
+
+    def visit_match(self, m: Match) -> T:
+        return self.visit_parser(m.parser, m)
+
+
+##
+
+
+class RuleVisitor(lang.Abstract, ta.Generic[T]):
+    _registry = col.AttrRegistry[ta.Callable, str]()
+
+    @classmethod
+    def register(cls, name):
+        return cls._registry.register(name)
+
+    @lang.cached_function
+    @classmethod
+    def _registry_cache(cls) -> col.AttrRegistryCache[ta.Callable, str, ta.Mapping[str, str]]:
+        def prepare(_, dct):
+            return col.make_map(((n, a) for a, (_, n) in dct.items()), strict=True)
+
+        return col.AttrRegistryCache(cls._registry, prepare)
+
+    def visit_rule(self, name: str, m: Match) -> T:
+        att = self._registry_cache().get(self.__class__)[name]
+        return getattr(self, att)(m)
+
+    #
+
+    def visit_match(self, m: Match) -> T:
+        return self.visit_rule(check.isinstance(m.parser, RuleRef).name, m)

{omextra-0.0.0.dev472.dist-info → omextra-0.0.0.dev473.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omextra
-Version: 0.0.0.dev472
+Version: 0.0.0.dev473
 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.dev472
+Requires-Dist: omlish==0.0.0.dev473
 Dynamic: license-file
 
 # Overview

{omextra-0.0.0.dev472.dist-info → omextra-0.0.0.dev473.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omextra/.omlish-manifests.json,sha256=E1M9UJ31RfpLfsZ2MfbN0_GAh_Lu_vj9wVJKPgak8jQ,290
-omextra/__about__.py,sha256=UmONS0zKtygpY7Z9AD42Kn1cajMEdLKHzUwG00kaaFM,689
+omextra/__about__.py,sha256=8R-v5C4UWEiLEyDv1CoxATr7YTxZxs6-7QRlva-gGWY,706
 omextra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/defs.py,sha256=iMaDGj5VSG7QdYA1s7MvIYTbtTsXc1msINsuuZym1vs,4902
 omextra/dynamic.py,sha256=i3aJRWwHJOmsrXI9a2iWCLa7pUQXx5YbMvUOS5LZ_Bs,6531
@@ -14,7 +14,18 @@ omextra/asyncs/bluelet/events.py,sha256=PJ55CuXNmvzhYYhMmIDOUWegWTMcn9IkxL4dHcjd
 omextra/asyncs/bluelet/files.py,sha256=wpvzFPfQltqPcSKUgmAUZ1sjSSawX_nr5rZ4InLhsTM,2424
 omextra/asyncs/bluelet/runner.py,sha256=pE080AUs66AIxY5WBOWqh-9V1i1JYOvxaE2wB8t72Mw,15516
 omextra/asyncs/bluelet/sockets.py,sha256=nTVPdLbsmmjI0e6G9Di2DA-JoTTnvu8xc_Yv8N_7g48,6781
+omextra/collections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omextra/collections/hamt/LICENSE,sha256=82rcXdtBwd6vGLddjx9Jk09kkwPL6yqqv1NzGjPUCoM,2460
+omextra/collections/hamt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omextra/collections/hamt/_hamt.c,sha256=LDYWBuAl4685DbAZICrzO--EfIN8PjHZq0MUJYBAD74,100898
 omextra/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omextra/formats/goyaml/LICENSE,sha256=qkavv9cjd59BFIFOMVMJMrC3FCEIELrBTA-GPhAFkoY,1071
+omextra/formats/goyaml/__init__.py,sha256=HuJqVB6wyqzQcHMRCW9r3ciPnjl3UvhDT-LjRp7kHDo,1817
+omextra/formats/goyaml/ast.py,sha256=55CyoNRiaDmu6YeKE_PRt51fE7zr35YcTWSDzVRjPRo,69984
+omextra/formats/goyaml/errors.py,sha256=UQfuManw4kOJKnXrV6MjFqt0ZU6KkwZL75KMdQQ6ZyU,949
+omextra/formats/goyaml/parsing.py,sha256=vZotOxOhLTrE9AGfXbSZcDrVC652PJ3K3ageu6aRT6Q,90558
+omextra/formats/goyaml/scanning.py,sha256=X5hl5lhQAPtiqiKC0pGAo46D2rrB2nZOtJuQOAtaXDM,63208
+omextra/formats/goyaml/tokens.py,sha256=fRshyMRU3XzZ5Pi9_C1F2BTzjtcrqIuIsHmQuqMu3Oo,29278
 omextra/formats/json/Json.g4,sha256=fYImsljcVPdlMTHBabM_rza2j4udqjfLQNxIz4S_TpY,1206
 omextra/formats/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/formats/json/_antlr/JsonLexer.py,sha256=SYlMV8XKi_kJ9meEulNmm2B98hjdzz_xLyPsoqCyYoE,4957
@@ -52,6 +63,15 @@ omextra/sql/parsing/_antlr/MinisqlParser.py,sha256=htIMgNde8PqLj7mDV2cLo7kDiwn-a
 omextra/sql/parsing/_antlr/MinisqlVisitor.py,sha256=UPs2qA2VlNRP_LMwF0DpMxMir9tIS9w59vGTq07mmlI,10052
 omextra/sql/parsing/_antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omextra/text/abnf/LICENSE,sha256=UJzrhSePw9TVm0VfkVmx9NRHkPS1n6jx2UgajTb14ts,1054
+omextra/text/abnf/__init__.py,sha256=v1ABrlcdhCB8ezqHZPl3MZ6SYoEZNerGET5MHjFYhP8,967
+omextra/text/abnf/base.py,sha256=oO9e8Rd0kjdjJ6wWtpzIJOcY_E0QgUSAltpuwqWx-aQ,7476
+omextra/text/abnf/core.py,sha256=VUD52hKgDsesvPjmhL1UZVXtpYr-EpWyBprdy722YTY,2303
+omextra/text/abnf/errors.py,sha256=z_RMXMYhPwSUb1neJpJG-XUvkSS87uLJEX9p4wmXQfU,88
+omextra/text/abnf/meta.py,sha256=ltiq70jpTB8Ab3jTfqRubmRdI-42SLPXztLk1_EWFLU,13704
+omextra/text/abnf/parsers.py,sha256=BA5XdbiWh4UyabV4-rajSjHBOBXNa6ieTDs9CwM4nRU,9351
+omextra/text/abnf/utils.py,sha256=OWJe9DvSidOLNzkbdUXdLupDKEIDy6TtQFPVjDmyCng,1420
+omextra/text/abnf/visitors.py,sha256=kAWPmc3fAOLynLoVl_-ciG_TA3XG7HPca9_I1vI4rL0,1288
 omextra/text/antlr/__init__.py,sha256=88bMl_28cfSKslgOkMGYXqALgsHz3KC4LFvAVtzj7k8,89
 omextra/text/antlr/delimit.py,sha256=s0Jlu6oOamtuyWv_V98P0YC7HmgFJBF7GHVsDfMYTdI,3476
 omextra/text/antlr/dot.py,sha256=37ZBYpum-n6Xg9UGj1Wc0wyuR3gL_uX63KwrSzyWNmk,967
@@ -125,9 +145,9 @@ omextra/text/antlr/cli/__main__.py,sha256=ckYkj0drxabBVwWYewH2SS36TTeAxllZtS4xEl
 omextra/text/antlr/cli/cli.py,sha256=LW8pJNmySBOV3g8QxquPjUgxFv7YblzEyi555hHH3_M,1234
 omextra/text/antlr/cli/consts.py,sha256=HUYJP9j4RfeuuQv6HFd2oFMS0piWJ9Sq1tbeAs4OlBc,290
 omextra/text/antlr/cli/gen.py,sha256=HYleVptrpynwcl6GspX6O9_oMRSxwdYAQGuUFfDYse8,5236
-omextra-0.0.0.dev472.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omextra-0.0.0.dev472.dist-info/METADATA,sha256=f7prA1cDtyumqmLEewCCt5UWrQikbjbnRYhhtsMxVnQ,1001
-omextra-0.0.0.dev472.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omextra-0.0.0.dev472.dist-info/entry_points.txt,sha256=-MFAMks5HgZ60Ore0Wl5lKVKk8z4kf1Ls3WY9E_OlCU,37
-omextra-0.0.0.dev472.dist-info/top_level.txt,sha256=o1nCNRejLMcayDngLuWMWwaeOucz33BXbpuoVvvzjPc,8
-omextra-0.0.0.dev472.dist-info/RECORD,,
+omextra-0.0.0.dev473.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omextra-0.0.0.dev473.dist-info/METADATA,sha256=4KrfUl4grgwui8gUkPsKwH83Mo313ZP45Rjibw5Vqhk,1001
+omextra-0.0.0.dev473.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omextra-0.0.0.dev473.dist-info/entry_points.txt,sha256=-MFAMks5HgZ60Ore0Wl5lKVKk8z4kf1Ls3WY9E_OlCU,37
+omextra-0.0.0.dev473.dist-info/top_level.txt,sha256=o1nCNRejLMcayDngLuWMWwaeOucz33BXbpuoVvvzjPc,8
+omextra-0.0.0.dev473.dist-info/RECORD,,