omlish 0.0.0.dev51__tar.gz → 0.0.0.dev57__tar.gz

{omlish-0.0.0.dev51/omlish.egg-info → omlish-0.0.0.dev57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev51
+Version: 0.0.0.dev57
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -27,7 +27,7 @@ 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~=5.0; extra == "all"
+Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: cbor2~=5.6; extra == "all"
 Requires-Dist: cloudpickle~=3.0; extra == "all"
 Requires-Dist: httpx[http2]~=0.27; extra == "all"
@@ -43,6 +43,13 @@ Requires-Dist: apsw~=3.46; extra == "all"
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
+Requires-Dist: anyio~=4.6; extra == "all"
+Requires-Dist: sniffio~=1.3; extra == "all"
+Requires-Dist: asttokens~=2.4; extra == "all"
+Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: orjson~=3.10; extra == "all"
+Requires-Dist: pyyaml~=6.0; extra == "all"
+Requires-Dist: wrapt~=1.14; extra == "all"
 Provides-Extra: async
 Requires-Dist: anyio~=4.6; extra == "async"
 Requires-Dist: sniffio~=1.3; extra == "async"
@@ -61,7 +68,7 @@ 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~=5.0; extra == "formats"
+Requires-Dist: pyyaml~=6.0; extra == "formats"
 Requires-Dist: cbor2~=5.6; extra == "formats"
 Requires-Dist: cloudpickle~=3.0; extra == "formats"
 Provides-Extra: http
@@ -83,3 +90,11 @@ Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "sqldrivers
 Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.0; extra == "testing"
+Provides-Extra: plus
+Requires-Dist: anyio~=4.6; extra == "plus"
+Requires-Dist: sniffio~=1.3; extra == "plus"
+Requires-Dist: asttokens~=2.4; extra == "plus"
+Requires-Dist: executing~=2.1; extra == "plus"
+Requires-Dist: orjson~=3.10; extra == "plus"
+Requires-Dist: pyyaml~=6.0; extra == "plus"
+Requires-Dist: wrapt~=1.14; extra == "plus"

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/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",
@@ -42,7 +54,10 @@
     "line": 1,
     "value": {
       "$omdev.cli.types.CliModule": {
-        "cmd_name": "jp",
+        "cmd_name": [
+          "jmespath",
+          "jp"
+        ],
         "mod_name": "omlish.specs.jmespath.__main__"
       }
     }

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev51'
-__revision__ = 'a9d714d2c1bc65f8d907b3e3bc7ad7d71f942d29'
+__version__ = '0.0.0.dev57'
+__revision__ = '6bc82bd3fa6f9a7e33d9f3a69e8d3e1855aa6417'
 
 
 #
@@ -28,6 +28,8 @@ class Project(ProjectBase):
     name = 'omlish'
     description = 'omlish'
 
+    #
+
     optional_dependencies = {
         'async': [
             'anyio ~= 4.6',
@@ -61,7 +63,7 @@ class Project(ProjectBase):
 
             'json5 ~= 0.9',
 
-            'pyyaml ~= 5.0',
+            'pyyaml ~= 6.0',
 
             'cbor2 ~= 5.6',
 
@@ -109,6 +111,32 @@ class Project(ProjectBase):
         ],
     }
 
+    #
+
+    _plus_dependencies = [
+        'anyio',
+        'sniffio',
+
+        'asttokens',
+        'executing',
+
+        'orjson',
+        'pyyaml',
+
+        'wrapt',
+    ]
+
+    _dependency_specs_by_name = (lambda od: {  # noqa
+        s.split()[0]: s
+        for l in od.values() for s in l
+    })(optional_dependencies)
+
+    optional_dependencies['plus'] = (lambda ds, pd: [  # noqa
+        ds[n] for n in pd
+    ])(_dependency_specs_by_name, _plus_dependencies)
+
+    #
+
     entry_points = {
         'omlish.manifests': {name: name},
     }
@@ -134,6 +162,7 @@ class SetuptoolsBase:
             '*.c',
             '*.cc',
             '*.cu',
+            '*.g4',
             '*.h',
 
             '.manifests.json',

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/bootstrap/sys.py

@@ -29,7 +29,7 @@ else:
     libc = lang.proxy_import('..libc', __package__)
     logs = lang.proxy_import('..logs', __package__)
     osu = lang.proxy_import('..os', __package__)
-    dotenv = lang.proxy_import('.formats.dotenv', __package__)
+    dotenv = lang.proxy_import('..formats.dotenv', __package__)
 
 
 ##

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/dataclasses/__init__.py

@@ -89,15 +89,19 @@ from .impl.reflect import (  # noqa
 )
 
 from .utils import (  # noqa
-    chain_metadata,
-    deep_replace,
-    field_modifier,
-    fields_dict,
     maybe_post_init,
+
     opt_repr,
+    truthy_repr,
+
+    fields_dict,
+    field_modifier,
+    chain_metadata,
     update_class_metadata,
-    update_field_extras,
     update_field_metadata,
+    update_field_extras,
     update_fields,
     update_fields_metadata,
+
+    deep_replace,
 )

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/dataclasses/impl/api.py

@@ -33,7 +33,7 @@ def field(  # noqa
         derive: ta.Callable[..., ta.Any] | None = None,
         coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None,
         validate: ta.Callable[[ta.Any], bool] | None = None,
-        check_type: bool | type | None = None,
+        check_type: bool | type | tuple[type | None, ...] | None = None,
         override: bool = False,
         repr_fn: ta.Callable[[ta.Any], str | None] | None = None,
         frozen: bool | None = None,

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/dataclasses/impl/fields.py

@@ -193,7 +193,10 @@ def field_init(
 
     if fx.check_type:
         cn = f'__dataclass_check_type__{f.name}__'
-        if isinstance(fx.check_type, type):
+        ct: ta.Any
+        if isinstance(fx.check_type, tuple):
+            ct = tuple(type(None) if e is None else check_.isinstance(e, type) for e in fx.check_type)
+        elif isinstance(fx.check_type, (type, tuple)):
             ct = fx.check_type
         # FIXME:
         # elif info.params_extras.generic_init:

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/dataclasses/impl/params.py

@@ -45,7 +45,7 @@ class FieldExtras(lang.Final):
     derive: ta.Callable[..., ta.Any] | None = None  # TODO
     coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None
     validate: ta.Callable[[ta.Any], bool] | None = None
-    check_type: bool | type | None = None
+    check_type: bool | type | tuple[type | None, ...] | None = None
     override: bool = False
     repr_fn: ta.Callable[[ta.Any], str | None] | None = None
     frozen: bool | None = None  # TODO

{omlish-0.0.0.dev51 → omlish-0.0.0.dev57}/omlish/dataclasses/utils.py

@@ -33,6 +33,10 @@ def opt_repr(o: ta.Any) -> str | None:
     return repr(o) if o is not None else None
 
 
+def truthy_repr(o: ta.Any) -> str | None:
+    return repr(o) if o else None
+
+
 #
 
 

omlish-0.0.0.dev57/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.dev51/omlish/specs/jmespath → omlish-0.0.0.dev57/omlish/formats/json}/__main__.py

@@ -1,6 +1,6 @@
 # @omlish-manifest
 _CLI_MODULE = {'$omdev.cli.types.CliModule': {
-    'cmd_name': 'jp',
+    'cmd_name': 'json',
     'mod_name': __name__,
 }}
 

omlish-0.0.0.dev57/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.dev57/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.dev57/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.dev57/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-0.0.0.dev51/omlish/formats → omlish-0.0.0.dev57/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.dev57/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()