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 is clear and well-structured. It uses type hints effectively, making the intent and data flow easy to understand. The class is short, focused, and logically organized with a single responsibility. Nesting is minimal and action granularity is appropriate, with one logical action per line. The reading flow is natural: the docstring explains the class, then the __init__ method proceeds step-by-step through response and request assignment, fallback logic, and super().__init__ call. The use of kwargs.pop() for extracting specific arguments is clean. Minor deductions: the conditional fallback logic could be slightly more explicit, and TYPE_CHECKING import is unused in this snippet. Overall, it’s highly readable and maintainable.
Run 3
The code is highly readable. It has a clear, single-purpose class with a well-written docstring that explains intent. The __init__ method is logical and flat, with no deep nesting. Each action is on its own line, and variables are descriptively named. Type hints improve clarity. The only minor issues are the slightly complex conditional line for setting self.request from response.request, and the use of the vague 'ambiguous exception' in the docstring, but both are acceptable. Overall, structure, length, and flow are excellent.
Run 1
Code Structure: Imports, class documentation, attribute annotations, and initialization are logically organized. Nesting: Only one shallow conditional keeps complexity low. Clarity of intent: Descriptive names, type annotations, and the initializer docstring clearly explain how request and response context are attached; however, the class docstring is vague, several imports are unused, and referenced types are not defined or imported in the snippet. Code length: Compact and appropriately sized, with little unnecessary code. Action granularity: Each statement performs one clear action, although the conditional combines three checks. Reading flow: Initialization proceeds naturally from extracting the response to assigning the request, deriving it when needed, and initializing the superclass. Additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: Imports, class documentation, annotations, and initialization are logically organized. Nesting: A single conditional keeps the code nearly flat. Clarity of intent: Descriptive names, type annotations, and the initializer docstring clearly explain how request and response context is attached; the class docstring is somewhat vague, and referenced types are not defined or imported in the snippet. Code length: Compact, with little unnecessary code, though several imports are unused here. Action granularity: Each statement performs one clear action. Reading flow: Initialization proceeds naturally from extracting response data to assigning attributes, inferring a request, and initializing the parent exception. The compound conditional requires slightly more attention but remains readable.
Run 3
Code Structure: Imports, class documentation, attributes, and initialization are logically organized, though several imports are unused in this snippet. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive names, type annotations, and the initializer docstring clearly explain request/response handling; the class docstring is somewhat vague, and referenced types are not defined or imported here. Code length: Compact without unnecessary implementation detail. Action granularity: Each statement performs one clear action; the compound condition is understandable. Reading flow: Initialization proceeds naturally from extracting the response to assigning attributes, inferring the request, and calling the parent initializer. Minor spacing improvements around imports and the class would enhance readability.