omlish 0.0.0.dev55__py3-none-any.whl → 0.0.0.dev57__py3-none-any.whl

omlish/.manifests.json

@@ -35,6 +35,18 @@
       }
     }
   },
+  {
+    "module": ".formats.json.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omlish/formats/json/__main__.py",
+    "line": 1,
+    "value": {
+      "$omdev.cli.types.CliModule": {
+        "cmd_name": "json",
+        "mod_name": "omlish.formats.json.__main__"
+      }
+    }
+  },
   {
     "module": ".specs.jmespath.__main__",
     "attr": "_CLI_MODULE",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev55'
-__revision__ = '6185da5f1914b76d0daffc87fd41272d70bf3806'
+__version__ = '0.0.0.dev57'
+__revision__ = '6bc82bd3fa6f9a7e33d9f3a69e8d3e1855aa6417'
 
 
 #

omlish/formats/json/__init__.py

@@ -0,0 +1,19 @@
+from .json import (  # noqa
+    COMPACT_KWARGS,
+    COMPACT_SEPARATORS,
+    PRETTY_INDENT,
+    PRETTY_KWARGS,
+    detect_encoding,
+    dump,
+    dump_compact,
+    dump_pretty,
+    dumps,
+    dumps_compact,
+    dumps_pretty,
+    load,
+    loads,
+)
+
+from .render import (  # noqa
+    JsonRenderer,
+)

omlish/formats/json/__main__.py

@@ -0,0 +1,11 @@
+# @omlish-manifest
+_CLI_MODULE = {'$omdev.cli.types.CliModule': {
+    'cmd_name': 'json',
+    'mod_name': __name__,
+}}
+
+
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()

omlish/formats/json/backends/orjson.py

@@ -0,0 +1,72 @@
+"""
+def loads(obj: str | bytes | bytearray | memoryview) -> ta.Any | oj.JSONDEcodeError
+def dumps(obj: ta.Any, **DumpOpts) -> bytes
+"""
+import dataclasses as dc
+import typing as ta
+
+from .... import lang
+
+
+if ta.TYPE_CHECKING:
+    import orjson as oj
+else:
+    oj = lang.proxy_import('orjson')
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Options:
+    append_newline: bool = False  # append \n to the output
+
+    indent_2: bool = False  # pretty-print output with an indent of two spaces.
+
+    naive_utc: bool = False  # serialize datetime.datetime objects without a tzinfo as UTC
+
+    non_str_keys: bool = False  # serialize dict keys of type other than str
+
+    omit_microseconds: bool = False  # do not serialize the microsecond field on datetime.datetime and datetime.time instances  # noqa
+
+    passthrough_dataclass: bool = False  # passthrough dataclasses.dataclass instances to default
+    passthrough_datetime: bool = False  # passthrough datetime.datetime, datetime.date, and datetime.time instances to default  # noqa
+    passthrough_subclass: bool = False  # passthrough subclasses of builtin types to default
+
+    serialize_numpy: bool = False  # serialize numpy.ndarray instances
+
+    sort_keys: bool = False  # serialize dict keys in sorted order - the default is to serialize in an unspecified order
+
+    strict_integer: bool = False  # enforce 53-bit limit on integers
+
+    utc_z: bool = False  # serialize a UTC timezone on datetime.datetime instances as Z instead of +00:00
+
+    ##
+
+    def __int__(self) -> int:
+        return (
+            (oj.OPT_APPEND_NEWLINE if self.append_newline else 0) |
+
+            (oj.OPT_INDENT_2 if self.indent_2 else 0) |
+
+            (oj.OPT_NAIVE_UTC if self.naive_utc else 0) |
+
+            (oj.OPT_NON_STR_KEYS if self.non_str_keys else 0) |
+
+            (oj.OPT_OMIT_MICROSECONDS if self.omit_microseconds else 0) |
+
+            (oj.OPT_PASSTHROUGH_DATACLASS if self.passthrough_dataclass else 0) |
+            (oj.OPT_PASSTHROUGH_DATETIME if self.passthrough_datetime else 0) |
+            (oj.OPT_PASSTHROUGH_SUBCLASS if self.passthrough_subclass else 0) |
+
+            (oj.OPT_SERIALIZE_NUMPY if self.serialize_numpy else 0) |
+
+            (oj.OPT_SORT_KEYS if self.sort_keys else 0) |
+
+            (oj.OPT_STRICT_INTEGER if self.strict_integer else 0) |
+
+            (oj.OPT_UTC_Z if self.utc_z else 0)
+        )
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DumpOpts:
+    default: ta.Callable[[ta.Any], ta.Any] | None = None
+    option: Options = Options()

omlish/formats/json/backends/std.py

@@ -0,0 +1,37 @@
+"""
+load(fp: File, **LoadOpts) -> ta.Any | json.JSONDecodeError
+loads(s: str | bytes | bytearray, **LoadOpts) -> ta.Any | json.JSONDecodeError
+dump(obj: ta.Any, fp: File, **DumpOpts) -> None
+dumps(obj: ta.Any, **DumpOpts) -> str
+"""
+import dataclasses as dc
+import json
+import typing as ta
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DumpOpts:
+    cls: type[json.JSONEncoder] | None = None
+    skipkeys: bool = False  # dict keys that are not basic types will be skipped instead of raising a TypeError
+    ensure_ascii: bool = True  # escape non-ASCII characters in JSON strings
+    check_circular: bool = True  # if False a circular reference will result in an RecursionError
+    allow_nan: bool = True  # use JS equivalents for out-of-range float values, otherwise raise ValueError
+    indent: int | None = None  # item indent - 0 will insert only newlines, None is most compact
+    separators: tuple[str, str] | None  = None  # (item_separator, key_separator) - default (', ', ': ') if indent is None else (',', ': ')  # noqa
+    default: ta.Callable[[ta.Any], ta.Any] | None = None  # should return a serializable version of obj or raise TypeError  # noqa
+    sort_keys: bool = False
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class LoadOpts:
+    cls: type[json.JSONDecoder] | None = None
+
+    parse_float: ta.Callable[[str], ta.Any] | None = None  # by default this is equivalent to float(num_str)
+    parse_int: ta.Callable[[str], ta.Any] | None = None  # by default this is equivalent to int(num_str)
+    parse_constant: ta.Callable[[str], ta.Any] | None = None  # # called with one of the following strings: -Infinity, Infinity, NaN  # noqa
+
+    # called with the result of any object literal decoded
+    object_hook: ta.Callable[[dict], ta.Any] | None = None
+
+    # called with the result of any object literal decoded with an ordered list of pairs, by default dict  # noqa
+    object_pairs_hook: ta.Callable[[list[tuple[str, ta.Any]]], ta.Any] | None = None

omlish/formats/json/backends/ujson.py

@@ -0,0 +1,25 @@
+"""
+load(fp: File) -> ta.Any | uj.JSONDecodeError
+loads(s: str | bytes | bytearray) -> ta.Any | uj.JSONDecodeError
+dump(obj: ta.Any, fp: File, **DumpOpts) -> None
+dumps(obj: ta.Any, **DumpOpts) -> None
+"""
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DumpOpts:
+    """
+    https://github.com/ultrajson/ultrajson/blob/2e4aba339b0ab08f893590aaa989d12846afc5d6/python/objToJSON.c#L662
+    """
+
+    ensure_ascii: bool = True  # limits output to ASCII and escapes all extended characters above 127.
+    encode_html_chars: bool = False  # enables special encoding of "unsafe" HTML characters into safer Unicode sequences
+    escape_forward_slashes: bool = True  # whether forward slashes (/) are escaped
+    indent: int = 0
+    sort_keys: bool = False
+    allow_nan: bool = True
+    reject_bytes: bool = True
+    default: ta.Callable[[ta.Any], ta.Any] | None = None  # should return a serializable version of obj or raise TypeError  # noqa
+    separators: tuple[str, str] | None = None

omlish/formats/json/cli.py

@@ -0,0 +1,141 @@
+import argparse
+import contextlib
+import dataclasses as dc
+import enum
+import json
+import subprocess
+import sys
+import typing as ta
+
+from ... import lang
+from ... import term
+from .render import JsonRenderer
+
+
+if ta.TYPE_CHECKING:
+    import tomllib
+
+    import yaml
+
+    from .. import dotenv
+    from .. import props
+
+else:
+    tomllib = lang.proxy_import('tomllib')
+
+    yaml = lang.proxy_import('yaml')
+
+    dotenv = lang.proxy_import('..dotenv', __package__)
+    props = lang.proxy_import('..props', __package__)
+
+
+def term_color(o: ta.Any, state: JsonRenderer.State) -> tuple[str, str]:
+    if state is JsonRenderer.State.KEY:
+        return term.SGR(term.SGRs.FG.BRIGHT_BLUE), term.SGR(term.SGRs.RESET)
+    elif isinstance(o, str):
+        return term.SGR(term.SGRs.FG.GREEN), term.SGR(term.SGRs.RESET)
+    else:
+        return '', ''
+
+
+@dc.dataclass(frozen=True)
+class Format:
+    names: ta.Sequence[str]
+    load: ta.Callable[[ta.TextIO], ta.Any]
+
+
+class Formats(enum.Enum):
+    JSON = Format(['json'], json.load)
+    YAML = Format(['yaml', 'yml'], lambda f: yaml.safe_load(f))
+    TOML = Format(['toml'], lambda f: tomllib.loads(f.read()))
+    ENV = Format(['env', 'dotenv'], lambda f: dotenv.dotenv_values(stream=f))
+    PROPS = Format(['properties', 'props'], lambda f: dict(props.Properties().load(f.read())))
+
+
+FORMATS_BY_NAME: ta.Mapping[str, Format] = {
+    n: f
+    for e in Formats
+    for f in [e.value]
+    for n in f.names
+}
+
+
+def _main() -> None:
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('file', nargs='?')
+    parser.add_argument('-f', '--format')
+    parser.add_argument('-z', '--compact', action='store_true')
+    parser.add_argument('-p', '--pretty', action='store_true')
+    parser.add_argument('-i', '--indent')
+    parser.add_argument('-s', '--sort-keys', action='store_true')
+    parser.add_argument('-c', '--color', action='store_true')
+    parser.add_argument('-l', '--less', action='store_true')
+    args = parser.parse_args()
+
+    separators = None
+    if args.compact:
+        separators = (',', ':')
+
+    indent = None
+    if args.pretty:
+        indent = 2
+    if args.indent:
+        try:
+            indent = int(args.indent)
+        except ValueError:
+            indent = args.indent
+
+    fmt_name = args.format
+    if fmt_name is None:
+        if args.file is not None:
+            ext = args.file.rpartition('.')[2]
+            if ext in FORMATS_BY_NAME:
+                fmt_name = ext
+    if fmt_name is None:
+        fmt_name = 'json'
+    fmt = FORMATS_BY_NAME[fmt_name]
+
+    with contextlib.ExitStack() as es:
+        if args.file is None:
+            in_file = sys.stdin
+        else:
+            in_file = es.enter_context(open(args.file))
+
+        data = fmt.load(in_file)
+
+    kw: dict[str, ta.Any] = dict(
+        indent=indent,
+        separators=separators,
+        sort_keys=args.sort_keys,
+    )
+
+    if args.color:
+        out = JsonRenderer.render_str(
+            data,
+            **kw,
+            style=term_color,
+        )
+
+    else:
+        out = json.dumps(
+            data,
+            **kw,
+        )
+
+    if args.less:
+        subprocess.run(
+            [
+                'less',
+                *(['-R'] if args.color else []),
+            ],
+            input=out.encode(),
+            check=True,
+        )
+
+    else:
+        print(out)
+
+
+if __name__ == '__main__':
+    _main()

omlish/formats/{json.py → json/json.py}

@@ -7,17 +7,6 @@ import functools
 import json as _json
 import typing as ta
 
-from .. import lang
-
-
-if ta.TYPE_CHECKING:
-    import orjson as _orjson
-    import ujson as _ujson
-
-else:
-    _orjson = lang.proxy_import('orjson')
-    _ujson = lang.proxy_import('ujson')
-
 
 ##
 

omlish/formats/json/render.py

@@ -0,0 +1,114 @@
+import enum
+import io
+import json
+import typing as ta
+
+
+class JsonRenderer:
+    class State(enum.Enum):
+        VALUE = enum.auto()
+        KEY = enum.auto()
+
+    def __init__(
+            self,
+            out: ta.TextIO,
+            *,
+            indent: int | str | None = None,
+            separators: tuple[str, str] | None = None,
+            sort_keys: bool = False,
+            style: ta.Callable[[ta.Any, State], tuple[str, str]] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._out = out
+        if isinstance(indent, (str, int)):
+            self._indent = (' ' * indent) if isinstance(indent, int) else indent
+            self._endl = '\n'
+            if separators is None:
+                separators = (',', ': ')
+        elif indent is None:
+            self._indent = self._endl = ''
+            if separators is None:
+                separators = (', ', ': ')
+        else:
+            raise TypeError(indent)
+        self._comma, self._colon = separators
+        self._sort_keys = sort_keys
+        self._style = style
+
+        self._level = 0
+
+    _literals: ta.ClassVar[ta.Mapping[ta.Any, str]] = {
+        True: 'true',
+        False: 'false',
+        None: 'null',
+    }
+
+    def _write(self, s: str) -> None:
+        if s:
+            self._out.write(s)
+
+    def _write_indent(self) -> None:
+        if self._indent:
+            self._write(self._endl)
+            if self._level:
+                self._write(self._indent * self._level)
+
+    def _render(self, o: ta.Any, state: State = State.VALUE) -> None:
+        if self._style is not None:
+            pre, post = self._style(o, state)
+            self._write(pre)
+        else:
+            post = None
+
+        if o is None or isinstance(o, bool):
+            self._write(self._literals[o])
+
+        elif isinstance(o, (str, int, float)):
+            self._write(json.dumps(o))
+
+        elif isinstance(o, ta.Mapping):
+            self._write('{')
+            self._level += 1
+            items = list(o.items())
+            if self._sort_keys:
+                items.sort(key=lambda t: t[0])
+            for i, (k, v) in enumerate(items):
+                if i:
+                    self._write(self._comma)
+                self._write_indent()
+                self._render(k, JsonRenderer.State.KEY)
+                self._write(self._colon)
+                self._render(v)
+            self._level -= 1
+            if o:
+                self._write_indent()
+            self._write('}')
+
+        elif isinstance(o, ta.Sequence):
+            self._write('[')
+            self._level += 1
+            for i, e in enumerate(o):
+                if i:
+                    self._write(self._comma)
+                self._write_indent()
+                self._render(e)
+            self._level -= 1
+            if o:
+                self._write_indent()
+            self._write(']')
+
+        else:
+            raise TypeError(o)
+
+        if post:
+            self._write(post)
+
+    def render(self, o: ta.Any) -> None:
+        self._render(o)
+
+    @classmethod
+    def render_str(cls, o: ta.Any, **kwargs: ta.Any) -> str:
+        out = io.StringIO()
+        cls(out, **kwargs).render(o)
+        return out.getvalue()

omlish/formats/props.py

@@ -508,7 +508,7 @@ class Properties(collections.abc.MutableMapping):
             source_data,
             encoding: str | None = 'iso-8859-1',
             metadoc: bool = False,
-    ) -> None:
+    ) -> ta.Self:
         self.reset(metadoc)
 
         if isinstance(source_data, bytes):
@@ -522,6 +522,8 @@ class Properties(collections.abc.MutableMapping):
 
         self._parse()
 
+        return self
+
     def store(
             self,
             out_stream,
@@ -530,7 +532,7 @@ class Properties(collections.abc.MutableMapping):
             strict: bool = True,
             strip_meta: bool = True,
             timestamp: bool = True,
-    ) -> None:
+    ) -> ta.Self:
         out_codec_info = codecs.lookup(encoding)
         wrapped_out_stream = out_codec_info.streamwriter(out_stream, _jbackslash_replace_codec_name)
         properties_escape_nonprinting = strict and out_codec_info == codecs.lookup('latin_1')
@@ -597,6 +599,8 @@ class Properties(collections.abc.MutableMapping):
                     file=wrapped_out_stream,
                 )
 
+        return self
+
     def list(self, out_stream=sys.stderr) -> None:
         print('-- listing properties --', file=out_stream)
         for key in self._properties:

{omlish-0.0.0.dev55.dist-info → omlish-0.0.0.dev57.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev55
+Version: 0.0.0.dev57
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev55.dist-info → omlish-0.0.0.dev57.dist-info}/RECORD

@@ -1,5 +1,5 @@
-omlish/.manifests.json,sha256=Xj-NnBpowZX7faAyhZ2j7g4fPFFw9Da7ITTC8AojNlM,1135
-omlish/__about__.py,sha256=86pwA2MtS7JWsIagoYPxrhXgpb3BzVvGI5w-JyrXhZM,3420
+omlish/.manifests.json,sha256=wTGXwNmvtaKsDWtTwwj3Uib5Inaj8ZBn0MB69bE80X4,1419
+omlish/__about__.py,sha256=TcVGEzTkX3fMqsIJaOXPCs013BBL_Tc4-lqbwNV4bgs,3420
 omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse.py,sha256=Vr70_85EVLJLgEkRtwOr264tMRtqtlN7ncFfXRUk5aM,6914
 omlish/c3.py,sha256=4vogWgwPb8TbNS2KkZxpoWbwjj7MuHG2lQG-hdtkvjI,8062
@@ -116,9 +116,17 @@ omlish/docker/hub.py,sha256=YcDYOi6t1FA2Sp0RVrmZ9cBXbzFWQ8wTps3wOskA-K0,1955
 omlish/docker/manifests.py,sha256=LR4FpOGNUT3bZQ-gTjB6r_-1C3YiG30QvevZjrsVUQM,7068
 omlish/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/dotenv.py,sha256=UjZl3gac-0U24sDjCCGMcCqO1UCWG2Zs8PZ4JdAg2YE,17348
-omlish/formats/json.py,sha256=61XG6rveb3SSXmYrKvUmRdaVDyMD6C-7yVqXBBMu8t8,1017
-omlish/formats/props.py,sha256=diYjZDsG1s50ImJhkpeinMwjr8952nIVI-0gYhBIvCY,18897
+omlish/formats/props.py,sha256=JwFJbKblqzqnzXf7YKFzQSDfcAXzkKsfoYvad6FPy98,18945
 omlish/formats/yaml.py,sha256=R3NTkjomsIfjsUNmSf_bOaCUIID3JTyHJHsliQDSYQo,6688
+omlish/formats/json/__init__.py,sha256=moSR67Qkju2eYb_qVDtaivepe44mxAnYuC8OCSbtETg,298
+omlish/formats/json/__main__.py,sha256=1wxxKZVkj_u7HCcewwMIbGuZj_Wph95yrUbm474Op9M,188
+omlish/formats/json/cli.py,sha256=4zftNijlIOnGUHYn5J1s4yRDRM1K4udBzS3Kh8R2vNc,3374
+omlish/formats/json/json.py,sha256=y8d8WWgzGZDTjzYc_xe9v4T0foXHI-UP7gjCwnHzUIA,828
+omlish/formats/json/render.py,sha256=6edhSrxXWW3nzRfokp5qaldT0_YAj-HVEan_rErf-vo,3208
+omlish/formats/json/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/formats/json/backends/orjson.py,sha256=GYZx0zgpxwkJbFh4EJLGa6VMoEK-Q6mf5tQp8aXqTDc,2526
+omlish/formats/json/backends/std.py,sha256=00NdUFT9GeWL1EWbgKhWLboDBIuDxr7EiizPZXbRWrc,1973
+omlish/formats/json/backends/ujson.py,sha256=m5-hlEQCMLhat3Hg_8QTyfMH-rSsQGJYdWRWoTWkfhM,1029
 omlish/graphs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/graphs/dags.py,sha256=JpTGxt5rsK7hy5EUy9rNUlIeDStT9ri86m8xEKiHQLE,3063
 omlish/graphs/domination.py,sha256=45iTyn7mZWPJ1ANrqD96aPXqzEeyFpybMvvcVxo9XvQ,7592
@@ -339,9 +347,9 @@ omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
 omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,3296
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
-omlish-0.0.0.dev55.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev55.dist-info/METADATA,sha256=KETPIaUeC-qvI4B-ZMyZKQC6pNl-9-GHQdoNBC5Yc4w,4167
-omlish-0.0.0.dev55.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-omlish-0.0.0.dev55.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev55.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev55.dist-info/RECORD,,
+omlish-0.0.0.dev57.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev57.dist-info/METADATA,sha256=SSyQEUrMKl0Bkig1soCu8_V7T-AVM8weCHYyMkDp8bc,4167
+omlish-0.0.0.dev57.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+omlish-0.0.0.dev57.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev57.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev57.dist-info/RECORD,,