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 response is not None and not self.request and hasattr(response, "request"):
self.request = response.request
super().__init__(*args, **kwargs)
Run 1
The code is highly readable with clear structure and purpose. It follows standard Python conventions with proper imports, type hints, and docstrings. The class hierarchy is logical (inherits from IOError), and the constructor clearly handles optional 'response' and 'request' parameters. Nesting is minimal (one conditional block), and the conditional logic is straightforward. Each action is on its own line, maintaining good granularity. The reading flow is natural - from argument parsing to attribute assignment to fallback logic. Minor deductions: the conditional could be slightly more explicit with parentheses for clarity, and the attribute annotations could use a comment explaining the None default. Otherwise, the code is concise, well-organized, and easy to follow.
Run 2
The code demonstrates good readability with clear structure and purpose. The class definition is straightforward, with a docstring explaining the exception's purpose. Type hints are used appropriately (TYPE_CHECKING, Any, Response, PreparedRequest), enhancing clarity. The __init__ method is concise, with each action on separate lines, making it easy to follow. The nesting is minimal—only one conditional with a compound condition, which slightly increases cognitive load but remains understandable. The logic of extracting 'response' and 'request' from kwargs, then setting self.request from response.request if needed, is clear. The imports are organized, though TYPE_CHECKING is imported but not used in visible code, which could be cleaned up. Overall, the code follows good practices but could benefit from minor refinements like breaking the compound condition into separate checks or adding comments for non-obvious logic.
Run 3
The code is highly readable. It has a clear, logical structure with a single, well-defined class. Nesting is minimal—only a single conditional block inside __init__, which is flat and easy to follow. Intent is explicitly stated in the docstring and type annotations, making the purpose unambiguous. The code is concise, avoiding unnecessary verbosity while including meaningful comments. Each line performs a single logical action, enhancing granularity. The reading flow is natural: imports, class definition, attributes, then a straightforward initializer that progressively handles arguments and fallback logic. Minor deductions are for the conditional block that contains two related actions (setting self.request and super().__init__) on separate lines but could be slightly more explicit about why the fallback exists, and the use of *args/**kwargs slightly reduces immediate signature clarity compared to explicit parameters.
Run 1
Code Structure: Imports, class documentation, attribute annotations, and initialization are logically organized, although several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: Descriptive names and the initializer docstring clearly convey how request and response context are attached; the class docstring is vague, and referenced types are not defined or imported here. Code length: Compact, with no unnecessary implementation complexity. Action granularity: Each statement performs one main action; the compound condition remains understandable. Reading flow: Initialization progresses naturally from extracting context to inferring the request and calling the superclass, with conventional formatting.
Run 2
Code Structure: Imports, class documentation, annotations, and initialization are logically organized. Nesting: A single conditional keeps the implementation flat and easy to follow. Clarity of intent: Descriptive names and the initializer docstring clearly explain how request and response information is stored, although the class docstring is vague and referenced types are not defined or imported in this snippet. Code length: The implementation is concise, but several imports are unused here. Action granularity: Each statement performs one primary action; the compound conditional remains readable. Reading flow: Initialization proceeds naturally from extracting the response to assigning attributes, inferring a request, and initializing the superclass. Additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: Imports, class documentation, attribute annotations, and initialization are logically organized. Nesting: Only one conditional keeps the implementation flat and easy to follow. Clarity of intent: Descriptive names, type hints, and the initializer docstring clarify how request and response are stored; the class docstring is somewhat vague. Code length: The implementation is concise, although several imports are unused in this snippet. Action granularity: Each statement performs a single clear action. Reading flow: Initialization proceeds naturally from extracting response, to assigning attributes, to inferring a request, and finally initializing the parent class. Minor readability limitations include Response, Request, and PreparedRequest not being defined or imported in the snippet, and a compound conditional that takes slightly more effort to parse.