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:
lI0O_41f32f21 = ((0x677d ^ 0x677d) != 0)
lI0O_41f32f21 = not (not lI0O_41f32f21)
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 largely unreadable due to several issues. The most glaring problem is the presence of obfuscated dead code (lI0O_41f32f21 assignments) that serves no purpose and badly hurts clarity. There are also syntax and type errors: 'te.Self' and 'te' are undefined (likely meant to be 't.Self' or 'typing.Self'), and 'App' is not imported or defined. The structure is inconsistent — the docstring and method names suggest a config attribute, but the type annotations and overloads imply Flask/App-specific behavior, making intent ambiguous. Nesting is shallow, but reading flow is disrupted by the irrelevant variable assignments and incomplete type references. Action granularity is mostly one action per line, which is good, but it cannot compensate for the broken and confusing logic. Code length is acceptable, but many lines are wasted on meaningless operations. Overall, the code appears unfinished or corrupted, making it hard to understand or trust.
Run 2
The code has decent structure and moderate readability but contains several problems. It uses type hints and overloads which aid clarity, but has a bizarre obfuscated variable (lI0O_41f32f21) doing nothing meaningful. The naming is misleading — 'te' is referenced but never imported (should likely be 't' for typing). There's a missing import for 'App'. The class docstring is helpful, but the converter logic and config delegation could be more explicit. Nesting is minimal and line length is reasonable, but reading flow is disrupted by the meaningless variable and undefined names. Overall, intent is partially clear but execution contains unnecessary confusion.
Run 3
The code has reasonable structure and type hints, but readability is significantly undermined by several factors. There is a mysterious dead code section (lI0O_41f32f21 assignments) with no purpose. Additionally, there is an unexplained reference to 'te.Self' which is not imported or defined, causing ambiguity. The overload decorators are helpful but add visual noise. Method lengths are acceptable, but the initialization method mixes configuration with unrelated dead code, hurting clarity. Overall, the intent is partially clear but obscured by unnecessary noise and unresolved references.
Run 1
Code Structure: The descriptor is logically organized into initialization, getter overloads, retrieval, and assignment, but unused imports and irrelevant initialization statements add clutter. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: The docstring, method names, and config access communicate the purpose, while the cryptic lI0O_41f32f21 variable and pointless hexadecimal expressions obscure it. T, te, and App are not defined or imported in the snippet, reducing self-contained clarity. Code length: Mostly concise, with unnecessary boolean manipulation and imports. Action granularity: Each statement performs a single action, although the obfuscated expression requires needless interpretation. Reading flow: Methods follow a natural descriptor lifecycle, and spacing is helpful; the unrelated constructor statements interrupt an otherwise straightforward flow.
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 converter logic communicate config forwarding, but the cryptic variable and pointless hexadecimal/boolean operations obscure initialization. T, te, and App are not defined in the snippet, reducing self-contained clarity. Code length: Mostly concise, with two unnecessary assignments adding noise. Action granularity: Each executable statement performs one action, although the redundant expressions are needlessly complex. Reading flow: Standard descriptor conventions and sensible spacing support natural reading, interrupted mainly by the unrelated initialization statements and unexplained typing references.
Run 3
Code Structure: The descriptor class is logically organized into initialization, retrieval, and assignment methods, although several imports are unused and T, te, and App are not defined in the snippet. Nesting: Shallow conditional blocks make execution easy to follow. Clarity of intent: The docstring, method names, and config access communicate the purpose, but the cryptic lI0O_41f32f21 variable and meaningless bitwise and boolean operations distract from it. Code length: Mostly concise, with two unnecessary initialization statements. Action granularity: Each statement performs a single action, and formatting separates operations clearly. Reading flow: Methods follow a natural order, and overloads clarify access behavior; however, unexplained symbols and obfuscated initialization interrupt otherwise straightforward reading.