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 has a clear class definition with two methods that are logically separated, minimal nesting, and concise docstrings explaining purpose. Imports are organized, type hints are used consistently, and each method has a single responsibility returning decorators. The use of `kwargs.pop` and `setdefault` is clear. Minor deductions: type-ignore comments and the long method signatures slightly reduce flow, but overall clarity and maintainability are high.
Run 2
The code is well-structured and readable, with clear class and method definitions. It uses type hints consistently and docstrings to explain purpose. Nesting is minimal—only a single nested function decorator inside the command method. Each action (popping kwargs, wrapping with app context, delegating to super) is on its own line, aiding clarity. The group method is very concise, setdefault and super call are clean. Import organization follows conventional grouping, though some imports like 'os' and 'sys' appear unused, slightly reducing clarity. The no-any-return type ignores are minor clutter but common in real-world code. Overall, the reading flow is natural and the intent is unambiguous for someone familiar with Click and Flask patterns.
Run 3
The code is well-structured, with clear class and method organization, flat nesting, and concise, purpose-driven methods. Type hints and docstrings clarify intent and usage. The command and group methods use a decorator pattern that is readable, though the double-nested decorator in command() adds slight complexity. Lines are short and actions are generally one per line, supporting a natural reading flow. The use of `# type: ignore` comments is minor clutter but standard for compatibility. Overall, this is highly readable code, slightly reduced from a perfect score due to decorator nesting and type-ignore noise.
Run 1
Code Structure: The class cleanly separates command and group customization, although the extensive import block distracts from the small implementation. Nesting: Limited to one inner decorator and a simple conditional, making control flow easy to follow. Clarity of intent: Descriptive method names, type annotations, and explanatory docstrings clearly communicate the application-context behavior; with_appcontext is not defined in the excerpt. Code length: Methods are concise, but many imports are unused in the shown code and verbose typing adds visual weight. Action granularity: Statements generally perform one action each, though the chained superclass command invocation combines creation and application of a decorator. Reading flow: Both methods follow a natural setup-and-return sequence; long signatures, type-ignore comments, and minimal spacing around top-level sections slightly interrupt readability.
Run 2
Code Structure: The class is logically organized into two focused methods, with helpful docstrings, although many imports are unused in this excerpt. Nesting: Shallow nesting; the inner decorator and single conditional are easy to follow. Clarity of intent: Descriptive method names, type annotations, and documentation clearly explain application-context wrapping and the default group class. The external with_appcontext dependency is not defined here. Code length: Methods are concise, but the extensive import block adds noise relative to the small implementation. Action granularity: Statements generally perform one action per line; the chained superclass call and decorator application require slightly more attention. Reading flow: The progression from configuration to wrapping to returning the decorator is natural. Long type signatures, type-ignore comments, and the explicit super(AppGroup, self) call introduce minor visual and conceptual friction.
Run 3
Code Structure: The class cleanly separates command and group customization, although numerous imports are unused in this snippet. Nesting: Shallow overall; the nested decorator and single conditional are appropriate. Clarity of intent: Descriptive method names, type hints, and informative docstrings clearly explain application-context wrapping and the default group class. The external with_appcontext helper requires surrounding context. Code length: Methods are concise, though imports and verbose annotations add visual overhead. Action granularity: Most lines perform one action; the chained super().command(...)(f) expression combines command creation and decorator application. Reading flow: Documentation precedes implementation consistently, and execution is easy to follow, with minor interruptions from type-ignore comments and densely formatted signatures.