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 highly readable with a clear, logical class structure. It uses type hints, a docstring with examples, and consistent method definitions. Nesting is minimal—only one conditional in __eq__—and actions are generally one per line. The intent of each method is obvious from its name and implementation. The code is concise but not overly terse, and the reading flow follows a natural order (init, item methods, iteration, length, comparison, copy, repr). Minor deductions could be made for the slightly long __eq__ method and the reliance on type: ignore, but they do not harm overall clarity.
Run 2
The code is well-structured with clear separation of concerns: imports, class definition, type hints, and method implementations are logically organized. Each method has a single, focused responsibility and the action granularity is appropriate with one operation per line. Nesting is minimal and flat, especially in methods like __iter__ and __eq__. The intent of the CaseInsensitiveDict is clearly documented in the docstring with practical examples, and comments explain the internal storage strategy. Type hints throughout enhance readability. The code length is reasonable without unnecessary verbosity. Reading flow is natural as methods follow standard MutableMapping patterns. Minor deductions: the type ignore comment in __eq__ slightly interrupts flow, and the lower_items return statement uses a generator expression wrapped in parentheses that could arguably be simpler.
Run 3
The code is highly readable. It has a clear class-level docstring explaining behavior and edge cases. Structure is logical and flat, with minimal nesting. Methods are concise and follow single-action-per-line patterns. Naming and type hints clarify intent. The use of helper methods like lower_items and the OrderedDict store make the case-insensitive design transparent. A few minor improvements could be made by extracting a helper for key normalization or adding a comment for the return-not-implemented branch, but overall it is clean and maintainable.
Run 1
Code Structure: Well-organized mapping class with focused methods and a clearly defined internal representation. Nesting: Minimal, with only simple conditionals and generator expressions. Clarity of intent: Descriptive names, type annotations, comments, and a comprehensive docstring explain case-insensitive behavior well; however, _VT is not defined in the snippet, and references to legacy iteration methods are distracting. Code length: Methods are concise, though the docstring is comparatively lengthy and some imports are unused. Action granularity: Statements generally perform one action per line; the equality conversion line is slightly crowded by its annotation and suppression comment. Reading flow: Natural progression from initialization through mapping operations to equality, copying, and representation. Overall, highly readable with minor annotation and documentation distractions.
Run 2
Code Structure: Well-organized class with small, focused methods implementing the mapping interface. Nesting: Minimal branching and no deeply nested blocks. Clarity of intent: The descriptive class name, extensive docstring, type annotations, and storage comment clearly explain case-insensitive behavior; however, _VT is not defined in the snippet, and names such as keyval are less expressive. Code length: Implementation is concise, though the docstring is relatively lengthy and the equality conversion line is unwieldy. Action granularity: Statements generally perform one action per line; generator expressions remain compact and understandable. Reading flow: Methods follow a natural sequence from initialization through core mapping operations to comparison, copying, and representation. Minor distractions include unused TypeVar and overload imports and the inline type-ignore annotation.
Run 3
Code Structure: Well-organized class with short, focused methods implementing the mapping interface. Nesting: Minimal branching and no deeply nested blocks. Clarity of intent: The detailed docstring, type annotations, and storage comment clearly explain case-insensitive lookup and preserved casing; however, _VT is never defined despite importing TypeVar, and names such as keyval are less descriptive. Code length: Implementation is concise, though the docstring is relatively long and overload is unused. Action granularity: Statements generally perform one action per line; generator expressions remain compact and understandable. Reading flow: Methods follow a natural sequence from initialization through core operations, comparison, copying, and representation. The long inline type-ignore comment and tuple indexing slightly interrupt an otherwise smooth reading experience.