|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /lib/python2.7/site-packages/werkzeug/ |
Upload File : |
�
./�_c @ s| d Z d d l Z d d l Z d d l m Z d d l m Z d d l m Z d d l m Z d d l
m
Z
d d l m Z d d
l m
Z
d d l m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m! Z! d d l" m# Z# d d l" m$ Z$ d d l" m% Z% d d l" m& Z& d d l" m' Z' d d! l" m( Z( d d" l) m* Z* d d# l+ m, Z, d d$ l- m. Z. d d% l- m/ Z/ y d d& l0 m1 Z2 Wn! e3 k
rud d& l4 m1 Z2 n Xy d d' l5 m6 Z6 Wn! e3 k
r�d d' l7 m6 Z6 n Xe8 d( d) e9 d* d+ � Z: e9 d* d, � Z; d- e< f d. � � YZ= d/ e< f d0 � � YZ> d1 e6 f d2 � � YZ? d3 � Z@ d4 e< f d5 � � YZA d6 eB f d7 � � YZC d8 e< f d9 � � YZD d: � ZE eF d; � ZG d S(< s�
werkzeug.test
~~~~~~~~~~~~~
This module implements a client to WSGI applications for testing.
:copyright: 2007 Pallets
:license: BSD-3-Clause
i����N( t BytesIO( t chain( t random( t
TemporaryFile( t timei ( t iteritems( t iterlists( t
itervalues( t make_literal_wrapper( t reraise( t string_types( t text_type( t to_bytes( t wsgi_encoding_dance( t _get_environ( t CallbackDict( t CombinedMultiDict( t EnvironHeaders( t
FileMultiDict( t Headers( t MultiDict( t dump_cookie( t dump_options_header( t parse_options_header( t
iri_to_uri( t
url_encode( t url_fix( t url_parse( t url_unparse( t url_unquote( t get_content_type( t BaseRequest( t ClosingIterator( t get_current_url( t Request( t CookieJari i� s utf-8c
s< | d k r% d t � t � f } n t � d t g � | rR � � f d � � n
� d j � � � f d � } t | t � s� t | � } n xdt | � D]V\ } } xG| D]?} | d | | f � t | d d � } | d k r�t | d t | d d � � } t | d d � }
|
d k rE| r<t
j | � d p?d
}
n | d k rb| d | � n
| d � | d
|
� xg | d � } | s�Pn � | � q}nA t | t � s�t
| � } n t | � � } | d � � | � | d � q� Wq� W| d | � t � d j � � } � d j d � � d | | f S( s� Encode a dict of values (either strings or file descriptors or
:class:`FileStorage` objects.) into a multipart encoded string stored
in a file descriptor.
s$ ---------------WerkzeugFormPart_%s%si c s� � \ } } } | r% | j | � n~ t | � } | � d � k rU | j | � n@ t d � } | j | j � � | j | � | � d <t � d <| | � d <d S( Ni s wb+i i ( t writet lenR t getvaluet True( t stringt streamt total_lengtht on_diskt lengtht
new_stream( t _closuret threshold( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt write_binaryI s
c s � | j � � � d S( N( t encode( R( ( t charsetR0 ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR$ \ s s/ --%s
Content-Disposition: form-data; name="%s"t readt filenamet namet content_types application/octet-streams ; filename="%s"
s
s Content-Type: %s
i @ s
s --%s--
N( t NoneR R R t FalseR$ t
isinstanceR R t getattrt mimetypest
guess_typeR
t strR t intt tellt seek(
t valuest use_tempfileR/ t boundaryR2 R$ t keyt valuet readerR4 R6 t chunkR, ( ( R. R2 R/ R0 s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt stream_encode_multipart< sN
c C s7 t | d t d | d | �\ } } } | | j � f S( s| Like `stream_encode_multipart` but returns a tuple in the form
(``boundary``, ``data``) where data is a bytestring.
RB RC R2 ( RH R8 R3 ( RA RC R2 R) R, ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt encode_multipart� s $t _TestCookieHeadersc B s, e Z d Z d � Z d � Z d d � Z RS( s$ A headers adapter for cookielib
c C s
| | _ d S( N( t headers( t selfRK ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt __init__� s c C sR g } | j � } x9 | j D]. \ } } | j � | k r | j | � q q W| S( N( t lowerRK t append( RL R5 RK t kt v( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt
getheaders� s c C sX g } x? | j D]4 \ } } | j � | j � k r | j | � q q W| pW | pW g S( N( RK RN RO ( RL R5 t defaultt rvRP RQ ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt get_all� s
N( t __name__t
__module__t __doc__RM RR R7 RU ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRJ � s t _TestCookieResponsec B s e Z d Z d � Z d � Z RS( s� Something that looks like a httplib.HTTPResponse, but is actually just an
adapter for our test responses to make them available for cookielib.
c C s t | � | _ d S( N( RJ RK ( RL RK ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRM � s c C s | j S( N( RK ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt info� s ( RV RW RX RM RZ ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRY � s t _TestCookieJarc B s e Z d Z d � Z d � Z RS( s� A cookielib.CookieJar modified to inject and read cookie headers from
and to wsgi environments, and wsgi application responses.
c C sY g | D] } d | j | j f ^ q } | rE d j | � | d <n | j d d � d S( sY Inject the cookies as client headers into the server's wsgi
environment.
s %s=%ss ; t HTTP_COOKIEN( R5 RE t joint popR7 ( RL t environt ct cvals( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt inject_wsgi� s )c C s& | j t | � t t | � � � d S( sX Extract the server's set-cookie headers as cookies into the
cookie jar.
N( t extract_cookiesRY t U2RequestR! ( RL R_ RK ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt extract_wsgi� s ( RV RW RX Rb Re ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR[ � s c c s� t | t � rK x� t | � D]( \ } } x | D] } | | f Vq/ Wq WnV xS t | � D]E \ } } t | t � r� x' | D] } | | f Vqz WqX | | f VqX Wd S( s� Iterates over a `dict` or :class:`MultiDict` yielding all keys and
values.
This is used to iterate over the data passed to the
:class:`EnvironBuilder`.
N( R9 R R R t list( t dataRD RA RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt
_iter_data� s
t EnvironBuilderc B s3 e Z d Z d Z d( Z e Z d d l Z e e j � Z
[ d d d d d d d d e e e d d d d d d d d � Z
e d
� � Z d � Z e d � � Z e d
� � Z e j d � � Z e d � � Z e j d � � Z e d � � Z e j d � � Z e d � � Z e d � � Z e j d � � Z d � Z d � Z e d � � Z e j d � � Z e d � � Z e j d � � Z e d � � Z e j d � � Z e d � � Z e j d � � Z e d � � Z e j d! � � Z e d" � � Z e d# � � Z! d$ � Z" d% � Z# d& � Z$ d d' � Z% RS() s� This class can be used to conveniently create a WSGI environment
for testing purposes. It can be used to quickly create WSGI environments
or request objects from arbitrary data.
The signature of this class is also used in some other places as of
Werkzeug 0.5 (:func:`create_environ`, :meth:`BaseResponse.from_values`,
:meth:`Client.open`). Because of this most of the functionality is
available through the constructor alone.
Files and regular form data can be manipulated independently of each
other with the :attr:`form` and :attr:`files` attributes, but are
passed with the same argument to the constructor: `data`.
`data` can be any of these values:
- a `str` or `bytes` object: The object is converted into an
:attr:`input_stream`, the :attr:`content_length` is set and you have to
provide a :attr:`content_type`.
- a `dict` or :class:`MultiDict`: The keys have to be strings. The values
have to be either any of the following objects, or a list of any of the
following objects:
- a :class:`file`-like object: These are converted into
:class:`FileStorage` objects automatically.
- a `tuple`: The :meth:`~FileMultiDict.add_file` method is called
with the key and the unpacked `tuple` items as positional
arguments.
- a `str`: The string is set as form data for the associated key.
- a file-like object: The object content is loaded in memory and then
handled like a regular `str` or a `bytes`.
:param path: the path of the request. In the WSGI environment this will
end up as `PATH_INFO`. If the `query_string` is not defined
and there is a question mark in the `path` everything after
it is used as query string.
:param base_url: the base URL is a URL that is used to extract the WSGI
URL scheme, host (server name + server port) and the
script root (`SCRIPT_NAME`).
:param query_string: an optional string or dict with URL parameters.
:param method: the HTTP method to use, defaults to `GET`.
:param input_stream: an optional input stream. Do not specify this and
`data`. As soon as an input stream is set you can't
modify :attr:`args` and :attr:`files` unless you
set the :attr:`input_stream` to `None` again.
:param content_type: The content type for the request. As of 0.5 you
don't have to provide this when specifying files
and form data via `data`.
:param content_length: The content length for the request. You don't
have to specify this when providing data via
`data`.
:param errors_stream: an optional error stream that is used for
`wsgi.errors`. Defaults to :data:`stderr`.
:param multithread: controls `wsgi.multithread`. Defaults to `False`.
:param multiprocess: controls `wsgi.multiprocess`. Defaults to `False`.
:param run_once: controls `wsgi.run_once`. Defaults to `False`.
:param headers: an optional list or :class:`Headers` object of headers.
:param data: a string or dict of form data or a file-object.
See explanation above.
:param json: An object to be serialized and assigned to ``data``.
Defaults the content type to ``"application/json"``.
Serialized with the function assigned to :attr:`json_dumps`.
:param environ_base: an optional dict of environment defaults.
:param environ_overrides: an optional dict of environment overrides.
:param charset: the charset used to encode unicode data.
.. versionadded:: 0.15
The ``json`` param and :meth:`json_dumps` method.
.. versionadded:: 0.15
The environ has keys ``REQUEST_URI`` and ``RAW_URI`` containing
the path before perecent-decoding. This is not part of the WSGI
PEP, but many WSGI servers include it.
.. versionchanged:: 0.6
``path`` and ``base_url`` can now be unicode strings that are
encoded with :func:`iri_to_uri`.
s HTTP/1.1i i i����Nt /t GETs utf-8c C sn t | � } | d k r9 | d � | k r9 t d � � n | d k rx | d � | k rx | j | d � d � \ } } n | | _ t | � | _ | d k r� t t | | � | � } n | | _ t | t
t f � r� | | _ n? | d k r� t
� } n t | t
� st
| � } n | | _ | | _ | d k rAt � } n t | t � s_t | � } n | | _ | d k r�| | _ n | d k r�t j } n | | _ | | _ |
| _ | | _ | | _ | | _ | | _ | | _ t | _ | d k r=|
d k rt d � � n | j | � }
| j d k r=d | _ q=n |
rR| d k r^t d � � n t! |
d � r||
j" � }
n t |
t � r�|
j# | j � }
n t |
t
� r�t$ |
� | _ | j d k rOt% |
� | _ qOqRxm t& |
� D]\ \ } } t | t' t( f � s t! | d � r2| j) | | � q�| j* j+ | � j, | � q�Wn | d k rj| | _- n d S( Nt ?s6 Query string is defined in the path and as an argumenti s can't provide both json and datas application/jsons# can't provide input stream and dataR3 (. R R7 t
ValueErrort splitR2 R t pathR t base_urlR9 t bytesR t query_stringR t argst methodR RK R6 t syst stderrt
errors_streamt multithreadt multiprocesst run_oncet environ_baset environ_overridest input_streamt content_lengthR8 t closedt TypeErrort
json_dumpst hasattrR3 R1 R R% Rh t tuplet dictt _add_file_from_datat formt setlistdefaultRO t mimetype( RL Ro Rp Rr Rt R} R6 R~ Rw Rx Ry Rz RK Rg R{ R| R2 R� t jsont path_sRD RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRM B sv ! $ c K s� t t | � � } i | d d 6| j | d | j d � | d � d 6| d d 6| d d
6| d d 6| j d
d � d 6| j d d � d 6| d d 6| d d 6| d d 6| d d 6| d 6} | j | � | | � S( s� Turn an environ dict back into a builder. Any extra kwargs
override the args extracted from the environ.
.. versionadded:: 0.15
t PATH_INFORo s wsgi.url_schemet Hostt SCRIPT_NAMERp t QUERY_STRINGRr t REQUEST_METHODRt s
wsgi.inputR} s Content-TypeR6 s Content-LengthR~ s wsgi.errorsRw s wsgi.multithreadRx s wsgi.multiprocessRy s
wsgi.run_onceRz RK N( R R t _make_base_urlR^ R7 t update( t clsR_ t kwargsRK t out( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt from_environ� s" !
c C s< t | t � r% | j j | | � n | j j | | � d S( s= Called in the EnvironBuilder to add files from the data dict.N( R9 R� t filest add_file( RL RD RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s c C s& t | | | d d f � j d � d S( Nt Rj ( R t rstrip( t schemet hostt script_root( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s c C s | j | j | j | j � S( s` The base URL is used to extract the URL scheme, host name,
port, and root path.
( R� t
url_schemeR� R� ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRp � s c C s | d k r! d } d } d } n6 t | � \ } } } } } | sH | rW t d � � n | j d � | _ | | _ | | _ d S( Nt httpt localhostR� s4 base url must not contain a query string or fragmentRj ( R7 R Rm R� R� R� R� ( RL RE R� t netlocR� t qst anchor( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRp � s c C sJ | j j d � } | d k rF | j rF | j r5 d S| j rB d Sd S| S( s� The content type for the request. Reflected from and to
the :attr:`headers`. Do not set if you set :attr:`files` or
:attr:`form` for auto detection.
s Content-Types multipart/form-datas! application/x-www-form-urlencodedN( RK t getR7 t
_input_streamt _filest _form( RL t ct( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR6 � s c C s3 | d k r" | j j d d � n
| | j d <d S( Ns Content-Type( R7 RK R^ ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR6 � s c C s* | j } | r& | j d � d j � Sd S( sY The mimetype (content type without charset etc.)
.. versionadded:: 0.14
t ;i N( R6 Rn t stripR7 ( RL R� ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s c C s t | | j � | _ d S( N( R R2 R6 ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s c s; � f d � } t � j j d d � � d } t | | � S( s� The mimetype parameters as dict. For example if the
content type is ``text/html; charset=utf-8`` the params would be
``{'charset': 'utf-8'}``.
.. versionadded:: 0.14
c s t � j | � � j d <d S( Ns Content-Type( R R� RK ( t d( RL ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt on_update s s content-typeR� i ( R RK R� R ( RL R� R� ( ( RL s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt mimetype_params� s c C s | j j d d t �S( s� The content length as integer. Reflected from and to the
:attr:`headers`. Do not set if you set :attr:`files` or
:attr:`form` for auto detection.
s Content-Lengtht type( RK R� R> ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR~ s c C s9 | d k r" | j j d d � n t | � | j d <d S( Ns Content-Length( R7 RK R^ R= ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR~ s c C sY | j d k r t d � � n t | | � } | d k rU | � } t | | | � n | S( s� Common behavior for getting the :attr:`form` and
:attr:`files` properties.
:param name: Name of the internal cached attribute.
:param storage: Storage class used for the data.
s an input stream is definedN( R} R7 t AttributeErrorR: t setattr( RL R5 t storageRT ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt _get_form s c C s d | _ t | | | � d S( s� Common behavior for setting the :attr:`form` and
:attr:`files` properties.
:param name: Name of the internal cached attribute.
:param value: Value to assign to the attribute.
N( R7 R� R� ( RL R5 RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt _set_form) s c C s | j d t � S( s$ A :class:`MultiDict` of form values.R� ( R� R ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� 3 s c C s | j d | � d S( NR� ( R� ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� 8 s c C s | j d t � S( sr A :class:`FileMultiDict` of uploaded files. Use
:meth:`~FileMultiDict.add_file` to add new files.
R� ( R� R ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� < s c C s | j d | � d S( NR� ( R� ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� C s c C s | j S( si An optional input stream. If you set this it will clear
:attr:`form` and :attr:`files`.
( R� ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR} G s c C s | | _ d | _ d | _ d S( N( R� R7 R� R� ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR} N s c C s? | j d k r8 | j d k r4 t | j d | j �Sd S| j S( si The query string. If you set this to a string
:attr:`args` will no longer be available.
R2 R� N( t
_query_stringR7 t _argsR R2 ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRr T s
c C s | | _ d | _ d S( N( R� R7 R� ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRr _ s c C sC | j d k r t d � � n | j d k r< t � | _ n | j S( s( The URL arguments as :class:`MultiDict`.s a query string is definedN( R� R7 R� R� R ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRs d s
c C s d | _ | | _ d S( N( R7 R� R� ( RL RE ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRs m s c C s | j j d d � d S( s4 The server name (read-only, use :attr:`host` to set)t :i i ( R� Rn ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt server_namer s c C s\ | j j d d � } t | � d k rE | d j � rE t | d � S| j d k rX d Sd S( s? The server port as integer (read-only, use :attr:`host` to set)R� i i t httpsi� iP ( R� Rn R% t isdigitR> R� ( RL t pieces( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt server_portw s "c C s& y | j � Wn t k
r! n Xd S( N( t closet Exception( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt __del__� s
c C sz | j r
d Sy t | j � } Wn t k
r9 d } n Xx0 | D]( } y | j � WqA t k
rh qA XqA Wt | _ d S( s� Closes all files. If you put real :class:`file` objects into the
:attr:`files` dict you can call this method to automatically close
them all in one go.
N( ( R R R� R� R� R� R' ( RL R� t f( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s
c s� � j } � j } � j } � j } | d! k rr | j � } | j d d � | j � } | j | � | | } n� | d k r� t � j � j g � } t
| d � j �\ } } } | d | } nW | d k rt � j d � j �} | j
d � } t | � } t | � } n t � } i } � j r>| j � j � n � f d � }
t � j � } | j i � j d 6|
� j � d
6|
� j � d 6| d 6t � j � d
6t � j � d 6� j d 6t � j � d 6� j d 6� j d 6� j d 6� j d 6| d 6� j d 6� j d 6� j d 6� j! d 6� � j" j# � } | d! k rc| | d <| j$ d | � n | d! k r�t | � | d <| j$ d | � n x: | j% � D], \ }
} | | d |
j& � j' d d � <q�W� j( r�| j � j( � n | S(" s� Return the built environ.
.. versionchanged:: 0.15
The content type and length headers are set based on
input stream detection. Previously this only set the WSGI
keys.
i i s multipart/form-dataR2 s ; boundary="%s"s! application/x-www-form-urlencodedt asciic s t t | � j � � j � S( N( R
R R2 ( t x( RL ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt _path_encode� s R� R� R� R� t REQUEST_URIt RAW_URIt SERVER_NAMEt SERVER_PORTt HTTP_HOSTt SERVER_PROTOCOLs wsgi.versions wsgi.url_schemes
wsgi.inputs wsgi.errorss wsgi.multithreads wsgi.multiprocesss
wsgi.run_oncet CONTENT_TYPEs Content-Typet CONTENT_LENGTHs Content-Lengths HTTP_%st -t _N() R} R~ R� R6 R7 R? R@ R R� R� RH R2 R R1 R% R R{ R� R
Rr Rt R� Ro R� R= R� R� t server_protocolt wsgi_versionR� Rw Rx Ry Rz RK t copyt sett to_wsgi_listt uppert replaceR| ( RL R} R~ R� R6 t start_post end_posRA RC t resultR� R� RK RD RE ( ( RL s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt get_environ� sr
$ c C s( | d k r | j } n | | j � � S( s� Returns a request with the data. If the request class is not
specified :attr:`request_class` is used.
:param cls: The request wrapper to use.
N( R7 t
request_classR� ( RL R� ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt get_request� s ( i i (& RV RW RX R� R� R R� R� t staticmethodt dumpsR� R7 R8 RM t classmethodR� R� R� t propertyRp t setterR6 R� R� R~ R� R� R� R� R} Rr Rs R� R� R� R� R� R� ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRi � sn M F
Vt ClientRedirectErrorc B s e Z d Z RS( s If a redirect loop is detected when using follow_redirects=True with
the :cls:`Client`, then this exception is raised.
( RV RW RX ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s t Clientc
B s� e Z d Z d e e d � Z d d d d d d e d d d � Z d d d � Z e d � Z e d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z d � Z d � Z d � Z RS( s� This class allows you to send requests to a wrapped application.
The response wrapper can be a class or factory function that takes
three arguments: app_iter, status and headers. The default response
wrapper just returns a tuple.
Example::
class ClientResponse(BaseResponse):
...
client = Client(MyApplication(), response_wrapper=ClientResponse)
The use_cookies parameter indicates whether cookies should be stored and
sent for subsequent requests. This is True by default, but passing False
will disable this behaviour.
If you want to request some subdomain of your application you may set
`allow_subdomain_redirects` to `True` as if not no external redirects
are allowed.
.. versionadded:: 0.5
`use_cookies` is new in this version. Older versions did not provide
builtin cookie support.
.. versionadded:: 0.14
The `mimetype` parameter was added.
.. versionadded:: 0.15
The ``json`` parameter.
c C s= | | _ | | _ | r' t � | _ n d | _ | | _ d S( N( t applicationt response_wrapperR[ t
cookie_jarR7 t allow_subdomain_redirects( RL R� R� t use_cookiesR� ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyRM ! s R� Rj s utf-8c C s� | j d k s t d � � t | | | | | | | | | d |
� } t | d d | �}
d | f g } | j j |
| � d S( s� Sets a cookie in the client's cookie jar. The server name
is required and has to match the one that is also passed to
the open call.
s cookies disabledt samesiteRp s http://s
Set-CookieN( R� R7 t AssertionErrorR t create_environRe ( RL R� RD RE t max_aget expiresRo t domaint securet httponlyR� R2 t headerR_ RK ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt
set_cookie0 s c C s, | j | | d d d d d | d | �d S( s$ Deletes a cookie in the test client.R� i R� Ro R� N( R� ( RL R� RD Ro R� ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt
delete_cookieS s c C sg | j d k r" | j j | � n t | j | d | �} | j d k rc | j j | | d � n | S( s5 Runs the wrapped WSGI app with the given environment.t bufferedi N( R� R7 Rb t run_wsgi_appR� Re ( RL R_ R� RT ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� Y s c C s� t | � \ } } } } } t j | d | �}
| j d d � d j d � } |
j j d � } | d g k r� | |
_ | |
_ n | } | | k r� | t | � | k r� | j s� t d � � q� q� t d � � n | j d � }
|
j
j d � } |
t | � | k r(| t |
j
� |
_ n | |
_ d |
_
t | d j d d � d � } | d
d h k r�|
j d k r�d
|
_ n d |
_ d |
_ d |
_ |
j j d d � n | j } d | _ z | j |
d t d | �SWd | | _ Xd S( sn Perform a new request to the location given by the redirect
response to the previous request.
Rr R� i i t .R� s- Following subdomain redirects is not enabled.s. Following external redirects is not supported.Rj i3 i4 t HEADRk s Transfer-Encodingt as_tupleR� N( R Ri R� Rn R� R� R� R% R� t RuntimeErrorR� Ro R> R7 Rt R} R6 R~ RK R^ R� t openR' ( RL t responset new_locationR_ R� R� R� Ro R� R� t buildert
to_name_partst from_name_partst
path_partst
root_partst status_codet old_response_wrapper( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt resolve_redirectb s@ c O s | j d t � } | j d t � } | j d t � } d } | r� t | � d k r� t | d t � r{ | d j � } q� t | d t � r� | d } q� n | d k r� t | | � } z | j � } Wd | j � Xn | j | j
� d | �} g } x� t | d j d d � d � }
|
d d d d
d d h k sC| rGPn | sex | d D] } qXWn | d
d } | |
f }
|
| k r�t
d � � n | j |
� | j | | | d | �\ } } q� | j d k r�| j | � } n | r�| | f S| S( s� Takes the same arguments as the :class:`EnvironBuilder` class with
some additions: You can provide a :class:`EnvironBuilder` or a WSGI
environment as only argument instead of the :class:`EnvironBuilder`
arguments and two optional keyword arguments (`as_tuple`, `buffered`)
that change the type of the return value or the way the application is
executed.
.. versionchanged:: 0.5
If a dict is provided as file in the dict for the `data` parameter
the content type has to be called `content_type` now instead of
`mimetype`. This change was made for consistency with
:class:`werkzeug.FileWrapper`.
The `follow_redirects` parameter was added to :func:`open`.
Additional parameters:
:param as_tuple: Returns a tuple in the form ``(environ, result)``
:param buffered: Set this to True to buffer the application run.
This will automatically close the application for
you as well.
:param follow_redirects: Set this to True if the `Client` should
follow HTTP redirects.
R� R� t follow_redirectsi i Ni- i. i/ i1 i3 i4 i t locations
loop detected( R^ R8 R7 R% R9 Ri R� R� R� R� R� R> Rn R� RO R R� ( RL Rs R� R� R� R R_ R� R� t redirect_chainR� R� R� t new_redirect_entry( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � sH
c O s d | d <| j | | � S( s( Like open but method is enforced to GET.Rk Rt ( R� ( RL Rs t kw( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� � s
c O s d | d <| j | | � S( s* Like open but method is enforced to PATCH.t PATCHRt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt patch� s
c O s d | d <| j | | � S( s) Like open but method is enforced to POST.t POSTRt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt post� s
c O s d | d <| j | | � S( s) Like open but method is enforced to HEAD.R� Rt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt head� s
c O s d | d <| j | | � S( s( Like open but method is enforced to PUT.t PUTRt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt put� s
c O s d | d <| j | | � S( s+ Like open but method is enforced to DELETE.t DELETERt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt delete s
c O s d | d <| j | | � S( s, Like open but method is enforced to OPTIONS.t OPTIONSRt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt options s
c O s d | d <| j | | � S( s* Like open but method is enforced to TRACE.t TRACERt ( R� ( RL Rs R ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt trace s
c C s d | j j | j f S( Ns <%s %r>( t __class__RV R� ( RL ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt __repr__ s N( RV RW RX R7 R' R8 RM R� R� R� R R� R� R R R
R R R R R ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� s4 ? J c O s/ t | | � } z | j � SWd | j � Xd S( s� Create a new WSGI environ dict based on the values passed. The first
parameter should be the path of the request which defaults to '/'. The
second one can either be an absolute path (in that case the host is
localhost:80) or a full path to the request with scheme, netloc port and
the path to the script.
This accepts the same arguments as the :class:`EnvironBuilder`
constructor.
.. versionchanged:: 0.5
This function is now a thin wrapper over :class:`EnvironBuilder` which
was added in 0.5. The `headers`, `environ_base`, `environ_overrides`
and `charset` parameters were added.
N( Ri R� R� ( Rs R� R� ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� s c s t | � } g � g � d � � f d � } | | | � } t | d d � } t | � } | r� z t | � } Wd | d k r� | � n Xnj x% | D] } � j | � � r� Pq� q� W� r� t � | � } n | d k r� | | k r� t | | � } n | � d t � d � f S( s Return a tuple in the form (app_iter, status, headers) of the
application output. This works best if you pass it an application that
returns an iterator all the time.
Sometimes applications may use the `write()` callable returned
by the `start_response` function. This tries to resolve such edge
cases automatically. But if you don't get the expected output you
should set `buffered` to `True` which enforces buffering.
If passed an invalid WSGI application the behavior of this function is
undefined. Never pass non-conforming WSGI applications to this function.
:param app: the application to execute.
:param buffered: set to `True` to enforce buffering.
:return: tuple in the form ``(app_iter, status, headers)``
c s- | d k r t | � n | | g � (� j S( N( R7 R RO ( t statusRK t exc_info( t bufferR� ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt start_responseB s
R� Ni i ( R R7 R: t iterRf RO R R R ( t appR_ R� R t app_rvt
close_funct app_itert item( ( R R� s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyR� - s*
(H RX R; Ru t ioR t itertoolsR R t tempfileR R t _compatR R R R R R
R R R
t _internalR t datastructuresR R R R R R R� R R R t urlsR R R R R R t utilsR t wrappersR t wsgiR R! t urllib.requestR" Rd t ImportErrort urllib2t http.cookiejarR# t cookielibR' R7 RH RI t objectRJ RY R[ Rh Ri R� R� R� R� R8 R� ( ( ( s1 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/test.pyt <module>
st
K
� � �