omlish 0.0.0.dev213__py3-none-any.whl → 0.0.0.dev215__py3-none-any.whl

omlish/formats/json5/literals.py

@@ -0,0 +1,130 @@
+"""
+https://spec.json5.org/
+"""
+import io
+import json
+import typing as ta
+
+from ... import lang
+from .errors import Json5Error
+
+
+##
+
+
+LITERAL_VALUES: ta.Mapping[str, ta.Any] = {
+    'true': True,
+    'false': False,
+    'null': None,
+}
+
+
+##
+
+
+STRING_LITERAL_ESCAPES: ta.Mapping[str, str] = {
+    'b': '\\u0008',
+    'f': '\\u000C',
+    'n': '\\u000A',
+    'r': '\\u000D',
+    't': '\\u0009',
+    'v': '\\u000B',
+    '0': '\\u0000',
+    'u': '\\u',
+    '"': '\\"',
+    "'": "'",
+    '\\': '\\\\',
+}
+
+
+def _check_state(b: bool, fmt: str = 'Json5 error', *args: ta.Any) -> None:
+    if not b:
+        raise Json5Error(fmt % args)
+
+
+def translate_string_literal(s: str) -> str:
+    _check_state(len(s) > 1)
+    q = s[0]
+    _check_state(q in '\'"')
+    _check_state(s[-1] == q)
+
+    c = 1
+    e = len(s) - 1
+
+    b = io.StringIO()
+    b.write('"')
+
+    ds = '\\\'"'
+    while True:
+        n = lang.find_any(s, ds, c, e)
+        if n < 0:
+            b.write(s[c:e])
+            break
+
+        _check_state(n < e)
+        b.write(s[c:n])
+
+        x = s[n]
+        if x == '\\':
+            _check_state(n < (e - 1))
+
+            y = s[n + 1]
+            if y in '\n\u2028\u2029':
+                c = n + 2
+
+            elif y == '\r':
+                c = n + 2
+                if c < e and s[c] == '\n':
+                    c += 1
+
+            elif y in 'x':
+                _check_state(n < (e - 3))
+                u = int(s[n + 2:n + 4], 16)
+                b.write(f'\\u00{u:02x}')
+                c = n + 4
+
+            elif (g := STRING_LITERAL_ESCAPES.get(y)) is not None:
+                b.write(g)
+                c = n + 2
+
+            elif not ('0' <= y <= '9'):
+                b.write(y)
+                c = n + 2
+
+            else:
+                raise Json5Error(f'Invalid string literal escape: {x}{y}')
+
+        elif x in '\\\'"':
+            _check_state(x != q)
+            if x == '"':
+                b.write('\\"')
+            else:
+                b.write(x)
+            c = n + 1
+
+        else:
+            raise RuntimeError
+
+    b.write('"')
+    return b.getvalue()
+
+
+def parse_string_literal(s: str) -> str:
+    j = translate_string_literal(s)
+
+    try:
+        return json.loads(j)
+    except json.JSONDecodeError as e:
+        raise Json5Error from e
+
+
+##
+
+
+def parse_number_literal(s: str) -> int | float:
+    s = s.lower()
+
+    if 'x' in s:
+        return int(s, 16)
+    else:
+        return float(s)

omlish/formats/json5/parsing.py

@@ -0,0 +1,79 @@
+# ruff: noqa: N802
+import typing as ta
+
+from omlish import antlr
+
+from ._antlr.Json5Lexer import Json5Lexer  # type: ignore
+from ._antlr.Json5Parser import Json5Parser  # type: ignore
+from ._antlr.Json5Visitor import Json5Visitor  # type: ignore
+from .errors import Json5Error
+from .literals import LITERAL_VALUES
+from .literals import parse_number_literal
+from .literals import parse_string_literal
+
+
+class Json5ParseVisitor(antlr.parsing.StandardParseTreeVisitor, Json5Visitor):
+    def visitArr(self, ctx: Json5Parser.ArrContext):
+        return [self.visit(e) for e in ctx.value()]
+
+    def visitKey(self, ctx: Json5Parser.KeyContext):
+        if (s := ctx.STRING()) is not None:
+            return parse_string_literal(s.getText())
+
+        elif (i := ctx.IDENTIFIER()) is not None:
+            return parse_string_literal(''.join(['"', i.getText(), '"']))
+
+        elif (l := ctx.LITERAL()) is not None:
+            return LITERAL_VALUES[l.getText()]
+
+        elif (n := ctx.NUMERIC_LITERAL()) is not None:
+            return n.getText()
+
+        else:
+            raise RuntimeError(ctx)
+
+    def visitNumber(self, ctx: Json5Parser.NumberContext):
+        return parse_number_literal(ctx.getText())
+
+    def visitObj(self, ctx: Json5Parser.ObjContext):
+        dct: dict[ta.Any, ta.Any] = {}
+        for pair in ctx.pair():
+            key, value = self.visit(pair)
+            dct[key] = value
+        return dct
+
+    def visitPair(self, ctx: Json5Parser.PairContext):
+        key = self.visit(ctx.key())
+        value = self.visit(ctx.value())
+        return (key, value)
+
+    def visitValue(self, ctx: Json5Parser.ValueContext):
+        if (s := ctx.STRING()) is not None:
+            return parse_string_literal(s.getText())
+
+        elif (n := ctx.LITERAL()) is not None:
+            return LITERAL_VALUES[n.getText()]
+
+        else:
+            return super().visitChildren(ctx)
+
+
+def parse(buf: str) -> ta.Any:
+    try:
+        parser = antlr.parsing.make_parser(
+            buf,
+            Json5Lexer,
+            Json5Parser,
+            silent_errors=True,
+        )
+
+        root = parser.json5()
+
+    except antlr.errors.ParseError as e:
+        raise Json5Error from e
+
+    if antlr.parsing.is_eof_context(root):
+        raise Json5Error('Empty input')
+
+    visitor = Json5ParseVisitor()
+    return visitor.visit(root)

omlish/lang/__init__.py

@@ -200,6 +200,7 @@ from .strings import (  # noqa
     BOOL_TRUE_STRINGS,
     STRING_BOOL_VALUES,
     camel_case,
+    find_any,
     indent_lines,
     is_dunder,
     is_ident,
@@ -209,6 +210,7 @@ from .strings import (  # noqa
     prefix_delimited,
     prefix_lines,
     replace_many,
+    rfind_any,
     snake_case,
     strip_prefix,
     strip_suffix,

omlish/lang/imports.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - proxy_init 'as' alias support - attrs of (src, dst)
+"""
 import contextlib
 import importlib.util
 import sys

omlish/lang/strings.py

@@ -42,7 +42,8 @@ def strip_suffix(s: StrOrBytesT, sfx: StrOrBytesT) -> StrOrBytesT:
 def replace_many(
         s: StrOrBytesT,
         old: ta.Iterable[StrOrBytesT],
-        new: StrOrBytesT, count_each: int = -1,
+        new: StrOrBytesT,
+        count_each: int = -1,
 ) -> StrOrBytesT:
     for o in old:
         s = s.replace(o, new, count_each)  # type: ignore
@@ -52,6 +53,37 @@ def replace_many(
 ##
 
 
+def find_any(
+        string: StrOrBytesT,
+        subs: ta.Iterable[StrOrBytesT],
+        start: int | None = None,
+        end: int | None = None,
+) -> int:
+    r = -1
+    for sub in subs:
+        if (p := string.find(sub, start, end)) >= 0:  # type: ignore
+            if r < 0 or p < r:
+                r = p
+    return r
+
+
+def rfind_any(
+        string: StrOrBytesT,
+        subs: ta.Iterable[StrOrBytesT],
+        start: int | None = None,
+        end: int | None = None,
+) -> int:
+    r = -1
+    for sub in subs:
+        if (p := string.rfind(sub, start, end)) >= 0:  # type: ignore
+            if r < 0 or p > r:
+                r = p
+    return r
+
+
+##
+
+
 def camel_case(name: str, *, lower: bool = False) -> str:
     if not name:
         return ''

omlish/lite/marshal.py

@@ -2,6 +2,7 @@
 TODO:
  - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
  - literals
+ - Options.sequence_cls = list, mapping_cls = dict, ... - def with_mutable_containers() -> Options
 """
 # ruff: noqa: UP006 UP007
 import abc
@@ -183,21 +184,55 @@ class IterableObjMarshaler(ObjMarshaler):
 @dc.dataclass(frozen=True)
 class FieldsObjMarshaler(ObjMarshaler):
     ty: type
-    fs: ta.Mapping[str, ObjMarshaler]
+
+    @dc.dataclass(frozen=True)
+    class Field:
+        att: str
+        key: str
+        m: ObjMarshaler
+
+        omit_if_none: bool = False
+
+    fs: ta.Sequence[Field]
+
     non_strict: bool = False
 
+    #
+
+    _fs_by_att: ta.ClassVar[ta.Mapping[str, Field]]
+    _fs_by_key: ta.ClassVar[ta.Mapping[str, Field]]
+
+    def __post_init__(self) -> None:
+        fs_by_att: dict = {}
+        fs_by_key: dict = {}
+        for f in self.fs:
+            check.not_in(check.non_empty_str(f.att), fs_by_att)
+            check.not_in(check.non_empty_str(f.key), fs_by_key)
+            fs_by_att[f.att] = f
+            fs_by_key[f.key] = f
+        self.__dict__['_fs_by_att'] = fs_by_att
+        self.__dict__['_fs_by_key'] = fs_by_key
+
+    #
+
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return {
-            k: m.marshal(getattr(o, k), ctx)
-            for k, m in self.fs.items()
-        }
+        d = {}
+        for f in self.fs:
+            mv = f.m.marshal(getattr(o, f.att), ctx)
+            if mv is None and f.omit_if_none:
+                continue
+            d[f.key] = mv
+        return d
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(**{
-            k: self.fs[k].unmarshal(v, ctx)
-            for k, v in o.items()
-            if not (self.non_strict or ctx.options.non_strict_fields) or k in self.fs
-        })
+        kw = {}
+        for k, v in o.items():
+            if (f := self._fs_by_key.get(k)) is None:
+                if not (self.non_strict or ctx.options.non_strict_fields):
+                    raise KeyError(k)
+                continue
+            kw[f.att] = f.m.unmarshal(v, ctx)
+        return self.ty(**kw)
 
 
 @dc.dataclass(frozen=True)
@@ -332,6 +367,22 @@ def register_single_field_type_obj_marshaler(fld, ty=None):
 ##
 
 
+class ObjMarshalerFieldMetadata:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+
+class OBJ_MARSHALER_FIELD_KEY(ObjMarshalerFieldMetadata):  # noqa
+    pass
+
+
+class OBJ_MARSHALER_OMIT_IF_NONE(ObjMarshalerFieldMetadata):  # noqa
+    pass
+
+
+##
+
+
 class ObjMarshalerManager:
     def __init__(
             self,
@@ -391,14 +442,30 @@ class ObjMarshalerManager:
             if dc.is_dataclass(ty):
                 return FieldsObjMarshaler(
                     ty,
-                    {f.name: rec(f.type) for f in dc.fields(ty)},
+                    [
+                        FieldsObjMarshaler.Field(
+                            att=f.name,
+                            key=check.non_empty_str(fk),
+                            m=rec(f.type),
+                            omit_if_none=check.isinstance(f.metadata.get(OBJ_MARSHALER_OMIT_IF_NONE, False), bool),
+                        )
+                        for f in dc.fields(ty)
+                        if (fk := f.metadata.get(OBJ_MARSHALER_FIELD_KEY, f.name)) is not None
+                    ],
                     non_strict=non_strict_fields,
                 )
 
             if issubclass(ty, tuple) and hasattr(ty, '_fields'):
                 return FieldsObjMarshaler(
                     ty,
-                    {p.name: rec(p.annotation) for p in inspect.signature(ty).parameters.values()},
+                    [
+                        FieldsObjMarshaler.Field(
+                            att=p.name,
+                            key=p.name,
+                            m=rec(p.annotation),
+                        )
+                        for p in inspect.signature(ty).parameters.values()
+                    ],
                     non_strict=non_strict_fields,
                 )
 

omlish/os/files.py

@@ -1,38 +1,10 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import contextlib
 import os
-import shutil
-import tempfile
 import typing as ta
 
 
-@contextlib.contextmanager
-def tmp_dir(
-        root_dir: str | None = None,
-        cleanup: bool = True,
-        **kwargs: ta.Any,
-) -> ta.Iterator[str]:
-    path = tempfile.mkdtemp(dir=root_dir, **kwargs)
-    try:
-        yield path
-    finally:
-        if cleanup:
-            shutil.rmtree(path, ignore_errors=True)
-
-
-@contextlib.contextmanager
-def tmp_file(
-        root_dir: str | None = None,
-        cleanup: bool = True,
-        **kwargs: ta.Any,
-) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
-    with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
-        try:
-            yield f
-        finally:
-            if cleanup:
-                shutil.rmtree(f.name, ignore_errors=True)
-
-
 def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None:
     if exist_ok:
         # First try to bump modification time
@@ -48,3 +20,18 @@ def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None:
         flags |= os.O_EXCL
     fd = os.open(self, flags, mode)
     os.close(fd)
+
+
+def unlink_if_exists(path: str) -> None:
+    try:
+        os.unlink(path)
+    except FileNotFoundError:
+        pass
+
+
+@contextlib.contextmanager
+def unlinking_if_exists(path: str) -> ta.Iterator[None]:
+    try:
+        yield
+    finally:
+        unlink_if_exists(path)

omlish/os/temp.py

@@ -0,0 +1,50 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import contextlib
+import os
+import shutil
+import tempfile
+import typing as ta
+
+from .files import unlink_if_exists
+
+
+def make_temp_file(**kwargs: ta.Any) -> str:
+    file_fd, file = tempfile.mkstemp(**kwargs)
+    os.close(file_fd)
+    return file
+
+
+@contextlib.contextmanager
+def temp_file_context(**kwargs: ta.Any) -> ta.Iterator[str]:
+    path = make_temp_file(**kwargs)
+    try:
+        yield path
+    finally:
+        unlink_if_exists(path)
+
+
+@contextlib.contextmanager
+def temp_dir_context(
+        root_dir: ta.Optional[str] = None,
+        **kwargs: ta.Any,
+) -> ta.Iterator[str]:
+    path = tempfile.mkdtemp(dir=root_dir, **kwargs)
+    try:
+        yield path
+    finally:
+        shutil.rmtree(path, ignore_errors=True)
+
+
+@contextlib.contextmanager
+def temp_named_file_context(
+        root_dir: ta.Optional[str] = None,
+        cleanup: bool = True,
+        **kwargs: ta.Any,
+) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
+    with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
+        try:
+            yield f
+        finally:
+            if cleanup:
+                shutil.rmtree(f.name, ignore_errors=True)

{omlish-0.0.0.dev213.dist-info → omlish-0.0.0.dev215.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev213
+Version: 0.0.0.dev215
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -23,11 +23,10 @@ Requires-Dist: python-snappy~=0.7; extra == "all"
 Requires-Dist: zstandard~=0.23; extra == "all"
 Requires-Dist: brotli~=1.1; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
-Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: executing~=2.2; extra == "all"
 Requires-Dist: psutil~=6.0; extra == "all"
 Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: ujson~=5.10; extra == "all"
-Requires-Dist: json5~=0.9; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: cbor2~=5.6; extra == "all"
 Requires-Dist: cloudpickle~=3.1; extra == "all"
@@ -47,7 +46,7 @@ Requires-Dist: pytest~=8.0; extra == "all"
 Requires-Dist: anyio~=4.8; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
-Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: executing~=2.2; extra == "all"
 Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: wrapt~=1.17; extra == "all"
@@ -64,12 +63,11 @@ Requires-Dist: zstandard~=0.23; extra == "compress"
 Requires-Dist: brotli~=1.1; extra == "compress"
 Provides-Extra: diag
 Requires-Dist: asttokens~=3.0; extra == "diag"
-Requires-Dist: executing~=2.1; extra == "diag"
+Requires-Dist: executing~=2.2; extra == "diag"
 Requires-Dist: psutil~=6.0; extra == "diag"
 Provides-Extra: formats
 Requires-Dist: orjson~=3.10; extra == "formats"
 Requires-Dist: ujson~=5.10; extra == "formats"
-Requires-Dist: json5~=0.9; extra == "formats"
 Requires-Dist: pyyaml~=6.0; extra == "formats"
 Requires-Dist: cbor2~=5.6; extra == "formats"
 Requires-Dist: cloudpickle~=3.1; extra == "formats"
@@ -96,7 +94,7 @@ Provides-Extra: plus
 Requires-Dist: anyio~=4.8; extra == "plus"
 Requires-Dist: sniffio~=1.3; extra == "plus"
 Requires-Dist: asttokens~=3.0; extra == "plus"
-Requires-Dist: executing~=2.1; extra == "plus"
+Requires-Dist: executing~=2.2; extra == "plus"
 Requires-Dist: orjson~=3.10; extra == "plus"
 Requires-Dist: pyyaml~=6.0; extra == "plus"
 Requires-Dist: wrapt~=1.17; extra == "plus"