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 >= (0x3, 0xb):
raise BaseExceptionGroup(message, self.errors) # noqa: F821
else:
raise self.errors[0x0]
Run 1
The code is generally readable and well-structured. Imports are organized, the class has a clear single responsibility, and docstrings explain intent. Methods are short, with one primary action per line. Nesting is shallow. Minor deductions: the conditional import/version logic in `raise_any` is slightly tangled and uses a magic number (`0x0`) for index 0. The type annotations are clear but add verbosity. Overall, it reads naturally with a logical flow.
Run 2
The code is fairly readable with clear structure and intent. The class has a concise docstring explaining its purpose, methods are small and focused, and type hints are used consistently. The nesting is minimal and the flow is logical. The main weaknesses are minor: the `__enter__` method with just `pass` is awkward, the version check with a hex literal `(0x3, 0xb)` is less readable than `(3, 11)`, and the fallback `self.errors[0x0]` uses hex unnecessarily. The import block is long but organized. Overall, the code is understandable but could be slightly cleaner.
Run 3
The code is moderately readable. It has clear structure with a docstring and a single class, and the logic is understandable. Import block is organized somewhat logically. However, nesting is minimal and clarity of intent is fair but the use of '0x0' instead of '0' for list indexing and the version check 'sys.version_info >= (0x3, 0xb)' are cryptic and hurt readability. Action granularity is good, one action per line mostly. The context manager's 'pass' in __enter__ is a minor smell. The exception group fallback is terse and not obvious. Overall, it is readable but not excellent.
Run 1
Code Structure: The context manager is logically organized into initialization, entry, exit, and deferred error reporting, although many imports are unused in this snippet. Nesting: Control flow is shallow, with only two levels in raise_any. Clarity of intent: The class docstring, method names, and type annotations clearly explain error collection and deferred raising. Hexadecimal literals for Python versions and the zero index unnecessarily obscure familiar values. Code length: The implementation is concise, though the import block outweighs the small class. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Methods follow the natural context-manager lifecycle, making the class easy to follow; import grouping and spacing before the class could be improved.
Run 2
Code Structure: The class is logically organized into initialization, context-manager methods, and error propagation, although many unrelated imports add clutter. Nesting: Most methods are flat; raise_any has modest, easily followed nesting. Clarity of intent: Descriptive names, type annotations, and docstrings clearly explain error collection and deferred raising. Hexadecimal literals for Python versions and list indexing unnecessarily obscure familiar values. Code length: The implementation is concise, but unused imports and an avoidable else after raise reduce economy. Action granularity: Each line generally performs one action, making behavior easy to scan. Reading flow: Methods follow the natural context-manager lifecycle, though import clutter and limited spacing between top-level sections slightly interrupt the flow.
Run 3
Code Structure: The context manager is logically organized into initialization, entry, exit, and error reporting, although many unrelated imports clutter the snippet. Nesting: Mostly flat, with only modest nesting in raise_any. Clarity of intent: The class docstring, method names, and type annotations clearly explain error collection and deferred raising; hexadecimal constants obscure otherwise straightforward version and index values. Code length: The implementation is concise, but unused imports add unnecessary length. Action granularity: Statements generally perform one action per line. Reading flow: Methods follow the natural context-manager lifecycle, followed by error reporting; excessive imports and unconventional numeric notation slightly interrupt readability.