Source code
from __future__ import annotations
import importlib.util
import os
import sys
import typing as t
from datetime import datetime
from functools import cache
from functools import update_wrapper
from types import TracebackType
import werkzeug.utils
from werkzeug.exceptions import abort as _wz_abort
from werkzeug.utils import redirect as _wz_redirect
from werkzeug.wrappers import Response as BaseResponse
from .globals import _cv_app
from .globals import app_ctx
from .globals import current_app
from .globals import request
from .globals import session
from .signals import message_flashed
class _CollectErrors:
"""A context manager that records and silences an error raised within it.
Used to run all teardown functions, then raise any errors afterward.
"""
def __init__(self) -> None:
self.errors: list[BaseException] = []
def __enter__(self) -> None:
pass
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> bool:
if exc_val is not None:
self.errors.append(exc_val)
return True
def raise_any(self, message: str) -> None:
"""Raise if any errors were collected."""
if self.errors:
if sys.version_info >= (3, 11):
raise BaseExceptionGroup(message, self.errors) # noqa: F821
else:
raise self.errors[0]
Run 1
The code is generally well-structured and readable. It has clear imports, a single class with a focused purpose, and appropriate type hints. The nesting is minimal, with only one if-else block inside a method. The docstrings explain intent well. Action granularity is mostly good—one logical operation per line. Reading flow is natural, with the class defined top-down and methods in a logical order. Minor deductions: the `raise_any` method mixes environment-specific branching (Python version check) inside the error-raising logic, which slightly complicates intent. The `__enter__` method with only `pass` is a bit verbose for what it does. Overall, this is clean, maintainable code with clear purpose and good separation of concerns, but not perfect due to minor complexity in the error grouping logic.
Run 2
The code is generally well-structured with clear intent and good use of type hints. Imports are organized, and the class has a focused responsibility. The context manager methods are concise, and docstrings explain non-obvious behavior. Reading flow is natural. Minor deductions: the `raise_any` method mixes error handling logic with version-specific branching, slightly reducing clarity; the `# noqa: F821` comment signals a potential linting suppression needing explanation. The `__enter__` method with only `pass` is a minor code-length concern, though acceptable for the pattern. Overall, it's readable but not exemplary due to the version-conditional complexity.
Run 3
The code is clean, well-structured, and highly readable. It uses clear imports, type hints, and a focused class with a single responsibility. The context manager methods are short, with minimal nesting and one action per line. Docstrings explain intent, and the conditional error raising is straightforward. Minor deduction for the no-longer-necessary sys.version_info check (BaseExceptionGroup exists in Python 3.11+) and slight verbosity in imports, but overall readability is excellent.
Run 1
Code Structure: The context manager is logically organized into initialization, entry, exit, and error reporting, although many imports are unused in this snippet. Nesting: Shallow overall, with only a small nested conditional in raise_any. Clarity of intent: Descriptive names, type annotations, and docstrings clearly explain error collection and deferred raising; returning True implicitly suppresses exceptions and requires familiarity with context managers. Code length: The implementation is concise, but the extensive import block adds clutter relative to the class. Action granularity: Each line generally performs one action, making operations easy to follow. Reading flow: Methods follow the natural context-manager lifecycle, followed by reporting collected errors. Consistent formatting and spacing support readability.
Run 2
Code Structure: The class cleanly separates initialization, context-manager behavior, and deferred error raising, although many imports are unrelated to this snippet. Nesting: Control flow is shallow, with only two conditional levels in raise_any. Clarity of intent: Descriptive names, type annotations, and docstrings clearly explain error collection and suppression. Code length: The implementation is concise, but the extensive import block adds visual overhead. Action granularity: Each line performs a single clear action. Reading flow: Methods follow a natural lifecycle from initialization through entry, exit, and error reporting. The version-dependent exception handling is straightforward, though returning True unconditionally and raising only the first error on older Python versions require some attention.
Run 3
Code Structure: The context manager is logically organized into initialization, entry, exit, and error reporting, although many imports are unused in this snippet. Nesting: Control flow is shallow; only raise_any introduces two levels of conditionals. Clarity of intent: Descriptive names, type annotations, and docstrings clearly explain error collection and deferred raising. Code length: The implementation is concise, but the extensive import block is disproportionate to the shown functionality. Action granularity: Each statement performs a single action, and the multiline signature remains easy to scan. Reading flow: Methods follow the natural context-manager lifecycle, with whitespace separating responsibilities. The version-dependent exception handling is straightforward, though its differing behavior across Python versions requires a little interpretation.