Name	Size	Mode	Actions
datastructures.cpython-36.pyc	107748	0644	editdlrm
exceptions.cpython-36.pyc	30639	0644	editdlrm
filesystem.cpython-36.pyc	2025	0644	editdlrm
formparser.cpython-36.pyc	13814	0644	editdlrm
http.cpython-36.pyc	37905	0644	editdlrm
local.cpython-36.pyc	22691	0644	editdlrm
routing.cpython-36.pyc	72931	0644	editdlrm
security.cpython-36.pyc	8040	0644	editdlrm
serving.cpython-36.pyc	30478	0644	editdlrm
test.cpython-36.pyc	38961	0644	editdlrm
testapp.cpython-36.pyc	9549	0644	editdlrm
urls.cpython-36.pyc	36414	0644	editdlrm
useragents.cpython-36.pyc	7417	0644	editdlrm
user_agent.cpython-36.pyc	1720	0644	editdlrm
utils.cpython-36.pyc	32960	0644	editdlrm
wsgi.cpython-36.pyc	30102	0644	editdlrm
_internal.cpython-36.pyc	18268	0644	editdlrm
_reloader.cpython-36.pyc	11899	0644	editdlrm
__init__.cpython-36.pyc	310	0644	editdlrm

3 _TBg�~
�@shdd
lZdd
l
Z
dd
lZdd
lZdd
lZddlmZ
ddlmZ
ddlm Z
ddl mZ
ddlm Z
ddlmZ
dd lmZ
dd lmZ
ddlmZ
ddlmZ
d d�Zdd�ZGdd�d�ZGdd�dee�ZGdd�d�ZGdd�de�Zdd�ZGdd�de�Z Gdd�de�Z!Gdd �d ee!�Z"Gd!d"�d"e!�Z#Gd#d$�d$�Z$Gd%d&�d&e#�Z%d'd(�Z&d)d*�Z'Gd+d,�d,�Z(Gd-d.�d.�Z)Gd/d0�d0e)e(�Z*Gd1d2�d2ee#�Z+Gd3d4�d4e#�Z,Gd5d6�d6ee�Z-Gd7d8�d8ee#�Z.Gd9d:�d:ee%�Z/Gd;d<�dd?�Z3Gd@dA�dAe0�Z4ej1dB�
Z5dCdD�Z6GdEdF�dFe0�Z7GdGdH�dHe0�Z8dIdJ�Z9dKdL�Z:GdMdN�dNe e�Z;GdOdP�dPee;�ZGdUdV�dVe e�Z?GdWdX�dXe e�Z@GdYdZ�dZe�ZAGd[d\�d\e�ZBGd]d^�d^�ZCGd_d`�d`�ZDdadb�ZEGdcdd�dd�ZFGdedf�dfee�ZGdpdgdh�
ZHdqdidj�
ZIGdkdl�dle e�ZJGdmdn�dn�ZKddolmLZL
d
S)r�N)
� Collection)
� MutableSet)
�deepcopy)
�BytesIO)
�repeat)
�fspath�
)
� exceptions)
�_make_encode_wrapper)
�_missing)
�get_filesystem_encodingc

Cstt
|�
j�d
��
�
dS)Nz objects are immutable)� TypeError�type�__name__)
�self�r�;/tmp/pip-build-0s3hx122/Werkzeug/werkzeug/datastructures.py�is_immutables
rc
cs�t|t
�r|jd
d�
EdH
n^t|t�rrxR|j�D]:\}
}t|ttf�rbx"|D]}|
|fV
qNWq2|
|fV
q2Wn |EdH
dS)zyIterates over the items of a mapping yielding keys and values without dropping any from more complex structures. T)
�multiN)� isinstance� MultiDict�items�dict�tuple�list)�mapping�key�value�
vrrr�iter_multi_itemss





rc@s�eZ
dZd
ZdZdd�Zdd�Zdd�Zd d �Zdd�Z d d�Z dd�Zdd�Zdd�Z dd�Zd dd�
Zdd�Zd!dd�
ZdS)"�ImmutableListMixinzOMakes a :class:`list` immutable. .. versionadded:: 0.5 :private: Nc
Cs&|jdk r|jSt
t|�
�
}
|_|
S)
N)�_hash_cache�hashr)r�rvrrr�__hash__2s



zImmutableListMixin.__hash__cCst|�
t
|�
f
fS)
N)rr)r�protocolrrr� __reduce_ex__8s
z ImmutableListMixin.__reduce_ex__cCst|�

dS)
N)
r)rrrrr�__delitem__;s
zImmutableListMixin.__delitem__cCst|�

dS)
N)
r)r�otherrrr�__iadd__>s
zImmutableListMixin.__iadd__cCst|�

dS)
N)
r)rr(rrr�__imul__As
zImmutableListMixin.__imul__cCst|�

dS)
N)
r)rrrrrr�__setitem__Ds
zImmutableListMixin.__setitem__cCst|�

dS)
N)
r)r�itemrrr�appendGs
zImmutableListMixin.appendcCst|�

dS)
N)
r)rr,rrr�removeJs
zImmutableListMixin.removecCst|�

dS)
N)
r)r�iterablerrr�extendMs
zImmutableListMixin.extendcCst|�

dS)
N)
r)r�posrrrr�insertPs
zImmutableListMixin.insertrcCst|�

dS)
N)
r)r�indexrrr�popSs
zImmutableListMixin.popc

Cst|�

dS)
N)
r)
rrrr�reverseVs
zImmutableListMixin.reverseFcCst|�

dS)
N)
r)rrr5rrr�sortYs
zImmutableListMixin.sort�����)
r7)NF)r� __module__�__qualname__�__doc__r!r$r&r'r)r*r+r-r.r0r2r4r5r6rrrrr (s r c@seZ
dZd
Zdd�ZdS)� ImmutableListzJAn immutable :class:`list`. .. versionadded:: 0.5 :private: c

Cst|�
j
�d
tj|�
�d�S)N�
(�
))rrr�__repr__)
rrrrr>es
zImmutableList.__repr__N)rr8r9r:r>rrrrr;]sr;cs~eZ
dZd
ZdZed�f
dd� �
Zdd�Zdd�Zd d �Z ddd�
Z d d�Zddd�
Zdd�Z dd�Zdd�Zdd�Z�ZS)�ImmutableDictMixinzOMakes a :class:`dict` immutable. .. versionadded:: 0.5 :private: Ncs$t�j
|�
}|jt|
t|�
��

|S)
N)�super�__new__�__init__�zipr)�cls�keysr�instance)
� __class__rr�fromkeysss

zImmutableDictMixin.fromkeyscCst|�
t
|�
f
fS)
N)rr)rr%rrrr&ys
z ImmutableDictMixin.__reduce_ex__c


Cs|j�S)
N)
r)
rrrr�_iter_hashitems|s
z"ImmutableDictMixin._iter_hashitemsc
Cs*|jdk r|jSt
t|j��
�
}
|_|
S)
N)r!r"� frozensetrI)rr#rrrr$s



zImmutableDictMixin.__hash__cCst|�

dS)
N)
r)rr�defaultrrr� setdefault�s
zImmutableDictMixin.setdefaultc
Ost|�

dS)
N)
r)r�args�kwargsrrr�update�s
zImmutableDictMixin.updatecCst|�

dS)
N)
r)rrrKrrrr4�s
zImmutableDictMixin.popc

Cst|�

dS)
N)
r)
rrrr�popitem�s
zImmutableDictMixin.popitemcCst|�

dS)
N)
r)rrrrrrr+�s
zImmutableDictMixin.__setitem__cCst|�

dS)
N)
r)rrrrrr'�s
zImmutableDictMixin.__delitem__c

Cst|�

dS)
N)
r)
rrrr�clear�s
zImmutableDictMixin.clear)
N)
N)
N)rr8r9r:r!�classmethodrHr&rIr$rLrOr4rPr+r'rQ� __classcell__rr)
rGrr?is
  r?c@sJeZ
dZd
Zdd�Zdd�Zdd�Zdd �Zd d�Zdd �Z ddd�
Z dS)�ImmutableMultiDictMixinzTMakes a :class:`MultiDict` immutable. .. versionadded:: 0.5 :private: cCst|�
t
|jd
d�
�
f
fS)NT)
r)rrr)rr%rrrr&�s
z%ImmutableMultiDictMixin.__reduce_ex__c

Cs|jd
d�
S)NT)
r)
r)
rrrrrI�s
z'ImmutableMultiDictMixin._iter_hashitemscCst|�

dS)
N)
r)rrrrrr�add�s
zImmutableMultiDictMixin.addc

Cst|�

dS)
N)
r)
rrrr�popitemlist�s
z#ImmutableMultiDictMixin.popitemlistcCst|�

dS)
N)
r)rrrrr�poplist�s
zImmutableMultiDictMixin.poplistcCst|�

dS)
N)
r)rr�new_listrrr�setlist�s
zImmutableMultiDictMixin.setlistNcCst|�

dS)
N)
r)rr�default_listrrr�setlistdefault�s
z&ImmutableMultiDictMixin.setlistdefault)
N)rr8r9r:r&rIrUrVrWrYr[rrrrrT�srTc
s�f
d
d�}
�|
_|
S)Nc
s.tt
t|���|
|�
}|jdk r*|j|�

|S)
N)�getattrr@�UpdateDictMixin� on_update)rrM�kwr#)
�namerr�oncall�s

z_calls_update..oncall)
r)r`rar)
r`r� _calls_update�s

rbcs^eZ
dZd
ZdZd�f
dd� Zef
�f
dd� Zed�
Z ed�
Z ed �
Zed �
Zed�
Z �ZS) r]zbMakes dicts call `self.on_update` on modifications. .. versionadded:: 0.5 :private: Ncs2|
|k}t�j
|
|�}|r.|jdk r.|j|�

|S)
N)r@rLr^)rrrK�modifiedr#)
rGrrrL�s




zUpdateDictMixin.setdefaultcsH|
|k}|tkrt
�j|
�
}nt
�j|
|�}|rD|jdk rD|j|�

|S)
N)rr@r4r^)rrrKrcr#)
rGrrr4�s





zUpdateDictMixin.popr+r'rQrPrO)
N)rr8r9r:r^rLrr4rbr+r'rQrPrOrSrr)
rGrr]�s 



r]c@seZ
dZd
Zddd�
ZdS)�TypeConversionDictz�Works like a regular dict but the :meth:`get` method can perform type conversions. :class:`MultiDict` and :class:`CombinedMultiDict` are subclasses of this class and provide the same feature. .. versionadded:: 0.5 NcCsTy||
}Wntk r


|SX|d
k rPy||�
}Wnt
k rN


|}YnX|S)a�Return the default value if the requested data doesn't exist. If `type` is provided and is a callable it should convert the value, return it or raise a :exc:`ValueError` if that is not possible. In this case the function will return the default as if the value was not found: >>> d = TypeConversionDict(foo='42', bar='blub') >>> d.get('foo', type=int) 42 >>> d.get('bar', -1, type=int) -1 :param key: The key to be looked up. :param default: The default value to be returned if the key can't be looked up. If not further specified `None` is returned. :param type: A callable that is used to cast the value in the :class:`MultiDict`. If a :exc:`ValueError` is raised by this callable the default value is returned. N)�KeyError� ValueError)rrrKrr#rrr�get�s








zTypeConversionDict.get)NN)rr8r9r:rgrrrrrd�srdc@s eZ
dZd
Zdd�Zdd�ZdS)�ImmutableTypeConversionDictzpWorks like a :class:`TypeConversionDict` but does not support modifications. .. versionadded:: 0.5 c

Cst|�
S)
z�Return a shallow mutable copy of this object. Keep in mind that the standard library's :func:`copy` function is a no-op for this class like for any other python immutable type (eg: :class:`tuple`). )
rd)
rrrr�copy
sz ImmutableTypeConversionDict.copyc


Cs|S)
Nr)
rrrr�__copy__
s
z$ImmutableTypeConversionDict.__copy__N)rr8r9r:rirjrrrrrh
srhc@s�eZ
dZd
Zd9dd�
Zdd�Zdd�Zd d �Zdd�Zd d�Z dd�Z d:dd�
Zdd�Zd;dd�
Z dd$d%�
Zd?d'd(�
Zd)d*�Zef
d+d,�
Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�ZdS)@raA :class:`MultiDict` is a dictionary subclass customized to deal with multiple values for the same key which is for example used by the parsing functions in the wrappers. This is necessary because some HTML form elements pass multiple values for the same key. :class:`MultiDict` implements all standard dictionary methods. Internally, it saves all values for a key as a list, but the standard dict access methods will only return the first value for a key. If you want to gain access to the other values, too, you have to use the `list` methods as explained below. Basic Usage: >>> d = MultiDict([('a', 'b'), ('a', 'c')]) >>> d MultiDict([('a', 'b'), ('a', 'c')]) >>> d['a'] 'b' >>> d.getlist('a') ['b', 'c'] >>> 'a' in d True It behaves like a normal dict thus all dict functions will only return the first value when multiple values for one key are found. From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP exceptions. A :class:`MultiDict` can be constructed from an iterable of ``(key, value)`` tuples, a dict, a :class:`MultiDict` or from Werkzeug 0.2 onwards some keyword parameters. :param mapping: the initial value for the :class:`MultiDict`. Either a regular dict, an iterable of ``(key, value)`` tuples or `None`. NcCs�t|
t
�r&tj|d
d�|
j�D�
�
n�t|
t�r�i}xH|
j�D]<\}}t|ttf�rlt|�
dkrbq>t|�
}n|g
}|||<q>Wtj||�
n8i}x&|
p�fD]\}}|j |g�j |�

q�Wtj||�
dS)Nc
ss"|]\}
}|
|dd�fV
qdS)
Nr)�.0�
k�
lrrr� N
sz%MultiDict.__init__..r
)rrrrB�listsrrr�lenrLr-)rr�tmprrrrrrBL
s













zMultiDict.__init__c

Cst|j
��
S)
N)rro)
rrrr�__getstate__`
s
zMultiDict.__getstate__cCstj
|�

tj||
�
dS)
N)rrQrO)rrrrr�__setstate__c
s

zMultiDict.__setstate__c

Cs tj
|�
S)
N)r�__iter__)
rrrrrtg
szMultiDict.__iter__cCs6|
|kr(tj
||
�}t|�
d
kr(|d
Stj|
�
�
dS)z�Return the first data value for this key; raises KeyError if not found. :param key: The key to be looked up. :raise KeyError: if the key does not exist. r
N)r�__getitem__rpr �BadRequestKeyError)rr�lstrrrrum
s 



zMultiDict.__getitem__cCstj
||
|g
�
d
S)z�Like :meth:`add` but removes an existing key first. :param key: the key for the value. :param value: the value to set. N)rr+)rrrrrrr+{
szMultiDict.__setitem__cCstj
||
g�j|�

d
S)z�Adds a new value for the key. .. versionadded:: 0.6 :param key: the key for the value. :param value: the value to add. N)rrLr-)rrrrrrrU�
sz MultiDict.addcCstytj
||
�}Wntk r$


gSX|d
kr6t|�
Sg}x4|D],}y|j||�
�

Wq@tk rj


Yq@Xq@W|S)a]Return the list of items for a given key. If that key is not in the `MultiDict`, the return value will be an empty list. Just like `get`, `getlist` accepts a `type` parameter. All items will be converted with the callable defined there. :param key: The key to be looked up. :param type: A callable that is used to cast the value in the :class:`MultiDict`. If a :exc:`ValueError` is raised by this callable the value will be removed from the list. :return: a :class:`list` of all the values for the key. N)rrurerr-rf)rrrr#�resultr,rrr�getlist�
s











zMultiDict.getlistcCstj
||
t|�
�
d
S)aRemove the old values for a key and add new ones. Note that the list you pass the values in will be shallow-copied before it is inserted in the dictionary. >>> d = MultiDict() >>> d.setlist('foo', ['1', '2']) >>> d['foo'] '1' >>> d.getlist('foo') ['1', '2'] :param key: The key for which the values are set. :param new_list: An iterable with the new values for the key. Old values are removed first. N)rr+r)rrrXrrrrY�
szMultiDict.setlistcCs|
|kr|||
<n||
}|S)
aG
Returns the value for the key if it is in the dict, otherwise it returns `default` and sets that value for `key`. :param key: The key to be looked up. :param default: The default value to be returned if the key is not in the dict. If not further specified it's `None`. r)rrrKrrrrL�
s

zMultiDict.setdefaultcCs4|
|kr$t|pf�
}t
j||
|�
nt
j||
�}|S)
a�Like `setdefault` but sets multiple values. The list returned is not a copy, but the list that is actually used internally. This means that you can put new values into the dict by appending items to the list: >>> d = MultiDict({"foo": 1}) >>> d.setlistdefault("foo").extend([2, 3]) >>> d.getlist("foo") [1, 2, 3] :param key: The key to be looked up. :param default_list: An iterable of default values. It is either copied (in case it was a list) or converted into a list before returned. :return: a :class:`list` )rrr+ru)rrrZrrrr[�
s 


zMultiDict.setlistdefaultFccsHxBtj
|�
D]4\}}|
r2x&|D]}||fV
qWq||d
fV
qWdS)a
Return an iterator of ``(key, value)`` pairs. :param multi: If set to `True` the iterator returned will have a pair for each value of each key. Otherwise it will only contain pairs for the first value of each key. r
N)rr)rrr�valuesrrrrr�
s 


zMultiDict.itemsc
cs*x$tj
|�
D]\}
}|
t|�
fV
qWd
S)zuReturn a iterator of ``(key, values)`` pairs, where values is the list of all values associated with the key.N)rrr)rrrzrrrro�
s
zMultiDict.listsc
cs"xtj
|�
D]}
|
d
V
qWdS)zAReturns an iterator of the first value on every key's value list.r
N)rrz)rrzrrrrz�
s
zMultiDict.valuesc

Cs tj
|�
S)
a
Return an iterator of all values associated with a key. Zipping :meth:`keys` and this is the same as calling :meth:`lists`: >>> d = MultiDict({"foo": [1, 2, 3]}) >>> zip(d.keys(), d.listvalues()) == d.lists() True )rrz)
rrrr� listvalues�
szMultiDict.listvaluesc

Cs |j|�
S)
z%Return a shallow copy of this object.)
rG)
rrrrriszMultiDict.copycCs|jt
|jd
d�
|
��
S)z"Return a deep copy of this object.F)
�flat)rGr�to_dict)r�memorrrrszMultiDict.deepcopyTcCs|
rt|j
��
St|j��
S)
a�
Return the contents as regular dict. If `flat` is `True` the returned dict will only have the first item present, if `flat` is `False` all values will be returned as lists. :param flat: If set to `False` the dict returned will have lists with all the values in it. Otherwise it will only contain the first value for each key. :return: a :class:`dict` )rrro)rr|rrrr} s 

zMultiDict.to_dictcCs(x"t|
�
D]\}}t
j|||�
q Wd
S)a�
update() extends rather than replaces existing key lists: >>> a = MultiDict({'x': 1}) >>> b = MultiDict({'x': 2, 'y': 3}) >>> a.update(b) >>> a MultiDict([('y', 3), ('x', 1), ('x', 2)]) If the value list for a key in ``other_dict`` is empty, no new values will be added to the dict and the key will not be created: >>> x = {'empty_list': []} >>> y = MultiDict() >>> y.update(x) >>> y MultiDict([]) N)rrrU)rrrrrrrrOs
zMultiDict.updatecCs\y*tj
||
�}t|�
d
kr$tj|
�
�
|d
Stk rV


|tk rF|Stj|
�
d�YnXdS)a�
Pop the first item for a list on the dict. Afterwards the key is removed from the dict, so additional values are discarded: >>> d = MultiDict({"foo": [1, 2, 3]}) >>> d.pop("foo") 1 >>> "foo" in d False :param key: the key to pop. :param default: if provided the value to return if the key was not in the dictionary. r
N)rr4rpr rvrer)rrrKrwrrrr4-s




z MultiDict.popc
Csvy
}

ztj|
jd
�
d�WYdd}
~
XnXdS)z*Pop a ``(key, list)`` tuple from the dict.r
N)rrPrer rvrM)rrrrrrV^s


zMultiDict.popitemlistc


Cs|j�S)
N)
ri)
rrrrrjes
zMultiDict.__copy__cCs|j|
d
�
S)N)
r~)
r)rr~rrr�__deepcopy__hs
zMultiDict.__deepcopy__c

Cs"t|�
j
�d
t|jdd�
�
�d�S)Nr<T)
rr=)rrrr)
rrrrr>ks
zMultiDict.__repr__)
N)
N)
N)
N)
F)
N)
T)rr8r9r:rBrrrsrtrur+rUryrYrLr[rrorzr{rirr}rOrr4rPrWrVrjr�r>rrrrr#
s6'         rc@s$eZ
dZd
ZdZdd�Zdd �Zd S)�_omd_bucketa
Wraps values in the :class:`OrderedMultiDict`. This makes it possible to keep an order over multiple different keys. It requires a lot of extra memory and slows down access a lot, but makes it possible to access elements in O(1) and iterate in O(n). �prevrr�nextcCsF|
j|_
||_||_d|_|
jdkr*||
_|
jdk r<||
j_||
_dS)
N)�_last_bucketr�rrr�� _first_bucket)r�omdrrrrrrBxs







z_omd_bucket.__init__cCsH|jr|j
|j_
|j
r |j|j
_|
j|kr2|j
|
_|
j|krD|j|
_dS)
N)r�r�r�r�)rr�rrr�unlink�s







z_omd_bucket.unlinkN)r�rrr�)rr8r9r:� __slots__rBr�rrrrr�osr�c@s�eZ
dZd
Zd2dd�
Zdd�ZdZdd�Zd d �Zdd�Z d d�Z dd�Zdd�Zdd�Z dd�Zdd�Zd3dd�
Zdd�Zdd�Zd d!�Zd4d"d#�
Zd$d%�Zd5d&d'�
Zd(d)�Zd*d+�Zef
d,d-�
Zd.d/�Zd0d1�ZdS)6�OrderedMultiDictaNWorks like a regular :class:`MultiDict` but preserves the order of the fields. To convert the ordered multi dict into a list you can use the :meth:`items` method and pass it ``multi=True``. In general an :class:`OrderedMultiDict` is an order of magnitude slower than a :class:`MultiDict`. .. admonition:: note Due to a limitation in Python you cannot convert an ordered multi dict into a regular dict by using ``dict(multidict)``. Instead you have to use the :meth:`to_dict` method, otherwise the internal bucket objects are exposed. NcCs.tj
|�

d|_|_|
dk r*tj||
�
dS)
N)rrBr�r�r�rO)rrrrrrB�s



zOrderedMultiDict.__init__c Cs�t|
t
�stSt|
t�r�t|jd
d�
�
}t|
jd
d�
�
}y6x0|D](\}}t|�
\}}||ksd||kr@dSq@WWntk r�


dSXyt|�

Wntk r�


d
SXdSt|�
t|
�
kr�dSx&|j �D]\}} |
j |�
| kr�dSq�Wd
S)NT)
rF)rr�NotImplementedr��iterrr�� StopIterationrprory) rr(Ziter1Ziter2Zk1Zv1Zk2Zv2rrzrrr�__eq__�s.






















zOrderedMultiDict.__eq__cCst|�
t
|jd
d�
�
f
fS)NT)
r)rrr)rr%rrrr&�s
zOrderedMultiDict.__reduce_ex__c

Cst|j
d
d�
�
S)NT)
r)rr)
rrrrrr�s
zOrderedMultiDict.__getstate__cCs,tj
|�

x|
D]\}}|j||�
qWdS)
N)rrQrU)rrzrrrrrrs�s


zOrderedMultiDict.__setstate__cCs(|
|krtj
||
�d
jStj|
�
�
dS)Nr
)rrurr rv)rrrrrru�s


zOrderedMultiDict.__getitem__cCs|j|
�

|j
|
|�
dS)
N)rWrU)rrrrrrr+�s

zOrderedMultiDict.__setitem__cCs|j|
�

dS)
N)
r4)rrrrrr'�s
zOrderedMultiDict.__delitem__c

Csd
d�|j�D�
S)Nc
ss|]\}
}|
V
qdS)
Nr)rkrrrrrrn�sz(OrderedMultiDict.keys..)
r)
rrrrrE�s
zOrderedMultiDict.keysc

Cst|j
��
S)
N)r�rE)
rrrrrt�s
zOrderedMultiDict.__iter__c

Csd
d�|j�D�
S)Nc
ss|]\}
}|V
qdS)
Nr)rkrrrrrrn�sz*OrderedMultiDict.values..)
r)
rrrrrz�s
zOrderedMultiDict.valuesFccsp|j}|
r.x`|dk r*|j
|jfV
|j}qWn>t�}x6|dk rj|j
|krb|j|j
�

|j
|jfV
|j}q6WdS)
N)r�rrr��setrU)rr�ptr� returned_keysrrrr�s









zOrderedMultiDict.itemsc
csNt�}
|j
}x<|dk rH|j|
kr@|j|j|j�
fV
|
j|j�

|j}qWdS)
N)r�r�rryrUr�)rr�r�rrrro�s






zOrderedMultiDict.listsc
cs x|j�D]\}
}|V
q WdS)
N)
ro)r�_keyrzrrrr{�s

zOrderedMultiDict.listvaluescCs tj
||
g�jt||
|��

dS)
N)rrLr-r�)rrrrrrrU�s
zOrderedMultiDict.addcCs|ytj
||
�}Wntk r$


gSX|dkrsz,OrderedMultiDict.getlist..)rrurer-rrf)rrrr#rxr,rrrry�s












zOrderedMultiDict.getlistcCs(|j|
�

x|D]}|j
|
|�
qWdS)
N)rWrU)rrrXrrrrrY s


zOrderedMultiDict.setlistcCstd
�
�
dS)Nz5setlistdefault is unsupported for ordered multi dicts)
r )rrrZrrrr[s
zOrderedMultiDict.setlistdefaultcCs(x"t|
�
D]\}}t
j|||�
q WdS)
N)rr�rU)rrrrrrrrOs

zOrderedMultiDict.updatecCs4tj
||
f�}x|D]}|j|�

qWd
d�|D�
S)Nc
Ssg|] }
|
j�qSr)
r)rkr�rrrr�sz,OrderedMultiDict.poplist..)rr4r�)rr�buckets�bucketrrrrWs



zOrderedMultiDict.poplistcCs`ytj
||
�}Wn,tk r<


|tk r,|Stj|
�
d�YnXx|D]}|j|�

qDW|d
jS)Nr
)rr4rerr rvr�r)rrrKr�r�rrrr4s





zOrderedMultiDict.popc
Csnytj
|�
\}
}Wn4tk rF
}
ztj|jd
�
d�WYdd}~XnXx|D]}|j|�

qNW|
|d
jfS)Nr
)rrPrer rvrMr�r)rrr�rr�rrrrP-s



$
zOrderedMultiDict.popitemc
Csrytj
|�
\}
}Wn4tk rF
}
ztj|jd
�
d�WYdd}~XnXx|D]}|j|�

qNW|
dd�|D�
fS)Nr
c
Ssg|] }
|
j�qSr)
r)rkr�rrrr�Asz0OrderedMultiDict.popitemlist..)rrPrer rvrMr�)rrr�rr�rrrrV8s



$
zOrderedMultiDict.popitemlist)
N)
F)
N)
N)rr8r9r:rBr�r$r&rrrsrur+r'rErtrzrror{rUryrYr[rOrWrr4rPrVrrrrr��s2     r�cCstj
|d
d�|
j�D�
�S)Nc
Ssi|]\}
}||
jdd
��qS)�
_�
-)
�replace)rkrlrrrr� Fsz'_options_header_vkw..)�httpZdump_options_headerr)rr_rrr�_options_header_vkwDs

r�c

Cs*t|t
�r|jd
�
}t|t�s&t|�
}|S)Nzlatin-1)r�bytes�decode�str)
rrrr�_unicodify_header_valueJs




r�c@s0
eZ
dZd
ZdGdd�
ZdHdd�
Zdd �ZdZdId d�
ZdJdd �
Z dd�Z dKdd�
ZdLdd�
Zdd�Z dd�ZdMdd�
Zdd�Zdefdd�
Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Z d;d<�Z!d=d>�Z"d?d@�Z#dAdB�Z$dCdD�Z%dEdF�Z&dS)N�Headersa�An object that stores some headers. It has a dict-like interface, but is ordered, can store the same key multiple times, and iterating yields ``(key, value)`` pairs instead of only keys. This data structure is useful if you want a nicer way to handle WSGI headers which are stored as tuples in a list. From Werkzeug 0.3 onwards, the :exc:`KeyError` raised by this class is also a subclass of the :class:`~exceptions.BadRequest` HTTP exception and will render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP exceptions. Headers is mostly compatible with the Python :class:`wsgiref.headers.Headers` class, with the exception of `__getitem__`. :mod:`wsgiref` will return `None` for ``headers['missing']``, whereas :class:`Headers` will raise a :class:`KeyError`. To create a new :class:`Headers` object pass it a list or dict of headers which are used as default values. This does not reuse the list passed to the constructor for internal usage. :param defaults: The list of default values for the :class:`Headers`. .. versionchanged:: 0.9 This data structure now stores unicode values similar to how the multi dicts do it. The main difference is that bytes can be set as well which will automatically be latin1 decoded. .. versionchanged:: 0.9 The :meth:`linked` function was removed without replacement as it was an API that does not support the changes to the encoding model. NcCs8g|_|
dk r4t
|
ttf�r*|jj|
�

n |j|
�

dS)
N)�_listrrr�r0)r�defaultsrrrrBts



zHeaders.__init__FcCs�|s2t|
t
�r|j|
St|
t�r2|j|j|
�
St|
t�sFtj|
�
�
|
j�}x"|jD]\}}|j�|krV|SqVW|r|t ��
tj|
�
�
dS)
N) r�intr��slicerGr�r rv�lowerre)rr� _get_mode�ikeyrlrrrrru|s












zHeaders.__getitem__cCs4d
d�}|
j|jko2t
t||
j��
t
t||j��
kS)Nc

Ss|d
j�f
|dd�S)Nr
r)
r�)
r,rrr�lowered�s
zHeaders.__eq__..lowered)rGr��mapr�)rr(r�rrrr��s


zHeaders.__eq__cCsdy|j|
d
d�}Wnt
k r&


|SX|r6|jd�
}|dkrB|Sy||�
Stk r^


|SXdS)a�Return the default value if the requested data doesn't exist. If `type` is provided and is a callable it should convert the value, return it or raise a :exc:`ValueError` if that is not possible. In this case the function will return the default as if the value was not found: >>> d = Headers([('Content-Length', '42')]) >>> d.get('Content-Length', type=int) 42 .. versionadded:: 0.9 Added support for `as_bytes`. :param key: The key to be looked up. :param default: The default value to be returned if the key can't be looked up. If not further specified `None` is returned. :param type: A callable that is used to cast the value in the :class:`Headers`. If a :exc:`ValueError` is raised by this callable the default value is returned. :param as_bytes: return bytes instead of strings. T)
r��latin1N)rure�encoderf)rrrKr�as_bytesr#rrrrg�s










zHeaders.getcCsr|
j�}g}x`|D]X\}}|j�|kr|r4|j
d
�
}|dk r`y||�
}Wntk r^


wYnX|j|�

qW|S)a�Return the list of items for a given key. If that key is not in the :class:`Headers`, the return value will be an empty list. Just like :meth:`get`, :meth:`getlist` accepts a `type` parameter. All items will be converted with the callable defined there. .. versionadded:: 0.9 Added support for `as_bytes`. :param key: The key to be looked up. :param type: A callable that is used to cast the value in the :class:`Headers`. If a :exc:`ValueError` is raised by this callable the value will be removed from the list. :return: a :class:`list` of all the values for the key. :param as_bytes: return bytes instead of strings. r�N)r�r�rfr-)rrrr�r�rxrlrrrrry�s











zHeaders.getlistcCs |j|
�
S)
z�Return a list of all the values for the named field. This method is compatible with the :mod:`wsgiref` :meth:`~wsgiref.headers.Headers.get_all` method. )
ry)rr`rrr�get_all�szHeaders.get_allccs,x&|D]\}}|
r|j�}||fV
qWdS)
N)
r�)rr�rrrrrr�s



z Headers.itemsccs"x|j|
�
D]\}}|V
qWdS)
N)
r)rr�rr�rrrrE�s

zHeaders.keysc
cs x|j�D]\}
}|V
q WdS)
N)
r)rr�rrrrrz�s

zHeaders.valuesc
Osnt|
�
d
krt
dt|
�
���
�
|
rHx$t|
d�
D]\}}|j||�
q0Wx t|�
D]\}}|j||�
qRWdS)a�
Extend headers in this object with items from another object containing header items as well as keyword arguments. To replace existing keys instead of extending, use :meth:`update` instead. If provided, the first argument can be another :class:`Headers` object, a :class:`MultiDict`, :class:`dict`, or iterable of pairs. .. versionchanged:: 1.0 Support :class:`MultiDict`. Allow passing ``kwargs``. rz)update expected at most 1 arguments, got r
N)rpr rrU)rrMrNrrrrrr0�s



zHeaders.extendTcCsj|rt|
t
tf�r|j|
=dS|
j�}
g}x,|jD]"\}}|j�|
kr2|j||f�

q2W||jdd�<dS)
N)rr�r�r�r�r-)rr�_index_operation�newrlrrrrr' s








zHeaders.__delitem__cCs|j|
d
d�S)zBRemove a key. :param key: The key to be removed. F)
r�)
r')rrrrrr.szHeaders.removecCsf|
d
kr|jj
�St|
t�r(|jj
|
�
Sy||
}|j|
�

Wn"tk r`


|tk rZ|S�YnX|S)aQ
Removes and returns a key or index. :param key: The key to be popped. If this is an integer the item at that position is removed, if it's a string the value for that key is. If the key is omitted or `None` the last item is removed. :return: an item. N)r�r4rr�r.rer)rrrKr#rrrr4s 










zHeaders.popc


Cs|j�S)
z7Removes a key or index and returns a (key, value) item.)
r4)
rrrrrP1szHeaders.popitemcCs,y|j|
d
d�
Wnt
k r&


dSXd
S)zCheck if a key is present.T)
r�F)rure)rrrrr�__contains__5s 



zHeaders.__contains__cCstj
d
tdd�
|
|kS)z{ .. deprecated:: 2.0 Will be removed in Werkzeug 2.1. Use ``key in data`` instead. zW'has_key' is deprecated and will be removed in Werkzeug 2.1. Use 'key in data' instead.�)
� stacklevel)�warnings�warn�DeprecationWarning)rrrrr�has_key=s 

zHeaders.has_keyc

Cs t|j
�
S)
zYield ``(key, value)`` tuples.)r�r�)
rrrrrtKszHeaders.__iter__c

Cs t|j
�
S)
N)rpr�)
rrrr�__len__Os
zHeaders.__len__cKs<|rt||�}t
|
�
}
t
|�
}|j|�

|jj|
|f�

d
S)aAdd a new header tuple to the list. Keyword arguments can specify additional parameters for the header value, with underscores converted to dashes:: >>> d = Headers() >>> d.add('Content-Type', 'text/plain') >>> d.add('Content-Disposition', 'attachment', filename='foo.png') The keyword argument dumping uses :func:`dump_options_header` behind the scenes. .. versionadded:: 0.4.1 keyword arguments were added for :mod:`wsgiref` compatibility. N)r�r��_validate_valuer�r-)rr��_valuer_rrrrURs




zHeaders.addcCs.t|
t
�std
�
�
d|
ks"d|
kr*td�
�
dS)NzValue should be a string.�
�
zGDetected newline in header value. This is a potential security problem)rr�r rf)rrrrrr�is




zHeaders._validate_valuecKs|j|
|f|�

d
S)z�Add a new header tuple to the list. An alias for :meth:`add` for compatibility with the :mod:`wsgiref` :meth:`~wsgiref.headers.Headers.add_header` method. N)
rU)rr�r��_kwrrr� add_headerrszHeaders.add_headerc

Cs|jd
d
�=d
S)zClears all headers.N)
r�)
rrrrrQzsz Headers.clearcs�|rt||�}t
|
�
}
t
|�
}|j|�

|jsB|jj|
|f�

d
St|j�
}|
j��xHt|�
D](\}\}}|j��kr^|
|f|j|<Pq^W|jj|
|f�

d
S�f
dd�|D�
|j|dd
�<d
S)a0Remove all header tuples for `key` and add a new one. The newly added key either appears at the end of the list if there was no entry or replaces the first one. Keyword arguments can specify additional parameters for the header value, with underscores converted to dashes. See :meth:`add` for more information. .. versionchanged:: 0.6.1 :meth:`set` now accepts the same arguments as :meth:`add`. :param key: The key to be inserted. :param value: The value to be inserted. Nc
s g|]}
|
dj��kr|
�qS)
r
)
r�)rk�
t)
r�rrr��szHeaders.set..r)r�r�r�r�r-r�r�� enumerate)rr�r�r_�listiter�idxZold_keyZ _old_valuer)
r�rr�~s"













zHeaders.setcCsF|r8t|�
}|j
|
t|�
�
x$|D]}|j|
|�
q"Wn |j|
�

d
S)z�Remove any existing values for a header and add new ones. :param key: The header key to set. :param values: An iterable of values to set for the key. .. versionadded:: 1.0 N)r�r�r�rUr.)rrrzZvalues_iterrrrrrY�s


zHeaders.setlistcCs |
|kr||
S|j|
|�
|S)
a*
Return the first value for the key if it is in the headers, otherwise set the header to the value given by ``default`` and return that. :param key: The header key to get. :param default: The value to set for the key if it is not in the headers. )
r�)rrrKrrrrL�s 

zHeaders.setdefaultcCs|
|kr|j|
|�
|j
|
�
S)
a�
Return the list of values for the key if it is in the headers, otherwise set the header to the list of values given by ``default`` and return that. Unlike :meth:`MultiDict.setlistdefault`, modifying the returned list will not affect the headers. :param key: The header key to get. :param default: An iterable of values to set for the key if it is not in the headers. .. versionadded:: 1.0 )rYry)rrrKrrrr[�s
zHeaders.setlistdefaultcCs~t|
t
tf�rnt|
t�r|g
}d
d�|D�
}x|D]\}}|j|�

q2Wt|
t�rb|d|j|
<qz||j|
<n|j|
|�
dS)z=Like :meth:`set` but also supports index/slice based setting.c
Ss g|]\}
}t|
�
t|�
f�qSr)
r�)rkrlrrrrr��s
z'Headers.__setitem__..r
N)rr�r�r�r�r�)rrrr�rrrrr+�s





zHeaders.__setitem__c
Os
t|
�
d
krt
dt|
�
���
�
|
r�|
d}t|ttf�r^x�|j�D]}|j||j|�
�
qBWnht|t�r�x\|j �D]0\}}t|t tf�r�|j||�
qr|j||�
qrWnx|D]\}}|j||�
q�Wx<|j �D]0\}}t|t tf�r�|j||�
q�|j||�
q�WdS)a�
Replace headers in this object with items from another headers object and keyword arguments. To extend existing keys instead of replacing, use :meth:`extend` instead. If provided, the first argument can be another :class:`Headers` object, a :class:`MultiDict`, :class:`dict`, or iterable of pairs. .. versionadded:: 1.0 rz)update expected at most 1 arguments, got r
N) rpr rr�rrErYryrrrrr�)rrMrNrrrrrrrO�s$ 










zHeaders.updatec

Cst|�
S)
zRConvert the headers into a list suitable for WSGI. :return: list )
r)
rrrr�to_wsgi_listszHeaders.to_wsgi_listc

Cs|j|j
�
S)
N)rGr�)
rrrrris
zHeaders.copyc


Cs|j�S)
N)
ri)
rrrrrjs
zHeaders.__copy__c
CsBg}
x(|j�D]\}}|
j
|�d
|���

qW|
j
d�

dj|
�
S)z9Returns formatted headers suitable for HTTP transmission.z: z )r�r-�join)r�strsrrrrr�__str__s 



zHeaders.__str__c

Cst|�
j
�d
t|�
�d�S)Nr<r=)rrr)
rrrrr>!s
zHeaders.__repr__)
N)
F)NNF)NF)
F)
F)
T)'rr8r9r:rBrur�r$rgryr�rrErzr0r'r.rr4rPr�r�rtr�rUr�r�rQr�rYrLr[r+rOr�rirjr�r>rrrrr�RsF    $     #&r�c@s�eZ
dZd
Zdd�Zdd�Zdd�Zdd �Zd d�Zdd �Z dd�Z dd�Zdd�Zdd�Z defdd�
Zdd�Zdd�Zdd�ZdS)�ImmutableHeadersMixinz�Makes a :class:`Headers` immutable. We do not mark them as hashable though since the only usecase for this datastructure in Werkzeug is a view on a mutable structure. .. versionadded:: 0.5 :private: cKst|�

dS)
N)
r)rrrNrrrr'/s
z!ImmutableHeadersMixin.__delitem__cCst|�

dS)
N)
r)rrrrrrr+2s
z!ImmutableHeadersMixin.__setitem__cKst|�

dS)
N)
r)rr�r�r_rrrr�5s
zImmutableHeadersMixin.setcCst|�

dS)
N)
r)rrrzrrrrY8s
zImmutableHeadersMixin.setlistcKst|�

dS)
N)
r)rr�r�r_rrrrU;s
zImmutableHeadersMixin.addcKst|�

dS)
N)
r)rr�r�r�rrrr�>s
z ImmutableHeadersMixin.add_headercCst|�

dS)
N)
r)rrrrrr.As
zImmutableHeadersMixin.removec
Ost|�

dS)
N)
r)rrMrNrrrr0Ds
zImmutableHeadersMixin.extendc
Ost|�

dS)
N)
r)rrMrNrrrrOGs
zImmutableHeadersMixin.updatecCst|�

dS)
N)
r)rr1rrrrr2Js
zImmutableHeadersMixin.insertNcCst|�

dS)
N)
r)rrrKrrrr4Ms
zImmutableHeadersMixin.popc

Cst|�

dS)
N)
r)
rrrrrPPs
zImmutableHeadersMixin.popitemcCst|�

dS)
N)
r)rrrKrrrrLSs
z ImmutableHeadersMixin.setdefaultcCst|�

dS)
N)
r)rrrKrrrr[Vs
z$ImmutableHeadersMixin.setlistdefault)rr8r9r:r'r+r�rYrUr�r.r0rOr2rr4rPrLr[rrrrr�%sr�c@sFeZ
dZd
Zdd�Zdd�ZdZddd �
Zd d�Zdd �Z dd�Z dS)�EnvironHeadersa�
Read only version of the headers from a WSGI environment. This provides the same interface as `Headers` and is constructed from a WSGI environment. From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP exceptions. cCs |
|_dS)
N)
�environ)rr�rrrrBes
zEnvironHeaders.__init__cCs|j|
jkS)
N)
r�)rr(rrrr�hs
zEnvironHeaders.__eq__NFcCsLt|
t
�st|
�
�
|
j�jd
d�}
|
dkr8t|j|
�
St|jd|
���
S)Nr�r��CONTENT_TYPE�CONTENT_LENGTH�HTTP_)r�r�)rr�re�upperr�r�r�)rrr�rrrrums




zEnvironHeaders.__getitem__c

Cstt
t|�
�
�
S)
N)rprr�)
rrrrr�wszEnvironHeaders.__len__c
csxxr|jj
�D]d\}
}|
jd
�
rJ|
d krJ|
dd�jdd�j�t|�
fV
q|
d kr|r|
jdd�j�t|�
fV
qWdS)Nr��HTTP_CONTENT_TYPE�HTTP_CONTENT_LENGTH�r�r�r�r�)r�r�)r�r�)r�r� startswithr��titler�)rrrrrrrt|s





zEnvironHeaders.__iter__c

Cstd
t
|�
j�d��
�
dS)Nzcannot create z copies)r rr)
rrrrri�s
zEnvironHeaders.copy)
F)rr8r9r:rBr�r$rur�rtrirrrrr�Zs   r�c@s�eZ
dZd
Zdd�Zd+dd�
Zed,dd�
�
Zd d �Zd-dd�
Z d.d d�
Z dd�Zdd�Zdd�Z d/dd�
Zdd�Zdd�Zdd�Zdd�Zd0d!d"�
Zd#d$�Zd%d&�Zd'd(�Zd)d*�ZdS)1�CombinedMultiDicta>A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict` instances as sequence and it will combine the return values of all wrapped dicts: >>> from werkzeug.datastructures import CombinedMultiDict, MultiDict >>> post = MultiDict([('foo', 'bar')]) >>> get = MultiDict([('blub', 'blah')]) >>> combined = CombinedMultiDict([get, post]) >>> combined['foo'] 'bar' >>> combined['blub'] 'blah' This works for all read operations and will raise a `TypeError` for methods that usually change data which isn't possible. From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP exceptions. cCst|�
|j
f
fS)
N)r�dicts)rr%rrrr&�s
zCombinedMultiDict.__reduce_ex__NcCst|
�
p g|_
dS)
N)rr�)rr�rrrrB�s
zCombinedMultiDict.__init__cCstd
|j
�d��
�
dS)Nzcannot create z instances by fromkeys)r r)rDrErrrrrH�szCombinedMultiDict.fromkeyscCs.x|jD]}|
|kr||
SqWt
j|
�
�
dS)
N)r�r rv)rr�
drrrru�s



zCombinedMultiDict.__getitem__cCsPxJ|jD]@}|
|kr|dk r@y|||
�
St
k r>


wYnX||
SqW|S)
N)r�rf)rrrKrr�rrrrg�s








zCombinedMultiDict.getcCs*g}x |jD]}|j
|j|
|��

qW|S)
N)r�r0ry)rrrr#r�rrrry�s



zCombinedMultiDict.getlistc
Cst�}
|
j
|j�
|
S)
z�This function exists so __len__ can be implemented more efficiently, saving one list creation from an iterator. )r�rOr�)rr#rrr� _keys_impl�s

zCombinedMultiDict._keys_implc


Cs|j�S)
N)
r�)
rrrrrE�s
zCombinedMultiDict.keysc

Cst|j
��
S)
N)r�rE)
rrrrrt�s
zCombinedMultiDict.__iter__Fccs^t�}xR|j
D]H}xB|j|
�
D]4\}}|
r6||fV
q||kr|j|�

||fV
qWqWdS)
N)r�r�rrU)rr�foundr�rrrrrr�s







zCombinedMultiDict.itemsc
cs x|j�D]\}
}|V
q WdS)
N)
r)rr�rrrrrz�s

zCombinedMultiDict.valuesc
CsHi}
x6|jD],}x&|j
�D]\}}|
j|g�j|�

qWqWt|
j��
S)
N)r�rorLr0rr)rr#r�rrzrrrro�s




zCombinedMultiDict.listsc

Csd
d�|j�D�
S)Nc
ss|]}
|
dV
qd
S)rNr)rkr�rrrrn�sz/CombinedMultiDict.listvalues..)
ro)
rrrrr{�s
zCombinedMultiDict.listvaluesc

Cst|�
S)
a0
Return a shallow mutable copy of this object. This returns a :class:`MultiDict` representing the data at the time of copying. The copy will no longer reflect changes to the wrapped dicts. .. versionchanged:: 0.15 Return a mutable :class:`MultiDict`. )
r)
rrrrri�s zCombinedMultiDict.copyTcCs|
rt|j
��
St|j��
S)
a�
Return the contents as regular dict. If `flat` is `True` the returned dict will only have the first item present, if `flat` is `False` all values will be returned as lists. :param flat: If set to `False` the dict returned will have lists with all the values in it. Otherwise it will only contain the first item for each key. :return: a :class:`dict` )rrro)rr|rrrr}�s 
zCombinedMultiDict.to_dictc

Cst|j
��
S)
N)rpr�)
rrrrr�s
zCombinedMultiDict.__len__cCs x|jD]}|
|krd
SqWdS)NTF)
r�)rrr�rrrr� s



zCombinedMultiDict.__contains__cCstj
d
tdd�
|
|kS)z{ .. deprecated:: 2.0 Will be removed in Werkzeug 2.1. Use ``key in data`` instead. zW'has_key' is deprecated and will be removed in Werkzeug 2.1. Use 'key in data' instead.r�)
r�)r�r�r�)rrrrrr�s 

zCombinedMultiDict.has_keyc

Cst|�
j
�d
|j�d�S)Nr<r=)rrr�)
rrrrr>s
zCombinedMultiDict.__repr__)
N)
N)NN)
N)
F)
T)rr8r9r:r&rBrRrHrurgryr�rErtrrzror{rir}r�r�r�r>rrrrr��s* 
    r�c@seZ
dZd
Zddd�
ZdS)� FileMultiDictz�A special :class:`MultiDict` that has convenience methods to add files to it. This is used for :class:`EnvironBuilder` and generally useful for unittesting. .. versionadded:: 0.5 NcCslt|t
�r|}nLt|t�r0|d
kr&|}t|d�}|rN|d
krNtj|�
dpLd}t
|||
|�}|j|
|�
d
S)aP
Adds a new file to the dict. `file` can be a file name or a :class:`file`-like or a :class:`FileStorage` object. :param name: the name of the field. :param file: a filename or :class:`file`-like object :param filename: an optional filename :param content_type: an optional content type N�rbr
zapplication/octet-stream)r�FileStorager��open� mimetypes� guess_typerU)rr`�file�filename�content_typerrrr�add_file)s




zFileMultiDict.add_file)NN)rr8r9r:r�rrrrr�!sr�c@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS) � ImmutableDictz;An immutable :class:`dict`. .. versionadded:: 0.5 c

Cst|�
j
�d
tj|�
�d�S)Nr<r=)rrrr>)
rrrrr>Hs
zImmutableDict.__repr__c

Cst|�
S)
z�Return a shallow mutable copy of this object. Keep in mind that the standard library's :func:`copy` function is a no-op for this class like for any other python immutable type (eg: :class:`tuple`). )
r)
rrrrriKszImmutableDict.copyc


Cs|S)
Nr)
rrrrrjRs
zImmutableDict.__copy__N)rr8r9r:r>rirjrrrrr�Bsr�c@s eZ
dZd
Zdd�Zdd�ZdS)�ImmutableMultiDictz@An immutable :class:`MultiDict`. .. versionadded:: 0.5 c

Cst|�
S)
z�Return a shallow mutable copy of this object. Keep in mind that the standard library's :func:`copy` function is a no-op for this class like for any other python immutable type (eg: :class:`tuple`). )
r)
rrrrri\szImmutableMultiDict.copyc


Cs|S)
Nr)
rrrrrjcs
zImmutableMultiDict.__copy__N)rr8r9r:rirjrrrrr�Vsr�c@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS) �ImmutableOrderedMultiDictzGAn immutable :class:`OrderedMultiDict`. .. versionadded:: 0.6 c

Cst|j
d
d�
�
S)NT)
r)r�r)
rrrrrIms
z)ImmutableOrderedMultiDict._iter_hashitemsc

Cst|�
S)
z�Return a shallow mutable copy of this object. Keep in mind that the standard library's :func:`copy` function is a no-op for this class like for any other python immutable type (eg: :class:`tuple`). )
r�)
rrrrripszImmutableOrderedMultiDict.copyc


Cs|S)
Nr)
rrrrrjws
z"ImmutableOrderedMultiDict.__copy__N)rr8r9r:rIrirjrrrrr�gsr�c@s�eZ
dZd
Zff
dd�
Zdd�Zdd�Zdd �Zd d�Zdd �Z dd�Z dd�Zdd�Zdd�Z dd�Zdd�Zdd�Zd!dd�
Zedd ��
ZdS)"�Accepta�An :class:`Accept` object is just a list subclass for lists of ``(value, quality)`` tuples. It is automatically sorted by specificity and quality. All :class:`Accept` objects work similar to a list but provide extra functionality for working with the data. Containment checks are normalized to the rules of that header: >>> a = CharsetAccept([('ISO-8859-1', 1), ('utf-8', 0.7)]) >>> a.best 'ISO-8859-1' >>> 'iso-8859-1' in a True >>> 'UTF8' in a True >>> 'utf7' in a False To get the quality for an item you can use normal item lookup: >>> print a['utf-8'] 0.7 >>> a['utf7'] 0 .. versionchanged:: 0.5 :class:`Accept` objects are forced immutable now. .. versionchanged:: 1.0.0 :class:`Accept` internal values are no longer ordered alphabetically for equal quality tags. Instead the initial order is preserved. csf|
dkrtj
��

d
�_nHt|
t�r:|
j�_tj
�|
�
n(d�_t|
�f
dd�dd�}
tj
�|
�
dS)NFTc

s�j|d
�
|dfS)Nr
r)
�_specificity)
r�)
rrr��sz!Accept.__init__..)rr5)rrB�providedrr��sorted)rrzr)
rrrB�s







zAccept.__init__cCs |
d
kf
S)z3Returns a tuple describing the value's specificity.�
*r)rrrrrr��szAccept._specificitycCs|d
kp|j�|
j�kS)z-Check if a value matches a given accept item.r�)
r�)rrr,rrr�_value_matches�szAccept._value_matchescCs t|
t
�r|j|
�
Stj||
�S)
z�Besides index lookup (getting item n) you can also pass it a string to get the quality for the item. If the item is not in the list, the returned quality is ``0``. )rr��qualityrru)rrrrrru�s

zAccept.__getitem__cCs&x |D]\}}|j|
|�r|SqWd
S)z�Returns the quality of the key. .. versionadded:: 0.6 In previous versions you had to use the item-lookup syntax (eg: ``obj[key]`` instead of ``obj.quality(key)``) r
)
r�)rrr,r�rrrr��s


zAccept.qualitycCs&x |D]\}}|j|
|�rd
SqWdS)NTF)
r�)rrr,�_qualityrrrr��s



zAccept.__contains__c
Cs*d
jdd�|D�
�
}
t
|�
j�d|
�d�S)Nz, c
ss$|]\}
}d|
�d
|�d�V
qdS)r<z, r=Nr)rkr��
yrrrrn�sz"Accept.__repr__..z([z]))r�rr)rZ pairs_strrrrr>�s

zAccept.__repr__cCsHt|
t
�rr3r�rzr�r�r�r��propertyr�rrrrr�{s "    r�z /|(?:\s*;\s*)c

Cstj
|j��
S)
N)�_mime_split_re�splitr�)
rrrr�_normalize_mime*s
r�c@sDeZ
dZd
Zdd�Zdd�Zedd��
Zedd ��
Zed d��
Z dS) � MIMEAcceptzRLike :class:`Accept` but with special methods and behavior for mimetypes. cCstd
d�t
j|
�
D�
�
S)Nc
ss|]}
|
dkV
qd
S)r�Nr)rkr�rrrrn4sz*MIMEAccept._specificity..)rr�r�)rrrrrr�3s
zMIMEAccept._specificitycCs�d
|krdSd
|
kr"td|
���
�
t
|
�
}|dd�\}}t|dd��
}|dkrh|dkrhtd|
���
�
t
|�
}|dd�\}} t|dd��
} |dkr�| dkr�dS|dkr�| dkp�|dkr�|dkp�||ko�| dkp�|dkp�| |ko�| |kS)N�
/Fzinvalid mimetype r�r�)rfr�r�)rrr,Znormalized_valueZ value_typeZ value_subtypeZvalue_paramsZnormalized_itemZ item_typeZitem_subtypeZitem_paramsrrrr�6s(










zMIMEAccept._value_matchesc

Csd
|kpd|kp|jS)z!True if this object accepts HTML.z text/htmlzapplication/xhtml+xml)
�accept_xhtml)
rrrr�accept_html^szMIMEAccept.accept_htmlc

Csd
|kpd|kS)z"True if this object accepts XHTML.zapplication/xhtml+xmlzapplication/xmlr)
rrrrr�eszMIMEAccept.accept_xhtmlc

Csd
|kS)z!True if this object accepts JSON.zapplication/jsonr)
rrrr�accept_jsonjszMIMEAccept.accept_jsonN) rr8r9r:r�r�r�r�r�r�rrrrr�.s(r�z[_-]c

Cstj
|j��
S)
z$Process a language tag for matching.)�_locale_delim_rer�r�)
rrrr�_normalize_langssr

cs*eZ
dZd
Zdd�Zd�f
dd� Z�ZS)�LanguageAcceptz>Like :class:`Accept` but with normalization for language tags.cCs|d
kpt|
�
t|�
kS)Nr�)
r

)rrr,rrrr�{s
zLanguageAccept._value_matchesNcs|t�j
|
�
��d
k r�Stdd�|D�
�
}|j
|
�
��d
k r@�Sdd�|
D�
}t�j
|�
��d
k rxt�f
dd�|
D�
�
S|S)a�Given a list of supported values, finds the best match from the list of accepted values. Language tags are normalized for the purpose of matching, but are returned unchanged. If no exact match is found, this will fall back to matching the first subtag (primary language only), first with the accepted values then with the match values. This partial is not applied to any other language subtags. The default is returned if no exact or fallback match is found. :param matches: A list of supported languages to find a match. :param default: The value that is returned if none match. Nc
Ss(g|] }
tj
|
dd
�d|
d
f�qS)r
r)r
r�)rkr,rrrr��sz-LanguageAccept.best_match..c
Ssg|]}
tj
|
d�d
�qS)rr
)r
r�)rkr,rrrr��sc
3s|]}
|
j��
r|
V
qdS)
N)
r�)rkr,)
rxrrrn�sz,LanguageAccept.best_match..)r@r�r�r�)rr�rK�fallbackZfallback_matches)
rG)
rxrr�~s

 


zLanguageAccept.best_match)
N)rr8r9r:r�r�rSrr)
rGrr
xs
r
c@seZ
dZd
Zdd�ZdS)� CharsetAcceptz9Like :class:`Accept` but with normalization for charsets.cCs d
d�}|dkp||
�
||�
kS)Nc

Ss*ytj
|�
jStk r$


|j�SXdS)
N)�codecs�lookupr`�LookupErrorr�)
r`rrr� _normalize�s



z0CharsetAccept._value_matches.._normalizer�r)rrr,r
rrrr��s
zCharsetAccept._value_matchesN)rr8r9r:r�rrrrr
�s
r
cs2t��
�fd
d��
�fdd��
f
dd�d�
���S)z�Return a new property object for a cache header. Useful if you want to add support for a cache extension in a subclass. .. versionchanged:: 2.0 Renamed from ``cache_property``. c

s|j�
���S)
N)
�_get_cache_value)
r�)�emptyrrrrr��sz(cache_control_property..cs|j�|
�
�S)
N)
�_set_cache_value)r�r)rrrrr��sc

s |j��
S)
N)
�_del_cache_value)
r�)
rrrr��sz accessor for )
r�)rr
rr)r
rrr�cache_control_property�s 



r
cCstj
d
tdd�
t||
|�S)Nzx'cache_property' is renamed to 'cache_control_property'. The old name is deprecated and will be removed in Werkzeug 2.1.r�)
r�)r�r�r�r
)rr
rrrr�cache_property�s


r
c@s�eZ
dZd
Zeddd�Zedde�Zedde�Z eddd�Z fdfd d �
Zdd�Zd d�Z dd�Zdd�Zdd�Zdd�Zee�
ZdS)� _CacheControlaVSubclass of a dict that stores values for a Cache-Control header. It has accessors for all the cache-control directives specified in RFC 2616. The class does not differentiate between request and response directives. Because the cache-control directives in the HTTP header use dashes the python descriptors use underscores for that. To get a header of the :class:`CacheControl` object again you can convert the object into a string or call the :meth:`to_header` method. If you plan to subclass it and add your own items have a look at the sourcecode for that class. .. versionchanged:: 0.4 Setting `no_cache` or `private` to boolean `True` will set the implicit none-value which is ``*``: >>> cc = ResponseCacheControl() >>> cc.no_cache = True >>> cc >>> cc.no_cache '*' >>> cc.no_cache = None >>> cc In versions before 0.5 the behavior documented here affected the now no longer existing `CacheControl` class. zno-cacher�Nzno-storezmax-agerzno-transformcCs$tj
||
pf�
||_|
dk |_dS)
N)rrBr^r�)rrzr^rrrrB�s


z_CacheControl.__init__cCs^|tkr|
|kS|
|krZ||
}|d
kr,|S|d
k rVy||�
}Wnt
k rT


YnX|Sd
S)z+Used internally by the accessor properties.N)�boolrf)rrr
rrrrrr
�s











z_CacheControl._get_cache_valuecCsX|tkr$|rd
||
<qT|j
|
d
�
n0|d
kr:|j
|
d
�
n|dkrLd
||
<n|||
<d
S)z+Used internally by the accessor properties.NT)r
r4)rrrrrrrr
s




z_CacheControl._set_cache_valuecCs|
|kr||
=d
S)z+Used internally by the accessor properties.Nr)rrrrrr
s
z_CacheControl._del_cache_valuec

Cs tj
|�
S)
z6Convert the stored values into a cache control header.)r��dump_header)
rrrrr�"sz_CacheControl.to_headerc


Cs|j�S)
N)
r�)
rrrrr�&s
z_CacheControl.__str__c
Cs4d
jdd�t
|j��
D�
�
}
dt|�
j�d
|
�d�S)N�
c
ss |]\}
}|
�d|��V
qd
S)�
=Nr)rkrlrrrrrn*sz)_CacheControl.__repr__..�
<�
>)r�r�rrr)r�kv_strrrrr>)s

z_CacheControl.__repr__r7)rr8r9r:r
�no_cacher
�no_storer�Zmax_ageZno_transformrBr
r
r
r�r�r>�staticmethodr
rrrrr
�s


r
c@s4eZ
dZd
Zedde�Zedde�Zedde�Z dS)�RequestCacheControla A cache control for requests. This is immutable and gives access to all the request-relevant cache control headers. To get a header of the :class:`RequestCacheControl` object again you can convert the object into a string or call the :meth:`to_header` method. If you plan to subclass it and add your own items have a look at the sourcecode for that class. .. versionadded:: 0.5 In previous versions a `CacheControl` class existed that was used both for request and response. z max-staler�z min-freshzonly-if-cachedN) rr8r9r:r
r�Z max_stale� min_freshr
Zonly_if_cachedrrrrr
0s

r
c@sXeZ
dZd
Zedde�Zeddd�Zedde�Zedde�Z eddd�Z ed de�ZdS) �ResponseCacheControla*A cache control for responses. Unlike :class:`RequestCacheControl` this is mutable and gives access to response-relevant cache control headers. To get a header of the :class:`ResponseCacheControl` object again you can convert the object into a string or call the :meth:`to_header` method. If you plan to subclass it and add your own items have a look at the sourcecode for that class. .. versionadded:: 0.5 In previous versions a `CacheControl` class existed that was used both for request and response. �publicN�privater�zmust-revalidatezproxy-revalidatezs-maxage� immutable)rr8r9r:r
r
r
r
Zmust_revalidateZproxy_revalidateZs_maxager
rrrrr
Cs 




r
c

s,t�f
d
d��f
dd��f
dd�d����S)z�Return a new property object for a content security policy header. Useful if you want to add support for a csp extension in a subclass. c

s |j��
S)
N)
� _get_value)
r�)
rrrr�`szcsp_property..cs|j�|
�S)
N)
� _set_value)r�r)
rrrr�asc

s |j��
S)
N)
� _del_value)
r�)
rrrr�bsz accessor for )
r�)
rr)
rr�csp_propertyZs 



r#
c@s
eZ
dZd
Zed�
Zed�
Zed�
Zed�
Zed�
Z ed�
Z ed�
Zed �
Zed �
Z ed�
Zed�
Zed �
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zed�
Zfdfdd�
Zdd�Zd d!�Z d"d#�Z!d$d%�Z"d&d'�Z#d(d)�Z$dS)*�ContentSecurityPolicyaVSubclass of a dict that stores values for a Content Security Policy header. It has accessors for all the level 3 policies. Because the csp directives in the HTTP header use dashes the python descriptors use underscores for that. To get a header of the :class:`ContentSecuirtyPolicy` object again you can convert the object into a string or call the :meth:`to_header` method. If you plan to subclass it and add your own items have a look at the sourcecode for that class. .. versionadded:: 1.0.0 Support for Content Security Policy headers was added. zbase-uriz child-srczconnect-srczdefault-srczfont-srczform-actionzframe-ancestorsz frame-srczimg-srczmanifest-srcz media-srcznavigate-toz object-srczprefetch-srczplugin-typesz report-toz report-uri�sandboxz script-srczscript-src-attrzscript-src-elemz style-srczstyle-src-attrzstyle-src-elemz worker-srcNcCs$tj
||
pf�
||_|
dk |_dS)
N)rrBr^r�)rrzr^rrrrB�s


zContentSecurityPolicy.__init__cCs |j|
�
S)
z+Used internally by the accessor properties.)
rg)rrrrrr
�sz ContentSecurityPolicy._get_valuecCs"|d
kr|j|
d
�
n|||
<d
S)z+Used internally by the accessor properties.N)
r4)rrrrrrr!
�s
z ContentSecurityPolicy._set_valuecCs|
|kr||
=d
S)z+Used internally by the accessor properties.Nr)rrrrrr"
�s
z ContentSecurityPolicy._del_valuec

Cs tj
|�
S)
z6Convert the stored values into a cache control header.)r�Zdump_csp_header)
rrrrr��szContentSecurityPolicy.to_headerc


Cs|j�S)
N)
r�)
rrrrr��s
zContentSecurityPolicy.__str__c
Cs4d
jdd�t
|j��
D�
�
}
dt|�
j�d
|
�d�S)Nr
c
ss |]\}
}|
�d|��V
qd
S)r
Nr)rkrlrrrrrn�sz1ContentSecurityPolicy.__repr__..r
r
)r�r�rrr)rr
rrrr>�s

zContentSecurityPolicy.__repr__)%rr8r9r:r#
Zbase_uriZ child_srcZconnect_srcZdefault_srcZfont_srcZform_actionZframe_ancestorsZ frame_srcZimg_srcZmanifest_srcZ media_srcZnavigate_toZ object_srcZprefetch_srcZplugin_typesZ report_toZ report_urir%
Z script_srcZscript_src_attrZscript_src_elemZ style_srcZstyle_src_attrZstyle_src_elemZ worker_srcrBr
r!
r"
r�r�r>rrrrr$
gsB























r$
c@s"eZ
dZd
Zddd�
Zdd�ZdS)�CallbackDictzwA dict that calls a function passed every time something is changed. The function is passed the dict instance. NcCstj
||
pf�
||_dS)
N)rrBr^)r�initialr^rrrrB�s

zCallbackDict.__init__c

Csd
t|�
j
�dtj|�
�d�S)Nr
r
r
)rrrr>)
rrrrr>�s
zCallbackDict.__repr__)NN)rr8r9r:rBr>rrrrr&
�s r&
c@s�eZ
dZd
Zd*dd�
Zdd�Zdd�Zd d �Zdd�Zd d�Z dd�Z dd�Zd+dd�
Zdd�Z dd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�ZdS),� HeaderSeta�
Similar to the :class:`ETags` class this implements a set-like structure. Unlike :class:`ETags` this is case insensitive and used for vary, allow, and content-language headers. If not constructed using the :func:`parse_set_header` function the instantiation works like this: >>> hs = HeaderSet(['foo', 'bar', 'baz']) >>> hs HeaderSet(['foo', 'bar', 'baz']) NcCs*t|
pf�
|_
d
d�|j
D�
|_||_dS)Nc
Ssh|]}
|
j��qSr)
r�)rkr�rrr� �sz%HeaderSet.__init__..)r�_headers�_setr^)r�headersr^rrrrB�s


zHeaderSet.__init__cCs|j|
f
�

d
S)zAdd a new header to the set.N)
rO)r�headerrrrrU�sz HeaderSet.addcCsl|
j�}||j
krt|
�
�
|j
j|�

x,t|j�
D]\}}|j�|
kr2|j|=Pq2W|jd
k rh|j|�

d
S)aC
Remove a header from the set. This raises an :exc:`KeyError` if the header is not in the set. .. versionchanged:: 0.5 In older versions a :exc:`IndexError` was raised instead of a :exc:`KeyError` if the object was missing. :param header: the header to be removed. N)r�r+
rer.r�r*
r^)rr-
rr�rrrr.�s 








zHeaderSet.removecCs\d
}x:|
D]2}|j�}||j
kr |jj|�

|j
j|�

d}q W|rX|jdk rX|j|�

dS)z�Add all the headers from the iterable to the set. :param iterable: updates the set with the items from the iterable. FTN)r�r+
r*
r-rUr^)rr/Zinserted_anyr-
rrrrrO�s







zHeaderSet.updatecCs(y|j|
�

Wnt
k r"


YnXd
S)zdLike :meth:`remove` but ignores errors. :param header: the header to be discarded. N)r.re)rr-
rrr�discard�s


zHeaderSet.discardcCs4|
j�}
x&t
|j�
D]\}}|j�|
kr|SqWdS)z�Return the index of the header in the set or return -1 if not found. :param header: the header to be looked up. rr7)r�r�r*
)rr-
r�r,rrrr� s 



zHeaderSet.findcCs|j|
�
}|d
krt
|
�
�
|S)z�Return the index of the header in the set or raise an :exc:`IndexError`. :param header: the header to be looked up. r
)r�� IndexError)rr-
r#rrrr3 s


zHeaderSet.indexc

Cs.|jj
�
|jd
d
�=|jd
k r*|j|�

d
S)zClear the set.N)r+
rQr*
r^)
rrrrrQ s


zHeaderSet.clearFcCs|
rt|j
�
St|j�
S)
a�
Return the set as real python set type. When calling this, all the items are converted to lowercase and the ordering is lost. :param preserve_casing: if set to `True` the items in the set returned will have the original case like in the :class:`HeaderSet`, otherwise they will be lowercase. )r�r*
r+
)rZpreserve_casingrrr�as_set! s 

zHeaderSet.as_setc

Csd
jt
tj|j��
S)z2Convert the header set into an HTTP header string.z, )r�r�r��quote_header_valuer*
)
rrrrr�. szHeaderSet.to_headercCs |j|
S)
N)
r*
)rr�rrrru2 s
zHeaderSet.__getitem__cCs4|jj
|
�
}|jj|j��

|jdk r0|j|�

dS)
N)r*
r4r+
r.r�r^)rr�r#rrrr'5 s



zHeaderSet.__delitem__cCsL|j|
}|j
j|j��

||j|
<|j
j|j��

|jdk rH|j|�

dS)
N)r*
r+
r.r�rUr^)rr�r�oldrrrr+; s





zHeaderSet.__setitem__cCs|
j�|j
kS)
N)r�r+
)rr-
rrrr�C s
zHeaderSet.__contains__c

Cs t|j
�
S)
N)rpr+
)
rrrrr�F s
zHeaderSet.__len__c

Cs t|j
�
S)
N)r�r*
)
rrrrrtI s
zHeaderSet.__iter__c

Cs t|j
�
S)
N)r
r+
)
rrrr�__bool__L s
zHeaderSet.__bool__c


Cs|j�S)
N)
r�)
rrrrr�O s
zHeaderSet.__str__c

Cst|�
j
�d
|j�d�S)Nr<r=)rrr*
)
rrrrr>R s
zHeaderSet.__repr__)NN)
F)rr8r9r:rBrUr.rOr.
r�r3rQr0
r�rur'r+r�r�rtr3
r�r>rrrrr(
�s(   r(
c@s�eZ
dZd
Zd"dd�
Zd#dd�
Zdd �Zd d�Zdd �Zdd�Z dd�Z dd�Zd$dd�
Zdd�Z dd�Zdd�Zdd�Zdd�Zd d!�ZdS)%�ETagszYA set that can be used to check if one etag is present in a collection of etags. NFcCs6|r|
rt|
�
|_
nt�|_
t|p&f�
|_||_dS)
N)rJ�_strong�_weak�star_tag)rZstrong_etagsZ weak_etagsr7
rrrrB[ s


zETags.__init__cCst|j
�
}|
r|j|j�

|S)
zoConvert the `ETags` object into a python set. Per default all the weak etags are not part of this set.)r�r5
rOr6
)r�include_weakr#rrrr0
d s


zETags.as_setcCs |
|jkS)
zCheck if an etag is weak.)
r6
)r�etagrrr�is_weakl sz ETags.is_weakcCs |
|jkS)
zCheck if an etag is strong.)
r5
)rr9
rrr� is_strongp szETags.is_strongcCs|j|
�
p|j
|
�
S)
zCCheck if an etag is part of the set including weak and strong tags.)r:
�contains)rr9
rrr� contains_weakt szETags.contains_weakcCs|jr d
S|j
|
�
S)zxCheck if an etag is part of the set ignoring weak tags. It is also possible to use the ``in`` operator. T)r7
r;
)rr9
rrrr<
x s

zETags.containscCs&tj
|
�
\}
}|r|j|
�
S|j|
�
S)
z�When passed a quoted tag it will check if this tag is part of the set. If the tag is weak it is checked against weak and strong tags, otherwise strong only.)r�Zunquote_etagr=
r<
)rr9
Zweakrrr�contains_raw� s


zETags.contains_rawc

Cs0|jr d
Sdj
dd�|jD�
dd�|jD�
�
S)z0Convert the etags set into a HTTP header string.r�z, c
Ssg|]}
d|
�d��qS)
�
"r)rkr�rrrr�� sz#ETags.to_header..c
Ssg|]}
d|
�d
��qS)zW/"r?
r)rkr�rrrr�� s)r7
r�r5
r6
)
rrrrr�� s


zETags.to_headercCsH|
|gjd�
d
krt
d�
�
|
dkr,tj|�
}
|r>|
|jkr>dS|
|jkS)Nrz-either tag or data required, but at least oneT)�countr r�Z generate_etagr6
r5
)rr9
�datar8
rrr�__call__� s







zETags.__call__c

Cst|j
p|jp|j�
S)
N)r
r7
r5
r6
)
rrrrr3
� s
zETags.__bool__c


Cs|j�S)
N)
r�)
rrrrr�� s
z ETags.__str__c

Cs t|j
�
S)
N)rpr5
)
rrrrr�� s
z ETags.__len__c

Cs t|j
�
S)
N)r�r5
)
rrrrrt� s
zETags.__iter__cCs |j|
�
S)
N)
r<
)rr9
rrrr�� s
zETags.__contains__c

Csd
t|�
j
�dt|�
�d�S)Nr
r
r
)rrr�)
rrrrr>� s
zETags.__repr__)NNF)
F)NNF)rr8r9r:rBr0
r:
r;
r=
r<
r>
r�rB
r3
r�r�rtr�r>rrrrr4
V s    r4
c@s2eZ
dZd
Zddd�
Zdd�Zdd�Zd d �ZdS)�IfRangez�Very simple object that represents the `If-Range` header in parsed form. It will either have neither a etag or date or one of either but never both. .. versionadded:: 0.7 NcCs|
|_||_
dS)
N)r9
�date)rr9
rD
rrrrB� szIfRange.__init__c

Cs0|jd
k rt
j|j�
S|jd
k r,t
j|j�
SdS)z-Converts the object back into an HTTP header.N�)rD
r�Z http_dater9
Z quote_etag)
rrrrr�� s 



zIfRange.to_headerc


Cs|j�S)
N)
r�)
rrrrr�� s
zIfRange.__str__c

Csd
t|�
j
�dt|�
�d�S)Nr
r
r
)rrr�)
rrrrr>� s
zIfRange.__repr__)NN)rr8r9r:rBr�r�r>rrrrrC
� s  rC
c@sHeZ
dZd
Zdd�Zdd�Zdd�Zdd �Zd d�Zdd �Z dd�Z dS)�RangeaX
Represents a ``Range`` header. All methods only support only bytes as the unit. Stores a list of ranges if given, but the methods only work if only one range is provided. :raise ValueError: If the ranges provided are invalid. .. versionchanged:: 0.15 The ranges passed in are validated. .. versionadded:: 0.7 cCsT|
|_||_
xB|D]:\}}|dks:|dk r|d
ks:||krt||f�d��
�
qWdS)Nr
z is not a valid range.)�units�rangesrf)rrG
rH
�start�endrrrrB� s 

zRange.__init__cCsn|jd
ks |
dks t
|j�
dkr$dS|jd\}}|dkrN|
}|dkrN||
7}tj|||
�rj|t||
�fSdS)z�If the range is for bytes, the length is not None and there is exactly one range and it is satisfiable it returns a ``(start, stop)`` tuple, otherwise `None`. r�Nrr
)rG
rprH
r��is_byte_range_valid�min)r�lengthrI
rJ
rrr�range_for_length� s








zRange.range_for_lengthcCs.|j|
�
}|d
k r*t
|j|d|d|
�Sd
S)z�Creates a :class:`~werkzeug.datastructures.ContentRange` object from the current range and given content length. Nr
r)rN
�ContentRangerG
)rrM
�rngrrr�make_content_range� s


zRange.make_content_rangec
Cspg}
xT|jD]J\}}|d
kr>|
j
|dkr2|�d�nt|�
�

q|
j
|�d|d���

qW|j�ddj|
�
��S)z-Converts the object back into an HTTP header.Nr
r�rr
r�)rH
r-r�rG
r�)rrH
�beginrJ
rrrr�� s


"
zRange.to_headercCs>|j|
�
}|d
k r:|j
�d|d�d|dd�d|
��Sd
S)z\Converts the object into `Content-Range` HTTP header, based on given length Nr
r
r�rr�)rN
rG
)rrM
�rangerrr�to_content_range_header s

(
zRange.to_content_range_headerc


Cs|j�S)
N)
r�)
rrrrr� s
z Range.__str__c

Csd
t|�
j
�dt|�
�d�S)Nr
r
r
)rrr�)
rrrrr> s
zRange.__repr__N)rr8r9r:rBrN
rQ
r�rT
r�r>rrrrrF
� s   rF
c
s"�f
d
d�}
�f
dd�}t|
|�S)Nc

s t|��S)
N)
r\)
r)
r`rr�fget s
z _callback_property..fgetcs$t|�|
�
|j
dk r |j
|�

dS)
N)�setattrr^)rr)
r`rr�fset s


z _callback_property..fset)
r�)r`rU
rW
r)
r`r�_callback_property s
rX
c@sleZ
dZd
Zddd�
Zed�
Zed�
Zed�
Zed�
Z dd d�
Z dd �Zdd�Zdd�Z dd�Zdd�ZdS)rO
zDRepresents the content range header. .. versionadded:: 0.7 NcCs0tj
|||�std
�
�
||_|j||||
�
dS)NzBad range provided)r�rK
�AssertionErrorr^r�)rrG
rI
�stoprM
r^rrrrB) s


zContentRange.__init__�_units�_start�_stop�_lengthr�cCsFtj
|
||�std
�
�
||_|
|_||_||_|jdk rB|j|�

dS)z#Simple method to update the ranges.zBad range providedN)r�rK
rY
r[
r\
r]
r^
r^)rrI
rZ
rM
rG
rrrr�8 s





zContentRange.setc

Cs|jd
d
d
d�
d
S)zcSets the units to `None` which indicates that the header should no longer be used. N)
rG
)
r�)
rrrr�unsetB szContentRange.unsetc
Csb|jdkrd
S|j
dkrd}
n|j
}
|jdkr>|j�d|
��S|j�d|j�d|jd�d|
��S)NrE
r�z */r
r�rr�)rG
rM
rI
rZ
)rrM
rrrr�H s






zContentRange.to_headerc

Cs |jdk S)
N)
rG
)
rrrrr3
S s
zContentRange.__bool__c


Cs|j�S)
N)
r�)
rrrrr�V s
zContentRange.__str__c

Csd
t|�
j
�dt|�
�d�S)Nr
r
r
)rrr�)
rrrrr>Y s
zContentRange.__repr__)NN)Nr�)rr8r9r:rBrX
rG
rI
rZ
rM
r�r_
r�r3
r�r>rrrrrO
# s  rO
c@s�eZ
dZd
Zddd�
Zedd��
Zedd��
Zed d ��
Zedd��
Z ed d��
Z edd��
Zedd��
Zedd��
Z edd��
Zedd��
Zdd�ZdS)� Authorizationa=
Represents an ``Authorization`` header sent by the client. This is returned by :func:`~werkzeug.http.parse_authorization_header`. It can be useful to create the object manually to pass to the test :class:`~werkzeug.test.Client`. .. versionchanged:: 0.5 This object became immutable. NcCstj
||pi�
|
|_dS)
N)rrBr)r� auth_typerA
rrrrBi s

zAuthorization.__init__c

Cs |jd
�
S)zdThe username transmitted. This is set for both basic and digest auth all the time. �username)
rg)
rrrrrb
m szAuthorization.usernamec

Cs |jd
�
S)zsWhen the authentication type is basic this is the password transmitted by the client, else `None`. �password)
rg)
rrrrrc
t szAuthorization.passwordc

Cs |jd
�
S)z8This is the server realm sent back for HTTP digest auth.�realm)
rg)
rrrrrd
{ szAuthorization.realmc

Cs |jd
�
S)z�The nonce the server sent for digest auth, sent back by the client. A nonce should be unique for every 401 response for HTTP digest auth. �nonce)
rg)
rrrrre
� szAuthorization.noncec

Cs |jd
�
S)z�The URI from Request-URI of the Request-Line; duplicated because proxies are allowed to change the Request-Line in transit. HTTP digest auth only. �uri)
rg)
rrrrrf
� szAuthorization.uric

Cs |jd
�
S)zzThe nonce count value transmitted by clients if a qop-header is also transmitted. HTTP digest auth only. �nc)
rg)
rrrrrg
� szAuthorization.ncc

Cs |jd
�
S)z�If the server sent a qop-header in the ``WWW-Authenticate`` header, the client has to provide this value for HTTP digest auth. See the RFC for more details. �cnonce)
rg)
rrrrrh
� szAuthorization.cnoncec

Cs |jd
�
S)z�A string of 32 hex digits computed as defined in RFC 2617, which proves that the user knows a password. Digest auth only. �response)
rg)
rrrrri
� szAuthorization.responsec

Cs |jd
�
S)z�The opaque header from the server returned unchanged by the client. It is recommended that this string be base64 or hexadecimal data. Digest auth only. �opaque)
rg)
rrrrrj
� szAuthorization.opaquec

Cs |jd
�
S)z�Indicates what "quality of protection" the client has applied to the message for HTTP digest auth. Note that this is a single token, not a quoted list of alternatives as in WWW-Authenticate. �qop)
rg)
rrrrrk
� szAuthorization.qopc
Csf|jd
kr6t
j|j�d|j��j��
jd�
}
d|
��S|jdkrPdtj|�
��St d|j�d��
�
d S) z�Convert to a string value for an ``Authorization`` header. .. versionadded:: 2.0 Added to support passing authorization to the test client. �basic�
:�utf8zBasic �digestzDigest zUnsupported type �
.N) r�base64� b64encoderb
rc
r�r�r�r
rf)rrrrrr�� s




zAuthorization.to_header)
N)rr8r9r:rBr�rb
rc
rd
re
rf
rg
rh
ri
rj
rk
r�rrrrr`
] s  r`
cs"�f
d
d�}t�f
dd�||
d�S)al
A static helper function for Authentication subclasses to add extra authentication system properties onto a class:: class FooAuthenticate(WWWAuthenticate): special_realm = auth_property('special_realm') For more information have a look at the sourcecode to see how the regular properties (:attr:`realm` etc.) are implemented. cs&|
dkr|j�d�
nt
|
�
|�<dS)
N)r4r�)rr)
r`rrr!
� s

z!auth_property.._set_valuec

s |j��
S)
N)
rg)
r�)
r`rrr�� szauth_property..)
�doc)
r�)r`rs
r!
r)
r`r� auth_property� srt
cs�f
d
d�}t||
d�S)Nc
s �
�fd
d�}
tj
�j�
�
|
�S)Nc

s*|r��
kr�
�=n|r&|j��
�<dS)
N)
r�)
Z header_set)r`rrrr^� s



z._set_property..fget..on_update)r�Zparse_set_headerrg)rr^)
r`)
rrrU
� s
z_set_property..fget)
rs
)
r�)r`rs
rU
r)
r`r� _set_property� s
 ru
c@s�eZ
dZd
Zedddddg�
Zd$dd �
Zd%dd�
Zd'dd�
Zdd�Z dd�Z dd�Zeddd�Z eddd�Zeddd�Zeddd�Zeddd�Zeddd�Zedd d�Zed!d"��
Zejd#d"��
Zee�
ZdS)(�WWWAuthenticatez5Provides simple access to `WWW-Authenticate` headers.�domainre
rj
rd
rk
NcCs&tj
||pf�
|
r|
|d
<||_dS)N� __auth_type__)rrBr^)rra
rzr^rrrrB� s



zWWWAuthenticate.__init__�authentication requiredcCs0tj
|�

tj|d
|
d��
|jr,|j|�

dS)z*Clear the auth info and enable basic auth.rl
)rx
rd
N)rrQrOr^)rrd
rrr� set_basic� s


zWWWAuthenticate.set_basic�authFcCsjd
|
|tj
|�
d�}|r d|d<|dk r0||d<|dk r@||d<tj|�

tj||�
|jrf|j|�

dS)z+Clear the auth info and enable digest auth.ro
)rx
rd
re
rk
�TRUE�staleNrj
� algorithm)r�r
rrQrOr^)rrd
re
rk
rj
r~
r}
r�rrr� set_digest� s











zWWWAuthenticate.set_digestc
sTt��
}
|
j
d
d�pd}�f
dd�|
j�D�
}djdd�|D�
�
}|j��d |��S) z9Convert the stored values into a WWW-Authenticate header.rx
Nrl
c
3s*|]"\}
}|
tj
||
�jkd�fV
qd
S))
Zallow_tokenN)r�r1
�_require_quoting)rkrlr)
rrrrns
z,WWWAuthenticate.to_header..z, c
Ssg|]\}
}|
�d|���qS)
r
r)rkrlrrrrr�sz-WWWAuthenticate.to_header..r
)rr4rr�r�)rr�ra
Zkv_itemsZ kv_stringr)
rrr�s


zWWWAuthenticate.to_headerc


Cs|j�S)
N)
r�)
rrrrr�s
zWWWAuthenticate.__str__c

Csd
t|�
j
�d|j��d�S)Nr
r
r
)rrr�)
rrrrr>s
zWWWAuthenticate.__repr__rx
zZThe type of the auth mechanism. HTTP currently specifies ``Basic`` and ``Digest``.)
rs
a
A string to be displayed to users so they know which username and password to use. This string should contain at least the name of the host performing the authentication and might additionally indicate the collection of users who might have access.z�A list of URIs that define the protection space. If a URI is an absolute path, it is relative to the canonical root URL of the server being accessed.z� A server-specified data string which should be uniquely generated each time a 401 response is made. It is recommended that this string be base64 or hexadecimal data.a
A string of data, specified by the server, which should be returned by the client unchanged in the Authorization header of subsequent requests with URIs in the same protection space. It is recommended that this string be base64 or hexadecimal data.r~
a
A string indicating a pair of algorithms used to produce the digest and a checksum. If this is not present it is assumed to be "MD5". If the algorithm is not understood, the challenge should be ignored (and a different one used, if there is more than one).zIA set of quality-of-privacy directives such as auth and auth-int.c
Cs"|jd
�
}
|
dk r|
j
�dkSdS)z}A flag, indicating that the previous request from the client was rejected because the nonce value was stale. r}
N�true)rgr�)r�valrrrr}
Qs

zWWWAuthenticate.stalecCs*|
dkr|jd
d�
n|
rdnd|d
<dS)Nr}
r|
�FALSE)
r4)rrrrrr}
Zs
)NNN)
ry
�
r{
)r�
NNF)rr8r9r:rJr�
rBrz
r
r�r�r>rt
rrd
ru
rw
re
rj
r~
rk
r�r}
�setterr
rrrrrv
� s@
   






 rv
c@s�eZ
dZd
Zddd�
Zdd�Zedd��
Zed d ��
Zedd��
Z ed d��
Z ddd�
Zdd�Zdd�Z dd�Zdd�Zdd�ZdS)r�a@
The :class:`FileStorage` class is a thin wrapper over incoming files. It is used by the request object to represent uploaded files. All the attributes of the wrapper stream are proxied by the file storage so it's possible to do ``storage.read()`` instead of the long form ``storage.stream.read()``. NcCs�||_|
pt
�|_|dkrnt|
d
d�}t|�
}|rV|d|d�
krV|d |d�
krVd}t|t�rn|jt�d�}||_ |dkr�t �}||_|dk r�||d<|dk r�t|�
|d<dS) Nr`r
r
rr
r�zContent-TypezContent-Lengthr7) r`r�streamr\r rr�r�rr�r�r,
r�)rr�
r�r`r��content_lengthr,
�
srrrrBls" 



$








zFileStorage.__init__c

Cst|d
�st
j|j�
|_dS)N�_parsed_content_type)�hasattrr�Zparse_options_headerr�r�
)
rrrr�_parse_content_type�s

zFileStorage._parse_content_typec

Cs|jj
d
�
S)z;The content-type sent in the header. Usually not availablezcontent-type)r,
rg)
rrrrr��szFileStorage.content_typec

Cst|j
jd
�
pd�
S)z=The content-length sent in the header. Usually not availablezcontent-lengthr
)r�r,
rg)
rrrrr�
�szFileStorage.content_lengthc

Cs|j�
|j
d
j�S)a
Like :attr:`content_type`, but without parameters (eg, without charset, type etc.) and always lowercase. For example if the content type is ``text/HTML; charset=utf-8`` the mimetype would be ``'text/html'``. .. versionadded:: 0.7 r
)r�
r�
r�)
rrrr�mimetype�s 
zFileStorage.mimetypec

Cs|j�
|j
d
S)z�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.7 r)r�
r�
)
rrrr�mimetype_params�s
zFileStorage.mimetype_params�@c Cs`d
dlm
}
d}t|
d�r"t|
�
}
t|
t�r:t|
d�}
d}z||j|
|�
Wd|rZ|
j�
XdS)anSave the file to a destination path or file object. If the destination is a file object you have to close it yourself after the call. The buffer size is the number of bytes held in memory during the copy process. It defaults to 16KB. For secure file saving also have a look at :func:`secure_filename`. :param dst: a filename, :class:`os.PathLike`, or open file object to write to. :param buffer_size: Passed as the ``length`` parameter of :func:`shutil.copyfileobj`. .. versionchanged:: 1.0 Supports :mod:`pathlib`. r
)
�copyfileobjF� __fspath__�wbTN) �shutilr�
r�
rrr�r�r�
�close)r�dst�buffer_sizer�
Z close_dstrrr�save�s




zFileStorage.savec

Cs(y|jj
�
Wntk r"


YnXd
S)z&Close the underlying file if possible.N)r�
r�
� Exception)
rrrrr�
�s


zFileStorage.closec

Cs t|j
�
S)
N)r
r�)
rrrrr3
�s
zFileStorage.__bool__cCsByt|j
|
�Stk r<


t|j
d
�r6t|j
j|
�S�YnXdS)N�_file)r\r�
�AttributeErrorr�
r�
)rr`rrr�__getattr__�s




zFileStorage.__getattr__c

Cs t|j
�
S)
N)r�r�
)
rrrrrt�s
zFileStorage.__iter__c

Cs"d
t|�
j
�d|j�d|j�d�S)Nr
z: z (z)>)rrr�r�)
rrrrr>�s
zFileStorage.__repr__)NNNNNN)
r�
)rr8r9r:rBr�
r�r�r�
r�
r�
r�
r�
r3
r�
rtr>rrrrr�ds$




 !r�)
r�)
N)
N)Mrq
r
r��rer��collections.abcrrrir�ior� itertoolsr�osrrE
r Z _internalr r� filesystemrrrr rr;r?rTrbrr]rdrhrr�r�r�r�r�r�r�r�r�r�r�r�r��compiler�r�r�r
r

r
r
r
r
r
r
r
r#
r$
r&
r(
r4
rC
rF
rX
rO
r`
rt
ru
rv
r�r�rrrr�
s�












52 ")N 6V53!- B 6  \ L XK:j  |