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:
lI0O_b89f0cb5, lI0O_1e88bbff = 0, 0
while lI0O_1e88bbff < 2:
lI0O_b89f0cb5 ^= (lI0O_1e88bbff << 1) ^ 0xd
lI0O_1e88bbff += 1
lI0O_b89f0cb5 ^= lI0O_b89f0cb5
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 has good structure with a clear class definition and docstrings. Imports are mostly organized. However, readability issues exist: the __enter__ method contains obfuscated code (meaningless variable names and a pointless while loop with bitwise operations) that serves no purpose. This significantly reduces clarity of intent. The method's body is confusing and appears to be dead code or anti-debugging code. Nesting is shallow, which is good, but the import section is somewhat long. Action granularity is mostly one action per line, but the obfuscated section violates this by performing multiple operations. Reading flow is interrupted by this anomaly. The __exit__ method is clear and well-documented, but the raise_any method could benefit from more explicit error type imports. Overall, the code would be readable without the obfuscated block; its presence suggests either intentional obfuscation or an oversight, which detracts from maintainability.
Run 2
The code has decent imports, class documentation, and clear error handling logic in _CollectErrors, making parts readable. However, it contains a confusing, meaningless loop in __enter__ with obfuscated variable names (lI0O_b89f0cb5) and dead code, severely undermining clarity of intent and readability. The exit method is straightforward, and raise_any is clear. Overall structure is okay but marred by the pointless block and mixed style.
Run 3
The code is moderately readable. Imports are organized, and class/method docstrings clarify intent. However, the '__enter__' method contains obfuscated code (variable names like 'lI0O_b89f0cb5' and a pointless loop) that severely hurts clarity. The '__exit__' method is straightforward, but 'raise_any' mixes Python version handling with error grouping in a way that adds branching complexity. Nesting is shallow overall, which is good, but the obfuscated block introduces unnecessary length and confusion. Action granularity is mostly fine, with one logical action per line in most methods. Reading flow is disrupted by the dead code in '__enter__'. Overall, the structure is acceptable, but the obfuscation and dead code significantly reduce readability.
Run 1
Code Structure: Imports and context-manager methods are logically organized, but unrelated computation in __enter__ disrupts an otherwise coherent class. Nesting: Mostly shallow, with only a small loop and a two-level conditional in raise_any. Clarity of intent: The class docstring, descriptive method names, and type annotations clearly explain error collection, but cryptic variable names and pointless bitwise operations obscure __enter__. Code length: The core implementation is concise; the no-op loop and trailing pass add unnecessary length. Action granularity: Most lines perform one action, although the paired assignment and compound bitwise expression are less immediately readable. Reading flow: Error capture and version-dependent raising follow naturally, but the obfuscated block interrupts that flow and forces readers to investigate irrelevant behavior.
Run 2
Code Structure: The context-manager class is logically organized into initialization, entry, exit, and error reporting, but numerous unrelated imports add clutter. Nesting: Mostly shallow, with only modest nesting in raise_any. Clarity of intent: The class docstring, method names, and type annotations clearly explain error collection; however, cryptic variable names and meaningless arithmetic in __enter__ obscure its purpose. Code length: The implementation is compact overall, but the unused imports and no-op loop unnecessarily inflate it. Action granularity: Most lines perform one action, although the combined assignment and bitwise expression are harder to parse. Reading flow: The lifecycle methods follow a natural sequence, but the obfuscated entry logic interrupts an otherwise straightforward implementation.
Run 3
Code Structure: The context-manager class is logically organized, but numerous unused imports and unrelated operations distract from its purpose. Nesting: Mostly shallow; the nested conditional in raise_any remains easy to follow. Clarity of intent: The class docstring, method names, and type annotations clearly explain error collection, but opaque variable names and meaningless bitwise operations in __enter__ obscure intent. Code length: The core implementation is concise, yet the import list and no-op loop add unnecessary length. Action granularity: Most lines perform one action, although the paired assignment and compound bitwise expression reduce clarity. Reading flow: Initialization, exception capture, and deferred raising follow a natural sequence, interrupted by the irrelevant __enter__ logic.