werkzeug.datastructures.CombinedMultiDict

class documentation

class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict): (source)

View In Hierarchy

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.

Class Method fromkeys Undocumented
Method __contains__ Undocumented
Method __getitem__ Return the first data value for this key; raises KeyError if not found.
Method __init__ Undocumented
Method __iter__ Undocumented
Method __len__ Undocumented
Method __reduce_ex__ Undocumented
Method __repr__ Undocumented
Method copy Return a shallow mutable copy of this object.
Method get 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:...
Method getlist 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.
Method items Return an iterator of ``(key, value)`` pairs.
Method keys Undocumented
Method lists Return a iterator of ``(key, values)`` pairs, where values is the list of all values associated with the key.
Method listvalues Return an iterator of all values associated with a key. Zipping :meth:`keys` and this is the same as calling :meth:`lists`:
Method to_dict 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.
Method values Returns an iterator of the first value on every key's value list.
Instance Variable dicts Undocumented
Method _keys_impl This function exists so __len__ can be implemented more efficiently, saving one list creation from an iterator.

Inherited from ImmutableMultiDictMixin:

Method add Undocumented
Method popitemlist Undocumented
Method poplist Undocumented
Method setlist Undocumented
Method setlistdefault Undocumented
Method _iter_hashitems Undocumented

Inherited from ImmutableDictMixin (via ImmutableMultiDictMixin):

Method __delitem__ Undocumented
Method __hash__ Undocumented
Method __setitem__ Undocumented
Method clear Undocumented
Method pop Undocumented
Method popitem Undocumented
Method setdefault Undocumented
Method update Undocumented
Instance Variable _hash_cache Undocumented

Inherited from MultiDict (via ImmutableMultiDictMixin, ImmutableDictMixin):

Method __copy__ Undocumented
Method __deepcopy__ Undocumented
Method __getstate__ Undocumented
Method __setstate__ Undocumented
Method deepcopy Return a deep copy of this object.
@classmethod
def fromkeys(cls, keys, value=None): (source)
overrides werkzeug.datastructures.ImmutableDictMixin.fromkeys

Undocumented

def __contains__(self, key): (source)

Undocumented

def __getitem__(self, key): (source)
overrides werkzeug.datastructures.MultiDict.__getitem__

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.

def __init__(self, dicts=None): (source)
overrides werkzeug.datastructures.MultiDict.__init__

Undocumented

def __iter__(self): (source)
overrides werkzeug.datastructures.MultiDict.__iter__

Undocumented

def __len__(self): (source)

Undocumented

def __reduce_ex__(self, protocol): (source)
overrides werkzeug.datastructures.ImmutableMultiDictMixin.__reduce_ex__

Undocumented

def __repr__(self): (source)
overrides werkzeug.datastructures.MultiDict.__repr__

Undocumented

def copy(self): (source)
overrides werkzeug.datastructures.MultiDict.copy

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`.

def get(self, key, default=None, type=None): (source)
overrides werkzeug.datastructures.TypeConversionDict.get

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.

def getlist(self, key, type=None): (source)
overrides werkzeug.datastructures.MultiDict.getlist

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.

def items(self, multi=False): (source)
overrides werkzeug.datastructures.MultiDict.items

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.

def keys(self): (source)

Undocumented

def lists(self): (source)
overrides werkzeug.datastructures.MultiDict.lists

Return a iterator of ``(key, values)`` pairs, where values is the list of all values associated with the key.

def listvalues(self): (source)
overrides werkzeug.datastructures.MultiDict.listvalues

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

def to_dict(self, flat=True): (source)
overrides werkzeug.datastructures.MultiDict.to_dict

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`

def values(self): (source)
overrides werkzeug.datastructures.MultiDict.values

Returns an iterator of the first value on every key's value list.

dicts = (source)

Undocumented

def _keys_impl(self): (source)

This function exists so __len__ can be implemented more efficiently, saving one list creation from an iterator.