omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/specs/irc/messages/parsing.py

@@ -1,98 +0,0 @@
-import typing as ta
-
-from .... import dataclasses as dc
-from .base import Message
-from .formats import MessageFormat
-
-
-##
-
-
-class ParseError(Exception):
-    pass
-
-
-def parse_message(cls: type[Message], params: ta.Sequence[str]) -> Message:
-    mf = cls.FORMAT
-
-    kws: dict = {}
-    i = 0
-    for fp in mf.params:
-        if isinstance(fp, MessageFormat.KwargParam):
-            if i >= len(params):
-                if not fp.optional:
-                    raise ParseError(f'Missing param: {fp.name}')
-                continue
-
-            kv: ta.Any
-            if (ar := fp.arity) is MessageFormat.KwargParam.Arity.SINGLE:
-                kv = params[i]
-                i += 1
-
-            elif ar is MessageFormat.KwargParam.Arity.VARIADIC:
-                kv = params[i:]
-                i = len(params)
-
-            elif ar is MessageFormat.KwargParam.Arity.COMMA_LIST:
-                kv = params[i].split(',')
-                i += 1
-
-            else:
-                raise TypeError(ar)
-
-            kws[fp.name] = kv
-
-        elif isinstance(fp, MessageFormat.LiteralParam):
-            if i >= len(params):
-                raise ParseError('Missing literal param')
-
-            pv = params[i]
-            if fp.text != pv:
-                raise ParseError(f'Unexpected literal: {pv}')
-            i += 1
-
-        else:
-            raise TypeError(fp)
-
-    if i != len(params):
-        raise ParseError('Unconsumed params')
-
-    if (up := mf.unpack_params) is not None:
-        kws = dict(up(kws))
-
-    return cls(**kws)
-
-
-##
-
-
-class UnparsedMessage(ta.NamedTuple):
-    name: str
-    params: ta.Sequence[str]
-
-
-def unparse_message(msg: Message) -> UnparsedMessage:
-    mf = msg.FORMAT
-
-    kws = {k: v for k, v in dc.asdict(msg).items() if v is not None}
-
-    if (up := mf.unpack_params) is not None:
-        kws = dict(up.backward(kws))
-
-    params = []
-
-    for fp in mf.params:
-        if isinstance(fp, MessageFormat.KwargParam):
-            # FIXME
-            raise NotImplementedError
-
-        elif isinstance(fp, MessageFormat.LiteralParam):
-            params.append(fp.text)
-
-        else:
-            raise TypeError(fp)
-
-    return UnparsedMessage(
-        name=mf.name,
-        params=params,
-    )

omlish/specs/irc/numerics/formats.py

@@ -1,97 +0,0 @@
-import dataclasses as dc
-import typing as ta
-
-from .... import check
-from .... import lang
-
-
-FormatPart: ta.TypeAlias = ta.Union[str, 'Formats.Optional', 'Formats.Variadic']
-FormatParts: ta.TypeAlias = ta.Sequence[FormatPart]
-
-
-##
-
-
-class Formats(lang.Namespace):
-    @dc.dataclass(frozen=True)
-    class Name:
-        name: str
-
-    @dc.dataclass(frozen=True)
-    class Optional:
-        body: FormatParts
-
-    @dc.dataclass(frozen=True)
-    class Variadic:
-        body: FormatParts
-
-    #
-
-    _PARTS_BY_DELIMITERS: ta.Mapping[tuple[str, str], type] = {
-        ('[', ']'): Optional,
-        ('{', '}'): Variadic,
-    }
-
-    _DELIMITERS_BY_PARTS: ta.Mapping[type, tuple[str, str]] = {v: k for k, v in _PARTS_BY_DELIMITERS.items()}
-
-    #
-
-    @staticmethod
-    def split_parts(s: str) -> FormatParts:
-        stk: list[tuple[str, list]] = [('', [])]
-
-        p = 0
-        while p < len(s):
-            n = lang.find_any(s, '{}[]<', p)
-
-            if n < 0:
-                check.state(not stk[-1][0])
-                stk[-1][1].append(s[p:])
-                break
-
-            if n != p:
-                stk[-1][1].append(s[p:n])
-
-            d = s[n]
-            if d == '<':
-                e = s.index('>', n)
-                stk[-1][1].append(Formats.Name(s[n + 1:e]))
-                p = e + 1
-
-            elif d in '{[':
-                stk.append((d, []))
-                p = n + 1
-
-            elif d in '}]':
-                x, l = stk.pop()
-                pc = Formats._PARTS_BY_DELIMITERS[(x, d)]
-                stk[-1][1].append(pc(l))
-                p = n + 1
-
-            else:
-                raise RuntimeError
-
-        _, ret = check.single(stk)
-        return ret
-
-    #
-
-    @staticmethod
-    def render_parts(p: FormatPart | FormatParts) -> ta.Iterator[str]:
-        if isinstance(p, str):
-            yield p
-
-        elif isinstance(p, Formats.Name):
-            yield '<'
-            yield p.name
-            yield '>'
-
-        elif isinstance(p, (Formats.Optional, Formats.Variadic)):
-            l, r = Formats._DELIMITERS_BY_PARTS[type(p)]
-            yield l
-            yield from Formats.render_parts(p.body)
-            yield r
-
-        else:
-            for c in p:
-                yield from Formats.render_parts(c)