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 not (obj is None):
pass
else:
return self
rv = obj.config[self.__name__]
if not (self.get_converter is not None):
pass
else:
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 generally readable with clear type hints, logical class structure, and consistent naming. However, readability is reduced by the use of negative conditional patterns such as 'if not (obj is None): pass else: return self', which inverts natural reading flow. The same issue appears in the get_converter check. These constructs create unnecessary nesting and obscure the intent compared to a straightforward 'if obj is None: return self' approach. The @overload decorators are well-placed and aid comprehension, but the custom 'te.Self' reference appears undefined within the shown scope, adding confusion. Line length and action granularity are acceptable, with one reasonable action per line. Overall, the code is maintainable but would benefit from clearer conditional logic and simplification of control flow.
Run 2
The code has clear elements—type hints, docstring, and overloaded getters—but readability is undermined by awkward conditional structures. The `if not (obj is None): pass else: return self` pattern is convoluted and should be a simple early return. Similarly, `if not (self.get_converter is not None): pass else: ...` is a double negative that obscures intent. These structures create unnecessary nesting and break natural reading flow. While the class is logically organized and concise, the conditional style makes it harder to scan. Action granularity is mostly one action per line, but the forced `pass` branches add noise. Overall, the code's meaning is recoverable but the control flow is stilted; a straightforward rewrite would improve clarity significantly.
Run 3
The code has a reasonable overall structure and uses type hints, which aids clarity. However, readability is harmed by awkward inverted conditional patterns (`if not (obj is None): pass else: return self`) that obscure intent. Nesting is minimal, and the class is concise, but the conditional logic disrupts natural reading flow and should be written directly (`if obj is None: return self`). The use of `te.Self` is incomplete (missing import) and may confuse. Action granularity is mostly one action per line, and the code length is appropriate, but the unclear conditionals and incomplete type reference reduce overall readability.
Run 1
Code Structure: The descriptor is logically organized into initialization, retrieval, and assignment methods, although unused imports and undefined names (T, te, App) weaken self-contained readability. Nesting: Nesting is shallow, but inverted conditions with pass branches introduce unnecessary control-flow complexity. Clarity of intent: The docstring, method names, and type annotations communicate configuration forwarding, though rv is vague and double-negative conditions obscure straightforward checks. Code length: Generally compact, but redundant pass/else branches and unused imports add avoidable length. Action granularity: Statements consistently perform one action per line. Reading flow: Method ordering is natural, but overload declarations and awkward conditionals interrupt an otherwise clear progression.
Run 2
Code Structure: The descriptor is logically organized into initialization, retrieval, and assignment methods, although T, te, and App lack definitions or imports in the snippet. Nesting: Nesting is shallow, but inverted conditions with empty pass branches introduce unnecessary control-flow complexity. Clarity of intent: The docstring, method names, and type annotations communicate configuration forwarding, while double-negative checks obscure straightforward conditions. Code length: The snippet is fairly short, but redundant branches, unused imports, and extensive typing machinery add visual overhead. Action granularity: Each statement generally performs one action, making individual operations easy to identify. Reading flow: Method ordering is natural, but readers must mentally simplify the conditional branches; direct checks and early returns would make retrieval behavior substantially easier to follow.
Run 3
Code Structure: The descriptor class is logically organized into initialization, retrieval, and assignment methods, but unresolved names (T, te, App) weaken self-contained clarity. Nesting: Shallow overall, though redundant if/else branches add avoidable complexity. Clarity of intent: The docstring, method names, and annotations communicate config forwarding, but negated conditions with pass branches obscure straightforward checks. Code length: Mostly concise, yet unnecessary branches and unused imports add clutter. Action granularity: Statements generally perform one action per line; compact overload declarations are still understandable. Reading flow: Method ordering is natural, but inverted conditions interrupt the flow and require extra mental effort.