json-repair 0.46.1__tar.gz → 0.47.0__tar.gz

{json_repair-0.46.1/src/json_repair.egg-info → json_repair-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_repair
-Version: 0.46.1
+Version: 0.47.0
 Summary: A package to repair broken json strings
 Author-email: Stefano Baccianella <4247706+mangiucugna@users.noreply.github.com>
 License: MIT License

{json_repair-0.46.1 → json_repair-0.47.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "json_repair"
-version = "0.46.1"
+version = "0.47.0"
 license = {file = "LICENSE"}
 authors = [
   { name="Stefano Baccianella", email="4247706+mangiucugna@users.noreply.github.com" },
@@ -53,26 +53,32 @@ json_repair = "json_repair.__main__:cli"
 [tool.ruff]
 # Same as Black.
 indent-width = 4
-
+line-length = 120
 # Assume Python 3.13
 target-version = "py313"
 [tool.ruff.lint]
 # Read more here https://docs.astral.sh/ruff/rules/
 # By default, Ruff enables Flake8's E and F rules
+# FastAPI - FAST
 # Flake8-bandit - S
 # Flake8-bugbear – catches real-world Python footguns - B
 # Flake8-builtins - A
+# Flake8-comprehensions  - C4
+# Flake8-commas - COM
+# Flake8-quotes - Q
 # Flake8-tidy-imports - TID
+# Flake8-unused-arguments - ARG
 # Isort - I
 # Mccabe – code complexity warnings - C90
+# PEP 8 Naming convention - N
 # Pycodestyle - E, W
 # Pyflakes - F
-# Pylint - PLC, PLE, PLW
+# Pylint - PLC, PLE, PLR, PLW
+# PyTest - PT
+# Pyupgrade – safe modernization (e.g., str() → f"") - UP
 # Ruff specific - RUF
 # Simplifications (e.g., if x == True → if x) - SIM
-# Pyupgrade – safe modernization (e.g., str() → f"") - UP
-
-select = ['A', 'ARG', 'B', 'C4', 'C90', 'COM', 'E', 'F', 'I', 'PLC', 'PLE', 'PLW', 'Q', 'S', 'SIM', 'TID','UP', 'W']
+select = ['A', 'ARG', 'B', 'C4', 'COM', 'C90', 'E', 'F', 'I', 'N', 'PLC', 'PLE', 'PLW', 'PT', 'Q', 'S', 'SIM', 'TID', 'UP', 'W']
 # Only enable these RUF rules
 extend-select = [
   "RUF001",  # ambiguous Unicode
@@ -81,8 +87,12 @@ extend-select = [
   "RUF016",  # unnecessary else after return (optional)
   "RUF018",  # unnecessary else after raise (optional)
 ]
-ignore = ["S101", "E501", "C901", "COM812"]
-
+ignore = [
+  "S101",   # assert: Use of assert detected. We like assert
+  "COM812", # Ruff: The following rule may cause conflicts when used with the formatter
+  "E501",   # Line too long
+  "C901",   # `function` is too complex
+]
 # Allow fix for all enabled rules (when `--fix`) is provided.
 fixable = ["ALL"]
 unfixable = []
@@ -101,4 +111,4 @@ line-ending = "auto"
 
 [tool.ruff.lint.per-file-ignores]
 # Explicit re-exports is fine in __init__.py, still a code smell elsewhere.
-"__init__.py" = ["PLC0414"]
+"__init__.py" = ["PLC0414"]

json_repair-0.47.0/src/json_repair/__init__.py

@@ -0,0 +1,3 @@
+from .json_repair import from_file, load, loads, repair_json
+
+__all__ = ["from_file", "load", "loads", "repair_json"]

{json_repair-0.46.1 → json_repair-0.47.0}/src/json_repair/json_parser.py

@@ -105,14 +105,10 @@ class JSONParser:
                 )
                 return ""
             # <string> starts with a quote
-            elif not self.context.empty and (
-                char in self.STRING_DELIMITERS or char.isalpha()
-            ):
+            elif not self.context.empty and (char in self.STRING_DELIMITERS or char.isalpha()):
                 return self.parse_string()
             # <number> starts with [0-9] or minus
-            elif not self.context.empty and (
-                char.isdigit() or char == "-" or char == "."
-            ):
+            elif not self.context.empty and (char.isdigit() or char == "-" or char == "."):
                 return self.parse_number()
             elif char in ["#", "/"]:
                 return self.parse_comment()
@@ -164,8 +160,7 @@ class JSONParser:
                             if isinstance(prev_value, list):
                                 prev_value.extend(
                                     new_array[0]
-                                    if len(new_array) == 1
-                                    and isinstance(new_array[0], list)
+                                    if len(new_array) == 1 and isinstance(new_array[0], list)
                                     else new_array
                                 )
                             self.skip_whitespaces_at()
@@ -185,11 +180,7 @@ class JSONParser:
                 )
                 self.index = rollback_index - 1
                 # add an opening curly brace to make this work
-                self.json_str = (
-                    self.json_str[: self.index + 1]
-                    + "{"
-                    + self.json_str[self.index + 1 :]
-                )
+                self.json_str = self.json_str[: self.index + 1] + "{" + self.json_str[self.index + 1 :]
                 break
 
             # Skip filler whitespaces
@@ -242,10 +233,7 @@ class JSONParser:
                 i = 1
                 i = self.skip_to_character(char, i)
                 i = self.skip_whitespaces_at(idx=i + 1, move_main_index=False)
-                if self.get_char_at(i) == ":":
-                    value = self.parse_object()
-                else:
-                    value = self.parse_string()
+                value = self.parse_object() if self.get_char_at(i) == ":" else self.parse_string()
             else:
                 value = self.parse_json()
 
@@ -307,10 +295,7 @@ class JSONParser:
         elif char.isalnum():
             # This could be a <boolean> and not a string. Because (T)rue or (F)alse or (N)ull are valid
             # But remember, object keys are only of type string
-            if (
-                char.lower() in ["t", "f", "n"]
-                and self.context.current != ContextValues.OBJECT_KEY
-            ):
+            if char.lower() in ["t", "f", "n"] and self.context.current != ContextValues.OBJECT_KEY:
                 value = self.parse_boolean_or_null()
                 if value != "":
                     return value
@@ -323,15 +308,9 @@ class JSONParser:
             self.index += 1
 
         # There is sometimes a weird case of doubled quotes, we manage this also later in the while loop
-        if (
-            self.get_char_at() in self.STRING_DELIMITERS
-            and self.get_char_at() == lstring_delimiter
-        ):
+        if self.get_char_at() in self.STRING_DELIMITERS and self.get_char_at() == lstring_delimiter:
             # If it's an empty key, this was easy
-            if (
-                self.context.current == ContextValues.OBJECT_KEY
-                and self.get_char_at(1) == ":"
-            ):
+            if self.context.current == ContextValues.OBJECT_KEY and self.get_char_at(1) == ":":
                 self.index += 1
                 return ""
             if self.get_char_at(1) == lstring_delimiter:
@@ -380,23 +359,20 @@ class JSONParser:
         char = self.get_char_at()
         unmatched_delimiter = False
         while char and char != rstring_delimiter:
-            if (
-                missing_quotes
-                and self.context.current == ContextValues.OBJECT_KEY
-                and (char == ":" or char.isspace())
-            ):
+            if missing_quotes and self.context.current == ContextValues.OBJECT_KEY and (char == ":" or char.isspace()):
                 self.log(
                     "While parsing a string missing the left delimiter in object key context, we found a :, stopping here",
                 )
                 break
             if (
-                (missing_quotes or not self.stream_stable)
+                not self.stream_stable
                 and self.context.current == ContextValues.OBJECT_VALUE
                 and char
                 in [
                     ",",
                     "}",
                 ]
+                and string_acc[-1] != rstring_delimiter
             ):
                 rstring_delimiter_missing = True
                 # check if this is a case in which the closing comma is NOT missing instead
@@ -421,9 +397,7 @@ class JSONParser:
                         else:
                             # But again, this could just be something a bit stupid like "lorem, "ipsum" sic"
                             # Check if we find a : afterwards (skipping space)
-                            i = self.skip_whitespaces_at(
-                                idx=i + 1, move_main_index=False
-                            )
+                            i = self.skip_whitespaces_at(idx=i + 1, move_main_index=False)
                             next_c = self.get_char_at(i)
                             if next_c and next_c != ":":
                                 rstring_delimiter_missing = False
@@ -461,9 +435,10 @@ class JSONParser:
                     )
                     break
             if (
-                (missing_quotes or not self.stream_stable)
+                not self.stream_stable
                 and char == "]"
                 and ContextValues.ARRAY in self.context.context
+                and string_acc[-1] != rstring_delimiter
             ):
                 # We found the end of an array and we are in array context
                 # So let's check if we find a rstring_delimiter forward otherwise end early
@@ -483,15 +458,30 @@ class JSONParser:
                 if char in [rstring_delimiter, "t", "n", "r", "b", "\\"]:
                     string_acc = string_acc[:-1]
                     escape_seqs = {"t": "\t", "n": "\n", "r": "\r", "b": "\b"}
-                    string_acc += escape_seqs.get(char, char) or char
+                    string_acc += escape_seqs.get(char, char)
                     self.index += 1
                     char = self.get_char_at()
+                    while char and string_acc[-1] == "\\" and char in [rstring_delimiter, "\\"]:
+                        # this is a bit of a special case, if I don't do this it will close the loop or create a train of \\
+                        # I don't love it though
+                        string_acc = string_acc[:-1]
+                        string_acc += char
+                        self.index += 1
+                        char = self.get_char_at()
+                    continue
+                elif char in ["u", "x"]:
+                    # If we find a unicode escape sequence, normalize it
+                    num_chars = 4 if char == "u" else 2
+                    next_chars = self.json_str[self.index + 1 : self.index + 1 + num_chars]
+                    if len(next_chars) == num_chars and all(c in "0123456789abcdefABCDEF" for c in next_chars):
+                        self.log("Found a unicode escape sequence, normalizing it")
+                        string_acc = string_acc[:-1]
+                        string_acc += chr(int(next_chars, 16))
+                        self.index += 1 + num_chars
+                        char = self.get_char_at()
+                        continue
             # If we are in object key context and we find a colon, it could be a missing right quote
-            if (
-                char == ":"
-                and not missing_quotes
-                and self.context.current == ContextValues.OBJECT_KEY
-            ):
+            if char == ":" and not missing_quotes and self.context.current == ContextValues.OBJECT_KEY:
                 # Ok now we need to check if this is followed by a value like "..."
                 i = self.skip_to_character(character=lstring_delimiter, idx=1)
                 next_c = self.get_char_at(i)
@@ -519,17 +509,12 @@ class JSONParser:
                     )
                     break
             # ChatGPT sometimes forget to quote stuff in html tags or markdown, so we do this whole thing here
-            if char == rstring_delimiter:
+            if char == rstring_delimiter and string_acc[-1] != "\\":
                 # Special case here, in case of double quotes one after another
                 if doubled_quotes and self.get_char_at(1) == rstring_delimiter:
-                    self.log(
-                        "While parsing a string, we found a doubled quote, ignoring it"
-                    )
+                    self.log("While parsing a string, we found a doubled quote, ignoring it")
                     self.index += 1
-                elif (
-                    missing_quotes
-                    and self.context.current == ContextValues.OBJECT_VALUE
-                ):
+                elif missing_quotes and self.context.current == ContextValues.OBJECT_VALUE:
                     # In case of missing starting quote I need to check if the delimeter is the end or the beginning of a key
                     i = 1
                     next_c = self.get_char_at(i)
@@ -573,18 +558,9 @@ class JSONParser:
                             check_comma_in_object_value = False
                         # If we are in an object context, let's check for the right delimiters
                         if (
-                            (
-                                ContextValues.OBJECT_KEY in self.context.context
-                                and next_c in [":", "}"]
-                            )
-                            or (
-                                ContextValues.OBJECT_VALUE in self.context.context
-                                and next_c == "}"
-                            )
-                            or (
-                                ContextValues.ARRAY in self.context.context
-                                and next_c in ["]", ","]
-                            )
+                            (ContextValues.OBJECT_KEY in self.context.context and next_c in [":", "}"])
+                            or (ContextValues.OBJECT_VALUE in self.context.context and next_c == "}")
+                            or (ContextValues.ARRAY in self.context.context and next_c in ["]", ","])
                             or (
                                 check_comma_in_object_value
                                 and self.context.current == ContextValues.OBJECT_VALUE
@@ -595,10 +571,7 @@ class JSONParser:
                         i += 1
                         next_c = self.get_char_at(i)
                     # If we stopped for a comma in object_value context, let's check if find a "} at the end of the string
-                    if (
-                        next_c == ","
-                        and self.context.current == ContextValues.OBJECT_VALUE
-                    ):
+                    if next_c == "," and self.context.current == ContextValues.OBJECT_VALUE:
                         i += 1
                         i = self.skip_to_character(character=rstring_delimiter, idx=i)
                         next_c = self.get_char_at(i)
@@ -606,29 +579,20 @@ class JSONParser:
                         i += 1
                         i = self.skip_whitespaces_at(idx=i, move_main_index=False)
                         next_c = self.get_char_at(i)
-                    elif (
-                        next_c == rstring_delimiter and self.get_char_at(i - 1) != "\\"
-                    ):
+                    elif next_c == rstring_delimiter and self.get_char_at(i - 1) != "\\":
                         # Check if self.index:self.index+i is only whitespaces, break if that's the case
-                        if all(
-                            str(self.get_char_at(j)).isspace()
-                            for j in range(1, i)
-                            if self.get_char_at(j)
-                        ):
+                        if all(str(self.get_char_at(j)).isspace() for j in range(1, i) if self.get_char_at(j)):
                             break
                         if self.context.current == ContextValues.OBJECT_VALUE:
                             # But this might not be it! This could be just a missing comma
                             # We found a delimiter and we need to check if this is a key
                             # so find a rstring_delimiter and a colon after
-                            i = self.skip_to_character(
-                                character=rstring_delimiter, idx=i + 1
-                            )
+                            i = self.skip_to_character(character=rstring_delimiter, idx=i + 1)
                             i += 1
                             next_c = self.get_char_at(i)
                             while next_c and next_c != ":":
                                 if next_c in [",", "]", "}"] or (
-                                    next_c == rstring_delimiter
-                                    and self.get_char_at(i - 1) != "\\"
+                                    next_c == rstring_delimiter and self.get_char_at(i - 1) != "\\"
                                 ):
                                     break
                                 i += 1
@@ -661,12 +625,7 @@ class JSONParser:
                             string_acc += str(char)
                             self.index += 1
                             char = self.get_char_at()
-        if (
-            char
-            and missing_quotes
-            and self.context.current == ContextValues.OBJECT_KEY
-            and char.isspace()
-        ):
+        if char and missing_quotes and self.context.current == ContextValues.OBJECT_KEY and char.isspace():
             self.log(
                 "While parsing a string, handling an extreme corner case in which the LLM added a comment instead of valid string, invalidate the string and return an empty value",
             )
@@ -686,9 +645,7 @@ class JSONParser:
         else:
             self.index += 1
 
-        if not self.stream_stable and (
-            missing_quotes or (string_acc and string_acc[-1] == "\n")
-        ):
+        if not self.stream_stable and (missing_quotes or (string_acc and string_acc[-1] == "\n")):
             # Clean the whitespaces for some corner cases
             string_acc = string_acc.rstrip()
 
@@ -796,9 +753,7 @@ class JSONParser:
                 while True:
                     char = self.get_char_at()
                     if not char:
-                        self.log(
-                            "Reached end-of-string while parsing block comment; unclosed block comment."
-                        )
+                        self.log("Reached end-of-string while parsing block comment; unclosed block comment.")
                         break
                     comment += char
                     self.index += 1

{json_repair-0.46.1 → json_repair-0.47.0}/src/json_repair/json_repair.py

@@ -236,10 +236,7 @@ def cli(inline_args: list[str] | None = None) -> int:
         help="Number of spaces for indentation (Default 2)",
     )
 
-    if inline_args is None:  # pragma: no cover
-        args = parser.parse_args()
-    else:
-        args = parser.parse_args(inline_args)
+    args = parser.parse_args() if inline_args is None else parser.parse_args(inline_args)
 
     # Inline mode requires a filename, so error out if none was provided.
     if args.inline and not args.filename:  # pragma: no cover

{json_repair-0.46.1 → json_repair-0.47.0}/src/json_repair/object_comparer.py

@@ -30,10 +30,7 @@ class ObjectComparer:  # pragma: no cover
         elif isinstance(obj1, list):
             if len(obj1) != len(obj2):
                 return False
-            for i in range(len(obj1)):
-                if not ObjectComparer.is_same_object(obj1[i], obj2[i]):
-                    return False
-            return True
+            return all(ObjectComparer.is_same_object(obj1[i], obj2[i]) for i in range(len(obj1)))
 
         # For atoms: types already match, so just return True
         return True

{json_repair-0.46.1 → json_repair-0.47.0}/src/json_repair/string_file_wrapper.py

@@ -4,7 +4,7 @@ from typing import TextIO
 
 class StringFileWrapper:
     # This is a trick to simplify the code, transform the filedescriptor handling into a string handling
-    def __init__(self, fd: TextIO, CHUNK_LENGTH: int) -> None:
+    def __init__(self, fd: TextIO, chunk_length: int) -> None:
         """
         Initialize the StringFileWrapper with a file descriptor and chunk length.
 
@@ -23,10 +23,10 @@ class StringFileWrapper:
         # Buffers are 1MB strings that are read from the file
         # and kept in memory to keep reads low
         self.buffers: dict[int, str] = {}
-        # CHUNK_LENGTH is in bytes
-        if not CHUNK_LENGTH or CHUNK_LENGTH < 2:
-            CHUNK_LENGTH = 1_000_000
-        self.buffer_length = CHUNK_LENGTH
+        # chunk_length is in bytes
+        if not chunk_length or chunk_length < 2:
+            chunk_length = 1_000_000
+        self.buffer_length = chunk_length
 
     def get_buffer(self, index: int) -> str:
         """
@@ -65,19 +65,11 @@ class StringFileWrapper:
             buffer_index = index.start // self.buffer_length
             buffer_end = index.stop // self.buffer_length
             if buffer_index == buffer_end:
-                return self.get_buffer(buffer_index)[
-                    index.start % self.buffer_length : index.stop % self.buffer_length
-                ]
+                return self.get_buffer(buffer_index)[index.start % self.buffer_length : index.stop % self.buffer_length]
             else:
-                start_slice = self.get_buffer(buffer_index)[
-                    index.start % self.buffer_length :
-                ]
-                end_slice = self.get_buffer(buffer_end)[
-                    : index.stop % self.buffer_length
-                ]
-                middle_slices = [
-                    self.get_buffer(i) for i in range(buffer_index + 1, buffer_end)
-                ]
+                start_slice = self.get_buffer(buffer_index)[index.start % self.buffer_length :]
+                end_slice = self.get_buffer(buffer_end)[: index.stop % self.buffer_length]
+                middle_slices = [self.get_buffer(i) for i in range(buffer_index + 1, buffer_end)]
                 return start_slice + "".join(middle_slices) + end_slice
         else:
             buffer_index = index // self.buffer_length

{json_repair-0.46.1 → json_repair-0.47.0/src/json_repair.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_repair
-Version: 0.46.1
+Version: 0.47.0
 Summary: A package to repair broken json strings
 Author-email: Stefano Baccianella <4247706+mangiucugna@users.noreply.github.com>
 License: MIT License

{json_repair-0.46.1 → json_repair-0.47.0}/tests/test_json_repair.py

@@ -17,9 +17,11 @@ def test_basic_types_valid():
     assert repair_json("[]", return_objects=True) == []
     assert repair_json("[1, 2, 3, 4]", return_objects=True) == [1, 2, 3, 4]
     assert repair_json("{}", return_objects=True) == {}
-    assert repair_json(
-        '{ "key": "value", "key2": 1, "key3": True }', return_objects=True
-    ) == {"key": "value", "key2": 1, "key3": True}
+    assert repair_json('{ "key": "value", "key2": 1, "key3": True }', return_objects=True) == {
+        "key": "value",
+        "key2": 1,
+        "key3": True,
+    }
 
 
 def test_basic_types_invalid():
@@ -30,9 +32,11 @@ def test_basic_types_invalid():
     assert repair_json("[", return_objects=True) == []
     assert repair_json("[1, 2, 3, 4", return_objects=True) == [1, 2, 3, 4]
     assert repair_json("{", return_objects=True) == {}
-    assert repair_json(
-        '{ "key": value, "key2": 1 "key3": null }', return_objects=True
-    ) == {"key": "value", "key2": 1, "key3": None}
+    assert repair_json('{ "key": value, "key2": 1 "key3": null }', return_objects=True) == {
+        "key": "value",
+        "key2": 1,
+        "key3": None,
+    }
 
 
 def test_valid_json():
@@ -40,26 +44,13 @@ def test_valid_json():
         repair_json('{"name": "John", "age": 30, "city": "New York"}')
         == '{"name": "John", "age": 30, "city": "New York"}'
     )
-    assert (
-        repair_json('{"employees":["John", "Anna", "Peter"]} ')
-        == '{"employees": ["John", "Anna", "Peter"]}'
-    )
+    assert repair_json('{"employees":["John", "Anna", "Peter"]} ') == '{"employees": ["John", "Anna", "Peter"]}'
     assert repair_json('{"key": "value:value"}') == '{"key": "value:value"}'
-    assert (
-        repair_json('{"text": "The quick brown fox,"}')
-        == '{"text": "The quick brown fox,"}'
-    )
-    assert (
-        repair_json('{"text": "The quick brown fox won\'t jump"}')
-        == '{"text": "The quick brown fox won\'t jump"}'
-    )
+    assert repair_json('{"text": "The quick brown fox,"}') == '{"text": "The quick brown fox,"}'
+    assert repair_json('{"text": "The quick brown fox won\'t jump"}') == '{"text": "The quick brown fox won\'t jump"}'
     assert repair_json('{"key": ""') == '{"key": ""}'
-    assert (
-        repair_json('{"key1": {"key2": [1, 2, 3]}}') == '{"key1": {"key2": [1, 2, 3]}}'
-    )
-    assert (
-        repair_json('{"key": 12345678901234567890}') == '{"key": 12345678901234567890}'
-    )
+    assert repair_json('{"key1": {"key2": [1, 2, 3]}}') == '{"key1": {"key2": [1, 2, 3]}}'
+    assert repair_json('{"key": 12345678901234567890}') == '{"key": 12345678901234567890}'
     assert repair_json('{"key": "value\u263a"}') == '{"key": "value\\u263a"}'
     assert repair_json('{"key": "value\\nvalue"}') == '{"key": "value\\nvalue"}'
 
@@ -87,21 +78,13 @@ def test_general_edge_cases():
 
 
 def test_mixed_data_types():
-    assert (
-        repair_json('  {"key": true, "key2": false, "key3": null}')
-        == '{"key": true, "key2": false, "key3": null}'
-    )
-    assert (
-        repair_json('{"key": TRUE, "key2": FALSE, "key3": Null}   ')
-        == '{"key": true, "key2": false, "key3": null}'
-    )
+    assert repair_json('  {"key": true, "key2": false, "key3": null}') == '{"key": true, "key2": false, "key3": null}'
+    assert repair_json('{"key": TRUE, "key2": FALSE, "key3": Null}   ') == '{"key": true, "key2": false, "key3": null}'
 
 
 def test_missing_and_mixed_quotes():
     assert (
-        repair_json(
-            "{'key': 'string', 'key2': false, \"key3\": null, \"key4\": unquoted}"
-        )
+        repair_json("{'key': 'string', 'key2': false, \"key3\": null, \"key4\": unquoted}")
         == '{"key": "string", "key2": false, "key3": null, "key4": "unquoted"}'
     )
     assert (
@@ -120,14 +103,8 @@ def test_missing_and_mixed_quotes():
         repair_json('{"name": John, "age": 30, "city": "New York"}')
         == '{"name": "John", "age": 30, "city": "New York"}'
     )
-    assert (
-        repair_json('{“slanted_delimiter”: "value"}')
-        == '{"slanted_delimiter": "value"}'
-    )
-    assert (
-        repair_json('{"name": "John", "age": 30, "city": "New')
-        == '{"name": "John", "age": 30, "city": "New"}'
-    )
+    assert repair_json('{“slanted_delimiter”: "value"}') == '{"slanted_delimiter": "value"}'
+    assert repair_json('{"name": "John", "age": 30, "city": "New') == '{"name": "John", "age": 30, "city": "New"}'
     assert (
         repair_json('{"name": "John", "age": 30, "city": "New York, "gender": "male"}')
         == '{"name": "John", "age": 30, "city": "New York", "gender": "male"}'
@@ -138,18 +115,12 @@ def test_missing_and_mixed_quotes():
         == '[{"key": "value", "notes": "lorem \\"ipsum\\", sic."}]'
     )
     assert repair_json('{"key": ""value"}') == '{"key": "value"}'
-    assert (
-        repair_json('{"key": "value", 5: "value"}') == '{"key": "value", "5": "value"}'
-    )
+    assert repair_json('{"key": "value", 5: "value"}') == '{"key": "value", "5": "value"}'
     assert repair_json('{"foo": "\\"bar\\""') == '{"foo": "\\"bar\\""}'
     assert repair_json('{"" key":"val"') == '{" key": "val"}'
+    assert repair_json('{"key": value "key2" : "value2" ') == '{"key": "value", "key2": "value2"}'
     assert (
-        repair_json('{"key": value "key2" : "value2" ')
-        == '{"key": "value", "key2": "value2"}'
-    )
-    assert (
-        repair_json('{"key": "lorem ipsum ... "sic " tamet. ...}')
-        == '{"key": "lorem ipsum ... \\"sic \\" tamet. ..."}'
+        repair_json('{"key": "lorem ipsum ... "sic " tamet. ...}') == '{"key": "lorem ipsum ... \\"sic \\" tamet. ..."}'
     )
     assert repair_json('{"key": value , }') == '{"key": "value"}'
     assert (
@@ -166,14 +137,8 @@ def test_array_edge_cases():
     assert repair_json("[1, 2, '...', 3]") == '[1, 2, "...", 3]'
     assert repair_json("[true, false, null, ...]") == "[true, false, null]"
     assert repair_json('["a" "b" "c" 1') == '["a", "b", "c", 1]'
-    assert (
-        repair_json('{"employees":["John", "Anna",')
-        == '{"employees": ["John", "Anna"]}'
-    )
-    assert (
-        repair_json('{"employees":["John", "Anna", "Peter')
-        == '{"employees": ["John", "Anna", "Peter"]}'
-    )
+    assert repair_json('{"employees":["John", "Anna",') == '{"employees": ["John", "Anna"]}'
+    assert repair_json('{"employees":["John", "Anna", "Peter') == '{"employees": ["John", "Anna", "Peter"]}'
     assert repair_json('{"key1": {"key2": [1, 2, 3') == '{"key1": {"key2": [1, 2, 3]}}'
     assert repair_json('{"key": ["value]}') == '{"key": ["value"]}'
     assert repair_json('["lorem "ipsum" sic"]') == '["lorem \\"ipsum\\" sic"]'
@@ -182,14 +147,9 @@ def test_array_edge_cases():
         == '{"key1": ["value1", "value2"], "key2": ["value3", "value4"]}'
     )
     assert repair_json('[ "value", /* comment */ "value2" ]') == '["value", "value2"]'
+    assert repair_json('{"key": ["value" "value1" "value2"]}') == '{"key": ["value", "value1", "value2"]}'
     assert (
-        repair_json('{"key": ["value" "value1" "value2"]}')
-        == '{"key": ["value", "value1", "value2"]}'
-    )
-    assert (
-        repair_json(
-            '{"key": ["lorem "ipsum" dolor "sit" amet, "consectetur" ", "lorem "ipsum" dolor", "lorem"]}'
-        )
+        repair_json('{"key": ["lorem "ipsum" dolor "sit" amet, "consectetur" ", "lorem "ipsum" dolor", "lorem"]}')
         == '{"key": ["lorem \\"ipsum\\" dolor \\"sit\\" amet, \\"consectetur\\" ", "lorem \\"ipsum\\" dolor", "lorem"]}'
     )
     assert repair_json('{"k"e"y": "value"}') == '{"k\\"e\\"y": "value"}'
@@ -198,9 +158,7 @@ def test_array_edge_cases():
 
 def test_escaping():
     assert repair_json("'\"'") == ""
-    assert (
-        repair_json('{"key": \'string"\n\t\\le\'') == '{"key": "string\\"\\n\\t\\\\le"}'
-    )
+    assert repair_json('{"key": \'string"\n\t\\le\'') == '{"key": "string\\"\\n\\t\\\\le"}'
     assert (
         repair_json(
             r'{"real_content": "Some string: Some other string \t Some string <a href=\"https://domain.com\">Some link</a>"'
@@ -209,26 +167,21 @@ def test_escaping():
     )
     assert repair_json('{"key_1\n": "value"}') == '{"key_1": "value"}'
     assert repair_json('{"key\t_": "value"}') == '{"key\\t_": "value"}'
+    assert repair_json("{\"key\": '\u0076\u0061\u006c\u0075\u0065'}") == '{"key": "value"}'
+    assert repair_json('{"key": "\\u0076\\u0061\\u006C\\u0075\\u0065"}', skip_json_loads=True) == '{"key": "value"}'
 
 
 def test_object_edge_cases():
     assert repair_json("{       ") == "{}"
     assert repair_json('{"": "value"') == '{"": "value"}'
-    assert (
-        repair_json('{"value_1": true, COMMENT "value_2": "data"}')
-        == '{"value_1": true, "value_2": "data"}'
-    )
+    assert repair_json('{"value_1": true, COMMENT "value_2": "data"}') == '{"value_1": true, "value_2": "data"}'
     assert (
         repair_json('{"value_1": true, SHOULD_NOT_EXIST "value_2": "data" AAAA }')
         == '{"value_1": true, "value_2": "data"}'
     )
+    assert repair_json('{"" : true, "key2": "value2"}') == '{"": true, "key2": "value2"}'
     assert (
-        repair_json('{"" : true, "key2": "value2"}') == '{"": true, "key2": "value2"}'
-    )
-    assert (
-        repair_json(
-            """{""answer"":[{""traits"":''Female aged 60+'',""answer1"":""5""}]}"""
-        )
+        repair_json("""{""answer"":[{""traits"":''Female aged 60+'',""answer1"":""5""}]}""")
         == '{"answer": [{"traits": "Female aged 60+", "answer1": "5"}]}'
     )
     assert (
@@ -241,47 +194,26 @@ def test_object_edge_cases():
     )
     assert repair_json("""{ "a" : "{ b": {} }" }""") == '{"a": "{ b"}'
     assert repair_json("""{"b": "xxxxx" true}""") == '{"b": "xxxxx"}'
+    assert repair_json('{"key": "Lorem "ipsum" s,"}') == '{"key": "Lorem \\"ipsum\\" s,"}'
+    assert repair_json('{"lorem": ipsum, sic, datum.",}') == '{"lorem": "ipsum, sic, datum."}'
     assert (
-        repair_json('{"key": "Lorem "ipsum" s,"}') == '{"key": "Lorem \\"ipsum\\" s,"}'
-    )
-    assert (
-        repair_json('{"lorem": ipsum, sic, datum.",}')
-        == '{"lorem": "ipsum, sic, datum."}'
-    )
-    assert (
-        repair_json(
-            '{"lorem": sic tamet. "ipsum": sic tamet, quick brown fox. "sic": ipsum}'
-        )
+        repair_json('{"lorem": sic tamet. "ipsum": sic tamet, quick brown fox. "sic": ipsum}')
         == '{"lorem": "sic tamet.", "ipsum": "sic tamet", "sic": "ipsum"}'
     )
     assert (
         repair_json('{"lorem_ipsum": "sic tamet, quick brown fox. }')
         == '{"lorem_ipsum": "sic tamet, quick brown fox."}'
     )
-    assert (
-        repair_json('{"key":value, " key2":"value2" }')
-        == '{"key": "value", " key2": "value2"}'
-    )
-    assert (
-        repair_json('{"key":value "key2":"value2" }')
-        == '{"key": "value", "key2": "value2"}'
-    )
+    assert repair_json('{"key":value, " key2":"value2" }') == '{"key": "value", " key2": "value2"}'
+    assert repair_json('{"key":value "key2":"value2" }') == '{"key": "value", "key2": "value2"}'
     assert (
         repair_json("{'text': 'words{words in brackets}more words'}")
         == '{"text": "words{words in brackets}more words"}'
     )
-    assert (
-        repair_json("{text:words{words in brackets}}")
-        == '{"text": "words{words in brackets}"}'
-    )
-    assert (
-        repair_json("{text:words{words in brackets}m}")
-        == '{"text": "words{words in brackets}m"}'
-    )
+    assert repair_json("{text:words{words in brackets}}") == '{"text": "words{words in brackets}"}'
+    assert repair_json("{text:words{words in brackets}m}") == '{"text": "words{words in brackets}m"}'
     assert repair_json('{"key": "value, value2"```') == '{"key": "value, value2"}'
-    assert (
-        repair_json("{key:value,key2:value2}") == '{"key": "value", "key2": "value2"}'
-    )
+    assert repair_json("{key:value,key2:value2}") == '{"key": "value", "key2": "value2"}'
     assert repair_json('{"key:"value"}') == '{"key": "value"}'
     assert repair_json('{"key:value}') == '{"key": "value"}'
     assert (
@@ -302,28 +234,23 @@ def test_object_edge_cases():
     )
     assert repair_json('{ "key": "value" /* comment') == '{"key": "value"}'
     assert (
-        repair_json(
-            '{ "key": ["arrayvalue"], ["arrayvalue1"], ["arrayvalue2"], "key3": "value3" }'
-        )
+        repair_json('{ "key": ["arrayvalue"], ["arrayvalue1"], ["arrayvalue2"], "key3": "value3" }')
         == '{"key": ["arrayvalue", "arrayvalue1", "arrayvalue2"], "key3": "value3"}'
     )
     assert (
         repair_json('{ "key": ["arrayvalue"], "key3": "value3", ["arrayvalue1"] }')
         == '{"key": ["arrayvalue"], "key3": "value3", "arrayvalue1": ""}'
     )
+    assert repair_json('{"key": "{\\\\"key\\\\\\":\\"value\\\\\\"}"}') == '{"key": "{\\"key\\":\\"value\\"}"}'
 
 
 def test_number_edge_cases():
     assert (
-        repair_json(' - { "test_key": ["test_value", "test_value2"] }')
-        == '{"test_key": ["test_value", "test_value2"]}'
+        repair_json(' - { "test_key": ["test_value", "test_value2"] }') == '{"test_key": ["test_value", "test_value2"]}'
     )
     assert repair_json('{"key": 1/3}') == '{"key": "1/3"}'
     assert repair_json('{"key": .25}') == '{"key": 0.25}'
-    assert (
-        repair_json('{"here": "now", "key": 1/3, "foo": "bar"}')
-        == '{"here": "now", "key": "1/3", "foo": "bar"}'
-    )
+    assert repair_json('{"here": "now", "key": 1/3, "foo": "bar"}') == '{"here": "now", "key": "1/3", "foo": "bar"}'
     assert repair_json('{"key": 12345/67890}') == '{"key": "12345/67890"}'
     assert repair_json("[105,12") == "[105, 12]"
     assert repair_json('{"key", 105,12,') == '{"key": "105,12"}'
@@ -344,22 +271,14 @@ def test_markdown():
         == '{"content": "[LINK](\\"https://google.com\\")"}'
     )
     assert repair_json('{ "content": "[LINK](" }') == '{"content": "[LINK]("}'
-    assert (
-        repair_json('{ "content": "[LINK](", "key": true }')
-        == '{"content": "[LINK](", "key": true}'
-    )
+    assert repair_json('{ "content": "[LINK](", "key": true }') == '{"content": "[LINK](", "key": true}'
 
 
 def test_leading_trailing_characters():
     assert repair_json('````{ "key": "value" }```') == '{"key": "value"}'
+    assert repair_json("""{    "a": "",    "b": [ { "c": 1} ] \n}```""") == '{"a": "", "b": [{"c": 1}]}'
     assert (
-        repair_json("""{    "a": "",    "b": [ { "c": 1} ] \n}```""")
-        == '{"a": "", "b": [{"c": 1}]}'
-    )
-    assert (
-        repair_json(
-            "Based on the information extracted, here is the filled JSON output: ```json { 'a': 'b' } ```"
-        )
+        repair_json("Based on the information extracted, here is the filled JSON output: ```json { 'a': 'b' } ```")
         == '{"a": "b"}'
     )
     assert (
@@ -375,40 +294,32 @@ def test_leading_trailing_characters():
 def test_multiple_jsons():
     assert repair_json("[]{}") == "[[], {}]"
     assert repair_json("{}[]{}") == "[{}, [], {}]"
+    assert repair_json('{"key":"value"}[1,2,3,True]') == '[{"key": "value"}, [1, 2, 3, true]]'
     assert (
-        repair_json('{"key":"value"}[1,2,3,True]')
+        repair_json('lorem ```json {"key":"value"} ``` ipsum ```json [1,2,3,True] ``` 42')
         == '[{"key": "value"}, [1, 2, 3, true]]'
     )
-    assert (
-        repair_json(
-            'lorem ```json {"key":"value"} ``` ipsum ```json [1,2,3,True] ``` 42'
-        )
-        == '[{"key": "value"}, [1, 2, 3, true]]'
-    )
-    assert (
-        repair_json('[{"key":"value"}][{"key":"value_after"}]')
-        == '[{"key": "value_after"}]'
-    )
+    assert repair_json('[{"key":"value"}][{"key":"value_after"}]') == '[{"key": "value_after"}]'
 
 
 def test_repair_json_with_objects():
     # Test with valid JSON strings
     assert repair_json("[]", return_objects=True) == []
     assert repair_json("{}", return_objects=True) == {}
-    assert repair_json(
-        '{"key": true, "key2": false, "key3": null}', return_objects=True
-    ) == {"key": True, "key2": False, "key3": None}
-    assert repair_json(
-        '{"name": "John", "age": 30, "city": "New York"}', return_objects=True
-    ) == {
+    assert repair_json('{"key": true, "key2": false, "key3": null}', return_objects=True) == {
+        "key": True,
+        "key2": False,
+        "key3": None,
+    }
+    assert repair_json('{"name": "John", "age": 30, "city": "New York"}', return_objects=True) == {
         "name": "John",
         "age": 30,
         "city": "New York",
     }
     assert repair_json("[1, 2, 3, 4]", return_objects=True) == [1, 2, 3, 4]
-    assert repair_json(
-        '{"employees":["John", "Anna", "Peter"]} ', return_objects=True
-    ) == {"employees": ["John", "Anna", "Peter"]}
+    assert repair_json('{"employees":["John", "Anna", "Peter"]} ', return_objects=True) == {
+        "employees": ["John", "Anna", "Peter"]
+    }
     assert repair_json(
         """
 {
@@ -460,9 +371,7 @@ def test_repair_json_with_objects():
     assert repair_json(
         '{\n"html": "<h3 id="aaa">Waarom meer dan 200 Technical Experts - "Passie voor techniek"?</h3>"}',
         return_objects=True,
-    ) == {
-        "html": '<h3 id="aaa">Waarom meer dan 200 Technical Experts - "Passie voor techniek"?</h3>'
-    }
+    ) == {"html": '<h3 id="aaa">Waarom meer dan 200 Technical Experts - "Passie voor techniek"?</h3>'}
     assert repair_json(
         """
         [
@@ -995,10 +904,7 @@ def test_repair_json_from_file():
 
 
 def test_ensure_ascii():
-    assert (
-        repair_json("{'test_中国人_ascii':'统一码'}", ensure_ascii=False)
-        == '{"test_中国人_ascii": "统一码"}'
-    )
+    assert repair_json("{'test_中国人_ascii':'统一码'}", ensure_ascii=False) == '{"test_中国人_ascii": "统一码"}'
 
 
 def test_stream_stable():
@@ -1008,24 +914,14 @@ def test_stream_stable():
     assert repair_json('{"key": "val\\', stream_stable=False) == '{"key": "val\\\\"}'
     assert repair_json('{"key": "val\\n', stream_stable=False) == '{"key": "val"}'
     assert (
-        repair_json('{"key": "val\\n123,`key2:value2', stream_stable=False)
-        == '{"key": "val\\n123", "key2": "value2"}'
-    )
-    assert (
-        repair_json('{"key": "val\\n123,`key2:value2`"}', stream_stable=True)
-        == '{"key": "val\\n123,`key2:value2`"}'
+        repair_json('{"key": "val\\n123,`key2:value2', stream_stable=False) == '{"key": "val\\n123", "key2": "value2"}'
     )
+    assert repair_json('{"key": "val\\n123,`key2:value2`"}', stream_stable=True) == '{"key": "val\\n123,`key2:value2`"}'
     # stream_stable = True
     assert repair_json('{"key": "val\\', stream_stable=True) == '{"key": "val"}'
     assert repair_json('{"key": "val\\n', stream_stable=True) == '{"key": "val\\n"}'
-    assert (
-        repair_json('{"key": "val\\n123,`key2:value2', stream_stable=True)
-        == '{"key": "val\\n123,`key2:value2"}'
-    )
-    assert (
-        repair_json('{"key": "val\\n123,`key2:value2`"}', stream_stable=True)
-        == '{"key": "val\\n123,`key2:value2`"}'
-    )
+    assert repair_json('{"key": "val\\n123,`key2:value2', stream_stable=True) == '{"key": "val\\n123,`key2:value2"}'
+    assert repair_json('{"key": "val\\n123,`key2:value2`"}', stream_stable=True) == '{"key": "val\\n123,`key2:value2`"}'
 
 
 def test_cli(capsys):

{json_repair-0.46.1 → json_repair-0.47.0}/tests/test_performance.py

@@ -22,9 +22,7 @@ def test_true_true_correct(benchmark):
     max_time = 3 / 10**3  # 3 millisecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_true_true_incorrect(benchmark):
@@ -37,9 +35,7 @@ def test_true_true_incorrect(benchmark):
     max_time = 3 / 10**3  # 3 millisecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_true_false_correct(benchmark):
@@ -51,9 +47,7 @@ def test_true_false_correct(benchmark):
     max_time = 30 * (1 / 10**6)  # 30 microsecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_true_false_incorrect(benchmark):
@@ -65,9 +59,7 @@ def test_true_false_incorrect(benchmark):
     max_time = 3 / 10**3  # 3 millisecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_false_true_correct(benchmark):
@@ -79,9 +71,7 @@ def test_false_true_correct(benchmark):
     max_time = 3 / 10**3  # 3 millisecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_false_true_incorrect(benchmark):
@@ -93,9 +83,7 @@ def test_false_true_incorrect(benchmark):
     max_time = 3 / 10**3  # 3 millisecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_false_false_correct(benchmark):
@@ -107,9 +95,7 @@ def test_false_false_correct(benchmark):
     max_time = 60 / 10**6  # 60 microsecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
 
 
 def test_false_false_incorrect(benchmark):
@@ -121,6 +107,4 @@ def test_false_false_incorrect(benchmark):
     max_time = 3 / 10**3  # 3 millisecond
 
     # Assert that the average time is below the threshold
-    assert mean_time < max_time, (
-        f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"
-    )
+    assert mean_time < max_time, f"Benchmark exceeded threshold: {mean_time:.3f}s > {max_time:.3f}s"

json_repair-0.46.1/src/json_repair/__init__.py

@@ -1,4 +0,0 @@
-from .json_repair import from_file as from_file
-from .json_repair import load as load
-from .json_repair import loads as loads
-from .json_repair import repair_json as repair_json