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):
"""The response object that is used by default in Flask. Works like the
response object from Werkzeug but is set to have an HTML mimetype by
default. Quite often you don't have to create this object yourself because
:meth:`~flask.Flask.make_response` will take care of that for you.
If you want to replace the response object used you can subclass this and
set :attr:`~flask.Flask.response_class` to your subclass.
.. versionchanged:: 1.0
JSON support is added to the response, like the request. This is useful
when testing to get the test client response data as JSON.
.. versionchanged:: 1.0
Added :attr:`max_cookie_size`.
"""
default_mimetype: str | None = "text/html"
json_module = json
autocorrect_location_header = False
@property
def max_cookie_size(self) -> int: # type: ignore
"""Read-only view of the :data:`MAX_COOKIE_SIZE` config key.
See :attr:`~werkzeug.wrappers.Response.max_cookie_size` in
Werkzeug's docs.
"""
if current_app:
return current_app.config["MAX_COOKIE_SIZE"] # type: ignore[no-any-return]
# return Werkzeug's default when not in an app context
return super().max_cookie_size
Run 1
The code is highly readable, with clear and logical structure. It imports modules explicitly, defines a response class with a single-focused purpose, and keeps nesting flat. The docstring clearly communicates the class's role and version changes. The `max_cookie_size` property is concise, with a natural reading flow: it first checks the app context, then falls back to the parent class. Variable and method names are descriptive, and type hints are used effectively. The code avoids unnecessary complexity and multiple actions per line, making it easy to follow and maintain.
Run 2
The code is highly readable. The class structure is logical, with a clear docstring explaining purpose and changes. Nesting is minimal; the only conditional is flat and returns early. Intent is explicit through descriptive names and type hints. The code is concise without sacrificing clarity. Each line performs one logical action, and the reading flow is natural, from imports to class definition to property. The use of comments and version change notes enhances maintainability. Minor deductions for slightly verbose docstring and repeated version notes, but overall exemplary.
Run 3
The code is highly readable, demonstrating clear structure and intent. The class definition is logical, with a well-organized docstring explaining purpose and version changes, followed by clearly named class attributes. Nesting is minimal, with only a simple if-else in the property method. The action granularity is good—each line performs a coherent action, such as returning the config value or calling the superclass. Imports are cleanly organized and type hints improve clarity. The only minor readability drawback is the inline type-ignore comments, which slightly interrupt the reading flow and add visual noise, but they are commonly used in compatibility-sensitive code. Overall, the code is concise, purposeful, and easy to follow.
Run 1
Code Structure: Imports, class configuration, and the property are logically organized. Nesting: Only one shallow conditional, with an early return keeping the implementation flat. Clarity of intent: Descriptive names, type annotations, and documentation clearly explain the response defaults and configuration fallback. Code length: Executable code is concise; the extensive class docstring and version notes slightly interrupt quick scanning but provide useful context. Action granularity: Each statement performs one action, with no compressed or compound lines. Reading flow: The code progresses naturally from dependencies to defaults to behavior, and the fallback comment clarifies the final return. Minor limitations include minimal spacing between imports and the class definition, plus type-ignore annotations that introduce some visual noise.
Run 2
Code Structure: Imports, class documentation, default attributes, and the property are logically organized, though several imports appear unused in this snippet. Nesting: Minimal nesting and an early return keep the property easy to follow. Clarity of intent: Descriptive names, type annotations, docstrings, and the fallback comment clearly explain the response defaults and configuration lookup. Code length: Implementation is concise; the lengthy documentation and version history slightly outweigh the small amount of executable code. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: The progression from class purpose to defaults to conditional configuration access is natural. Minor formatting issues, including limited separation around imports and the class declaration, slightly reduce polish.
Run 3
Code Structure: The Response subclass logically groups defaults and a configuration-backed property, although several imports are unused in this snippet. Nesting: A single conditional and early return keep the implementation flat. Clarity of intent: Descriptive names, type annotations, docstrings, and the fallback comment clearly explain behavior; framework context is needed to understand current_app. Code length: Executable code is concise, though the lengthy class docstring and version-history notes outweigh the small implementation. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Imports, class documentation, defaults, and property implementation follow a natural order; additional spacing between import groups and the class would improve visual organization.