| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130 |
- """
- requests.structures
- ~~~~~~~~~~~~~~~~~~~
- Data structures that power Requests.
- """
- from __future__ import annotations
- from collections import OrderedDict
- from collections.abc import Iterable, Iterator, Mapping
- from typing import Any, Generic, TypeVar, overload
- from .compat import MutableMapping
- _VT = TypeVar("_VT")
- _D = TypeVar("_D")
- class CaseInsensitiveDict(MutableMapping[str, _VT], Generic[_VT]):
- """A case-insensitive ``dict``-like object.
- Implements all methods and operations of
- ``MutableMapping`` as well as dict's ``copy``. Also
- provides ``lower_items``.
- All keys are expected to be strings. The structure remembers the
- case of the last key to be set, and ``iter(instance)``,
- ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
- will contain case-sensitive keys. However, querying and contains
- testing is case insensitive::
- cid = CaseInsensitiveDict()
- cid['Accept'] = 'application/json'
- cid['aCCEPT'] == 'application/json' # True
- list(cid) == ['Accept'] # True
- For example, ``headers['content-encoding']`` will return the
- value of a ``'Content-Encoding'`` response header, regardless
- of how the header name was originally stored.
- If the constructor, ``.update``, or equality comparison
- operations are given keys that have equal ``.lower()``s, the
- behavior is undefined.
- """
- _store: OrderedDict[str, tuple[str, _VT]]
- def __init__(
- self,
- data: Mapping[str, _VT] | Iterable[tuple[str, _VT]] | None = None,
- **kwargs: _VT,
- ) -> None:
- self._store = OrderedDict()
- if data is None:
- data = {}
- self.update(data, **kwargs)
- def __setitem__(self, key: str, value: _VT) -> None:
- # Use the lowercased key for lookups, but store the actual
- # key alongside the value.
- self._store[key.lower()] = (key, value)
- def __getitem__(self, key: str) -> _VT:
- return self._store[key.lower()][1]
- def __delitem__(self, key: str) -> None:
- del self._store[key.lower()]
- def __iter__(self) -> Iterator[str]:
- return (casedkey for casedkey, _ in self._store.values())
- def __len__(self) -> int:
- return len(self._store)
- def lower_items(self) -> Iterator[tuple[str, _VT]]:
- """Like iteritems(), but with all lowercase keys."""
- return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
- def __eq__(self, other: object) -> bool:
- if isinstance(other, Mapping):
- other_dict: CaseInsensitiveDict[Any] = CaseInsensitiveDict(other) # type: ignore[reportUnknownArgumentType]
- else:
- return NotImplemented
- # Compare insensitively
- return dict(self.lower_items()) == dict(other_dict.lower_items())
- # Copy is required
- def copy(self) -> CaseInsensitiveDict[_VT]:
- return CaseInsensitiveDict(self._store.values())
- def __repr__(self) -> str:
- return str(dict(self.items()))
- class LookupDict(dict[str, _VT]):
- """Dictionary lookup object."""
- name: Any
- def __init__(self, name: Any = None) -> None:
- self.name = name
- super().__init__()
- def __repr__(self) -> str:
- return f"<lookup '{self.name}'>"
- def __getattr__(self, key: str) -> _VT | None:
- # We need this for type checkers to infer typing
- # on attribute access with status_codes.py
- if key in self.__dict__:
- return self.__dict__[key]
- else:
- raise AttributeError(
- f"'{type(self).__name__}' object has no attribute '{key}'"
- )
- def __getitem__(self, key: str) -> _VT | None: # type: ignore[override]
- # We allow fall-through here, so values default to None
- return self.__dict__.get(key, None)
- @overload
- def get(self, key: str, default: None = None) -> _VT | None: ...
- @overload
- def get(self, key: str, default: _D | _VT) -> _D | _VT: ...
- def get(self, key: str, default: _D | None = None) -> _VT | _D | None:
- return self.__dict__.get(key, default)
|
