json-repair 0.27.2__tar.gz → 0.28.1__tar.gz

{json_repair-0.27.2/src/json_repair.egg-info → json_repair-0.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: json_repair
-Version: 0.27.2
+Version: 0.28.1
 Summary: A package to repair broken json strings
 Author-email: Stefano Baccianella <4247706+mangiucugna@users.noreply.github.com>
 License: MIT License
@@ -27,6 +27,7 @@ License: MIT License
         
 Project-URL: Homepage, https://github.com/mangiucugna/json_repair/
 Project-URL: Bug Tracker, https://github.com/mangiucugna/json_repair/issues
+Project-URL: Live demo, https://mangiucugna.github.io/json_repair/
 Keywords: JSON,REPAIR,LLM,PARSER
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{json_repair-0.27.2 → json_repair-0.28.1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "json_repair"
-version = "0.27.2"
+version = "0.28.1"
 license = {file = "LICENSE"}
 authors = [
   { name="Stefano Baccianella", email="4247706+mangiucugna@users.noreply.github.com" },
@@ -17,11 +17,15 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-
 [project.urls]
 "Homepage" = "https://github.com/mangiucugna/json_repair/"
 "Bug Tracker" = "https://github.com/mangiucugna/json_repair/issues"
+"Live demo" = "https://mangiucugna.github.io/json_repair/"
 [tool.pytest.ini_options]
 pythonpath = [
   "."
 ]
+[tool.setuptools.package-data]
+"pkgname" = ["py.typed"]
+[tool.setuptools.packages.find]
+where = ["src"]

{json_repair-0.27.2 → json_repair-0.28.1}/src/json_repair/json_repair.py

@@ -24,7 +24,7 @@ All supported use cases are in the unit tests
 
 import os
 import json
-from typing import Any, Dict, List, Optional, Union, TextIO, Tuple
+from typing import Any, Dict, List, Optional, Union, TextIO, Tuple, overload, Literal
 
 
 class StringFileWrapper:
@@ -51,9 +51,6 @@ class StringFileWrapper:
             self.fd.seek(current_position)
         return self.length
 
-    def __setitem__(self) -> None:
-        raise Exception("This is read-only!")
-
 
 class LoggerConfig:
     # This is a type class to simplify the declaration
@@ -180,7 +177,7 @@ class JSONParser:
             # <member> starts with a <string>
             key = ""
             while self.get_char_at():
-                key = self.parse_string()
+                key = str(self.parse_string())
 
                 if key != "" or (key == "" and self.get_char_at() == ":"):
                     # If the string is empty but there is a object divider, we are done here
@@ -258,7 +255,7 @@ class JSONParser:
         self.reset_context()
         return arr
 
-    def parse_string(self) -> Union[str, JSONReturnType]:
+    def parse_string(self) -> Union[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
@@ -310,8 +307,7 @@ class JSONParser:
             if self.get_context() == "object_key" and self.get_char_at(1) == ":":
                 self.index += 1
                 return ""
-
-            # This is a valid exception only if it's closed by a double delimiter again
+            # Find the next delimiter
             i = 1
             next_c = self.get_char_at(i)
             while next_c and next_c != rstring_delimiter:
@@ -386,7 +382,7 @@ class JSONParser:
             string_acc += char
             self.index += 1
             char = self.get_char_at()
-            if len(string_acc) > 0 and string_acc[-1] == "\\":
+            if char and len(string_acc) > 0 and string_acc[-1] == "\\":
                 # This is a special case, if people use real strings this might happen
                 self.log("Found a stray escape sequence, normalizing it", "info")
                 string_acc = string_acc[:-1]
@@ -442,7 +438,7 @@ class JSONParser:
                     ]:
                         # This is a bit of a weird workaround, essentially in object_value context we don't always break on commas
                         # This is because the routine after will make sure to correct any bad guess and this solves a corner case
-                        if next_c.isalpha():
+                        if check_comma_in_object_value and next_c.isalpha():
                             check_comma_in_object_value = False
                         # If we are in an object context, let's check for the right delimiters
                         if (
@@ -477,7 +473,7 @@ class JSONParser:
                                 "While parsing a string, we a misplaced quote that would have closed the string but has a different meaning here since this is the last element of the object, ignoring it",
                                 "info",
                             )
-                            string_acc += char
+                            string_acc += str(char)
                             self.index += 1
                             char = self.get_char_at()
                     elif next_c == rstring_delimiter:
@@ -507,7 +503,7 @@ class JSONParser:
                                     "While parsing a string, we a misplaced quote that would have closed the string but has a different meaning here, ignoring it",
                                     "info",
                                 )
-                                string_acc += char
+                                string_acc += str(char)
                                 self.index += 1
                                 char = self.get_char_at()
 
@@ -525,7 +521,8 @@ class JSONParser:
             if self.get_char_at() not in [":", ","]:
                 return ""
 
-        # A fallout of the previous special case in the while loop, we need to update the index only if we had a closing quote
+        # A fallout of the previous special case in the while loop,
+        # we need to update the index only if we had a closing quote
         if char != rstring_delimiter:
             self.log(
                 "While parsing a string, we missed the closing quote, ignoring",
@@ -567,6 +564,7 @@ class JSONParser:
         # <boolean> is one of the literal strings 'true', 'false', or 'null' (unquoted)
         starting_index = self.index
         char = (self.get_char_at() or "").lower()
+        value = None
         if char == "t":
             value = ("true", True)
         elif char == "f":
@@ -587,7 +585,7 @@ class JSONParser:
         self.index = starting_index
         return ""
 
-    def get_char_at(self, count: int = 0) -> Union[str, bool]:
+    def get_char_at(self, count: int = 0) -> Union[str, Literal[False]]:
         # Why not use something simpler? Because try/except in python is a faster alternative to an "if" statement that is often True
         try:
             return self.json_str[self.index + count]
@@ -615,16 +613,10 @@ class JSONParser:
             self.context.append(value)
 
     def reset_context(self) -> None:
-        try:
-            self.context.pop()
-        except Exception:
-            return
+        self.context.pop()
 
     def get_context(self) -> str:
-        try:
-            return self.context[-1]
-        except Exception:
-            return ""
+        return self.context[-1]
 
     def log(self, text: str, level: str) -> None:
         if level == self.logger.log_level:
@@ -640,6 +632,50 @@ class JSONParser:
             )
 
 
+@overload
+def repair_json(
+    json_str: str = "",
+    return_objects: Optional[Literal[False]] = False,
+    skip_json_loads: Optional[bool] = False,
+    logging: Optional[Literal[False]] = False,  # None is treated as False
+    json_fd: Optional[TextIO] = None,
+    ensure_ascii: Optional[bool] = True,
+) -> str: ...
+
+
+@overload
+def repair_json(
+    json_str: str = "",
+    return_objects: Literal[True] = True,
+    skip_json_loads: Optional[bool] = False,
+    logging: Optional[Literal[False]] = False,  # None is treated as False
+    json_fd: Optional[TextIO] = None,
+    ensure_ascii: Optional[bool] = True,
+) -> JSONReturnType: ...
+
+
+@overload
+def repair_json(
+    json_str: str = "",
+    return_objects: Optional[Literal[False]] = False,  # None is treated as False
+    skip_json_loads: Optional[bool] = False,
+    logging: Literal[True] = True,
+    json_fd: Optional[TextIO] = None,
+    ensure_ascii: Optional[bool] = True,
+) -> Tuple[str, List[Dict[str, str]]]: ...
+
+
+@overload
+def repair_json(
+    json_str: str = "",
+    return_objects: Literal[True] = True,
+    skip_json_loads: Optional[bool] = False,
+    logging: Literal[True] = True,
+    json_fd: Optional[TextIO] = None,
+    ensure_ascii: Optional[bool] = True,
+) -> Tuple[JSONReturnType, List[Dict[str, str]]]: ...
+
+
 def repair_json(
     json_str: str = "",
     return_objects: Optional[bool] = False,
@@ -653,7 +689,7 @@ def repair_json(
     It will return the fixed string by default.
     When `return_objects=True` is passed, it will return the decoded data structure instead.
     When `skip_json_loads=True` is passed, it will not call the built-in json.loads() function
-    When `logging=True` is passed, it will return an tuple with the repaired json and a log of all repair actions
+    When `logging=True` is passed, it will return a tuple with the repaired json and a log of all repair actions
     """
     parser = JSONParser(json_str, json_fd, logging)
     if skip_json_loads:
@@ -666,12 +702,29 @@ def repair_json(
                 parsed_json = json.loads(json_str)
         except json.JSONDecodeError:
             parsed_json = parser.parse()
-    # It's useful to return the actual object instead of the json string, it allows this lib to be a replacement of the json library
+    # It's useful to return the actual object instead of the json string,
+    # it allows this lib to be a replacement of the json library
     if return_objects or logging:
         return parsed_json
     return json.dumps(parsed_json, ensure_ascii=ensure_ascii)
 
 
+@overload
+def loads(
+    json_str: str,
+    skip_json_loads: Optional[bool] = False,
+    logging: Optional[Literal[False]] = False,  # None is treated as False
+) -> JSONReturnType: ...
+
+
+@overload
+def loads(
+    json_str: str,
+    skip_json_loads: Optional[bool] = False,
+    logging: Literal[True] = True,
+) -> Tuple[JSONReturnType, List[Dict[str, str]]]: ...
+
+
 def loads(
     json_str: str,
     skip_json_loads: Optional[bool] = False,
@@ -689,6 +742,20 @@ def loads(
     )
 
 
+@overload
+def load(
+    fd: TextIO,
+    skip_json_loads: Optional[bool] = False,
+    logging: Optional[Literal[False]] = False,
+) -> JSONReturnType: ...
+
+
+@overload
+def load(
+    fd: TextIO, skip_json_loads: Optional[bool] = False, logging: Literal[True] = True
+) -> Tuple[JSONReturnType, List[Dict[str, str]]]: ...
+
+
 def load(
     fd: TextIO, skip_json_loads: Optional[bool] = False, logging: Optional[bool] = False
 ) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
@@ -704,6 +771,22 @@ def load(
     )
 
 
+@overload
+def from_file(
+    filename: str,
+    skip_json_loads: Optional[bool] = False,
+    logging: Optional[Literal[False]] = False,
+) -> JSONReturnType: ...
+
+
+@overload
+def from_file(
+    filename: str,
+    skip_json_loads: Optional[bool] = False,
+    logging: Literal[True] = True,
+) -> Tuple[JSONReturnType, List[Dict[str, str]]]: ...
+
+
 def from_file(
     filename: str,
     skip_json_loads: Optional[bool] = False,

{json_repair-0.27.2 → json_repair-0.28.1/src/json_repair.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: json_repair
-Version: 0.27.2
+Version: 0.28.1
 Summary: A package to repair broken json strings
 Author-email: Stefano Baccianella <4247706+mangiucugna@users.noreply.github.com>
 License: MIT License
@@ -27,6 +27,7 @@ License: MIT License
         
 Project-URL: Homepage, https://github.com/mangiucugna/json_repair/
 Project-URL: Bug Tracker, https://github.com/mangiucugna/json_repair/issues
+Project-URL: Live demo, https://mangiucugna.github.io/json_repair/
 Keywords: JSON,REPAIR,LLM,PARSER
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{json_repair-0.27.2 → json_repair-0.28.1}/src/json_repair.egg-info/SOURCES.txt

@@ -3,9 +3,11 @@ README.md
 pyproject.toml
 src/json_repair/__init__.py
 src/json_repair/json_repair.py
+src/json_repair/py.typed
 src/json_repair.egg-info/PKG-INFO
 src/json_repair.egg-info/SOURCES.txt
 src/json_repair.egg-info/dependency_links.txt
 src/json_repair.egg-info/top_level.txt
+tests/test_coverage.py
 tests/test_json_repair.py
 tests/test_performance.py

json_repair-0.28.1/tests/test_coverage.py

@@ -0,0 +1,18 @@
+import coverage
+import sys
+
+COVERAGE_THRESHOLD = 100
+
+cov = coverage.Coverage()
+cov.start()
+
+import pytest
+retcode = pytest.main(["./tests/test_json_repair.py", "--cov-config=.coveragerc"])
+
+cov.stop()
+cov.save()
+coverage_percent = cov.report(show_missing=True)
+
+if coverage_percent < COVERAGE_THRESHOLD:
+    print(f"ERROR: Coverage {coverage_percent:.2f}% is below the threshold of {COVERAGE_THRESHOLD}%")
+    sys.exit(1)  # This will prevent the commit/push

{json_repair-0.27.2 → json_repair-0.28.1}/tests/test_json_repair.py

@@ -94,10 +94,12 @@ def test_missing_and_mixed_quotes():
         repair_json('{"name": "John", "age": 30, "city": "New')
         == '{"name": "John", "age": 30, "city": "New"}'
     )
-    assert repair_json('[{"key": "value", COMMENT "notes": "lorem "ipsum", sic."}]') == '[{"key": "value", "notes": "lorem \\"ipsum\\", sic."}]'
+    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"}'
 
 def test_array_edge_cases():
     assert repair_json("[1, 2, 3,") == "[1, 2, 3]"
@@ -106,16 +108,9 @@ 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]}}'
-
     
 def test_escaping():
     assert repair_json("'\"'") == '""'
@@ -127,6 +122,7 @@ def test_escaping():
     
 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"}'
@@ -138,6 +134,8 @@ def test_object_edge_cases():
     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('{"key":value, " key2":"value2" }') == '{"key": "value", " key2": "value2"}'
+    assert repair_json('{"key":value "key2":"value2" }') == '{"key": "value", "key2": "value2"}'
 
 def test_number_edge_cases():
     assert repair_json(' - { "test_key": ["test_value", "test_value2"] }') == '{"test_key": ["test_value", "test_value2"]}'