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 convert(
self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
) -> t.Any:
try:
import ssl
except ImportError:
raise click.BadParameter(
'Using "--cert" requires Python to be compiled with SSL support.',
ctx,
param,
) from None
try:
return self.path_type(value, param, ctx)
except click.BadParameter:
value = click.STRING(value, param, ctx).lower() # type: ignore[union-attr]
if value == "adhoc":
try:
import cryptography # noqa: F401
except ImportError:
raise click.BadParameter(
"Using ad-hoc certificates requires the cryptography library.",
ctx,
param,
) from None
return value
obj = import_string(value, silent=True)
if isinstance(obj, ssl.SSLContext):
return obj
raise
Run 1
The code is generally readable with clear imports, type hints, and logical organization. The CertParamType class has a focused purpose and the convert method follows a coherent flow. However, there are some issues: the nested try/except blocks create moderate complexity, and the final raise statement without context could be confusing - it re-raises the original BadParameter exception from the path_type call, which isn't immediately obvious. The import ssl inside the method could be at module level for clarity. Type ignores and conditional imports add minor noise. Variable naming is clear, and line lengths are reasonable. Overall structure is good but the error handling flow could be more explicit, and the exception re-raise pattern requires careful reading to understand.
Run 2
The code is generally readable with clear class and method naming, decent type hints, and logical grouping of imports. The CertParamType class has a clear purpose and the convert method follows a mostly linear flow. However, there are some issues: the nested try/except blocks create moderate nesting depth, the convert method mixes multiple responsibilities (SSL import, path validation, adhoc handling, object import), and the raise statement without a specific exception type reduces clarity. The type: ignore comments add visual noise. While the code is not deeply tangled, flattening nested exceptions and extracting helper methods would improve readability.
Run 3
The code is moderately readable. It has a logical class structure and clear intent, with reasonable action granularity. However, there are issues: nested try-except blocks create some depth, the except ImportError blocks add complexity, and the re-raising of exceptions without context ('raise') can be ambiguous. Type hints and docstrings improve clarity, but the overall flow is somewhat disrupted by the exception handling. The code is not excessively long but could be flatter.
Run 1
Code Structure: A focused parameter-type class separates initialization from conversion, with logically grouped validation paths. Nesting: Mostly manageable, although nested exception handling and the ad-hoc certificate branch require extra attention. Clarity of intent: The docstring, descriptive names, type annotations, and explicit error messages clearly explain supported certificate inputs. The final bare raise is less immediately obvious because it re-raises the earlier path-validation error. Code length: The implementation is concise, but numerous imports unused in this snippet add visual clutter. Action granularity: Statements generally perform one action per line, with readable multiline calls. Reading flow: Processing proceeds naturally from SSL availability to file paths, ad-hoc certificates, and imported SSL contexts; exception-driven fallback slightly interrupts the linear flow.
Run 2
Code Structure: The class cleanly groups certificate validation, with initialization separated from conversion, although numerous unused imports clutter this excerpt. Nesting: Several nested try/except and conditional blocks add complexity, but the method remains manageable. Clarity of intent: The docstring, type annotations, descriptive names, and actionable error messages clearly explain the accepted inputs. The final bare raise requires understanding the enclosing exception handler. Code length: The implementation is reasonably concise, though the import list is disproportionately long for the shown functionality. Action granularity: Statements generally perform one action per line; multiline calls improve legibility. Reading flow: Validation proceeds logically from SSL availability to file paths, ad-hoc certificates, and imported SSL contexts. Using exception handling to switch between input interpretations slightly interrupts the otherwise natural flow.
Run 3
Code Structure: The class cleanly separates initialization from conversion, with logically organized validation and fallback handling. Nesting: Mostly moderate, but nested exception handling and the 'adhoc' branch increase indentation. Clarity of intent: The docstring, descriptive names, type annotations, and explicit error messages make the accepted certificate inputs clear; the final bare raise requires tracking the enclosing exception handler. Code length: The implementation is reasonably concise, although many imports are unused in this excerpt and add visual clutter. Action granularity: Statements generally perform one action per line, with readable multiline calls. Reading flow: Processing naturally moves from SSL availability to file validation, ad-hoc certificates, and imported SSL contexts, though exceptions used as fallback control flow slightly interrupt linear reading.