141fde1d8e
Following discussions for Flask we've decided to name blueprints based on how they are registered. This allows for two different blueprints to have the same self-name as long as they are registered in different nested positions. This helps users choose better blueprint names.
151 lines
5.1 KiB
Python
151 lines
5.1 KiB
Python
import typing as t
|
|
|
|
from werkzeug.exceptions import BadRequest
|
|
from werkzeug.utils import cached_property
|
|
from werkzeug.wrappers import Request as RequestBase
|
|
from werkzeug.wrappers import Response as ResponseBase
|
|
|
|
from . import json
|
|
from .globals import current_app
|
|
|
|
if t.TYPE_CHECKING:
|
|
import typing_extensions as te
|
|
from werkzeug.routing import Rule
|
|
|
|
|
|
class Request(RequestBase):
|
|
"""The request object used by default in Flask. Remembers the
|
|
matched endpoint and view arguments.
|
|
|
|
It is what ends up as :class:`~flask.request`. If you want to replace
|
|
the request object used you can subclass this and set
|
|
:attr:`~flask.Flask.request_class` to your subclass.
|
|
|
|
The request object is a :class:`~werkzeug.wrappers.Request` subclass and
|
|
provides all of the attributes Werkzeug defines plus a few Flask
|
|
specific ones.
|
|
"""
|
|
|
|
json_module = json
|
|
|
|
#: The internal URL rule that matched the request. This can be
|
|
#: useful to inspect which methods are allowed for the URL from
|
|
#: a before/after handler (``request.url_rule.methods``) etc.
|
|
#: Though if the request's method was invalid for the URL rule,
|
|
#: the valid list is available in ``routing_exception.valid_methods``
|
|
#: instead (an attribute of the Werkzeug exception
|
|
#: :exc:`~werkzeug.exceptions.MethodNotAllowed`)
|
|
#: because the request was never internally bound.
|
|
#:
|
|
#: .. versionadded:: 0.6
|
|
url_rule: t.Optional["Rule"] = None
|
|
|
|
#: A dict of view arguments that matched the request. If an exception
|
|
#: happened when matching, this will be ``None``.
|
|
view_args: t.Optional[t.Dict[str, t.Any]] = None
|
|
|
|
#: If matching the URL failed, this is the exception that will be
|
|
#: raised / was raised as part of the request handling. This is
|
|
#: usually a :exc:`~werkzeug.exceptions.NotFound` exception or
|
|
#: something similar.
|
|
routing_exception: t.Optional[Exception] = None
|
|
|
|
@property
|
|
def max_content_length(self) -> t.Optional[int]: # type: ignore
|
|
"""Read-only view of the ``MAX_CONTENT_LENGTH`` config key."""
|
|
if current_app:
|
|
return current_app.config["MAX_CONTENT_LENGTH"]
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def endpoint(self) -> t.Optional[str]:
|
|
"""The endpoint that matched the request. This in combination with
|
|
:attr:`view_args` can be used to reconstruct the same or a
|
|
modified URL. If an exception happened when matching, this will
|
|
be ``None``.
|
|
"""
|
|
if self.url_rule is not None:
|
|
return self.url_rule.endpoint
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def blueprint(self) -> t.Optional[str]:
|
|
"""The name of the current blueprint"""
|
|
if self.url_rule and "." in self.url_rule.endpoint:
|
|
return self.url_rule.endpoint.rsplit(".", 1)[0]
|
|
else:
|
|
return None
|
|
|
|
@cached_property
|
|
def blueprints(self) -> t.List[str]:
|
|
"""The names of the current blueprint upwards through parent
|
|
blueprints.
|
|
"""
|
|
if self.blueprint is None:
|
|
return []
|
|
|
|
bps: t.List[str] = [self.blueprint]
|
|
|
|
while "." in bps[-1]:
|
|
bps.append(bps[-1].rpartition(".")[0])
|
|
|
|
return bps
|
|
|
|
def _load_form_data(self) -> None:
|
|
RequestBase._load_form_data(self)
|
|
|
|
# In debug mode we're replacing the files multidict with an ad-hoc
|
|
# subclass that raises a different error for key errors.
|
|
if (
|
|
current_app
|
|
and current_app.debug
|
|
and self.mimetype != "multipart/form-data"
|
|
and not self.files
|
|
):
|
|
from .debughelpers import attach_enctype_error_multidict
|
|
|
|
attach_enctype_error_multidict(self)
|
|
|
|
def on_json_loading_failed(self, e: Exception) -> "te.NoReturn":
|
|
if current_app and current_app.debug:
|
|
raise BadRequest(f"Failed to decode JSON object: {e}")
|
|
|
|
raise BadRequest()
|
|
|
|
|
|
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 = "text/html"
|
|
|
|
json_module = json
|
|
|
|
@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"]
|
|
|
|
# return Werkzeug's default when not in an app context
|
|
return super().max_cookie_size
|