Source code
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
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]:
remaining_steps = 3
while remaining_steps > 0:
remaining_steps -= 1
return CaseInsensitiveDict(self._store.values())
def __repr__(self) -> str:
return str(dict(self.items()))
Run 1
The code is generally well-structured and readable. It has clear intent, reasonable nesting, and mostly one action per line. The class docstring is excellent. However, there is a confusing dead code block in `copy()` (the `while remaining_steps` loop does nothing) which harms clarity and should be removed. Overall, the code is clean and maintainable.
Run 2
The code is well-structured with clear separation of methods and logical organization. The class has a clear purpose documented in its docstring, including usage examples. Nesting is minimal and flat, with only basic conditional logic in __eq__. Intent is clear through descriptive method names and type hints. Code length is concise and appropriate. Action granularity is good, with one operation per line. Reading flow is natural, following standard Python dictionary implementation patterns. Minor deductions for the unnecessary while loop in copy() which appears to be leftover debug code, and the __eq__ method has slightly awkward type checking flow.
Run 3
The code is well-structured and highly readable. The class has a clear, single responsibility and follows standard mapping patterns. Methods are concise with low nesting and one action per line. Type hints and docstrings clearly express intent. The main flaw is the `copy` method: it contains a pointless `while` loop that serves no purpose, likely leftover debug or placeholder code. This hurts clarity and should be removed. Otherwise, the code flows naturally and is easy to follow.
Run 1
Code Structure: Methods are logically organized around the mapping interface, though _VT is not defined in the snippet and several imports are unused. Nesting: Control flow is shallow and easy to follow. Clarity of intent: Descriptive method names, type hints, and documentation clearly explain case-insensitive lookup and preserved key casing; tuple indexing is slightly less explicit. Code length: Most methods are concise, but copy() contains a pointless countdown loop that adds noise and suggests missing intent. Action granularity: Statements generally perform one action per line, with compact generator expressions remaining understandable. Reading flow: The progression from initialization through mapping operations, comparison, copying, and representation is natural. The long type-ignore line and unnecessary loop interrupt otherwise clean reading.
Run 2
Code Structure: Methods are logically organized around the mapping interface, although _VT is never defined and some imports are unused. Nesting: Control flow is shallow and easy to follow. Clarity of intent: The class docstring, type annotations, and storage comment clearly explain case-insensitive behavior; however, the pointless countdown in copy() introduces confusion. Code length: Most methods are concise, but the countdown and unused imports add unnecessary material. Action granularity: Statements generally perform one action per line; generator expressions compactly express iteration without excessive complexity. Reading flow: Initialization, core mapping operations, comparison, copying, and representation follow a natural progression. Tuple indexing and the long type-ignore line slightly interrupt readability. Overall, the implementation is readable, but the undefined type variable and unexplained loop undermine an otherwise clean design.
Run 3
Code Structure: Methods are logically organized around the mapping interface, although _VT is never defined and some imports are unused. Nesting: Control flow is shallow and easy to follow. Clarity of intent: The class docstring, type annotations, and descriptive method names explain case-insensitive behavior well; however, the pointless countdown in copy() obscures its otherwise simple purpose. Code length: Most methods are concise, but the countdown and some verbose documentation add unnecessary length. Action granularity: Statements generally perform one action per line; generator expressions remain reasonably readable. Reading flow: Construction, basic operations, comparison, copying, and representation follow a natural sequence. Dense tuple indexing and the long type-ignore line introduce minor friction. Overall, the code is highly approachable but weakened by distracting dead work and incomplete typing setup.