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 and well-structured. Each class and method has a clear responsibility, and the import section is organized. Nesting is moderate; the nested try/except blocks are logically necessary but make the flow slightly harder to follow at a glance. The action granularity is good, with one logical action per line in most cases. Reading flow is natural, especially due to descriptive error messages. The main deductions come from the repeated pattern of raising click.BadParameter inside nested try/except blocks, which could be simplified or extracted for clarity. Some lines, like the type-ignore comment and multi-part return/raise, add slight noise. Overall, the code is concise and understandable for a developer familiar with Click and Flask.
Run 3
The code is well-structured and readable. It uses clear class and method naming, type hints, and a logical progression of operations within the `convert` method. Each action is generally on its own line, and nesting is moderate (mostly within conditionals and try-except blocks). The purpose of handling different certificate types is evident, and error messages are descriptive. The main source of minor complexity is the nested try-except for the ad-hoc certificate case, which adds some depth but is still understandable. Overall, the code is concise, intention-revealing, and follows common Python patterns.
Run 1
Code Structure: Imports, a documented parameter class, and focused methods provide logical organization. Nesting: The conversion method has moderately nested exception handling and conditional branches, but remains manageable. Clarity of intent: The docstring, descriptive names, type annotations, and explicit error messages clearly explain supported certificate inputs. Code length: The implementation is concise for its validation responsibilities, although the many imports unrelated to this excerpt add visual overhead. Action granularity: Statements generally perform one action each, with no compressed multi-statement lines. Reading flow: Validation proceeds naturally from SSL availability to file paths, ad-hoc certificates, and imported SSL contexts. However, the fallback logic inside an exception handler and the final bare raise require readers to track the original exception, slightly weakening readability.
Run 2
Code Structure: The class cleanly encapsulates certificate-option parsing, separating initialization from conversion, although the long import block adds clutter. Nesting: Several nested try/except and conditional blocks make the fallback path moderately difficult to follow. Clarity of intent: The docstring, descriptive names, type annotations, and specific error messages clearly explain supported inputs and requirements. Code length: The implementation is reasonably concise, but many imports are unused in this snippet. Action granularity: Statements generally perform one action per line, with readable multiline calls. Reading flow: Processing naturally progresses from SSL availability to file validation, then ad-hoc certificates and imported SSL contexts. However, placing all alternative handling inside an exception block and ending with a bare raise requires readers to track exception context.
Run 3
Code Structure: The class cleanly separates initialization from conversion, although many imports are unused in this excerpt. Nesting: Moderate nesting in exception handling and the ad-hoc certificate branch adds some complexity. Clarity of intent: The docstring, descriptive names, type annotations, and actionable error messages clearly explain supported inputs. Code length: The implementation is reasonably concise, but the large import block distracts from the small class. Action granularity: Statements generally perform one action per line, with readable multiline calls. Reading flow: Conversion follows a logical progression from SSL availability to file paths, ad-hoc certificates, and imported SSL contexts. However, using an exception handler for fallback dispatch and ending with a bare raise require readers to track exception context.