U
|
Þ=®d| ã @ sX d dl mZ d dlmZ d dlmZ ddlmZ ddlm Z ddl
|
m Z dd l
|
m Z dd
|
l
|
m Z dd l
|
mZ d d Zdd ZG dd de eZG dd deZG dd de eZG dd deZG dd dZG dd deZG d d d e eZG d d d e eZG d d! d!e eZG d"d# d#e eZ G d$d% d%eeZ G d&d' d'eZ dd(lm Z d)S )*é )Ú annotations)Ú
|
MutableSet©Údeepcopyé )Ú
|
exceptions)Ú_missingé )ÚImmutableDictMixin)ÚImmutableListMixin)ÚImmutableMultiDictMixin)ÚUpdateDictMixinc C s t t| jdd S )Nz objects are immutable)Ú TypeErrorÚtypeÚ__name__©Úself© r úYd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/datastructures/structures.pyÚ is_immutable s r c c sx t | tr | jddE dH nVt | trj| ¡ D ]6\}}t |ttfr\|D ]}||fV qJq0||fV q0n
|
| E dH 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Úvr r r Úiter_multi_items s
|
|
r" c @ s e Zd ZdZdd ZdS )Ú ImmutableListzJAn immutable :class:`list`.
|
|
.. versionadded:: 0.5
|
|
:private:
|
c C s t | j dt | ¡ dS ©Nú(ú))r r r Ú__repr__r r r r r' + s zImmutableList.__repr__N)r Ú
|
__module__Ú __qualname__Ú__doc__r' r r r r r# # s r# c @ s e Zd ZdZdddZdS )Ú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
|
Nc C sX z | | }W n t k
|
r$ | Y S X |dk rTz ||}W n tk
|
rR |}Y nX |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)r r Údefaultr Úrvr r r Úget7 s
|
|
zTypeConversionDict.get)NN)r r( r) r* r0 r r r r r+ / s r+ c @ s e Zd ZdZdd Zdd ZdS )ÚImmutableTypeConversionDictzpWorks like a :class:`TypeConversionDict` but does not support
|
modifications.
|
|
.. versionadded:: 0.5
|
c C s t | 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+ r r r r Úcopy_ s z ImmutableTypeConversionDict.copyc C s | S ©Nr r r r r Ú__copy__f s z$ImmutableTypeConversionDict.__copy__N©r r( r) r* r3 r5 r r r r r1 X s r1 c @ sò e Zd ZdZd9ddZdd Zdd Zd d
|
Zd d Zd d Z dd Z
|
d:ddZ dd Z d;ddZ d<ddZd=ddZd d Zd d Zd d! Zd"d# Zd>d$d%Zd?d'd(Zd)d* Zefd+d,Zd-d. Zd/d0 Zd1d2 Zd3d4 Z d5d6 Z d7d8 Z dS )@r a A :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`.
|
Nc C sÀ t |tr&t | dd | ¡ D ¡ nt |tri }| ¡ D ]<\}}t |ttfrjt|dkr`q<t|}n|g}|||< q<t | |¡ n4i }|pdD ]\}}| |g ¡
|
|¡ qt | |¡ d S )Nc s s" | ]\}}||d d
fV qd S r4 r )Ú.0ÚkÚlr r r Ú <genexpr> s z%MultiDict.__init__.<locals>.<genexpr>r r ) r r r Ú__init__Úlistsr r r ÚlenÚ
|
setdefaultÚappend)r r Útmpr r r r r r; s
|
|
|
|
zMultiDict.__init__c C s t | ¡ S r4 )r r< r r r r Ú __getstate__§ s zMultiDict.__getstate__c C s t | ¡ t | |¡ d S r4 )r ÚclearÚupdate)r r r r r Ú __setstate__ª s
|
zMultiDict.__setstate__c C s
|
t | ¡S r4 )r Ú__iter__r r r r rE ® s zMultiDict.__iter__c C s6 || kr(t | |¡}t|dkr(|d S t |¡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__r= r ÚBadRequestKeyError)r r Úlstr r r rF ´ s
|
zMultiDict.__getitem__c C s t | ||g¡ dS )zLike :meth:`add` but removes an existing key first.
|
|
:param key: the key for the value.
|
:param value: the value to set.
|
N)r Ú __setitem__©r r r r r r rI Â s zMultiDict.__setitem__c C s t | |g ¡ |¡ dS )zAdds a new value for the key.
|
|
.. versionadded:: 0.6
|
|
:param key: the key for the value.
|
:param value: the value to add.
|
N)r r> r? rJ r r r ÚaddÊ s z MultiDict.addc C st zt | |¡}W n tk
|
r( g Y S X |dkr:t|S g }|D ],}z| ||¡ W qB tk
|
rl Y qBX qB|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)r rF r, r r? r- ©r r r r/ ÚresultÚitemr r r ÚgetlistÔ s
|
zMultiDict.getlistc C s t | |t|¡ dS )a Remove 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)r rI r )r r Únew_listr r r Úsetlistî s zMultiDict.setlistc C s || 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 )r r r. r r r r> s
|
zMultiDict.setdefaultc C s4 || kr$t |pd}t | ||¡ n t | |¡}|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`
|
r )r r rI rF ©r r Z default_listr r r Úsetlistdefault s
|
zMultiDict.setlistdefaultFc c s@ t | ¡D ]0\}}|r,|D ]}||fV qq
|
||d fV q
|
dS )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)r r )r r r Úvaluesr r r r r & s
|
zMultiDict.itemsc c s& t | ¡D ]\}}|t|fV q
|
dS )zuReturn a iterator of ``(key, values)`` pairs, where values is the list
|
of all values associated with the key.N)r r r )r r rT r r r r< 4 s zMultiDict.listsc c s t | ¡D ]}|d V q
|
dS )zAReturns an iterator of the first value on every key's value list.r N©r rT )r rT r r r rT : s zMultiDict.valuesc C s
|
t | ¡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
|
rU r r r r Ú
|
listvalues? s zMultiDict.listvaluesc C s
|
| | ¡S )z%Return a shallow copy of this object.)Ú __class__r r r r r3 I s zMultiDict.copyc C s | t| jdd|¡S )z"Return a deep copy of this object.F)Úflat)rW r Úto_dict©r Úmemor r r r M s zMultiDict.deepcopyTc C s |rt | ¡ S t | ¡ 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`
|
©r r r< ©r rX r r r rY Q s
|
zMultiDict.to_dictc C s$ t |D ]\}}t | ||¡ qdS )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)r" r rK ©r r r r r r r rC _ s zMultiDict.updatec C sb z,t | |¡}t|dkr$t |¡|d W S tk
|
r\ |tk rL| Y S t |¡dY nX dS )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)r Úpopr= r rG r, r )r r r. rH r r r r_ t s
|
|
z MultiDict.popc
|
C sx z>t | ¡}t|d dkr*t |d ¡|d |d d fW S tk
|
rr } zt |jd ¡dW 5 d}~X Y nX dS )zPop an item from the dict.r r N)r Úpopitemr= r rG r, Úargs)r rN Úer r r r` s
|
zMultiDict.popitemc C s t | |g ¡S )z÷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.
|
)r r_ ©r r r r r Úpoplist s zMultiDict.poplistc
|
C sF z t | ¡W S tk
|
r@ } zt |jd ¡dW 5 d}~X Y nX dS )z*Pop a ``(key, list)`` tuple from the dict.r N)r r` r, r rG ra )r rb r r r Ú popitemlist¥ s zMultiDict.popitemlistc C s | ¡ S r4 )r3 r r r r r5 ¬ s zMultiDict.__copy__c C s | j |dS )N)r[ r rZ r r r Ú __deepcopy__¯ s zMultiDict.__deepcopy__c C s" t | j dt| jdddS )Nr% Tr r& )r r r r r r r r r' ² s zMultiDict.__repr__)N)N)N)N)F)N)T) r r( r) r* r; rA rD rE rF rI rK rO rQ r> rS r r< rT rV r3 r rY rC r r_ r` rd re r5 rf r' r r r r r j s6 (
|
|
|
|
|
|
|
|
|
|
r c @ s$ e Zd ZdZdZdd Zdd ZdS )Ú _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).
|
)Úprevr r Únextc C sF |j | _|| _|| _d | _|jd kr*| |_|j d k r<| |j _| |_ d S r4 )Ú _last_bucketrh r r ri Ú _first_bucket)r Úomdr r r r r r; ¿ s
|
|
z_omd_bucket.__init__c C sH | j r| j| j _| jr | j | j_ |j| kr2| j|_|j| krD| j |_d S r4 )rh ri rk rj )r rl r r r ÚunlinkË s
|
|
|
|
z_omd_bucket.unlinkN)r r( r) r* Ú __slots__r; rm r r r r rg ¶ s rg c @ sØ e Zd ZdZd2ddZdd ZdZdd Zd d
|
Zd d Z d d Z
|
dd Z dd Z dd Z dd Zdd Zd3ddZd d Zd d Zd d! Zd4d"d#Zd$d% Zd5d&d'Zd(d) Zd*d+ Zefd,d-Zd.d/ Zd0d1 Z dS )6ÚOrderedMultiDictaN Works 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.
|
Nc C s. t | ¡ d | _| _|d k r*t | |¡ d S r4 )r r; rk rj ro rC )r r r r r r; æ s
|
zOrderedMultiDict.__init__c
|
C sì t |tstS t |tr®t| jdd}t|jdd}z6|D ],\}}t|\}}||ksb||kr> W dS q>W n tk
|
r Y dS X z t| W n tk
|
r¨ Y dS X dS t| t|krÂdS | ¡ D ] \}} |
|
|¡| krÊ dS qÊdS )NTr F) r r ÚNotImplementedro Úiterr ri Ú StopIterationr= r< rO )
|
r ÚotherZiter1Ziter2Zk1Zv1Zk2Zv2r rT r r r Ú__eq__ì s.
|
|
zOrderedMultiDict.__eq__c C s t | t| jddffS ©NTr )r r r ©r Úprotocolr r r Ú __reduce_ex__ s z OrderedMultiDict.__reduce_ex__c C s t | jddS ru )r r r r r r rA
|
s z OrderedMultiDict.__getstate__c C s( t | ¡ |D ]\}}| ||¡ qd S r4 )r rB rK )r rT r r r r r rD s
|
z OrderedMultiDict.__setstate__c C s( || krt | |¡d jS t |¡d S ©Nr )r rF r r rG rc r r r rF s z OrderedMultiDict.__getitem__c C s | |¡ | ||¡ d S r4 ©rd rK rJ r r r rI s
|
z OrderedMultiDict.__setitem__c C s | |¡ d S r4 )r_ rc r r r Ú __delitem__ s z OrderedMultiDict.__delitem__c C s dd | ¡ D S )Nc s s | ]\}}|V qd S r4 r ©r7 r r r r r r: s z(OrderedMultiDict.keys.<locals>.<genexpr>©r r r r r Úkeys s zOrderedMultiDict.keysc C s t | ¡ S r4 ©rq r~ r r r r rE ! s zOrderedMultiDict.__iter__c C s dd | ¡ D S )Nc s s | ]\}}|V qd S r4 r r| r r r r: % s z*OrderedMultiDict.values.<locals>.<genexpr>r} r r r r rT $ s zOrderedMultiDict.valuesFc c sh | j }|r*|d k rd|j|jfV |j}q
|
n:t }|d k rd|j|kr\| |j¡ |j|jfV |j}q0d S r4 )rk r r ri ÚsetrK )r r ÚptrÚ returned_keysr r r r ' s
|
|
zOrderedMultiDict.itemsc c sJ t }| j}|d k rF|j|kr>|j| |j¡fV | |j¡ |j}q d S r4 )r rk r rO rK ri )r r r r r r r< 5 s
|
zOrderedMultiDict.listsc c s | ¡ D ]\}}|V qd S r4 ©r< )r Ú_keyrT r r r rV > s zOrderedMultiDict.listvaluesc C s t | |g ¡ t| ||¡ d S r4 )r r> r? rg rJ r r r rK B s zOrderedMultiDict.addc C s| zt | |¡}W n tk
|
r( g Y S X |d kr@dd |D S g }|D ].}z| ||j¡ W qH tk
|
rt Y qHX qH|S )Nc S s g | ]
|
}|j qS r ©r ©r7 Úxr r r Ú
|
<listcomp>K s z,OrderedMultiDict.getlist.<locals>.<listcomp>)r rF r, r? r r- rL r r r rO E s
|
zOrderedMultiDict.getlistc C s$ | |¡ |D ]}| ||¡ qd S r4 rz )r r rP r r r r rQ T s
|
zOrderedMultiDict.setlistc C s t dd S )Nz5setlistdefault is unsupported for ordered multi dicts)r rR r r r rS Y s z OrderedMultiDict.setlistdefaultc C s$ t |D ]\}}t | ||¡ qd S r4 )r" ro rK r^ r r r rC \ s zOrderedMultiDict.updatec C s0 t | |d¡}|D ]}| | ¡ qdd |D S )Nr c S s g | ]
|
}|j qS r r
r r r r r d s z,OrderedMultiDict.poplist.<locals>.<listcomp>)r r_ rm )r r ÚbucketsÚbucketr r r rd ` s zOrderedMultiDict.poplistc C s` zt | |¡}W n0 tk
|
r@ |tk r0| Y S t |¡d Y nX |D ]}| | ¡ qF|d jS ry )r r_ r, r r rG rm r )r r r. r r r r r r_ f s zOrderedMultiDict.popc
|
C sj zt | ¡\}}W n4 tk
|
rF } zt |jd ¡d W 5 d }~X Y nX |D ]}| | ¡ qL||d jfS ry )r r` r, r rG ra rm r ©r r r rb r r r r r` t s $ zOrderedMultiDict.popitemc
|
C sn zt | ¡\}}W n4 tk
|
rF } zt |jd ¡d W 5 d }~X Y nX |D ]}| | ¡ qL|dd |D fS )Nr c S s g | ]
|
}|j qS r r
r r r r r s z0OrderedMultiDict.popitemlist.<locals>.<listcomp>)r r` r, r rG ra rm r r r r re s $ z OrderedMultiDict.popitemlist)N)F)N)N) r r( r) r* r; rt Ú__hash__rx rA rD rF rI r{ r~ rE rT r r< rV rK rO rQ rS rC rd r r_ r` re r r r r ro Ö s2
|
|
|
|
ro c @ s° e Zd ZdZdd Zd)ddZed*ddZd d
|
Zd+d d Z d,d dZ
|
dd Z dd Z dd Z d-ddZdd Zdd Zd d Zd d Zd.d!d"Zd#d$ Zd%d& Zd'd( ZdS )/Ú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.
|
c C s t | | jffS r4 )r Údictsrv r r r rx ¢ s z CombinedMultiDict.__reduce_ex__Nc C s t |p
|
g | _d S r4 )r r )r r r r r r; ¥ s zCombinedMultiDict.__init__c C s t d| jdd S )Nzcannot create z instances by fromkeys)r r )Úclsr~ r r r r Úfromkeys¨ s zCombinedMultiDict.fromkeysc C s. | j D ]}||kr|| S qt |¡d S r4 )r r rG ©r r Údr r r rF ¬ s
|
z CombinedMultiDict.__getitem__c C sX | j D ]L}||kr|d k rFz||| W S tk
|
rD Y qY nX || S q|S r4 )r r- )r r r. r r r r r r0 ² s
|
|
zCombinedMultiDict.getc C s& g }| j D ]}| | ||¡¡ q
|
|S r4 )r ÚextendrO )r r r r/ r r r r rO ½ s
|
zCombinedMultiDict.getlistc C s t }|j| j |S )zThis function exists so __len__ can be implemented more efficiently,
|
saving one list creation from an iterator.
|
)r rC r )r r/ r r r Ú
|
_keys_implà s z CombinedMultiDict._keys_implc C s | ¡ S r4 )r r r r r r~ Ë s zCombinedMultiDict.keysc C s t | ¡ S r4 r r r r r rE Î s zCombinedMultiDict.__iter__Fc c sV t }| jD ]D}| |¡D ]4\}}|r2||fV q||kr| |¡ ||fV qq d S r4 )r r r rK )r r Úfoundr r r r r r r Ñ s
|
|
zCombinedMultiDict.itemsc c s | ¡ D ]\}}|V qd S r4 r} )r r r r r r rT Û s zCombinedMultiDict.valuesc C s@ i }| j D ](}| ¡ D ]\}}| |g ¡ |¡ qq
|
t| ¡ S r4 )r r< r> r r r )r r/ r r rT r r r r< ß s
|
|
zCombinedMultiDict.listsc C s dd | ¡ D S )Nc s s | ]}|d V qdS )r Nr r r r r r: ç s z/CombinedMultiDict.listvalues.<locals>.<genexpr>r r r r r rV æ s z CombinedMultiDict.listvaluesc C s t | 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 r r r r r3 é s
|
zCombinedMultiDict.copyTc C s |rt | ¡ S t | ¡ 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`
|
r\ r] r r r rY õ s
|
zCombinedMultiDict.to_dictc C s t | ¡ S r4 )r= r r r r r Ú__len__ s zCombinedMultiDict.__len__c C s | j D ]}||kr dS qdS )NTF)r r r r r Ú __contains__ s
|
z CombinedMultiDict.__contains__c C s t | j d| jdS r$ )r r r r r r r r' s zCombinedMultiDict.__repr__)N)N)NN)N)F)T)r r( r) r* rx r; Ú classmethodr rF r0 rO r r~ rE r rT r< rV r3 rY r r r' r r r r r s(
|
|
|
|
|
|
r c @ s( e Zd ZdZdd Zdd Zdd ZdS ) Ú ImmutableDictz;An immutable :class:`dict`.
|
|
.. versionadded:: 0.5
|
c C s t | j dt | ¡ dS r$ ©r r r r' r r r r r' s zImmutableDict.__repr__c C s t | S r2 )r r r r r r3 s zImmutableDict.copyc C s | S r4 r r r r r r5 ! s zImmutableDict.__copy__N)r r( r) r* r' r3 r5 r r r r r s r c @ s e Zd ZdZdd Zdd ZdS )ÚImmutableMultiDictz@An immutable :class:`MultiDict`.
|
|
.. versionadded:: 0.5
|
c C s t | S r2 r r r r r r3 + s zImmutableMultiDict.copyc C s | S r4 r r r r r r5 2 s zImmutableMultiDict.__copy__Nr6 r r r r r % s r c @ s( e Zd ZdZdd Zdd Zdd ZdS ) ÚImmutableOrderedMultiDictzGAn immutable :class:`OrderedMultiDict`.
|
|
.. versionadded:: 0.6
|
c C s t | jddS ru )Ú enumerater r r r r Ú_iter_hashitems< s z)ImmutableOrderedMultiDict._iter_hashitemsc C s t | S r2 )ro r r r r r3 ? s z ImmutableOrderedMultiDict.copyc C s | S r4 r r r r r r5 F s z"ImmutableOrderedMultiDict.__copy__N)r r( r) r* r r3 r5 r r r r r 6 s r c @ s" e Zd ZdZdddZdd ZdS )Ú CallbackDictzwA dict that calls a function passed every time something is changed.
|
The function is passed the dict instance.
|
Nc C s t | |p d¡ || _d S )Nr )r r; Ú on_update)r Úinitialr¡ r r r r; O s zCallbackDict.__init__c C s dt | j dt | ¡ dS )Nú<ú ú>r r r r r r' S s zCallbackDict.__repr__)NN)r r( r) r* r; r' r r r r r J s
|
r c @ s¬ e Zd ZdZd*ddZdd Zdd Zd d
|
Zd d Zd d Z dd Z
|
dd Z d+ddZ dd Z dd Zdd Zd d Zd d 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'])
|
Nc C s* t |pd| _dd | jD | _|| _d S )Nr c S s h | ] }| ¡ qS r )Úlowerr r r r Ú <setcomp>f s z%HeaderSet.__init__.<locals>.<setcomp>)r Ú_headersÚ_setr¡ )r Úheadersr¡ r r r r; d s zHeaderSet.__init__c C s | |f¡ dS )z Add a new header to the set.N)rC ©r Úheaderr r r rK i s z HeaderSet.addc C sj | ¡ }|| jkrt|| j |¡ t| jD ] \}}| ¡ |kr0| j|= qRq0| jdk rf| | ¡ dS )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ª r, Úremover r© r¡ )r r r Úidxr r r r® m s
|
|
|
zHeaderSet.removec C sX d}|D ]2}| ¡ }|| jkr| j |¡ | j |¡ d}q|rT| jdk rT| | ¡ dS )zAdd 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? rK r¡ )r ÚiterableZ inserted_anyr r r r r rC s
|
zHeaderSet.updatec C s( z| |¡ W n tk
|
r" Y nX dS )zdLike :meth:`remove` but ignores errors.
|
|
:param header: the header to be discarded.
|
N)r® r, r¬ r r r Údiscard s zHeaderSet.discardc C s4 | ¡ }t| jD ] \}}| ¡ |kr| S qdS )zReturn the index of the header in the set or return -1 if not found.
|
|
:param header: the header to be looked up.
|
éÿÿÿÿ)r§ r r© )r r r¯ rN r r r Úfind s
|
|
zHeaderSet.findc C s | |¡}|dk rt||S )zReturn the index of the header in the set or raise an
|
:exc:`IndexError`.
|
|
:param header: the header to be looked up.
|
r )r³ Ú
|
IndexError)r r r/ r r r Úindex¦ s
|
zHeaderSet.indexc C s. | j ¡ | jdd
= | jdk r*| | ¡ dS )zClear the set.N)rª rB r© r¡ r r r r rB ± s
|
|
zHeaderSet.clearFc C s |rt | jS t | jS )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ª )r Zpreserve_casingr r r Úas_set¸ s
|
zHeaderSet.as_setc C s d ttj| j¡S )z2Convert the header set into an HTTP header string.z, )ÚjoinÚmapÚhttpZquote_header_valuer© r r r r Ú to_headerÅ s zHeaderSet.to_headerc C s
|
| j | S r4 )r© )r r¯ r r r rF É s zHeaderSet.__getitem__c C s4 | j |¡}| j | ¡ ¡ | jd k r0| | ¡ d S r4 )r© r_ rª r® r§ r¡ )r r¯ r/ r r r r{ Ì s
|
zHeaderSet.__delitem__c C sL | j | }| j | ¡ ¡ || j |< | j | ¡ ¡ | jd k rH| | ¡ d S r4 )r© rª r® r§ rK r¡ )r r¯ r Úoldr r r rI Ò s
|
|
|
zHeaderSet.__setitem__c C s | ¡ | jkS r4 )r§ rª r¬ r r r r Ú s zHeaderSet.__contains__c C s
|
t | jS r4 )r= rª r r r r r Ý s zHeaderSet.__len__c C s
|
t | jS r4 )rq r© r r r r rE à s zHeaderSet.__iter__c C s
|
t | jS r4 )Úboolrª r r r r Ú__bool__ã s zHeaderSet.__bool__c C s | ¡ S r4 )rº r r r r Ú__str__æ s zHeaderSet.__str__c C s t | j d| jdS r$ )r r r© r r r r r' é s zHeaderSet.__repr__)NN)F)r r( r) r* r; rK r® rC r± r³ rµ rB r¶ rº rF r{ rI r r rE r½ r¾ r' r r r r r¦ W s(
|
|
|
r¦ )r¹ N) Ú
|
__future__r Úcollections.abcr r3 r Ú r Ú _internalr Zmixinsr
|
r r r r r" r r# r r+ r1 r rg ro r r r r r r¦ r¹ r r r r Ú<module> s8 ) N 6
|
