�
o�Dac@s<dZd
dl
Z
d
dlZd
dlZd
dlmZ
d
dlmZ
ddlm	Z	
ddl
mZ
ddl
mZ
dd	l
m
Z

dd
l
mZ
ddl
mZ
ddl
mZ
dd
l
mZ
ddl
mZ
ddl
mZ
ddl
mZ
ddl
mZ
ddl
mZ
ddl
mZ
ddlmZ
ddlmZ
d�Zd�Zd�Zdef
d��YZ de e!fd��YZ"def
d��YZ#de#f
d ��YZ$d!ef
d"��YZ%d#e&f
d$��YZ'd%e#e'fd&��YZ(d'ef
d(��YZ)ed)d*d+d,d-g�
d.e'f
d/��Y�
Z*d0ef
d1��YZ+ed)d*d+d,d-g�
d2e*f
d3��Y�
Z,d4�Z-d5�Z.ed)d*d+g�
d6ef
d7��Y�
Z/d8ef
d9��YZ0d:e0e/fd;��YZ1ed)d*d+d,d-g�
d<e$e*fd=��Y�
Z2d>e*f
d?��YZ3d@e#e&fdA��YZ4dBe$e*fdC��YZ5dDe$e,fdE��YZ6ed*g
�
dFe"f
dG��Y�
Z7ej8dH�
Z9dI�Z:dJe7f
dK��YZ;ej8dL�
Z<dM�Z=dNe7f
dO��YZ>dPe7f
dQ��YZ?dR�Z@dSe%e&fdT��YZAdUe#eAfdV��YZBdWeAf
dX��YZCeDe@�
eA_@dY�ZEdZe%e&fd[��YZFd\e%e&fd]��YZGd^ejHf
d_��YZId`ejJejKfda��YZLdbef
dc��YZMddef
de��YZNdfef
dg��YZOdhe#e&fdi��YZPdje%e&fdk��YZQdlef
dm��YZRddnlSmTZT
ddolSmUZU
ddplSmVZV
ddqlSmWZW
ddrlSmXZX
ddslSmYZY
ddtlSmZZZ
ddulSm[Z[
ddvlSm\Z\
ddwlSm]Z]
ddxlSm^Z^
dS(ys�
    werkzeug.datastructures
    ~~~~~~~~~~~~~~~~~~~~~~~

    This module provides mixins and classes with an immutable interface.

    :copyright: 2007 Pallets
    :license: BSD-3-Clause
i����N(
tdeepcopy(
trepeati
(
t
exceptions(
tBytesIO(
tcollections_abc(
tfspath(
t
integer_types(
t	iteritems(
titerkeys(
t	iterlists(
t
itervalues(
tmake_literal_wrapper(
tPY2(
tstring_types(
t	text_type(
t	to_native(
t_missing(
tget_filesystem_encodingc

Cstd
|j
j�
�
dS(Ns%r objects are immutable(t	TypeErrort	__class__t__name__(
tself((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytis_immutable#s
c
cs�t|t
�r4x�t|d
t�

D]}
|
V
q"Wn�t|t�r�xrt|�
D]K\}}t|ttf�r�x'|D]}||fV
qxWqP||fV
qPWnx|D]}
|
V
q�WdS(syIterates over the items of a mapping yielding keys and values
    without dropping any from more complex structures.
    tmultiN(t
isinstancet	MultiDictRtTruetdictttupletlist(tmappingtitemtkeytvaluet
v((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytiter_multi_items's









c
s8ts
d
�Sd��d��
��
�fd�}
|
S(Nc


Ss|S(
N((
t
x((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt<lambda><tcsVd
�}d��
��
fd�}||_d|�f|_
t|||�
dS(Nsview%ssview_%sc
st|��
|
|�S(
N(
t	ViewItems(Rt
atkw(tnamet	repr_name(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
viewmethodBs
s$`%s()` object providing a view on %s(Rt__doc__tsetattr(tclsR*tviewmethod_nameR,((R*R+s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
setviewmethod>s



	



cs\t||
��t
|d
|
��
�f
d�}|
|_d|
|_t
||
|�
dS(Nsiter%sc
st�||
|�
�
S(
N(
R(RR(R)(
t
itermethod(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
listmethodPs
s+Like :py:meth:`iter%s`, but returns a list.(tgetattrR.RR-(R/R*R3((
R2s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
setitermethodLs

	


c
s/x(�D] }
�
||
�
�||
�
qW|S(
N((R/R*(tnamesR5R1(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytwrapWs





(
R(R6R7((R6R5R1s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytnative_itermethods:s

		tImmutableListMixincBs�eZ
dZd
Zd
�Zd�Zd�Zd�ZeZ	d�Z
d�ZeZd�Z
d�Zd	d
�
Zd�Zd
d
d
d�ZRS(sOMakes a :class:`list` immutable.

    .. versionadded:: 0.5

    :private:
    c
Cs3|jdk	r|jStt|�
�
}
|_|
S(
N(t_hash_cachetNonethashR(Rtrv((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__hash__js



cCst|�
t
|�
f
fS(
N(ttypeR(Rtprotocol((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
__reduce_ex__ps
cCst|�

dS(
N(
R(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__delitem__ss
cCst|�

dS(
N(
R(Rtother((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__iadd__vs
cCst|�

dS(
N(
R(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__setitem__{s
cCst|�

dS(
N(
R(RR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytappend~s
cCst|�

dS(
N(
R(Rtiterable((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytextend�s
cCst|�

dS(
N(
R(RtposR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytinsert�s
i����cCst|�

dS(
N(
R(Rtindex((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytpop�s
c

Cst|�

dS(
N(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytreverse�s
cCst|�

dS(
N(
R(RtcmpR RM((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytsort�s
N(Rt
__module__R-R;R:R>RARBRDt__imul__RERFtremoveRHRJRLRMRO(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR9`s									t
ImmutableListc
BseZ
dZd
�ZRS(sJAn immutable :class:`list`.

    .. versionadded:: 0.5

    :private:
    c

Csd
|jj
tj|�
fS(Ns%s(%s)(RRRt__repr__(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�s
(RRPR-RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRS�stImmutableDictMixincBs�eZ
dZdZedd
�
�
Zd�Zd�Zd�Z	dd�
Z
d�Zdd�
Zd�Z
d	�Zd
�Zd�ZRS(
sOMakes a :class:`dict` immutable.

    .. versionadded:: 0.5

    :private:
    cCs8t||�j
|�
}|jt|
t|�
��

|S(
N(tsupert__new__t__init__tzipR
(R/tkeysR!tinstance((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytfromkeys�s

cCst|�
t
|�
f
fS(
N(R?R(RR@((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRA�s
c

Cs
t|�
S(
N(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_iter_hashitems�s
c
Cs9|jdk	r|jStt|j��
�
}
|_|
S(
N(R:R;R<t	frozensetR](RR=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR>�s



cCst|�

dS(
N(
R(RR tdefault((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
setdefault�s
c
Ost|�

dS(
N(
R(Rtargstkwargs((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytupdate�s
cCst|�

dS(
N(
R(RR R_((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRL�s
c

Cst|�

dS(
N(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytpopitem�s
cCst|�

dS(
N(
R(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRE�s
cCst|�

dS(
N(
R(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRB�s
c

Cst|�

dS(
N(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytclear�s
N(RRPR-R;R:tclassmethodR\RAR]R>R`RcRLRdRERBRe(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRU�s
							tImmutableMultiDictMixincBsPeZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zdd�
Z
RS(	sTMakes a :class:`MultiDict` immutable.

    .. versionadded:: 0.5

    :private:
    cCs%t|�
t
t|d
t�

�
f
fS(NR(R?RRR(RR@((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRA�s
c

Cst|d
t
�

S(NR(RR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR]�s
cCst|�

dS(
N(
R(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytadd�s
c

Cst|�

dS(
N(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytpopitemlist�s
cCst|�

dS(
N(
R(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytpoplist�s
cCst|�

dS(
N(
R(RR tnew_list((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytsetlist�s
cCst|�

dS(
N(
R(RR tdefault_list((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytsetlistdefault�s
N(RRPR-RAR]RhRiRjRlR;Rn(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRg�s						tUpdateDictMixincBsteZ
dZd	Zd
�Zd	d�
Zed�
Zed�
Z	ed�
Z
ed�
Zed�
Zed�
Z
[RS(
sbMakes dicts call `self.on_update` on modifications.

    .. versionadded:: 0.5

    :private:
    c
s�f
d
�}
�|
_|
S(Nc
sDtt
t|���|
|�}|jdk	r@|j|�

n|S(
N(R4RVRot	on_updateR;(RRaR)R=(
R*(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytoncall�s
!


(
R(R*Rq((
R*s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytcalls_update�s
	
cCsP|
|k}tt
|�j|
|�}|rL|jdk	rL|j|�

n|S(
N(RVRoR`RpR;(RR R_tmodifiedR=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR`
s





cCsw|
|k}|tkr3t
t|�j|
�
}nt
t|�j|
|�}|rs|jdk	rs|j|�

n|S(
N(RRVRoRLRpR;(RR R_RsR=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRL

s





RERBReRdRcN(RRPR-R;RpRrR`RRLRERBReRdRc(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRo�s	






tTypeConversionDictcBseZ
dZddd
�ZRS(s�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
    cCs`y||
}Wntk
r"


|SX|d
k	r\y||�
}Wq\tk
rX


|}q\Xn|S(s�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(tKeyErrorR;t
ValueError(RR R_R?R=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytget$
s











N(RRPR-R;Rw(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRt
stImmutableTypeConversionDictc
Bs eZ
dZd
�Zd�ZRS(spWorks like a :class:`TypeConversionDict` but does not support
    modifications.

    .. versionadded:: 0.5
    c

Cs
t|�
S(
s�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`).
        (
Rt(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytcopyL
sc


Cs|S(
N((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__copy__S
s
(RRPR-RyRz(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRxE
s	R'c
Bs,eZ
d�Zd
�Zd�Zd�ZRS(cOs1|
|_||_
||_||_||_dS(
N(t_ViewItems__multi_dictt_ViewItems__methodt_ViewItems__repr_namet
_ViewItems__at_ViewItems__kw(Rt
multi_dicttmethodR+R(R)((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRXX
s

	
	
	
	
c

Cs"t|j
|j�|j|j�S(
N(R4R{R|R~R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__get_items_
s
c

Csd
|jt
|j��
fS(Ns%s(%r)(R}Rt_ViewItems__get_items(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTb
s
c

Cst|j
��
S(
N(titerR�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__iter__e
s
(RRPRXR�RTR�(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR'W
s
			RZtvaluestitemstlistst
listvaluesRcBs
eZ
dZdd
�
Zd�Zd�Zd�Zd�Zd�Z	dd�
Z
d�Zdd	�
Zdd
�
Z
ed�
Zd�Zd
�ZeZd�Zd�Zd�Zdd�
Zed�
Zd�Zed�
Zd�Zd�Zd�Zd�Zd�Z d�Z!RS(sA :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`.
    cCs
t|
t
�r2tj|d
�t|
�
D�
�
n�t|
t�r�i}xit|
�
D][\}}t|ttf�r�t|�
dkr�qTnt|�
}n	|g
}|||<qTWtj||�
nLi}x3|
p�dD]%\}}|j	|g�j
|�

q�Wtj||�
dS(Nc
ss"|]\}
}|
|fV
qdS(
N((t.0t
kt
l((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>�
si((RRRRXR	RRRtlenR`RF(RRttmpR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�
s 

#






	




c

Cst|j
��
S(
N(RR�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__getstate__�
s
cCs!tj
|�

tj||
�
dS(
N(RReRc(RR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__setstate__�
s


cCsN|
|kr;tj
||
�}t|�
d
kr;|d
Sntj|
�
�
dS(s�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.
        iN(Rt__getitem__R�RtBadRequestKeyError(RR tlst((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��
s




cCstj
||
|g
�
d
S(s�Like :meth:`add` but removes an existing key first.

        :param key: the key for the value.
        :param value: the value to set.
        N(RRE(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRE�
scCs tj
||
g�j|�

d
S(s�Adds a new value for the key.

        .. versionadded:: 0.6

        :param key: the key for the value.
        :param value: the value to add.
        N(RR`RF(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRh�
scCs�ytj
||
�}Wntk
r*


gSX|d
krAt|�
Sg}x9|D]1}y|j||�
�

WqNtk
r~


qNXqNW|S(sZReturn 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 as `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(RR�RuR;RRFRv(RR R?R=tresultR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytgetlist�
s















cCstj
||
t|�
�
d
S(sRemove 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(RRER(RR Rk((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRl�
scCs'|
|kr|||
<n
||
}|S(
sG
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`.
        ((RR R_((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR`�
s



cCsJ|
|kr4t|pd
�
}t
j||
|�
nt
j||
�}|S(s�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`
        ((RRRER�(RR Rm((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRns



ccsXxQtt
|�D]@\}}|
rAx+|D]}||fV
q)Wq||d
fV
qWdS(s
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.
        iN(RR(RRR R�R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR� s




c
cs5x.tt
|�D]\}
}|
t|�
fV
qWd
S(suReturn a iterator of ``(key, values)`` pairs, where values is the list
        of all values associated with the key.N(RRR(RR R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�/s
c

Cs
tt
|�S(
N(RR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRZ6s
c
cs'x tt
|�D]}
|
d
V
qWdS(sAReturns an iterator of the first value on every key's value list.iN(R
R(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�;s
c

Cs
tt
|�S(
s
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
        (R
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�@s	c

Cs
|j|�
S(
s%Return a shallow copy of this object.(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRyKscCs"|jt
|jd
t�
|
��
S(s"Return a deep copy of this object.tflat(RRtto_dicttFalse(Rtmemo((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyROscCs&|
rtt
|�
�
St|j��
S(
s�
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`
        (RRR�(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�Ss


cCs4x-t|
�
D]\}}t
j|||�
q
Wd
S(s�
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(R#RRh(Rt
other_dictR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRcas
cCsyyBtj
||
�}t|�
d
kr9tj|
�
�
n|d
SWn0tk
rt


|tk	rb|Stj|
�
�
n
XdS(s�
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.
        iN(RRLR�RR�RuR(RR R_R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRLvs






c
Cs�yQtj
|�
}
t|
d
�
dkr:tj|
�
�
n|
d|
d
dfSWn)tk
r|
}
tj|jd�
�
n
XdS(sPop an item from the dict.i
iN(RRdR�RR�RuRa(RRt
e((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRd�s



cCstj
||
g�S(
s�Pop the list for a key from the dict.  If the key is not in the dict
        an empty list is returned.

        .. versionchanged:: 0.5
           If the key does no longer exist a list is returned instead of
           raising an error.
        (RRL(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRj�sc
CsAytj
|�
SWn)tk
r<
}

tj|
jd
�
�
n
XdS(s*Pop a ``(key, list)`` tuple from the dict.iN(RRdRuRR�Ra(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRi�s


c


Cs
|j�S(
N(
Ry(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRz�s
cCs|jd
|
�
S(NR�(
R(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__deepcopy__�s
c

Cs&d
|jj
tt|dt�

�
fS(Ns%s(%r)R(RRRRR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�s
N("RRPR-R;RXR�R�R�RERhR�RlR`RnR�R�R�RZR�R�R�RyRRR�RcRRLRdRjRiRzR�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRi
s8(					
									
			t_omd_bucketcBs&eZ
dZdZd�Zd�ZRS(s
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).
    tprevR R!tnextcCsm|
j|_
||_||_d|_|
jdkrB||
_n|
jdk	r`||
j_n||
_dS(
N(t_last_bucketR�R R!R;R�t
_first_bucket(RtomdR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s

	
	
	



cCsv|jr|j
|j_
n|j
r6|j|j
_n|
j|krT|j
|
_n|
j|krr|j|
_ndS(
N(R�R�R�R�(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytunlink�s
	

	




(R�R R!R�(RRPR-t	__slots__RXR�(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s	tOrderedMultiDictcBs�eZ
dZdd
�
Zd�ZdZd�Zd�Zd�Z	d�Z
d�Zd�Zd	�Z
d
�ZeZd�Zed�
Zd
�Zd�Zd�Zdd�
Zd�Zdd�
Zd�Zd�Zed�
Zd�Zd�ZRS(sNWorks 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.
    cCs@tj
|�

d|_|_|
dk	r<tj||
�
ndS(
N(RRXR;R�R�R�Rc(RR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s




c
Cs!
t|
t
�stSt|
t�r�t|d
t�

}t|
d
t�

}yIxB|D]:\}}t|�
\}}||ks�||krPtSqPWWntk
r�


tSXyt|�

Wntk
r�


tSXtSt	|�
t	|
�
kr�tSx3t
|�
D]%\}}	|
j|�
|	kr�tSq�WtS(NR(RRtNotImplementedR�RRR�R�t
StopIterationR�R	R�(
RRCtiter1titer2tk1tv1tk2tv2R R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__eq__�s.
























cCs|j|
�
S(
N(
R�(RRC((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__ne__	s
cCs%t|�
t
t|d
t�

�
f
fS(NR(R?RRR(RR@((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRAs
c

Cstt
|d
t�

�
S(NR(RRR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s
cCs8tj
|�

x$|
D]\}}|j||�
qWdS(
N(RReRh(RR�R R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s



cCs6|
|kr#tj
||
�d
jStj|
�
�
dS(Ni(RR�R!RR�(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s


cCs!|j|
�

|j
|
|�
dS(
N(RjRh(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyREs


cCs|j|
�

dS(
N(
RL(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRB s
c

Csd
�t|�
D�
S(Nc
ss|]\}
}|
V
qdS(
N((R�R R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>$s(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRZ#s
c

Csd
�t|�
D�
S(Nc
ss|]\}
}|V
qdS(
N((R�R R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>)s(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�(s
ccs�|j}|
r?x�|dk	r;|j|jfV
|j}qWnXt�}xL|dk	r�|j|kr�|j|j�

|j|jfV
n|j}qKWdS(
N(R�R;R R!R�tsetRh(RRtptrt
returned_keys((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�+s
	



	




c
csnt�}
|j
}xU|dk	ri|j|
kr]|j|j|j�
fV
|
j|j�

n|j}qWdS(
N(R�R�R;R R�RhR�(RR�R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�9s
	
	




c
cs&xt|�
D]\}
}|V
q
WdS(
N(
R	(Rt_keyR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�Bs

cCs,tj
||
g�jt||
|��

dS(
N(RR`RFR�(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRhFs
cCs�ytj
||
�}Wntk
r*


gSX|dkrQg|D]}|j^q>Sg}x<|D]4}y|j||j�
�

Wq^tk
r�


q^Xq^W|S(
N(RR�RuR;R!RFRv(RR R?R=R$R�R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�Is















cCs2|j|
�

x|D]}|j
|
|�
qWdS(
N(RjRh(RR RkR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRlXs




cCstd
�
�
dS(Ns5setlistdefault is unsupported for ordered multi dicts(
R(RR Rm((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRn]s
cCs4x-t|
�
D]\}}t
j|||�
q
WdS(
N(R#R�Rh(RRR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRc`s

cCsMtj
||
d
�}x|D]}|j|�

qWg|D]}|j^q:S(N((RRLR�R!(RR tbucketstbucketR$((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRjds




cCsrytj
||
�}Wn0tk
rH


|tk	r6|Stj|
�
�
n
Xx|D]}|j|�

qPW|d
jS(Ni(RRLRuRRR�R�R!(RR R_R�R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRLjs










c
Cstytj
|�
\}
}Wn)tk
rD
}
tj|jd
�
�
n
Xx|D]}|j|�

qLW|
|d
jfS(Ni(RRdRuRR�RaR�R!(RR R�R�R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRdus







c
Cs�ytj
|�
\}
}Wn)tk
rD
}
tj|jd
�
�
n
Xx|D]}|j|�

qLW|
g|D]}|j^qmfS(Ni(RRdRuRR�RaR�R!(RR R�R�R�R$((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRi~s







N(RRPR-R;RXR�R>R�RAR�R�R�RERBRZR�R�R�R�R�R�RhR�RlRnRcRjRRLRdRi(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s4																			cCs#t|t
d
�|
j�D�
�
�S(Nc
ss-|]#\}
}|
jdd
�|fV
qdS(t
_t
-N(
treplace(R�R�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>�s(tdump_options_headerRR�(R!R)((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_options_header_vkw�s

c

CsCt|t
�r!|jd
�
}nt|t�s?t|�
}n|S(Nslatin-1(RtbytestdecodeR(
R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_unicodify_header_value�s





tHeaderscBsg
eZ
dZd"d
�
Zed�
Zd�Zd"Zd�Z	d"d"ed�Z
d"ed�Zd�Zed�
Z
ed	�
Zd
�Zd�Zed�
Zd
�Zd"ed�Zd�Zd�ZeZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%d�Z&d�Z'd �Z(d!�Z)RS(#s�An object that stores some headers.  It has a dict-like interface
    but is ordered and can store the same keys multiple times.

    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.
    cCsQg|_|
dk	rMt|
ttf�r=|jj|
�

qM|j|
�

ndS(
N(t_listR;RRR�RH(Rtdefaults((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s

	


cCs�|sFt|
t
�r |j|
St|
t�rF|j|j|
�
Snt|
t�sgtj|
�
�
n|
j�}x-|jD]"\}}|j�|kr}|Sq}W|r�t	��
ntj|
�
�
dS(
N(
RRR�tsliceRR
RR�tlowerRu(RR t	_get_modetikeyR�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s












cCsId
�}|
j|jkoHt
t||
j��
t
t||j��
kS(Nc

Ss|d
j�f
|dS(Nii
(
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytlowered�s
(RR�tmapR�(RRCR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s
	

cCs|j|
�
S(
N(
R�(RRC((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s
cCs}y|j|
d
t
�

}Wntk
r-


|SX|rF|jd�
}n|dkrV|Sy||�
SWntk
rx


|SXdS(s]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

        If a headers object is bound you must not add unicode strings
        because no encoding takes place.

        .. 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 unicode strings.
        R�tlatin1N(R�RRutencodeR;Rv(RR R_R?tas_bytesR=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRw�s












cCs�|
j�}g}x�|D]|\}}|j�|kr|rO|j
d
�
}n|dk	r�y||�
}Wq�tk
r�


qq�Xn|j|�

qqW|S(s�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 as
        :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 unicode strings.
        R�N(R�R�R;RvRF(RR R?R�R�R�R�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s













cCs
|j|
�
S(
s�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.
        (
R�(RR*((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytget_all%sccs;x4|D],\}}|
r(|j�}n||fV
qWdS(
N(
R�(RR�R R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�-s



ccs)x"t||
�D]\}}|V
qWdS(
N(
R(RR�R R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRZ3s

c
cs&xt|�
D]\}
}|V
q
WdS(
N(
R(RR�R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�7s

c
Os�t|
�
d
kr+t
dt|
�
�
�
n|
rex1t|
d�
D]\}}|j||�
qBWnx*t|�
D]\}}|j||�
qrWdS(s�
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``.
        i
s+update expected at most 1 arguments, got %diN(R�RR#Rh(RRaRbR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRH;s



cCs�|r)t|
t
tf�r)|j|
=dS|
j�}
g}x?|jD]4\}}|j�|
krE|j||f�

qEqEW||j(dS(
N(RRR�R�R�RF(RR t_index_operationtnewR�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRBSs









cCs|j|
d
t
�

S(sBRemove a key.

        :param key: The key to be removed.
        R�(RBR�(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRR^scCs~|
d
kr|j
j�St|
t�r8|j
j|
�
Sy||
}|j|
�

Wn$tk
ry


|tk	rs|S�n
X|S(sQ
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;R�RLRRRRRuR(RR R_R=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRLes	













c


Cs
|j�S(
s7Removes a key or index and returns a (key, value) item.(
RL(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRd{scCs0y|j|
d
t
�


Wntk
r+


tSXt
S(sCheck if a key is present.R�(R�RRuR�(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__contains__s





c

Cs
t|j
�
S(
sYield ``(key, value)`` tuples.(R�R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��sc

Cs
t|j
�
S(
N(R�R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__len__�s
cKsW|rt||�}nt
|
�
}
t
|�
}|j|�

|jj|
|f�

d
S(sAdd 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�t_validate_valueR�RF(RR�t_valueR)((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRh�s





cCsIt|
t
�std
�
�
nd|
ks6d|
krEtd�
�
ndS(NsValue should be unicode.u

u

sGDetected newline in header value.  This is a potential security problem(RRRRv(RR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s





cKs|j|
||�
d
S(s�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(
Rh(RR�R�t_kw((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
add_header�sc


Cs|j2d
S(sClears all headers.N(
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRe�sc
Ks
|rt||�}nt
|
�
}
t
|�
}|j|�

|js`|jj|
|f�

d
St|j�
}|
j�}xct|�
D];\}\}}|j�|kr�|
|f|j|<Pq�q�W|jj|
|f�

d
Sg|D]"}	|	dj�|kr�|	^q�|j|d)d
S(s0Remove 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.
        Nii
(R�R�R�R�RFR�R�t	enumerate(
RR�R�R)tlistiterR�tidxtold_keyt
_old_valuet
t((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s"





	








cCs]|rLt|�
}|j
|
t|�
�
x.|D]}|j|
|�
q/Wn
|j|
�

d
S(s�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�RhRR(RR R�tvalues_iterR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRl�s



cCs(|
|kr||
S|j|
|�
|S(
s*
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�(RR R_((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR`�s	

cCs,|
|kr|j|
|�
n|j
|
�
S(
s�
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
        (RlR�(RR R_((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRn�s
cCs�t|
t
tf�r�t|
t�r0|g
}ng|D]$\}}t|�
t|�
f^q7}g|D]\}}|j|�
^qh
t|
t�r�|d
|j|
<q�||j|
<n|j|
|�
dS(s=Like :meth:`set` but also supports index/slice based setting.iN(RR�RR�R�R�R�(RR R!R�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyREs


.&

c
Osm
t|
�
d
kr+t
dt|
�
�
�
n|
r
|
d}t|ttf�r�x�|j�D]}|j||j|�
�
q]Wq
t|t�r�x|t	|�
D]D\}}t|t
tf�r�|j||�
q�|j||�
q�Wq
x'|D]\}}|j||�
q�WnxRt	|�
D]D\}}t|t
tf�rU
|j||�
q!
|j||�
q!
WdS(s�
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
        i
s+update expected at most 1 arguments, got %diN(
R�RRR�RRZRlR�RRRRR�(RRaRbRR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRc#s$





 






c
CsBtr8g|D]'\}
}t
|
�
|jd
�
f^q
St|�
S(s�Convert the headers into a list suitable for WSGI.

        The values are byte strings in Python 2 converted to latin1 and unicode
        strings in Python 3 for the WSGI server to encode.

        :return: list
        R�(RRR�R(RR�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytto_wsgi_listIs
2
c

Cs|j|j
�
S(
N(RR�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRyUs
c


Cs
|j�S(
N(
Ry(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRzXs
c
CsTg}
x1|j�D]#\}}|
j
d
||f�

qW|
j
d�

dj|
�
S(s9Returns formatted headers suitable for HTTP transmission.s%s: %ss
(R�RFtjoin(RtstrsR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__str__[s





c

Csd
|jj
t|�
fS(Ns%s(%r)(RRR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTcs
N(*RRPR-R;RXR�R�R�R>R�RwR�R�R�RZR�RHRRBRRRRLRdR�thas_keyR�R�RhR�R�ReR�RlR`RnRERcR�RyRzR�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��sH 		'														#					&				tImmutableHeadersMixincBs�eZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zdd�
Z
d
�Zd�Zd�ZRS(s�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:
    cKst|�

dS(
N(
R(RR Rb((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRBqs
cCst|�

dS(
N(
R(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyREts
cCst|�

dS(
N(
R(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�ws
cCst|�

dS(
N(
R(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRlzs
cCst|�

dS(
N(
R(RR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRh}s
cCst|�

dS(
N(
R(RR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s
cCst|�

dS(
N(
R(RR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRR�s
c
Ost|�

dS(
N(
R(RRaRb((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRH�s
c
Ost|�

dS(
N(
R(RRaRb((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRc�s
cCst|�

dS(
N(
R(RRIR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRJ�s
i����cCst|�

dS(
N(
R(RRK((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRL�s
c

Cst|�

dS(
N(
R(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRd�s
cCst|�

dS(
N(
R(RR R_((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR`�s
cCst|�

dS(
N(
R(RR R_((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRn�s
(RRPR-RBRER�RlRhR�RRRHRcRJRLRdR`Rn(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�gs												tEnvironHeaderscBsMeZ
dZd
�Zd�ZdZed�
Zd�Z	d�Z
d�ZRS(s�
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(
tenviron(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s
cCs|j|
jkS(
N(
R�(RRC((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s
cCsht|
t
�st|
�
�
n|
j�jd
d�}
|
dkrSt|j|
�
St|jd|
�
S(NR�R�tCONTENT_TYPEtCONTENT_LENGTHtHTTP_(R�R�(RR
RutupperR�R�R�(RR R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s




c

Cstt
t|�
�
�
S(
N(R�RR�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��sc
cs�x�t|j
�
D]�\}
}|
jd
�
ra|
d	kra|
djdd�j�t|�
fV
q|
d
kr|r|
jdd�j�t|�
fV
qqWdS(NR�tHTTP_CONTENT_TYPEtHTTP_CONTENT_LENGTHiR�R�R�R�(R�R�(R�R�(RR�t
startswithR�ttitleR�(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s



	

c

Cstd
|j
j�
�
dS(Nscannot create %r copies(RRR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRy�s
N(RRPR-RXR�R;R>R�R�R�R�Ry(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s			
		
tCombinedMultiDictcBs�eZ
dZd
�Zdd�
Zed��
Zd�Zddd�Z	dd�
Z
d�Zd�ZeZ
ed	�
Zd
�Zd�Zd�Zd
�Zed�
Zd�Zd�ZeZd�ZRS(s>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?tdicts(RR@((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRA�s
cCs|
p	g|_dS(
N(
R�(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s
c

Cstd
|j
�
�
dS(Ns&cannot create %r instances by fromkeys(RR(
R/((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR\�scCs;x%|jD]}|
|kr
||
Sq
Wt
j|
�
�
dS(
N(R�RR�(RR t
d((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s



cCsdx]|jD]R}|
|kr
|dk	rTy|||
�
SWqTtk
rP


q
qTXn||
Sq
W|S(
N(R�R;Rv(RR R_R?R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRw�s










cCs7g}x*|jD]}|j
|j|
|��

qW|S(
N(R�RHR�(RR R?R=R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s



c
Cs4t�}
x$|j
D]}|
jt|�
�

qW|
S(
s
This function exists so __len__ can be implemented more efficiently,
        saving one list creation from an iterator.

        Using this for Python 2's ``dict.keys`` behavior would be useless since
        `dict.keys` in Python 2 returns a list, while we have a set here.
        (R�R�RcR(RR=R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
_keys_impls	


c

Cst|j
��
S(
N(R�R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRZs
ccs|t�}xl|j
D]a}xXt||
�D]G\}}|
rI||fV
q)||kr)|j|�

||fV
q)q)WqWdS(
N(R�R�RRh(RRtfoundR�R R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s
	







c
cs&xt|�
D]\}
}|V
q
WdS(
N(
R(RR�R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�#s

c
CsZi}
xG|jD]<}x3t
|�
D]%\}}|
j|g�j|�

q#WqWt|
�
S(
N(R�R	R`RHR(RR=R�R R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�'s




!
c

Csd
�|j�D�
S(Nc
ss|]}
|
dV
qd
S(i
N((R�R$((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>/s(
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�.s
c

Cs
t|�
S(
s0
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(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRy1s
cCs:i}x-t|j
�
D]}|j|j|
�
�

qW|S(
s�
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`
        (treversedR�RcR�(RR�R=R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�=s



c

Cst|j
��
S(
N(R�R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�Ls
cCs(x!|jD]}|
|kr
t
Sq
WtS(
N(R�RR�(RR R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�Os



c

Csd
|jj
|jfS(Ns%s(%r)(RRR�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTWs
N(RRPR-RAR;RXRfR\R�RwR�R�RZR�R�R�R�R�R�RyRR�R�R�R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s(				
						t
FileMultiDictcBseZ
dZddd
�ZRS(s�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
    cCs�t|t
�r|}nyt|t�rN|dkr<|}nt|d
�}n|r||dkr|tj|�
dpvd}nt
|||
|�}|j|
|�
dS(sP
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
        trbisapplication/octet-streamN(RtFileStorageR
R;topent	mimetypest
guess_typeRh(RR*tfiletfilenametcontent_typeR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytadd_filecs	
	

	

N(RRPR-R;R�(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�[st
ImmutableDictc
Bs)eZ
dZd
�Zd�Zd�ZRS(s;An immutable :class:`dict`.

    .. versionadded:: 0.5
    c

Csd
|jj
tj|�
fS(Ns%s(%s)(RRRRT(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�s
c

Cs
t|�
S(
s�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(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRy�sc


Cs|S(
N((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRz�s
(RRPR-RTRyRz(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�|s		tImmutableMultiDictc
Bs eZ
dZd
�Zd�ZRS(s@An immutable :class:`MultiDict`.

    .. versionadded:: 0.5
    c

Cs
t|�
S(
s�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(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRy�sc


Cs|S(
N((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRz�s
(RRPR-RyRz(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s	tImmutableOrderedMultiDictc
Bs)eZ
dZd
�Zd�Zd�ZRS(sGAn immutable :class:`OrderedMultiDict`.

    .. versionadded:: 0.6
    c

Cstt
|d
t�

�
S(NR(R�RR(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR]�s
c

Cs
t|�
S(
s�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�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRy�sc


Cs|S(
N((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRz�s
(RRPR-R]RyRz(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s		tAcceptcBs�eZ
dZdd
�
Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zdd�
Zed��
ZRS(s�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.

    cs�|
dkr%t
j��

t�_nht|
t�rS|
j�_t
j�|
�
n:t�_t|
d
�f
d�dt�
}
t
j�|
�
dS(NR c

s�j|d
�
|dfS(Nii
(
t_specificity(
R$(
R(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&RM(	R;RRXR�tprovidedRR�Rtsorted(RR�((
Rs9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s






	

cCs
|
d
kf
S(s3Returns a tuple describing the value's specificity.t
*((RR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��scCs"|d
kp!|j�|
j�kS(s-Check if a value matches a given accept item.R

(
R�(RR!R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_value_matches�scCs,t|
t
�r|j|
�
Stj||
�S(
s�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
tqualityRR�(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s


cCs1x*|D]"\}}|j|
|�r|SqWd
S(s�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)``)
        i(
R
(RR RR
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�s


cCs1x*|D]"\}}|j|
|�rt
SqWtS(
N(R
RR�(RR!Rt_quality((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s



c

Cs'd
|jj
djd�|D�
�
fS(Ns%s([%s])s, c
ss%|]\}
}d|
|fV
qd
S(s(%r, %s)N((R�R$t
y((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>s(RRR�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTs

	
cCsgt|
t
�rWx6t|�
D](\}\}}|j|
|�r|SqWt|
�
�
ntj||
�S(
s�Get the position of an entry or raise :exc:`ValueError`.

        :param key: The key to be looked up.

        .. versionchanged:: 0.5
           This used to raise :exc:`IndexError`, which was inconsistent
           with the list API.
        (RR
R�R
RvRRK(RR R�RR
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRKs	




cCs*y|j|
�
SWnt
k
r%


d
SXdS(saGet the position of an entry or return -1.

        :param key: The key to be looked up.
        i����N(RKRv(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytfind!s



c
csx|D]}
|
d
V
qWdS(sIterate over all values.iN((RR((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�+s

c
CsVg}
x@|D]8\}}|d
kr8d||f}n|
j|�

q
Wdj
|
�
S(s2Convert the header set into an HTTP header string.i
s%s;q=%st
,(RFR�(RR�R!R
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt	to_header0s




c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�9s
cCs7x0|D](\}}|j|
|�r||fSqWdS(
N(
R
(Rtmatchtclient_itemR
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_best_single_match<s

cCs�|}d
}d}x�|
D]�}|j|�
}|s:qn|\}}	|j
|�
}
|	dk
s|	|krsqn|	|ks�|
|kr|}|	}|
}qqW|S(sV
Returns the best match from a list of possible matches based
        on the specificity and quality of the client. If two items have the
        same quality and specificity, the one is returned that comes first.

        :param matches: a list of matches to check for
        :param default: the value that is returned if none match
        i����i(
i����(R
R�(RtmatchesR_R�tbest_qualitytbest_specificitytserver_itemR	
R

R
tspecificity((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
best_matchBs 















c

Cs|r|d
d
SdS(sThe best match as value.iN((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytbest\s
(N(RRPR-RXR�R
R�R
R�RTRKR
R�R
R�R
R;R
tpropertyR
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s #									
					s
/|(?:\s*;\s*)c

Cstj
|j��
S(
N(t_mime_split_retsplitR�(
R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_normalize_mimefs
t
MIMEAcceptcBsMeZ
dZd
�Zd�Zed��
Zed��
Zed��
ZRS(sRLike :class:`Accept` but with special methods and behavior for
    mimetypes.
    cCstd
�t
j|
�
D�
�
S(Nc
ss|]}
|
dkV
qd
S(R

N((R�R$((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>ps(RR
R
(RR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�os
cCs8
d
|krtSd
|
kr/t
d|
�
�
nt|
�
}|d \}}t|d�
}|dkr�|dkr�t
d|
�
�
nt|�
}|d \}}	t|d�
}
|dkr�|	dkr�tS|dkr�|	dkp7
|dkr�|dkp7
||ko7
|	dkp7
|dkp7
|	|ko7
|
|kS(Nt
/sinvalid mimetype %riR

(R�RvR
R
(RR!Rtnormalized_valuet
value_typet
value_subtypetvalue_paramstnormalized_itemt	item_typetitem_subtypetitem_params((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
rs(










c

Csd
|kpd|kp|jS(s!True if this object accepts HTML.s	text/htmlsapplication/xhtml+xml(
taccept_xhtml(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytaccept_html�sc

Csd
|kpd|kS(s"True if this object accepts XHTML.sapplication/xhtml+xmlsapplication/xml((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR!
�sc

Cs
d
|kS(s!True if this object accepts JSON.sapplication/json((
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytaccept_json�s(	RRPR-R�R
R
R"
R!
R#
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
js		(s[_-]c

Cstj
|j��
S(
s$Process a language tag for matching.(t_locale_delim_reR
R�(
R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_normalize_lang�stLanguageAcceptcBs#eZ
dZd
�Zdd�
ZRS(s>Like :class:`Accept` but with normalization for language tags.cCs"|d
kp!t|
�
t|�
kS(NR

(
R%
(RR!R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�s
cs�tt
|�j|
�
��dk	r(�Stg|D]*}tj|d
d�d
|df^q2�
}|j|
�
��dk	r��Sg|
D]}tj|d�d
^q�}tt
|�j|�
��dk	r�t�f
d�|
D�
�
S|S(s�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.
        ii
c
3s$|]}
|
j��
r|
V
qdS(
N(
R�(R�R(
R�(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>�sN(RVR&
R
R;R�R$
R
R�(RR
R_Rtfallbacktfallback_matches((
R�s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�s

:
)

N(RRPR-R
R;R
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR&
�s
	t
CharsetAcceptc
BseZ
dZd
�ZRS(s9Like :class:`Accept` but with normalization for charsets.cCs+d
�}|dkp*||
�
||�
kS(Nc

Ss3ytj
|�
jSWntk
r.


|j�SXdS(
N(tcodecstlookupR*tLookupErrorR�(
R*((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
_normalize�s




R

((RR!RR-
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�s
	(RRPR-R
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR)
�s
cs;t��
�fd
��
�fd��
f
d�d�
�S(s|Return a new property object for a cache header.  Useful if you
    want to add support for a cache extension in a subclass.c

s|j�
���S(
N(
t_get_cache_value(
R$(temptyR R?(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&cs|j�|
�
�S(
N(
t_set_cache_value(R$R"(R R?(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&c

s
|j��
S(
N(
t_del_cache_value(
R$(
R (s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&saccessor for %r(
R
(R R/
R?((R/
R R?s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytcache_property�s




t
_CacheControlcBs�eZ
dZed
dd�Zedde�Zedde�Z	eddd�Z
ddd�Zd�Zd	�Z
d
�Zd�Zd�Zd
�ZRS(sVSubclass 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
       <ResponseCacheControl 'no-cache'>
       >>> cc.no_cache
       '*'
       >>> cc.no_cache = None
       >>> cc
       <ResponseCacheControl ''>

       In versions before 0.5 the behavior documented here affected the now
       no longer existing `CacheControl` class.
    sno-cacheR

sno-storesmax-agei����sno-transformcCs2tj
||
pd
�
||_|
dk	|_dS(N((RRXRpR;R�(RR�Rp((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX's

	
cCsw|tkr|
|kS|
|krs||
}|d
kr<|S|d
k	roy||�
}Wqotk
rk


qoXn|Sd
S(s+Used internally by the accessor properties.N(tboolR;Rv(RR R/
R?R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR.
,s













cCsx|tkr2|rd
||
<qt|j|
d
�
nB|d
krQ|j|
d
�
n#|tkrjd
||
<n
|||
<d
S(s+Used internally by the accessor properties.N(R4
R;RLR(RR R!R?((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR0
;s






cCs|
|kr||
=nd
S(s+Used internally by the accessor properties.N((RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR1
Js
c

Cs
t|�
S(
s6Convert the stored values into a cache control header.(
tdump_header(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
Osc


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�Ss
c

Cs3d
|jj
djd�t|j��
D�
�
fS(Ns<%s %s>t
 c
ss%|]\}
}d|
|fV
qd
S(s%s=%rN((R�R�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>Ys(RRR�R
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTVs

	
N((RRPR-R2
R;tno_cacheR4
tno_storetinttmax_agetno_transformRXR.
R0
R1
R
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR3
s


					tRequestCacheControlcBsDeZ
dZed
de�Zedde�Zedde�Z	RS(s	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.
    s	max-staleR

s	min-freshsonly-if-cachedN(
RRPR-R2
R9
t	max_stalet	min_freshR;R4
tonly_if_cached(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR<
]s

tResponseCacheControlcBszeZ
dZed
de�Zeddd�Zedde�Zedde�Z	eddd�Z
edde�ZRS(	s*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.
    tpublictprivateR

smust-revalidatesproxy-revalidatess-maxaget	immutableN(RRPR-R2
R;R4
RA
RB
tmust_revalidatetproxy_revalidatets_maxageRC
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR@
ps





c

s2t�f
d
��f
d��f
d�d��S(s�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(
t
_get_value(
R$(
R (s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&cs|j�|
�S(
N(
t
_set_value(R$R"(
R (s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&c

s
|j��
S(
N(
t
_del_value(
R$(
R (s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%�R&saccessor for %r(
R
(
R ((
R s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytcsp_property�s




tContentSecurityPolicycBs
eZ
dZed
�
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�
Zd!d"d�Zd�Zd�Z d�Z!d�Z"d�Z#d �Z$RS(#sVSubclass 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.

    sbase-uris	child-srcsconnect-srcsdefault-srcsfont-srcsform-actionsframe-ancestorss	frame-srcsimg-srcsmanifest-srcs	media-srcsnavigate-tos
object-srcsprefetch-srcsplugin-typess	report-tos
report-uritsandboxs
script-srcsscript-src-attrsscript-src-elems	style-srcsstyle-src-attrsstyle-src-elems
worker-srccCs2tj
||
pd
�
||_|
dk	|_dS(N((RRXRpR;R�(RR�Rp((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s

	
cCs
|j|
�
S(
s+Used internally by the accessor properties.(
Rw(RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRG
�scCs-|d
kr|j
|
d
�
n
|||
<d
S(s+Used internally by the accessor properties.N(R;RL(RR R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRH
�s
cCs|
|kr||
=nd
S(s+Used internally by the accessor properties.N((RR ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRI
�s
c

Cs
t|�
S(
s6Convert the stored values into a cache control header.(
tdump_csp_header(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�sc


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s
c

Cs3d
|jj
djd�t|j��
D�
�
fS(Ns<%s %s>R6
c
ss%|]\}
}d|
|fV
qd
S(s%s=%rN((R�R�R"((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pys	<genexpr>�s(RRR�R
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�s

	
(N(%RRPR-RJ
tbase_urit	child_srctconnect_srctdefault_srctfont_srctform_actiontframe_ancestorst	frame_srctimg_srctmanifest_srct	media_srctnavigate_tot
object_srctprefetch_srctplugin_typest	report_tot
report_uriRL
t
script_srctscript_src_attrtscript_src_elemt	style_srctstyle_src_attrtstyle_src_elemt
worker_srcR;RXRG
RH
RI
R
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRK
�sB























					tCallbackDictcBs&eZ
dZddd
�Zd�ZRS(swA dict that calls a function passed every time something is changed.
    The function is passed the dict instance.
    cCs#tj
||
pd
�
||_dS(N((RRXRp(RtinitialRp((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s

c

Csd
|jj
tj|�
fS(Ns<%s %s>(RRRRT(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�s
N(RRPR-R;RXRT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRf
�st	HeaderSetcBs�eZ
dZddd
�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zed	�
Z
d
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(s�
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'])
    cCsMt|
pd
�
|_
tg|j
D]}|j�^q"�
|_||_dS(N((Rt_headersR�R�t_setRp(RtheadersRpR$((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX
	s

+
cCs|j|
f
�

d
S(sAdd a new header to the set.N(
Rc(Rtheader((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRh	scCs�|
j�}||j
kr*t|
�
�
n|j
j|�

x=t|j�
D],\}}|j�|
krJ|j|=PqJqJW|jd
k	r�|j|�

nd
S(sC
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�Rj
RuRRR�Ri
RpR;(RRl
R R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRR
	s










cCs�t}xR|
D]J}|j
�}||jkr
|jj|�

|jj|�

t}q
q
W|r�|jd
k	r�|j|�

nd
S(s�Add all the headers from the iterable to the set.

        :param iterable: updates the set with the items from the iterable.
        N(	R�R�Rj
Ri
RFRhRRpR;(RRGtinserted_anyRl
R ((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRc	s









cCs)y|j|
�
SWnt
k
r$


n
Xd
S(sdLike :meth:`remove` but ignores errors.

        :param header: the header to be discarded.
        N(RRRu(RRl
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytdiscard.	s



cCsF|
j�}
x3t
|j�
D]"\}}|j�|
kr|SqWd
S(s�Return the index of the header in the set or return -1 if not found.

        :param header: the header to be looked up.
        i����(R�R�Ri
(RRl
R�R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
8	s




cCs.|j|
�
}|d
kr*t
|
�
�
n|S(s�Return the index of the header in the set or raise an
        :exc:`IndexError`.

        :param header: the header to be looked up.
        i(R
t
IndexError(RRl
R=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRKC	s


c

Cs7|jj
�
|j2|jd
k	r3|j|�

nd
S(sClear the set.N(Rj
ReRi
RpR;(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyReN	s



cCs |
rt|j
�
St|j�
S(
s�
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�Ri
Rj
(Rtpreserve_casing((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytas_setU	s	


c

Csd
jt
t|j��
S(s2Convert the header set into an HTTP header string.s, (R�R�tquote_header_valueRi
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
b	scCs|j|
S(
N(
Ri
(RR�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�f	s
cCsK|jj
|
�
}|jj|j��

|jdk	rG|j|�

ndS(
N(Ri
RLRj
RRR�RpR;(RR�R=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRBi	s



cCsi|j|
}|j
j|j��

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

|jdk	re|j|�

ndS(
N(Ri
Rj
RRR�RhRpR;(RR�R!told((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyREo	s







cCs|
j�|j
kS(
N(R�Rj
(RRl
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�w	s
c

Cs
t|j
�
S(
N(R�Rj
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�z	s
c

Cs
t|j
�
S(
N(R�Ri
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�}	s
c

Cs
t|j
�
S(
N(R4
Rj
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__nonzero__�	s
c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��	s
c

Csd
|jj
|jfS(Ns%s(%r)(RRRi
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�	s
N(RRPR-R;RXRhRRRcRn
R
RKReR�Rq
R
R�RBRER�R�R�Rt
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRh
�s(				
			
									tETagscBs�eZ
dZdded
�Zed�
Zd�Zd�Zd�Z	d�Z
d�Zd�Zdded	�Z
d
�ZeZd�Zd�Zd
�Zd�ZRS(sYA set that can be used to check if one etag is present in a collection
    of etags.
    cCs>t|r|
pd
�
|_
t|p(d�
|_||_dS(N(((R^t_strongt_weaktstar_tag(Rtstrong_etagst
weak_etagsRx
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�	s


cCs,t|j
�
}|
r(|j|j�

n|S(
soConvert the `ETags` object into a python set.  Per default all the
        weak etags are not part of this set.(R�Rv
RcRw
(Rtinclude_weakR=((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRq
�	s


cCs
|
|jkS(
sCheck if an etag is weak.(
Rw
(Rtetag((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytis_weak�	scCs
|
|jkS(
sCheck if an etag is strong.(
Rv
(RR|
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt	is_strong�	scCs|j|
�
p|j
|
�
S(
sCCheck if an etag is part of the set including weak and strong tags.(R}
tcontains(RR|
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
contains_weak�	scCs|jr
t
S|j|
�
S(
sxCheck if an etag is part of the set ignoring weak tags.
        It is also possible to use the ``in`` operator.
        (Rx
RR~
(RR|
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�	s	

cCs2t|
�
\}
}|r%|j
|
�
S|j|
�
S(
s�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.(tunquote_etagR�
R
(RR|
tweak((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytcontains_raw�	s



c
CsR|jr
d
Sdj
g|jD]}
d|
^qg|jD]}
d|
^q:�
S(s0Convert the etags set into a HTTP header string.R

s, s"%s"sW/"%s"(Rx
R�Rv
Rw
(RR$((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�	s	


cCsn|
|gjd�
d
kr*td�
�
n|
dkrEt|�
}
n|ra|
|jkratSn|
|jkS(Ni
s-either tag or data required, but at least one(tcountR;Rt
generate_etagRw
RRv
(RR|
tdataR{
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__call__�	s







c

Cst|j
p|jp|j�
S(
N(R4
Rx
Rv
Rw
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__bool__�	s
c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��	s
c

Cs
t|j
�
S(
N(R�Rv
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��	s
cCs
|j|
�
S(
N(
R
(RR|
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��	s
c

Csd
|jj
t|�
fS(Ns<%s %r>(RRtstr(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�	s
N(RRPR-R;R�RXRq
R}
R~
R�
R
R�
R
R�
R�
Rt
R�R�R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRu
�	s 							
				tIfRangecBs8eZ
dZddd
�Zd�Zd�Zd�ZRS(s�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
    cCs|
|_||_
dS(
N(R|
tdate(RR|
R�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�	s	c

Cs<|jdk	rt|j�
S|jdk	r8t|j�
Sd
S(s-Converts the object back into an HTTP header.R&N(R�
R;t	http_dateR|
t
quote_etag(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
�	s






c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��	s
c

Csd
|jj
t|�
fS(Ns<%s %r>(RRR�
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�	s
N(RRPR-R;RXR
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�	s
		tRangec
BsMeZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	RS(sX
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
    cCs{|
|_||_
xb|D]Z\}}|dksU|dk	r|d
ksU||krtdj||f�
�
�
qqWdS(Nis{} is not a valid range.(tunitstrangesR;Rvtformat(RR�
R�
tstarttend((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX
s
		
0
cCs�|jd
ks0|
dks0t|j�
dkr4dS|jd\}}|dkru|
}|dkru||
7}qunt|||
�r�|t||
�fSdS(s�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�i
iN(R�
R;R�R�
tis_byte_range_validtmin(RtlengthR�
R�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytrange_for_length
s0







cCs=|j|
�
}|dk	r9t|j|d
|d|
�SdS(s�Creates a :class:`~werkzeug.datastructures.ContentRange` object
        from the current range and given content length.
        ii
N(R�
R;tContentRangeR�
(RR�
trng((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytmake_content_range"
s

c
Cs�g}
xj|jD]_\}}|dkrT|
j|d
krDd|n	t|�
�

q|
jd||df�

qWd|jdj|
�
fS(s-Converts the object back into an HTTP header.is%s-s%s-%si
s%s=%sR
N(R�
R;RFR�
R�
R�(RR�
tbeginR�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
*
s


,
cCsB|j|
�
}|dk	r>d
|j|d|dd|
fSdS(s\Converts the object into `Content-Range` HTTP header,
        based on given length
        s%s %d-%d/%dii
N(R�
R;R�
(RR�
R�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytto_content_range_header4
s





c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�B
s
c

Csd
|jj
t|�
fS(Ns<%s %r>(RRR�
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTE
s
(
RRPR-RXR�
R�
R
R�
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�	s				
		R�
cBs�eZ
dZddd
�Zd�Zed�
Zed�
Zed�
Zed�
Z	[ddd�Z
d	�Zd
�Zd�Z
e
Zd�Zd
�ZRS(sDRepresents the content range header.

    .. versionadded:: 0.7
    cCsAt|||�st
d
�
�
||_|j||||
�
dS(NsBad range provided(R�
tAssertionErrorRpR�(RR�
R�
tstopR�
Rp((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRXO
s

	
c
s+�f
d
�}
�f
d�}t|
|�S(Nc

s
t|��S(
N(
R4(
R(
R*(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytfgetU
s
cs3t|�|
�
|j
dk	r/|j
|�

ndS(
N(R.RpR;(RR!(
R*(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytfsetX
s


(
R
(R*R�
R�
((
R*s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_callback_propertyT
s
t_unitst_startt_stopt_lengthR�cCset|
||�st
d
�
�
||_|
|_||_||_|jdk	ra|j|�

ndS(s#Simple method to update the ranges.sBad range providedN(R�
R�
R�
R�
R�
R�
RpR;(RR�
R�
R�
R�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�j
s
	
	
	
	

c

Cs|jddd
d�

dS(scSets the units to `None` which indicates that the header should
        no longer be used.
        R�
N(R�R;(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytunsett
sc
Csu|jdkrd
S|jdkr+d}
n	|j}
|jdkrTd|j|
fSd|j|j|jd|
fS(NR&R

s%s */%ss%s %s-%s/%si
(R�
R;R�
R�
R�
(RR�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
z
s



		


c

Cs
|jdk	S(
N(R�
R;(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRt
�
s
c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��
s
c

Csd
|jj
t|�
fS(Ns<%s %r>(RRR�
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT�
s
N(RRPR-R;RXR�
R�
R�
R�
R�
R�R�
R
Rt
R�
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
I
s	

				t
AuthorizationcBs�eZ
dZdd
�
Zed��
Zed��
Zed��
Zed��
Z	ed��
Z
ed��
Zed��
Zed	��
Z
ed
��
Zed��
ZRS(
s�
Represents an `Authorization` header sent by the client.  You should
    not create this kind of object yourself but use it when it's returned by
    the `parse_authorization_header` function.

    This object is a dict subclass and can be altered by setting dict items
    but it should be considered immutable as it's returned by the client and
    not meant for modifications.

    .. versionchanged:: 0.5
       This object became immutable.
    cCs#tj
||pi�
|
|_dS(
N(RRXR?(Rt	auth_typeR�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�
s

c

Cs
|jd
�
S(sdThe username transmitted.  This is set for both basic and digest
        auth all the time.
        tusername(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(ssWhen the authentication type is basic this is the password
        transmitted by the client, else `None`.
        tpassword(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s8This is the server realm sent back for HTTP digest auth.trealm(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s�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.
        tnonce(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s�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.
        turi(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(szThe nonce count value transmitted by clients if a qop-header is
        also transmitted.  HTTP digest auth only.
        tnc(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s�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.
        tcnonce(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s�A string of 32 hex digits computed as defined in RFC 2617, which
        proves that the user knows a password.  Digest auth only.
        tresponse(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s�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.
        topaque(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sc

Cs
|jd
�
S(s�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.
        tqop(
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sN(RRPR-R;RXR
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
stWWWAuthenticatecBs=
eZ
dZed
ddddg�
Zdddd�Zdd�
Zddded
�Z	d�Z
d�Zd
�Zdd�
Z
dd�
Ze
ddd�

Ze
ddd�

Zed
dd�

Ze
ddd�

Ze
ddd�

Ze
ddd�

Zeddd�

Zed��
Zejd��
Zee
�
Z
[RS(s5Provides simple access to `WWW-Authenticate` headers.tdomainR�
R�
R�
R�
cCs6tj
||pd�
|
r)|
|d
<n||_dS(Nt
__auth_type__((RRXRp(RR�
R�Rp((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�
s




sauthentication requiredcCsHtj
|�

tj|id
d6|
d6�
|jrD|j|�

ndS(s*Clear the auth info and enable basic auth.tbasicR�
R�
N(RReRcRp(RR�
((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt	set_basic�
s


	
tauthcCs�id
d6|
d6|d6t|�
d6}|r;d|d<n|d
k	rT||d<n|d
k	rm||d	<ntj|�

tj||�
|jr�|j|�

nd
S(s+Clear the auth info and enable digest auth.tdigestR�
R�
R�
R�
tTRUEtstaleR�
t	algorithmN(R5
R;RReRcRp(RR�
R�
R�
R�
R�
R�
R�((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
set_digest�
s















	
c
Cst|�
}
|
j
d
d�p!d}d|j�djgt|
�
D]1\}}d|t|d||jk�

f^qC�
fS(s9Convert the stored values into a WWW-Authenticate header.R�
R�
s%s %ss, s%s=%stallow_tokenN(RRLR;R�R�RRr
t_require_quoting(RR�R�
R R!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR
s


	
c


Cs
|j�S(
N(
R
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�'s
c

Csd
|jj
|j�fS(Ns<%s %r>(RRR
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRT*s
cs+�f
d
�}t�f
d�|d|
�
S(su
A static helper function for 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.
        cs3|
dkr|j
�d�
nt|
�
|�<dS(
N(R;RLR�
(RR!(
R*(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRH
8s

c

s
|j��
S(
N(
Rw(
R$(
R*(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR%>R&tdoc(
R
(R*R�
RH
((
R*s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
auth_property-scs�f
d
�}t|d|
�

S(Nc
s(�
�fd
�}
t�j
�
�
|
�S(Nc

s:|r��
kr�
�=n|r6|j��
�<ndS(
N(
R
(
t
header_set(R*R(s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRpBs




(tparse_set_headerRw(RRp(
R*(
Rs9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
As
R�
(
R
(R*R�
R�
((
R*s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt
_set_property@s
	R�
R�
sZThe type of the auth mechanism. HTTP currently specifies
        ``Basic`` and ``Digest``.s
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.s�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.s�
        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.s
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�
s 
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).sIA set of quality-of-privacy directives such as auth and
        auth-int.c
Cs/|jd
�
}
|
dk	r+|
j�dkSdS(s}A flag, indicating that the previous request from the client
        was rejected because the nonce value was stale.
        R�
ttrueN(RwR;R�(Rtval((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
|s

cCs9|
dkr|j
d
d�
n|
r+dnd|d
<dS(NR�
R�
tFALSE(R;RL(RR!((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�s
N(
R�
(RRPR-R^R�
R;RXR�
R�R�
R
R�RTR�
R�
R?R�
R�
R�
R�
R�
R�
R
R�
tsettertstaticmethod(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�
sF
			
	
	
	
	
	
	
		
R�cBs�eZ
dZddddddd
�Zd�Zed��
Zed��
Zed��
Z	ed��
Z
dd�
Zd	�Zd
�Z
e
Zd�Zd�Zd
�ZRS(s@
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()``.
    cCs
||_|
pt
�|_|dkr�t|
d
d�}t|�
}|r�|d|d�
kr�|d|d�
kr�d}ntr�t|t�r�|j	t
�d�}q�n||_|dkr�t�}n||_
|dk	r�||d<n|dk	r
t|�
|d<ndS(	NR*it
<i����t
>R�sContent-TypesContent-Length(R*RtstreamR;R4RRRR�R�RR�R�Rk
R�
(RR�
R�R*R�tcontent_lengthRk
t
s((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRX�s"		



2
	
	


	




c

Cs(t|d
�s$t
|j�
|_ndS(Nt_parsed_content_type(thasattrtparse_options_headerR�R�
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt_parse_content_type�s

c

Cs|jj
d
�
S(s;The content-type sent in the header.  Usually not availablescontent-type(Rk
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��sc

Cst|j
jd
�
pd�
S(s=The content-length sent in the header.  Usually not availablescontent-lengthi(R9
Rk
Rw(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
�sc

Cs|j�
|j
d
j�S(s
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
        i(R�
R�
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytmimetype�s	

c

Cs|j�
|j
d
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.7
        i
(R�
R�
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytmimetype_params�s

i@cCs�d
dlm
}
t}t|
d�r4t|
�
}
nt|
t�r[t|
d�}
t}nz||j	|
|�
Wd|r�|
j
�
nXdS(snSave 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`.
        i����(
tcopyfileobjt
__fspath__twbN(tshutilR�
R�R�
RRR
R�RR�
tclose(Rtdsttbuffer_sizeR�
t	close_dst((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pytsave�s


	

c

Cs)y|jj
�
Wntk
r$


n
Xd
S(s&Close the underlying file if possible.N(R�
R�
t	Exception(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�
s



c

Cs
t|j
�
S(
N(R4
R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRt

s
cCsTyt|j
|
�SWn9tk
rO


t|j
d
�rIt|j
j|
�S�n
XdS(Nt_file(R4R�
tAttributeErrorR�
R�
(RR*((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt__getattr__s





c

Cs
t|j
�
S(
N(R�R�
(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR�s
c

Csd
|jj
|j|jfS(Ns
<%s: %r (%r)>(RRR�R�(
R((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyRTs

	

N(RRPR-R;RXR�
R
R�R�
R�
R�
R�
R�
Rt
R�
R�
R�RT(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyR��s&




	!				(
RM
(
R5
(
R�(
R�
(
R�
(
R�
(
R�
(
R�
(
R�
(
Rr
(
R�
(_R-R*
R�treRyRt	itertoolsR
R&Rt_compatRRRRRRR	R
RRR
RRt	_internalRt
filesystemRRR#R8tobjectR9RRSRURgRoRRtRxR'RR�R�R�R�R�R�R�R�R�R�R�R�R�tcompileR
R
R
R$
R%
R&
R)
R2
R3
R<
R@
R�
RJ
RK
Rf
t
MutableSetRh
t	ContainertIterableRu
R�
R�
R�
R�
R�
R�thttpRM
R5
R�R�
R�
R�
R�
R�
R�
Rr
R�
(((s9/tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/datastructures.pyt<module>
s�



















			&32-)
�N 
�		
��53
�!
�	B	6
	[	
N
�SNHZ��