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 RequestException(IOError):
"""There was an ambiguous exception that occurred while handling your
request.
"""
response: Response | None
request: Request | PreparedRequest | None
def __init__(self, *args: Any, **kwargs: Any) -> None:
"""Initialize RequestException with `request` and `response` objects."""
response: Response | None = kwargs.pop("response", None)
self.response = response
self.request = kwargs.pop("request", None)
if not (response is not None and not self.request and hasattr(response, "request")):
pass
else:
self.request = response.request
super().__init__(*args, **kwargs)
Run 1
The code has clear type annotations and class-level attributes, but several issues reduce readability. The if/else condition is unnecessarily complex and lacks clarity - 'if not (response is not None and not self.request and hasattr(response, 'request'))' is convoluted. The empty 'pass' branch followed by 'else' is an anti-pattern that could be simplified to a positive if-statement. The exception hierarchy is clear, and the docstring is helpful, but the conditional logic obscures the intent. The code is relatively flat and concise, but the action granularity suffers from the compressed conditional expression. Overall structure is logical with good typing, but the conditional could be replaced with 'if response and not self.request and hasattr(response, 'request'): self.request = response.request' for better readability.
Run 2
The code is understandable but has readability issues. Structure is logical with clear class definition and type hints. However, the conditional logic in __init__ is convoluted: the condition 'not (response is not None and not self.request and hasattr(response, "request"))' with pass/else branches inverts the natural reading order - the meaningful action happens in the else block. This creates unnecessary nesting depth and obscures intent. The logic could be flattened by checking the positive condition directly (if response and not self.request and hasattr(response, 'request'): self.request = response.request). Action granularity is mostly one action per line, but the multi-part condition violates this. Reading flow is disrupted by the inverted condition. Length is acceptable, docstrings are helpful. Overall, the code works but the conditional structure needs simplification for better clarity.
Run 3
The code is generally readable with clear class naming, type hints, and docstrings. The __init__ method has concerning logic: a conditional with a pass statement and an else block that reverses the natural reading order — this creates unnecessary cognitive load. The condition itself (`response is not None and not self.request and hasattr(response, 'request')`) is complex but named variables would help. Action granularity is mostly one-per-line, and structure is logical. The nesting is shallow, which is good, but the if/else with pass could simply be inverted: `if response and not self.request and hasattr(...): self.request = response.request`. This would flatten the logic and improve flow. Overall the code is clean and maintainable, with the main issue being the awkward conditional structure.
Run 1
Code Structure: Imports, class attributes, and initialization are logically organized, though TYPE_CHECKING and exception aliases are unused in this snippet. Nesting: Shallow, but the negated conditional with an empty pass branch adds needless complexity. Clarity of intent: Descriptive names, type annotations, and the initializer docstring clarify exception setup; the class docstring is vague, and Request, PreparedRequest, and Response are not defined or imported here. Code length: Mostly concise, but the pass/else construct could be replaced with a direct positive condition. Action granularity: Each statement performs a distinct action, making assignments and initialization easy to track. Reading flow: Generally natural, progressing from response extraction to request assignment and superclass initialization, but the inverted conditional interrupts that flow.
Run 2
Code Structure: Imports, class attributes, and initialization are logically organized, though unused imports add clutter. Nesting: Shallow overall, but the negated condition with an empty pass branch creates unnecessary control flow. Clarity of intent: Type annotations and the initializer docstring clarify the stored objects; the compound negative condition and vague class docstring reduce clarity. Code length: Mostly concise, but a direct positive conditional would eliminate the pass and else lines. Action granularity: Each statement performs one clear action, with no packed statements. Reading flow: Initialization proceeds naturally from extracting arguments to setting attributes and calling the superclass, but the inverted conditional interrupts that flow.
Run 3
Code Structure: Imports, exception class, annotations, and initializer are logically organized. Nesting: Shallow, but the empty if branch and else introduce unnecessary branching. Clarity of intent: The initializer docstring and descriptive names clarify the purpose, while the negated compound condition makes request inference harder to understand. Code length: Mostly concise, though the pass branch, unused imports, and redundant local annotation add clutter. Action granularity: Each statement performs one clear action. Reading flow: Initialization proceeds naturally from extracting arguments to setting attributes and invoking the superclass, but the inverted conditional interrupts that flow; a direct positive condition would be easier to read.