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 well-structured with clear class definition, logical MRO handling, and explicit intent through docstrings. It maintains flat nesting, concise methods, and one action per line. Minor readability trade-offs include slightly complex inheritance (necessary for the use case) and somewhat dense docstrings, but overall it is highly readable and maintainable.
Run 2
The code has a clear purpose with good docstrings explaining the non-obvious MRO and error construction logic. However, several issues hurt readability: the inheritance order is counterintuitive and requires explanation to understand. The __init__ method relies on side effects of assigning self.args between parent calls, which is subtle and fragile. Method names like __reduce__ are not self-documenting without domain knowledge. The nested exception class hierarchy adds cognitive overhead. Some lines are unnecessarily long (exceeding 79 characters). The code is concise but at the cost of clarity - a reader must understand Python's MRO, pickling protocol, and error class internals. The docstrings help but indicate the code itself is not naturally readable. Structure is acceptable but the tricky initialization sequence makes maintenance risky.
Run 3
The code is well-structured with clear separation of concerns through multiple inheritance. It maintains a flat nesting structure with no deep conditionals. Naming is descriptive and docstrings effectively explain the non-obvious parts, particularly the inheritance and pickling behavior. The class body is concise, containing only two methods. Each method performs a single logical action per line, with the __init__ method making its two-part initialization explicit. The reading flow is natural: construct, then handle serialization. Minor deductions: the multiple inheritance line could benefit from a brief comment, and the __reduce__ docstring is somewhat dense. Overall, the code is highly readable and maintainable.
Run 1
Code Structure: Imports and a focused exception class are logically organized, though InvalidJSONError is not defined or imported in the snippet and two imports are unused. Nesting: Minimal nesting makes both methods easy to follow. Clarity of intent: Descriptive names, type annotations, and docstrings explain the subtle initialization and pickling behavior; multiple inheritance requires some background knowledge. Code length: The implementation is concise, although the explanatory docstrings are somewhat verbose. Action granularity: Each statement performs one clear action. Reading flow: Initialization followed by serialization support is natural, with explicit base-class calls making the execution sequence clear.
Run 2
Code Structure: The exception class logically groups initialization and pickling behavior, although InvalidJSONError is not defined or imported in the snippet and two imports are unused. Nesting: Methods are flat, with no branching or deeply nested blocks. Clarity of intent: Descriptive names, type annotations, and docstrings explain the otherwise subtle multiple-inheritance behavior. Code length: Implementation is concise; the docstrings are somewhat verbose but provide useful context. Action granularity: Each executable line performs one clear action. Reading flow: Imports, class declaration, initialization, and serialization follow a natural sequence, though understanding the parent classes and method resolution order requires external context.
Run 3
Code Structure: The exception class is logically organized, with initialization followed by serialization behavior, though InvalidJSONError is not defined or imported in the snippet and two imports are unused. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Descriptive names, type annotations, and docstrings explain the unusual multiple-inheritance initialization and pickling requirements. Code length: The implementation is concise, although the docstrings are somewhat wordy and contain minor grammatical issues. Action granularity: Each statement performs one clear action. Reading flow: Imports, class declaration, constructor, and __reduce__ follow a natural sequence; understanding the inheritance interactions requires some familiarity with exception internals.