json-repair 0.47.5__tar.gz → 0.47.7__tar.gz

{json_repair-0.47.5/src/json_repair.egg-info → json_repair-0.47.7}/PKG-INFO

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

{json_repair-0.47.5 → json_repair-0.47.7}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "json_repair"
-version = "0.47.5"
+version = "0.47.7"
 license = {file = "LICENSE"}
 authors = [
   { name="Stefano Baccianella", email="4247706+mangiucugna@users.noreply.github.com" },

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/json_parser.py

@@ -3,23 +3,34 @@ from typing import Literal, TextIO
 from .constants import STRING_DELIMITERS, JSONReturnType
 from .json_context import JsonContext
 from .object_comparer import ObjectComparer
-from .parse_array import parse_array
-from .parse_boolean_or_null import parse_boolean_or_null
-from .parse_comment import parse_comment
-from .parse_number import parse_number
-from .parse_object import parse_object
-from .parse_string import parse_string
+from .parse_array import parse_array as _parse_array
+from .parse_boolean_or_null import parse_boolean_or_null as _parse_boolean_or_null
+from .parse_comment import parse_comment as _parse_comment
+from .parse_number import parse_number as _parse_number
+from .parse_object import parse_object as _parse_object
+from .parse_string import parse_string as _parse_string
 from .string_file_wrapper import StringFileWrapper
 
 
 class JSONParser:
     # Split the parse methods into separate files because this one was like 3000 lines
-    parse_array = parse_array
-    parse_boolean_or_null = parse_boolean_or_null
-    parse_comment = parse_comment
-    parse_number = parse_number
-    parse_object = parse_object
-    parse_string = parse_string
+    def parse_array(self, *args, **kwargs):
+        return _parse_array(self, *args, **kwargs)
+
+    def parse_boolean_or_null(self, *args, **kwargs):
+        return _parse_boolean_or_null(self, *args, **kwargs)
+
+    def parse_comment(self, *args, **kwargs):
+        return _parse_comment(self, *args, **kwargs)
+
+    def parse_number(self, *args, **kwargs):
+        return _parse_number(self, *args, **kwargs)
+
+    def parse_object(self, *args, **kwargs):
+        return _parse_object(self, *args, **kwargs)
+
+    def parse_string(self, *args, **kwargs):
+        return _parse_string(self, *args, **kwargs)
 
     def __init__(
         self,

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/parse_array.py

@@ -1,8 +1,13 @@
+from typing import TYPE_CHECKING
+
 from .constants import STRING_DELIMITERS, JSONReturnType
 from .json_context import ContextValues
 
+if TYPE_CHECKING:
+    from .json_parser import JSONParser
+
 
-def parse_array(self) -> list[JSONReturnType]:
+def parse_array(self: "JSONParser") -> list[JSONReturnType]:
     # <array> ::= '[' [ <json> *(', ' <json>) ] ']' ; A sequence of JSON values separated by commas
     arr = []
     self.context.set(ContextValues.ARRAY)

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/parse_boolean_or_null.py

@@ -1,4 +1,10 @@
-def parse_boolean_or_null(self) -> bool | str | None:
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .json_parser import JSONParser
+
+
+def parse_boolean_or_null(self: "JSONParser") -> bool | str | None:
     # <boolean> is one of the literal strings 'true', 'false', or 'null' (unquoted)
     starting_index = self.index
     char = (self.get_char_at() or "").lower()

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/parse_comment.py

@@ -1,7 +1,13 @@
+from typing import TYPE_CHECKING
+
+from .constants import JSONReturnType
 from .json_context import ContextValues
 
+if TYPE_CHECKING:
+    from .json_parser import JSONParser
+
 
-def parse_comment(self) -> str:
+def parse_comment(self: "JSONParser") -> JSONReturnType:
     """
     Parse code-like comments:
 

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/parse_number.py

@@ -1,10 +1,15 @@
-from .constants import JSONReturnType
+from typing import TYPE_CHECKING
+
 from .json_context import ContextValues
 
 NUMBER_CHARS: set[str] = set("0123456789-.eE/,")
 
 
-def parse_number(self) -> float | int | str | JSONReturnType:
+if TYPE_CHECKING:
+    from .json_parser import JSONParser
+
+
+def parse_number(self: "JSONParser") -> float | int | str | bool | None:
     # <number> is a valid real number expressed in one of a number of given formats
     number_str = ""
     char = self.get_char_at()

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/parse_object.py

@@ -1,8 +1,13 @@
+from typing import TYPE_CHECKING
+
 from .constants import JSONReturnType
 from .json_context import ContextValues
 
+if TYPE_CHECKING:
+    from .json_parser import JSONParser
+
 
-def parse_object(self) -> dict[str, JSONReturnType]:
+def parse_object(self: "JSONParser") -> dict[str, JSONReturnType]:
     # <object> ::= '{' [ <member> *(', ' <member>) ] '}' ; A sequence of 'members'
     obj: dict[str, JSONReturnType] = {}
     # Stop when you either find the closing parentheses or you have iterated over the entire string
@@ -59,12 +64,17 @@ def parse_object(self) -> dict[str, JSONReturnType]:
                 # If the string is empty but there is a object divider, we are done here
                 break
         if ContextValues.ARRAY in self.context.context and key in obj:
-            self.log(
-                "While parsing an object we found a duplicate key, closing the object here and rolling back the index",
-            )
-            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 :]
+            if self.stream_stable:
+                # This is possibly another problem, the key is incomplete and it "appears" duplicate
+                # Let's just do nothing
+                pass
+            else:
+                self.log(
+                    "While parsing an object we found a duplicate key, closing the object here and rolling back the index",
+                )
+                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 :]
             break
 
         # Skip filler whitespaces

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair/parse_string.py

@@ -1,8 +1,13 @@
+from typing import TYPE_CHECKING
+
 from .constants import STRING_DELIMITERS
 from .json_context import ContextValues
 
+if TYPE_CHECKING:
+    from .json_parser import JSONParser
+
 
-def parse_string(self) -> str | bool | None:
+def parse_string(self: "JSONParser") -> str | bool | None:
     # <string> is a string of valid characters enclosed in quotes
     # i.e. { name: "John" }
     # Somehow all weird cases in an invalid JSON happen to be resolved in this function, so be careful here
@@ -328,7 +333,24 @@ def parse_string(self) -> str | bool | None:
                     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
+                        i = self.skip_whitespaces_at(idx=i + 1, move_main_index=False)
+                        if self.get_char_at(i) == ",":
+                            # So we found a comma, this could be a case of a single quote like "va"lue",
+                            # Search if it's followed by another key, starting with the first delimeter
+                            i = self.skip_to_character(character=lstring_delimiter, idx=i + 1)
+                            i += 1
+                            i = self.skip_to_character(character=rstring_delimiter, idx=i + 1)
+                            i += 1
+                            i = self.skip_whitespaces_at(idx=i, move_main_index=False)
+                            next_c = self.get_char_at(i)
+                            if next_c == ":":
+                                self.log(
+                                    "While parsing a string, we a misplaced quote that would have closed the string but has a different meaning here, ignoring it",
+                                )
+                                string_acc += str(char)
+                                self.index += 1
+                                char = self.get_char_at()
+                                continue
                         # 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)

{json_repair-0.47.5 → json_repair-0.47.7/src/json_repair.egg-info}/PKG-INFO

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

{json_repair-0.47.5 → json_repair-0.47.7}/src/json_repair.egg-info/SOURCES.txt

@@ -22,5 +22,12 @@ src/json_repair.egg-info/dependency_links.txt
 src/json_repair.egg-info/entry_points.txt
 src/json_repair.egg-info/top_level.txt
 tests/test_json_repair.py
+tests/test_parse_array.py
+tests/test_parse_boolean_or_null.py
 tests/test_parse_comment.py
-tests/test_performance.py
+tests/test_parse_number.py
+tests/test_parse_object.py
+tests/test_parse_string.py
+tests/test_performance.py
+tests/test_repair_json_cli.py
+tests/test_repair_json_from_file.py

json_repair-0.47.7/tests/test_json_repair.py

@@ -0,0 +1,161 @@
+from src.json_repair.json_repair import loads, repair_json
+
+
+def test_valid_json():
+    assert (
+        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('{"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('{"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('{"key": "value\u263a"}') == '{"key": "value\\u263a"}'
+    assert repair_json('{"key": "value\\nvalue"}') == '{"key": "value\\nvalue"}'
+
+
+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('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"}]'
+
+
+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) == {
+        "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(
+        """
+{
+  "resourceType": "Bundle",
+  "id": "1",
+  "type": "collection",
+  "entry": [
+    {
+      "resource": {
+        "resourceType": "Patient",
+        "id": "1",
+        "name": [
+          {"use": "official", "family": "Corwin", "given": ["Keisha", "Sunny"], "prefix": ["Mrs."},
+          {"use": "maiden", "family": "Goodwin", "given": ["Keisha", "Sunny"], "prefix": ["Mrs."]}
+        ]
+      }
+    }
+  ]
+}
+""",
+        return_objects=True,
+    ) == {
+        "resourceType": "Bundle",
+        "id": "1",
+        "type": "collection",
+        "entry": [
+            {
+                "resource": {
+                    "resourceType": "Patient",
+                    "id": "1",
+                    "name": [
+                        {
+                            "use": "official",
+                            "family": "Corwin",
+                            "given": ["Keisha", "Sunny"],
+                            "prefix": ["Mrs."],
+                        },
+                        {
+                            "use": "maiden",
+                            "family": "Goodwin",
+                            "given": ["Keisha", "Sunny"],
+                            "prefix": ["Mrs."],
+                        },
+                    ],
+                }
+            }
+        ],
+    }
+    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>'}
+    assert repair_json(
+        """
+        [
+            {
+                "foo": "Foo bar baz",
+                "tag": "#foo-bar-baz"
+            },
+            {
+                "foo": "foo bar "foobar" foo bar baz.",
+                "tag": "#foo-bar-foobar"
+            }
+        ]
+        """,
+        return_objects=True,
+    ) == [
+        {"foo": "Foo bar baz", "tag": "#foo-bar-baz"},
+        {"foo": 'foo bar "foobar" foo bar baz.', "tag": "#foo-bar-foobar"},
+    ]
+
+
+def test_repair_json_skip_json_loads():
+    assert (
+        repair_json('{"key": true, "key2": false, "key3": null}', skip_json_loads=True)
+        == '{"key": true, "key2": false, "key3": null}'
+    )
+    assert repair_json(
+        '{"key": true, "key2": false, "key3": null}',
+        return_objects=True,
+        skip_json_loads=True,
+    ) == {"key": True, "key2": False, "key3": None}
+    assert (
+        repair_json('{"key": true, "key2": false, "key3": }', skip_json_loads=True)
+        == '{"key": true, "key2": false, "key3": ""}'
+    )
+    assert loads('{"key": true, "key2": false, "key3": }', skip_json_loads=True) == {
+        "key": True,
+        "key2": False,
+        "key3": "",
+    }
+
+
+def test_ensure_ascii():
+    assert repair_json("{'test_中国人_ascii':'统一码'}", ensure_ascii=False) == '{"test_中国人_ascii": "统一码"}'
+
+
+def test_stream_stable():
+    # default: stream_stable = False
+    # When the json to be repaired is the accumulation of streaming json at a certain moment.
+    # The default repair result is unstable.
+    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`"}'
+    # 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": "value", "key', stream_stable=True) == '[{"key": "value"}]'

json_repair-0.47.7/tests/test_parse_array.py

@@ -0,0 +1,37 @@
+from src.json_repair.json_repair import repair_json
+
+
+def test_parse_array():
+    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("[[1\n\n]") == "[[1]]"
+
+
+def test_parse_array_edge_cases():
+    assert repair_json("[{]") == "[{}]"
+    assert repair_json("[") == "[]"
+    assert repair_json('["') == "[]"
+    assert repair_json("]") == ""
+    assert repair_json("[1, 2, 3,") == "[1, 2, 3]"
+    assert repair_json("[1, 2, 3, ...]") == "[1, 2, 3]"
+    assert repair_json("[1, 2, ... , 3]") == "[1, 2, 3]"
+    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('{"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"]'
+    assert (
+        repair_json('{"key1": ["value1", "value2"}, "key2": ["value3", "value4"]}')
+        == '{"key1": ["value1", "value2"], "key2": ["value3", "value4"]}'
+    )
+    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"]}')
+        == '{"key": ["lorem \\"ipsum\\" dolor \\"sit\\" amet, \\"consectetur\\" ", "lorem \\"ipsum\\" dolor", "lorem"]}'
+    )
+    assert repair_json('{"k"e"y": "value"}') == '{"k\\"e\\"y": "value"}'
+    assert repair_json('["key":"value"}]') == '[{"key": "value"}]'

json_repair-0.47.7/tests/test_parse_boolean_or_null.py

@@ -0,0 +1,12 @@
+from src.json_repair.json_repair import repair_json
+
+
+def test_parse_boolean_or_null():
+    assert repair_json("True", return_objects=True) == ""
+    assert repair_json("False", return_objects=True) == ""
+    assert repair_json("Null", return_objects=True) == ""
+    assert repair_json("true", return_objects=True)
+    assert not repair_json("false", return_objects=True)
+    assert repair_json("null", return_objects=True) is None
+    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}'

{json_repair-0.47.5 → json_repair-0.47.7}/tests/test_parse_comment.py

@@ -2,6 +2,7 @@ from src.json_repair.json_repair import repair_json
 
 
 def test_parse_comment():
+    assert repair_json("/") == ""
     assert repair_json('/* comment */ {"key": "value"}')
     assert (
         repair_json('{ "key": { "key2": "value2" // comment }, "key3": "value3" }')

json_repair-0.47.7/tests/test_parse_number.py

@@ -0,0 +1,27 @@
+from src.json_repair.json_repair import repair_json
+
+
+def test_parse_number():
+    assert repair_json("1", return_objects=True) == 1
+    assert repair_json("1.2", return_objects=True) == 1.2
+
+
+def test_parse_number_edge_cases():
+    assert (
+        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('{"key": 12345/67890}') == '{"key": "12345/67890"}'
+    assert repair_json("[105,12") == "[105, 12]"
+    assert repair_json('{"key", 105,12,') == '{"key": "105,12"}'
+    assert repair_json('{"key": 1/3, "foo": "bar"}') == '{"key": "1/3", "foo": "bar"}'
+    assert repair_json('{"key": 10-20}') == '{"key": "10-20"}'
+    assert repair_json('{"key": 1.1.1}') == '{"key": "1.1.1"}'
+    assert repair_json("[- ") == "[]"
+    assert repair_json('{"key": 1. }') == '{"key": 1.0}'
+    assert repair_json('{"key": 1e10 }') == '{"key": 10000000000.0}'
+    assert repair_json('{"key": 1e }') == '{"key": 1}'
+    assert repair_json('{"key": 1notanumber }') == '{"key": "1notanumber"}'
+    assert repair_json("[1, 2notanumber]") == '[1, "2notanumber"]'

json_repair-0.47.7/tests/test_parse_object.py

@@ -0,0 +1,85 @@
+from src.json_repair.json_repair import repair_json
+
+
+def test_parse_object():
+    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("{", return_objects=True) == {}
+    assert repair_json('{ "key": value, "key2": 1 "key3": null }', return_objects=True) == {
+        "key": "value",
+        "key2": 1,
+        "key3": None,
+    }
+    assert repair_json("   {  }   ") == "{}"
+    assert repair_json("{") == "{}"
+    assert repair_json("}") == ""
+    assert repair_json('{"') == "{}"
+
+
+def test_parse_object_edge_cases():
+    assert repair_json("{foo: [}") == '{"foo": []}'
+    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, 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("""{""answer"":[{""traits"":''Female aged 60+'',""answer1"":""5""}]}""")
+        == '{"answer": [{"traits": "Female aged 60+", "answer1": "5"}]}'
+    )
+    assert (
+        repair_json('{ "words": abcdef", "numbers": 12345", "words2": ghijkl" }')
+        == '{"words": "abcdef", "numbers": 12345, "words2": "ghijkl"}'
+    )
+    assert (
+        repair_json("""{"number": 1,"reason": "According...""ans": "YES"}""")
+        == '{"number": 1, "reason": "According...", "ans": "YES"}'
+    )
+    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('{"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("{'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('{"key": "value, value2"```') == '{"key": "value, 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 (
+        repair_json('[{"lorem": {"ipsum": "sic"}, """" "lorem": {"ipsum": "sic"}]')
+        == '[{"lorem": {"ipsum": "sic"}}, {"lorem": {"ipsum": "sic"}}]'
+    )
+    assert (
+        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\\\\\\"],\\"key2\\":"value2"}"}')
+        == '{"key": "{\\"key\\":[\\"value\\"],\\"key2\\":\\"value2\\"}"}'
+    )
+    assert repair_json('{"key": , "key2": "value2"}') == '{"key": "", "key2": "value2"}'