Source code
from __future__ import annotations
from typing import TYPE_CHECKING, Any
from urllib3.exceptions import HTTPError as BaseHTTPError
from .compat import JSONDecodeError as CompatJSONDecodeError
class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError):
"""Couldn't decode the text into json"""
def __init__(self, *args: Any, **kwargs: Any) -> None:
"""
Construct the JSONDecodeError instance first with all
args. Then use it's args to construct the IOError so that
the json specific args aren't used as IOError specific args
and the error message from JSONDecodeError is preserved.
"""
CompatJSONDecodeError.__init__(self, *args)
InvalidJSONError.__init__(self, *self.args, **kwargs)
def __reduce__(self) -> tuple[Any, ...] | str:
"""
The __reduce__ method called when pickling the object must
be the one from the JSONDecodeError (be it json/simplejson)
as it expects all the arguments for instantiation, not just
one like the IOError, and the MRO would by default call the
__reduce__ method from the IOError due to the inheritance order.
"""
return CompatJSONDecodeError.__reduce__(self)
Run 1
The code is generally readable with clear intent and docstrings explaining non-obvious design decisions. The class structure is logical and the methods are short. However, the multiple inheritance and the custom __init__ ordering create conceptual complexity despite explanatory comments. The code uses flat nesting and mostly one action per line, which helps. The reading flow is somewhat disrupted by the dense explanatory docstrings and the need to understand inheritance semantics, but overall it is maintainable and intentional rather than tangled.
Run 2
The code is well-structured with clear separation of class definition, constructor, and serialization method. The inheritance and exception handling logic is explicit, and docstrings provide necessary context for non-obvious design decisions (MRO, pickling). Nesting is minimal, with only one method-level indentation. Intent is clear: define a hybrid JSON decode error class. However, readability is slightly reduced by the unusual multiple inheritance pattern and the need for comments to explain why specific parent methods are called. The __reduce__ method's return type annotation is a bit complex. Overall, the code is concise but context-dependent; someone unfamiliar with the class hierarchy might need to read the docstrings carefully. Action granularity is reasonable, though the constructor chains two initialization calls in sequence, which is acceptable given the explanation.
Run 3
The code is generally readable with clear intent and good structure. The class hierarchy is logical, and docstrings explain non-obvious design choices, such as the __init__ ordering and __reduce__ override. Nesting is minimal, action granularity is reasonable, and the flow is natural. However, the __init__ method's comment and implementation could be clearer, and a few lines are dense. Overall, it's a well-documented and maintainable piece of code.
Run 1
Code Structure: The class logically groups initialization and pickling behavior, though imports lack separation from the class and InvalidJSONError is not defined or imported in the snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Descriptive names and docstrings explain the otherwise subtle multiple-inheritance behavior; unused imports add minor distraction. Code length: Implementation is concise, although the docstrings are somewhat verbose. Action granularity: Each statement performs one clear action. Reading flow: Initialization followed by serialization support is natural, with explicit parent-method calls making execution order clear.
Run 2
Code Structure: The class logically groups initialization and pickling behavior, though missing spacing after imports and the undefined InvalidJSONError base reduce self-contained readability. Nesting: Flat methods with no nested control flow are easy to follow. Clarity of intent: Descriptive aliases, type annotations, and docstrings explain the unusual multiple-inheritance behavior well; unused imports add minor noise. Code length: The implementation is concise, although the docstrings are somewhat verbose and contain minor grammatical issues. Action granularity: Each executable line performs a single clear action. Reading flow: Initialization proceeds naturally, followed by serialization behavior; understanding the inheritance details requires some background knowledge, but the explanations help.
Run 3
Code Structure: Imports and a focused exception class are logically organized, though InvalidJSONError is not defined or imported in the snippet and spacing between imports and the class is missing. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: Descriptive aliases, type annotations, and docstrings explain the unusual initialization and pickling behavior, although multiple inheritance requires background knowledge. Code length: The implementation is concise; the detailed docstrings are useful but slightly wordy. Action granularity: Each statement performs one clear action. Reading flow: Initialization followed by serialization support is natural, but unused TYPE_CHECKING and BaseHTTPError imports add minor distraction.