json-repair 0.52.4__tar.gz → 0.53.0__tar.gz

{json_repair-0.52.4/src/json_repair.egg-info → json_repair-0.53.0}/PKG-INFO

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

{json_repair-0.52.4 → json_repair-0.53.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "json_repair"
-version = "0.52.4"
+version = "0.53.0"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [

{json_repair-0.52.4 → json_repair-0.53.0}/src/json_repair/json_parser.py

@@ -158,23 +158,32 @@ class JSONParser:
 
     def skip_to_character(self, character: str | list[str], idx: int = 0) -> int:
         """
-        This function quickly iterates to find a character, syntactic sugar to make the code more concise
+        Advance from (self.index + idx) until we hit an *unescaped* target character.
+        Returns the offset (idx) from self.index to that position, or the distance to the end if not found.
         """
-        try:
-            char = self.json_str[self.index + idx]
-        except IndexError:
-            return idx
-        character_list = character if isinstance(character, list) else [character]
-        while char not in character_list:
-            idx += 1
-            try:
-                char = self.json_str[self.index + idx]
-            except IndexError:
-                return idx
-        if self.json_str[self.index + idx - 1] == "\\":
-            # Ah shoot this was actually escaped, continue
-            return self.skip_to_character(character, idx + 1)
-        return idx
+        targets = set(character) if isinstance(character, list) else {character}
+        i = self.index + idx
+        n = len(self.json_str)
+        backslashes = 0  # count of consecutive '\' immediately before current char
+
+        while i < n:
+            ch = self.json_str[i]
+
+            if ch == "\\":
+                backslashes += 1
+                i += 1
+                continue
+
+            # ch is not a backslash; if it's a target and not escaped (even backslashes), we're done
+            if ch in targets and (backslashes % 2 == 0):
+                return i - self.index
+
+            # reset backslash run when we see a non-backslash
+            backslashes = 0
+            i += 1
+
+        # not found; return distance to end
+        return n - self.index
 
     def _log(self, text: str) -> None:
         window: int = 10

{json_repair-0.52.4 → json_repair-0.53.0}/src/json_repair/parse_object.py

@@ -7,7 +7,7 @@ if TYPE_CHECKING:
     from .json_parser import JSONParser
 
 
-def parse_object(self: "JSONParser") -> dict[str, JSONReturnType]:
+def parse_object(self: "JSONParser") -> JSONReturnType:
     # <object> ::= '{' [ <member> *(', ' <member>) ] '}' ; A sequence of 'members'
     obj: dict[str, JSONReturnType] = {}
     start_index = self.index

{json_repair-0.52.4 → json_repair-0.53.0}/src/json_repair/parse_string.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING
 
 from .constants import STRING_DELIMITERS, JSONReturnType
 from .json_context import ContextValues
+from .parse_string_helpers.parse_json_llm_block import parse_json_llm_block
 
 if TYPE_CHECKING:
     from .json_parser import JSONParser
@@ -49,7 +50,14 @@ def parse_string(self: "JSONParser") -> JSONReturnType:
 
     if not missing_quotes:
         self.index += 1
-
+    if self.get_char_at() == "`":
+        ret_val = parse_json_llm_block(self)
+        # If we found a valid JSON block, return it, otherwise continue parsing the string
+        if ret_val is not False:
+            return ret_val
+        self.log(
+            "While parsing a string, we found code fences but they did not enclose valid JSON, continuing parsing the string",
+        )
     # There is sometimes a weird case of doubled quotes, we manage this also later in the while loop
     if self.get_char_at() in STRING_DELIMITERS and self.get_char_at() == lstring_delimiter:
         # If it's an empty key, this was easy

json_repair-0.53.0/src/json_repair/parse_string_helpers/parse_json_llm_block.py

@@ -0,0 +1,19 @@
+from typing import TYPE_CHECKING
+
+from ..constants import JSONReturnType  # noqa: TID252
+
+if TYPE_CHECKING:
+    from ..json_parser import JSONParser  # noqa: TID252
+
+
+def parse_json_llm_block(self: "JSONParser") -> JSONReturnType:
+    """
+    Extracts and normalizes JSON enclosed in ```json ... ``` blocks.
+    """
+    # Try to find a ```json ... ``` block
+    if self.json_str[self.index : self.index + 7] == "```json":
+        i = self.skip_to_character("`", idx=7)
+        if self.json_str[self.index + i : self.index + i + 3] == "```":
+            self.index += 7  # Move past ```json
+            return self.parse_json()
+    return False

{json_repair-0.52.4 → json_repair-0.53.0/src/json_repair.egg-info}/PKG-INFO

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

{json_repair-0.52.4 → json_repair-0.53.0}/src/json_repair.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/json_repair.egg-info/SOURCES.txt
 src/json_repair.egg-info/dependency_links.txt
 src/json_repair.egg-info/entry_points.txt
 src/json_repair.egg-info/top_level.txt
+src/json_repair/parse_string_helpers/parse_json_llm_block.py
 tests/test_json_repair.py
 tests/test_parse_array.py
 tests/test_parse_boolean_or_null.py

{json_repair-0.52.4 → json_repair-0.53.0}/tests/test_parse_string.py

@@ -100,3 +100,13 @@ def test_leading_trailing_characters():
                        ```""")
         == '{"key": "value"}'
     )
+
+
+def test_string_json_llm_block():
+    assert repair_json('{"key": "``"') == '{"key": "``"}'
+    assert repair_json('{"key": "```json"') == '{"key": "```json"}'
+    assert (
+        repair_json('{"key": "```json {"key": [{"key1": 1},{"key2": 2}]}```"}')
+        == '{"key": {"key": [{"key1": 1}, {"key2": 2}]}}'
+    )
+    assert repair_json('{"response": "```json{}"') == '{"response": "```json{}"}'