json-repair 0.53.1__py3-none-any.whl → 0.54__py3-none-any.whl

json_repair/json_parser.py

@@ -35,6 +35,7 @@ class JSONParser:
         logging: bool | None,
         json_fd_chunk_length: int = 0,
         stream_stable: bool = False,
+        strict: bool = False,
     ) -> None:
         # The string to parse
         self.json_str: str | StringFileWrapper = json_str
@@ -66,6 +67,10 @@ class JSONParser:
         #   case 3:  '{"key": "val\\n123,`key2:value2' => '{"key": "val\\n123,`key2:value2"}'
         #   case 4:  '{"key": "val\\n123,`key2:value2`"}' => '{"key": "val\\n123,`key2:value2`"}'
         self.stream_stable = stream_stable
+        # Over time the library got more and more complex heuristics to repair JSON. Some of these heuristics
+        # may not be desirable in some use cases and the user would prefer json_repair to return an exception.
+        # So strict mode was added to disable some of those heuristics.
+        self.strict = strict
 
     def parse(
         self,
@@ -93,6 +98,11 @@ class JSONParser:
                     "There were no more elements, returning the element without the array",
                 )
                 json = json[0]
+            elif self.strict:
+                self.log(
+                    "Multiple top-level JSON elements found in strict mode, raising an error",
+                )
+                raise ValueError("Multiple top-level JSON elements found in strict mode.")
         if self.logging:
             return json, self.logger
         else:

json_repair/json_repair.py

@@ -40,6 +40,7 @@ def repair_json(
     json_fd: TextIO | None = None,
     chunk_length: int = 0,
     stream_stable: bool = False,
+    strict: bool = False,
     **json_dumps_args: Any,
 ) -> str: ...
 
@@ -53,6 +54,7 @@ def repair_json(
     json_fd: TextIO | None = None,
     chunk_length: int = 0,
     stream_stable: bool = False,
+    strict: bool = False,
     **json_dumps_args: Any,
 ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]: ...
 
@@ -65,6 +67,7 @@ def repair_json(
     json_fd: TextIO | None = None,
     chunk_length: int = 0,
     stream_stable: bool = False,
+    strict: bool = False,
     **json_dumps_args: Any,
 ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
     """
@@ -79,10 +82,11 @@ def repair_json(
         ensure_ascii (bool, optional): Set to False to avoid converting non-latin characters to ascii (for example when using chinese characters). Defaults to True. Ignored if `skip_json_loads` is True.
         chunk_length (int, optional): Size in bytes of the file chunks to read at once. Ignored if `json_fd` is None. Do not use! Use `from_file` or `load` instead. Defaults to 1MB.
         stream_stable (bool, optional): When the json to be repaired is the accumulation of streaming json at a certain moment.If this parameter to True will keep the repair results stable.
+        strict (bool, optional): If True, surface structural problems (duplicate keys, missing separators, empty keys/values, etc.) as ValueError instead of repairing them.
     Returns:
         Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]: The repaired JSON or a tuple with the repaired JSON and repair log when logging is True.
     """
-    parser = JSONParser(json_str, json_fd, logging, chunk_length, stream_stable)
+    parser = JSONParser(json_str, json_fd, logging, chunk_length, stream_stable, strict)
     if skip_json_loads:
         parsed_json = parser.parse()
     else:
@@ -109,6 +113,7 @@ def loads(
     skip_json_loads: bool = False,
     logging: bool = False,
     stream_stable: bool = False,
+    strict: bool = False,
 ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]] | str:
     """
     This function works like `json.loads()` except that it will fix your JSON in the process.
@@ -118,6 +123,7 @@ def loads(
         json_str (str): The JSON string to load and repair.
         skip_json_loads (bool, optional): If True, skip calling the built-in json.loads() function to verify that the json is valid before attempting to repair. Defaults to False.
         logging (bool, optional): If True, return a tuple with the repaired json and a log of all repair actions. Defaults to False.
+        strict (bool, optional): If True, surface structural problems (duplicate keys, missing separators, empty keys/values, etc.) as ValueError instead of repairing them.
 
     Returns:
         Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]], str]: The repaired JSON object or a tuple with the repaired JSON object and repair log.
@@ -128,6 +134,7 @@ def loads(
         skip_json_loads=skip_json_loads,
         logging=logging,
         stream_stable=stream_stable,
+        strict=strict,
     )
 
 
@@ -136,6 +143,7 @@ def load(
     skip_json_loads: bool = False,
     logging: bool = False,
     chunk_length: int = 0,
+    strict: bool = False,
 ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
     """
     This function works like `json.load()` except that it will fix your JSON in the process.
@@ -146,6 +154,7 @@ def load(
         skip_json_loads (bool, optional): If True, skip calling the built-in json.loads() function to verify that the json is valid before attempting to repair. Defaults to False.
         logging (bool, optional): If True, return a tuple with the repaired json and a log of all repair actions. Defaults to False.
         chunk_length (int, optional): Size in bytes of the file chunks to read at once. Defaults to 1MB.
+        strict (bool, optional): If True, surface structural problems (duplicate keys, missing separators, empty keys/values, etc.) as ValueError instead of repairing them.
 
     Returns:
         Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]: The repaired JSON object or a tuple with the repaired JSON object and repair log.
@@ -156,6 +165,7 @@ def load(
         return_objects=True,
         skip_json_loads=skip_json_loads,
         logging=logging,
+        strict=strict,
     )
 
 
@@ -164,6 +174,7 @@ def from_file(
     skip_json_loads: bool = False,
     logging: bool = False,
     chunk_length: int = 0,
+    strict: bool = False,
 ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
     """
     This function is a wrapper around `load()` so you can pass the filename as string
@@ -173,6 +184,7 @@ def from_file(
         skip_json_loads (bool, optional): If True, skip calling the built-in json.loads() function to verify that the json is valid before attempting to repair. Defaults to False.
         logging (bool, optional): If True, return a tuple with the repaired json and a log of all repair actions. Defaults to False.
         chunk_length (int, optional): Size in bytes of the file chunks to read at once. Defaults to 1MB.
+        strict (bool, optional): If True, surface structural problems (duplicate keys, missing separators, empty keys/values, etc.) as ValueError instead of repairing them.
 
     Returns:
         Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]: The repaired JSON object or a tuple with the repaired JSON object and repair log.
@@ -183,6 +195,7 @@ def from_file(
             skip_json_loads=skip_json_loads,
             logging=logging,
             chunk_length=chunk_length,
+            strict=strict,
         )
 
     return jsonobj
@@ -240,6 +253,11 @@ def cli(inline_args: list[str] | None = None) -> int:
         default=2,
         help="Number of spaces for indentation (Default 2)",
     )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Raise on duplicate keys, missing separators, empty keys/values, and other unrecoverable structures instead of repairing them",
+    )
 
     args = parser.parse_args() if inline_args is None else parser.parse_args(inline_args)
 
@@ -259,10 +277,10 @@ def cli(inline_args: list[str] | None = None) -> int:
     try:
         # Use from_file if a filename is provided; otherwise read from stdin.
         if args.filename:
-            result = from_file(args.filename)
+            result = from_file(args.filename, strict=args.strict)
         else:
             data = sys.stdin.read()
-            result = loads(data)
+            result = loads(data, strict=args.strict)
         if args.inline or args.output:
             with open(args.output or args.filename, mode="w") as fd:
                 json.dump(result, fd, indent=args.indent, ensure_ascii=ensure_ascii)

json_repair/parse_object.py

@@ -62,9 +62,17 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
             if key == "":
                 self.skip_whitespaces()
             if key != "" or (key == "" and self.get_char_at() in [":", "}"]):
-                # If the string is empty but there is a object divider, we are done here
+                # Empty keys now trigger in strict mode, otherwise we keep repairing as before
+                if key == "" and self.strict:
+                    self.log(
+                        "Empty key found in strict mode while parsing object, raising an error",
+                    )
+                    raise ValueError("Empty key found in strict mode while parsing object.")
                 break
         if ContextValues.ARRAY in self.context.context and key in obj:
+            if self.strict:
+                self.log("Duplicate key found in strict mode while parsing object, raising an error")
+                raise ValueError("Duplicate key found in strict mode while parsing object.")
             self.log(
                 "While parsing an object we found a duplicate key, closing the object here and rolling back the index",
             )
@@ -84,6 +92,11 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
 
         # An extreme case of missing ":" after a key
         if self.get_char_at() != ":":
+            if self.strict:
+                self.log(
+                    "Missing ':' after key in strict mode while parsing object, raising an error",
+                )
+                raise ValueError("Missing ':' after key in strict mode while parsing object.")
             self.log(
                 "While parsing an object we missed a : after a key",
             )
@@ -91,17 +104,21 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
         self.index += 1
         self.context.reset()
         self.context.set(ContextValues.OBJECT_VALUE)
-        # The value can be any valid json
+        # The value can be any valid json; strict mode will refuse repaired empties
         self.skip_whitespaces()
         # Corner case, a lone comma
         value: JSONReturnType = ""
         if self.get_char_at() in [",", "}"]:
             self.log(
-                "While parsing an object value we found a stray , ignoring it",
+                "While parsing an object value we found a stray " + str(self.get_char_at()) + ", ignoring it",
             )
         else:
             value = self.parse_json()
-
+        if value == "" and self.strict and self.get_char_at(-1) not in STRING_DELIMITERS:
+            self.log(
+                "Parsed value is empty in strict mode while parsing object, raising an error",
+            )
+            raise ValueError("Parsed value is empty in strict mode while parsing object.")
         # Reset context since our job is done
         self.context.reset()
         obj[key] = value
@@ -116,6 +133,11 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
 
     # If the object is empty but also isn't just {}
     if not obj and self.index - start_index > 2:
+        if self.strict:
+            self.log(
+                "Parsed object is empty but contains extra characters in strict mode, raising an error",
+            )
+            raise ValueError("Parsed object is empty but contains extra characters in strict mode.")
         self.log("Parsed object is empty, we will try to parse this as an array instead")
         self.index = start_index
         return self.parse_array()
@@ -133,11 +155,12 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
     self.skip_whitespaces()
     if self.get_char_at() not in STRING_DELIMITERS:
         return obj
-    self.log(
-        "Found a comma and string delimiter after object closing brace, checking for additional key-value pairs",
-    )
-    additional_obj = self.parse_object()
-    if isinstance(additional_obj, dict):
-        obj.update(additional_obj)
+    if not self.strict:
+        self.log(
+            "Found a comma and string delimiter after object closing brace, checking for additional key-value pairs",
+        )
+        additional_obj = self.parse_object()
+        if isinstance(additional_obj, dict):
+            obj.update(additional_obj)
 
     return obj

json_repair/parse_string.py

@@ -81,7 +81,10 @@ def parse_string(self: "JSONParser") -> JSONReturnType:
             self.log(
                 "While parsing a string, we found a doubled quote and then a quote again, ignoring it",
             )
-            return ""
+            if self.strict:
+                raise ValueError("Found doubled quotes followed by another quote.")
+            else:
+                return ""
         # Find the next delimiter
         i = self.skip_to_character(character=rstring_delimiter, idx=1)
         next_c = self.get_char_at(i)
@@ -102,6 +105,10 @@ def parse_string(self: "JSONParser") -> JSONReturnType:
                 self.log(
                     "While parsing a string, we found a doubled quote but also another quote afterwards, ignoring it",
                 )
+                if self.strict:
+                    raise ValueError(
+                        "Found doubled quotes followed by another quote while parsing a string.",
+                    )
                 self.index += 1
                 return ""
             elif next_c not in [",", "]", "}"]:
@@ -292,7 +299,9 @@ def parse_string(self: "JSONParser") -> JSONReturnType:
                     if self.get_char_at(i) in [",", "}"]:
                         # Ok then this is a missing right quote
                         self.log(
-                            "While parsing a string missing the right delimiter in object key context, we found a , or } stopping here",
+                            "While parsing a string missing the right delimiter in object key context, we found a "
+                            + str(self.get_char_at(i))
+                            + " stopping here",
                         )
                         break
             else:

json_repair/utils/string_file_wrapper.py

@@ -19,14 +19,16 @@ class StringFileWrapper:
             buffer_length (int): The length of each buffer chunk.
         """
         self.fd = fd
-        self.length: int = 0
-        # Buffers are 1MB strings that are read from the file
-        # and kept in memory to keep reads low
+        # Buffers are chunks of text read from the file and cached to reduce disk access.
         self.buffers: dict[int, str] = {}
-        # chunk_length is in bytes
         if not chunk_length or chunk_length < 2:
             chunk_length = 1_000_000
+        # chunk_length now refers to the number of characters per chunk.
         self.buffer_length = chunk_length
+        # Keep track of the starting file position ("cookie") for each chunk so we can
+        # seek safely without landing in the middle of a multibyte code point.
+        self._chunk_positions: list[int] = [0]
+        self.length: int | None = None
 
     def get_buffer(self, index: int) -> str:
         """
@@ -38,15 +40,33 @@ class StringFileWrapper:
         Returns:
             str: The buffer chunk at the specified index.
         """
-        if self.buffers.get(index) is None:
-            self.fd.seek(index * self.buffer_length)
-            self.buffers[index] = self.fd.read(self.buffer_length)
-            # Save memory by keeping max 2MB buffer chunks and min 2 chunks
-            if len(self.buffers) > max(2, 2_000_000 / self.buffer_length):
-                oldest_key = next(iter(self.buffers))
-                if oldest_key != index:
-                    self.buffers.pop(oldest_key)
-        return self.buffers[index]
+        if index < 0:
+            raise IndexError("Negative indexing is not supported")
+
+        cached = self.buffers.get(index)
+        if cached is not None:
+            return cached
+
+        self._ensure_chunk_position(index)
+        start_pos = self._chunk_positions[index]
+        self.fd.seek(start_pos)
+        chunk = self.fd.read(self.buffer_length)
+        if not chunk:
+            raise IndexError("Chunk index out of range")
+        end_pos = self.fd.tell()
+        if len(self._chunk_positions) <= index + 1:
+            self._chunk_positions.append(end_pos)
+        if len(chunk) < self.buffer_length:
+            self.length = index * self.buffer_length + len(chunk)
+
+        self.buffers[index] = chunk
+        # Save memory by keeping max 2MB buffer chunks and min 2 chunks
+        max_buffers = max(2, int(2_000_000 / self.buffer_length))
+        if len(self.buffers) > max_buffers:
+            oldest_key = next(iter(self.buffers))
+            if oldest_key != index:
+                self.buffers.pop(oldest_key)
+        return chunk
 
     def __getitem__(self, index: int | slice) -> str:
         """
@@ -62,18 +82,49 @@ class StringFileWrapper:
         # self.buffers[index]: the row in the array of length 1MB, index is `i` modulo CHUNK_LENGTH
         # self.buffures[index][j]: the column of the row that is `i` remainder CHUNK_LENGTH
         if isinstance(index, slice):
-            buffer_index = index.start // self.buffer_length
-            buffer_end = index.stop // self.buffer_length
+            total_len = len(self)
+            start = 0 if index.start is None else index.start
+            stop = total_len if index.stop is None else index.stop
+            step = 1 if index.step is None else index.step
+
+            if start < 0:
+                start += total_len
+            if stop < 0:
+                stop += total_len
+
+            start = max(start, 0)
+            stop = min(stop, total_len)
+
+            if step == 0:
+                raise ValueError("slice step cannot be zero")
+            if step != 1:
+                return "".join(self[i] for i in range(start, stop, step))
+
+            if start >= stop:
+                return ""
+
+            buffer_index = start // self.buffer_length
+            buffer_end = (stop - 1) // self.buffer_length
+            start_mod = start % self.buffer_length
+            stop_mod = stop % self.buffer_length
+            if stop_mod == 0 and stop > start:
+                stop_mod = self.buffer_length
             if buffer_index == buffer_end:
-                return self.get_buffer(buffer_index)[index.start % self.buffer_length : index.stop % self.buffer_length]
-            else:
-                start_slice = self.get_buffer(buffer_index)[index.start % self.buffer_length :]
-                end_slice = self.get_buffer(buffer_end)[: index.stop % self.buffer_length]
-                middle_slices = [self.get_buffer(i) for i in range(buffer_index + 1, buffer_end)]
-                return start_slice + "".join(middle_slices) + end_slice
+                buffer = self.get_buffer(buffer_index)
+                return buffer[start_mod:stop_mod]
+
+            start_slice = self.get_buffer(buffer_index)[start_mod:]
+            end_slice = self.get_buffer(buffer_end)[:stop_mod]
+            middle_slices = [self.get_buffer(i) for i in range(buffer_index + 1, buffer_end)]
+            return start_slice + "".join(middle_slices) + end_slice
         else:
+            if index < 0:
+                index += len(self)
+            if index < 0:
+                raise IndexError("string index out of range")
             buffer_index = index // self.buffer_length
-            return self.get_buffer(buffer_index)[index % self.buffer_length]
+            buffer = self.get_buffer(buffer_index)
+            return buffer[index % self.buffer_length]
 
     def __len__(self) -> int:
         """
@@ -82,11 +133,10 @@ class StringFileWrapper:
         Returns:
             int: The total number of characters in the file.
         """
-        if self.length < 1:
-            current_position = self.fd.tell()
-            self.fd.seek(0, os.SEEK_END)
-            self.length = self.fd.tell()
-            self.fd.seek(current_position)
+        if self.length is None:
+            while self.length is None:
+                chunk_index = len(self._chunk_positions)
+                self._ensure_chunk_position(chunk_index)
         return self.length
 
     def __setitem__(self, index: int | slice, value: str) -> None:  # pragma: no cover
@@ -106,3 +156,21 @@ class StringFileWrapper:
         self.fd.seek(start)
         self.fd.write(value)
         self.fd.seek(current_position)
+
+    def _ensure_chunk_position(self, chunk_index: int) -> None:
+        """
+        Ensure that we know the starting file position for the given chunk index.
+        """
+        while len(self._chunk_positions) <= chunk_index:
+            prev_index = len(self._chunk_positions) - 1
+            start_pos = self._chunk_positions[-1]
+            self.fd.seek(start_pos, os.SEEK_SET)
+            chunk = self.fd.read(self.buffer_length)
+            end_pos = self.fd.tell()
+            if len(chunk) < self.buffer_length:
+                self.length = prev_index * self.buffer_length + len(chunk)
+            self._chunk_positions.append(end_pos)
+            if not chunk:
+                break
+        if len(self._chunk_positions) <= chunk_index:
+            raise IndexError("Chunk index out of range")

{json_repair-0.53.1.dist-info → json_repair-0.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_repair
-Version: 0.53.1
+Version: 0.54
 Summary: A package to repair broken json strings
 Author-email: Stefano Baccianella <4247706+mangiucugna@users.noreply.github.com>
 License-Expression: MIT
@@ -167,6 +167,23 @@ Some rules of thumb to use:
 - `skip_json_loads` is faster only if you 100% know that the string is not a valid JSON
 - If you are having issues with escaping pass the string as **raw** string like: `r"string with escaping\""`
 
+### Strict mode
+
+By default `json_repair` does its best to “fix” input, even when the JSON is far from valid.  
+In some scenarios you want the opposite behavior and need the parser to error out instead of repairing; pass `strict=True` to `repair_json`, `loads`, `load`, or `from_file` to enable that mode:
+
+```
+from json_repair import repair_json
+
+repair_json(bad_json_string, strict=True)
+```
+
+The CLI exposes the same behavior with `json_repair --strict input.json` (or piping data via stdin).
+
+In strict mode the parser raises `ValueError` as soon as it encounters structural issues such as duplicate keys, missing `:` separators, empty keys/values introduced by stray commas, multiple top-level elements, or other ambiguous constructs. This is useful when you just need validation with friendlier error messages while still benefiting from json_repair’s resilience elsewhere in your stack.
+
+Strict mode still honors `skip_json_loads=True`; combining them lets you skip the initial `json.loads` check but still enforce strict parsing rules.
+
 ### Use json_repair with streaming
 
 Sometimes you are streaming some data and want to repair the JSON coming from it. Normally this won't work but you can pass `stream_stable` to `repair_json()` or `loads()` to make it work:
@@ -198,6 +215,7 @@ options:
                         If specified, the output will be written to TARGET filename instead of stdout
   --ensure_ascii        Pass ensure_ascii=True to json.dumps()
   --indent INDENT       Number of spaces for indentation (Default 2)
+  --strict              Raise on duplicate keys, missing separators, empty keys/values, and similar structural issues instead of repairing them
 ```
 
 ## Adding to requirements

{json_repair-0.53.1.dist-info → json_repair-0.54.dist-info}/RECORD

@@ -1,22 +1,22 @@
 json_repair/__init__.py,sha256=JQ4Nm8YzR8Id2a527Ql0Az-rKapTp8DCMPKybLtQ620,180
 json_repair/__main__.py,sha256=EsJb-y89uZEvGQQg1GdIDWzfDwfOMvVekKEtdguQXCM,67
-json_repair/json_parser.py,sha256=tryp6hMKkjL8Rn1C1SgrmCDbK0ftvFMAQFg8vPzMHmw,7883
-json_repair/json_repair.py,sha256=tf0FA4qorTFCae0-kz09AKHVvh2rOMpYcJYuA4I0WYc,11568
+json_repair/json_parser.py,sha256=nATFDlcEnPD8G2NDSKj2nme_v1la_cCcFZrdQvEjTZs,8495
+json_repair/json_repair.py,sha256=iT-OJgpBnKUJVIV4IUlXmMUkOyW6bNnKCZLB7Fys8hk,12758
 json_repair/parse_array.py,sha256=rZfnRiS86vBATOUHqSx2T5fE79Ndlk2NoTsg9Wek7l4,2239
 json_repair/parse_comment.py,sha256=MUDxrx8BFfAaKvx6x4gWviJNvwRi2yv5qnrR6honmas,2660
 json_repair/parse_number.py,sha256=Ddv3Dih1VYfdasUe5DxQWAqy7YAE3aZJ7iePCfdi1EQ,1292
-json_repair/parse_object.py,sha256=ousZReaYw1PUZwF0muRvXVPtqL6O_X8uBTTeipnPD80,5505
-json_repair/parse_string.py,sha256=vWpcjknLqdFB77m5erRlQAAK6YRWQ4CKoKra6cyGjVo,25740
+json_repair/parse_object.py,sha256=noaiP10kzl-jA-1jc6tMmtFoJMIputpB3zFxcAuYQvY,6986
+json_repair/parse_string.py,sha256=L4McLWzRkbW_7Xx_hSGOmfpoPMwbYTGEKBAjqwanLEs,26146
 json_repair/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 json_repair/parse_string_helpers/parse_boolean_or_null.py,sha256=pGmH1QATBls70kTvUlJv4F8NiPaBWcyGhRL03sTOnto,871
 json_repair/parse_string_helpers/parse_json_llm_block.py,sha256=wPSm-8RY30Ek8HxzjCkCRtdLq4-Cez-PJB3vOk_vP3w,670
 json_repair/utils/constants.py,sha256=cv2gvyosuq0me0600WyTysM9avrtfXPuXYR26tawcuo,158
 json_repair/utils/json_context.py,sha256=WsMOjqpGSr6aaDONcrk8UFtTurzWon2Qq9AoBBYseoI,934
 json_repair/utils/object_comparer.py,sha256=XKV3MRab8H7_v4sm-wpEa5le0XX9OeycWo5S-MFm-GI,1716
-json_repair/utils/string_file_wrapper.py,sha256=tGkWBEUPE-CZPf4uSM5NE9oSDTpskX0myJiXsl-gbds,4333
-json_repair-0.53.1.dist-info/licenses/LICENSE,sha256=wrjQo8MhNrNCicXtMe3MHmS-fx8AmQk1ue8AQwiiFV8,1076
-json_repair-0.53.1.dist-info/METADATA,sha256=IFe-MSHaytu_BrjLp4UK9YCriXiRjmCsQg3CTpp6UD4,11027
-json_repair-0.53.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-json_repair-0.53.1.dist-info/entry_points.txt,sha256=SNfge3zPSP-ASqriYU9r3NAPaXdseYr7ciPMKdV2uSw,57
-json_repair-0.53.1.dist-info/top_level.txt,sha256=7-VZwZN2CgB_n0NlSLk-rEUFh8ug21lESbsblOYuZqw,12
-json_repair-0.53.1.dist-info/RECORD,,
+json_repair/utils/string_file_wrapper.py,sha256=Zlm0ZfJAw_VPlIy-QldL_OKYrPk3TYGq1JVAFPv7SnQ,6862
+json_repair-0.54.dist-info/licenses/LICENSE,sha256=wrjQo8MhNrNCicXtMe3MHmS-fx8AmQk1ue8AQwiiFV8,1076
+json_repair-0.54.dist-info/METADATA,sha256=xoD5G1EZ7muIRVbzdjsgD10OQbxS-K06sNGqlNDvvdQ,12220
+json_repair-0.54.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+json_repair-0.54.dist-info/entry_points.txt,sha256=SNfge3zPSP-ASqriYU9r3NAPaXdseYr7ciPMKdV2uSw,57
+json_repair-0.54.dist-info/top_level.txt,sha256=7-VZwZN2CgB_n0NlSLk-rEUFh8ug21lESbsblOYuZqw,12
+json_repair-0.54.dist-info/RECORD,,