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]:
return CaseInsensitiveDict(self._store.values())
def __repr__(self) -> str:
return str(dict(self.items()))
Run 1
The code is well-structured and readable. It uses clear class-level documentation, type hints, and a logical method ordering. Nesting is minimal, with only one conditional in __eq__. Intent is clear, especially with the docstring explaining case-insensitive key handling and the lower_items helper. Code length is appropriate—no redundancy. Action granularity is mostly one action per line, though a few generator expressions are slightly dense but still understandable. Reading flow follows the natural progression of a mapping implementation. Minor deductions for the slightly complex generator expressions and the single type: ignore comment, but overall this is highly readable.
Run 2
The code is well-structured with clear separation of methods, strong type hints, and a comprehensive docstring explaining behavior. Nesting is minimal—only one level in `__eq__`. Each method has a single, clear purpose and concise implementation. Readability is enhanced by meaningful variable names and comments that clarify non-obvious logic like the lowercased key storage. The only minor drawbacks are the long `__init__` type annotation line and slight complexity in `__eq__` with type ignore, but overall the code is highly readable.
Run 3
The code is well-structured with clear separation of methods, minimal nesting, and strong readability. Each method performs a single, focused action, and the type hints improve clarity. The docstring is excellent, providing concrete examples of the case-insensitive behavior. The implementation logic is straightforward — using a lowercased key for storage while preserving the original case — and the comments are sparing but helpful. Minor deductions: the `data` variable reassignment in `__init__` is slightly awkward, and `lower_items` could be more concise. Overall, it is clean, idiomatic Python with a natural reading flow and no unnecessary complexity.
Run 1
Code Structure: Logically organized around standard mapping methods, with a consistent internal representation. Nesting: Very shallow; only simple conditional branches appear. Clarity of intent: The class docstring, type annotations, and storage comment clearly explain case-insensitive behavior, although the undefined _VT type variable and unused imports distract and leave the snippet incomplete. Code length: Methods are concise; the extensive docstring is useful but somewhat repetitive. Action granularity: Almost every line performs one clear action, with generator expressions remaining reasonably readable. Reading flow: Methods follow a natural progression from initialization through basic operations, comparison, copying, and representation. Minor weaknesses include the lengthy inline type-ignore comment, tuple indexing in lower_items, and the vague 'Copy is required' comment.
Run 2
Code Structure: Methods are logically organized around the mapping interface, with a consistent internal representation. Nesting: Control flow is shallow, with only simple conditionals. Clarity of intent: The class docstring, type annotations, and storage comment clearly explain case-insensitive lookup and preserved key casing. However, _VT is never defined despite importing TypeVar, and names such as keyval are less descriptive. Code length: Methods are concise; the extensive docstring is useful, though somewhat repetitive. Action granularity: Statements generally perform one action per line; generator expressions remain compact and understandable. Reading flow: Construction, core mapping operations, comparison, copying, and representation follow a natural sequence. The long type-ignore line and tuple indexing slightly interrupt readability.
Run 3
Code Structure: Logically organized into short, focused mapping methods with a consistent internal representation. Nesting: Very shallow, with only simple conditionals and generator expressions. Clarity of intent: The class docstring, type annotations, and storage comment clearly explain case-insensitive lookup and preserved key casing. However, _VT is never defined in the snippet despite importing TypeVar, and names such as keyval are less descriptive. Code length: Implementation is concise; the lengthy docstring provides useful context, though some references to legacy iteration methods add clutter. Action granularity: Statements generally perform one action per line; tuple indexing and comprehensions remain manageable. Reading flow: Methods follow a natural progression from initialization through core mapping operations to comparison, copying, and representation. The long inline type-ignore comment slightly interrupts the otherwise clean presentation.