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 with a clear structure and purpose. It uses type hints, docstrings, and logical organization. The constructor is moderately complex but not deeply nested. The conditional logic for base_url construction is somewhat lengthy but flows naturally. The assert statement is complex and might benefit from extraction, but it clearly conveys intent. Action granularity is appropriate, with one logical operation per line. The mix of parsing URL components and constructing base_url in a single block slightly reduces clarity, and the json_dumps method is concise. Overall, it is well-structured and maintainable, with minor opportunities for improvement in breaking up the constructor logic.
Run 3
The code is well-structured and highly readable. The class has a clear purpose, and its constructor logically groups URL/base_url resolution steps with minimal nesting. Type hints and future annotations improve clarity. Docstrings are thorough and explain parameters well. The assertion message clearly communicates constraints. The base_url construction uses multiple lines but remains natural to follow. The json_dumps method is concise and delegates appropriately. Minor deductions: the long assertion condition slightly reduces clarity, and the base_url string concatenation could be split across lines more naturally. Overall, strong readability with clear intent and structure.
Run 1
Code Structure: Logically organized imports and a focused class with clearly separated initialization and JSON serialization. Nesting: Shallow, with straightforward conditionals inside one main configuration branch. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain the purpose well; however, the compound assertion is difficult to parse, and Flask is referenced without a visible import. Code length: Implementation is concise, although documentation occupies much of the snippet and several imports appear unused. Action granularity: Generally one action per line, with multiline expressions formatted cleanly. Reading flow: Configuration defaults, URL construction, and superclass initialization follow a natural sequence; the assertion briefly interrupts that flow.
Run 2
Code Structure: The class cleanly separates environment initialization from JSON serialization, with logically grouped configuration and URL handling. Nesting: Control flow stays shallow, with only a few conditionals inside the base_url branch. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain the purpose well, although the compound assertion is harder to interpret than a direct validation condition. Code length: Methods are concise, but numerous imports unused in this excerpt and the lengthy parameter documentation add reading overhead. Action granularity: Statements generally perform one action per line; multiline expressions are formatted clearly. Reading flow: Initialization proceeds naturally from validation through default resolution and URL construction to superclass initialization. The dense assertion and the Flask annotation without a visible import slightly interrupt an otherwise clear presentation.
Run 3
Code Structure: Imports, a focused class, and two clearly separated methods provide logical organization. Nesting: Mostly shallow, with a few straightforward conditionals inside base URL construction. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain application-specific defaults well; however, the compound assertion is difficult to parse. Code length: Implementation is concise for its purpose, although the documentation is relatively lengthy. Action granularity: Statements generally perform one action each, and multiline expressions improve formatting without combining unrelated operations. Reading flow: Configuration lookup, URL construction, instance initialization, and parent initialization follow a natural sequence. Minor distractions include unused imports in the supplied snippet and the unexplained Flask annotation.