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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_repair
-Version: 0.47.5
+Version: 0.47.6
 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.6}/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.6"
 license = {file = "LICENSE"}
 authors = [
   { name="Stefano Baccianella", email="4247706+mangiucugna@users.noreply.github.com" },

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

@@ -328,7 +328,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.6/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.6
 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.6}/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.6/tests/test_json_repair.py

@@ -0,0 +1,160 @@
+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`"}'

json_repair-0.47.6/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.6/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.6}/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.6/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.6/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"}'

json_repair-0.47.6/tests/test_parse_string.py

@@ -0,0 +1,99 @@
+from src.json_repair.json_repair import repair_json
+
+
+def test_parse_string():
+    assert repair_json('"') == ""
+    assert repair_json("\n") == ""
+    assert repair_json(" ") == ""
+    assert repair_json("string") == ""
+    assert repair_json("stringbeforeobject {}") == "{}"
+
+
+def test_missing_and_mixed_quotes():
+    assert (
+        repair_json("{'key': 'string', 'key2': false, \"key3\": null, \"key4\": unquoted}")
+        == '{"key": "string", "key2": false, "key3": null, "key4": "unquoted"}'
+    )
+    assert (
+        repair_json('{"name": "John", "age": 30, "city": "New York')
+        == '{"name": "John", "age": 30, "city": "New York"}'
+    )
+    assert (
+        repair_json('{"name": "John", "age": 30, city: "New York"}')
+        == '{"name": "John", "age": 30, "city": "New York"}'
+    )
+    assert (
+        repair_json('{"name": "John", "age": 30, "city": New York}')
+        == '{"name": "John", "age": 30, "city": "New York"}'
+    )
+    assert (
+        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('{"name": "John", "age": 30, "city": "New York, "gender": "male"}')
+        == '{"name": "John", "age": 30, "city": "New York", "gender": "male"}'
+    )
+
+    assert (
+        repair_json('[{"key": "value", COMMENT "notes": "lorem "ipsum", sic." }]')
+        == '[{"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('{"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": "lorem ipsum ... "sic " tamet. ...}') == '{"key": "lorem ipsum ... \\"sic \\" tamet. ..."}'
+    )
+    assert repair_json('{"key": value , }') == '{"key": "value"}'
+    assert (
+        repair_json('{"comment": "lorem, "ipsum" sic "tamet". To improve"}')
+        == '{"comment": "lorem, \\"ipsum\\" sic \\"tamet\\". To improve"}'
+    )
+    assert repair_json('{"key": "v"alu"e"} key:') == '{"key": "v\\"alu\\"e"}'
+    assert repair_json('{"key": "v"alue", "key2": "value2"}') == '{"key": "v\\"alue", "key2": "value2"}'
+
+
+def test_escaping():
+    assert repair_json("'\"'") == ""
+    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>"'
+        )
+        == r'{"real_content": "Some string: Some other string \t Some string <a href=\"https://domain.com\">Some link</a>"}'
+    )
+    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_markdown():
+    assert (
+        repair_json('{ "content": "[LINK]("https://google.com")" }')
+        == '{"content": "[LINK](\\"https://google.com\\")"}'
+    )
+    assert repair_json('{ "content": "[LINK](" }') == '{"content": "[LINK]("}'
+    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("Based on the information extracted, here is the filled JSON output: ```json { 'a': 'b' } ```")
+        == '{"a": "b"}'
+    )
+    assert (
+        repair_json("""
+                       The next 64 elements are:
+                       ```json
+                       { "key": "value" }
+                       ```""")
+        == '{"key": "value"}'
+    )

json_repair-0.47.6/tests/test_repair_json_cli.py

@@ -0,0 +1,67 @@
+import io
+import os
+import tempfile
+from unittest.mock import patch
+
+import pytest
+
+from src.json_repair.json_repair import cli
+
+
+def test_cli(capsys):
+    # Create a temporary file
+    temp_fd, temp_path = tempfile.mkstemp(suffix=".json")
+    try:
+        # Write content to the temporary file
+        with os.fdopen(temp_fd, "w") as tmp:
+            tmp.write("{key:value")
+        cli(inline_args=[temp_path, "--indent", 0, "--ensure_ascii"])
+        captured = capsys.readouterr()
+        assert captured.out == '{\n"key": "value"\n}\n'
+
+        # Test the output option
+        tempout_fd, tempout_path = tempfile.mkstemp(suffix=".json")
+        cli(inline_args=[temp_path, "--indent", 0, "-o", tempout_path])
+        with open(tempout_path) as tmp:
+            out = tmp.read()
+        assert out == '{\n"key": "value"\n}'
+
+        # Test the inline option
+        cli(inline_args=[temp_path, "--indent", 0, "-i"])
+        with open(temp_path) as tmp:
+            out = tmp.read()
+        assert out == '{\n"key": "value"\n}'
+
+    finally:
+        # Clean up - delete the temporary file
+        os.remove(temp_path)
+        os.remove(tempout_path)
+
+    # Prepare a JSON string that needs to be repaired.
+    test_input = "{key:value"
+    # Expected output when running cli with --indent 0.
+    expected_output = '{\n"key": "value"\n}\n'
+    # Patch sys.stdin so that cli() reads from it instead of a file.
+    with patch("sys.stdin", new=io.StringIO(test_input)):
+        cli(inline_args=["--indent", 0])
+    captured = capsys.readouterr()
+    assert captured.out == expected_output
+
+
+def test_cli_inline_requires_filename(capsys):
+    """cli() should exit with an error when --inline is passed without a filename."""
+    with pytest.raises(SystemExit) as exc:
+        cli(inline_args=["--inline"])
+    captured = capsys.readouterr()
+    assert captured.err.strip() == "Error: Inline mode requires a filename"
+    assert exc.value.code != 0
+
+
+def test_cli_inline_and_output_error(tmp_path, capsys):
+    """cli() should exit with an error when --inline and --output are used together."""
+    outfile = tmp_path / "out.json"
+    with pytest.raises(SystemExit) as exc:
+        cli(inline_args=["dummy.json", "--inline", "--output", str(outfile)])
+    captured = capsys.readouterr()
+    assert captured.err.strip() == "Error: You cannot pass both --inline and --output"
+    assert exc.value.code != 0

json_repair-0.47.5/tests/test_json_repair.py → json_repair-0.47.6/tests/test_repair_json_from_file.py

@@ -1,406 +1,8 @@
-import io
 import os.path
 import pathlib
 import tempfile
-from unittest.mock import patch
 
-import pytest
-
-from src.json_repair.json_repair import cli, from_file, loads, repair_json
-
-
-def test_basic_types_valid():
-    assert repair_json("True", return_objects=True) == ""
-    assert repair_json("False", return_objects=True) == ""
-    assert repair_json("Null", return_objects=True) == ""
-    assert repair_json("1", return_objects=True) == 1
-    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,
-    }
-
-
-def test_basic_types_invalid():
-    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("1.2", return_objects=True) == 1.2
-    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,
-    }
-
-
-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_brackets_edge_cases():
-    assert repair_json("[{]") == "[{}]"
-    assert repair_json("   {  }   ") == "{}"
-    assert repair_json("[") == "[]"
-    assert repair_json("]") == ""
-    assert repair_json("{") == "{}"
-    assert repair_json("}") == ""
-    assert repair_json('{"') == "{}"
-    assert repair_json('["') == "[]"
-    assert repair_json("{foo: [}") == '{"foo": []}'
-
-
-def test_general_edge_cases():
-    assert repair_json('"') == ""
-    assert repair_json("\n") == ""
-    assert repair_json(" ") == ""
-    assert repair_json("[[1\n\n]") == "[[1]]"
-    assert repair_json("string") == ""
-    assert repair_json("stringbeforeobject {}") == "{}"
-    assert repair_json("/") == ""
-
-
-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}'
-
-
-def test_missing_and_mixed_quotes():
-    assert (
-        repair_json("{'key': 'string', 'key2': false, \"key3\": null, \"key4\": unquoted}")
-        == '{"key": "string", "key2": false, "key3": null, "key4": "unquoted"}'
-    )
-    assert (
-        repair_json('{"name": "John", "age": 30, "city": "New York')
-        == '{"name": "John", "age": 30, "city": "New York"}'
-    )
-    assert (
-        repair_json('{"name": "John", "age": 30, city: "New York"}')
-        == '{"name": "John", "age": 30, "city": "New York"}'
-    )
-    assert (
-        repair_json('{"name": "John", "age": 30, "city": New York}')
-        == '{"name": "John", "age": 30, "city": "New York"}'
-    )
-    assert (
-        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('{"name": "John", "age": 30, "city": "New York, "gender": "male"}')
-        == '{"name": "John", "age": 30, "city": "New York", "gender": "male"}'
-    )
-
-    assert (
-        repair_json('[{"key": "value", COMMENT "notes": "lorem "ipsum", sic." }]')
-        == '[{"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('{"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": "lorem ipsum ... "sic " tamet. ...}') == '{"key": "lorem ipsum ... \\"sic \\" tamet. ..."}'
-    )
-    assert repair_json('{"key": value , }') == '{"key": "value"}'
-    assert (
-        repair_json('{"comment": "lorem, "ipsum" sic "tamet". To improve"}')
-        == '{"comment": "lorem, \\"ipsum\\" sic \\"tamet\\". To improve"}'
-    )
-    assert repair_json('{"key": "v"alu"e"} key:') == '{"key": "v\\"alu\\"e"}'
-
-
-def test_array_edge_cases():
-    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"}]'
-
-
-def test_escaping():
-    assert repair_json("'\"'") == ""
-    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>"'
-        )
-        == r'{"real_content": "Some string: Some other string \t Some string <a href=\"https://domain.com\">Some link</a>"}'
-    )
-    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, 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"}'
-
-
-def test_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"]'
-
-
-def test_markdown():
-    assert (
-        repair_json('{ "content": "[LINK]("https://google.com")" }')
-        == '{"content": "[LINK](\\"https://google.com\\")"}'
-    )
-    assert repair_json('{ "content": "[LINK](" }') == '{"content": "[LINK]("}'
-    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("Based on the information extracted, here is the filled JSON output: ```json { 'a': 'b' } ```")
-        == '{"a": "b"}'
-    )
-    assert (
-        repair_json("""
-                       The next 64 elements are:
-                       ```json
-                       { "key": "value" }
-                       ```""")
-        == '{"key": "value"}'
-    )
-
-
-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": "",
-    }
+from src.json_repair.json_repair import from_file
 
 
 def test_repair_json_from_file():
@@ -891,83 +493,3 @@ def test_repair_json_from_file():
     finally:
         # Clean up - delete the temporary file
         os.remove(temp_path)
-
-
-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`"}'
-
-
-def test_cli(capsys):
-    # Create a temporary file
-    temp_fd, temp_path = tempfile.mkstemp(suffix=".json")
-    try:
-        # Write content to the temporary file
-        with os.fdopen(temp_fd, "w") as tmp:
-            tmp.write("{key:value")
-        cli(inline_args=[temp_path, "--indent", 0, "--ensure_ascii"])
-        captured = capsys.readouterr()
-        assert captured.out == '{\n"key": "value"\n}\n'
-
-        # Test the output option
-        tempout_fd, tempout_path = tempfile.mkstemp(suffix=".json")
-        cli(inline_args=[temp_path, "--indent", 0, "-o", tempout_path])
-        with open(tempout_path) as tmp:
-            out = tmp.read()
-        assert out == '{\n"key": "value"\n}'
-
-        # Test the inline option
-        cli(inline_args=[temp_path, "--indent", 0, "-i"])
-        with open(temp_path) as tmp:
-            out = tmp.read()
-        assert out == '{\n"key": "value"\n}'
-
-    finally:
-        # Clean up - delete the temporary file
-        os.remove(temp_path)
-        os.remove(tempout_path)
-
-    # Prepare a JSON string that needs to be repaired.
-    test_input = "{key:value"
-    # Expected output when running cli with --indent 0.
-    expected_output = '{\n"key": "value"\n}\n'
-    # Patch sys.stdin so that cli() reads from it instead of a file.
-    with patch("sys.stdin", new=io.StringIO(test_input)):
-        cli(inline_args=["--indent", 0])
-    captured = capsys.readouterr()
-    assert captured.out == expected_output
-
-
-def test_cli_inline_requires_filename(capsys):
-    """cli() should exit with an error when --inline is passed without a filename."""
-    with pytest.raises(SystemExit) as exc:
-        cli(inline_args=["--inline"])
-    captured = capsys.readouterr()
-    assert captured.err.strip() == "Error: Inline mode requires a filename"
-    assert exc.value.code != 0
-
-
-def test_cli_inline_and_output_error(tmp_path, capsys):
-    """cli() should exit with an error when --inline and --output are used together."""
-    outfile = tmp_path / "out.json"
-    with pytest.raises(SystemExit) as exc:
-        cli(inline_args=["dummy.json", "--inline", "--output", str(outfile)])
-    captured = capsys.readouterr()
-    assert captured.err.strip() == "Error: You cannot pass both --inline and --output"
-    assert exc.value.code != 0