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 generally readable with clear structure and intent. It uses modern Python typing syntax, concise docstrings, and overloaded getters to improve clarity. Nesting is minimal, and actions are mostly one per line. However, readability is slightly reduced by the use of a forward reference `te.Self` without immediately visible import, and `type: ignore` comments that hint at typing workarounds. The `__get__` method combines attribute access, config lookup, optional conversion, and return in a compact but still understandable flow. The descriptor pattern is standard but may require domain knowledge to grasp fully. Overall, it's well-organized but could benefit from a brief class-level comment explaining the descriptor's role or the `te` import context.
Run 3
The code is highly readable with clear structure and logical organization. It uses type hints consistently, follows a flat structure with minimal nesting, and each method has a single responsibility. The use of overloads for __get__ clearly communicates intent, though the type annotations are slightly verbose. The ConfigAttribute class is concise and focused, with proper separation of concerns. The reading flow is natural, progressing from initialization to getter to setter. Minor deductions for the complex generic typing which adds some cognitive load, and the type: ignore comment suggests a slight workaround. Overall, the code demonstrates excellent readability with clear naming, proper documentation, and maintainable design patterns.
Run 1
Code Structure: The descriptor class is logically organized into initialization, retrieval, and assignment methods, with overloads grouped appropriately. Nesting: Minimal nesting and an early return keep control flow flat. Clarity of intent: The docstring, method names, and type annotations clearly communicate configuration forwarding, though the abbreviated variable 'rv' and undefined names T, te, and App reduce standalone clarity. Code length: The implementation is concise, but several unused imports add clutter. Action granularity: Each statement performs one clear action. Reading flow: The progression from setup to access and mutation is natural, with helpful whitespace; the overload declarations and type-ignore comment introduce modest visual complexity.
Run 2
Code Structure: The descriptor class is logically organized into initialization, overloaded access signatures, retrieval, and assignment. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: The docstring, method names, and type annotations communicate configuration forwarding, although the abbreviated variable 'rv' and undefined references T, te, and App reduce standalone clarity. Code length: Concise overall; overloads add length but clarify typing behavior. Action granularity: Each statement performs a single action, with no compressed multi-operation lines. Reading flow: Retrieval follows a natural sequence of handling class access, fetching the configuration value, optionally converting it, and returning it. Additional spacing between imports and the class would improve visual organization.
Run 3
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 communicate configuration forwarding and optional conversion, although T, te, and App are not defined in the snippet, 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 follow a natural descriptor lifecycle, and whitespace separates logical steps. Unused imports and missing separation between imports and the class slightly reduce polish.