U
|
Þ=®da ã @ s$ d dl mZ d dlZd dlZd dlZd dlmZ ddlm Z ddl
|
m Z ddl
|
m Z ddl
|
m Z dd l
|
mZ dd
|
l
|
mZ dd l
|
mZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z ej rd dl!m"Z" d dl!m#Z# G dd deZdS )é )Ú annotationsN)ÚBytesIOé )Ú_wsgi_decoding_dance)ÚCombinedMultiDict)ÚEnvironHeaders)Ú FileStorage)ÚImmutableMultiDict)Úiter_multi_items)Ú MultiDict)Ú
|
BadRequest)ÚUnsupportedMediaType©Údefault_stream_factory)ÚFormDataParser)ÚRequest)Úcached_property)Úenviron_property)Ú _get_server)Úget_input_stream)ÚWSGIApplication)ÚWSGIEnvironmentc s¶ e Zd ZU dZdZded< dZded< dZeZ ded< d ed
|
< d ed < dfd d d dd fdd Z
|
e ddd dddZ e dddddZ dgdd d dd d d d Zed d!d"d#Zd$d!d%d&Zdd!d'd(Zd d!d)d*Zdd!d+d,Zd d!d-d.Zdd!d/d0Zed d!d1d2Zeeje d3d4d5Z ed6d!d7d8Z ej dhd d9d d6d:d;d<Z ej did d>d d?d:d@d<Z djd d d dAd:dBd<Z edCd!dDdEZ!edFd!dGdHZ"edId!dJdKZ#ed?d!dLdMZ$ed?d!dNdOZ%ee& dPdQd5Z'ee( dRdSd5Z)ee( dTdUd5Z*ee( dVdWd5Z+e,Z-edXd!dYdZZ,e.e.fZ/d[ed\< ej dkd d9d dd]d^d_Z0ej dld d d dXd]d`d_Z0dmd d d dXd]dad_Z0dbddcdddeZ1 Z2S )nr aí Represents an incoming WSGI HTTP request, with headers and body
|
taken from the WSGI environment. Has properties and methods for
|
using the functionality defined by various HTTP specs. The data in
|
requests object is read-only.
|
|
Text data is assumed to use UTF-8 encoding, which should be true for
|
the vast majority of modern clients. Using an encoding set by the
|
client is unsafe in Python due to extra encodings it provides, such
|
as ``zip``. To change the assumed encoding, subclass and replace
|
:attr:`charset`.
|
|
:param environ: The WSGI environ is generated by the WSGI server and
|
contains information about the server configuration and client
|
request.
|
:param populate_request: Add this request object to the WSGI environ
|
as ``environ['werkzeug.request']``. Can be useful when
|
debugging.
|
:param shallow: Makes reading from :attr:`stream` (and any method
|
that would read from it) raise a :exc:`RuntimeError`. Useful to
|
prevent consuming the form data in middleware, which would make
|
it unavailable to the final application.
|
|
.. versionchanged:: 2.1
|
Old ``BaseRequest`` and mixin classes were removed.
|
|
.. versionchanged:: 2.1
|
Remove the ``disable_data_descriptor`` attribute.
|
|
.. versionchanged:: 2.0
|
Combine ``BaseRequest`` and mixins into a single ``Request``
|
class.
|
|
.. versionchanged:: 0.5
|
Read-only mode is enforced with immutable classes for all data.
|
Nz
|
int | NoneÚmax_content_lengthÚmax_form_memory_sizeiè ztype[FormDataParser]Úform_data_parser_classr ÚenvironÚboolÚshallowTFÚNone)r Úpopulate_requestr Úreturnc s t j| dd¡| dd¡t|t| d¡p.dt| d¡p>d| dd¡ d ¡t|| d
|
¡d || _|| _|r|s| | jd < d S ) NÚREQUEST_METHODÚGETzwsgi.url_schemeÚhttpZ SCRIPT_NAMEÚ Z PATH_INFOÚ QUERY_STRINGÚlatin1Z REMOTE_ADDR)ÚmethodÚschemeÚserverÚ root_pathÚpathZ query_stringÚheadersZ remote_addrzwerkzeug.request) ÚsuperÚ__init__Úgetr r Úencoder r r )Úselfr r r ©Ú __class__© úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/wrappers/request.pyr. i s
|
|
ø
|
zRequest.__init__zt.Any)ÚargsÚkwargsr c O sR ddl m} | dt| jts$| jnd¡ |||}z| | ¡W ¢S | ¡ X dS )a Create a new request object based on the values provided. If
|
environ is given missing values are filled from there. This method is
|
useful for small scripts when you need to simulate a request from an URL.
|
Do not use this method for unittesting, there is a full featured client
|
object (:class:`Client`) that allows to create multipart requests,
|
support for cookies etc.
|
|
This accepts the same options as the
|
:class:`~werkzeug.test.EnvironBuilder`.
|
|
.. versionchanged:: 0.5
|
This method now accepts the same arguments as
|
:class:`~werkzeug.test.EnvironBuilder`. Because of this the
|
`environ` parameter is now called `environ_overrides`.
|
|
:return: request object
|
r )ÚEnvironBuilderÚcharsetN)Útestr8 Ú
|
setdefaultÚ
|
isinstancer9 ÚpropertyÚcloseÚ get_request)Úclsr6 r7 r8 Zbuilderr4 r4 r5 Ú from_values s ÿ
|
zRequest.from_valuesz&t.Callable[[Request], WSGIApplication]r )Úfr c s2 ddl m t ¡ fdd}t d|¡S )am Decorate a function as responder that accepts the request as
|
the last argument. This works like the :func:`responder`
|
decorator but the function is passed the request object as the
|
last argument and the request object will be closed
|
automatically::
|
|
@Request.application
|
def my_wsgi_app(request):
|
return Response('Hello World!')
|
|
As of Werkzeug 0.14 HTTP exceptions are automatically caught and
|
converted to responses instead of failing.
|
|
:param f: the WSGI callable to decorate
|
:return: a new WSGI callable
|
r )Ú HTTPExceptionc s | d }|j z| d d
|f }W n0 k
|
r\ } z| | d ¡}W 5 d }~X Y nX || dd
W 5 Q R £ S Q R X d S )Néþÿÿÿ)Z get_response)r6 ÚrequestÚrespÚe©rC r@ rB r4 r5 Ú application· s z(Request.application.<locals>.applicationr )Ú
|
exceptionsrC Ú functoolsÚwrapsÚtÚcast)r@ rB rI r4 rH r5 rI s zRequest.applicationz
|
str | Nonez t.IO[bytes])Útotal_content_lengthÚ content_typeÚfilenameÚcontent_lengthr c C s t ||||dS )aà Called to get a stream for the file upload.
|
|
This must provide a file-like class with `read()`, `readline()`
|
and `seek()` methods that is both writeable and readable.
|
|
The default implementation returns a temporary file if the total
|
content length is higher than 500KB. Because many browsers do not
|
provide a content length for the files only the total content
|
length matters.
|
|
:param total_content_length: the total content length of all the
|
data in the request combined. This value
|
is guaranteed to be there.
|
:param content_type: the mimetype of the uploaded file.
|
:param filename: the filename of the uploaded file. May be `None`.
|
:param content_length: the length of this file. This value is usually
|
not provided because webbrowsers do not provide
|
this value.
|
)rO rQ rP rR r )r1 rO rP rQ rR r4 r4 r5 Ú_get_file_streamà s üzRequest._get_file_stream)r c C s t | j d¡S )z``True`` if the request method carries content. By default
|
this is true if a ``Content-Type`` is sent.
|
|
.. versionadded:: 0.8
|
Ú CONTENT_TYPE)r r r/ ©r1 r4 r4 r5 Úwant_form_data_parsedä s z Request.want_form_data_parsedr c C sJ | j dkr| j nd}| jdkr$| jnd}| j| j||| j| j| j| jdS )zCreates the form data parser. Instantiates the
|
:attr:`form_data_parser_class` with some parameters.
|
|
.. versionadded:: 0.8
|
zutf-8NÚreplace)Zstream_factoryr9 Úerrorsr r Úmax_form_partsr@ )Ú_charsetÚ_encoding_errorsr rS r r rY Úparameter_storage_class)r1 r9 rX r4 r4 r5 Úmake_form_data_parserí s ùz Request.make_form_data_parserc C sl d| j krdS | jr8| ¡ }| | ¡ | j| j| j¡}n| j| ¡ | ¡ f}| j }|\|d< |d< |d< dS )au Method used internally to retrieve submitted data. After calling
|
this sets `form` and `files` on the request object to multi dicts
|
filled with the incoming form data. As a matter of fact the input
|
stream will be empty afterwards. You can also call this method to
|
force the parsing of the form data.
|
|
.. versionadded:: 0.8
|
ÚformNÚstreamÚfiles)
|
Ú__dict__rV r] ÚparseÚ_get_stream_for_parsingÚmimetyperR Zmimetype_paramsr_ r\ )r1 ÚparserÚdataÚdr4 r4 r5 Ú_load_form_dataÿ s
|
|
üýzRequest._load_form_datac C s" t | dd}|dk r t|S | jS )zïThis is the same as accessing :attr:`stream` with the difference
|
that if it finds cached data from calling :meth:`get_data` first it
|
will create a new stream out of the cached data.
|
|
.. versionadded:: 0.9.3
|
Ú _cached_dataN)Úgetattrr r_ )r1 Z cached_datar4 r4 r5 rc s z Request._get_stream_for_parsingc C s. | j d¡}t|pdD ]\}}| ¡ qdS )zñCloses associated resources of this request object. This
|
closes all file handles explicitly. You can also use the request
|
object in a with statement which will automatically close it.
|
|
.. versionadded:: 0.9
|
r` r4 N)ra r/ r
|
r> )r1 r` Ú_keyÚvaluer4 r4 r5 r> , s z Request.closec C s | S ©Nr4 rU r4 r4 r5 Ú __enter__7 s zRequest.__enter__c C s | ¡ d S rm )r> )r1 Úexc_typeÚ exc_valueÚtbr4 r4 r5 Ú__exit__: s zRequest.__exit__c C s | j rtdt| j| jdS )añ The WSGI input stream, with safety checks. This stream can only be consumed
|
once.
|
|
Use :meth:`get_data` to get the full data as bytes or text. The :attr:`data`
|
attribute will contain the full bytes only if they do not represent form data.
|
The :attr:`form` attribute will contain the parsed form data in that case.
|
|
Unlike :attr:`input_stream`, this stream guards against infinite streams or
|
reading past :attr:`content_length` or :attr:`max_content_length`.
|
|
If ``max_content_length`` is set, it can be enforced on streams if
|
``wsgi.input_terminated`` is set. Otherwise, an empty stream is returned.
|
|
If the limit is reached before the underlying stream is exhausted (such as a
|
file that is too large, or an infinite stream), the remaining contents of the
|
stream cannot be read safely. Depending on how the server handles this, clients
|
may show a "connection reset" failure instead of seeing the 413 response.
|
|
.. versionchanged:: 2.3
|
Check ``max_content_length`` preemptively and while reading.
|
|
.. versionchanged:: 0.9
|
The stream is always set (but may be consumed) even if form parsing was
|
accessed first.
|
zXThis request was created with 'shallow=True', reading from the input stream is disabled.)r )r Ú RuntimeErrorr r r rU r4 r4 r5 r_ = s ÿ ÿzRequest.streamz
|
wsgi.inputzÿThe raw WSGI input stream, without any safety checks.
|
|
This is dangerous to use. It does not guard against infinite streams or reading
|
past :attr:`content_length` or :attr:`max_content_length`.
|
|
Use :attr:`stream` instead.
|
)ÚdocÚbytesc C s | j ddS )z¾The raw data read from :attr:`stream`. Will be empty if the request
|
represents form data.
|
|
To get the raw data even if it represents form data, use :meth:`get_data`.
|
T)Úparse_form_data)Úget_datarU r4 r4 r5 rf m s z Request.datazt.Literal[False])ÚcacheÚas_textrv r c C s d S rm r4 ©r1 rx ry rv r4 r4 r5 rw v s zRequest.get_data.zt.Literal[True]Ústrc C s d S rm r4 rz r4 r4 r5 rw s z bytes | strc C sL t | dd}|dkr4|r | ¡ | j ¡ }|r4|| _|rH| | j| j¡}|S )aÐ This reads the buffered incoming data from the client into one
|
bytes object. By default this is cached but that behavior can be
|
changed by setting `cache` to `False`.
|
|
Usually it's a bad idea to call this method without checking the
|
content length first as a client could send dozens of megabytes or more
|
to cause memory problems on the server.
|
|
Note that if the form data was already parsed this method will not
|
return anything as form data parsing does not cache the data like
|
this method does. To implicitly invoke form data parsing function
|
set `parse_form_data` to `True`. When this is done the return value
|
of this method will be an empty string if the form parser handles
|
the data. This generally is not necessary as if the whole data is
|
cached (which is the default) the form parser will used the cached
|
data to parse the form data. Please be generally aware of checking
|
the content length first in any case before calling this method
|
to avoid exhausting server memory.
|
|
If `as_text` is set to `True` the return value will be a decoded
|
string.
|
|
.. versionadded:: 0.9
|
ri N)rj rh r_ Úreadri ÚdecoderZ r[ )r1 rx ry rv Úrvr4 r4 r5 rw s
|
z ImmutableMultiDict[str, str]c C s | ¡ | jS )aD The form parameters. By default an
|
:class:`~werkzeug.datastructures.ImmutableMultiDict`
|
is returned from this function. This can be changed by setting
|
:attr:`parameter_storage_class` to a different type. This might
|
be necessary if the order of the form data is important.
|
|
Please keep in mind that file uploads will not end up here, but instead
|
in the :attr:`files` attribute.
|
|
.. versionchanged:: 0.9
|
|
Previous to Werkzeug 0.9 this would only contain form data for POST
|
and PUT requests.
|
)rh r^ rU r4 r4 r5 r^ ® s z Request.formzCombinedMultiDict[str, str]c C sP | j g}| jdkr | | j¡ g }|D ] }t|ts<t|}| |¡ q&t|S )a A :class:`werkzeug.datastructures.CombinedMultiDict` that
|
combines :attr:`args` and :attr:`form`.
|
|
For GET requests, only ``args`` are present, not ``form``.
|
|
.. versionchanged:: 2.0
|
For GET requests, only ``args`` are present, not ``form``.
|
r" )r6 r' Úappendr^ r< r r )r1 Úsourcesr6 rg r4 r4 r5 ÚvaluesÁ s
|
|
|
zRequest.valuesz$ImmutableMultiDict[str, FileStorage]c C s | ¡ | jS )a» :class:`~werkzeug.datastructures.MultiDict` object containing
|
all uploaded files. Each key in :attr:`files` is the name from the
|
``<input type="file" name="">``. Each value in :attr:`files` is a
|
Werkzeug :class:`~werkzeug.datastructures.FileStorage` object.
|
|
It basically behaves like a standard file object you know from Python,
|
with the difference that it also has a
|
:meth:`~werkzeug.datastructures.FileStorage.save` function that can
|
store the file on the filesystem.
|
|
Note that :attr:`files` will only contain data if the request method was
|
POST, PUT or PATCH and the ``<form>`` that posted to the request had
|
``enctype="multipart/form-data"``. It will be empty otherwise.
|
|
See the :class:`~werkzeug.datastructures.MultiDict` /
|
:class:`~werkzeug.datastructures.FileStorage` documentation for
|
more details about the used data structure.
|
)rh r` rU r4 r4 r5 r` Þ s z Request.filesc C s | j S )zgAlias for :attr:`self.root_path`. ``environ["SCRIPT_ROOT"]``
|
without a trailing slash.
|
)r* rU r4 r4 r5 Ú script_rootõ s zRequest.script_rootc C s | j S )zAlias for :attr:`root_url`. The URL with scheme, host, and
|
root path. For example, ``https://example.com/app/``.
|
)Zroot_urlrU r4 r4 r5 Úurl_rootü s zRequest.url_rootZ REMOTE_USERzIf the server supports user authentication, and the
|
script is protected, this attribute contains the username the
|
user has authenticated as.zwsgi.multithreadz[boolean that is `True` if the application is served by a
|
multithreaded WSGI server.zwsgi.multiprocesszlboolean that is `True` if the application is served by a
|
WSGI server that spawns multiple processes.z wsgi.run_oncezÜboolean that is `True` if the application will be
|
executed only once in a process lifetime. This is the case for
|
CGI for example, but it's not guaranteed that the execution only
|
happens one time.z t.Any | Nonec C s | ¡ S )aã The parsed JSON data if :attr:`mimetype` indicates JSON
|
(:mimetype:`application/json`, see :attr:`is_json`).
|
|
Calls :meth:`get_json` with default arguments.
|
|
If the request content type is not ``application/json``, this
|
will raise a 415 Unsupported Media Type error.
|
|
.. versionchanged:: 2.3
|
Raise a 415 error instead of 400.
|
|
.. versionchanged:: 2.1
|
Raise a 400 error if the content type is incorrect.
|
)Úget_jsonrU r4 r4 r5 Újson! s z Request.jsonztuple[t.Any, t.Any]Ú _cached_json)ÚforceÚsilentrx r c C s d S rm r4 ©r1 r r rx r4 r4 r5 r 7 s zRequest.get_jsonc C s d S rm r4 r r4 r4 r5 r = s c
|
|
C sÎ |r | j | tk r | j | S |s8| js8|s4| d¡S dS | j|d}z| j |¡}W nf tk
|
rº } zH|rd}|rª| j \}}||f| _ n"| |¡}|rª| j \}} || f| _ W 5 d}~X Y nX |rÊ||f| _ |S )a Parse :attr:`data` as JSON.
|
|
If the mimetype does not indicate JSON
|
(:mimetype:`application/json`, see :attr:`is_json`), or parsing
|
fails, :meth:`on_json_loading_failed` is called and
|
its return value is used as the return value. By default this
|
raises a 415 Unsupported Media Type resp.
|
|
:param force: Ignore the mimetype and always try to parse JSON.
|
:param silent: Silence mimetype and parsing errors, and
|
return ``None`` instead.
|
:param cache: Store the parsed JSON to return for subsequent
|
calls.
|
|
.. versionchanged:: 2.3
|
Raise a 415 error instead of 400.
|
|
.. versionchanged:: 2.1
|
Raise a 400 error if the content type is incorrect.
|
N)rx )r ÚEllipsisZis_jsonÚon_json_loading_failedrw Ú json_moduleÚloadsÚ
|
ValueError)
|
r1 r r rx rf r~ rG Z normal_rvÚ_Z silent_rvr4 r4 r5 r C s,
|
|
|
|
|
|
|
zValueError | None)rG r c C s" |dk rt d| tddS )aÒ Called if :meth:`get_json` fails and isn't silenced.
|
|
If this method returns a value, it is used as the return value
|
for :meth:`get_json`. The default implementation raises
|
:exc:`~werkzeug.exceptions.BadRequest`.
|
|
:param e: If parsing failed, this is the exception. It will be
|
``None`` if the content type wasn't ``application/json``.
|
|
.. versionchanged:: 2.3
|
Raise a 415 error instead of 400.
|
Nz Failed to decode JSON object: z^Did not attempt to load JSON data because the request Content-Type was not 'application/json'.)r r )r1 rG r4 r4 r5 r z s
|
ÿz Request.on_json_loading_failed)TF)NN)TFF)T.F)TFF)...)...)FFT)3Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r Ú__annotations__r rY r r r. Ú classmethodrA rI rS r= rV r] rh rc r> rn rr r r_ r rM ÚIOru Z input_streamrf Úoverloadrw r^ r r` r r r{ Z remote_userr Zis_multithreadZis_multiprocessZ is_run_oncer
r r r r r Ú __classcell__r4 r4 r2 r5 r s¸
|
+ ü ) û!! $ þ ü ü ÿ& þþþþ ÿ ÿ ÿ7r )$Ú
|
__future__r rK r
ÚtypingrM Úior Ú _internalr Zdatastructuresr r r r r
|
r rJ r r Z
|
formparserr r Zsansio.requestr Z_SansIORequestÚutilsr r Zwsgir r Ú TYPE_CHECKINGZ_typeshed.wsgir r r4 r4 r4 r5 Ú<module> s0
|
