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,
c: Mapping[str, _VT] | Iterable[tuple[str, _VT]] | None = None,
**d: _VT,
) -> None:
self._store = OrderedDict()
if c is None:
c = {}
self.update(c, **d)
def __setitem__(self, e: str, f: _VT) -> None:
# Use the lowercased key for lookups, but store the actual
# key alongside the value.
self._store[e.lower()] = (e, f)
def __getitem__(self, g: str) -> _VT:
return self._store[g.lower()][1]
def __delitem__(self, h: str) -> None:
del self._store[h.lower()]
def __iter__(self) -> Iterator[str]:
return (i for i, j in self._store.values())
def __len__(self) -> int:
return len(self._store)
def a(self) -> Iterator[tuple[str, _VT]]:
"""Like iteritems(), but with all lowercase keys."""
return ((k, l[1]) for (k, l) in self._store.items())
def __eq__(self, m: object) -> bool:
if isinstance(m, Mapping):
n: CaseInsensitiveDict[Any] = CaseInsensitiveDict(m) # type: ignore[reportUnknownArgumentType]
else:
return NotImplemented
# Compare insensitively
return dict(self.a()) == dict(n.lower_items())
# Copy is required
def b(self) -> CaseInsensitiveDict[_VT]:
return CaseInsensitiveDict(self._store.values())
def __repr__(self) -> str:
return str(dict(self.items()))
Run 1
The code structure is logically organized with clear class methods, but the readability is severely degraded by the use of meaningless single-letter variable names (e.g., 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'). This destroys clarity of intent, making it difficult to understand what each parameter or variable represents. The docstring is helpful but cannot compensate for the opaque naming throughout the implementation. Additionally, the method names 'a' and 'b' are completely non-descriptive, and there is a broken reference to 'lower_items' in __eq__ while the method is actually named 'a'. Nesting is flat, and line lengths are mostly reasonable, but the reading flow is disrupted by the cryptic identifiers. Action granularity is acceptable, but the severe naming problems make the code significantly harder to read than necessary.
Run 2
The code implements a case-insensitive dictionary with clear intent from the docstring, but readability suffers from poor naming and structure. Multi-character generic type variables (_VT) and methods with single-letter names (a, b) violate clarity, making them ambiguous. The __eq__ method is nested with type ignores and unclear variable names. The lower_items method is logically okay but renamed 'a' destroys intent. Action granularity is acceptable, but code length is inflated by unhelpful comments and repetitive lowercasing. Reading flow is broken by irregular naming (e, f, g, h, i, j, k, l, m, n) that obscure purpose. Flat nesting is mostly maintained, but the __eq__ conditional creates ambiguity. The code lacks meaningful names and uses unnecessary obfuscation, hence a low score.
Run 3
The code is a mix of clear structure and confusing elements. The class docstring is detailed and helpful, and the overall organization follows a logical MutableMapping pattern with one method per concern, which is good for readability. However, several aspects severely hurt clarity: method and variable names are non-descriptive (e.g., 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'm', 'n'), which obscures intent and makes the reading flow unnatural. The '__eq__' method has an awkward structure and a type-ignore comment that breaks flow. Nesting is generally flat, and line lengths are mostly acceptable, but the generator expressions and multiple operations crammed into some lines reduce action granularity. The class works but reads like obfuscated or minified code, which contradicts the otherwise clean structure.
Run 1
Code Structure: Mapping operations are logically separated into short methods, but the undefined _VT and mismatches between documented and implemented method names undermine coherence. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: The class docstring and storage comment explain the design well, but single-letter parameters and methods a/b obscure meaning. The equality method calls lower_items(), although the corresponding method is named a, creating a confusing inconsistency. Code length: Methods are concise; the lengthy docstring provides useful context but references unavailable methods. Action granularity: Statements generally perform one action per line, with compact generator expressions that remain manageable. Reading flow: Standard mapping methods appear in a natural order, but cryptic naming, an unused overload import, and the missing TypeVar definition interrupt comprehension.
Run 2
Code Structure: Methods are logically organized around the mapping interface, with small, focused implementations. Nesting: Minimal branching and no deeply nested blocks make the code easy to scan. Clarity of intent: The class docstring and type annotations explain the design, but single-letter parameters and method names obscure meaning. The documented lower_items and copy methods are named a and b instead, and equality calls the absent lower_items method. The undefined _VT also makes the typing incomplete. Code length: Implementations are concise; the longer docstring provides useful context. Action granularity: Most lines perform one clear operation, although comprehensions require some unpacking mentally. Reading flow: The conventional method sequence supports natural reading, but inconsistent naming and discrepancies between documentation and implementation interrupt comprehension.
Run 3
Code Structure: The class is logically organized into small mapping methods, though _VT is undefined and advertised methods do not match their implementations. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: The class docstring and storage comment explain case-insensitive behavior well, but single-letter parameters and method names a and b obscure meaning. Calling lower_items() despite defining a() creates additional confusion. Code length: Methods are concise; the extensive docstring is useful, although unused imports add clutter. Action granularity: Statements generally perform one action per line, with straightforward generator expressions. Reading flow: Familiar mapping-method ordering supports natural reading, but inconsistent naming, missing type-variable declaration, and the mismatch between documentation and code interrupt understanding.