json_write 0.0.1.3__py3-none-any.whl

json_write/__init__.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+# coding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__version__ = (0, 0, 1)
+__all__ = [
+    "json_log_gen_write", "json_log_write", "json_array_gen_write", "json_array_write", 
+    "json_object_gen_write", "json_object_write", "json_groups_gen_write", "json_groups_write", 
+    "json_gen_write", "json_write", "json_ensure_gen_write", "json_ensure_write", 
+]
+
+from collections.abc import Callable, Generator, Iterable, Mapping, Sequence
+from contextlib import contextmanager
+from functools import update_wrapper
+from io import TextIOWrapper
+from os import PathLike
+from os.path import exists
+from operator import itemgetter
+from sys import stdout
+from typing import Optional, Protocol, TypeAlias
+
+dumps: Callable[..., bytes]
+try:
+    from orjson import dumps
+except ImportError:
+    _dumps: Callable[..., str]
+    try:
+        from ujson import dumps as _dumps
+    except ImportError:
+        from json import dumps as _dumps
+    dumps = lambda obj: _dumps(obj, ensure_ascii=False).encode("utf-8")
+
+
+PathType: TypeAlias = bytes | str | PathLike
+
+
+class SupportsWriteBytes(Protocol):
+    def write(self, s: bytes, /) -> object: ...
+
+
+@contextmanager
+def gen_as_ctx(gen: Generator, /):
+    try:
+        yield gen.send
+    finally:
+        gen.close()
+
+
+def gen_startup(func, /):
+    def wrapper(*args, **kwds):
+        r = func(*args, **kwds)
+        next(r)
+        return r
+    return update_wrapper(wrapper, func)
+
+
+def foreach(fn, it, /, *its):
+    if its:
+        for args in zip(it, *its):
+            fn(*args)
+    else:
+        for arg in it:
+            fn(arg)
+
+
+@gen_startup
+def json_log_gen_write(
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    if isinstance(file, TextIOWrapper):
+        file = file.buffer
+    write = file.write
+    while True:
+        val = yield
+        if value is not None:
+            val = value(val)
+        write(dumps(val))
+        write(b"\n")
+
+
+def json_log_write(
+    it: Iterable, 
+    /, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    with gen_as_ctx(json_log_gen_write(value=value, file=file)) as write:
+        foreach(write, it)
+
+
+@gen_startup
+def json_array_gen_write(
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    if isinstance(file, TextIOWrapper):
+        file = file.buffer
+    write = file.write
+    write(b"[")
+    try:
+        not_first = False
+        while True:
+            val = yield
+            if value is not None:
+                val = value(val)
+            if not_first:
+                write(b","+dumps(val))
+            else:
+                write(dumps(val))
+                not_first = True
+    finally:
+        write(b"]")
+
+
+def json_array_write(
+    it: Iterable, 
+    /, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    with gen_as_ctx(json_array_gen_write(value=value, file=file)) as write:
+        foreach(write, it)
+
+
+@gen_startup
+def json_object_gen_write(
+    key: Callable, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    if isinstance(file, TextIOWrapper):
+        file = file.buffer
+    write = file.write
+    write(b"{")
+    try:
+        not_first = False
+        while True:
+            val = yield
+            if value is not None:
+                val = value(val)
+            if not_first:
+                tpl = b",%s:%s"
+            else:
+                tpl = b"%s:%s"
+                not_first = True
+            write(tpl % (dumps(str(key(val))), dumps(val)))
+    finally:
+        write(b"}")
+
+
+def json_object_write(
+    it: Iterable, 
+    /, 
+    key: Optional[Callable] = None, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    if key is None:
+        if isinstance(it, Mapping):
+            if hasattr(it, "items"):
+                it = it.items()
+            else:
+                it = ((k, it[k]) for k in it)
+        key = itemgetter(0)
+        if value is None:
+            value = itemgetter(1)
+        else:
+            value = lambda t, _val=value: _val(t[1])
+    with gen_as_ctx(json_object_gen_write(key, value=value, file=file)) as write:
+        foreach(write, it)
+
+
+@gen_startup
+def json_groups_gen_write(
+    keys: Sequence[Callable], 
+    *, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    assert keys, "empty keys"
+    if isinstance(file, TextIOWrapper):
+        file = file.buffer
+    write = file.write
+    last_ks: tuple[bytes, ...] = ()
+    write(b"{")
+    try:
+        while True:
+            val = yield
+            if value is not None:
+                val = value(val)
+            ks = tuple(dumps(str(key(val))) for key in keys)
+            if last_ks:
+                for i, (k0, k1) in enumerate(zip(last_ks, ks)):
+                    if k0 != k1:
+                        break
+                ks2 = ks[i:-1]
+                if ks2:
+                    write(b"}" * len(ks2))
+                write(b",")
+            else:
+                ks2 = ks[:-1]
+            for k in ks2:
+                write(b"%s:{" % k)
+            write(b"%s:%s" % (ks[-1], dumps(val)))
+            last_ks = ks
+    finally:
+        if last_ks:
+            write(b"}" * len(keys))
+        else:
+            write(b"}")
+
+
+def json_groups_write(
+    it: Iterable, 
+    /, 
+    keys: Sequence[Callable], 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    with gen_as_ctx(json_groups_gen_write(keys, value=value, file=file)) as write:
+        foreach(write, it)
+
+
+def json_gen_write(
+    keys: None | Callable | Sequence[Callable] = None, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    if keys is None:
+        return json_log_gen_write(value=value, file=file)
+    elif callable(keys):
+        return json_object_gen_write(keys, value=value, file=file)
+    elif keys:
+        if len(keys) == 1:
+            return json_object_gen_write(keys[0], value=value, file=file)
+        return json_groups_gen_write(keys, value=value, file=file)
+    else:
+        return json_array_gen_write(value=value, file=file)
+
+
+def json_write(
+    it: Iterable, 
+    /, 
+    keys: None | Callable | Sequence[Callable] = None, 
+    value: Optional[Callable] = None, 
+    file: SupportsWriteBytes | TextIOWrapper = stdout, # type: ignore
+):
+    with gen_as_ctx(json_gen_write(keys=keys, value=value, file=file)) as write:
+        foreach(write, it)
+
+
+@gen_startup
+def json_ensure_gen_write(
+    path: PathType, 
+    key: Optional[Callable] = None, 
+    value: Optional[Callable] = None, 
+    resume: bool = False, 
+    bufsize: int = -1, 
+):
+    if bufsize <= 1:
+        bufsize = -1
+    if resume and exists(path):
+        f = open(path, "r+b", buffering=bufsize)
+    else:
+        f = open(path, "wb", buffering=bufsize)
+    seek = f.seek
+    write = f.write
+    not_first = seek(0, 2) >= 2
+    if not not_first:
+        seek(0)
+    if key is None:
+        while True:
+            val = yield
+            if value is not None:
+                val = value(val)
+            if not_first:
+                seek(-1, 1)
+                tpl = b",%s]"
+            else:
+                tpl = b"[%s]"
+                not_first = True
+            write(tpl % dumps(val))
+    else:
+        while True:
+            val = yield
+            if value is not None:
+                val = value(val)
+            if not_first:
+                seek(-1, 1)
+                tpl = b",%s:%s}"
+            else:
+                tpl = b"{%s:%s}"
+                not_first = True
+            write(tpl % (dumps(str(key(val))), dumps(val)))
+
+
+def json_ensure_write(
+    it: Iterable, 
+    /, 
+    path: PathType, 
+    key: Optional[Callable] = None, 
+    value: Optional[Callable] = None, 
+    resume: bool = False, 
+    bufsize: int = -1, 
+):
+    with gen_as_ctx(json_ensure_gen_write(
+        it, 
+        path, 
+        key=key, 
+        value=value, 
+        resume=resume, 
+        bufsize=bufsize, 
+    )) as write:
+        foreach(write, it)
+

json_write-0.0.1.3.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: json_write
+Version: 0.0.1.3
+Summary: JSON write tools.
+License: MIT
+License-File: LICENSE
+Keywords: json,write
+Author: ChenyangGao
+Author-email: wosiwujm@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Homepage, https://github.com/ChenyangGao/python-modules/tree/main/json_write
+Project-URL: Repository, https://github.com/ChenyangGao/python-modules/tree/main/json_write
+Description-Content-Type: text/markdown
+
+# JSON write tools
+
+## Installation
+
+You can install from [pypi](https://pypi.org/project/json_write/)
+
+```console
+pip install -U json_write
+```
+
+## Usage
+
+...
+

json_write-0.0.1.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+json_write/__init__.py,sha256=LzcC6lI9NJ-l507h-ACdVjW9UNcceg6fbOmN9SISLVc,8358
+json_write/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+json_write-0.0.1.3.dist-info/METADATA,sha256=9fuE5m2_8P-rHXX96WvxdaSvelo3XelkNm51DhToprI,1375
+json_write-0.0.1.3.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+json_write-0.0.1.3.dist-info/licenses/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+json_write-0.0.1.3.dist-info/RECORD,,

json_write-0.0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

json_write-0.0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ChenyangGao <https://github.com/ChenyangGao>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.