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 into a single class with clearly named methods and docstrings explaining intent. Nesting is minimal, limited to one decorator inside each method. Type hints and comments improve clarity. The code is concise but not overly compressed. Each method handles a single responsibility, and the reading flow is logical. Slight deductions for type-ignore comments and slightly long docstrings, but overall readability is high.
Run 3
The code is highly readable. It is logically structured, with each class (AppGroup) and method clearly defined. The nesting is minimal, with only a single inner decorator function. Intent is clear through descriptive naming, docstrings, and type hints. Although some lines are long (e.g., return type annotations), the code is concise overall. Each line generally performs one action, and the reading flow is natural, following a top-to-bottom inheritance pattern. Minor deductions for dense type annotations and a few lengthy lines, but overall clarity is strong.
Run 1
Code Structure: The class cleanly separates command and group customization, although the extensive import block distracts from the small implementation. Nesting: Shallow overall; the nested decorator and conditional are appropriate to the behavior. Clarity of intent: Descriptive method names, type annotations, and docstrings clearly explain application-context wrapping and default group selection, though with_appcontext is not defined in the excerpt. Code length: Methods are concise, but many imports are unused in the shown code and documentation is somewhat repetitive. Action granularity: Statements generally perform one action per line; the chained superclass call and decorator application require slightly more parsing. Reading flow: Methods proceed naturally from configuration to delegation, but tightly packed imports, long annotations, and inline type-ignore comments add visual noise.
Run 2
Code Structure: The class cleanly separates command wrapping and group configuration into focused methods, although the many unused imports distract in this snippet. Nesting: Shallow nesting, with only a small inner decorator and one conditional, keeps complexity low. Clarity of intent: Descriptive names, type annotations, and informative docstrings explain the behavior well; with_appcontext is referenced but not defined here. Code length: The implementation is concise, though imports and verbose annotations add visual overhead. Action granularity: Statements generally perform one action per line, with the chained superclass command invocation slightly denser. Reading flow: Configuration, conditional wrapping, and delegation proceed naturally; long signatures and type-ignore comments introduce minor interruptions.
Run 3
Code Structure: The class cleanly separates command and group customization, although the many unused imports clutter this excerpt. Nesting: Shallow overall; the nested decorator and single conditional are straightforward. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain application-context wrapping and the default group class. The externally defined with_appcontext requires some surrounding context. Code length: Methods are concise, but the import block and repeated documentation make the excerpt longer than necessary. Action granularity: Most lines perform one action; the chained superclass call and decorator application compress several operations into one expression. Reading flow: The class progresses naturally from command behavior to group behavior, though multiline signatures, type-ignore comments, and the dense import section slightly interrupt scanning.