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:
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:
if self.errors:
if sys.version_info >= (3, 11):
raise BaseExceptionGroup(message, self.errors)
else:
raise self.errors[0]
Run 1
The code is highly readable with clear structure and intent. Each method is short, focused, and has a single responsibility. Type hints improve clarity. The context manager handles exceptions cleanly, and the version-specific logic is isolated in one place. Minor issues include a blank line after class definition, unused imports (which are typical in framework code), and slight logic ambiguity in 'raise_any' when multiple errors exist on Python < 3.11. Overall, the code is concise, follows logical flow, and is easy to understand.
Run 2
The code has clear structure with logical imports and a single class, but contains notable readability issues. The class has a missing docstring, and the `raise_any` method has an awkward indentation on line 37. Type hints are good, but the version check block creates unnecessary nesting. The `_CollectErrors` class could be simplified with a context manager decorator. The `_wz_abort` and `_wz_redirect` imports suggest unused or re-exported modules. Overall, the code is maintainable but lacks polish in formatting and documentation.
Run 3
The code is generally readable with a clear logical structure: imports are organized, class methods are well-separated, and type hints improve clarity. Nesting is mostly flat, with only one conditional block inside __exit__ and a simple if/else in raise_any. Intent is reasonably clear — a helper to collect exceptions raised within a context. However, some aspects reduce readability: the @cache import from functools is unused, imports include several potentially unnecessary dependencies (e.g., werkzeug, signals, globals) unrelated to the class, and the empty __enter__ method adds noise without clear purpose. Action granularity is good with one action per line, and reading flow is natural. The docstring-like blank lines before methods are unusual and could be replaced with actual docstrings for better clarity. Overall, it is clean but could be tightened by removing unused imports and adding documentation.
Run 1
Code Structure: The class is logically organized around collecting exceptions and raising them later, although many unrelated imports clutter the snippet. Nesting: Methods are mostly flat; raise_any has modest, easily followed nesting. Clarity of intent: Descriptive class and method names, type annotations, and straightforward conditionals communicate the purpose. However, unconditional exception suppression in __exit__ and the version-dependent raising behavior could benefit from explanation. Code length: The implementation is concise, but unused imports and excessive blank space reduce focus. Action granularity: Each line generally performs one action, with no compressed statements. Reading flow: Methods follow a natural lifecycle from initialization through context-manager handling to reporting errors; inconsistent whitespace and the disproportionate import section slightly interrupt that flow.
Run 2
Code Structure: The class logically groups exception collection and raising behavior, although numerous unused imports clutter the snippet. Nesting: Methods remain shallow, with only two levels in raise_any. Clarity of intent: Descriptive method names and type annotations make the purpose clear, but unconditional exception suppression in __exit__ and the version-dependent raising behavior would benefit from brief documentation. Code length: The implementation is concise, though excess blank lines and unused imports add noise. Action granularity: Each statement performs a single action, making individual operations easy to follow. Reading flow: Methods follow a natural initialization, context entry, context exit, and error-reporting sequence; inconsistent whitespace slightly disrupts the otherwise straightforward presentation.
Run 3
Code Structure: The class logically groups exception collection and deferred raising, although numerous unused imports clutter the snippet. Nesting: Control flow is shallow overall, with only two levels in raise_any. Clarity of intent: Descriptive class, method, and attribute names plus type annotations make the purpose clear; a brief explanation of unconditional exception suppression would help. Code length: The implementation is concise, but unused imports and empty whitespace add unnecessary length. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Methods follow a natural initialization, context-entry, exception-collection, and raising sequence. Excess blank lines and trailing whitespace slightly reduce polish.