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:
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 is well-structured with concise, focused methods. The use of overloads for type hinting improves clarity for type checkers, but the unused imports (errno, json, os, import_string) slightly detract from cleanliness. The class has a clear purpose and docstring. Nesting is minimal, and the reading flow is natural. Although one line combines setting and returning, it's still clear. Overall, it's highly readable.
Run 2
The code is well-structured and highly readable. It uses clear class and method definitions with descriptive names, type hints, and overloads that clarify intent. The nesting is minimal, with only a couple of conditional blocks, and each action is separated into distinct lines, improving granularity. The reading flow is natural—initialization, getter, setter—following a logical progression. The use of `@t.overload` improves IDE support and intent clarity, though it slightly increases length. Overall, the code is concise for its purpose and avoids unnecessary complexity.
Run 3
The code is highly readable with a clear, focused purpose: implementing a descriptor that forwards attribute access to a config object. Structure is logical, with type hints and overloads enhancing clarity. Nesting is minimal, limited to two simple conditionals within __get__. Variable names are concise yet descriptive. Action granularity is appropriate, with one logical operation per line. The reading flow is natural, following standard Python descriptor patterns. Minor deductions: the missing import for 'te' and reliance on type-ignore comments slightly reduce clarity, and the overload signatures could be simplified for readability, but overall the code is well-organized and maintainable.
Run 1
Code Structure: The descriptor is logically organized into initialization, getter overloads, getter implementation, and setter. Nesting: Minimal nesting and an early return keep control flow flat. Clarity of intent: The docstring, method names, and type annotations clearly convey forwarding attribute access to configuration, with optional conversion. However, T, te, and App are undefined in the snippet, several imports are unused, and rv is a vague variable name. Code length: The implementation is concise; overloads add length but clarify typing behavior. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Methods and whitespace support natural top-to-bottom reading, although unexplained typing dependencies and unused imports introduce minor distractions.
Run 2
Code Structure: The descriptor is logically organized into initialization, getter overloads, retrieval, and assignment. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: The docstring, method names, and type annotations clearly communicate configuration forwarding and optional conversion, although T, te, and App lack definitions or imports in the snippet, and rv is a vague variable name. Code length: The implementation is concise; overloads add length but convey useful typing information. Action granularity: Each statement performs a single clear action. Reading flow: Consistent formatting and whitespace make the code easy to follow, though unused imports introduce clutter and unresolved typing references require outside context.
Run 3
Code Structure: The descriptor class is logically organized into initialization, getter overloads, retrieval, and assignment. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: The docstring, method names, and type annotations clearly convey forwarding attributes to configuration with optional conversion, although 'rv' is vague and T, te, and App are not defined in the snippet. Code length: Concise overall, but several unused imports add clutter. Action granularity: Each statement performs a single action, making operations easy to follow. Reading flow: Conventional method ordering and whitespace support natural reading; dense type annotations and overload declarations introduce minor friction.