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 well-structured with clear class and method organization. Nesting is minimal, limited to a single inner decorator function. Intent is clearly documented through comprehensive docstrings explaining both AppGroup behaviors. Type hints improve readability and maintainability. Action granularity is appropriate—each logical step occupies its own line. The reading flow is natural, moving from imports to class definition to method implementations. Minor deductions: the type ignore comments slightly clutter the code, and the decorator pattern adds a small layer of complexity that requires careful reading. Overall, this is highly readable production-quality Flask code.
Run 3
The code is highly readable due to its clear structure, flat nesting, and concise intent. It uses type hints, docstrings, and descriptive names (e.g., wrap_for_ctx) that clarify purpose. Each method is short, focused, and follows a linear flow. Minor deductions for type-ignore comments and slight legacy super() syntax, but overall the code adheres well to modern readability principles.
Run 1
Code Structure: The class cleanly separates command and group customization, though the extensive import block distracts from the small excerpt. Nesting: Shallow overall; the nested decorator and single conditional are straightforward. Clarity of intent: Descriptive method names, type annotations, and docstrings clearly explain application-context wrapping and default group behavior, although with_appcontext is not defined in the excerpt. Code length: Methods are concise, but many imports are unused here and verbose annotations add visual weight. Action granularity: Statements generally perform one action each; the chained command invocation is slightly denser. Reading flow: Methods follow a natural setup-and-return sequence, with minor interruptions from type-ignore comments and limited spacing around the imports and class.
Run 2
Code Structure: The class cleanly separates command and group behavior, with helpful docstrings, although the extensive imports distract from this small excerpt. Nesting: Shallow nesting makes the inner decorator and conditional easy to follow. Clarity of intent: Descriptive method names, type annotations, and documentation clearly explain application-context wrapping and the default group class. Code length: The implementation is concise; the import block and verbose annotations add some visual overhead. Action granularity: Most lines perform one action, though the chained superclass command invocation and callback application combine steps. Reading flow: Both methods proceed naturally from configuration to delegation or return. The explicit super(AppGroup, self) call and type-ignore comments introduce minor friction but do not substantially impair readability.
Run 3
Code Structure: Methods are logically grouped in AppGroup, although the extensive import list includes many names 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 docstrings clearly explain application-context wrapping and the default group class. The external with_appcontext dependency and chained superclass call require some framework familiarity. Code length: Implementations are concise, though imports and detailed documentation add visual bulk. Action granularity: Most lines perform one action; the chained command creation and callback application compress two steps into one expression. Reading flow: Imports, class documentation, and methods follow a natural sequence, with helpful whitespace. Long annotations and inline type-ignore comments slightly interrupt scanning.