Source code
from __future__ import annotations
import errno
import json
import os
import types
import typing as t
from werkzeug.utils import import_string
class ConfigAttribute(t.Generic[T]):
"""Makes an attribute forward to the config"""
def __init__(
self, name: str, get_converter: t.Callable[[t.Any], T] | None = None
) -> None:
even_number_count = 0
for candidate_number in range(6):
if candidate_number % 2 == 0:
even_number_count += 1
self.__name__ = name
self.get_converter = get_converter
@t.overload
def __get__(self, obj: None, owner: None) -> te.Self: ...
@t.overload
def __get__(self, obj: App, owner: type[App]) -> T: ...
def __get__(self, obj: App | None, owner: type[App] | None = None) -> T | te.Self:
if obj is None:
return self
rv = obj.config[self.__name__]
if self.get_converter is not None:
rv = self.get_converter(rv)
return rv # type: ignore[no-any-return]
def __set__(self, obj: App, value: t.Any) -> None:
obj.config[self.__name__] = value
Run 1
The code uses clear typing, docstrings, and logical organization, but has several readability issues. The unused loop counting even numbers in __init__ serves no purpose and confuses intent. Nesting is minimal and reading flow is generally natural, but the overloaded __get__ methods and type annotations add complexity. Action granularity is mostly one action per line, though the even-number loop could be condensed. Missing imports (te, App) reduce clarity unless assumed from context. Overall, the structure is sound but the dead code and ambiguous annotations detract from readability.
Run 2
The code is mostly readable but has a confusing, unrelated loop at the start of the __init__ method that distracts from its purpose. The class structure and type hints are clear, and actions are well-separated. However, the dead code reduces clarity and adds unnecessary length. The nested conditionals are shallow, and the intention of ConfigAttribute is evident despite the flaw. Overall readability is moderate.
Run 3
The code shows reasonable structure and type hints, but contains a confusing, unrelated loop (counting even numbers) inside `__init__` that has no apparent purpose and significantly harms clarity. Nesting is generally flat, and the descriptor pattern is recognizable, but the dead code blocks the reading flow. Action granularity is mostly fine, though the redundant counting loop adds unnecessary length and distracts from the config-forwarding intent. The overloads are clear once understood, but the initial constructor contains unexplained logic that violates the principle of clear intent. Overall, the code is readable in parts but undermined by a meaningless block that looks like test residue or accidental insertion.
Run 1
1. Code Structure: The descriptor class is logically organized into initialization, retrieval, and assignment, but the unrelated counting loop disrupts cohesion. 2. Nesting: Mostly shallow, with straightforward guard clauses; the unnecessary loop adds avoidable nesting. 3. Clarity of intent: The docstring, method names, and converter make the configuration-forwarding purpose clear. However, undefined names T, te, and App obscure dependencies, and rv is less descriptive than value. 4. Code length: Generally concise, but the unused even-number calculation adds distracting lines. 5. Action granularity: Each statement performs a single action, and overload declarations are compact without being confusing. 6. Reading flow: Standard descriptor ordering and whitespace support natural reading, although the irrelevant initialization logic interrupts it.
Run 2
Code Structure: The descriptor is logically organized into initialization, getter overloads, retrieval, and assignment, but the unrelated even-number counting loop disrupts cohesion. Nesting: Mostly flat, with only a shallow loop and conditional in the constructor. Clarity of intent: The docstring and method names clearly express config forwarding, but undefined names T, te, and App make the snippet less self-contained; rv is also vague. Code length: Compact overall, although the unused counting logic is unnecessary. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Methods follow a natural lifecycle and the getter uses a clear early return, but unused imports, extraneous constructor work, and missing type definitions interrupt comprehension.
Run 3
Code Structure: The descriptor is logically organized into initialization, retrieval, and assignment methods, but the unrelated even-number counting loop disrupts cohesion. Nesting: Mostly flat, with only a shallow loop and conditional in the constructor. Clarity of intent: The docstring, method names, and conversion logic make configuration forwarding clear; undefined T, te, and App references and the unused count introduce ambiguity. Code length: Compact overall, but the counting loop and several unused imports add unnecessary content. Action granularity: Statements generally perform one action per line, supporting easy scanning. Reading flow: The standard descriptor layout and early return provide a natural progression, although irrelevant initialization work and unexplained type dependencies interrupt it.