omextra 0.0.0.dev494__py3-none-any.whl → 0.0.0.dev496__py3-none-any.whl

omextra/text/abnf/ops.py

@@ -0,0 +1,276 @@
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .base import LeafOp
+from .base import Op
+
+
+##
+
+
+class Literal(LeafOp, lang.Abstract):
+    def _match_repr(self) -> str:
+        return repr(self)
+
+
+@ta.final
+class StringLiteral(Literal, lang.Final):
+    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})'
+
+
+@ta.final
+class CaseInsensitiveStringLiteral(Literal, lang.Final):
+    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})'
+
+
+@ta.final
+class RangeLiteral(Literal, lang.Final):
+    @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})'
+
+
+@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)
+
+
+##
+
+
+@ta.final
+class Concat(Op, lang.Final):
+    def __init__(self, *children: Op) -> None:
+        super().__init__()
+
+        for c in check.not_empty(children):
+            check.isinstance(c, Op)
+        self._children = children
+
+    @property
+    def children(self) -> ta.Sequence[Op]:
+        return self._children
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({", ".join(map(repr, self._children))})'
+
+
+concat = Concat
+
+
+##
+
+
+@ta.final
+class Repeat(Op, lang.Final):
+    @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:
+            if not self.min and self.max is None:
+                s = '*'
+            elif not self.min and self.max == 1:
+                s = '?'
+            elif self.min and self.max is None:
+                s = f'{self.min}+'
+            else:
+                s = f'{self.min}-{self.max!r}'
+            return f'{self.__class__.__name__}({s})'
+
+    def __init__(self, times: Times, child: Op) -> None:
+        super().__init__()
+
+        self._times = check.isinstance(times, Repeat.Times)
+        self._child = check.isinstance(child, Op)
+
+    @property
+    def times(self) -> Times:
+        return self._times
+
+    @property
+    def child(self) -> Op:
+        return self._child
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._times}, {self._child!r})'
+
+
+@ta.overload
+def repeat(child: Op) -> Repeat:  # noqa
+    ...
+
+
+@ta.overload
+def repeat(times: Repeat.Times, child: Op) -> Repeat:  # noqa
+    ...
+
+
+@ta.overload
+def repeat(min: int, child: Op) -> Repeat:  # noqa
+    ...
+
+
+@ta.overload
+def repeat(min: int, max: int | None, child: Op) -> Repeat:  # noqa
+    ...
+
+
+def repeat(*args):
+    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
+
+    return Repeat(
+        Repeat.Times(
+            check.isinstance(min, int),
+            check.isinstance(max, (int, None)),
+        ),
+        check.isinstance(child, Op),
+    )
+
+
+ZERO_OR_ONE_TIMES = Repeat.Times(0, 1)
+
+
+def option(child: Op) -> Repeat:
+    return Repeat(ZERO_OR_ONE_TIMES, check.isinstance(child, Op))
+
+
+##
+
+
+@ta.final
+class Either(Op, lang.Final):
+    def __init__(self, *children: Op, first_match: bool = False) -> None:
+        super().__init__()
+
+        for c in check.not_empty(children):
+            check.isinstance(c, Op)
+        self._children = children
+        self._first_match = first_match
+
+    @property
+    def children(self) -> ta.Sequence[Op]:
+        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 ""})'
+        )
+
+
+either = Either
+
+
+##
+
+
+@ta.final
+class RuleRef(Op, lang.Final):
+    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)
+
+
+rule = RuleRef

omextra/text/abnf/parsing.py

@@ -0,0 +1,212 @@
+import typing as ta
+
+from omlish import check
+
+from .base import Grammar
+from .base import Match
+from .base import Op
+from .internal import Regex
+from .ops import CaseInsensitiveStringLiteral
+from .ops import Concat
+from .ops import Either
+from .ops import RangeLiteral
+from .ops import Repeat
+from .ops import RuleRef
+from .ops import StringLiteral
+
+
+##
+
+
+class _Parser:
+    def __init__(
+            self,
+            grammar: Grammar,
+            source: str,
+    ) -> None:
+        super().__init__()
+
+        self._grammar = grammar
+        self._source = source
+
+        self._dispatch: dict[type[Op], ta.Any] = {
+            StringLiteral: self._iter_parse_string_literal,
+            CaseInsensitiveStringLiteral: self._iter_parse_case_insensitive_string_literal,
+            RangeLiteral: self._iter_parse_range_literal,
+            Concat: self._iter_parse_concat,
+            Repeat: self._iter_parse_repeat,
+            Either: self._iter_parse_either,
+            RuleRef: self._iter_parse_rule_ref,
+            Regex: self._iter_parse_regex,
+        }
+
+    def _iter_parse_string_literal(self, op: StringLiteral, start: int) -> ta.Iterator[Match]:
+        if start < len(self._source):  # noqa
+            source = self._source[start : start + len(op._value)]  # noqa
+            if source == op._value:  # noqa
+                yield Match(op, start, start + len(source), ())
+
+    def _iter_parse_case_insensitive_string_literal(self, op: CaseInsensitiveStringLiteral, start: int) -> ta.Iterator[Match]:  # noqa
+        if start < len(self._source):  # noqa
+            source = self._source[start : start + len(op._value)].casefold()  # noqa
+            if source == op._value:  # noqa
+                yield Match(op, start, start + len(source), ())
+
+    def _iter_parse_range_literal(self, op: RangeLiteral, start: int) -> ta.Iterator[Match]:
+        try:
+            source = self._source[start]  # noqa
+        except IndexError:
+            return
+        # ranges are always case-sensitive
+        if (value := op._value).lo <= source <= value.hi:  # noqa
+            yield Match(op, start, start + 1, ())
+
+    def _iter_parse_concat(self, op: Concat, start: int) -> ta.Iterator[Match]:
+        i = 0
+        match_tups: list[tuple[Match, ...]] = [()]
+        for cp in op._children:  # noqa
+            next_match_tups: list[tuple[Match, ...]] = []
+            for mt in match_tups:
+                for cm in self.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(op, start, mt[-1].end if mt else start, mt)
+
+    def _iter_parse_repeat(self, op: Repeat, start: int) -> ta.Iterator[Match]:
+        match_tup_set: set[tuple[Match, ...]] = set()
+        last_match_tup_set: set[tuple[Match, ...]] = {()}
+        i = 0
+        while True:
+            if op._times.max is not None and i == op._times.max:  # noqa
+                break
+            next_match_tup_set: set[tuple[Match, ...]] = set()
+            for mt in last_match_tup_set:
+                for cm in self.iter_parse(op._child, mt[-1].end if mt else start):  # noqa
+                    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 < op._times.min:  # noqa
+            return
+        for mt in sorted(match_tup_set or [()], key=len, reverse=True):
+            yield Match(op, start, mt[-1].end if mt else start, mt)  # noqa
+
+    def _iter_parse_either(self, op: Either, start: int) -> ta.Iterator[Match]:
+        for cp in op._children:  # noqa
+            found = False
+            for cm in self.iter_parse(cp, start):
+                found = True
+                yield Match(op, start, cm.end, (cm,))
+            if found and op._first_match:  # noqa
+                return
+
+    def _iter_parse_rule_ref(self, op: RuleRef, start: int) -> ta.Iterator[Match]:
+        cp = self._grammar._rules_by_name_f[op._name_f].op  # noqa
+        for cm in self.iter_parse(cp, start):
+            yield Match(op, cm.start, cm.end, (cm,))
+
+    def _iter_parse_regex(self, op: Regex, start: int) -> ta.Iterator[Match]:
+        raise NotImplementedError
+
+    def iter_parse(self, op: Op, start: int) -> ta.Iterator[Match]:
+        return self._dispatch[op.__class__](op, start)
+
+
+##
+
+
+class _DebugParser(_Parser):
+    def __init__(
+            self,
+            grammar: Grammar,
+            source: str,
+            level: int = 1,
+            *,
+            write: ta.Callable[[str], None] | None = None,
+    ) -> None:
+        super().__init__(grammar, source)
+
+        self._level = level
+        if write is None:
+            write = print
+        self._write = write
+
+        self._op_strs: dict[Op, str] = {}
+
+    def _op_str(self, op: Op) -> str:
+        try:
+            return self._op_strs[op]
+        except KeyError:
+            pass
+        ps = self._op_strs[op] = str(op)
+        return ps
+
+    _depth: int = 0
+
+    def iter_parse(self, op: Op, start: int) -> ta.Iterator[Match]:
+        if self._level < 2 and not isinstance(op, RuleRef):
+            yield from super().iter_parse(op, start)
+            return
+
+        ws = f'{"  " * self._depth} '
+
+        if self._level < 2:
+            ps = check.isinstance(op, RuleRef).name
+        else:
+            ps = self._op_str(op)
+        body = f'{start}:{self._source[start]!r} {ps}'
+
+        if self._level > 2:
+            self._write(f'{ws}+ {body}')
+        else:
+            self._write(f'{ws}{body}')
+
+        try:
+            self._depth += 1
+
+            for m in super().iter_parse(op, start):  # noqa
+                if self._level > 3:
+                    self._write(f'{ws}! {m.start}-{m.end}:{self._source[m.start:m.end]!r}')
+
+                yield m
+
+        finally:
+            self._depth -= 1
+
+            if self._level > 3:
+                self._write(f'{ws}- {body}')
+
+
+##
+
+
+def _iter_parse(
+        grammar: Grammar,
+        source: str,
+        op: Op,
+        start: int,
+        *,
+        debug: int = 0,
+) -> ta.Iterator[Match]:
+    parser: _Parser
+    if debug:
+        parser = _DebugParser(
+            grammar,
+            source,
+            level=debug,
+        )
+    else:
+        parser = _Parser(
+            grammar,
+            source,
+        )
+
+    return parser.iter_parse(op, start)

omextra/text/abnf/utils.py

@@ -6,8 +6,7 @@ from omlish import check
 
 from .base import Grammar
 from .base import Match
-from .errors import AbnfIncompleteParseError
-from .parsers import RuleRef
+from .ops import RuleRef
 
 
 ##
@@ -18,7 +17,7 @@ def strip_insignificant_match_rules(m: Match, g: Grammar) -> Match:
         return c.flat_map_children(
             lambda x: (
                 (rec(x),) if not (
-                    isinstance((xp := x.parser), RuleRef) and
+                    isinstance((xp := x.op), RuleRef) and
                     check.not_none(g.rule(xp.name)).insignificant
                 ) else ()
             ),
@@ -28,7 +27,7 @@ def strip_insignificant_match_rules(m: Match, g: Grammar) -> Match:
 
 def only_match_rules(m: Match) -> Match:
     def rec(c: Match) -> ta.Iterable[Match]:
-        if isinstance(c.parser, RuleRef):
+        if isinstance(c.op, RuleRef):
             return (c.flat_map_children(rec),)
         else:
             return itertools.chain.from_iterable(map(rec, c.children))
@@ -44,7 +43,6 @@ def parse_rules(
         root: str | None = None,
         *,
         start: int = 0,
-        complete: bool = False,
         **kwargs: ta.Any,
 ) -> Match | None:
     if (match := grammar.parse(
@@ -55,9 +53,6 @@ def parse_rules(
     )) is None:
         return None
 
-    if complete and (match.start, match.end) != (start, len(source)):
-        raise AbnfIncompleteParseError
-
     match = only_match_rules(match)
     match = strip_insignificant_match_rules(match, grammar)
 
@@ -67,7 +62,7 @@ def parse_rules(
 ##
 
 
-def fix_grammar_ws(s: str) -> str:
+def fix_ws(s: str) -> str:
     return (
         textwrap.dedent(s)
         .rstrip()

omextra/text/abnf/visitors.py

@@ -6,8 +6,8 @@ from omlish import dispatch
 from omlish import lang
 
 from .base import Match
-from .base import Parser
-from .parsers import RuleRef
+from .base import Op
+from .ops import RuleRef
 
 
 T = ta.TypeVar('T')
@@ -16,21 +16,21 @@ T = ta.TypeVar('T')
 ##
 
 
-class ParserVisitor(lang.Abstract, ta.Generic[T]):
+class OpMatchVisitor(lang.Abstract, ta.Generic[T]):
     @dispatch.method()
-    def visit_parser(self, p: Parser, m: Match) -> T:
-        raise TypeError(p)
+    def visit_op(self, o: Op, m: Match) -> T:
+        raise TypeError(o)
 
     #
 
     def visit_match(self, m: Match) -> T:
-        return self.visit_parser(m.parser, m)
+        return self.visit_op(m.op, m)
 
 
 ##
 
 
-class RuleVisitor(lang.Abstract, ta.Generic[T]):
+class RuleMatchVisitor(lang.Abstract, ta.Generic[T]):
     _registry = col.AttrRegistry[ta.Callable, str]()
 
     @classmethod
@@ -52,4 +52,4 @@ class RuleVisitor(lang.Abstract, ta.Generic[T]):
     #
 
     def visit_match(self, m: Match) -> T:
-        return self.visit_rule(check.isinstance(m.parser, RuleRef).name, m)
+        return self.visit_rule(check.isinstance(m.op, RuleRef).name, m)

{omextra-0.0.0.dev494.dist-info → omextra-0.0.0.dev496.dist-info}/METADATA

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

{omextra-0.0.0.dev494.dist-info → omextra-0.0.0.dev496.dist-info}/RECORD

@@ -65,14 +65,20 @@ omextra/sql/parsing/_antlr/MinisqlVisitor.py,sha256=UPs2qA2VlNRP_LMwF0DpMxMir9tI
 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=4ckTD1WSkte_7LzO7vvhcZ17uEdSrNdnpkkuJBRJ2BY,1095
-omextra/text/abnf/base.py,sha256=xDlMH9jaGXh2PN4DMR6AIMB-zOU_MVy20BcEd6Bpu4U,8128
-omextra/text/abnf/core.py,sha256=VUD52hKgDsesvPjmhL1UZVXtpYr-EpWyBprdy722YTY,2303
+omextra/text/abnf/__init__.py,sha256=nDwr8A5pU8HajHvmAyT8Kr_d_nAUx3tO-ioZXifHob4,1298
+omextra/text/abnf/_dataclasses.py,sha256=YBZeWEvEkYZ8LqJo0MrV5kpKaUWoyLAP7hCT4ziOEh4,18787
+omextra/text/abnf/base.py,sha256=fhZwnsghININSgE7O5NWHBK196LKf_g_xyXwugvR_Vo,7134
+omextra/text/abnf/core.py,sha256=H5U5d-QOI66YSacrLXEcvMQipkabvP8EWo6d9QaxWoU,2283
 omextra/text/abnf/errors.py,sha256=uj1oQvRVRlWkMG8mpmcRUg25kICeIJx5EWAVij3pmXc,142
-omextra/text/abnf/meta.py,sha256=1i2AAGZBLEQhF2HUYQPr385qAMMYLEo0dZT-dcH2Gv0,14447
-omextra/text/abnf/parsers.py,sha256=JKRff1lXbjbKokGL5IBG9tnPflrQ0Fd7X--MRcKTdtE,9209
-omextra/text/abnf/utils.py,sha256=UXJ0MlTkigm3cWuKVU1Ao3bVjQKqy6sZgPni1aVgFgk,1667
-omextra/text/abnf/visitors.py,sha256=kAWPmc3fAOLynLoVl_-ciG_TA3XG7HPca9_I1vI4rL0,1288
+omextra/text/abnf/internal.py,sha256=PzHIzEEv3H5oLI_hwSmkuOwwzh_BZpvXBjGKYqmPvzs,493
+omextra/text/abnf/meta.py,sha256=IvWdyo8739fCmBwVLzz7VrkScc5DM9uVOKUpEb6-lfM,14504
+omextra/text/abnf/ops.py,sha256=LHF1_NfczSypGb3XhNJIT0zWkIx57lzoZSgSELxUE2E,6063
+omextra/text/abnf/parsing.py,sha256=lDMBPCC-3Rs9XwnW_18E7NMjTSz_gz896u21mv15rvs,6676
+omextra/text/abnf/utils.py,sha256=cpPTGeiVFf1AN4K3KgodsOcarEhFxdEcgxtpRx9xB84,1460
+omextra/text/abnf/visitors.py,sha256=S7ZJ2TmQR_RHJ70xWWt3w6UGRD20uE7Nd5UqFYU593k,1266
+omextra/text/abnf/docs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omextra/text/abnf/docs/rfc5234.txt,sha256=I478qv82TBjP29ZpQT-D6_pb3rHOU6wiwN2ZMGiXLLU,26352
+omextra/text/abnf/docs/rfc7405.txt,sha256=Bwt1VISu7eBvlPox9a0iuVD_uCF39teXrEMUQAuuvqU,6661
 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
@@ -146,9 +152,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.dev494.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omextra-0.0.0.dev494.dist-info/METADATA,sha256=E0TGNCRC7ZmGWkMu6P0pMWnSMJ5mPI4iEVBBVkO-qKY,1409
-omextra-0.0.0.dev494.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omextra-0.0.0.dev494.dist-info/entry_points.txt,sha256=-MFAMks5HgZ60Ore0Wl5lKVKk8z4kf1Ls3WY9E_OlCU,37
-omextra-0.0.0.dev494.dist-info/top_level.txt,sha256=o1nCNRejLMcayDngLuWMWwaeOucz33BXbpuoVvvzjPc,8
-omextra-0.0.0.dev494.dist-info/RECORD,,
+omextra-0.0.0.dev496.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omextra-0.0.0.dev496.dist-info/METADATA,sha256=6sf1j4HqLxz1VaR6VxOC4dVNrH97Z0YP0YZZNVgudXc,1409
+omextra-0.0.0.dev496.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omextra-0.0.0.dev496.dist-info/entry_points.txt,sha256=-MFAMks5HgZ60Ore0Wl5lKVKk8z4kf1Ls3WY9E_OlCU,37
+omextra-0.0.0.dev496.dist-info/top_level.txt,sha256=o1nCNRejLMcayDngLuWMWwaeOucz33BXbpuoVvvzjPc,8
+omextra-0.0.0.dev496.dist-info/RECORD,,