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 CertParamType(click.ParamType): # type: ignore[type-arg]
"""Click option type for the ``--cert`` option. Allows either an
existing file, the string ``'adhoc'``, or an import for a
:class:`~ssl.SSLContext` object.
"""
name = "path"
def __init__(self) -> None:
self.path_type = click.Path(exists=True, dir_okay=False, resolve_path=True)
def deliver(
self, limit: t.Any, entry: click.Parameter | None, key: click.Context | None
) -> t.Any:
try:
import ssl
except ImportError:
raise click.BadParameter(
'Using "--cert" requires Python to be compiled with SSL support.',
key,
entry,
) from None
try:
return self.path_type(limit, entry, key)
except click.BadParameter:
limit = click.STRING(limit, entry, key).lower() # type: ignore[union-attr]
if limit == "adhoc":
try:
import cryptography # noqa: F401
except ImportError:
raise click.BadParameter(
"Using ad-hoc certificates requires the cryptography library.",
key,
entry,
) from None
return limit
age = import_string(limit, silent=True)
if isinstance(age, ssl.SSLContext):
return age
raise
Run 1
The code is generally well-structured, with a clear class definition and method organization. It avoids deep nesting by using early returns and exceptions, maintaining flat readability. The intent is clear: parsing and validating a --cert option with multiple fallback cases. Lines are concise, although some multi-line function calls with complex arguments slightly reduce readability (e.g., click.BadParameter with multiple positional args). Action granularity is mostly one action per line, though type-ignore comments and inline imports add minor noise. Reading flow is logical: try for SSL, try path, then fallback to adhoc or import string. The use of descriptive variable names (limit, entry, key) is okay but not highly descriptive. The main weakness is the terse variable name 'age' for the imported SSLContext, which obscures intent, and some repetition of exception handling blocks. Overall, the code is readable but could be improved with slightly better naming and minor restructuring to reduce repetitive error handling.
Run 2
The code is generally readable with clear intent, logical structure, and good use of type hints and docstrings. The class has a single responsibility, and the method follows a mostly linear flow. However, there are some readability concerns: the variable naming is inconsistent ('limit', 'entry', 'key' are opaque; 'age' appears to be a typo for 'ctx' or similar), and the nested try/except blocks add moderate depth. The re-raising of the original exception after the import_string check is subtle and could confuse readers. Overall, the code is concise and well-organized, but the unclear variable names and mixed abstraction levels prevent a higher score.
Run 3
The code has clear logical organization and follows standard Python patterns, but readability is hampered by several issues. The nesting is deep (3-4 levels in the 'deliver' method), making the flow hard to follow. The exception handling creates tangled control flow where the 'raise' at the end re-raises the original 'BadParameter' caught earlier. Variable names are cryptic: 'limit' should be 'value', 'age' should be 'ctx', 'key' and 'entry' have reversed/unclear roles (they appear to be the parameter and context, respectively). The 'deliver' method name is ambiguous for a type converter. The method signature with type hints is verbose and adds noise. The import of 'cryptography' with 'noqa' comment is a side-effect import that obscures intent. While each line performs one action and the code is not excessively long, the unclear naming, deep nesting, and convoluted exception flow reduce readability. The docstring is helpful but the internal logic requires careful reading to understand the three possible return scenarios.
Run 1
Code Structure: Certificate handling is logically grouped in a class and method, but many unrelated imports distract from the snippet. Nesting: Nested exception handling and conditional branches require moderate effort to follow. Clarity of intent: The class docstring, descriptive class name, and error messages explain the purpose, but names such as deliver, limit, entry, key, and age obscure parameter roles and intermediate values. Code length: The implementation is reasonably concise, although the extensive unused imports add clutter. Action granularity: Statements generally perform one action per line, with readable multiline calls. Reading flow: Processing progresses naturally from SSL availability to file validation, ad-hoc certificates, and imported contexts; however, exception-driven fallback and the final bare raise make control flow less immediately obvious.
Run 2
Code Structure: The class and method are logically organized around certificate validation, although many imports are unused in this excerpt. Nesting: Nested exception handlers and conditionals create moderate depth, particularly for the ad-hoc certificate branch. Clarity of intent: The class docstring and error messages clearly explain supported inputs, but names such as deliver, limit, entry, key, and age obscure the method's role and the values being processed. Code length: The implementation is reasonably concise, though the extensive import list adds visual overhead. Action granularity: Most lines perform one action, with readable multiline calls. Reading flow: Validation progresses naturally from a file path to an ad-hoc certificate and then an imported SSL context, but exception-driven branching and the final bare raise require closer attention.
Run 3
Code Structure: The class cleanly groups certificate-option handling, but numerous unrelated imports distract from its purpose. Nesting: Nested exception handling and the conditional dependency check introduce moderate depth, though returns keep branches manageable. Clarity of intent: The docstring and error messages clearly explain supported inputs, but names such as deliver, limit, entry, key, and age obscure their roles. Code length: The implementation is reasonably concise, while the import block is excessive for this excerpt. Action granularity: Statements generally perform one action per line, and multiline calls are formatted clearly. Reading flow: Processing moves logically from SSL availability to file validation, ad-hoc certificates, and imported SSL contexts. However, handling alternative inputs inside an exception block and ending with a bare raise make the flow less immediately obvious.