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 is highly readable, with clear intent and logical structure. The class definition is concise, and the inheritance order is documented. The `__init__` method uses a well-explained two-step construction pattern, avoiding ambiguity. The `__reduce__` method includes a detailed docstring explaining its necessity, which adds clarity. Nesting is flat, action granularity is appropriate, and the reading flow is natural. Minor deductions: the import of `HTTPError` as `BaseHTTPError` appears unused, and the docstring in `__init__` could be slightly more concise. Overall, excellent clarity and maintainability.
Run 3
The code is generally readable and well-structured. It has a clear class definition with a single method, flat nesting, and concise docstrings explaining intent and rationale. Action granularity is appropriate, with one operation per line in the __init__ and __reduce__ methods. Reading flow is natural, from class docstring to method definitions. However, some aspects slightly reduce clarity: the inheritance order requires careful reading (InvalidJSONError, CompatJSONDecodeError), and the __init__ logic, while documented, relies on understanding the interplay between two parent initializers. The __reduce__ docstring is somewhat verbose and could be condensed. Overall, the code is maintainable and understandable, but the complex inheritance and exception parsing could be simplified or commented further.
Run 1
Code Structure: The class is logically organized into initialization and pickling behavior, though InvalidJSONError is not defined or imported in the snippet and two imports are unused. Nesting: There is no nested control flow, making the methods easy to scan. Clarity of intent: Descriptive aliases and docstrings explain the subtle multiple-inheritance behavior, although understanding it requires familiarity with exception arguments and method resolution order. Code length: The implementation is concise; the docstrings are somewhat lengthy but provide useful context. Action granularity: Each executable line performs one clear action. Reading flow: Imports, class definition, initialization, and serialization follow a natural sequence. Minor grammatical issues in the documentation and missing context slightly reduce readability.
Run 2
Code Structure: Imports and a focused exception class are logically organized, though InvalidJSONError is not defined or imported in the snippet and two imports appear unused. Nesting: Minimal nesting makes both methods easy to follow. Clarity of intent: Type annotations and docstrings explain the unusual initialization and pickling behavior, although understanding multiple inheritance requires some background. Code length: The implementation is concise; the docstrings are somewhat verbose but explain important subtleties. Action granularity: Each executable line performs a single clear action. Reading flow: Initialization followed by serialization support creates a natural progression. Minor grammatical issues in the documentation and missing context slightly reduce readability.
Run 3
Code Structure: The exception class logically groups initialization and pickling behavior, though InvalidJSONError is not defined or imported in the snippet and several imports are unused. Nesting: Flat method bodies make the code easy to scan. Clarity of intent: Descriptive names, type annotations, and docstrings explain the otherwise subtle multiple-inheritance behavior; minor grammatical errors reduce polish. Code length: Implementation is concise, although the explanatory docstrings are somewhat verbose. Action granularity: Each statement performs one distinct action. Reading flow: Imports, class declaration, initialization, and serialization follow a natural order, with explicit base-class calls making execution straightforward to trace.