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 command( # type: ignore[override]
self, *args: t.Any, **kwargs: 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``.
"""
wrap_for_ctx = kwargs.pop("with_appcontext", True)
def decorator(f: t.Callable[..., t.Any]) -> click.Command:
if wrap_for_ctx:
f = with_appcontext(f)
return super(AppGroup, self).command(*args, **kwargs)(f) # type: ignore[no-any-return]
return decorator
def group( # type: ignore[override]
self, *args: t.Any, **kwargs: 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`.
"""
kwargs.setdefault("cls", AppGroup)
return super().group(*args, **kwargs) # type: ignore[no-any-return]
Run 1
The code is well-structured and readable. It uses clear class and method names, proper type hints, and concise docstrings. Nesting is minimal, with only one level inside the decorator. Action granularity is good, with one main action per line. The reading flow is natural, progressing from imports to class definition to method overrides. Minor deductions: the decorator closure adds slight indirection, and type-ignore comments add noise. The `super(AppGroup, self).command` call is explicit but slightly verbose compared to `super().command`. Overall, the code is clean, maintainable, and easy to follow for developers familiar with Click and Flask.
Run 2
The code is highly readable with clear structure and purpose. It is well-documented with descriptive docstrings that explain the differences from the parent class. The two methods are short, focused, and avoid deep nesting. Type hints are used consistently, and the logic in each method is straightforward—either wrapping a function with an application context or setting a default class. The only minor issues are the `# type: ignore` comments and some long signatures, which slightly reduce flow but are common in typed Python projects. Overall it follows a natural reading order and maintains one action per line.
Run 3
The code is highly readable with clear class and method names, concise docstrings, and logical organization. It uses minimal nesting, maintains a flat structure, and each action is clearly separated. Type hints and comments improve clarity, and the code length is appropriate for the functionality. The reading flow is natural, starting with imports and progressing to class definition and methods. Minor deductions for the reliance on type ignore comments and slightly dense import block, but overall the code is well-structured and maintainable.
Run 1
Code Structure: The class cleanly separates command wrapping from group configuration, although many imports are unused in this excerpt. Nesting: Shallow overall; the nested decorator and single conditional are appropriate. Clarity of intent: Descriptive method names, type annotations, and useful docstrings explain the behavior, though with_appcontext is not defined in the excerpt. Code length: Methods are concise, but the lengthy import list adds visual overhead. Action granularity: Statements generally perform one action per line; the chained superclass command invocation is slightly dense. Reading flow: Methods follow a natural progression from configuration to execution and return, although missing blank lines between import groups and before the class reduce visual separation.
Run 2
Code Structure: The class cleanly separates command and group behavior, although the many imports unused in this snippet add clutter. Nesting: Shallow nesting, with only a decorator closure and a single conditional, is easy to follow. Clarity of intent: Descriptive names, type annotations, and focused docstrings clearly explain application-context wrapping and group defaults. Code length: The implementation is concise; documentation and typing add useful context, though some signatures are visually dense. Action granularity: Statements generally perform one action each, but the chained superclass command invocation combines decorator creation and application. Reading flow: Consistent formatting and straightforward control flow make reading natural. The explicit super call inside the closure and type-ignore comments introduce minor visual and conceptual friction.
Run 3
Code Structure: The class cleanly separates command and group customization, although many imports are unused in this excerpt. Nesting: Shallow overall; the nested decorator and single conditional are easy to follow. Clarity of intent: Descriptive method names, type annotations, and informative docstrings explain application-context wrapping and the default group class. Code length: Methods are concise, but the extensive import block adds visual overhead relative to the functionality shown. Action granularity: Most lines perform one action; the chained superclass command invocation and callback application are slightly dense. Reading flow: The progression from imports to class documentation and related methods is natural. Long type signatures, type-ignore comments, and framework-specific decorator mechanics introduce minor reading friction.