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 generally well-structured and readable. It has a clear class hierarchy, concise docstrings explaining non-obvious behavior, and follows good practices like explicit type annotations. Nesting is minimal (one class with two methods), and each action is on its own line. The __init__ method has a clear sequential flow, constructing one parent from args then another from those results. The __reduce__ method is short with a clear purpose. Minor deductions: the multiple inheritance order may require careful reading, and the __init__ logic, while documented, is somewhat subtle. Overall, the code is concise, well-commented where needed, and easy to follow for someone familiar with Python MRO and error class hierarchies.
Run 3
The code is well-structured and readable. The class definition is concise, with a clear multiple inheritance pattern and purposeful method overrides. Docstrings are thorough and explain the non-obvious reasoning behind the method implementations, which significantly enhances clarity. Nesting is minimal, and each method focuses on a single action, maintaining good action granularity. The logic in __init__ is slightly complex but is well-documented. Variable names are descriptive, and the overall length is appropriate. The only minor drawback is the slight complexity in understanding the multiple inheritance behavior without documentation, but the provided docstrings mitigate this effectively.
Run 1
Code Structure: The class cleanly groups 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 names, type annotations, and docstrings explain the otherwise subtle multiple-inheritance behavior. Minor grammatical errors slightly reduce polish. Code length: Implementation is concise; the longer docstrings provide useful context rather than unnecessary repetition. Action granularity: Each statement performs a single clear action. Reading flow: Imports, class declaration, initialization, and serialization follow a natural order, although understanding the inheritance relationships requires context outside the snippet.
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 the code easy to scan. Clarity of intent: Type annotations and docstrings explain the unusual initialization and pickling behavior, although understanding it requires familiarity with multiple inheritance 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: Initialization followed by serialization support is natural, with explicit base-class calls making execution straightforward. Minor grammatical issues in the documentation slightly reduce polish.
Run 3
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: Methods are flat, with no nested control flow. Clarity of intent: Type hints and docstrings explain the multiple-inheritance initialization and serialization requirements, although understanding them requires familiarity with exception inheritance and MRO. Code length: Implementation is concise, but the explanatory docstrings are somewhat wordy. Action granularity: Each statement performs one clear action. Reading flow: Imports, class declaration, initialization, and serialization follow a natural order; the missing base-class context and minor documentation wording issues slightly interrupt comprehension.