omlish 0.0.0.dev305__tar.gz → 0.0.0.dev307__tar.gz

{omlish-0.0.0.dev305/omlish.egg-info → omlish-0.0.0.dev307}/PKG-INFO

@@ -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 → omlish-0.0.0.dev307}/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-0.0.0.dev305 → omlish-0.0.0.dev307}/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-0.0.0.dev307/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-0.0.0.dev307/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-0.0.0.dev307/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()