json-repair 0.44.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

json_repair/json_context.py

@@ -1,5 +1,4 @@
 from enum import Enum, auto
-from typing import List, Optional
 
 
 class ContextValues(Enum):
@@ -10,8 +9,8 @@ class ContextValues(Enum):
 
 class JsonContext:
     def __init__(self) -> None:
-        self.context: List[ContextValues] = []
-        self.current: Optional[ContextValues] = None
+        self.context: list[ContextValues] = []
+        self.current: ContextValues | None = None
         self.empty: bool = True
 
     def set(self, value: ContextValues) -> None:

json_repair/json_parser.py

@@ -1,26 +1,27 @@
-from typing import Any, Dict, List, Literal, Optional, TextIO, Tuple, Union
+from typing import Any, ClassVar, Literal, TextIO
 
 from .json_context import ContextValues, JsonContext
 from .object_comparer import ObjectComparer
 from .string_file_wrapper import StringFileWrapper
 
-JSONReturnType = Union[Dict[str, Any], List[Any], str, float, int, bool, None]
+JSONReturnType = dict[str, Any] | list[Any] | str | float | int | bool | None
 
 
 class JSONParser:
     # Constants
-    STRING_DELIMITERS = ['"', "'", "“", "”"]
+    STRING_DELIMITERS: ClassVar[list[str]] = ['"', "'", "“", "”"]
+    NUMBER_CHARS: ClassVar[set[str]] = set("0123456789-.eE/,")
 
     def __init__(
         self,
-        json_str: Union[str, StringFileWrapper],
-        json_fd: Optional[TextIO],
-        logging: Optional[bool],
+        json_str: str | StringFileWrapper,
+        json_fd: TextIO | None,
+        logging: bool | None,
         json_fd_chunk_length: int = 0,
         stream_stable: bool = False,
     ) -> None:
         # The string to parse
-        self.json_str: Union[str, StringFileWrapper] = json_str
+        self.json_str: str | StringFileWrapper = json_str
         # Alternatively, the file description with a json file in it
         if json_fd:
             # This is a trick we do to treat the file wrapper as an array
@@ -31,12 +32,12 @@ class JSONParser:
         self.context = JsonContext()
         # Use this to log the activity, but only if logging is active
 
-        # This is a trick but a beatiful one. We call self.log in the code over and over even if it's not needed.
+        # This is a trick but a beautiful one. We call self.log in the code over and over even if it's not needed.
         # We could add a guard in the code for each call but that would make this code unreadable, so here's this neat trick
         # Replace self.log with a noop
         self.logging = logging
         if logging:
-            self.logger: List[Dict[str, str]] = []
+            self.logger: list[dict[str, str]] = []
             self.log = self._log
         else:
             # No-op
@@ -52,14 +53,13 @@ class JSONParser:
 
     def parse(
         self,
-    ) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
+    ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
         json = self.parse_json()
         if self.index < len(self.json_str):
             self.log(
                 "The parser returned early, checking if there's more json elements",
             )
             json = [json]
-            last_index = self.index
             while self.index < len(self.json_str):
                 j = self.parse_json()
                 if j != "":
@@ -67,9 +67,6 @@ class JSONParser:
                         # replace the last entry with the new one since the new one seems an update
                         json.pop()
                     json.append(j)
-                if self.index == last_index:
-                    self.index += 1
-                last_index = self.index
             # If nothing extra was found, don't return an array
             if len(json) == 1:
                 self.log(
@@ -120,9 +117,9 @@ class JSONParser:
             else:
                 self.index += 1
 
-    def parse_object(self) -> Dict[str, JSONReturnType]:
+    def parse_object(self) -> dict[str, JSONReturnType]:
         # <object> ::= '{' [ <member> *(', ' <member>) ] '}' ; A sequence of 'members'
-        obj: Dict[str, JSONReturnType] = {}
+        obj: dict[str, JSONReturnType] = {}
         # Stop when you either find the closing parentheses or you have iterated over the entire string
         while (self.get_char_at() or "}") != "}":
             # This is what we expect to find:
@@ -173,8 +170,6 @@ class JSONParser:
                                 self.index += 1
                             self.skip_whitespaces_at()
                             continue
-                        else:
-                            self.index = rollback_index
                 key = str(self.parse_string())
                 if key == "":
                     self.skip_whitespaces_at()
@@ -228,7 +223,7 @@ class JSONParser:
         self.index += 1
         return obj
 
-    def parse_array(self) -> List[JSONReturnType]:
+    def parse_array(self) -> list[JSONReturnType]:
         # <array> ::= '[' [ <json> *(', ' <json>) ] ']' ; A sequence of JSON values separated by commas
         arr = []
         self.context.set(ContextValues.ARRAY)
@@ -265,7 +260,7 @@ class JSONParser:
         self.context.reset()
         return arr
 
-    def parse_string(self) -> Union[str, bool, None]:
+    def parse_string(self) -> 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
@@ -312,59 +307,50 @@ class JSONParser:
             self.index += 1
 
         # There is sometimes a weird case of doubled quotes, we manage this also later in the while loop
-        if self.get_char_at() in self.STRING_DELIMITERS:
-            # If the next character is the same type of quote, then we manage it as double quotes
-            if self.get_char_at() == lstring_delimiter:
-                # If it's an empty key, this was easy
-                if (
-                    self.context.current == ContextValues.OBJECT_KEY
-                    and self.get_char_at(1) == ":"
-                ):
-                    self.index += 1
-                    return ""
-                if self.get_char_at(1) == lstring_delimiter:
-                    # There's something fishy about this, we found doubled quotes and then again quotes
-                    self.log(
-                        "While parsing a string, we found a doubled quote and then a quote again, ignoring it",
-                    )
-                    return ""
-                # Find the next delimiter
-                i = self.skip_to_character(character=rstring_delimiter, idx=1)
+        if (
+            self.get_char_at() in self.STRING_DELIMITERS
+            and self.get_char_at() == lstring_delimiter
+        ):
+            # If it's an empty key, this was easy
+            if (
+                self.context.current == ContextValues.OBJECT_KEY
+                and self.get_char_at(1) == ":"
+            ):
+                self.index += 1
+                return ""
+            if self.get_char_at(1) == lstring_delimiter:
+                # There's something fishy about this, we found doubled quotes and then again quotes
+                self.log(
+                    "While parsing a string, we found a doubled quote and then a quote again, ignoring it",
+                )
+                return ""
+            # Find the next delimiter
+            i = self.skip_to_character(character=rstring_delimiter, idx=1)
+            next_c = self.get_char_at(i)
+            # Now check that the next character is also a delimiter to ensure that we have "".....""
+            # In that case we ignore this rstring delimiter
+            if next_c and (self.get_char_at(i + 1) or "") == rstring_delimiter:
+                self.log(
+                    "While parsing a string, we found a valid starting doubled quote",
+                )
+                doubled_quotes = True
+                self.index += 1
+            else:
+                # Ok this is not a doubled quote, check if this is an empty string or not
+                i = self.skip_whitespaces_at(idx=1, move_main_index=False)
                 next_c = self.get_char_at(i)
-                # Now check that the next character is also a delimiter to ensure that we have "".....""
-                # In that case we ignore this rstring delimiter
-                if next_c and (self.get_char_at(i + 1) or "") == rstring_delimiter:
+                if next_c in self.STRING_DELIMITERS + ["{", "["]:
+                    # something fishy is going on here
                     self.log(
-                        "While parsing a string, we found a valid starting doubled quote",
+                        "While parsing a string, we found a doubled quote but also another quote afterwards, ignoring it",
                     )
-                    doubled_quotes = True
                     self.index += 1
-                else:
-                    # Ok this is not a doubled quote, check if this is an empty string or not
-                    i = self.skip_whitespaces_at(idx=1, move_main_index=False)
-                    next_c = self.get_char_at(i)
-                    if next_c in self.STRING_DELIMITERS + ["{", "["]:
-                        # something fishy is going on here
-                        self.log(
-                            "While parsing a string, we found a doubled quote but also another quote afterwards, ignoring it",
-                        )
-                        self.index += 1
-                        return ""
-                    elif next_c not in [",", "]", "}"]:
-                        self.log(
-                            "While parsing a string, we found a doubled quote but it was a mistake, removing one quote",
-                        )
-                        self.index += 1
-            else:
-                # Otherwise we need to do another check before continuing
-                i = self.skip_to_character(character=rstring_delimiter, idx=1)
-                next_c = self.get_char_at(i)
-                if not next_c:
-                    # mmmm that delimiter never appears again, this is a mistake
+                    return ""
+                elif next_c not in [",", "]", "}"]:
                     self.log(
-                        "While parsing a string, we found a quote but it was a mistake, ignoring it",
+                        "While parsing a string, we found a doubled quote but it was a mistake, removing one quote",
                     )
-                    return ""
+                    self.index += 1
 
         # Initialize our return value
         string_acc = ""
@@ -413,10 +399,6 @@ class JSONParser:
                         # So we need to check if we find a new lstring_delimiter afterwards
                         # If we do, maybe this is a missing delimiter
                         i = self.skip_to_character(character=lstring_delimiter, idx=i)
-                        if doubled_quotes:
-                            i = self.skip_to_character(
-                                character=lstring_delimiter, idx=i
-                            )
                         next_c = self.get_char_at(i)
                         if not next_c:
                             rstring_delimiter_missing = False
@@ -457,8 +439,6 @@ class JSONParser:
                                     # Ok then this is part of the string
                                     rstring_delimiter_missing = False
                                     break
-                                elif c == "}":
-                                    break
                 if rstring_delimiter_missing:
                     self.log(
                         "While parsing a string missing the left delimiter in object value context, we found a , or } and we couldn't determine that a right delimiter was present. Stopping here",
@@ -610,15 +590,6 @@ class JSONParser:
                         i += 1
                         i = self.skip_whitespaces_at(idx=i, move_main_index=False)
                         next_c = self.get_char_at(i)
-                        if next_c == "}":
-                            # OK this is valid then
-                            self.log(
-                                "While parsing a string, we misplaced a quote that would have closed the string but has a different meaning here since this is the last element of the object, ignoring it",
-                            )
-                            unmatched_delimiter = not unmatched_delimiter
-                            string_acc += str(char)
-                            self.index += 1
-                            char = self.get_char_at()
                     elif (
                         next_c == rstring_delimiter and self.get_char_at(i - 1) != "\\"
                     ):
@@ -707,13 +678,12 @@ class JSONParser:
 
         return string_acc
 
-    def parse_number(self) -> Union[float, int, str, JSONReturnType]:
+    def parse_number(self) -> float | int | str | JSONReturnType:
         # <number> is a valid real number expressed in one of a number of given formats
         number_str = ""
         char = self.get_char_at()
         is_array = self.context.current == ContextValues.ARRAY
-        NUMBER_CHARS = set("0123456789-.eE/,")
-        while char and char in NUMBER_CHARS and (not is_array or char != ","):
+        while char and char in self.NUMBER_CHARS and (not is_array or char != ","):
             number_str += char
             self.index += 1
             char = self.get_char_at()
@@ -730,19 +700,16 @@ class JSONParser:
                 return str(number_str)
             if "." in number_str or "e" in number_str or "E" in number_str:
                 return float(number_str)
-            elif number_str == "-":
-                # If there is a stray "-" this will throw an exception, throw away this character
-                return self.parse_json()
             else:
                 return int(number_str)
         except ValueError:
             return number_str
 
-    def parse_boolean_or_null(self) -> Union[bool, str, None]:
+    def parse_boolean_or_null(self) -> bool | str | None:
         # <boolean> is one of the literal strings 'true', 'false', or 'null' (unquoted)
         starting_index = self.index
         char = (self.get_char_at() or "").lower()
-        value: Optional[Tuple[str, Optional[bool]]]
+        value: tuple[str, bool | None] | None = None
         if char == "t":
             value = ("true", True)
         elif char == "f":
@@ -823,17 +790,9 @@ class JSONParser:
                         break
                 self.log(f"Found block comment: {comment}")
                 return ""
-            else:
-                # Not a recognized comment pattern, skip the slash.
-                self.index += 1
-                return ""
-
-        else:
-            # Should not be reached: if for some reason the current character does not start a comment, skip it.
-            self.index += 1
-            return ""
+        return ""  # pragma: no cover
 
-    def get_char_at(self, count: int = 0) -> Union[str, Literal[False]]:
+    def get_char_at(self, count: int = 0) -> 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]
@@ -873,9 +832,6 @@ class JSONParser:
                 char = self.json_str[self.index + idx]
             except IndexError:
                 return idx
-        if self.index + idx > 0 and self.json_str[self.index + idx - 1] == "\\":
-            # Ah this is an escaped character, try again
-            return self.skip_to_character(character=character, idx=idx + 1)
         return idx
 
     def _log(self, text: str) -> None:

json_repair/json_repair.py

@@ -14,7 +14,7 @@ This module will parse the JSON file following the BNF definition:
     <object> ::= '{' [ <member> *(', ' <member>) ] '}' ; A sequence of 'members'
     <member> ::= <string> ': ' <json> ; A pair consisting of a name, and a JSON value
 
-If something is wrong (a missing parantheses or quotes for example) it will use a few simple heuristics to fix the JSON string:
+If something is wrong (a missing parentheses or quotes for example) it will use a few simple heuristics to fix the JSON string:
 - Add the missing parentheses if the parser believes that the array or object should be closed
 - Quote strings or add missing single quotes
 - Adjust whitespaces and remove line breaks
@@ -25,21 +25,47 @@ All supported use cases are in the unit tests
 import argparse
 import json
 import sys
-from typing import Dict, List, Optional, TextIO, Tuple, Union
+from typing import Literal, TextIO, overload
 
 from .json_parser import JSONParser, JSONReturnType
 
 
+@overload
+def repair_json(
+    json_str: str = "",
+    return_objects: Literal[False] = False,
+    skip_json_loads: bool = False,
+    logging: bool = False,
+    json_fd: TextIO | None = None,
+    ensure_ascii: bool = True,
+    chunk_length: int = 0,
+    stream_stable: bool = False,
+) -> str: ...
+
+
+@overload
+def repair_json(
+    json_str: str = "",
+    return_objects: Literal[True] = True,
+    skip_json_loads: bool = False,
+    logging: bool = False,
+    json_fd: TextIO | None = None,
+    ensure_ascii: bool = True,
+    chunk_length: int = 0,
+    stream_stable: bool = False,
+) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]: ...
+
+
 def repair_json(
     json_str: str = "",
     return_objects: bool = False,
     skip_json_loads: bool = False,
     logging: bool = False,
-    json_fd: Optional[TextIO] = None,
+    json_fd: TextIO | None = None,
     ensure_ascii: bool = True,
     chunk_length: int = 0,
     stream_stable: bool = False,
-) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
+) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
     """
     Given a json formatted string, it will try to decode it and, if it fails, it will try to fix it.
 
@@ -60,16 +86,16 @@ def repair_json(
         parsed_json = parser.parse()
     else:
         try:
-            if json_fd:
-                parsed_json = json.load(json_fd)
-            else:
-                parsed_json = json.loads(json_str)
+            parsed_json = json.load(json_fd) if json_fd else 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
     if return_objects or logging:
         return parsed_json
+    # Avoid returning only a pair of quotes if it's an empty string
+    elif parsed_json == "":
+        return ""
     return json.dumps(parsed_json, ensure_ascii=ensure_ascii)
 
 
@@ -78,7 +104,7 @@ def loads(
     skip_json_loads: bool = False,
     logging: bool = False,
     stream_stable: bool = False,
-) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
+) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]] | str:
     """
     This function works like `json.loads()` except that it will fix your JSON in the process.
     It is a wrapper around the `repair_json()` function with `return_objects=True`.
@@ -89,7 +115,7 @@ def loads(
         logging (bool, optional): If True, return a tuple with the repaired json and a log of all repair actions. Defaults to False.
 
     Returns:
-        Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]: The repaired JSON object or a tuple with the repaired JSON object and repair log.
+        Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]], str]: The repaired JSON object or a tuple with the repaired JSON object and repair log.
     """
     return repair_json(
         json_str=json_str,
@@ -105,7 +131,7 @@ def load(
     skip_json_loads: bool = False,
     logging: bool = False,
     chunk_length: int = 0,
-) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
+) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
     """
     This function works like `json.load()` except that it will fix your JSON in the process.
     It is a wrapper around the `repair_json()` function with `json_fd=fd` and `return_objects=True`.
@@ -133,7 +159,7 @@ def from_file(
     skip_json_loads: bool = False,
     logging: bool = False,
     chunk_length: int = 0,
-) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
+) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]:
     """
     This function is a wrapper around `load()` so you can pass the filename as string
 
@@ -157,7 +183,7 @@ def from_file(
     return jsonobj
 
 
-def cli(inline_args: Optional[List[str]] = None) -> int:
+def cli(inline_args: list[str] | None = None) -> int:
     """
     Command-line interface for repairing and parsing JSON files.
 

json_repair/object_comparer.py

@@ -1,9 +1,9 @@
 from typing import Any
 
 
-class ObjectComparer:
+class ObjectComparer:  # pragma: no cover
     def __init__(self) -> None:
-        return
+        pass  # No operation performed in the constructor
 
     @staticmethod
     def is_same_object(obj1: Any, obj2: Any, path: str = "") -> bool:
@@ -16,40 +16,24 @@ class ObjectComparer:
             # Fail immediately if the types don't match
             return False
 
-        if isinstance(obj1, dict) and isinstance(obj2, dict):
-            # Compare dictionary keys
-            keys1, keys2 = set(obj1.keys()), set(obj2.keys())
-            common_keys = keys1 & keys2
-            extra_keys1 = keys1 - keys2
-            extra_keys2 = keys2 - keys1
-
-            if extra_keys1:
-                return False
-            if extra_keys2:
+        if isinstance(obj1, dict):
+            # Quick length check before key compares
+            if len(obj1) != len(obj2):
                 return False
-
-            # Recursively compare the common keys
-            for key in common_keys:
-                if not ObjectComparer.is_same_object(
-                    obj1[key], obj2[key], path=f"{path}/{key}"
-                ):
+            for key in obj1:
+                if key not in obj2:
+                    return False
+                if not ObjectComparer.is_same_object(obj1[key], obj2[key]):
                     return False
+            return True
 
-        elif isinstance(obj1, list) and isinstance(obj2, list):
-            # Compare lists
-            min_length = min(len(obj1), len(obj2))
+        elif isinstance(obj1, list):
             if len(obj1) != len(obj2):
                 return False
-
-            for i in range(min_length):
-                if not ObjectComparer.is_same_object(
-                    obj1[i], obj2[i], path=f"{path}[{i}]"
-                ):
+            for i in range(len(obj1)):
+                if not ObjectComparer.is_same_object(obj1[i], obj2[i]):
                     return False
+            return True
 
-            if len(obj1) > len(obj2):
-                return False
-            elif len(obj2) > len(obj1):
-                return False
-
+        # For atoms: types already match, so just return True
         return True

json_repair/string_file_wrapper.py

@@ -1,5 +1,5 @@
 import os
-from typing import TextIO, Union
+from typing import TextIO
 
 
 class StringFileWrapper:
@@ -48,7 +48,7 @@ class StringFileWrapper:
                     self.buffers.pop(oldest_key)
         return self.buffers[index]
 
-    def __getitem__(self, index: Union[int, slice]) -> str:
+    def __getitem__(self, index: int | slice) -> str:
         """
         Retrieve a character or a slice of characters from the file.
 
@@ -97,7 +97,7 @@ class StringFileWrapper:
             self.fd.seek(current_position)
         return self.length
 
-    def __setitem__(self, index: Union[int, slice], value: str) -> None:
+    def __setitem__(self, index: int | slice, value: str) -> None:  # pragma: no cover
         """
         Set a character or a slice of characters in the file.
 
@@ -105,10 +105,7 @@ class StringFileWrapper:
             index (slice): The slice of characters to set.
             value (str): The value to set at the specified index or slice.
         """
-        if isinstance(index, slice):
-            start = index.start or 0
-        else:
-            start = index or 0
+        start = index.start or 0 if isinstance(index, slice) else index or 0
 
         if start < 0:
             start += len(self)

{json_repair-0.44.0.dist-info → json_repair-0.45.0.dist-info}/METADATA

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

json_repair-0.45.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+json_repair/__init__.py,sha256=c4L2kZrHvWEKfj_ODU2naliNuvU6FlFVxtF0hbLe6s8,178
+json_repair/__main__.py,sha256=EsJb-y89uZEvGQQg1GdIDWzfDwfOMvVekKEtdguQXCM,67
+json_repair/json_context.py,sha256=WsMOjqpGSr6aaDONcrk8UFtTurzWon2Qq9AoBBYseoI,934
+json_repair/json_parser.py,sha256=DnLeC0SKTs9yaixYBYZ3J4gwxGXwOLsTWHelptGUp4Q,39407
+json_repair/json_repair.py,sha256=9wxf0vVNfr_RNQI1rbVPvxQ9feEwwvgnvkiYXwGEBX8,11292
+json_repair/object_comparer.py,sha256=ZjxrzepSNGrhiwzid2Dm657x1Aj-E1-h37bDygK8ByE,1261
+json_repair/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+json_repair/string_file_wrapper.py,sha256=uwW4B1s9Cf-iF3ANsCz-RPu2ddCqDETrt8bdojh8ufA,4485
+json_repair-0.45.0.dist-info/licenses/LICENSE,sha256=wrjQo8MhNrNCicXtMe3MHmS-fx8AmQk1ue8AQwiiFV8,1076
+json_repair-0.45.0.dist-info/METADATA,sha256=0RAn-AntRZtUdgJcBt8tvsZG-hHadaGfB9Vy2PBRcRk,12157
+json_repair-0.45.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+json_repair-0.45.0.dist-info/entry_points.txt,sha256=SNfge3zPSP-ASqriYU9r3NAPaXdseYr7ciPMKdV2uSw,57
+json_repair-0.45.0.dist-info/top_level.txt,sha256=7-VZwZN2CgB_n0NlSLk-rEUFh8ug21lESbsblOYuZqw,12
+json_repair-0.45.0.dist-info/RECORD,,

{json_repair-0.44.0.dist-info → json_repair-0.45.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

json_repair-0.44.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-json_repair/__init__.py,sha256=c4L2kZrHvWEKfj_ODU2naliNuvU6FlFVxtF0hbLe6s8,178
-json_repair/__main__.py,sha256=EsJb-y89uZEvGQQg1GdIDWzfDwfOMvVekKEtdguQXCM,67
-json_repair/json_context.py,sha256=mm6dOyrPJ1sDskTORZSXCW7W9-5veMlUKqXQ3Hw3EG4,971
-json_repair/json_parser.py,sha256=ID60F0RMzaCpeHPkZbuidJcsmrVBiPmQDRUOgjoeedE,41972
-json_repair/json_repair.py,sha256=o84um759Alft7mlj7lXZFtPQZQPjbo5Jxraa7dTdiRg,10621
-json_repair/object_comparer.py,sha256=SeicB6_N4BHAEPon7s2BELEaJc4oyR9ZhfX2RgPk6Bw,1682
-json_repair/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-json_repair/string_file_wrapper.py,sha256=koZmdq2-Z5K7XF1bDqX6dEbNaVMJYcMTjq-aGe6NQvA,4526
-json_repair-0.44.0.dist-info/licenses/LICENSE,sha256=wrjQo8MhNrNCicXtMe3MHmS-fx8AmQk1ue8AQwiiFV8,1076
-json_repair-0.44.0.dist-info/METADATA,sha256=mu_r9oiyo_35hwk745ZTFoMZrJ9PBjRPjFKgICkKSZQ,12157
-json_repair-0.44.0.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-json_repair-0.44.0.dist-info/entry_points.txt,sha256=SNfge3zPSP-ASqriYU9r3NAPaXdseYr7ciPMKdV2uSw,57
-json_repair-0.44.0.dist-info/top_level.txt,sha256=7-VZwZN2CgB_n0NlSLk-rEUFh8ug21lESbsblOYuZqw,12
-json_repair-0.44.0.dist-info/RECORD,,