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 highly readable with a clear, logical structure. It uses flat nesting with only two levels deep in exception handling, making the flow easy to follow. Intent is explicit: the class purpose is documented, and each conversion branch (SSL import, path, adhoc, import string) is handled distinctly. Lines are concise, generally performing one action each, and the reading flow is natural—error handling is co-located with the relevant operation. Type hints and comments reinforce clarity without adding noise. Minor deductions: the repeated `try/except ImportError` blocks add slight length, and the final bare `raise` inside an except block, while idiomatic, could be marginally confusing for readers unfamiliar with exception context. Overall, this is well-organized, maintainable code.
Run 3
The code is well-structured and readable despite some complexity. It follows a logical flow: class definition, type setup, and conversion logic. Nesting is moderate (try/except blocks and one nested if statement), but the error handling is clear and justified. The intent is explicit—handling certificate parameter types—and each action is generally one per line. The reading flow is natural, moving from import validation to path validation to fallback handling. Minor deductions: the nested try/except within the 'adhoc' branch adds slight complexity, and the exception re-raising pattern could be more explicit. Type hints and docstrings improve clarity, but the overall length is somewhat long for a single method. Overall, it's maintainable and comprehensible, earning a strong readability score.
Run 1
Code Structure: A focused class cleanly separates initialization from parameter conversion. 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 specific error messages clearly explain the supported inputs; the final bare raise is less immediately obvious. Code length: The class is reasonably concise, but numerous imports unused in this snippet add clutter. Action granularity: Statements generally perform one action per line, with multiline calls formatted clearly. Reading flow: Validation proceeds logically from SSL availability to file paths, ad-hoc certificates, and imported SSL contexts, though exception-driven branching slightly interrupts the flow.
Run 2
Code Structure: The class cleanly groups certificate conversion logic, although the surrounding imports include many unused names in this excerpt. Nesting: Moderate nesting from exception handling and the ad-hoc certificate branch adds some complexity, but early returns limit it. Clarity of intent: The docstring, descriptive names, type annotations, and specific error messages clearly explain accepted inputs and requirements. Code length: The implementation is reasonably concise, with some visual overhead from imports and multiline calls. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Validation proceeds logically from SSL availability to file paths, ad-hoc certificates, and imported SSL contexts. The final bare raise requires readers to remember the enclosing exception handler, slightly reducing clarity.
Run 3
Code Structure: A focused parameter-type class separates initialization from conversion, although the many unused imports in this snippet add clutter. Nesting: Mostly moderate, but nested exception handling and the ad-hoc certificate branch require extra attention. Clarity of intent: The docstring, descriptive names, type annotations, and specific error messages clearly explain supported certificate inputs; the final bare raise is less immediately obvious. Code length: The implementation is reasonably concise, with some overhead from imports and multiline error construction. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Conversion proceeds logically from SSL availability to file validation, ad-hoc handling, and SSLContext import, though placing fallback logic inside an exception block slightly interrupts the flow.