Source code
from __future__ import annotations
import typing as t
from werkzeug.exceptions import BadRequest
from werkzeug.exceptions import HTTPException
from werkzeug.wrappers import Request as RequestBase
from werkzeug.wrappers import Response as ResponseBase
from . import json
from .globals import current_app
from .helpers import _split_blueprint_path
class Response(ResponseBase):
default_mimetype: str | None = "text/html"
json_module = json
autocorrect_location_header = False
@property
def max_cookie_size(self) -> int:
if current_app:
return current_app.config["MAX_COOKIE_SIZE"]
return super().max_cookie_size
Run 1
The code is generally readable due to its simple class structure, type hints, and descriptive naming, but it suffers from inconsistent formatting and unnecessary blank lines. The inheritance from Werkzeug's Response is clear, and properties are logically ordered. However, the excessive vertical whitespace between the property definition and its body (three blank lines) disrupts reading flow, and the indentation of the return statements is inconsistent. The `json_module` and `autocorrect_location_header` attributes are understandable but lack immediate context. Overall, the structure is sound, but formatting inconsistencies and minor verbosity reduce clarity.
Run 2
The code is generally readable but has some issues. The imports and class definition are clear, though the blank spacing is inconsistent (extra blank lines after class declaration and before method). The docstring is missing, which hurts clarity of intent. The method has good flat structure with minimal nesting, but the conditional return could be clearer. Action granularity is good - one action per line. Naming is clear for max_cookie_size and the config key. The use of type hints and future annotations shows good practice. However, the inconsistent whitespace and lack of explanatory comments for the config value or the autocorrect_location_header flag reduce readability. Overall, it's comprehensible but could benefit from minor cleanup and documentation to reach higher readability.
Run 3
The code is generally readable and well-structured. It uses type hints, clear imports, and logical class organization. The nesting is minimal, action granularity is appropriate, and intent is mostly clear. However, there are minor issues: excessive blank lines disrupt reading flow, the `max_cookie_size` property logic could be clearer (e.g., a comment explaining the fallback), and the `if current_app:` check is somewhat implicit about what `current_app` being falsy means. These slightly reduce clarity and flow but do not significantly harm readability.
Run 1
Code Structure: The class is logically organized, with configuration attributes followed by a property, although several imports are unused. Nesting: A single conditional keeps nesting shallow. Clarity of intent: Descriptive names and type annotations make the cookie-size lookup and superclass fallback clear. Code length: The implementation is concise, but excessive blank lines and unused imports add clutter. Action granularity: Each statement performs one action, making individual operations easy to follow. Reading flow: The flow from class defaults to application configuration and then fallback is natural; inconsistent whitespace slightly disrupts visual readability.
Run 2
Code Structure: The Response subclass logically groups configuration attributes and a related property, but unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive names make the cookie-size configuration lookup and fallback clear, though the class-level settings lack context. Code length: The implementation is concise, but excessive blank lines and unnecessary imports reduce compactness. Action granularity: Each statement performs one clear action. Reading flow: The property naturally checks application configuration before falling back to the superclass, but inconsistent whitespace and spacing between imports and the class interrupt an otherwise straightforward flow.
Run 3
Code Structure: The imports, class attributes, and property are logically organized, though several imports appear unused. Nesting: A single conditional keeps the method shallow and easy to follow. Clarity of intent: Descriptive names make the response configuration and cookie-size override understandable, although the application-context check requires framework knowledge. Code length: The implementation is concise, but excessive blank lines and trailing whitespace add visual clutter. Action granularity: Each statement performs one action, with no compressed or compound operations. Reading flow: The property naturally checks application configuration before falling back to the superclass; inconsistent spacing slightly disrupts an otherwise straightforward flow.