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 well-structured with clear imports, a single class definition, and a concise property. Nesting is minimal (one conditional in a property). The intent is clear: this is a Flask response subclass with a default HTML mimetype and a config-aware max cookie size. Code length is appropriate and not unnecessarily long. Each action is separated logically, with one meaningful action per line. Reading flow is natural, from imports to class definition to the property. The only minor deductions are for the overly long docstring and the type-ignore comments, which slightly reduce readability. Overall, it is highly readable.
Run 2
The code is highly readable with clear structure and intent. It uses concise imports, a well-documented class, and follows Flask's idiomatic style. The single property method has minimal nesting and clear action granularity. Type hints improve clarity, and consistent spacing enhances flow. Minor deductions for the type: ignore comments and slight verbosity in the docstring, which could reduce scanning speed but add useful context.
Run 3
The code is highly readable, with clear structure, minimal nesting, and logical organization. The class definition is concise, with a well-documented purpose, and the method/property is straightforward. Imports are grouped and explicit, though slightly verbose. The conditional in `max_cookie_size` is flat and easy to follow. Action granularity is appropriate, with one logical action per line. Type annotations improve clarity. The only minor issue is the slightly scattered use of `# type: ignore` comments, but this is a small trade-off for compatibility. Overall, the code is clean, maintainable, and unambiguous.
Run 1
Code Structure: Imports, class documentation, defaults, and the property are logically organized. Nesting: Only one shallow conditional, with an early return keeping the fallback flat. Clarity of intent: Descriptive names, type annotations, docstrings, and the fallback comment clearly explain behavior; understanding current_app and inherited defaults requires some Flask/Werkzeug familiarity. Code length: Executable code is concise, although the extensive class docstring and version-history entries add reading overhead. Action granularity: Each statement performs a single action, with no compressed multi-operation lines. Reading flow: The progression from response defaults to configuration-dependent behavior is natural; slightly more spacing between import groups and the class would improve visual separation.
Run 2
Code Structure: The class is logically organized, with documentation, class attributes, and a focused property; several unused imports add clutter. Nesting: A single conditional keeps the implementation flat and easy to follow. Clarity of intent: Descriptive names, type annotations, and documentation clearly explain the response defaults and configuration fallback, though some behavior depends on inherited functionality and application context. Code length: The executable code is concise, but the lengthy docstring and historical notes outweigh the small implementation. Action granularity: Each statement performs one clear action, with no compressed or compound operations. Reading flow: The property reads naturally from checking the application context to returning the configured value or the superclass default. Additional spacing around the import groups and class declaration would improve visual organization.
Run 3
Code Structure: The response defaults and configuration-backed property are logically grouped in a small class, 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 the Flask-specific behavior. Code length: Executable code is concise; the lengthy documentation and version-history notes slightly outweigh the implementation. Action granularity: Each statement performs one clear action, without compressed multi-action lines. Reading flow: Imports, class documentation, defaults, and the property follow a natural order. Minor spacing issues around the import block and class declaration, plus type-ignore annotations, add small distractions.