omlish 0.0.0.dev305__py3-none-any.whl → 0.0.0.dev307__py3-none-any.whl

omlish/.manifests.json

@@ -51,6 +51,20 @@
       }
     }
   },
+  {
+    "module": ".formats.edn.codec",
+    "attr": "_EDN_LAZY_CODEC",
+    "file": "omlish/formats/edn/codec.py",
+    "line": 25,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.edn.codec",
+        "attr_name": "EDN_CODEC",
+        "name": "edn",
+        "aliases": null
+      }
+    }
+  },
   {
     "module": ".formats.ini.codec",
     "attr": "_INI_LAZY_CODEC",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev305'
-__revision__ = '13f1bfc223e6af63310421aa4ac6133b3f1e0110'
+__version__ = '0.0.0.dev307'
+__revision__ = '7fd729bd16b72af663b113712ea301f150b2449d'
 
 
 #
@@ -101,7 +101,7 @@ class Project(ProjectBase):
 
             'apsw ~= 3.49',
 
-            'sqlean.py ~= 3.47',
+            'sqlean.py ~= 3.49',
 
             'duckdb ~= 1.2',
         ],

omlish/formats/edn/__init__.py

@@ -0,0 +1,16 @@
+from .parsing import (  # Noqa
+    MetaMaker,
+    parse,
+    parse_list,
+)
+
+from .values import (  # noqa
+    Char,
+    Keyword,
+    List,
+    Map,
+    Set,
+    Symbol,
+    Tagged,
+    Vector,
+)

omlish/formats/edn/codec.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+from ..codecs import make_object_lazy_loaded_codec
+from ..codecs import make_str_object_codec
+from .parsing import parse
+
+
+##
+
+
+def dumps(obj: ta.Any) -> str:
+    # return json.dumps(obj)
+    raise NotImplementedError
+
+
+def loads(s: str) -> ta.Any:
+    return parse(s)
+
+
+##
+
+
+EDN_CODEC = make_str_object_codec('edn', dumps, loads)
+
+# @omlish-manifest
+_EDN_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'EDN_CODEC', EDN_CODEC)

omlish/formats/edn/lexing.py

@@ -0,0 +1,325 @@
+r"""
+https://github.com/edn-format/edn
+https://github.com/antlr/grammars-v4/blob/master/edn/edn.g4
+https://github.com/jorinvo/edn-data/blob/1e5824f63803eb58f35e98839352000053d47115/src/parse.ts
+https://clojure.org/reference/reader#_extensible_data_notation_edn
+"""
+import dataclasses as dc
+import io
+import typing as ta
+
+from ... import check
+from ...funcs.genmachine import GenMachine
+
+
+##
+
+
+TokenKind: ta.TypeAlias = ta.Literal[
+    'STRING',
+    'CHAR',
+    'WORD',
+    'COMMENT',
+
+    'LPAREN',
+    'RPAREN',
+    'LBRACKET',
+    'RBRACKET',
+    'HASH_LBRACE',
+    'LBRACE',
+    'RBRACE',
+
+    'HASH_UNDERSCORE',
+    'META',
+    'QUOTE',
+]
+
+
+class Position(ta.NamedTuple):
+    ofs: int
+    line: int
+    col: int
+
+
+class Token(ta.NamedTuple):
+    kind: TokenKind
+    src: str
+
+    pos: Position
+
+    def __iter__(self):
+        raise TypeError
+
+
+##
+
+
+SINGLE_TOKENS: ta.Mapping[str, TokenKind] = {
+    '(': 'LPAREN',
+    ')': 'RPAREN',
+    '[': 'LBRACKET',
+    ']': 'RBRACKET',
+    '{': 'LBRACE',
+    '}': 'RBRACE',
+
+    '^': 'META',
+    "'": 'QUOTE',
+}
+
+
+HASH_TOKENS: ta.Mapping[str, TokenKind] = {
+    '{': 'HASH_LBRACE',
+    '_': 'HASH_UNDERSCORE',
+}
+
+
+WORD_FIRST_SPECIAL_CHARS = ':.*+!-_?$%&=<>.'
+WORD_BODY_SPECIAL_CHARS = '/'
+
+
+##
+
+
+@dc.dataclass()
+class StreamLexError(Exception):
+    message: str
+
+    pos: Position
+
+
+class StreamLexer(GenMachine[str, Token]):
+    def __init__(self) -> None:
+        self._ofs = 0
+        self._line = 1
+        self._col = 0
+
+        self._buf = io.StringIO()
+
+        super().__init__(self._do_main())
+
+    @property
+    def pos(self) -> Position:
+        return Position(
+            self._ofs,
+            self._line,
+            self._col,
+        )
+
+    def _char_in(self, c: str) -> str:
+        if not isinstance(c, str):
+            raise TypeError(c)
+        if c and len(c) != 1:
+            raise ValueError(c)
+
+        self._ofs += 1
+
+        if c == '\n':
+            self._line += 1
+            self._col = 0
+        else:
+            self._col += 1
+
+        return c
+
+    def _make_tok(
+            self,
+            kind: TokenKind,
+            src: str,
+            pos: Position,
+    ) -> ta.Sequence[Token]:
+        tok = Token(
+            kind,
+            src,
+            pos,
+        )
+        return (tok,)
+
+    def _flip_buf(self) -> str:
+        src = self._buf.getvalue()
+        self._buf.seek(0)
+        self._buf.truncate()
+        return src
+
+    def _raise(self, msg: str, src: Exception | None = None) -> ta.NoReturn:
+        raise StreamLexError(msg, self.pos) from src
+
+    def _do_main(self, p: str | None = None):
+        while True:
+            if p is not None:
+                c = p
+                p = None
+            else:
+                c = self._char_in((yield None))  # noqa
+
+            if not c:
+                return None
+
+            if c.isspace() or c == ',':
+                continue
+
+            if c in SINGLE_TOKENS:
+                yield self._make_tok(SINGLE_TOKENS[c], c, self.pos)
+                continue
+
+            if c == ';':
+                return self._do_comment()
+
+            if c == '"':
+                return self._do_string()
+
+            if c == '\\':
+                return self._do_char()
+
+            if c == '#':
+                return self._do_hash()
+
+            if (
+                    c.isalnum() or
+                    c in WORD_FIRST_SPECIAL_CHARS
+            ):
+                return self._do_word(c)
+
+            self._raise(f'Unexpected input: {c}')
+
+    def _do_comment(self):
+        check.state(self._buf.tell() == 0)
+        self._buf.write(';')
+
+        pos = self.pos
+
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c or c == '\n':
+                break
+
+            self._buf.write(c)
+
+        src = self._flip_buf()
+        yield self._make_tok('COMMENT', src, pos)
+        return self._do_main()
+
+    def _do_string(self):
+        check.state(self._buf.tell() == 0)
+        self._buf.write('"')
+
+        pos = self.pos
+
+        esc = False
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c:
+                self._raise(f'Unterminated string literal: {self._buf.getvalue()}')
+
+            self._buf.write(c)
+            if esc:
+                esc = False
+            elif c == '\\':
+                esc = True
+            elif c == '"':
+                break
+
+        src = self._flip_buf()
+        yield self._make_tok('STRING', src, pos)
+        return self._do_main()
+
+    def _do_char(self):
+        check.state(self._buf.tell() == 0)
+        self._buf.write('\\')
+
+        pos = self.pos
+
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c or not (
+                    c.isalnum() or
+                    c == '\\'
+            ):
+                break
+
+            self._buf.write(c)
+
+        src = self._flip_buf()
+        yield self._make_tok('CHAR', src, pos)
+        return self._do_main(c)
+
+    def _do_hash(self):
+        check.state(self._buf.tell() == 0)
+
+        pos = self.pos
+
+        try:
+            c = self._char_in((yield None))  # noqa
+        except GeneratorExit:
+            self._raise('Unexpected end of input')
+
+        if (ht := HASH_TOKENS.get(c)) is not None:
+            yield self._make_tok(ht, '#' + c, pos)
+            return self._do_main()
+
+        elif (
+                c.isalnum() or
+                c == '#' or
+                c in WORD_FIRST_SPECIAL_CHARS
+        ):
+            return self._do_word('#' + c, pos=pos)
+
+        else:
+            self._raise(f'Unexpected input: {c}')
+
+    def _do_word(self, pfx: str, *, pos: Position | None = None):
+        check.state(self._buf.tell() == 0)
+        self._buf.write(pfx)
+
+        if pos is None:
+            pos = self.pos
+
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c or not (
+                    c.isalnum() or
+                    c in WORD_FIRST_SPECIAL_CHARS or
+                    c in WORD_BODY_SPECIAL_CHARS
+            ):
+                break
+
+            self._buf.write(c)
+
+        src = self._flip_buf()
+        yield self._make_tok('WORD', src, pos)
+        return self._do_main(c)
+
+
+##
+
+
+def test_lex():
+    for s in [
+        '"abc"',
+        '{"a" "b"}',
+        '1',
+        '-1',
+        '{a :b c 420}',
+        '#{a}',
+    ]:
+        print(s)
+        with StreamLexer() as lex:
+            for c in [*s, '']:
+                for t in lex(c):
+                    print(t)
+        print()

omlish/formats/edn/parsing.py

@@ -0,0 +1,400 @@
+# ruff: noqa: PYI055 UP007
+"""
+TODO:
+ - \u0123 in strings
+ - https://clojure.org/reference/reader
+ - reader meta - ^:foo
+ - read table
+"""
+import dataclasses as dc
+import datetime
+import enum
+import io
+import re
+import typing as ta
+
+from ... import check
+from ...funcs.genmachine import GenMachine
+from .lexing import Position
+from .lexing import StreamLexer
+from .lexing import Token
+from .values import Char
+from .values import Collection
+from .values import Keyword
+from .values import List
+from .values import Map
+from .values import Set
+from .values import Symbol
+from .values import Tagged
+from .values import Vector
+
+
+##
+
+
+WORD_CONST_VALUES: ta.Mapping[str, ta.Any] = {
+    'true': True,
+    'false': False,
+    'nil': None,
+
+    '##Inf': float('inf'),
+    '##-Inf': float('-inf'),
+    '##NaN': float('nan'),
+}
+
+
+STRING_ESCAPE_MAP: ta.Mapping[str, str] = {
+    '"': '"',
+    '\\': '\\',
+    'b': '\b',
+    'f': '\f',
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+}
+
+
+CHAR_ESCAPE_MAP: ta.Mapping[str, str] = {
+    'backspace': '\b',
+    'formfeed': '\f',
+    'newline': '\n',
+    'return': '\r',
+    'space': ' ',
+    'tab': '\t',
+}
+
+
+##
+
+
+@dc.dataclass()
+class StreamParseError(Exception):
+    message: str
+
+    pos: Position | None = None
+
+
+@dc.dataclass(frozen=True)
+class MetaMaker:
+    fn: ta.Callable[..., ta.Any]
+
+    def __call__(self, *args: ta.Any, meta: ta.Any | None = None) -> ta.Any:
+        return self.fn(*args, meta=meta)
+
+
+class StreamParser(GenMachine[Token, ta.Any]):
+    DEFAULT_TAG_HANDLERS: ta.ClassVar[ta.Mapping[str, ta.Callable[..., ta.Any]]] = {
+        'inst': lambda val: datetime.datetime.fromisoformat(val) if isinstance(val, str) else None,
+    }
+
+    def __init__(
+            self,
+            *,
+            keyword_maker: ta.Callable[..., ta.Any] = MetaMaker(Keyword),
+            char_maker: ta.Callable[..., ta.Any] = MetaMaker(Char),
+            symbol_maker: ta.Callable[..., ta.Any] = MetaMaker(Symbol),
+
+            list_maker: ta.Callable[..., ta.Any] = MetaMaker(List.new),
+            vector_maker: ta.Callable[..., ta.Any] = MetaMaker(Vector.new),
+            set_maker: ta.Callable[..., ta.Any] = MetaMaker(Set.new),
+            map_maker: ta.Callable[..., ta.Any] = MetaMaker(Map.new),
+
+            tag_handlers: ta.Mapping[str, ta.Callable[..., ta.Any]] | None = None,
+    ) -> None:
+        self._keyword_maker = keyword_maker
+        self._char_maker = char_maker
+        self._symbol_maker = symbol_maker
+
+        self._list_maker = list_maker
+        self._vector_maker = vector_maker
+        self._set_maker = set_maker
+        self._map_maker = map_maker
+
+        self._tag_handlers = {
+            **self.DEFAULT_TAG_HANDLERS,
+            **(tag_handlers or {}),
+        }
+
+        self._stack: list[
+            tuple[
+                ta.Union[
+                    type[Collection],
+                    StreamParser._StackSpecial,
+                ],
+                list[ta.Any],
+            ],
+        ] = []
+
+        super().__init__(self._do_main())
+
+    class _StackSpecial(enum.Enum):  # noqa
+        DISCARD = enum.auto()
+        TAG = enum.auto()
+
+    def _emit_value(self, value: ta.Any) -> tuple[ta.Any, ...]:
+        while self._stack and self._stack[-1][0] is StreamParser._StackSpecial.TAG:
+            cc, cl = self._stack.pop()
+            ts = check.non_empty_str(check.single(cl))
+            value = Tagged(ts, value)
+
+        if not self._stack:
+            return (value,)
+
+        cc, cl = self._stack[-1]
+
+        if cc is StreamParser._StackSpecial.DISCARD:
+            check.empty(cl)
+            self._stack.pop()
+            return ()
+
+        elif cc is StreamParser._StackSpecial.TAG:
+            ts = check.non_empty_str(check.single(cl))
+            self._stack.pop()
+            tv = Tagged(ts, value)
+            return (tv,)
+
+        elif cc is Map:
+            if cl and len(cl[-1]) < 2:
+                cl[-1] = (*cl[-1], value)
+            else:
+                cl.append((value,))
+            return ()
+
+        elif isinstance(cc, type) and issubclass(cc, Collection):
+            cl.append(value)
+            return ()
+
+        else:
+            raise RuntimeError(cc)
+
+    def _do_main(self):
+        while True:
+            tok: Token
+            try:
+                tok = yield None  # noqa
+            except GeneratorExit:
+                if self._stack:
+                    raise StreamParseError('Expected value') from None
+                else:
+                    raise
+
+            value: ta.Any
+
+            # scalars
+
+            if tok.kind == 'STRING':
+                value = self._parse_string(tok)
+
+            elif tok.kind == 'CHAR':
+                value = self._parse_char(tok)
+
+            elif tok.kind == 'WORD':
+                if tok.src.startswith('#'):
+                    # FIXME: more dispatching
+                    self._stack.append((StreamParser._StackSpecial.TAG, [tok.src[1:]]))
+                    continue
+
+                else:
+                    value = self._parse_word(tok)
+
+            elif tok.kind == 'COMMENT':
+                continue
+
+            # open
+
+            elif tok.kind == 'LPAREN':
+                self._stack.append((List, []))
+                continue
+
+            elif tok.kind == 'LBRACKET':
+                self._stack.append((Vector, []))
+                continue
+
+            elif tok.kind == 'HASH_LBRACE':
+                self._stack.append((Set, []))
+                continue
+
+            elif tok.kind == 'LBRACE':
+                self._stack.append((Map, []))
+                continue
+
+            elif tok.kind == 'HASH_UNDERSCORE':
+                self._stack.append((StreamParser._StackSpecial.DISCARD, []))
+                continue
+
+            # close
+
+            elif tok.kind == 'RPAREN':
+                cc, cl = self._stack.pop()
+                check.state(cc is List)
+                value = self._list_maker(cl)
+
+            elif tok.kind == 'RBRACKET':
+                cc, cl = self._stack.pop()
+                check.state(cc is Vector)
+                value = self._vector_maker(cl)
+
+            elif tok.kind == 'RBRACE':
+                cc, cl = self._stack.pop()
+
+                if cc is Set:
+                    value = self._set_maker(cl)
+
+                elif cc is Map:
+                    if cl and len(cl[-1]) != 2:
+                        raise RuntimeError('Mismatched map entries')
+                    value = self._map_maker(cl)
+
+                else:
+                    raise RuntimeError(cc)
+
+            # nyi
+
+            elif tok.kind == 'META':
+                raise NotImplementedError
+
+            elif tok.kind == 'QUOTE':
+                raise NotImplementedError
+
+            # failure
+
+            else:
+                raise ValueError(tok.kind)
+
+            # emit
+
+            if (ev := self._emit_value(value)):
+                yield ev
+
+    def _parse_string(self, tok: Token) -> str:
+        check.state(tok.kind == 'STRING')
+        src = tok.src
+        check.state(src[0] == '"')
+        check.state(src[-1] == '"')
+        check.state(len(src) > 1)
+
+        p = 1
+        end = len(src) - 1
+        if src.find('\\', p, end) < 0:
+            return src[1:-1]
+
+        sb = io.StringIO()
+        while True:
+            if (n := src.find('\\', p, end)) < 0:
+                sb.write(src[p:end])
+                break
+
+            sb.write(src[p:n])
+            p = n + 1
+            check.state(p < end)
+            x = src[p]
+            p += 1
+
+            if x == 'u':
+                check.state(p < end - 4)
+                r = chr(int(src[p:p + 4], 16))
+                p += 4
+
+            else:
+                r = STRING_ESCAPE_MAP[x]
+
+            sb.write(r)
+
+        return sb.getvalue()
+
+    def _parse_char(self, tok: Token) -> ta.Any:
+        check.state(tok.kind == 'CHAR')
+        src = tok.src
+        check.state(len(src) > 1)
+        check.state(src.startswith('\\'))
+
+        if len(src) == 2:
+            c = src[1]
+
+        elif src[1] == 'u':
+            check.state(len(src) == 6)
+            c = chr(int(src[2:], 16))
+
+        elif src[1] == 'o':
+            # \oXXX -> octal
+            raise NotImplementedError
+
+        else:
+            c = CHAR_ESCAPE_MAP[src[1:]]
+
+        return self._char_maker(c)
+
+    _INT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)')
+    _BIGINT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)N')
+    _FLOAT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?(0|[1-9][0-9]*))?M?')
+
+    def _parse_word(self, tok: Token) -> ta.Any:
+        check.state(tok.kind == 'WORD')
+        src = tok.src
+        check.non_empty_str(src)
+        check.state(not src.startswith('#'))
+
+        if src in WORD_CONST_VALUES:
+            return WORD_CONST_VALUES[src]
+
+        elif src.startswith(':'):
+            return self._keyword_maker(src[1:])
+
+        elif self._INT_PAT.fullmatch(src):
+            # FIXME: numbers lol
+            # 2r101010, 052, 8r52, 0x2a, 36r16, and 42 are all the same Long.
+            # Floating point numbers are read as Doubles; with M suffix they are read as BigDecimals.
+            # Ratios are supported, e.g. 22/7.
+            return int(src)
+
+        elif self._BIGINT_PAT.fullmatch(src):
+            return int(src[:-1])
+
+        elif self._FLOAT_PAT.fullmatch(src):
+            return float(src)
+
+        else:
+            return self._symbol_maker(src)
+
+
+##
+
+
+def parse_list(src: str, **kwargs: ta.Any) -> list[ta.Any]:
+    r: list[ta.Any] = []
+    with StreamLexer() as l:
+        with StreamParser(**kwargs) as p:
+            for c in [*src, '']:
+                for t in l(c):
+                    for o in p(t):
+                        r.append(o)  # noqa
+    return r
+
+
+def parse(src: str, **kwargs: ta.Any) -> ta.Any | None:
+    values = parse_list(src, **kwargs)
+    if not values:
+        return None
+    return check.single(values)
+
+
+##
+
+
+def test_parse():
+    for s in [
+        '"abc"',
+        '"a\\bc"',
+        '{"a" "b"}',
+        '1',
+        '-1',
+        '{a :b c 420}',
+        '#{a}',
+        '(1 #_ 2 3)',
+        '"foo\u1234bar"',
+        '\\x',
+        '\\u1234',
+    ]:
+        print(s)
+        print(parse(s))
+        print()

omlish/formats/edn/values.py

@@ -0,0 +1,162 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import lang
+from ...lite.dataclasses import dataclass_cache_hash
+
+
+##
+
+
+_DEBUG = __debug__
+# _DEBUG = True
+
+
+@dc.dataclass(frozen=True)
+class Value(lang.Abstract, lang.Sealed):
+    meta: ta.Any | None = dc.field(default=None, kw_only=True)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Scalar(Value, lang.Abstract):
+    pass
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Keyword(Scalar, lang.Final):
+    s: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.s!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.s, str)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Char(Scalar, lang.Final):
+    c: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.c!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.c, str)
+            check.equal(len(self.c), 1)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Symbol(Scalar, lang.Final):
+    n: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.n!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.n)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Collection(Value, lang.Abstract):
+    pass
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class List(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any], *, meta: ta.Any | None = None) -> 'List':
+        return cls(tuple(items), meta=meta)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Vector(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any], *, meta: ta.Any | None = None) -> 'Vector':
+        return cls(tuple(items), meta=meta)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Set(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any], *, meta: ta.Any | None = None) -> 'Set':
+        return cls(tuple(items), meta=meta)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Map(Collection, lang.Final):
+    items: ta.Sequence[tuple[ta.Any, ta.Any]]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+            for t in self.items:
+                check.isinstance(t, tuple)
+                check.equal(len(t), 2)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Iterable[ta.Any]], *, meta: ta.Any | None = None) -> 'Map':
+        return cls(tuple((k, v) for k, v in items), meta=meta)
+
+
+#
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Tagged(Value, lang.Final):
+    t: str
+    v: ta.Any
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.t!r}, {self.v!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.t)

omlish/formats/json/__init__.py

@@ -35,11 +35,11 @@ from .json import (  # noqa
 )
 
 if _ta.TYPE_CHECKING:
-    from .render import (  # noqa
+    from .rendering import (  # noqa
         JsonRenderer,
     )
 else:
-    _lang.proxy_init(globals(), '.render', [
+    _lang.proxy_init(globals(), '.rendering', [
         'JsonRenderer',
     ])
 

omlish/formats/json/stream/{build.py → building.py}

@@ -1,13 +1,13 @@
 import typing as ta
 
-from .lex import SCALAR_VALUE_TYPES
-from .parse import BeginArray
-from .parse import BeginObject
-from .parse import EndArray
-from .parse import EndObject
-from .parse import JsonStreamObject
-from .parse import JsonStreamParserEvent
-from .parse import Key
+from .lexing import SCALAR_VALUE_TYPES
+from .parsing import BeginArray
+from .parsing import BeginObject
+from .parsing import EndArray
+from .parsing import EndObject
+from .parsing import JsonStreamObject
+from .parsing import JsonStreamParserEvent
+from .parsing import Key
 
 
 ##

omlish/formats/json/stream/{parse.py → parsing.py}

@@ -4,11 +4,11 @@ import typing as ta
 from .... import lang
 from ....funcs.genmachine import GenMachine
 from .errors import JsonStreamError
-from .lex import SCALAR_VALUE_TYPES
-from .lex import VALUE_TOKEN_KINDS
-from .lex import Position
-from .lex import ScalarValue
-from .lex import Token
+from .lexing import SCALAR_VALUE_TYPES
+from .lexing import VALUE_TOKEN_KINDS
+from .lexing import Position
+from .lexing import ScalarValue
+from .lexing import Token
 
 
 ##

omlish/formats/json/stream/{render.py → rendering.py}

@@ -1,14 +1,14 @@
 import io
 import typing as ta
 
-from ..render import AbstractJsonRenderer
+from ..rendering import AbstractJsonRenderer
 from ..types import SCALAR_TYPES
-from .parse import BeginArray
-from .parse import BeginObject
-from .parse import EndArray
-from .parse import EndObject
-from .parse import JsonStreamParserEvent
-from .parse import Key
+from .parsing import BeginArray
+from .parsing import BeginObject
+from .parsing import EndArray
+from .parsing import EndObject
+from .parsing import JsonStreamParserEvent
+from .parsing import Key
 
 
 ##

omlish/formats/json/stream/utils.py

@@ -2,9 +2,9 @@ import dataclasses as dc
 import typing as ta
 
 from .... import lang
-from .build import JsonObjectBuilder
-from .lex import JsonStreamLexer
-from .parse import JsonStreamParser
+from .building import JsonObjectBuilder
+from .lexing import JsonStreamLexer
+from .parsing import JsonStreamParser
 
 
 ##

omlish/funcs/genmachine.py

@@ -34,7 +34,10 @@ class GenMachine(ta.Generic[I, O]):
             if initial is None:
                 raise TypeError('No initial state')
 
-        self._advance(initial)
+        self._gen = initial
+
+        if (n := next(self._gen)) is not None:  # noqa
+            raise GenMachine.NotStartedError
 
     def _initial_state(self) -> MachineGen | None:
         return None
@@ -74,33 +77,34 @@ class GenMachine(ta.Generic[I, O]):
     class Error(Exception):
         pass
 
-    class ClosedError(Exception):
+    class NotStartedError(Error):
         pass
 
-    class StateError(Exception):
+    class ClosedError(Error):
         pass
 
-    #
-
-    def _advance(self, gen: MachineGen) -> None:
-        self._gen = gen
+    class StateError(Error):
+        pass
 
-        if (n := next(self._gen)) is not None:  # noqa
-            raise GenMachine.ClosedError
+    #
 
     def __call__(self, i: I) -> ta.Iterable[O]:
         if self._gen is None:
             raise GenMachine.ClosedError
 
         gi: I | None = i
-        try:
-            while (o := self._gen.send(gi)) is not None:
-                gi = None
-                yield from o
+        while True:
+            try:
+                while (o := self._gen.send(gi)) is not None:  # type: ignore[union-attr]
+                    gi = None
+                    yield from o
 
-        except StopIteration as s:
-            if s.value is None:
-                self._gen = None
-                return None
+                break
 
-            self._advance(s.value)
+            except StopIteration as s:
+                if (sv := s.value) is None:
+                    self._gen = None
+                    return None
+
+                self._gen = sv
+                gi = None

{omlish-0.0.0.dev305.dist-info → omlish-0.0.0.dev307.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev305
+Version: 0.0.0.dev307
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -40,7 +40,7 @@ Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.21; extra == "all"
 Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.49; extra == "all"
-Requires-Dist: sqlean.py~=3.47; extra == "all"
+Requires-Dist: sqlean.py~=3.49; extra == "all"
 Requires-Dist: duckdb~=1.2; extra == "all"
 Requires-Dist: markupsafe~=3.0; extra == "all"
 Requires-Dist: jinja2~=3.1; extra == "all"
@@ -88,7 +88,7 @@ Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.21; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.49; extra == "sqldrivers"
-Requires-Dist: sqlean.py~=3.47; extra == "sqldrivers"
+Requires-Dist: sqlean.py~=3.49; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.2; extra == "sqldrivers"
 Provides-Extra: templates
 Requires-Dist: markupsafe~=3.0; extra == "templates"

{omlish-0.0.0.dev305.dist-info → omlish-0.0.0.dev307.dist-info}/RECORD

@@ -1,5 +1,5 @@
-omlish/.manifests.json,sha256=pjGUyLHaoWpPqRP3jz2u1fC1qoRc2lvrEcpU_Ax2tdg,8253
-omlish/__about__.py,sha256=LvSNEgc-zfbkykExJmNhbtQkXdEXRqPSJufulYnCjfw,3478
+omlish/.manifests.json,sha256=orgsRvtpHu8tdhaCvlP9v3P495OJopYYiHKjK68WtWg,8587
+omlish/__about__.py,sha256=YdK-L7JBeMEmm3Dl7hWjoFj3BouojWQPvOl_zSLUgMA,3478
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -319,16 +319,21 @@ omlish/formats/props.py,sha256=auCv-Jx79KGlWfyG1-Qo0ou-Ex0W_mF3r_lDFdsVkWI,18920
 omlish/formats/repr.py,sha256=kYrNs4o-ji8nOdp6u_L3aMgBMWN1ZAZJSAWgQQfStSQ,414
 omlish/formats/xml.py,sha256=VJfqHR60dhAtjeG8WXFMozFqesTBSGvv264d67eDFXc,3514
 omlish/formats/yaml.py,sha256=jGPQlTE0vSV-p0O7TJRNlf6o1uq4gx8PrHZe1ApJ_o8,7386
+omlish/formats/edn/__init__.py,sha256=H3q5B-dibXvQV8pmuWizTo6Xk75M7M0M7VPCLt86rpo,195
+omlish/formats/edn/codec.py,sha256=k6-Ra3P3Rlv6JA69-jPLI4nCe5XVes_QJbcsj5DYzMM,454
+omlish/formats/edn/lexing.py,sha256=plwbFwHLOmrr5_QhmzvMTmTK55Ot0DxRgKY6ASSl_-Y,6966
+omlish/formats/edn/parsing.py,sha256=rtoOnDo8TuTo_GAhrNoVHu7Ys7CboALdgOF2PevAJYk,10152
+omlish/formats/edn/values.py,sha256=jf0g88KJIMALxcuH51SoaMWg1HqTUqc1ugldmyyXWoc,3707
 omlish/formats/ini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/ini/codec.py,sha256=omuFg0kiDksv8rRlWd_v32ebzEcKlgmiPgGID3bRi2M,631
 omlish/formats/ini/sections.py,sha256=7wYyZdVTQbMPFpjQEACKJfAEPzUBrogINsrvFgxJoZ0,1015
-omlish/formats/json/__init__.py,sha256=1lEtsA5v3F34nlhnWCn2CtoC3cgDIubSsxGz5J9wkZs,780
+omlish/formats/json/__init__.py,sha256=HXFv4VDTBhx0k5U4JYWZqxziBwzJoPX51QK3xIboT8U,786
 omlish/formats/json/codecs.py,sha256=E5KErfqsgGZq763ixXLT3qysbk5MIsypT92xG5aSaIs,796
 omlish/formats/json/consts.py,sha256=A0cTAGGLyjo-gcYIQrL4JIaardI0yPMhQoNmh42BaRg,387
 omlish/formats/json/encoding.py,sha256=O4iIWle7W_-RwpOvJNlqOfkbnDyiQHexV5Za4hlrFzw,497
 omlish/formats/json/json.py,sha256=Mdqv2vdMi7gp96eV0BIYH5UdWpjWfsh-tSMZeywG-08,331
 omlish/formats/json/literals.py,sha256=6ptwZyfTXodEtAjDnUhsx6XU3KRZWWYWKYtZ8T7rzsQ,5625
-omlish/formats/json/render.py,sha256=r6J5YKSzcxPg_RiG5idGqJ-AIZozJQ_Awj6W_oSGRjk,4555
+omlish/formats/json/rendering.py,sha256=r6J5YKSzcxPg_RiG5idGqJ-AIZozJQ_Awj6W_oSGRjk,4555
 omlish/formats/json/types.py,sha256=ueO9-uOU2eVWowJf0LH1fHFLjZ6fTIZyq9qybcLQaiQ,147
 omlish/formats/json/backends/__init__.py,sha256=gnaNDCxy_KmmPUPDnjxO5_WjuWxLGbI9FYWx8ZJuQUU,97
 omlish/formats/json/backends/base.py,sha256=WqtyoM82pyM0NyqpPwndrebr1bUVU1QlpmVQNrcAO8c,1114
@@ -338,12 +343,12 @@ omlish/formats/json/backends/orjson.py,sha256=wR8pMGFtkhZGHcNVk7vNYUnv8lUapdK89p
 omlish/formats/json/backends/std.py,sha256=PM00Kh9ZR2XzollHMEvdo35Eml1N-zFfRW-LOCV5ftM,3085
 omlish/formats/json/backends/ujson.py,sha256=BNJCU4kluGHdqTUKLJEuHhE2m2TmqR7HEN289S0Eokg,2278
 omlish/formats/json/stream/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/formats/json/stream/build.py,sha256=EveVyYjc3lbVQRs8Y5uMGEKp0E_gJAUR5bd2ToSVnSU,2533
+omlish/formats/json/stream/building.py,sha256=SGbExmaerqOEiNSom2AERlpyXTj4dpM0QbMW-2WWM2o,2550
 omlish/formats/json/stream/errors.py,sha256=c8M8UAYmIZ-vWZLeKD2jMj4EDCJbr9QR8Jq_DyHjujQ,43
-omlish/formats/json/stream/lex.py,sha256=ItsWvtl5SZH-HwQtPy8Cpf4nszqDzvUTdIOEmSRiZ-E,6807
-omlish/formats/json/stream/parse.py,sha256=JuYmXwtTHmQJTFKoJNoEHUpCPxXdl_gvKPykVXgED34,6208
-omlish/formats/json/stream/render.py,sha256=NtmDsN92xZi5dkgSSuMeMXMAiJblmjz1arB4Ft7vBhc,3715
-omlish/formats/json/stream/utils.py,sha256=QASlxxQGscktsHrORlt8m9V3VWLDakP01QnsSPHLDQ8,1189
+omlish/formats/json/stream/lexing.py,sha256=ItsWvtl5SZH-HwQtPy8Cpf4nszqDzvUTdIOEmSRiZ-E,6807
+omlish/formats/json/stream/parsing.py,sha256=yvH5Llql3Ri_1xDhi1s9CKL6XLJVSQ8vYJ_dz3KAX-4,6223
+omlish/formats/json/stream/rendering.py,sha256=uuJc__MR0G5kypYMAAudBNjBfiIzA_GGli-DWT90428,3730
+omlish/formats/json/stream/utils.py,sha256=UhBRuWbb25wrdQWl8Ttq7xGRLoa329TvNdecGCZxgzg,1197
 omlish/formats/json5/Json5.g4,sha256=ZUmgJPvj8lSMUD_v3wijp10ZQExYB5mu5Q089dYEJSU,2389
 omlish/formats/json5/__init__.py,sha256=BsjPz5zJDji3GjQ8x8hWvcl1GYPV_ZIHnE3c2Sr8aTU,102
 omlish/formats/json5/codec.py,sha256=ldnxCRo0JP1fkGLt0mMxJlLvNxqIF_1KUCcSp1HtI-M,452
@@ -360,7 +365,7 @@ omlish/formats/toml/codec.py,sha256=5HFGWEPd9IFxPlRMRheX8FEDlRIzLe1moHEOj2_PFKU,
 omlish/formats/toml/parser.py,sha256=c6Hrf6OfVQVtgsYUXL5P5PQQqF-v7r8nkUmprxhV-lI,30536
 omlish/formats/toml/writer.py,sha256=HIp6XvriXaPTLqyLe-fkIiEf1Pyhsp0TcOg5rFBpO3g,3226
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/funcs/genmachine.py,sha256=jvctDOJd3X-S2_8C83sgWYz2llYlyhHN7P19-WsanOs,2506
+omlish/funcs/genmachine.py,sha256=8K5fNvFwxctZcVyulOqPLhZ_6Nwh8RAN6yawiE4wFio,2606
 omlish/funcs/match.py,sha256=gMLZn1enNiFvQaWrQubY300M1BrmdKWzeePihBS7Ywc,6153
 omlish/funcs/pairs.py,sha256=VCkZjDmJGtR76BsejsHNfb4TcpHCtkkmak-zWDFchAo,3904
 omlish/funcs/pipes.py,sha256=E7Sz8Aj8ke_vCs5AMNwg1I36kRdHVGTnzxVQaDyn43U,2490
@@ -847,9 +852,9 @@ omlish/typedvalues/holder.py,sha256=ZTnHiw-K38ciOBLEdwgrltr7Xp8jjEs_0Lp69DH-G-o,
 omlish/typedvalues/marshal.py,sha256=hWHRLcrGav7lvXJDtb9bNI0ickl4SKPQ6F4BbTpqw3A,4219
 omlish/typedvalues/reflect.py,sha256=Ih1YgU-srUjsvBn_P7C66f73_VCvcwqE3ffeBnZBgt4,674
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev305.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev305.dist-info/METADATA,sha256=xv6KDihpZe0TCjJOQAtfs6Yld4oOHnwCwhVuHNkBYR4,4416
-omlish-0.0.0.dev305.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-omlish-0.0.0.dev305.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev305.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev305.dist-info/RECORD,,
+omlish-0.0.0.dev307.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev307.dist-info/METADATA,sha256=UgKZG7ukJ09NYqteFnD8DCdWblMH5cosVoyewHJxBTY,4416
+omlish-0.0.0.dev307.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+omlish-0.0.0.dev307.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev307.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev307.dist-info/RECORD,,

{omlish-0.0.0.dev305.dist-info → omlish-0.0.0.dev307.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any