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 demonstrates strong readability through clear structure, minimal nesting, and explicit type hints. Each method has a single responsibility, and the action granularity is appropriate — one logical operation per line. The use of overloaded signatures clearly documents the intended behavior for descriptor access, and the flow is natural: type declarations, initialization, then descriptor protocol implementation. Minor deductions: the `# type: ignore` comment slightly interrupts flow, and the `owner` parameter in `__get__` is unused, which could confuse readers. Overall, this is concise, well-organized, and unambiguous code.
Run 3
The code is highly readable due to its clear structure, flat nesting, and explicit typing. Each method has a single responsibility, and the use of type hints and overloads clarifies intent. The class and method names are self-documenting, and the logic flows naturally. Minor issues include a missing import for `te` and a slightly verbose typing approach, which slightly reduce clarity but do not significantly hinder readability.
Run 1
Code Structure: The descriptor class 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 configuration forwarding and optional conversion, although T, te, and App are not defined or imported in the snippet, and rv is a vague variable name. Code length: The implementation is concise; overloads add useful typing detail, but several unused imports introduce clutter. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural order and whitespace separates logical steps, though missing separation between imports and the class slightly reduces polish.
Run 2
Code Structure: Imports and a focused descriptor class are logically organized, with distinct initialization, retrieval, and assignment methods. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: The docstring, method names, and type annotations explain configuration forwarding and optional conversion, though T, te, and App are not defined or imported in the snippet, and rv is a vague name. Code length: Concise overall; overloads add length but convey useful typing distinctions. Action granularity: Each statement performs a single action, with no compressed multi-operation lines. Reading flow: Methods follow a natural sequence, and whitespace separates logical steps. Missing typing context and dense annotations slightly interrupt otherwise straightforward reading.
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 the implementation flat. Clarity of intent: The docstring, method names, and annotations clearly communicate config forwarding and optional conversion, although 'rv' is vague and T, te, and App are not defined or imported in the snippet. Code length: The implementation is concise, but several unused imports add clutter; overloads add length while providing useful typing information. Action granularity: Each statement performs one clear action. Reading flow: Consistent formatting and whitespace make the getter easy to follow, though unresolved typing references and the type-ignore comment introduce minor distractions.