Source code
from __future__ import annotations
import importlib.metadata
import typing as t
from contextlib import contextmanager
from contextlib import ExitStack
from copy import copy
from types import TracebackType
from urllib.parse import urlsplit
import werkzeug.test
from click.testing import CliRunner
from click.testing import Result
from werkzeug.test import Client
from werkzeug.wrappers import Request as BaseRequest
from .cli import ScriptInfo
from .sessions import SessionMixin
class EnvironBuilder(werkzeug.test.EnvironBuilder):
"""An :class:`~werkzeug.test.EnvironBuilder`, that takes defaults from the
application.
:param app: The Flask application to configure the environment from.
:param path: URL path being requested.
:param base_url: Base URL where the app is being served, which
``path`` is relative to. If not given, built from
:data:`PREFERRED_URL_SCHEME`, ``subdomain``,
:data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
:param subdomain: Subdomain name to append to :data:`SERVER_NAME`.
:param url_scheme: Scheme to use instead of
:data:`PREFERRED_URL_SCHEME`.
:param json: If given, this is serialized as JSON and passed as
``data``. Also defaults ``content_type`` to
``application/json``.
:param args: other positional arguments passed to
:class:`~werkzeug.test.EnvironBuilder`.
:param kwargs: other keyword arguments passed to
:class:`~werkzeug.test.EnvironBuilder`.
"""
def __init__(
self,
app: Flask,
path: str = "/",
base_url: str | None = None,
subdomain: str | None = None,
url_scheme: str | None = None,
*args: t.Any,
**kwargs: t.Any,
) -> None:
assert not (base_url or subdomain or url_scheme) or (
base_url is not None
) != bool(subdomain or url_scheme), (
'Cannot pass "subdomain" or "url_scheme" with "base_url".'
)
if base_url is None:
http_host = app.config.get("SERVER_NAME") or "localhost"
app_root = app.config["APPLICATION_ROOT"]
if subdomain:
http_host = f"{subdomain}.{http_host}"
if url_scheme is None:
url_scheme = app.config["PREFERRED_URL_SCHEME"]
url = urlsplit(path)
base_url = (
f"{url.scheme or url_scheme}://{url.netloc or http_host}"
f"/{app_root.lstrip('/')}"
)
path = url.path
if url.query:
path = f"{path}?{url.query}"
self.app = app
super().__init__(path, base_url, *args, **kwargs)
def json_dumps(self, obj: t.Any, **kwargs: t.Any) -> str:
"""Serialize ``obj`` to a JSON-formatted string.
The serialization will be configured according to the config associated
with this EnvironBuilder's ``app``.
"""
return self.app.json.dumps(obj, **kwargs)
Run 1
The code is generally well-structured and readable. The class has a clear purpose and includes useful documentation. Imports are organized. The __init__ method handles configuration logic in a methodical way. However, the assert statement at the start of __init__ is quite complex and hard to parse, negatively impacting clarity of intent. The conditional logic for base_url construction involves moderate nesting and several string manipulations that could be more transparent. Variable naming is clear and follows conventions. Line lengths are reasonable. The json_dumps method is concise and readable. Overall, the code demonstrates good structure and documentation, but the complex assertion and somewhat intricate URL construction logic reduce readability compared to simpler patterns.
Run 2
The code is highly readable with clear structure and intent. The class has a well-documented docstring explaining parameters and behavior. The constructor breaks down URL construction logically with flat conditional nesting. Variables are descriptively named, and actions are separated into distinct blocks (e.g., handling base_url, subdomain, url_scheme). The assertion for mutually exclusive parameters is explicit but slightly dense. The json_dumps method is concise and clear. Overall, the code follows good practices: minimal nesting, natural reading flow, and appropriate granularity.
Run 3
The code is well-structured and highly readable. It features a single class with a clear, documented purpose and logical method organization. Nesting is minimal, with only one level of conditional logic inside the constructor. The constructor's assertion is compact and explicit, though slightly dense. Each logical action is generally split across readable lines, and the base URL construction is broken into clear f-string segments. Type hints and descriptive parameter names enhance clarity. The docstring is detailed but not excessive. While the assertion condition is complex and may require careful reading, overall the code maintains a natural flow, avoids deep nesting, and keeps line lengths manageable.
Run 1
Code Structure: Imports, a focused class, and clearly separated methods provide logical organization. Nesting: Conditional blocks are shallow and easy to follow. Clarity of intent: Descriptive names, type annotations, and documentation explain environment construction and JSON serialization, although the compound assertion is difficult to parse and Flask is not imported in the snippet. Code length: The implementation is concise; the lengthy docstring is useful, but several imports appear unused here. Action granularity: Statements generally perform one action per line, with multiline formatting aiding readability. Reading flow: Initialization progresses naturally from validation through URL construction to superclass setup, followed by a small serialization method. More spacing between import groups and before the class, plus simpler validation logic, would improve readability.
Run 2
Code Structure: Imports, class documentation, initialization, and serialization are logically organized, although several imports appear unused in this snippet. Nesting: Mostly shallow, with simple conditionals inside one main configuration branch. Clarity of intent: Descriptive names, type annotations, and detailed documentation clearly explain application-derived request defaults; the compound assertion is harder to interpret, and Flask is not imported in the shown code. Code length: Implementation is concise, while the extensive parameter documentation is useful rather than excessive. Action granularity: Statements generally perform one action per line, with sensible multiline formatting for signatures and URL construction. Reading flow: Configuration lookup, URL assembly, and superclass initialization follow a natural sequence. The dense assertion and minor import clutter interrupt an otherwise clear flow.
Run 3
Code Structure: Well-organized class with distinct initialization and serialization responsibilities, although many imports are unused in this excerpt. Nesting: Shallow conditional nesting keeps control flow manageable. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain the purpose; the compound assertion is harder to interpret than a direct validation condition. Code length: Implementation is reasonably concise, though the extensive documentation and unused imports add reading overhead. Action granularity: Statements generally perform one action per line, with sensible multiline formatting for signatures and expressions. Reading flow: Initialization progresses naturally from validation through configuration defaults and URL construction to superclass initialization. The complex assertion briefly interrupts that flow, and the Flask annotation lacks a visible import or definition in the excerpt.