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 with a clear structure and purpose. Each method is short and focused, maintaining good action granularity. However, there are significant readability issues: the 'get' method checks __dict__ instead of the dict itself, contradicting the class's dict inheritance and creating ambiguity. The __getattr__ and __getitem__ methods have confusing semantics — __getitem__ silently returns None for missing keys rather than raising KeyError, which violates dict expectations. Type annotations are helpful, but the generics (_VT, _D) are not defined in the visible code, requiring readers to infer them. The overloads for 'get' are somewhat verbose but acceptable. Nesting is minimal and beneficial. The class docstring is too brief for the unusual behavior implemented. Overall structure is clean, but clarity of intent and semantic consistency are compromised.
Run 3
The code is well-structured and maintains a clear purpose as a dictionary subclass with attribute-style access for HTTP status lookups. The class is logically organized with clear method separation and appropriate type hints. Nesting is minimal and the reading flow is natural, moving from initialization through representation to access methods. Each line performs a single action, and the code is concise without unnecessary verbosity. The overloaded get methods add some complexity but are properly documented. The main readability concerns are the placeholder type variables (_VT and _D) which are referenced but not defined in the visible code, making it difficult to understand the full type contract without seeing the complete module. Additionally, the @overload decorators and associated type checking comments add moderate cognitive overhead for readers unfamiliar with static typing patterns. Despite these minor issues, the code demonstrates good practices with clear docstrings and appropriate use of modern Python features.
Run 1
Code Structure: Methods are logically grouped within a small class, although unused imports and undefined type variables in the snippet distract. Nesting: Minimal nesting makes control flow easy to follow; the else after a return is unnecessary. Clarity of intent: Method names, annotations, and comments help, but a dict subclass that reads from __dict__ rather than dictionary storage is surprising and insufficiently explained. Code length: Concise overall, with some typing boilerplate and redundant get(key, None). Action granularity: Each line generally performs one action, and compact overload declarations remain understandable. Reading flow: Initialization, representation, attribute access, and lookup methods follow a natural progression, though missing type-variable definitions and the unusual storage model interrupt comprehension.
Run 2
Code Structure: Imports and a single class with short, focused methods provide logical organization, though the undefined type variables in the snippet obscure typing context. Nesting: Minimal nesting makes control flow easy to follow; the else after a return is unnecessary. Clarity of intent: Descriptive method names, type annotations, and comments help, but storing lookups in __dict__ rather than the inherited dictionary is surprising, and the class docstring does little to explain this behavior. Code length: Concise overall, with some typing boilerplate and a redundant explicit None default. Action granularity: Statements generally perform one action per line; compact overload declarations remain understandable. Reading flow: Methods progress naturally from initialization and representation to lookup operations, although inconsistent blank spacing and missing type-variable definitions slightly interrupt comprehension.
Run 3
Code Structure: Methods are logically grouped within a small class, with overloads placed directly before their implementation. Nesting: Minimal nesting makes control flow easy to follow, although the else after a returning branch is unnecessary. Clarity of intent: Method names, type annotations, and comments explain lookup behavior, but using instance attributes rather than dictionary entries is surprising for a dict subclass. The generic class docstring provides little context, and _VT and _D are not defined in the shown snippet. Code length: Concise overall, with modest typing boilerplate and an unnecessary blank line in __getitem__. Action granularity: Each statement performs a single clear action. Reading flow: Imports, initialization, representation, and lookup methods follow a natural sequence; dense union annotations and type-checking accommodations slightly interrupt the flow.