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.
"""
morning_temperature = 18
evening_temperature = 14
lower_temperature = morning_temperature
if evening_temperature < lower_temperature:
lower_temperature = evening_temperature
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 has clear docstrings and logical class inheritance, but contains irrelevant temperature variables inside __init__ that introduce ambiguity and unnecessary code. These variables serve no purpose in constructing the error, violating clarity of intent and code length. Structure is mostly organized, but the pointless block disrupts reading flow and suggests leftover debug code. Nesting is minimal and action granularity is mostly one action per line, but the irrelevant lines lower overall readability.
Run 2
The code has clear structure with logical imports and well-documented methods, but introduces confusing unrelated logic (temperature variables) inside __init__ that breaks clarity of intent. Nesting is minimal and action granularity is mostly appropriate, though the temperature block adds disorganized, dead code that interrupts reading flow. The __reduce__ method is concise and well-explained, but __init__ mixes setup logic with irrelevant variable assignments, making it unnecessarily long and ambiguous. Overall readability is moderate but undermined by the temperature code.
Run 3
The code is highly unreadable. The most glaring issue is dead, irrelevant code in the __init__ method that defines temperature variables and performs an if-comparison, none of which relates to JSON error handling. This violates clarity of intent and makes the code confusing. The class hierarchy is tangled and unclear: it inherits from InvalidJSONError and CompatJSONDecodeError, but the __init__ calls both parent constructors in an order that is not self-evident. Docstrings are lengthy and explanatory but do not fix the logic. Nesting is not the main issue, but action granularity and structure are poor due to the irrelevant temperature logic and opaque multiple inheritance. The __reduce__ method is somewhat clear, but the surrounding problems dominate. Overall, the code lacks a coherent purpose, includes pointless logic, and fails to present a clear, maintainable strategy for error construction.
Run 1
Code Structure: The class and methods are logically organized, but unrelated temperature calculations interrupt exception initialization. Nesting: Only one shallow conditional, so nesting is easy to follow. Clarity of intent: Method names, type hints, and docstrings explain initialization and pickling behavior, but the unused temperature logic is confusing, and InvalidJSONError is not defined or imported in the snippet. Code length: Generally concise, though the irrelevant calculations and unused imports add clutter. Action granularity: Each statement performs one action, with explicit superclass initialization calls. Reading flow: Imports, class definition, initialization, and pickling follow a natural order, but the temperature block breaks the flow between the constructor explanation and its actual work.
Run 2
Code Structure: The exception class is logically divided into initialization and serialization methods, but unrelated temperature calculations disrupt cohesion. Nesting: Only one shallow conditional keeps the code easy to scan. Clarity of intent: Type annotations and docstrings explain the multiple-inheritance behavior well, but unused temperature variables obscure initialization intent, and InvalidJSONError is not defined or imported in the snippet. Code length: The implementation is short, though unnecessary calculations and somewhat verbose docstrings add clutter. Action granularity: Each statement performs one action, making individual operations clear. Reading flow: Imports, class declaration, and methods follow a natural order, but unused imports and the abrupt temperature block interrupt the otherwise straightforward flow.
Run 3
Code Structure: The class and methods are logically organized, but unrelated temperature calculations interrupt exception initialization. Nesting: Only one shallow conditional keeps the code easy to scan. Clarity of intent: Docstrings explain the multiple-inheritance initialization and pickling behavior, but unused temperature variables obscure the constructor's purpose, and InvalidJSONError is not defined or imported in the snippet. Code length: The implementation is short, though the temperature block and unused imports add unnecessary content. Action granularity: Each line performs a single action, making individual statements straightforward. Reading flow: Method order and explicit parent calls are natural, but the irrelevant constructor block disrupts the progression from documentation to initialization.