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()][0x1]
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[0x1]) 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 shows good structure with clear class organization and proper type hints. The docstring is helpful but somewhat verbose. However, several readability issues exist: the use of hexadecimal `0x1` instead of `1` for tuple indexing is confusing and unconventional; the equality comparison logic is a bit convoluted with the `NotImplemented` return and type ignore comment; variable names like `casedkey`, `keyval`, and `lowerkey` are inconsistent (mixing styles); the `__iter__` generator expression could be clearer with a named variable instead of underscore. The class is relatively flat with minimal nesting, which is good. Action granularity is mostly one action per line, though some generator expressions pack multiple operations. Overall the intent is clear, but these minor issues prevent maximum readability.
Run 2
The code is generally readable with clear structure and intent. It benefits from type hints, a docstring with usage examples, and a logical organization. However, readability is slightly reduced by unconventional choices like `[0x1]` instead of `[1]`, which obscures intent, and the use of `reportUnknownArgumentType`/`type: ignore` comments that add noise. Nesting is flat and methods are concise, with one action per line in most cases. The `__eq__` method has a slightly awkward flow, and the `lower_items` generator expression is compact but less natural to read. Overall, the code is well-structured but could be improved with clearer indexing syntax and fewer type-related suppressions.
Run 3
The code is generally well-structured with clear class-level documentation, logical method organization, and type hints that clarify intent. Methods are short and focused, with one action per line in most cases. Nesting is minimal. However, readability is somewhat reduced by the use of non-obvious hexadecimal indexing (`0x1`) instead of `1`, inconsistent use of generator expressions vs. list/dict comprehensions in `__iter__` and `lower_items`, and a slightly convoluted `__eq__` method that could be simplified. The `type: ignore` comment in `__eq__` also hints at type-checking friction that may confuse readers. Overall, the code is understandable but has a few stylistic quirks that prevent it from being maximally readable.
Run 1
Code Structure: Well-organized class with small, focused methods implementing a familiar mapping interface. Nesting: Minimal nesting; simple conditionals and generator expressions keep complexity low. Clarity of intent: The detailed docstring, type annotations, and storage comment explain case-insensitive behavior clearly. However, hexadecimal tuple indices (0x1) obscure ordinary indexing, and _VT is referenced without a visible definition. Code length: Methods are concise; the docstring is lengthy but useful, while unused imports add minor clutter. Action granularity: Statements generally perform one action each, with compact expressions remaining understandable. Reading flow: Methods follow a natural progression from initialization through mapping operations to comparison, copying, and representation. Minor distractions include the long type-ignore line, terse tuple variable names, and references to legacy iteration methods.
Run 2
Code Structure: Well-organized class with small methods corresponding to standard mapping operations. Nesting: Very shallow, with only simple conditionals and generator expressions. Clarity of intent: The descriptive class name, comprehensive docstring, type annotations, and storage comment explain the case-insensitive behavior clearly. However, _VT is never defined despite importing TypeVar, and hexadecimal tuple indices (0x1) unnecessarily obscure ordinary indexing. Code length: Implementation is concise; the lengthy docstring is mostly useful, though some documentation and comments reference outdated methods or state the obvious. Action granularity: Statements generally perform one clear action each. Reading flow: Methods progress naturally from initialization through mapping operations to comparison, copying, and representation. Long annotation lines and inconsistent variable naming slightly interrupt otherwise smooth reading.
Run 3
Code Structure: Methods are logically organized around the mapping interface, with a consistent internal representation. Nesting: Minimal nesting and short methods make control flow easy to follow. Clarity of intent: The class docstring, descriptive method names, and type annotations clearly explain case-insensitive behavior. However, _VT is not defined in the snippet despite importing TypeVar, and hexadecimal tuple indices (0x1) unnecessarily obscure simple value access. Code length: Implementation is concise; the lengthy docstring mostly provides useful context. Action granularity: Statements generally perform one action per line, although generator expressions and the long equality-conversion line require slightly more effort to parse. Reading flow: Construction, core mapping operations, comparison, copying, and representation follow a natural sequence. Minor distractions include outdated iteritems references and the verbose type-ignore comment.