pallets__werkzeug-2194

{
  "status": "ok",
  "stdout": "src/werkzeug/datastructures.py:1413:class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "522:    def to_dict(self, flat=True):\n1519:    def to_dict(self, flat=True):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "    def to_dict(self, flat=True):\n        \"\"\"Return the contents as regular dict.  If `flat` is `True` the\n        returned dict will only have the first item present, if `flat` is\n        `False` all values will be returned as lists.\n\n        :param flat: If set to `False` the dict returned will have lists\n                     with all the values in it.  Otherwise it will only\n                     contain the first value for each key.\n        :return: a :class:`dict`\n        \"\"\"\n        if flat:\n            return dict(self.items())\n        return dict(self.lists())\n\n    def update(self, mapping):\n        \"\"\"update() extends rather than replaces existing key lists:\n\n        >>> a = MultiDict({'x': 1})\n        >>> b = MultiDict({'x': 2, 'y': 3})",
  "start_line": 522,
  "end_line": 540,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "    def to_dict(self, flat=True):\n        \"\"\"Return the contents as regular dict.  If `flat` is `True` the\n        returned dict will only have the first item present, if `flat` is\n        `False` all values will be returned as lists.\n\n        :param flat: If set to `False` the dict returned will have lists\n                     with all the values in it.  Otherwise it will only\n                     contain the first item for each key.\n        :return: a :class:`dict`\n        \"\"\"\n        rv = {}\n        for d in reversed(self.dicts):",
  "start_line": 1519,
  "end_line": 1530,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "    def to_dict(self, flat=True):\n        \"\"\"Return the contents as regular dict.  If `flat` is `True` the\n        returned dict will only have the first item present, if `flat` is\n        `False` all values will be returned as lists.\n\n        :param flat: If set to `False` the dict returned will have lists\n                     with all the values in it.  Otherwise it will only\n                     contain the first item for each key.\n        :return: a :class:`dict`\n        \"\"\"\n        rv = {}\n        for d in reversed(self.dicts):\n            rv.update(d.to_dict(flat))\n        return rv\n\n    def __len__(self):\n        return len(self._keys_impl())\n\n    def __contains__(self, key):\n        for d in self.dicts:\n            if key in d:\n                return True\n        return False\n\n    def has_key(self, key):\n        \"\"\"\n        .. deprecated:: 2.0\n            Will be removed in Werkzeug 2.1. Use ``key in data``\n            instead.\n        \"\"\"\n        warnings.warn(\n            \"'has_key' is deprecated and will be removed in Werkzeug\"",
  "start_line": 1519,
  "end_line": 1550,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "getlist: ['bar3', 'bar', 'bar2']\nto_dict(flat=False): {'foo': ['bar3']}\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "            self[key] = default\n        else:\n            default = self[key]\n        return default\n\n    def setlistdefault(self, key, default_list=None):\n        \"\"\"Like `setdefault` but sets multiple values.  The list returned\n        is not a copy, but the list that is actually used internally.  This\n        means that you can put new values into the dict by appending items\n        to the list:\n\n        >>> d = MultiDict({\"foo\": 1})\n        >>> d.setlistdefault(\"foo\").extend([2, 3])\n        >>> d.getlist(\"foo\")\n        [1, 2, 3]\n\n        :param key: The key to be looked up.\n        :param default_list: An iterable of default values.  It is either copied\n                             (in case it was a list) or converted into a list\n                             before returned.\n        :return: a :class:`list`\n        \"\"\"\n        if key not in self:\n            default_list = list(default_list or ())\n            dict.__setitem__(self, key, default_list)\n        else:\n            default_list = dict.__getitem__(self, key)\n        return default_list\n\n    def items(self, multi=False):\n        \"\"\"Return an iterator of ``(key, value)`` pairs.\n\n        :param multi: If set to `True` the iterator returned will have a pair\n                      for each value of each key.  Otherwise it will only\n                      contain pairs for the first value of each key.\n        \"\"\"\n        for key, values in dict.items(self):\n            if multi:\n                for value in values:\n                    yield key, value\n            else:\n                yield key, values[0]\n\n    def lists(self):\n        \"\"\"Return a iterator of ``(key, values)`` pairs, where values is the list\n        of all values associated with the key.\"\"\"\n        for key, values in dict.items(self):\n            yield key, list(values)\n\n    def values(self):\n        \"\"\"Returns an iterator of the first value on every key's value list.\"\"\"\n        for values in dict.values(self):\n            yield values[0]\n\n    def listvalues(self):\n        \"\"\"Return an iterator of all values associated with a key.  Zipping\n        :meth:`keys` and this is the same as calling :meth:`lists`:\n\n        >>> d = MultiDict({\"foo\": [1, 2, 3]})\n        >>> zip(d.keys(), d.listvalues()) == d.lists()\n        True\n        \"\"\"\n        return dict.values(self)\n\n    def copy(self):\n        \"\"\"Return a shallow copy of this object.\"\"\"\n        return self.__class__(self)\n\n    def deepcopy(self, memo=None):\n        \"\"\"Return a deep copy of this object.\"\"\"\n        return self.__class__(deepcopy(self.to_dict(flat=False), memo))\n",
  "start_line": 450,
  "end_line": 521,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict):\n    \"\"\"A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict`\n    instances as sequence and it will combine the return values of all wrapped\n    dicts:\n\n    >>> from werkzeug.datastructures import CombinedMultiDict, MultiDict\n    >>> post = MultiDict([('foo', 'bar')])\n    >>> get = MultiDict([('blub', 'blah')])\n    >>> combined = CombinedMultiDict([get, post])\n    >>> combined['foo']\n    'bar'\n    >>> combined['blub']\n    'blah'\n\n    This works for all read operations and will raise a `TypeError` for\n    methods that usually change data which isn't possible.\n\n    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a\n    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will\n    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP\n    exceptions.\n    \"\"\"\n\n    def __reduce_ex__(self, protocol):\n        return type(self), (self.dicts,)\n\n    def __init__(self, dicts=None):\n        self.dicts = list(dicts) or []\n\n    @classmethod\n    def fromkeys(cls, keys, value=None):\n        raise TypeError(f\"cannot create {cls.__name__!r} instances by fromkeys\")\n\n    def __getitem__(self, key):\n        for d in self.dicts:\n            if key in d:\n                return d[key]\n        raise exceptions.BadRequestKeyError(key)\n\n    def get(self, key, default=None, type=None):\n        for d in self.dicts:\n            if key in d:\n                if type is not None:\n                    try:\n                        return type(d[key])\n                    except ValueError:\n                        continue\n                return d[key]\n        return default\n\n    def getlist(self, key, type=None):\n        rv = []\n        for d in self.dicts:\n            rv.extend(d.getlist(key, type))\n        return rv\n\n    def _keys_impl(self):\n        \"\"\"This function exists so __len__ can be implemented more efficiently,\n        saving one list creation from an iterator.\n        \"\"\"\n        rv = set()\n        rv.update(*self.dicts)\n        return rv\n\n    def keys(self):\n        return self._keys_impl()\n\n    def __iter__(self):",
  "start_line": 1413,
  "end_line": 1480,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "            dict.__init__(self, tmp)\n\n    def __getstate__(self):\n        return dict(self.lists())\n\n    def __setstate__(self, value):\n        dict.clear(self)\n        dict.update(self, value)\n\n    def __iter__(self):\n        # Work around https://bugs.python.org/issue43246.\n        # (`return super().__iter__()` also works here, which makes this look\n        # even more like it should be a no-op, yet it isn't.)\n        return dict.__iter__(self)\n\n    def __getitem__(self, key):\n        \"\"\"Return the first data value for this key;\n        raises KeyError if not found.\n\n        :param key: The key to be looked up.\n        :raise KeyError: if the key does not exist.\n        \"\"\"\n\n        if key in self:\n            lst = dict.__getitem__(self, key)\n            if len(lst) > 0:\n                return lst[0]\n        raise exceptions.BadRequestKeyError(key)\n\n    def __setitem__(self, key, value):\n        \"\"\"Like :meth:`add` but removes an existing key first.\n\n        :param key: the key for the value.\n        :param value: the value to set.\n        \"\"\"\n        dict.__setitem__(self, key, [value])\n\n    def add(self, key, value):\n        \"\"\"Adds a new value for the key.\n\n        .. versionadded:: 0.6\n\n        :param key: the key for the value.\n        :param value: the value to add.\n        \"\"\"\n        dict.setdefault(self, key, []).append(value)\n\n    def getlist(self, key, type=None):\n        \"\"\"Return the list of items for a given key. If that key is not in the\n        `MultiDict`, the return value will be an empty list.  Just like `get`,\n        `getlist` accepts a `type` parameter.  All items will be converted\n        with the callable defined there.\n\n        :param key: The key to be looked up.\n        :param type: A callable that is used to cast the value in the\n                     :class:`MultiDict`.  If a :exc:`ValueError` is raised\n                     by this callable the value will be removed from the list.\n        :return: a :class:`list` of all the values for the key.\n        \"\"\"\n        try:\n            rv = dict.__getitem__(self, key)\n        except KeyError:\n            return []\n        if type is None:\n            return list(rv)\n        result = []\n        for item in rv:\n            try:\n                result.append(type(item))\n            except ValueError:\n                pass\n        return result\n\n    def setlist(self, key, new_list):\n        \"\"\"Remove the old values for a key and add new ones.  Note that the list\n        you pass the values in will be shallow-copied before it is inserted in\n        the dictionary.\n\n        >>> d = MultiDict()\n        >>> d.setlist('foo', ['1', '2'])\n        >>> d['foo']\n        '1'\n        >>> d.getlist('foo')\n        ['1', '2']\n\n        :param key: The key for which the values are set.\n        :param new_list: An iterable with the new values for the key.  Old values\n                         are removed first.\n        \"\"\"\n        dict.__setitem__(self, key, list(new_list))\n\n    def setdefault(self, key, default=None):\n        \"\"\"Returns the value for the key if it is in the dict, otherwise it\n        returns `default` and sets that value for `key`.\n\n        :param key: The key to be looked up.\n        :param default: The default value to be returned if the key is not\n                        in the dict.  If not further specified it's `None`.\n        \"\"\"\n        if key not in self:\n            self[key] = default",
  "start_line": 350,
  "end_line": 450,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "                        continue\n                    value = list(value)\n                else:\n                    value = [value]\n                tmp[key] = value\n            dict.__init__(self, tmp)\n        else:\n            tmp = {}\n            for key, value in mapping or ():\n                tmp.setdefault(key, []).append(value)\n            dict.__init__(self, tmp)\n\n    def __getstate__(self):\n        return dict(self.lists())\n\n    def __setstate__(self, value):\n        dict.clear(self)\n        dict.update(self, value)\n\n    def __iter__(self):\n        # Work around https://bugs.python.org/issue43246.",
  "start_line": 340,
  "end_line": 360,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "    \"\"\"\n\n    def __init__(self, mapping=None):\n        if isinstance(mapping, MultiDict):\n            dict.__init__(self, ((k, l[:]) for k, l in mapping.lists()))\n        elif isinstance(mapping, dict):\n            tmp = {}\n            for key, value in mapping.items():\n                if isinstance(value, (tuple, list)):\n                    if len(value) == 0:\n                        continue",
  "start_line": 330,
  "end_line": 340,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "lists(): [('foo', ['bar3', 'bar', 'bar2'])]\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "155:class ImmutableMultiDictMixin(ImmutableDictMixin):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "class ImmutableMultiDictMixin(ImmutableDictMixin):\n    \"\"\"Makes a :class:`MultiDict` immutable.\n\n    .. versionadded:: 0.5\n\n    :private:\n    \"\"\"\n\n    def __reduce_ex__(self, protocol):\n        return type(self), (list(self.items(multi=True)),)\n\n    def _iter_hashitems(self):\n        return self.items(multi=True)\n\n    def add(self, key, value):\n        is_immutable(self)\n\n    def popitemlist(self):\n        is_immutable(self)\n\n    def poplist(self, key):\n        is_immutable(self)\n\n    def setlist(self, key, new_list):\n        is_immutable(self)\n\n    def setlistdefault(self, key, default_list=None):\n        is_immutable(self)\n\n\ndef _calls_update(name):\n    def oncall(self, *args, **kw):\n        rv = getattr(super(UpdateDictMixin, self), name)(*args, **kw)\n\n        if self.on_update is not None:\n            self.on_update(self)\n\n        return rv\n\n    oncall.__name__ = name\n    return oncall\n\n\nclass UpdateDictMixin(dict):\n    \"\"\"Makes dicts call `self.on_update` on modifications.\n",
  "start_line": 155,
  "end_line": 200,
  "total_lines": 3051,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/werkzeug/datastructures.py",
  "content": "class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict):\n    \"\"\"A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict`\n    instances as sequence and it will combine the return values of all wrapped\n    dicts:\n\n    >>> from werkzeug.datastructures import CombinedMultiDict, MultiDict\n    >>> post = MultiDict([('foo', 'bar')])\n    >>> get = MultiDict([('blub', 'blah')])\n    >>> combined = CombinedMultiDict([get, post])\n    >>> combined['foo']\n    'bar'\n    >>> combined['blub']\n    'blah'\n\n    This works for all read operations and will raise a `TypeError` for\n    methods that usually change data which isn't possible.\n\n    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a\n    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will\n    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP\n    exceptions.\n    \"\"\"\n\n    def __reduce_ex__(self, protocol):\n        return type(self), (self.dicts,)\n\n    def __init__(self, dicts=None):\n        self.dicts = list(dicts) or []\n\n    @classmethod\n    def fromkeys(cls, keys, value=None):\n        raise TypeError(f\"cannot create {cls.__name__!r} instances by fromkeys\")\n\n    def __getitem__(self, key):\n        for d in self.dicts:\n            if key in d:\n                return d[key]\n        raise exceptions.BadRequestKeyError(key)\n\n    def get(self, key, default=None, type=None):\n        for d in self.dicts:\n            if key in d:\n                if type is not None:\n                    try:\n                        return type(d[key])\n                    except ValueError:\n                        continue\n                return d[key]\n        return default\n\n    def getlist(self, key, type=None):\n        rv = []\n        for d in self.dicts:\n            rv.extend(d.getlist(key, type))\n        return rv\n\n    def _keys_impl(self):\n        \"\"\"This function exists so __len__ can be implemented more efficiently,\n        saving one list creation from an iterator.\n        \"\"\"\n        rv = set()\n        rv.update(*self.dicts)\n        return rv\n\n    def keys(self):\n        return self._keys_impl()\n\n    def __iter__(self):\n        return iter(self.keys())\n\n    def items(self, multi=False):\n        found = set()\n        for d in self.dicts:\n            for key, value in d.items(multi):\n                if multi:\n                    yield key, value\n                elif key not in found:\n                    found.add(key)\n                    yield key, value\n\n    def values(self):\n        for _key, value in self.items():\n            yield value\n\n    def lists(self):\n        rv = {}\n        for d in self.dicts:\n            for key, values in d.lists():\n                rv.setdefault(key, []).extend(values)\n        return list(rv.items())\n\n    def listvalues(self):\n        return (x[1] for x in self.lists())\n\n    def copy(self):\n        \"\"\"Return a shallow mutable copy of this object.\n\n        This returns a :class:`MultiDict` representing the data at the\n        time of copying. The copy will no longer reflect changes to the\n        wrapped dicts.\n\n        .. versionchanged:: 0.15\n            Return a mutable :class:`MultiDict`.\n        \"\"\"\n        return MultiDict(self)\n\n    def to_dict(self, flat=True):\n        \"\"\"Return the contents as regular dict.  If `flat` is `True` the",
  "start_line": 1413,
  "end_line": 1520,
  "total_lines": 3051,
  "is_truncated": false
}