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 class has a clear purpose and mostly logical organization, with a docstring that explains case-insensitive behavior and key storage. However, readability is undermined by inconsistent formatting: missing blank lines between methods, inconsistent indentation/alignment (e.g., in __init__ and __eq__), and trailing whitespace in function signatures. The code is not deeply nested and methods are mostly short, which helps, but occasional confusing constructs like 'type: ignore[reportUnknownArgumentType]' add noise without context. Action granularity is mostly fine, though generator expressions in lower_items are slightly dense. Overall, the code is understandable but the formatting inconsistencies disrupt reading flow and make it feel less polished than it should be.
Run 2
The code is generally well-structured with clear intent, especially in the docstring and method comments. However, several issues reduce readability: inconsistent spacing, a misplaced closing parenthesis in __init__, and multiple methods crammed together without blank lines (e.g., lower_items, __eq__, copy, __repr__). Some lines are too long and combine multiple actions. Nesting is low, which is good, but formatting inconsistencies and minor layout problems disrupt reading flow. Overall, the logic is understandable but the presentation could be cleaner.
Run 3
The code is generally well-structured with clear class and method separation. It uses type hints, docstrings, and comments effectively. However, readability is reduced by minor issues: the `__init__` signature has awkward spacing before `)`, multiple methods are packed together without blank lines (e.g., `lower_items`, `__eq__`, `copy`, `__repr__`), and the generator expressions in `__iter__` and `lower_items` are compact but dense. The `__eq__` method includes a type-ignore comment that adds noise. Overall, intent is clear and the logic is flat, but formatting inconsistencies and slight verbosity in some operations lower the score.
Run 1
Code Structure: The class is logically organized into small mapping methods, though missing blank lines between some methods and imports reduce visual separation. Nesting: Control flow is shallow and easy to follow. Clarity of intent: The detailed docstring, conventional method names, and comments explain case-insensitive lookup and preservation of original keys. However, _VT is never defined despite importing TypeVar, and names such as keyval are less descriptive. Code length: Implementation methods are concise; documentation is lengthy but useful. Action granularity: Statements generally perform one action per line, with straightforward generator expressions. Reading flow: Methods follow a natural progression from initialization through mapping operations to equality and representation. Awkward constructor formatting and a long type-ignore line interrupt otherwise smooth reading.
Run 2
Code Structure: Logically organized into small mapping methods, though missing blank lines between some methods and before the class weaken visual separation. Nesting: Very shallow, with only simple conditionals. Clarity of intent: The class docstring, type annotations, and storage comment clearly explain case-insensitive behavior; however, _VT is not defined in the snippet, and unused imports introduce distraction. Code length: Implementation is concise, although the docstring is relatively long and references legacy iteration methods. Action granularity: Statements generally perform one action per line; generator expressions are compact and understandable. Reading flow: Methods follow a natural progression from initialization through mapping operations, equality, copying, and representation. Awkward constructor formatting and the long annotated assignment in __eq__ slightly interrupt readability.
Run 3
Code Structure: Well organized into a focused mapping class with small, logically grouped methods, though missing blank lines weaken separation. Nesting: Very shallow, with only simple conditionals. Clarity of intent: The class docstring, descriptive method names, annotations, and storage comment clearly explain case-insensitive behavior. However, _VT is referenced without a visible definition, some imports are unused, and tuple indexing slightly obscures the internal representation. Code length: Implementation is concise; the lengthy docstring provides useful context but references legacy methods. Action granularity: Statements generally perform one action per line, with compact generator expressions remaining readable. Reading flow: Follows conventional mapping operations naturally, but the malformed-looking constructor spacing, long equality annotation line, and inconsistent method spacing interrupt the flow.