pyfracturedjson 2.2.2__cp315-cp315-win32.whl

_rust_wrapper/__init__.py

@@ -0,0 +1,5 @@
+from ._rust_wrapper import *
+
+__doc__ = _rust_wrapper.__doc__
+if hasattr(_rust_wrapper, "__all__"):
+    __all__ = _rust_wrapper.__all__

fracturedjson/__init__.py

@@ -0,0 +1,239 @@
+import json
+from collections.abc import Iterator
+from typing import Callable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fracturedjson import _rust_wrapper # type: ignore[reportMissingModuleSource]
+else:
+    import _rust_wrapper
+
+
+class Encoder(json.encoder.JSONEncoder):
+    def __init__(
+            self,
+            *,
+            skipkeys: bool = False,
+            ensure_ascii: bool = True,
+            check_circular: bool = True,
+            allow_nan: bool = True,
+            sort_keys: bool = False,
+            indent = 4,
+            separators: tuple[str, str] | None = None,
+            default: Callable | None = None,
+            max_inline_complexity = 2,
+            max_compact_array_complexity = 2,
+            max_table_row_complexity = 2,
+            number_list_alignment= "decimal",
+            max_prop_name_padding = 16,
+            **kwargs
+        ):
+        super().__init__(
+            skipkeys=skipkeys,
+            ensure_ascii=ensure_ascii,
+            check_circular=check_circular,
+            allow_nan=allow_nan,
+            sort_keys=sort_keys,
+            indent=indent,
+            separators=separators,
+            default=default
+            )
+        
+        if indent is None:
+            indent = 4
+        self._indent = indent
+        self.line_length = kwargs.get("line_length", 120)
+        self.max_inline_complexity = max_inline_complexity
+        self.max_compact_array_complexity = max_compact_array_complexity
+        self.max_table_row_complexity = max_table_row_complexity
+        self.number_list_alignment = number_list_alignment
+        self.max_prop_name_padding = max_prop_name_padding
+
+        
+    
+    def encode(self, o) -> str:
+        unformatted = json.dumps(o)
+        formatted = _rust_wrapper.reformat_string(
+            unformatted,
+            indent=self._indent,
+            line_length=self.line_length,
+            max_inline_complexity = self.max_inline_complexity,
+            max_compact_array_complexity = self.max_compact_array_complexity,
+            max_table_row_complexity = self.max_table_row_complexity,
+            number_list_alignment = self.number_list_alignment,
+            max_prop_name_padding = self.max_prop_name_padding
+        )
+        return formatted
+    
+    def iterencode(self, o, *args, **kwargs) -> Iterator[str]:
+        return iter(self.encode(o))
+
+
+def dump(
+        obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
+        allow_nan=True, cls=None, indent=None, separators=None,
+        default=None, sort_keys=False, **kw
+        ):
+    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
+    ``.write()``-supporting file-like object).
+
+    If ``skipkeys`` is true then ``dict`` keys that are not basic types
+    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
+    instead of raising a ``TypeError``.
+
+    If ``ensure_ascii`` is false, then the strings written to ``fp`` can
+    contain non-ASCII characters if they appear in strings contained in
+    ``obj``. Otherwise, all such characters are escaped in JSON strings.
+
+    If ``check_circular`` is false, then the circular reference check
+    for container types will be skipped and a circular reference will
+    result in an ``RecursionError`` (or worse).
+
+    If ``allow_nan`` is false, then it will be a ``ValueError`` to
+    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
+    in strict compliance of the JSON specification, instead of using the
+    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+    If ``indent`` is a non-negative integer, then JSON array elements and
+    object members will be pretty-printed with that indent level. An indent
+    level of 0 will only insert newlines. ``None`` is the most compact
+    representation.
+
+    If specified, ``separators`` should be an ``(item_separator, key_separator)``
+    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
+    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
+    you should specify ``(',', ':')`` to eliminate whitespace.
+
+    ``default(obj)`` is a function that should return a serializable version
+    of obj or raise TypeError. The default simply raises TypeError.
+
+    If *sort_keys* is true (default: ``False``), then the output of
+    dictionaries will be sorted by key.
+
+    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+    ``.default()`` method to serialize additional types), specify it with
+    the ``cls`` kwarg; otherwise ``FracturedJSON.Encoder`` is used.
+
+    """
+    return json.dump(
+        obj, fp,
+        cls=Encoder if cls is None else cls,
+        skipkeys=skipkeys, ensure_ascii=ensure_ascii, check_circular=check_circular,
+        allow_nan=allow_nan, indent=indent, separators=separators,
+        default=default, sort_keys=sort_keys,
+        **kw
+    )
+
+def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
+        allow_nan=True, cls=None, indent=None, separators=None,
+        default=None, sort_keys=False, **kw):
+    """Serialize ``obj`` to a JSON formatted ``str``.
+
+    If ``skipkeys`` is true then ``dict`` keys that are not basic types
+    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
+    instead of raising a ``TypeError``.
+
+    If ``ensure_ascii`` is false, then the return value can contain non-ASCII
+    characters if they appear in strings contained in ``obj``. Otherwise, all
+    such characters are escaped in JSON strings.
+
+    If ``check_circular`` is false, then the circular reference check
+    for container types will be skipped and a circular reference will
+    result in an ``RecursionError`` (or worse).
+
+    If ``allow_nan`` is false, then it will be a ``ValueError`` to
+    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
+    strict compliance of the JSON specification, instead of using the
+    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+    If ``indent`` is a non-negative integer, then JSON array elements and
+    object members will be pretty-printed with that indent level. An indent
+    level of 0 will only insert newlines. ``None`` is the most compact
+    representation.
+
+    If specified, ``separators`` should be an ``(item_separator, key_separator)``
+    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
+    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
+    you should specify ``(',', ':')`` to eliminate whitespace.
+
+    ``default(obj)`` is a function that should return a serializable version
+    of obj or raise TypeError. The default simply raises TypeError.
+
+    If *sort_keys* is true (default: ``False``), then the output of
+    dictionaries will be sorted by key.
+
+    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+    ``.default()`` method to serialize additional types), specify it with
+    the ``cls`` kwarg; otherwise ``FracturedJSON.Encoder`` is used.
+
+    """
+    return json.dumps(
+        obj,
+        cls=Encoder if cls is None else cls,
+        skipkeys=skipkeys, ensure_ascii=ensure_ascii, check_circular=check_circular,
+        allow_nan=allow_nan, indent=indent, separators=separators,
+        default=default, sort_keys=sort_keys,
+        **kw
+    )
+
+def load(fp, *, cls=None, object_hook=None, parse_float=None,
+        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
+    """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
+    a JSON document) to a Python object.
+
+    ``object_hook`` is an optional function that will be called with the
+    result of any object literal decode (a ``dict``). The return value of
+    ``object_hook`` will be used instead of the ``dict``. This feature
+    can be used to implement custom decoders (e.g. JSON-RPC class hinting).
+
+    ``object_pairs_hook`` is an optional function that will be called with the
+    result of any object literal decoded with an ordered list of pairs.  The
+    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
+    This feature can be used to implement custom decoders.  If ``object_hook``
+    is also defined, the ``object_pairs_hook`` takes priority.
+
+    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+    kwarg; otherwise ``JSONDecoder`` is used.
+    """
+    return json.load(fp, cls=cls, object_hook=object_hook, parse_float=parse_float,
+        parse_int=parse_int, parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)
+
+def loads(fp, *, cls=None, object_hook=None, parse_float=None,
+        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
+    """Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
+    containing a JSON document) to a Python object.
+
+    ``object_hook`` is an optional function that will be called with the
+    result of any object literal decode (a ``dict``). The return value of
+    ``object_hook`` will be used instead of the ``dict``. This feature
+    can be used to implement custom decoders (e.g. JSON-RPC class hinting).
+
+    ``object_pairs_hook`` is an optional function that will be called with the
+    result of any object literal decoded with an ordered list of pairs.  The
+    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
+    This feature can be used to implement custom decoders.  If ``object_hook``
+    is also defined, the ``object_pairs_hook`` takes priority.
+
+    ``parse_float``, if specified, will be called with the string
+    of every JSON float to be decoded. By default this is equivalent to
+    float(num_str). This can be used to use another datatype or parser
+    for JSON floats (e.g. decimal.Decimal).
+
+    ``parse_int``, if specified, will be called with the string
+    of every JSON int to be decoded. By default this is equivalent to
+    int(num_str). This can be used to use another datatype or parser
+    for JSON integers (e.g. float).
+
+    ``parse_constant``, if specified, will be called with one of the
+    following strings: -Infinity, Infinity, NaN.
+    This can be used to raise an exception if invalid JSON numbers
+    are encountered.
+
+    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+    kwarg; otherwise ``JSONDecoder`` is used.
+    """
+    return json.loads(fp, cls=cls, object_hook=object_hook, parse_float=parse_float,
+        parse_int=parse_int, parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)
+
+def detect_encoding(b: bytes | bytearray):
+    return json.detect_encoding(b)

fracturedjson/_rust_wrapper.pyi

@@ -0,0 +1,22 @@
+"""Internal. Wraps a rust file, that reformats a json string to FracturedJSON"""
+
+def reformat_string(
+        input_string: str,
+        *,
+        indent:int,
+        line_length:int,
+        max_inline_complexity:int,
+        max_compact_array_complexity:int,
+        max_table_row_complexity:int,
+        number_list_alignment:str,
+        max_prop_name_padding:int
+        ) -> str:
+    """Reformat a JSON string.
+    
+    Args:
+        input: A JSON string to reformat.
+        
+    Returns:
+        The reformatted JSON string.        
+    """
+    ...

pyfracturedjson-2.2.2.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: pyfracturedjson
+Version: 2.2.2
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+License-File: LICENSE
+Summary: A compact yet readable JSON formatter
+Keywords: json,formatter,fracturedjson,compact,readable
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/g-b-f/pyFracturedJSON/blob/master/CHANGELOG.md
+Project-URL: Repository, https://github.com/g-b-f/pyFracturedJSON
+
+<div align="center">
+
+# pyFracturedJSON
+
+**Adds [FracturedJSON](https://github.com/j-brooke/FracturedJson) support to python,
+letting you create JSON that is both compact and readable.**
+
+<a href="https://pypi.org/project/pyfracturedjson">
+<img alt="PyPI Version" src="https://img.shields.io/pypi/v/pyfracturedjson?cacheSeconds=3600">
+<img alt="minimum python version" src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpyfracturedjson%2Fjson&query=%24.info.requires_python&label=requires%20python&cacheSeconds=3600">
+</a>
+</div>
+</br>
+
+You can trivially use it as a drop-in replacement for the built-in `json` module:
+
+```python
+import fracturedjson as json
+
+long_list = [f"thing_{i}" for i in range(20)]
+data = {"abcd": "abcd", "long_list": long_list}
+
+print(json.dumps(data))
+print(json.dumps(data, line_length=50))
+print(json.dumps(data, indent=2))
+
+with open("file.json", "w") as f:
+    json.dump(data, f)
+
+with open("file.json") as f:
+    json.load(f)
+
+json.loads('{"foo":"bar"}')
+```
+
+Or, if you'd prefer:
+
+```python
+import json
+from fracturedjson import Encoder
+
+long_list = [f"thing_{i}" for i in range(20)]
+data = {"abcd": "abcd", "long_list": long_list}
+
+print(json.dumps(data, cls=Encoder))
+print(json.dumps(data, cls=Encoder, line_length=50))
+print(json.dumps(data, cls=Encoder, indent=2))
+
+with open("file.json", "w") as f:
+    json.dump(data, f, cls=Encoder)
+```
+
+This is largely a wrapper around [fracturedjson-rs](https://github.com/fcoury/fracturedjson-rs),
+so credit to the creator.

pyfracturedjson-2.2.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+_rust_wrapper/__init__.py,sha256=_OZ0ZjGSxq5kGDhgN6USYLwglh4x7KWblKJTRlFDNCo,135
+_rust_wrapper/_rust_wrapper.cp315-win32.pyd,sha256=6BpWRi5wRNt5400yqH6OFuG-58Ibb5gXCImWy3l86Ss,318464
+fracturedjson/__init__.py,sha256=2g2BmK7mNT0AGPiQF52xVkEi32z4z049IWxeqF_8XRk,10830
+fracturedjson/_rust_wrapper.pyi,sha256=yD8YfRPau1-JSlAm0a60sOJZR4L4DxhVlTiAnoYJ9u8,581
+pyfracturedjson-2.2.2.dist-info/METADATA,sha256=TauQVmkRk1PQXnwAG3AZcgZTMjV3Fr5c97clWluk5w4,2156
+pyfracturedjson-2.2.2.dist-info/WHEEL,sha256=EfmT5yHmSsKCMf88H0y_gDJxXP11dyYwZSLaX0aGPEg,93
+pyfracturedjson-2.2.2.dist-info/licenses/LICENSE,sha256=JP_jxkJtN5lbsNOleIbX63niT5A27wFehjCm0X8rCrE,1120
+pyfracturedjson-2.2.2.dist-info/sboms/pyfracturedjson.cyclonedx.json,sha256=lM2rgAPrLlkHfgxrvbH5fFZCQie2yqB2y3Nr_NBF6Xk,43024
+pyfracturedjson-2.2.2.dist-info/RECORD,,

pyfracturedjson-2.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.15.0)
+Root-Is-Purelib: false
+Tag: cp315-cp315-win32

pyfracturedjson-2.2.2.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-2019 Counsyl/Myriad Genetics Inc.
+
+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.