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, *arg: Any, **kwa: Any) -> None:
"""Initialize RequestException with `request` and `response` objects."""
res: Response | None = kwa.pop("response", None)
self.response = res
self.request = kwa.pop("request", None)
if res is not None and not self.request and hasattr(res, "request"):
self.request = res.request
super().__init__(*arg, **kwa)
Run 1
The code is well-structured and readable. It has a clear class definition with a focused purpose. Nesting is minimal, with only one conditional block. Intent is explicit through the docstrings and type hints. Code length is concise and appropriate, avoiding unnecessary verbosity. Each line performs a single clear action, particularly evident in the __init__ method's step-by-step processing. The reading flow is natural—arguments are extracted, the response/request relationship is established, and then the parent initializer is called. Type hints and the use of kwa.pop('response', None) and kwa.pop('request', None) make the data flow transparent. Minor deductions could come from slightly dense conditional on the request/response relationship and reliance on an undefined Response/Request type at the global scope (assuming they are imported elsewhere via TYPE_CHECKING), but this doesn't significantly hinder comprehension. Overall, this is clean, maintainable code.
Run 2
The code demonstrates solid readability through clear structure and intent. The class is logically organized with relevant type hints and succinct documentation. Nesting is minimal, with only one conditional during initialization. Action granularity is good, with mostly one action per line. The reading flow is natural, moving from attribute declarations to initialization logic. The conditional line `if res is not None and not self.request and hasattr(res, 'request')` is slightly long but still readable. The `response` and `request` attributes use modern Python 3.10+ union type syntax without importing Optional, which is clear if the project supports it. The import of JSONDecodeError as CompatJSONDecodeError is not used in this snippet, which slightly violates conciseness and clarity, as unused imports can confuse readers. Overall, the code is concise and well-designed.
Run 3
The code is generally readable with a clear class definition and sensible docstrings. It has a flat structure with minimal nesting, and each action is on its own line. Type hints improve clarity. However, it loses points for vague parameter names (*arg, **kwa) and slightly cryptic logic around populating the request from the response. The conditional checking for request and response is compact but could be clearer with an intermediate variable. Overall, the code is concise and well-organized, but the ambiguous naming and condensed conditional slightly reduce readability.
Run 1
Code Structure: Imports, class documentation, attribute annotations, and initialization are logically organized, though TYPE_CHECKING and exception aliases are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The constructor clearly captures request and response objects and derives the request from the response when needed; abbreviated names such as arg, kwa, and res slightly reduce clarity. Code length: Compact without unnecessary implementation detail. Action granularity: Each statement performs one primary action. Reading flow: Initialization progresses naturally from extracting arguments to setting attributes, applying a fallback, and initializing the superclass. Minor weaknesses include the vague class docstring, limited spacing around top-level definitions, and type names whose definitions or imports are not shown.
Run 2
Code Structure: Imports, class documentation, annotations, and initialization are logically organized, though several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The initializer clearly associates request and response objects with an exception, but abbreviated names such as arg, kwa, and res reduce clarity; the class docstring is also vague. Code length: Compact and appropriately sized, with little unnecessary code. Action granularity: Each line performs one primary action, making assignments and initialization easy to follow. Reading flow: The sequence from extracting the response to deriving the request and initializing the superclass is natural. Additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: Imports, class documentation, type annotations, and initialization are logically organized, though several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The initializer clearly stores request and response objects and derives a request from the response when needed. However, abbreviated names such as arg, kwa, and res reduce clarity, and the class docstring is vague. Code length: The implementation is concise without unnecessary complexity. Action granularity: Each line performs one primary action, making state changes easy to follow. Reading flow: Initialization proceeds naturally from extracting the response to assigning the request, applying a fallback, and initializing the superclass. Additional spacing between imports and the class would improve visual separation.