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 readable and well-organized. The class has a clear purpose, the docstring is helpful, and the method logic is logically structured. The assertion statement, however, is somewhat complex and hard to parse, reducing clarity. Nesting is minimal, and most code is at the method level. The `__init__` method contains a few multi-step operations (e.g., building the base URL and path) that are reasonably concise but could be slightly clearer with helper methods. Action granularity is mostly one action per line, but the assertion and URL-building lines bundle multiple operations, slightly reducing readability. Reading flow is natural overall, with imports and method ordering following common patterns.
Run 2
The code is generally readable and well-structured. The class has a clear purpose and the method organization is logical. The docstring is comprehensive, explaining parameters clearly. The assertion is complex but captures a non-obvious validation rule, though it could be simplified for readability. The conditional logic for building the base_url is well-segmented but nests three levels deep. Variable naming is clear and intent-revealing. The json_dumps method is concise with good separation of concerns. The main readability challenge is the dense assertion expression and the conditional URL construction block, which requires careful reading to understand the branching logic. Overall, the code demonstrates good practices like type hints, clear naming, and documentation.
Run 3
The code is generally well-structured and readable. The class has a clear single responsibility, the __init__ method logically separates URL construction from initialization, and the docstring is thorough. The assert statement is somewhat dense and could be clearer, but it uses a helpful error message. The reading flow is natural, with good action granularity. Minor deductions for the complex boolean assertion and the assert containing multiple conditions, which reduces clarity and nesting readability slightly.
Run 1
Code Structure: Imports, class documentation, initialization, and serialization are logically organized. Nesting: Conditional nesting is shallow and easy to follow. Clarity of intent: Descriptive names, type annotations, and detailed documentation make the purpose clear, but the compound assertion is difficult to parse. Code length: Implementation is concise; documentation is useful but occupies much of the snippet, and several imports appear unused here. Action granularity: Each statement generally performs one action, with complex URL construction sensibly split across lines. Reading flow: Configuration lookup, URL assembly, and superclass initialization follow a natural sequence. Missing blank lines between import groups and before the class slightly reduce visual clarity.
Run 2
Code Structure: Clearly organized into a documented class, constructor, and serialization method, although several imports appear unused in this snippet. Nesting: Shallow conditional nesting keeps the main logic easy to follow. Clarity of intent: Descriptive names, type hints, and thorough documentation explain application-derived defaults; the compound assertion is unnecessarily difficult to parse. Code length: Implementation is reasonably concise, though the lengthy docstring and unused imports add reading overhead. Action granularity: Most lines perform a single action, with multiline expressions used appropriately for formatting. Reading flow: Configuration lookup, URL construction, path adjustment, and superclass initialization follow a natural sequence. The dense assertion and Flask annotation without a visible import slightly interrupt comprehension.
Run 3
Code Structure: Well-organized class with a focused initializer and separate serialization method, though several imports are unused in this snippet. Nesting: Shallow and manageable, with simple conditionals inside one main configuration branch. Clarity of intent: Descriptive names, type annotations, and thorough documentation make the purpose clear; the compound assertion is harder to interpret than an explicit validation condition. Code length: Implementation is reasonably concise, although the docstring is substantial relative to the code. Action granularity: Statements generally perform one action each, with URL construction appropriately split across lines. Reading flow: Configuration defaults, URL parsing, and superclass initialization follow a natural sequence. Minor distractions include unused imports and the Flask annotation lacking an import in the shown code.