131 lines
4.0 KiB
Python
131 lines
4.0 KiB
Python
"""
|
|
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)
|