Source code
from __future__ import annotations
import ast
import collections.abc as cabc
import importlib.metadata
import inspect
import os
import platform
import re
import sys
import traceback
import typing as t
from functools import update_wrapper
from operator import itemgetter
from types import ModuleType
import click
from click.core import ParameterSource
from werkzeug import run_simple
from werkzeug.serving import is_running_from_reloader
from werkzeug.utils import import_string
from .globals import current_app
from .helpers import get_debug_flag
from .helpers import get_load_dotenv
class AppGroup(click.Group):
"""This works similar to a regular click :class:`~click.Group` but it
changes the behavior of the :meth:`command` decorator so that it
automatically wraps the functions in :func:`with_appcontext`.
Not to be confused with :class:`FlaskGroup`.
"""
def a( # type: ignore[override]
self, *c: t.Any, **d: t.Any
) -> t.Callable[[t.Callable[..., t.Any]], click.Command]:
"""This works exactly like the method of the same name on a regular
:class:`click.Group` but it wraps callbacks in :func:`with_appcontext`
unless it's disabled by passing ``with_appcontext=False``.
"""
e = d.pop("with_appcontext", True)
def decorator(g: t.Callable[..., t.Any]) -> click.Command:
if wrap_for_ctx:
g = with_appcontext(g)
return super(AppGroup, self).command(*args, **kwargs)(g) # type: ignore[no-any-return]
return decorator
def b( # type: ignore[override]
self, *h: t.Any, **i: t.Any
) -> t.Callable[[t.Callable[..., t.Any]], click.Group]:
"""This works exactly like the method of the same name on a regular
:class:`click.Group` but it defaults the group class to
:class:`AppGroup`.
"""
i.setdefault("cls", AppGroup)
return super().group(*h, **i) # type: ignore[no-any-return]
Run 1
This code is extremely difficult to read due to deliberately obfuscated naming (a, b, c, d, e, g, h, i) that obscures purpose, despite docstrings. The structure deviates from standard Flask internals where methods would be 'command' and 'group'. The nesting is moderate but the decorator wrapper adds complexity. Clarity of intent is severely undermined—readers cannot infer what parameters like 'c' and 'd' represent. Code length is reasonable but action granularity suffers from dense lines (e.g., super call combined with ignore comment). Reading flow is unnatural because method names 'a' and 'b' require cross-referencing docstrings to understand behavior. While imports and type hints are proper, the parameter renaming destroys maintainability. The code mimics real Flask source but removes meaningful identifiers, making it harder to audit or modify. Only the docstrings and comments preserve some clarity, but they cannot compensate for the cryptic symbols replacing conventional names.
Run 2
The code is highly unreadable due to deliberate obfuscation. Function and variable names are single letters (a, g, c, d, e, h, i), obscuring intent. References to undefined names (wrap_for_ctx, args, kwargs, with_appcontext) suggest errors or missing context. The decorator logic is muddled, with unclear flow and purpose. Nesting is moderate, but the unclear naming and mixed concerns make the code hard to follow. Method 'a' does multiple things in one decorator closure, violating action granularity. Overall, the structure is tangled, intent is ambiguous, and reading flow is poor despite the short length.
Run 3
The code is highly unreadable due to arbitrary single-letter variable names (a, b, c, d, e, g, h, i) replacing meaningful ones like 'command', 'group', 'args', 'kwargs', etc. This completely obscures the intent and makes the logic ambiguous. It also references an undefined 'wrap_for_ctx' variable and inconsistent parameter usage, likely resulting in runtime errors. The nesting is moderate, but the structure and clarity of intent are severely compromised. While the docstrings are helpful, the method names and parameters undermine them. The code length is acceptable, but action granularity and reading flow suffer from the opaque naming and broken references.
Run 1
Code Structure: Imports and a class with two separate methods provide logical organization, but many imports are irrelevant to the excerpt. Nesting: Shallow nesting, with only an inner decorator and conditional, is easy to follow. Clarity of intent: Docstrings and type annotations help, but single-letter method and variable names obscure purpose. The decorator references wrap_for_ctx, args, and kwargs instead of the available e, c, and d, making its intended data flow confusing. Code length: The implementation is compact, although the import block and verbose docstrings outweigh the small amount of executable code. Action granularity: Statements generally perform one action per line, with a slightly dense chained superclass call. Reading flow: Conventional formatting supports scanning, but inconsistent identifiers and documentation that describes methods without meaningful names interrupt comprehension.
Run 2
Code Structure: The class and two methods are logically organized, but numerous unrelated imports add clutter. Nesting: Shallow nesting, with only a decorator closure and conditional, is easy to follow. Clarity of intent: Docstrings and type annotations explain the intended behavior, but single-letter method and variable names obscure meaning. References to undefined wrap_for_ctx, args, and kwargs instead of e, c, and d create confusion and disconnect the implementation from its apparent intent. Code length: The methods are concise, although the import block is disproportionately long for this snippet. Action granularity: Statements generally perform one action per line, with conventional chained calls. Reading flow: Formatting and spacing are consistent, but misleading method names, inconsistent identifiers, and docstrings referring to same-named Click methods interrupt comprehension.
Run 3
Code Structure: The class and its two methods are logically organized, but the large import block adds clutter relative to the small implementation. Nesting: Shallow nesting, limited to an inner decorator and conditional, is easy to follow. Clarity of intent: Docstrings and type annotations describe the intended behavior, but single-letter method and parameter names obscure meaning. References to undefined wrap_for_ctx, args, and kwargs instead of e, c, and d further undermine comprehension. Code length: The implementation is concise, though many imports are unused in this snippet and documentation outweighs executable code. Action granularity: Statements generally perform one action per line, with only the wrapping and invocation expression slightly compressed. Reading flow: Conventional formatting and method separation help, but inconsistent identifiers force readers to infer connections between the documentation, parameters, and implementation.