json-repair 0.20.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

json_repair/json_repair.py

@@ -24,11 +24,55 @@ All supported use cases are in the unit tests
 
 import os
 import json
-from typing import Any, Dict, List, Union, TextIO
+from typing import Any, Dict, List, Optional, Union, TextIO, Tuple
+
+
+class StringFileWrapper:
+    # This is a trick to simplify the code, transform the filedescriptor handling into a string handling
+    def __init__(self, fd: TextIO) -> None:
+        self.fd = fd
+        self.length: int = 0
+
+    def __getitem__(self, index: int) -> str:
+        if isinstance(index, slice):
+            self.fd.seek(index.start)
+            value = self.fd.read(index.stop - index.start)
+            self.fd.seek(index.start)
+            return value
+        else:
+            self.fd.seek(index)
+            return self.fd.read(1)
+
+    def __len__(self) -> int:
+        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)
+        return self.length
+
+    def __setitem__(self) -> None:
+        raise Exception("This is read-only!")
+
+
+class LoggerConfig:
+    # This is a type class to simplify the declaration
+    def __init__(self, log_level: Optional[str]):
+        self.log: List[Dict[str, str]] = []
+        self.window: int = 10
+        self.log_level: str = log_level if log_level else "none"
+
+
+JSONReturnType = Union[Dict[str, Any], List[Any], str, float, int, bool, None]
 
 
 class JSONParser:
-    def __init__(self, json_str: str, json_fd: TextIO, logging: bool = False) -> None:
+    def __init__(
+        self,
+        json_str: Union[str, StringFileWrapper],
+        json_fd: Optional[TextIO],
+        logging: Optional[bool],
+    ) -> None:
         # The string to parse
         self.json_str = json_str
         # Alternatively, the file description with a json file in it
@@ -36,25 +80,23 @@ class JSONParser:
             # This is a trick we do to treat the file wrapper as an array
             self.json_str = StringFileWrapper(json_fd)
         # Index is our iterator that will keep track of which character we are looking at right now
-        self.index = 0
+        self.index: int = 0
         # This is used in the object member parsing to manage the special cases of missing quotes in key or value
-        self.context = []
+        self.context: list[str] = []
         # Use this to log the activity, but only if logging is active
-        self.logger = {
-            "log": [],
-            "window": 10,
-            "log_level": "info" if logging else "none",
-        }
-
-    def parse(self) -> Union[Dict[str, Any], List[Any], str, float, int, bool, None]:
-        if self.logger["log_level"] == "none":
+        self.logger = LoggerConfig(log_level="info" if logging else None)
+
+    def parse(
+        self,
+    ) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
+        if self.logger.log_level == "none":
             return self.parse_json()
         else:
-            return self.parse_json(), self.logger["log"]
+            return self.parse_json(), self.logger.log
 
     def parse_json(
         self,
-    ) -> Union[Dict[str, Any], List[Any], str, float, int, bool, None]:
+    ) -> JSONReturnType:
         char = self.get_char_at()
         # False means that we are at the end of the string provided, is the base case for recursion
         if char is False:
@@ -131,10 +173,14 @@ class JSONParser:
                     # Sometimes the string search might not move the index at all, that might lead us to an infinite loop
                     self.index += 1
 
+            self.skip_whitespaces_at()
+
             # We reached the end here
             if (self.get_char_at() or "}") == "}":
                 continue
 
+            self.skip_whitespaces_at()
+
             # An extreme case of missing ":" after a key
             if (self.get_char_at() or "") != ":":
                 self.log(
@@ -178,7 +224,7 @@ class JSONParser:
             value = self.parse_json()
 
             # It is possible that parse_json() returns nothing valid, so we stop
-            if not value:
+            if value == "":
                 break
 
             if value == "..." and self.get_char_at(-1) == ".":
@@ -221,7 +267,7 @@ class JSONParser:
         self.reset_context()
         return arr
 
-    def parse_string(self) -> str:
+    def parse_string(self) -> Union[str, JSONReturnType]:
         # <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
@@ -320,7 +366,7 @@ class JSONParser:
                 string_acc = string_acc[:-1]
                 if char in [rstring_delimiter, "t", "n", "r", "b", "\\"]:
                     escape_seqs = {"t": "\t", "n": "\n", "r": "\r", "b": "\b"}
-                    string_acc += escape_seqs.get(char, char)
+                    string_acc += escape_seqs.get(char, char) or char
                     self.index += 1
                     char = self.get_char_at()
             # ChatGPT sometimes forget to quote stuff in html tags or markdown, so we do this whole thing here
@@ -358,7 +404,29 @@ class JSONParser:
                             break
                         i += 1
                         next_c = self.get_char_at(i)
-                    if next_c == rstring_delimiter:
+                    # If we stopped for a comma in object_value context, let's check if find a "} at the end of the string
+                    if next_c == "," and self.get_context() == "object_value":
+                        i += 1
+                        next_c = self.get_char_at(i)
+                        while next_c and next_c != rstring_delimiter:
+                            i += 1
+                            next_c = self.get_char_at(i)
+                        # Ok now I found a delimiter, let's skip whitespaces and see if next we find a }
+                        i += 1
+                        next_c = self.get_char_at(i)
+                        while next_c and next_c.isspace():
+                            i += 1
+                            next_c = self.get_char_at(i)
+                        if next_c == "}":
+                            # OK this is valid then
+                            self.log(
+                                "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
+                            self.index += 1
+                            char = self.get_char_at()
+                    elif next_c == rstring_delimiter:
                         if self.get_context() == "object_value":
                             # But this might not be it! This could be just a missing comma
                             # We found a delimiter and we need to check if this is a key
@@ -414,7 +482,7 @@ class JSONParser:
 
         return string_acc.rstrip()
 
-    def parse_number(self) -> Union[float, int, str]:
+    def parse_number(self) -> Union[float, int, str, JSONReturnType]:
         # <number> is a valid real number expressed in one of a number of given formats
         number_str = ""
         number_chars = set("0123456789-.eE/,")
@@ -447,8 +515,7 @@ class JSONParser:
     def parse_boolean_or_null(self) -> Union[bool, str, None]:
         # <boolean> is one of the literal strings 'true', 'false', or 'null' (unquoted)
         starting_index = self.index
-        value = ""
-        char = self.get_char_at().lower()
+        char = (self.get_char_at() or "").lower()
         if char == "t":
             value = ("true", True)
         elif char == "f":
@@ -456,12 +523,12 @@ class JSONParser:
         elif char == "n":
             value = ("null", None)
 
-        if len(value):
+        if value:
             i = 0
             while char and i < len(value[0]) and char == value[0][i]:
                 i += 1
                 self.index += 1
-                char = self.get_char_at().lower()
+                char = (self.get_char_at() or "").lower()
             if i == len(value[0]):
                 return value[1]
 
@@ -509,12 +576,12 @@ class JSONParser:
             return ""
 
     def log(self, text: str, level: str) -> None:
-        if level == self.logger["log_level"]:
+        if level == self.logger.log_level:
             context = ""
-            start = max(self.index - self.logger["window"], 0)
-            end = min(self.index + self.logger["window"], len(self.json_str))
+            start = max(self.index - self.logger.window, 0)
+            end = min(self.index + self.logger.window, len(self.json_str))
             context = self.json_str[start:end]
-            self.logger["log"].append(
+            self.logger.log.append(
                 {
                     "text": text,
                     "context": context,
@@ -524,11 +591,11 @@ class JSONParser:
 
 def repair_json(
     json_str: str = "",
-    return_objects: bool = False,
-    skip_json_loads: bool = False,
-    logging: bool = False,
-    json_fd: TextIO = None,
-) -> Union[Dict[str, Any], List[Any], str, float, int, bool, None]:
+    return_objects: Optional[bool] = False,
+    skip_json_loads: Optional[bool] = False,
+    logging: Optional[bool] = False,
+    json_fd: Optional[TextIO] = None,
+) -> Union[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.
     It will return the fixed string by default.
@@ -555,7 +622,7 @@ def repair_json(
 
 def loads(
     json_str: str, skip_json_loads: bool = False, logging: bool = False
-) -> Union[Dict[str, Any], List[Any], str, float, int, bool, None]:
+) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[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`.
@@ -570,7 +637,7 @@ def loads(
 
 def load(
     fd: TextIO, skip_json_loads: bool = False, logging: bool = False
-) -> Union[Dict[str, Any], List[Any], str, float, int, bool, None]:
+) -> Union[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`.
@@ -580,7 +647,7 @@ def load(
 
 def from_file(
     filename: str, skip_json_loads: bool = False, logging: bool = False
-) -> Union[Dict[str, Any], List[Any], str, float, int, bool, None]:
+) -> Union[JSONReturnType, Tuple[JSONReturnType, List[Dict[str, str]]]]:
     """
     This function is a wrapper around `load()` so you can pass the filename as string
     """
@@ -589,31 +656,3 @@ def from_file(
     fd.close()
 
     return jsonobj
-
-
-class StringFileWrapper:
-    # This is a trick to simplify the code above, transform the filedescriptor handling into an array handling
-    def __init__(self, fd: TextIO) -> None:
-        self.fd = fd
-        self.length = None
-
-    def __getitem__(self, index: int) -> Any:
-        if isinstance(index, slice):
-            self.fd.seek(index.start)
-            value = self.fd.read(index.stop - index.start)
-            self.fd.seek(index.start)
-            return value
-        else:
-            self.fd.seek(index)
-            return self.fd.read(1)
-
-    def __len__(self) -> int:
-        if not self.length:
-            current_position = self.fd.tell()
-            self.fd.seek(0, os.SEEK_END)
-            self.length = self.fd.tell()
-            self.fd.seek(current_position)
-        return self.length
-
-    def __setitem__(self):
-        raise Exception("This is read-only!")

{json_repair-0.20.0.dist-info → json_repair-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: json_repair
-Version: 0.20.0
+Version: 0.21.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.21.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+json_repair/__init__.py,sha256=IIzSm1DsCRrr8seF3UeMZXwxcq-tE3j-8d1WBxvEJvE,178
+json_repair/json_repair.py,sha256=ry94U3QoJwVgyG1qeQNEb8Qt8NtCLpCGR41GBA7tozY,27320
+json_repair-0.21.0.dist-info/LICENSE,sha256=wrjQo8MhNrNCicXtMe3MHmS-fx8AmQk1ue8AQwiiFV8,1076
+json_repair-0.21.0.dist-info/METADATA,sha256=obBsHuNN7Ph5zX77VHmER2O9A61F3MXGBreEowdr-so,7333
+json_repair-0.21.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+json_repair-0.21.0.dist-info/top_level.txt,sha256=7-VZwZN2CgB_n0NlSLk-rEUFh8ug21lESbsblOYuZqw,12
+json_repair-0.21.0.dist-info/RECORD,,

json_repair-0.20.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-json_repair/__init__.py,sha256=IIzSm1DsCRrr8seF3UeMZXwxcq-tE3j-8d1WBxvEJvE,178
-json_repair/json_repair.py,sha256=zYg4tIwZ4rdVkCQ5XVceNQaOz2MT50O7jHJbJ1EpKhk,25446
-json_repair-0.20.0.dist-info/LICENSE,sha256=wrjQo8MhNrNCicXtMe3MHmS-fx8AmQk1ue8AQwiiFV8,1076
-json_repair-0.20.0.dist-info/METADATA,sha256=2WrsjORPx37e4CqdkdiARwB-VoP5EyjsZaS0hcVnVBo,7333
-json_repair-0.20.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-json_repair-0.20.0.dist-info/top_level.txt,sha256=7-VZwZN2CgB_n0NlSLk-rEUFh8ug21lESbsblOYuZqw,12
-json_repair-0.20.0.dist-info/RECORD,,