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]):
def __init__(
self, name: str, get_converter: t.Callable[[t.Any], T] | None = None
) -> None:
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
def __set__(self, obj: App, value: t.Any) -> None:
obj.config[self.__name__] = value
Run 1
The code demonstrates good readability with clear structure and typing. The ConfigAttribute class is logically organized with well-defined methods for descriptor behavior. Nesting is minimal, with only one conditional in __get__ for the converter check. Intent is clear through descriptive names and type hints. Code length is concise and avoids redundancy. Action granularity is mostly one action per line, though the __set__ method could be more explicit. Reading flow is natural, starting with class definition and proceeding methodically through methods. Minor issues include the trailing 'te.Self' typo, inconsistent spacing around decorators, and slightly compressed logic in __get__ that could benefit from a temporary variable. Overall, the code is clean and maintainable but falls short of exemplary due to its brevity and minor formatting inconsistencies.
Run 2
The code is generally readable with clear structure, type hints, and concise methods. However, there are minor issues: the overloads for __get__ reference 'te.Self' and 'App' without visible imports in the snippet, which may confuse readers. The __get__ method has slightly more than one logical action per line in the conversion block, and the return 'rv' line has trailing spaces. Overall, intent is clear and nesting is minimal, but the missing context for referenced types slightly reduces clarity.
Run 3
The code is highly readable due to its clear structure, minimal nesting, and consistent typing. The class has a single responsibility and uses descriptive names. Type hints and overloads enhance clarity and intent. Each method performs a focused action with clear logic flow. The only minor deductions are for slight line-length in signatures and the presence of two nearly identical overload decorators, which could be simplified. Overall, the code is well-organized, concise, and easy to follow.
Run 1
Code Structure: The class logically groups initialization, descriptor access, and assignment, although several imports are unused and T, te, and App are not defined in the snippet. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Standard descriptor methods and type annotations convey configuration-backed attribute access, but rv is vague and there is no explanatory docstring. Code length: The implementation is concise; overloads add useful typing information rather than unnecessary complexity. Action granularity: Each statement performs one clear action. Reading flow: Methods follow a natural initialization/get/set order, though excess blank lines, trailing whitespace, and unresolved typing names slightly interrupt readability.
Run 2
Code Structure: Methods are logically organized within a focused descriptor class, although several imports are unused and T, te, and App lack visible definitions or imports. Nesting: Shallow conditionals and an early return make execution easy to follow. Clarity of intent: Configuration access and optional value conversion are reasonably clear, aided by type annotations, but the absence of a class docstring and the abbreviated variable rv slightly reduce clarity. Code length: The implementation is concise, with only minor excess whitespace. Action granularity: Each statement performs one clear action. Reading flow: Initialization, getter overloads, getter implementation, and setter follow a natural order; overload syntax adds some complexity, while inconsistent spacing and unresolved typing names interrupt otherwise smooth reading.
Run 3
Code Structure: The descriptor class logically groups initialization, overloaded access, retrieval, and assignment, though unused imports and undefined references (T, te, App) distract. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Method names, type annotations, and straightforward configuration access convey the purpose, but rv is vague and descriptor behavior lacks explanation. Code length: The implementation is concise; extra blank lines and unused imports add minor clutter. Action granularity: Each statement performs one clear action. Reading flow: Methods follow a natural lifecycle, with overloads directly preceding their implementation; missing type context and inconsistent whitespace slightly interrupt readability.