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 not (value == "adhoc"):
pass
else:
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 not (isinstance(obj, ssl.SSLContext)):
pass
else:
return obj
raise
Run 1
The code has moderate structure with a clear class definition and docstring. However, readability suffers due to unnecessary nesting (the `try` block wrapping the `ssl` import, and the convoluted `if not ... pass else ...` patterns that reverse normal conditional logic). The reversed conditionals create unnatural reading flow and make intent ambiguous. Multiple actions are sometimes packed into single lines (e.g., `value = click.STRING(value, param, ctx).lower()`), reducing action granularity. Variable names like `ctx` and `param` are clear enough, but the error handling flow lacks clarity. The repeated `raise click.BadParameter` blocks are verbose but acceptable. Overall, the code would benefit from flattened logic, standard `if` conditions, and clearer separation of validation steps.
Run 2
The code is moderately readable but has several issues. The class structure is clear with a logical import order, but the convert method suffers from poor organization and awkward control flow. The if/else blocks with `pass` statements and inverted conditions ('if not (value == "adhoc")') make the intent confusing and disrupt reading flow. Multiple nested exception handlers create deeper nesting than necessary. The error handling logic is tangled - the final `raise` statement is ambiguous and could raise various exceptions. Action granularity is mostly good with one operation per line, and the code length is reasonable for the functionality. However, the negative conditionals and pass statements should be refactored to positive logic with early returns, which would significantly improve clarity. The type hints are good, but the flow from validation to return values is not straightforward. The logic could be flattened and made more explicit about what conditions lead to what outcomes.
Run 3
The code has clear imports and a well-documented class, but shows mixed readability. The CertParamType structure is logical with a clear purpose, yet the convert method has problematic nesting (3 levels) and redundant conditional checks like 'if not (value == "adhoc"): pass else:' that obscure intent. These incomplete conditionals are ambiguous—likely placeholders—but as written they add confusion. The method contains one primary action per line mostly, which helps, but the control flow twists the reading experience. The exception handling adds depth and some paths are unclear. Overall, it's partially readable: structure and documentation are good, but nesting and unclear conditional logic hurt clarity significantly.
Run 1
Code Structure: The class and conversion method are logically organized, although numerous unused imports clutter this excerpt. Nesting: Nested exception handling and conditionals require extra effort to follow. Clarity of intent: The docstring, descriptive names, and explicit error messages clearly explain supported certificate inputs. However, negated conditions with pass branches obscure straightforward checks, and the final bare raise requires tracking the enclosing exception handler. Code length: Generally compact, but redundant branches and imports add unnecessary length. Action granularity: Statements typically perform one action per line, with readable formatting for calls and signatures. Reading flow: The progression from SSL availability to file validation, ad-hoc certificates, and imported contexts is sensible, but inverted conditionals interrupt the natural flow.
Run 2
Code Structure: The class and conversion method are logically organized, though numerous unused imports distract from this snippet. Nesting: Nested exception handling and conditional branches add complexity, particularly within the fallback path. Clarity of intent: The docstring, descriptive names, type annotations, and specific error messages clearly explain supported certificate inputs. However, inverted conditions with pass branches obscure straightforward checks. Code length: The implementation is reasonably compact, but unnecessary conditional scaffolding and imports increase its length. Action granularity: Most lines perform a single action, making individual operations easy to follow. Reading flow: Validation proceeds naturally from SSL availability to file paths, ad-hoc certificates, and imported contexts. Nevertheless, the inverted branches interrupt that flow, and the final bare raise requires readers to track the enclosing exception handler.
Run 3
Code Structure: Imports, class definition, initialization, and conversion logic are logically organized, although many imports are unused in this snippet. Nesting: Nested exception handlers and conditionals add moderate complexity. Clarity of intent: The docstring, descriptive names, and explicit error messages clearly explain accepted certificate inputs. However, inverted conditions with pass branches obscure straightforward checks, and the final bare raise requires tracking the enclosing exception handler. Code length: Mostly concise, but redundant pass branches and unrelated imports add noise. Action granularity: Statements generally perform one action per line; multiline calls are cleanly formatted. Reading flow: The progression from file path to ad-hoc certificate to SSLContext is coherent, but unnecessary else blocks and negated predicates interrupt the flow.