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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_repair
-Version: 0.53.0
+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.0 → json_repair-0.54}/README.md

@@ -150,6 +150,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:
@@ -181,6 +198,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.0 → json_repair-0.54}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "json_repair"
-version = "0.53.0"
+version = "0.54"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
@@ -117,3 +117,5 @@ line-ending = "auto"
 [tool.ruff.lint.per-file-ignores]
 # Explicit re-exports is fine in __init__.py, still a code smell elsewhere.
 "__init__.py" = ["PLC0414"]
+[tool.mypy]
+strict = true

{json_repair-0.53.0 → json_repair-0.54}/src/json_repair/__init__.py

@@ -1,4 +1,4 @@
-from .constants import JSONReturnType
 from .json_repair import from_file, load, loads, repair_json
+from .utils.constants import JSONReturnType
 
 __all__ = ["from_file", "load", "loads", "repair_json", "JSONReturnType"]

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

@@ -1,36 +1,32 @@
-from typing import Literal, TextIO
+from typing import TextIO
 
-from .constants import STRING_DELIMITERS, JSONReturnType
-from .json_context import JsonContext
-from .object_comparer import ObjectComparer
 from .parse_array import parse_array as _parse_array
-from .parse_boolean_or_null import parse_boolean_or_null as _parse_boolean_or_null
 from .parse_comment import parse_comment as _parse_comment
 from .parse_number import parse_number as _parse_number
 from .parse_object import parse_object as _parse_object
 from .parse_string import parse_string as _parse_string
-from .string_file_wrapper import StringFileWrapper
+from .utils.constants import STRING_DELIMITERS, JSONReturnType
+from .utils.json_context import JsonContext
+from .utils.object_comparer import ObjectComparer
+from .utils.string_file_wrapper import StringFileWrapper
 
 
 class JSONParser:
     # Split the parse methods into separate files because this one was like 3000 lines
-    def parse_array(self, *args, **kwargs):
-        return _parse_array(self, *args, **kwargs)
+    def parse_array(self) -> list[JSONReturnType]:
+        return _parse_array(self)
 
-    def parse_boolean_or_null(self, *args, **kwargs):
-        return _parse_boolean_or_null(self, *args, **kwargs)
+    def parse_comment(self) -> JSONReturnType:
+        return _parse_comment(self)
 
-    def parse_comment(self, *args, **kwargs):
-        return _parse_comment(self, *args, **kwargs)
+    def parse_number(self) -> JSONReturnType:
+        return _parse_number(self)
 
-    def parse_number(self, *args, **kwargs):
-        return _parse_number(self, *args, **kwargs)
+    def parse_object(self) -> JSONReturnType:
+        return _parse_object(self)
 
-    def parse_object(self, *args, **kwargs):
-        return _parse_object(self, *args, **kwargs)
-
-    def parse_string(self, *args, **kwargs):
-        return _parse_string(self, *args, **kwargs)
+    def parse_string(self) -> JSONReturnType:
+        return _parse_string(self)
 
     def __init__(
         self,
@@ -39,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
@@ -70,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,
@@ -97,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:
@@ -107,8 +113,8 @@ class JSONParser:
     ) -> JSONReturnType:
         while True:
             char = self.get_char_at()
-            # False means that we are at the end of the string provided
-            if char is False:
+            # None means that we are at the end of the string provided
+            if char is None:
                 return ""
             # <object> starts with '{'
             elif char == "{":
@@ -130,30 +136,36 @@ class JSONParser:
             else:
                 self.index += 1
 
-    def get_char_at(self, count: int = 0) -> str | Literal[False]:
+    def get_char_at(self, count: int = 0) -> str | None:
         # 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]
         except IndexError:
-            return False
+            return None
 
-    def skip_whitespaces_at(self, idx: int = 0, move_main_index=True) -> int:
+    def skip_whitespaces(self) -> None:
         """
-        This function quickly iterates on whitespaces, syntactic sugar to make the code more concise
+        This function quickly iterates on whitespaces, moving the self.index forward
         """
         try:
-            char = self.json_str[self.index + idx]
-        except IndexError:
-            return idx
-        while char.isspace():
-            if move_main_index:
+            char = self.json_str[self.index]
+            while char.isspace():
                 self.index += 1
-            else:
+                char = self.json_str[self.index]
+        except IndexError:
+            pass
+
+    def scroll_whitespaces(self, idx: int = 0) -> int:
+        """
+        This function quickly iterates on whitespaces. Doesn't move the self.index and returns the offset from self.index
+        """
+        try:
+            char = self.json_str[self.index + idx]
+            while char.isspace():
                 idx += 1
-            try:
                 char = self.json_str[self.index + idx]
-            except IndexError:
-                return idx
+        except IndexError:
+            pass
         return idx
 
     def skip_to_character(self, character: str | list[str], idx: int = 0) -> int:

{json_repair-0.53.0 → json_repair-0.54}/src/json_repair/json_repair.py

@@ -25,10 +25,10 @@ All supported use cases are in the unit tests
 import argparse
 import json
 import sys
-from typing import Literal, TextIO, overload
+from typing import Any, Literal, TextIO, overload
 
-from .constants import JSONReturnType
 from .json_parser import JSONParser
+from .utils.constants import JSONReturnType
 
 
 @overload
@@ -40,7 +40,8 @@ def repair_json(
     json_fd: TextIO | None = None,
     chunk_length: int = 0,
     stream_stable: bool = False,
-    **json_dumps_args,
+    strict: bool = False,
+    **json_dumps_args: Any,
 ) -> str: ...
 
 
@@ -53,7 +54,8 @@ def repair_json(
     json_fd: TextIO | None = None,
     chunk_length: int = 0,
     stream_stable: bool = False,
-    **json_dumps_args,
+    strict: bool = False,
+    **json_dumps_args: Any,
 ) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]]: ...
 
 
@@ -65,8 +67,9 @@ def repair_json(
     json_fd: TextIO | None = None,
     chunk_length: int = 0,
     stream_stable: bool = False,
-    **json_dumps_args,
-) -> JSONReturnType | tuple[JSONReturnType, list[dict[str, str]]] | tuple[JSONReturnType, list]:
+    strict: bool = False,
+    **json_dumps_args: Any,
+) -> 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.
 
@@ -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-0.53.0 → json_repair-0.54}/src/json_repair/parse_array.py

@@ -1,8 +1,8 @@
 from typing import TYPE_CHECKING
 
-from .constants import STRING_DELIMITERS, JSONReturnType
-from .json_context import ContextValues
-from .object_comparer import ObjectComparer
+from .utils.constants import STRING_DELIMITERS, JSONReturnType
+from .utils.json_context import ContextValues
+from .utils.object_comparer import ObjectComparer
 
 if TYPE_CHECKING:
     from .json_parser import JSONParser
@@ -15,7 +15,7 @@ def parse_array(self: "JSONParser") -> list[JSONReturnType]:
     # Stop when you either find the closing parentheses or you have iterated over the entire string
     char = self.get_char_at()
     while char and char not in ["]", "}"]:
-        self.skip_whitespaces_at()
+        self.skip_whitespaces()
         value: JSONReturnType = ""
         if char in STRING_DELIMITERS:
             # Sometimes it can happen that LLMs forget to start an object and then you think it's a string in an array
@@ -23,13 +23,13 @@ def parse_array(self: "JSONParser") -> list[JSONReturnType]:
             # And either parse the string or parse the object
             i = 1
             i = self.skip_to_character(char, i)
-            i = self.skip_whitespaces_at(idx=i + 1, move_main_index=False)
+            i = self.scroll_whitespaces(idx=i + 1)
             value = self.parse_object() if self.get_char_at(i) == ":" else self.parse_string()
         else:
             value = self.parse_json()
 
-        # It is possible that parse_json() returns nothing valid, so we increase by 1
-        if ObjectComparer.is_strictly_empty(value):
+        # It is possible that parse_json() returns nothing valid, so we increase by 1, unless we find an array separator
+        if ObjectComparer.is_strictly_empty(value) and self.get_char_at() not in ["]", ","]:
             self.index += 1
         elif value == "..." and self.get_char_at(-1) == ".":
             self.log(
@@ -45,7 +45,7 @@ def parse_array(self: "JSONParser") -> list[JSONReturnType]:
             char = self.get_char_at()
 
     # Especially at the end of an LLM generated json you might miss the last "]"
-    if char and char != "]":
+    if char != "]":
         self.log(
             "While parsing an array we missed the closing ], ignoring it",
         )

{json_repair-0.53.0 → json_repair-0.54}/src/json_repair/parse_comment.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING
 
-from .constants import JSONReturnType
-from .json_context import ContextValues
+from .utils.constants import JSONReturnType
+from .utils.json_context import ContextValues
 
 if TYPE_CHECKING:
     from .json_parser import JSONParser

{json_repair-0.53.0 → json_repair-0.54}/src/json_repair/parse_number.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING
 
-from .json_context import ContextValues
+from .utils.constants import JSONReturnType
+from .utils.json_context import ContextValues
 
 NUMBER_CHARS: set[str] = set("0123456789-.eE/,")
 
@@ -9,7 +10,7 @@ if TYPE_CHECKING:
     from .json_parser import JSONParser
 
 
-def parse_number(self: "JSONParser") -> float | int | str | bool | None:
+def parse_number(self: "JSONParser") -> JSONReturnType:
     # <number> is a valid real number expressed in one of a number of given formats
     number_str = ""
     char = self.get_char_at()

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

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING
 
-from .constants import STRING_DELIMITERS, JSONReturnType
-from .json_context import ContextValues
+from .utils.constants import STRING_DELIMITERS, JSONReturnType
+from .utils.json_context import ContextValues
 
 if TYPE_CHECKING:
     from .json_parser import JSONParser
@@ -17,10 +17,10 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
         # <member> ::= <string> ': ' <json>
 
         # Skip filler whitespaces
-        self.skip_whitespaces_at()
+        self.skip_whitespaces()
 
         # Sometimes LLMs do weird things, if we find a ":" so early, we'll change it to "," and move on
-        if (self.get_char_at() or "") == ":":
+        if self.get_char_at() == ":":
             self.log(
                 "While parsing an object we found a : before a key, ignoring",
             )
@@ -53,18 +53,26 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
                             prev_value.extend(
                                 new_array[0] if len(new_array) == 1 and isinstance(new_array[0], list) else new_array
                             )
-                        self.skip_whitespaces_at()
+                        self.skip_whitespaces()
                         if self.get_char_at() == ",":
                             self.index += 1
-                        self.skip_whitespaces_at()
+                        self.skip_whitespaces()
                         continue
             key = str(self.parse_string())
             if key == "":
-                self.skip_whitespaces_at()
+                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",
             )
@@ -74,16 +82,21 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
             break
 
         # Skip filler whitespaces
-        self.skip_whitespaces_at()
+        self.skip_whitespaces()
 
         # We reached the end here
         if (self.get_char_at() or "}") == "}":
             continue
 
-        self.skip_whitespaces_at()
+        self.skip_whitespaces()
 
         # An extreme case of missing ":" after a key
-        if (self.get_char_at() or "") != ":":
+        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,31 +104,40 @@ 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
-        self.skip_whitespaces_at()
+        # 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() or "") in [",", "}"]:
+        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
 
-        if (self.get_char_at() or "") in [",", "'", '"']:
+        if self.get_char_at() in [",", "'", '"']:
             self.index += 1
 
         # Remove trailing spaces
-        self.skip_whitespaces_at()
+        self.skip_whitespaces()
 
     self.index += 1
 
     # 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()
@@ -126,18 +148,19 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
     if not self.context.empty:
         return obj
 
-    self.skip_whitespaces_at()
-    if (self.get_char_at() or "") != ",":
+    self.skip_whitespaces()
+    if self.get_char_at() != ",":
         return obj
     self.index += 1
-    self.skip_whitespaces_at()
-    if (self.get_char_at() or "") not in STRING_DELIMITERS:
+    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