omdev 0.0.0.dev135__py3-none-any.whl → 0.0.0.dev136__py3-none-any.whl

omdev/.manifests.json

@@ -95,6 +95,21 @@
       }
     }
   },
+  {
+    "module": ".json.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/json/__main__.py",
+    "line": 4,
+    "value": {
+      "$.cli.types.CliModule": {
+        "cmd_name": [
+          "json",
+          "j"
+        ],
+        "mod_name": "omdev.json.__main__"
+      }
+    }
+  },
   {
     "module": ".magic.find",
     "attr": "_CLI_MODULE",

omdev/json/__main__.py

@@ -0,0 +1,11 @@
+from ..cli import CliModule
+
+
+# @omlish-manifest
+_CLI_MODULE = CliModule(['json', 'j'], __name__)
+
+
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()

omdev/json/cli.py

@@ -0,0 +1,299 @@
+"""
+TODO:
+ - read from http
+ - jmespath output flat, unquoted strs like jq '.[]'
+
+==
+
+jq Command options:
+  -n, --null-input          use `null` as the single input value;
+  -R, --raw-input           read each line as string instead of JSON;
+  -s, --slurp               read all inputs into an array and use it as the single input value;
+  -c, --compact-output      compact instead of pretty-printed output;
+  -r, --raw-output          output strings without escapes and quotes;
+      --raw-output0         implies -r and output NUL after each output;
+  -j, --join-output         implies -r and output without newline after each output;
+  -a, --ascii-output        output strings by only ASCII characters using escape sequences;
+  -S, --sort-keys           sort keys of each object on output;
+  -C, --color-output        colorize JSON output;
+  -M, --monochrome-output   disable colored output;
+      --tab                 use tabs for indentation;
+      --indent n            use n spaces for indentation (max 7 spaces);
+      --unbuffered          flush output stream after each output;
+      --stream              parse the input value in streaming fashion;
+      --stream-errors       implies --stream and report parse error as an array;
+      --seq                 parse input/output as application/json-seq;
+  -f, --from-file file      load filter from the file;
+  -L directory              search modules from the directory;
+      --arg name value      set $name to the string value;
+      --argjson name value  set $name to the JSON value;
+      --slurpfile name file set $name to an array of JSON values read from the file;
+      --rawfile name file   set $name to string contents of file;
+      --args                consume remaining arguments as positional string values;
+      --jsonargs            consume remaining arguments as positional JSON values;
+  -e, --exit-status         set exit status code based on the output;
+  -V, --version             show the version;
+  --build-configuration     show jq's build configuration;
+  -h, --help                show the help;
+  --                        terminates argument processing;
+"""
+import argparse
+import contextlib
+import dataclasses as dc
+import io
+import os
+import subprocess
+import sys
+import typing as ta
+
+from omlish import check
+from omlish import lang
+from omlish.funcs import pipes as fp
+
+from .formats import FORMATS_BY_NAME
+from .formats import Format
+from .formats import Formats
+from .parsing import DelimitingParser
+from .parsing import EagerParser
+from .parsing import StreamBuilder
+from .parsing import StreamParser
+from .processing import ProcessingOptions
+from .processing import Processor
+from .rendering import EagerRenderer
+from .rendering import RenderingOptions
+from .rendering import StreamRenderer
+
+
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+
+
+def _build_args_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('file', nargs='?')
+
+    parser.add_argument('--stream', action='store_true')
+    parser.add_argument('--stream-build', action='store_true')
+
+    parser.add_argument('-l', '--lines', action='store_true')
+
+    parser.add_argument('--read-buffer-size', type=int, default=0x4000)
+
+    parser.add_argument('-f', '--format')
+
+    parser.add_argument('-x', '--jmespath-expr')
+    parser.add_argument('-F', '--flat', action='store_true')
+
+    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('-R', '--raw', action='store_true')
+    parser.add_argument('-U', '--unicode', action='store_true')
+    parser.add_argument('-c', '--color', action='store_true')
+
+    parser.add_argument('-L', '--less', action='store_true')
+
+    return parser
+
+
+def _parse_args(args: ta.Any = None) -> ta.Any:
+    return _build_args_parser().parse_args(args)
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class RunConfiguration:
+    format: Format
+    processing: ProcessingOptions
+    rendering: RenderingOptions
+
+
+def _process_args(args: ta.Any) -> RunConfiguration:
+    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'
+    format = FORMATS_BY_NAME[fmt_name]  # noqa
+
+    if args.stream:
+        check.arg(format is Formats.JSON.value)
+
+    #
+
+    processing = ProcessingOptions(
+        jmespath_expr=args.jmespath_expr,
+        flat=args.flat,
+    )
+
+    #
+
+    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
+
+    rendering = RenderingOptions(
+        indent=indent,
+        separators=separators,
+        sort_keys=args.sort_keys,
+        raw=args.raw,
+        unicode=args.unicode,
+        color=args.color,
+    )
+
+    #
+
+    return RunConfiguration(
+        format=format,
+        processing=processing,
+        rendering=rendering,
+    )
+
+
+def _main() -> None:
+    args = _parse_args()
+
+    #
+
+    cfg = _process_args(args)
+
+    #
+
+    with contextlib.ExitStack() as es:
+        if args.file is None:
+            in_file = sys.stdin.buffer
+
+        else:
+            in_file = es.enter_context(open(args.file, 'rb'))
+
+        def yield_input() -> ta.Generator[bytes, None, None]:
+            fd = check.isinstance(in_file.fileno(), int)
+
+            while True:
+                buf = os.read(fd, args.read_buffer_size)
+
+                yield buf
+
+                if not buf:
+                    break
+
+        #
+
+        if args.less:
+            less = subprocess.Popen(
+                [
+                    'less',
+                    *(['-R'] if cfg.rendering.color else []),
+                ],
+                stdin=subprocess.PIPE,
+                encoding='utf-8',
+            )
+            out = check.not_none(less.stdin)
+
+            def close_less() -> None:
+                out.close()
+                less.wait()
+
+            es.enter_context(lang.defer(close_less))  # noqa
+
+        else:
+            out = sys.stdout
+
+        #
+
+        parser: ta.Any
+        renderer: ta.Any
+
+        if args.stream:
+            with contextlib.ExitStack() as es2:
+                parser = es2.enter_context(StreamParser())
+
+                def flush_output(
+                        fn: ta.Callable[[T], ta.Iterable[U]],
+                        i: T,
+                ) -> ta.Generator[U, None, None]:
+                    n = 0
+                    for o in fn(i):
+                        yield o
+                        n += 1
+                    if n:
+                        out.flush()
+
+                pipeline: ta.Any
+
+                if args.stream_build:
+                    builder: StreamBuilder = es2.enter_context(StreamBuilder())
+                    processor = Processor(cfg.processing)
+                    renderer = EagerRenderer(cfg.rendering)
+                    trailing_newline = False
+
+                    def append_newlines(
+                            fn: ta.Callable[[T], ta.Iterable[str]],
+                            i: T,
+                    ) -> ta.Generator[str, None, None]:
+                        yield from fn(i)
+                        yield '\n'
+
+                    pipeline = lambda v: (renderer.render(v),)  # Any -> [str]  # noqa
+                    pipeline = fp.bind(append_newlines, pipeline)  # Any -> [str]
+                    pipeline = fp.bind(lang.flatmap, pipeline)  # [Any] -> [str]
+                    pipeline = fp.pipe(fp.bind(lang.flatmap, processor.process), pipeline)  # [Any] -> [str]
+                    pipeline = fp.pipe(fp.bind(lang.flatmap, builder.build), pipeline)  # [JsonStreamParserEvent] -> [str]  # noqa
+                    pipeline = fp.pipe(parser.parse, pipeline)  # bytes -> [str]
+
+                else:
+                    renderer = StreamRenderer(cfg.rendering)
+                    trailing_newline = True
+
+                    pipeline = renderer.render  # JsonStreamParserEvent -> [str]
+                    pipeline = fp.bind(lang.flatmap, pipeline)  # [JsonStreamParserEvent] -> [str]
+                    pipeline = fp.pipe(parser.parse, pipeline)  # bytes -> [str]
+
+                pipeline = fp.bind(flush_output, pipeline)  # bytes -> [str]
+
+                for buf in yield_input():
+                    for s in pipeline(buf):
+                        print(s, file=out, end='')
+
+                if trailing_newline:
+                    print(file=out)
+
+        elif args.lines:
+            parser = DelimitingParser(cfg.format)
+            processor = Processor(cfg.processing)
+            renderer = EagerRenderer(cfg.rendering)
+
+            for buf in yield_input():
+                for v in parser.parse(buf):
+                    for e in processor.process(v):
+                        s = renderer.render(e)
+                        print(s, file=out)
+
+        else:
+            parser = EagerParser(cfg.format)
+            processor = Processor(cfg.processing)
+            renderer = EagerRenderer(cfg.rendering)
+
+            with io.TextIOWrapper(in_file) as tf:
+                v = parser.parse(tf)
+
+            for e in processor.process(v):
+                s = renderer.render(e)
+                print(s, file=out)
+
+
+if __name__ == '__main__':
+    _main()

omdev/json/formats.py

@@ -0,0 +1,71 @@
+"""
+TODO:
+ - options lol - csv header, newline, etc
+"""
+import dataclasses as dc
+import enum
+import json
+import typing as ta
+
+from omlish import lang
+
+
+if ta.TYPE_CHECKING:
+    import ast
+    import csv
+    import tomllib
+
+    import yaml
+
+    from omlish.formats import dotenv
+    from omlish.formats import props
+    from omlish.formats import xml
+
+else:
+    ast = lang.proxy_import('ast')
+    csv = lang.proxy_import('csv')
+    tomllib = lang.proxy_import('tomllib')
+
+    yaml = lang.proxy_import('yaml')
+
+    dotenv = lang.proxy_import('omlish.formats.dotenv')
+    props = lang.proxy_import('omlish.formats.props')
+    xml = lang.proxy_import('omlish.formats.xml')
+
+
+##
+
+
+@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())))
+
+    PY = Format(['py', 'python', 'repr'], lambda f: ast.literal_eval(f.read()))
+
+    XML = Format(['xml'], lambda f: xml.build_simple_element(xml.parse_tree(f.read()).getroot()).as_dict())
+
+    CSV = Format(['csv'], lambda f: list(csv.DictReader(f)))
+    TSV = Format(['tsv'], lambda f: list(csv.DictReader(f, delimiter='\t')))
+    FLAT_CSV = Format(['fcsv'], lambda f: list(csv.reader(f)))
+    FLAT_TSV = Format(['ftsv'], lambda f: list(csv.reader(f, delimiter='\t')))
+
+
+FORMATS_BY_NAME: ta.Mapping[str, Format] = {
+    n: f
+    for e in Formats
+    for f in [e.value]
+    for n in f.names
+}

omdev/json/io.py

@@ -0,0 +1,74 @@
+# """
+# TODO:
+#  - -I/-Ogz, lz4, etc
+#   - fnpairs? or not yet just do it
+# """
+# import abc
+# import contextlib
+# import dataclasses as dc
+# import gzip
+# import os
+# import typing as ta
+#
+# from .... import lang
+#
+#
+# if ta.TYPE_CHECKING:
+#     import bz2 as _bz2
+#     import gzip as _gzip
+#     import lzma as _lzma
+# else:
+#     _bz2 = lang.proxy_import('bz2')
+#     _gzip = lang.proxy_import('gzip')
+#     _lzma = lang.proxy_import('lzma')
+#
+#
+# ##
+#
+#
+# class BaseIo(lang.Abstract):
+#     def close(self) -> None:
+#         raise NotImplementedError
+#
+#     def fileno(self) -> int | None:
+#         return None
+#
+#
+# class Input(BaseIo):
+#     @abc.abstractmethod
+#     def read(self, sz: int | None = None) -> bytes:
+#         raise NotImplementedError
+#
+#
+# class Output(BaseIo):
+#     @abc.abstractmethod
+#     def write(self, data: bytes) -> int:
+#         raise NotImplementedError
+#
+#
+# #
+#
+#
+# DEFAULT_READ_SZ = 0x4000
+#
+#
+# @dc.dataclass(frozen=True)
+# class FdIo(Input, Output):
+#     fd: int
+#
+#     default_read_sz: int = DEFAULT_READ_SZ
+#
+#     def read(self, sz: int | None = None) -> bytes:
+#         return os.read(self.fd, sz or self.default_read_sz)
+#
+#     def write(self, data: bytes) -> int:
+#         return os.write(self.fd, data)
+#
+#
+# ##
+#
+#
+# @contextlib.contextmanager
+# def gzip_io_codec(f: ta.IO, mode: str) -> ta.ContextManager[ta.IO]:
+#     with gzip.open(f, mode) as o:
+#         yield o

omdev/json/parsing.py

@@ -0,0 +1,83 @@
+import codecs
+import io
+import typing as ta
+
+from omlish import check
+from omlish import lang
+from omlish.formats.json.stream.build import JsonObjectBuilder
+from omlish.formats.json.stream.lex import JsonStreamLexer
+from omlish.formats.json.stream.parse import JsonStreamParser
+from omlish.formats.json.stream.parse import JsonStreamParserEvent
+from omlish.lite.io import DelimitingBuffer
+
+from .formats import Format
+
+
+##
+
+
+class EagerParser:
+    def __init__(self, fmt: Format) -> None:
+        super().__init__()
+
+        self._fmt = fmt
+
+    def parse(self, f: ta.TextIO) -> ta.Generator[ta.Any, None, None]:
+        return self._fmt.load(f)
+
+
+##
+
+
+class DelimitingParser:
+    def __init__(
+            self,
+            fmt: Format,
+            *,
+            delimiters: ta.Iterable[int] = b'\n',
+    ) -> None:
+        super().__init__()
+
+        self._fmt = fmt
+
+        self._db = DelimitingBuffer(delimiters)
+
+    def parse(self, b: bytes) -> ta.Generator[ta.Any, None, None]:
+        for chunk in self._db.feed(b):
+            s = check.isinstance(chunk, bytes).decode('utf-8')
+            v = self._fmt.load(io.StringIO(s))
+            yield v
+
+
+##
+
+
+class StreamBuilder(lang.ExitStacked):
+    _builder: JsonObjectBuilder | None = None
+
+    def __enter__(self) -> ta.Self:
+        super().__enter__()
+        self._builder = self._enter_context(JsonObjectBuilder())
+        return self
+
+    def build(self, e: JsonStreamParserEvent) -> ta.Generator[ta.Any, None, None]:
+        yield from check.not_none(self._builder)(e)
+
+
+class StreamParser(lang.ExitStacked):
+    _decoder: codecs.IncrementalDecoder
+    _lex: JsonStreamLexer
+    _parse: JsonStreamParser
+
+    def __enter__(self) -> ta.Self:
+        super().__enter__()
+        self._decoder = codecs.getincrementaldecoder('utf-8')()
+        self._lex = self._enter_context(JsonStreamLexer())
+        self._parse = self._enter_context(JsonStreamParser())
+        return self
+
+    def parse(self, b: bytes) -> ta.Generator[JsonStreamParserEvent, None, None]:
+        for s in self._decoder.decode(b, not b):
+            for c in s:
+                for t in self._lex(c):
+                    yield from self._parse(t)

omdev/json/processing.py

@@ -0,0 +1,48 @@
+import dataclasses as dc
+import typing as ta
+
+from omlish import lang
+
+
+if ta.TYPE_CHECKING:
+    from omlish.specs import jmespath
+else:
+    jmespath = lang.proxy_import('omlish.specs.jmespath')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ProcessingOptions:
+    jmespath_expr: ta.Any | None = None
+    flat: bool = False
+
+
+class Processor:
+    def __init__(self, opts: ProcessingOptions) -> None:
+        super().__init__()
+
+        self._opts = opts
+
+        jmespath_expr = opts.jmespath_expr
+        if isinstance(jmespath_expr, str):
+            jmespath_expr = jmespath.compile(jmespath_expr)
+        self._jmespath_expr: ta.Any | None = jmespath_expr
+
+    def process(self, v: ta.Any) -> ta.Iterable[ta.Any]:
+        if self._jmespath_expr is not None:
+            v = self._jmespath_expr.search(v)
+
+        if self._opts.flat:
+            if (
+                    not isinstance(v, ta.Iterable) or  # noqa
+                    isinstance(v, ta.Mapping) or
+                    isinstance(v, lang.BUILTIN_SCALAR_ITERABLE_TYPES)
+            ):
+                raise TypeError(f'Flat output must be flat collections, got {type(v)}', v)
+
+            yield from v
+
+        else:
+            yield v

omdev/json/rendering.py

@@ -0,0 +1,92 @@
+import dataclasses as dc
+import json
+import typing as ta
+
+from omlish import lang
+from omlish import term
+from omlish.formats.json.render import JsonRenderer
+from omlish.formats.json.stream.parse import JsonStreamParserEvent
+from omlish.formats.json.stream.render import StreamJsonRenderer
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class RenderingOptions:
+    indent: int | str | None = None
+    separators: tuple[str, str] | None = None
+    sort_keys: bool = False
+    raw: bool = False
+    unicode: bool = False
+    color: bool = False
+
+
+def make_render_kwargs(opts: RenderingOptions) -> ta.Mapping[str, ta.Any]:
+    return dict(
+        indent=opts.indent,
+        separators=opts.separators,
+        sort_keys=opts.sort_keys,
+        ensure_ascii=not opts.unicode,
+    )
+
+
+class Renderer(lang.Abstract):
+    def __init__(self, opts: RenderingOptions) -> None:
+        super().__init__()
+        self._opts = opts
+        self._kw = make_render_kwargs(opts)
+
+
+##
+
+
+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 '', ''
+
+
+##
+
+
+class EagerRenderer(Renderer):
+    def render(self, v: ta.Any) -> str:
+        if self._opts.raw:
+            if not isinstance(v, str):
+                raise TypeError(f'Raw output must be strings, got {type(v)}', v)
+
+            return v
+
+        elif self._opts.color:
+            return JsonRenderer.render_str(
+                v,
+                **self._kw,
+                style=term_color,
+            )
+
+        else:
+            return json.dumps(
+                v,
+                **self._kw,
+            )
+
+
+##
+
+
+class StreamRenderer(Renderer):
+    def __init__(self, opts: RenderingOptions) -> None:
+        super().__init__(opts)
+
+        self._renderer = StreamJsonRenderer(
+            style=term_color if self._opts.color else None,
+            delimiter='\n',
+            **self._kw,
+        )
+
+    def render(self, e: JsonStreamParserEvent) -> ta.Generator[str, None, None]:
+        return self._renderer.render((e,))

omdev/packaging/marshal.py

@@ -7,8 +7,8 @@ import typing as ta
 
 from omlish import lang
 from omlish import marshal as msh
-from omlish import matchfns as mfs
 from omlish import reflect as rfl
+from omlish.funcs import match as mfs
 
 from .requires import RequiresMarkerItem
 from .requires import RequiresMarkerList

{omdev-0.0.0.dev135.dist-info → omdev-0.0.0.dev136.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev135
+Version: 0.0.0.dev136
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev135
+Requires-Dist: omlish==0.0.0.dev136
 Provides-Extra: all
 Requires-Dist: black~=24.10; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev135.dist-info → omdev-0.0.0.dev136.dist-info}/RECORD

@@ -1,4 +1,4 @@
-omdev/.manifests.json,sha256=ZbWhw6kNdM060la45GKn5IVYDrhem2rFtsah98rVF38,7479
+omdev/.manifests.json,sha256=AQ_MtyaYpRcm1jSGJIDiCxxwm5CnW3wx9TcjzruR8WY,7769
 omdev/__about__.py,sha256=n5x-SO70OgbDQFzQ1d7sZDVMsnkQc4PxQZPFaIQFa0E,1281
 omdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/bracepy.py,sha256=I8EdqtDvxzAi3I8TuMEW-RBfwXfqKbwp06CfOdj3L1o,2743
@@ -79,6 +79,14 @@ omdev/interp/resolvers.py,sha256=tpzlmqGp1C4QKdA6TfcPmtmaygu7mb6WK2RPSbyNQ6s,302
 omdev/interp/standalone.py,sha256=XcltiL7ypcfV89C82_3knQ3Kx7aW4wnnxf2056ZXC3A,7731
 omdev/interp/system.py,sha256=bI-JhX4GVJqW7wMxnIa-DGJWnCLmFcIsnl9pc1RGY2g,3513
 omdev/interp/types.py,sha256=EMN3StEMkFoQAMUIZd7JYL4uUWqzFGY-2hTL8EBznYM,2437
+omdev/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omdev/json/__main__.py,sha256=A2NlzsXebLuA0Zw6sikwM_tXZsyBYf33Q8qpNhtaY5o,167
+omdev/json/cli.py,sha256=EubIMT-n2XsjWBZjSy2fWXqijlwrIhLsfbkg3SZzi28,9586
+omdev/json/formats.py,sha256=XHabWAQnAQ9uNS7fHu3mdgxoptWw00RVLq08uadD6kk,1753
+omdev/json/io.py,sha256=IoJ5asjS_gUan5TcrGgS0KpJaiSE5YQgEGljFMCcDto,1427
+omdev/json/parsing.py,sha256=QLsdYv-fRFNIWwy8KLr19fQ5RodiQEX2hIw4jndnEXM,2180
+omdev/json/processing.py,sha256=iFm5VqaxJ97WHaun2ed7NEjMxhFeJqf28bLNfoDJft0,1209
+omdev/json/rendering.py,sha256=jNShMfCpFR9-Kcn6cUFuOChXHjg71diuTC4x7Ofmz-o,2240
 omdev/magic/__init__.py,sha256=CBzRB71RLyylkrj8dph6JUEddA8KSMJvDgriHqFfJGU,478
 omdev/magic/find.py,sha256=tTmpWXAleaXG3_kNOsRF7s8D0CpYMXbdz6-HbCNBW90,7070
 omdev/magic/magic.py,sha256=h1nxoW6CV1MRCiHjDt3sO4kmG0qTtTRbkDNiPLGo2BE,224
@@ -91,7 +99,7 @@ omdev/manifests/types.py,sha256=Jv6PAdVLPb9Hh4y6vDhPlWuMNBBViin1bC_u83jfsH4,234
 omdev/mypy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/mypy/debug.py,sha256=WcZw-3Z1njg_KFGqi3DB6RuqbBa3dLArJnjVCuY1Mn0,3003
 omdev/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omdev/packaging/marshal.py,sha256=mWRuZ_okYxRJXylKFQLQpC8Pp7xjkUEfWYNzQIS5A2c,2376
+omdev/packaging/marshal.py,sha256=c4Mdy5-s4O51eEKMWWBwkhTGQ1FoxVI2lD6CxI_cF3k,2379
 omdev/packaging/names.py,sha256=-a7AykFPVR1i6EYJepbe3ABRrZQ_tPPmK5olzbn9HLI,2528
 omdev/packaging/requires.py,sha256=kyyVCM0RyaKqmXd6tU5zf0QjWvCLQMNV_ev5hvOee_o,15731
 omdev/packaging/specifiers.py,sha256=X8xOcwRLXTQYx5mYAS3ijqoTLlCtYESyUu4fX9bvblY,17447
@@ -143,9 +151,9 @@ omdev/tools/sqlrepl.py,sha256=tmFZh80-xsGM62dyQ7_UGLebChrj7IHbIPYBWDJMgVk,5741
 omdev/tools/pawk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tools/pawk/__main__.py,sha256=VCqeRVnqT1RPEoIrqHFSu4PXVMg4YEgF4qCQm90-eRI,66
 omdev/tools/pawk/pawk.py,sha256=Eckymn22GfychCQcQi96BFqRo_LmiJ-EPhC8TTUJdB4,11446
-omdev-0.0.0.dev135.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omdev-0.0.0.dev135.dist-info/METADATA,sha256=3EnPWvtCGkOsFN8UkDHvSreOI-4XnPwZFBWQECGAcPQ,1760
-omdev-0.0.0.dev135.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omdev-0.0.0.dev135.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
-omdev-0.0.0.dev135.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
-omdev-0.0.0.dev135.dist-info/RECORD,,
+omdev-0.0.0.dev136.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omdev-0.0.0.dev136.dist-info/METADATA,sha256=5fzbDwbPmVqwXlevjUg0X61EiA0ZuAQorzhvPrjXzPY,1760
+omdev-0.0.0.dev136.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omdev-0.0.0.dev136.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
+omdev-0.0.0.dev136.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
+omdev-0.0.0.dev136.dist-info/RECORD,,