omdev 0.0.0.dev416__py3-none-any.whl → 0.0.0.dev500__py3-none-any.whl

omdev/irc/messages/parsing.py

@@ -0,0 +1,99 @@
+import typing as ta
+
+from omlish 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,
+    )

omdev/irc/numerics/formats.py

@@ -0,0 +1,97 @@
+import dataclasses as dc
+import typing as ta
+
+from omlish import check
+from omlish 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)