omlish 0.0.0.dev55__tar.gz → 0.0.0.dev56__tar.gz

{omlish-0.0.0.dev55/omlish.egg-info → omlish-0.0.0.dev56}/PKG-INFO

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

{omlish-0.0.0.dev55 → omlish-0.0.0.dev56}/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-0.0.0.dev55 → omlish-0.0.0.dev56}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev55'
-__revision__ = '6185da5f1914b76d0daffc87fd41272d70bf3806'
+__version__ = '0.0.0.dev56'
+__revision__ = '1d081aeb233ec7ae534199fc0a6c063d4c79fcf7'
 
 
 #

omlish-0.0.0.dev56/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-0.0.0.dev56/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-0.0.0.dev56/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-0.0.0.dev56/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-0.0.0.dev56/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-0.0.0.dev56/omlish/formats/json/cli.py

@@ -0,0 +1,72 @@
+import argparse
+import contextlib
+import json
+import sys
+import typing as ta
+
+from ... import term
+from .render import JsonRenderer
+
+
+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 '', ''
+
+
+def _main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('file', nargs='?')
+    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')
+    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
+
+    with contextlib.ExitStack() as es:
+        if args.file is None:
+            in_file = sys.stdin
+        else:
+            in_file = es.enter_context(open(args.file))
+
+        data = json.load(in_file)
+
+    kw: dict[str, ta.Any] = dict(
+        indent=indent,
+        separators=separators,
+    )
+
+    if args.color:
+        JsonRenderer(
+            sys.stdout,
+            **kw,
+            style=term_color,
+        ).render(data)
+        print()
+
+    else:
+        print(json.dumps(
+            data,
+            **kw,
+        ))
+
+
+if __name__ == '__main__':
+    _main()

{omlish-0.0.0.dev55/omlish/formats → omlish-0.0.0.dev56/omlish/formats/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-0.0.0.dev56/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-0.0.0.dev55 → omlish-0.0.0.dev56/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev55 → omlish-0.0.0.dev56}/omlish.egg-info/SOURCES.txt

@@ -126,9 +126,17 @@ omlish/docker/hub.py
 omlish/docker/manifests.py
 omlish/formats/__init__.py
 omlish/formats/dotenv.py
-omlish/formats/json.py
 omlish/formats/props.py
 omlish/formats/yaml.py
+omlish/formats/json/__init__.py
+omlish/formats/json/__main__.py
+omlish/formats/json/cli.py
+omlish/formats/json/json.py
+omlish/formats/json/render.py
+omlish/formats/json/backends/__init__.py
+omlish/formats/json/backends/orjson.py
+omlish/formats/json/backends/std.py
+omlish/formats/json/backends/ujson.py
 omlish/graphs/__init__.py
 omlish/graphs/dags.py
 omlish/graphs/domination.py

{omlish-0.0.0.dev55 → omlish-0.0.0.dev56}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '~=3.12'
-version = '0.0.0.dev55'
+version = '0.0.0.dev56'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',