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, name: Any = None) -> None:
self.name = name
super().__init__()
def __repr__(self) -> str:
return f"<lookup '{self.name}'>"
def __getattr__(self, key: str) -> _VT | None:
# We need this for type checkers to infer typing
# on attribute access with status_codes.py
if key in self.__dict__:
return self.__dict__[key]
else:
raise AttributeError(
f"'{type(self).__name__}' object has no attribute '{key}'"
)
def __getitem__(self, key: str) -> _VT | None: # type: ignore[override]
# We allow fall-through here, so values default to None
return self.__dict__.get(key, None)
@overload
def get(self, key: str, default: None = None) -> _VT | None: ...
@overload
def get(self, key: str, default: _D | _VT) -> _D | _VT: ...
def get(self, key: str, default: _D | None = None) -> _VT | _D | None:
return self.__dict__.get(key, default)
Run 1
The code is generally readable, with clear class naming and straightforward method definitions. However, several issues reduce clarity. The `LookupDict` is described as a dictionary lookup object, but its `__getitem__` and `get` methods read from `__dict__` rather than the dictionary itself, which is confusing and seems unintended. The `__getattr__` method has odd branching: it checks `key in self.__dict__`, returns the value if true, then raises AttributeError in the else, but never actually falls through—making the `if`/`else` redundant. The `__repr__` is concise and clear. The overloads for `get` add some complexity but are manageable. Overall, structure is okay but intent is ambiguous due to the mismatch between class purpose and internal behavior, and the action granularity varies (multiple actions in one line in `__getitem__`). The nesting is minimal, which is a positive.
Run 2
The code is generally readable but has several clarity issues. The class structure is logical with clear method separation, and nesting is minimal. However, the intent is ambiguous: LookupDict inherits from dict but overrides __getitem__ to look in __dict__ instead of the dict itself, which is surprising and confusing. The __getattr__ implementation seems counterintuitive—it checks if the key exists in __dict__ but then returns it, otherwise raises AttributeError, yet the docstring implies fall-through behavior. Method docstrings are sparse and don't explain the unusual design. Type hints add complexity, especially the overloads on get(). The code is concise but could benefit from better documentation of its non-standard behavior. Reading flow is adequate.
Run 3
The code is highly readable with a clear purpose: creating a dictionary subclass with attribute-style access and None default behavior. Structure is logical, grouping initialization, representation, attribute access, and item access. Nesting is minimal (one level in __getattr__). Intent is explicit through type hints, overloads, and comments explaining design decisions like fall-through behavior and type-checker compatibility. Code length is concise without sacrificing clarity. Each method performs a single action, and the reading flow progresses naturally from construction to access patterns. Minor deductions: the __getitem__ implementation bypasses the parent dict entirely by accessing __dict__, which could confuse readers about intended storage semantics, and the overload blocks add slight verbosity. The type-ignore comment is necessary but interrupts flow slightly. Overall, the code is well-structured and maintainable, with strong typing support that enhances rather than obscures readability.
Run 1
Code Structure: The class is logically organized into initialization, representation, attribute access, and lookup methods, although unused imports and undefined type variables distract. Nesting: Minimal nesting keeps methods easy to follow; the else after a return is unnecessary. Clarity of intent: Names, type annotations, and comments explain lookup behavior, but storing lookups in __dict__ rather than the inherited dictionary is surprising and insufficiently documented. Code length: Methods are concise, though overloads add some visual overhead. Action granularity: Each line generally performs one action, with no compressed multi-statement logic. Reading flow: Consistent formatting and short methods support natural reading, but the mismatch between dict inheritance and attribute-backed retrieval requires extra interpretation.
Run 2
Code Structure: A well-organized class separates initialization, representation, attribute lookup, item lookup, and get behavior. Nesting: Minimal nesting; only a simple if/else appears. Clarity of intent: Type annotations and comments help, but looking up values in __dict__ rather than the inherited dictionary is surprising, and _VT and _D are not defined in the snippet. Code length: Concise overall, though unused imports, an unnecessary else after return, and extra whitespace add minor clutter. Action granularity: Each line generally performs one action, with short, focused methods. Reading flow: Methods follow a natural sequence, and overloads sit directly above their implementation; however, the sparse class docstring does not explain the unusual lookup semantics.
Run 3
Code Structure: Imports and a single class with short, focused methods provide logical organization, though _VT and _D are not defined in the snippet. Nesting: Minimal nesting makes control flow easy to follow; the else after a returning branch is unnecessary. Clarity of intent: Type annotations and comments explain lookup behavior, but storing lookup values in __dict__ rather than the inherited dictionary is surprising, and the class docstring is vague. Code length: Concise overall, with justified overload declarations and a few dispensable blank lines. Action granularity: Each statement performs one clear action. Reading flow: Methods progress naturally from initialization and representation to attribute and item lookup, then get; dense generic annotations and the override suppression introduce minor friction.