pyfracturedjson 2.0.0__tar.gz → 2.1.1__tar.gz

{pyfracturedjson-2.0.0 → pyfracturedjson-2.1.1}/.github/workflows/publish.yml

@@ -191,6 +191,32 @@ jobs:
           name: wheels-macos-${{ matrix.platform.target }}
           path: dist
 
+  android:
+      runs-on: ubuntu-latest
+      needs: test_install
+      strategy:
+        matrix:
+          platform:
+            - aarch64-linux-android
+            - x86_64-linux-android
+            # - armv7-linux-androideabi
+      steps:
+        - uses: actions/checkout@v6
+        - uses: actions/setup-python@v6
+          with:
+            python-version: 3.x
+        - name: Build wheels
+          uses: PyO3/maturin-action@v1
+          with:
+            target: ${{ matrix.platform }}
+            args: --release --out dist -i python3.12
+            sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
+        - name: Upload wheels
+          uses: actions/upload-artifact@v5
+          with:
+            name: wheels-android-${{ matrix.platform }}
+            path: dist
+
   sdist:
     runs-on: ubuntu-latest
     needs: test_install
@@ -210,7 +236,7 @@ jobs:
   release:
       name: Release
       runs-on: ubuntu-latest
-      needs: [linux, musllinux, windows, macos, sdist, test_install]
+      needs: [linux, musllinux, windows, macos, android, sdist, test_install]
       if: startsWith(github.ref, 'refs/tags/v') 
       permissions:
         id-token: write

{pyfracturedjson-2.0.0 → pyfracturedjson-2.1.1}/.gitignore

@@ -1,5 +1,4 @@
 /target
-test_env/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

{pyfracturedjson-2.0.0 → pyfracturedjson-2.1.1}/Cargo.lock

@@ -168,7 +168,7 @@ dependencies = [
 
 [[package]]
 name = "pyfracturedjson"
-version = "2.0.0"
+version = "2.1.1"
 dependencies = [
  "fracturedjson",
  "pyo3",

pyfracturedjson-2.1.1/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "pyfracturedjson"
+version = "2.1.1"
+edition = "2024"
+license = "MIT"
+readme = "README.md"
+
+[package.metadata.maturin]
+compatibility = "abi3"
+
+[lib]
+name = "_rust_wrapper"
+crate-type = ["cdylib"]
+
+[dependencies]
+fracturedjson = "0.1.1"
+
+[dependencies.pyo3]
+version = "0.28.0"
+features = ["extension-module", "abi3-py39"]

pyfracturedjson-2.1.1/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.

{pyfracturedjson-2.0.0 → pyfracturedjson-2.1.1}/PKG-INFO

@@ -1,11 +1,13 @@
 Metadata-Version: 2.4
 Name: pyfracturedjson
-Version: 2.0.0
+Version: 2.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+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: Repository, https://github.com/g-b-f/pyFracturedJSON
@@ -15,24 +17,8 @@ Project-URL: Repository, https://github.com/g-b-f/pyFracturedJSON
 Adds [FracturedJSON](https://github.com/j-brooke/FracturedJson) support to python,
 allowing you to create JSON that is both compact and readable.
 
-Using it is easy:
 
-```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)
-```
-
-You can also use it as a drop-in replacement for the `json` module:
+You can trivially use it as a drop-in replacement for the built-in `json` module:
 
 ```python
 import fracturedjson as json
@@ -53,5 +39,22 @@ with open("file.json") as f:
 json.loads('{"foo":"bar"}')
 ```
 
-This is mostly a wrapper around [fracturedjson-rs](https://github.com/fcoury/fracturedjson-rs),
-so all credit goes to the creator.
+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.0.0 → pyfracturedjson-2.1.1}/README.md

@@ -3,24 +3,8 @@
 Adds [FracturedJSON](https://github.com/j-brooke/FracturedJson) support to python,
 allowing you to create JSON that is both compact and readable.
 
-Using it is easy:
 
-```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)
-```
-
-You can also use it as a drop-in replacement for the `json` module:
+You can trivially use it as a drop-in replacement for the built-in `json` module:
 
 ```python
 import fracturedjson as json
@@ -41,5 +25,22 @@ with open("file.json") as f:
 json.loads('{"foo":"bar"}')
 ```
 
-This is mostly a wrapper around [fracturedjson-rs](https://github.com/fcoury/fracturedjson-rs),
-so all credit goes to the creator.
+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.0.0 → pyfracturedjson-2.1.1}/fracturedjson/__init__.py

@@ -17,6 +17,10 @@ class Encoder(json.encoder.JSONEncoder):
             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",
             **kwargs
         ):
         super().__init__(
@@ -34,6 +38,11 @@ class Encoder(json.encoder.JSONEncoder):
             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
+
         
     
     def encode(self, o) -> str:
@@ -41,7 +50,11 @@ class Encoder(json.encoder.JSONEncoder):
         formatted = _rust_wrapper.reformat_string(
             unformatted,
             indent=self._indent,
-            line_length=self.line_length
+            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
         )
         return formatted
     

pyfracturedjson-2.1.1/fracturedjson/_rust_wrapper.pyi

@@ -0,0 +1,21 @@
+"""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
+        ) -> str:
+    """Reformat a JSON string.
+    
+    Args:
+        input: A JSON string to reformat.
+        
+    Returns:
+        The reformatted JSON string.        
+    """
+    ...

{pyfracturedjson-2.0.0 → pyfracturedjson-2.1.1}/pyproject.toml

@@ -4,6 +4,8 @@ requires-python = ">=3.9"
 description = "A compact yet readable JSON formatter"
 readme = "README.md"
 packages = ["fracturedjson"]
+license = "MIT"
+license-files = ["LICENSE"]
 
 classifiers = [
     "Programming Language :: Rust",
@@ -28,10 +30,8 @@ follow_untyped_imports = true
 filterwarnings = ["error"]
 
 [tool.maturin]
-
 include = ["fracturedjson/*"] 
 
-
 [tool.ruff.lint]
 extend-select = [
     "BLE",  # Blind exceptions
@@ -48,6 +48,4 @@ extend-select = [
 ]
 
 [dependency-groups]
-dev = [
-    "pytest>=8.3.5",
-]
+dev = ["pytest>=8.3.5"]

pyfracturedjson-2.1.1/src/lib.rs

@@ -0,0 +1,38 @@
+use pyo3::prelude::*;
+use fracturedjson::{Formatter, NumberListAlignment};
+
+#[pyfunction]
+fn reformat_string(
+    input: String,
+    indent:usize,
+    line_length: usize,
+    max_inline_complexity: isize,
+    max_compact_array_complexity: isize,
+    max_table_row_complexity: isize,
+    number_list_alignment: &str
+) -> String {
+    let mut formatter = Formatter::new();
+    formatter.options.max_total_line_length = line_length;
+    formatter.options.indent_spaces = indent;
+    formatter.options.max_inline_complexity = max_inline_complexity;
+    formatter.options.max_compact_array_complexity = max_compact_array_complexity;
+    formatter.options.max_table_row_complexity = max_table_row_complexity;
+
+    match number_list_alignment {
+        "left" => formatter.options.number_list_alignment = NumberListAlignment::Left,
+        "right" => formatter.options.number_list_alignment = NumberListAlignment::Right,
+        "decimal" => formatter.options.number_list_alignment = NumberListAlignment::Decimal,
+        "normalize" => formatter.options.number_list_alignment = NumberListAlignment::Normalize,
+        _ => formatter.options.number_list_alignment = NumberListAlignment::Decimal
+    }
+
+    let formatted = formatter.reformat(&input, 0);
+    let output = formatted.expect("Unexpected output");
+    return output
+}
+
+#[pymodule]
+fn _rust_wrapper(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(reformat_string, m)?)?;
+    Ok(())
+}

pyfracturedjson-2.1.1/tests/JSONs/compact_array_complexity_-1.json

@@ -0,0 +1,148 @@
+{
+    "BasicObject": {
+        "ModuleId"   : "armor",
+        "Name"       : "",
+        "Locations"  : [
+            [11,  2],
+            [11,  3],
+            [11,  4],
+            [11,  5],
+            [11,  6],
+            [11,  7],
+            [11,  8],
+            [11,  9],
+            [11, 10],
+            [11, 11],
+            [11, 12],
+            [11, 13],
+            [11, 14],
+            [ 1, 14],
+            [ 1, 13],
+            [ 1, 12],
+            [ 1, 11],
+            [ 1, 10],
+            [ 1,  9],
+            [ 1,  8],
+            [ 1,  7],
+            [ 1,  6],
+            [ 1,  5],
+            [ 1,  4],
+            [ 1,  3],
+            [ 1,  2],
+            [ 4,  2],
+            [ 5,  2],
+            [ 6,  2],
+            [ 7,  2],
+            [ 8,  2],
+            [ 8,  3],
+            [ 7,  3],
+            [ 6,  3],
+            [ 5,  3],
+            [ 4,  3],
+            [ 0,  4],
+            [ 0,  5],
+            [ 0,  6],
+            [ 0,  7],
+            [ 0,  8],
+            [12,  8],
+            [12,  7],
+            [12,  6],
+            [12,  5],
+            [12,  4]
+        ],
+        "Orientation": "Fore",
+        "Seed"       : 272691529
+    },
+    "SimilarArrays": {
+        "Katherine": ["blue",       "lightblue", "black"       ],
+        "Logan"    : ["yellow",     "blue",      "black", "red"],
+        "Erik"     : ["red",        "purple"                   ],
+        "Jean"     : ["lightgreen", "yellow",    "black"       ]
+    },
+    "SimilarObjects": [
+        { "type": "turret",    "hp": 400, "loc": {"x": 47, "y":  -4}, "flags": "S"   },
+        { "type": "assassin",  "hp":  80, "loc": {"x": 12, "y":   6}, "flags": "Q"   },
+        { "type": "berserker", "hp": 150, "loc": {"x":  0, "y":   0}                 },
+        { "type": "pittrap",              "loc": {"x": 10, "y": -14}, "flags": "S,I" }
+    ],
+    "NumberAlignmentTests": [
+        {"a":    123.456 , "b": 0   , "c":   0  },
+        {"a": 234567.8   , "b": 0   , "c":   0  },
+        {"a":      3     , "b": 0.0 , "c": 700.0},
+        {"a":   null     , "b": 0.2 , "c": 800.0},
+        {"a":      5.6789, "b": 0.35, "c":   0  }
+    ],
+    "InlineComplexityTests": {
+        "Subthing1"  : {"X": 55, "Y": 19, "Z": -4},
+        "Subthing2"  : { "Q": null, "W": [-2, -1, 0, 1] },
+        "Distraction": [[], null, null]
+    },
+    "CompactArrayComplexityTest_1": [
+          2,
+          3,
+          5,
+          7,
+         11,
+         13,
+         17,
+         19,
+         23,
+         29,
+         31,
+         37,
+         41,
+         43,
+         47,
+         53,
+         59,
+         61,
+         67,
+         71,
+         73,
+         79,
+         83,
+         89,
+         97,
+        101,
+        103,
+        107,
+        109,
+        113,
+        127,
+        131,
+        137,
+        139,
+        149,
+        151,
+        157,
+        163,
+        167,
+        173,
+        179,
+        181,
+        191,
+        193,
+        197,
+        199
+    ],
+    "CompactArrayComplexityTest_2": [
+        [19,  2],
+        [ 3,  8],
+        [14,  0],
+        [ 9,  9],
+        [ 9,  9],
+        [ 0,  3],
+        [10,  1],
+        [ 9,  1],
+        [ 9,  2],
+        [ 6, 13],
+        [18,  5],
+        [ 4, 11],
+        [12,  2]
+    ],
+    "TableRowComplexityTests": {
+        "Rect" : { "position": {"x": -44, "y":  3.4        }, "color": [0, 255, 255] },
+        "Point": { "position": {          "y": 22.0, "z": 3}                         },
+        "Oval" : { "position": null,                          "color": "#7f3e96"     }
+    }
+}

pyfracturedjson-2.1.1/tests/JSONs/compact_array_complexity_0.json

@@ -0,0 +1,148 @@
+{
+    "BasicObject": {
+        "ModuleId"   : "armor",
+        "Name"       : "",
+        "Locations"  : [
+            [11,  2],
+            [11,  3],
+            [11,  4],
+            [11,  5],
+            [11,  6],
+            [11,  7],
+            [11,  8],
+            [11,  9],
+            [11, 10],
+            [11, 11],
+            [11, 12],
+            [11, 13],
+            [11, 14],
+            [ 1, 14],
+            [ 1, 13],
+            [ 1, 12],
+            [ 1, 11],
+            [ 1, 10],
+            [ 1,  9],
+            [ 1,  8],
+            [ 1,  7],
+            [ 1,  6],
+            [ 1,  5],
+            [ 1,  4],
+            [ 1,  3],
+            [ 1,  2],
+            [ 4,  2],
+            [ 5,  2],
+            [ 6,  2],
+            [ 7,  2],
+            [ 8,  2],
+            [ 8,  3],
+            [ 7,  3],
+            [ 6,  3],
+            [ 5,  3],
+            [ 4,  3],
+            [ 0,  4],
+            [ 0,  5],
+            [ 0,  6],
+            [ 0,  7],
+            [ 0,  8],
+            [12,  8],
+            [12,  7],
+            [12,  6],
+            [12,  5],
+            [12,  4]
+        ],
+        "Orientation": "Fore",
+        "Seed"       : 272691529
+    },
+    "SimilarArrays": {
+        "Katherine": ["blue",       "lightblue", "black"       ],
+        "Logan"    : ["yellow",     "blue",      "black", "red"],
+        "Erik"     : ["red",        "purple"                   ],
+        "Jean"     : ["lightgreen", "yellow",    "black"       ]
+    },
+    "SimilarObjects": [
+        { "type": "turret",    "hp": 400, "loc": {"x": 47, "y":  -4}, "flags": "S"   },
+        { "type": "assassin",  "hp":  80, "loc": {"x": 12, "y":   6}, "flags": "Q"   },
+        { "type": "berserker", "hp": 150, "loc": {"x":  0, "y":   0}                 },
+        { "type": "pittrap",              "loc": {"x": 10, "y": -14}, "flags": "S,I" }
+    ],
+    "NumberAlignmentTests": [
+        {"a":    123.456 , "b": 0   , "c":   0  },
+        {"a": 234567.8   , "b": 0   , "c":   0  },
+        {"a":      3     , "b": 0.0 , "c": 700.0},
+        {"a":   null     , "b": 0.2 , "c": 800.0},
+        {"a":      5.6789, "b": 0.35, "c":   0  }
+    ],
+    "InlineComplexityTests": {
+        "Subthing1"  : {"X": 55, "Y": 19, "Z": -4},
+        "Subthing2"  : { "Q": null, "W": [-2, -1, 0, 1] },
+        "Distraction": [[], null, null]
+    },
+    "CompactArrayComplexityTest_1": [
+          2,
+          3,
+          5,
+          7,
+         11,
+         13,
+         17,
+         19,
+         23,
+         29,
+         31,
+         37,
+         41,
+         43,
+         47,
+         53,
+         59,
+         61,
+         67,
+         71,
+         73,
+         79,
+         83,
+         89,
+         97,
+        101,
+        103,
+        107,
+        109,
+        113,
+        127,
+        131,
+        137,
+        139,
+        149,
+        151,
+        157,
+        163,
+        167,
+        173,
+        179,
+        181,
+        191,
+        193,
+        197,
+        199
+    ],
+    "CompactArrayComplexityTest_2": [
+        [19,  2],
+        [ 3,  8],
+        [14,  0],
+        [ 9,  9],
+        [ 9,  9],
+        [ 0,  3],
+        [10,  1],
+        [ 9,  1],
+        [ 9,  2],
+        [ 6, 13],
+        [18,  5],
+        [ 4, 11],
+        [12,  2]
+    ],
+    "TableRowComplexityTests": {
+        "Rect" : { "position": {"x": -44, "y":  3.4        }, "color": [0, 255, 255] },
+        "Point": { "position": {          "y": 22.0, "z": 3}                         },
+        "Oval" : { "position": null,                          "color": "#7f3e96"     }
+    }
+}