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 LookupDict(dict[str, _VT]):
"""Dictionary lookup object."""
name: Any
def __init__(self, d: Any = None) -> None:
self.name = d
super().__init__()
def __repr__(self) -> str:
return f"<lookup '{self.name}'>"
def __getattr__(self, e: str) -> _VT | None:
# We need this for type checkers to infer typing
# on attribute access with status_codes.py
if e in self.__dict__:
return self.__dict__[e]
else:
raise AttributeError(
f"'{type(self).__name__}' object has no attribute '{e}'"
)
def __getitem__(self, f: str) -> _VT | None: # type: ignore[override]
# We allow fall-through here, so values default to None
return self.__dict__.get(f, None)
@overload
def c(self, g: str, h: None = None) -> _VT | None: ...
@overload
def c(self, i: str, j: _D | _VT) -> _D | _VT: ...
def c(self, k: str, l: _D | None = None) -> _VT | _D | None:
return self.__dict__.get(k, l)
Run 1
The code is functionally concise but scores poorly on clarity and readability. The class hierarchy is straightforward, but the method names and parameter names are entirely non-descriptive: `c`, `k`, `l`, `f`, `g`, `h`, `i`, `j` convey no intent, forcing readers to infer meaning from context. The variable `_VT`, `_D`, and `d` are not explained. Docstrings are too terse to clarify behavior, especially for `__getitem__` which has unusual fall-through semantics. Overloads for method `c` are cryptic—readers cannot tell what 'c' stands for without external knowledge. The `name: Any` attribute set to `d` (an optional dict) is semantically confusing. Logically, the code is flat and short, but action granularity is reasonable, one operation per line. However, the lack of explicit intention—despite type hints—makes it hard to maintain. Shortness helps, but ambiguous naming and unclear purpose justify a below-average readability score.
Run 2
The code demonstrates basic structure with clear separation among methods, but suffers from poor readability due to cryptic naming (single and double letter variable names), unclear idioms such as storing values in __dict__ directly instead of using dictionary semantics, and a confusing overload design that complicates intent. There's a disconnect between class purpose and implementation—for example, the class extends dict but bypasses the dict body entirely, creating ambiguity about intended storage and semantics. Nesting is low and line length is acceptable, but action granularity and reading flow suffer due to dense or misleading method bodies. The type annotations are extensive, which helps static analysis, yet the terse alias heavy signature choices harm readability. Overall, the code is mechanically simple but semantically unclear.
Run 3
The code is highly unreadable due to several major issues. First, the class inherits from dict but never uses the dict storage — it initializes with super().__init__() but then reads and writes only to __dict__, creating confusing and misleading behavior. Second, single-letter variable names (d, e, f, g, h, i, j, k, l) reveal nothing about intent, violating clarity and action granularity. Third, the overloads are repetitive and obscure the method's purpose. Fourth, __getitem__ ignores the passed key and returns from __dict__, which is both surprising and inconsistent with the dict base class. The docstrings are sparse and do not explain the unusual fall-through design or why __dict__ is used as storage. Overall, the structure is tangled, the naming is cryptic, and the logic is ambiguous — making the code difficult to understand, debug, or maintain.
Run 1
Code Structure: Methods are logically grouped within a small class, but unused imports and undefined type variables distract. Nesting: Almost entirely flat, with only a simple conditional. Clarity of intent: Lookup behavior is partly explained by comments, but single-letter parameters and the method name 'c' obscure meaning. Accessing instance attributes rather than dictionary entries is surprising for a dict subclass. Code length: Concise overall, though overloads and an unnecessary else add some overhead. Action granularity: Each line generally performs one clear action. Reading flow: Constructor, representation, and lookup methods follow a natural sequence, but cryptic naming and inconsistent parameter names across overloads interrupt comprehension.
Run 2
Code Structure: Methods are logically grouped within one class, but unused imports and undefined type variables in the provided snippet distract. Nesting: Very shallow; the unnecessary else after a returning branch is minor. Clarity of intent: The lookup purpose is partially explained by comments, but single-letter parameters and the method name c obscure meaning. Using instance attributes rather than dictionary contents also makes behavior surprising for a dict subclass. Code length: Generally concise, though overloads and typing add visual complexity relative to the small implementation. Action granularity: Each line performs one clear operation, with no compressed multi-action statements. Reading flow: Conventional method ordering and spacing help, but cryptic names, inconsistent parameter names across overloads, and the attribute-backed lookup interrupt comprehension.
Run 3
Code Structure: Methods are logically grouped in a small class, though unused imports and unexplained type variables add clutter. Nesting: Shallow control flow makes the code easy to scan; the else after raise could be avoided. Clarity of intent: The docstring and comments help, but single-letter parameters and the method name c obscure purpose. Using instance attributes rather than dictionary entries for lookups is surprising for a dict subclass. Code length: Mostly concise, although overload declarations and formatting add visual overhead. Action granularity: Each line generally performs one action. Reading flow: Initialization, representation, and lookup methods follow a reasonable order, but inconsistent parameter names across overloads interrupt comprehension. _VT and _D are not defined in the snippet, making the typing harder to understand.