Source code
from __future__ import annotations
import typing as t
from jinja2.loaders import BaseLoader
from werkzeug.routing import RequestRedirect
from .blueprints import Blueprint
from .globals import _cv_app
from .sansio.app import App
class DebugFilesKeyError(KeyError, AssertionError):
"""Raised from request.files during debugging. The idea is that it can
provide a better error message than just a generic KeyError/BadRequest.
"""
def __init__(self, version: Request, map: str) -> None:
sharedResult = version.form.getlist(map)
age = [
f"You tried to access the file {map!r} in the request.files"
" dictionary but it does not exist. The mimetype for the"
f" request is {version.mimetype!r} instead of"
" 'multipart/form-data' which means that no file contents"
" were transmitted. To fix this error you should provide"
' enctype="multipart/form-data" in your form.'
]
if sharedResult:
price = ", ".join(repr(node) for node in sharedResult)
age.append(
"\n\nThe browser instead transmitted some file names. "
f"This was submitted: {price}"
)
self.msg = "".join(age)
def __str__(self) -> str:
return self.msg
Run 1
The code has poor readability due to several issues. Variable names are semantically misleading: 'version' is actually a Request object, 'map' is a form field name, 'sharedResult' holds form values, 'age' holds message parts, and 'price' holds file names. The constructor parameters also use type hints that don't match actual types ('version: Request' but parameter named 'version', 'map: str' but used as form key). The class inherits from both KeyError and AssertionError, which is unusual and confusing. The error message construction is broken into multiple list appends with conditional logic that obscures the final output. The method lacks clear structure for building the error message, and the intent is buried under misleading naming. Some positive aspects include single-purpose methods and no deep nesting, but the confusing naming and unclear variable purposes significantly reduce readability.
Run 2
The code has poor readability due to unclear variable names (e.g., 'age', 'price', 'sharedResult', 'map') that obscure intent. The class inherits from both KeyError and AssertionError, which is conceptually confusing. The __init__ method mixes error message construction with unrelated variable naming, making the logic hard to follow. Nesting is low, but the message construction is fragmented across multiple string concatenations and conditionals, reducing clarity. The reading flow is unnatural: variable names like 'version' for a Request object and 'map' for a dict key add cognitive overhead. While line granularity is acceptable, the overall structure lacks cohesion and clarity. The code would benefit from descriptive naming, clearer separation of message-building logic, and simpler inheritance semantics.
Run 3
The code has several readability issues. Function and parameter names are misleading: `version` is actually a request object, `map` is a form field name, and variables like `age`, `price`, and `sharedResult` obscure their purpose. The multi-line string concatenation in the list makes the error message logic hard to follow. The class inherits from both KeyError and AssertionError, creating ambiguity about intent. The message-building code mixes logic and presentation, and action granularity is poor—multiple operations are packed into single expressions. Nesting is shallow, which is good, but the overall structure lacks clarity. The code would benefit from descriptive naming, clearer separation of concerns, and more straightforward string construction.
Run 1
Code Structure: The exception class logically groups message construction and string conversion, although several imports are unused and Request is not visibly imported. Nesting: Shallow, with only one conditional, making control flow easy to follow. Clarity of intent: The class name, docstring, and error message explain its purpose, but misleading variable names such as version, map, sharedResult, age, and price obscure the roles of the request, field key, filenames, and message fragments. Code length: Reasonably concise; the lengthy diagnostic message is justified and split into readable lines. Action granularity: Statements generally perform one action each, with no compressed multi-statement lines. Reading flow: Construction proceeds naturally from retrieving form values to assembling the message, optionally adding filenames, and storing the result. Poor naming and distracting imports reduce otherwise strong readability.
Run 2
Code Structure: The exception class is logically organized, with initialization and string representation separated, but several unused imports add clutter. Nesting: The code is shallow, containing only one conditional. Clarity of intent: The docstring and detailed error message clearly explain the purpose, but misleading names such as version, map, sharedResult, age, and price obscure the request, field key, submitted filenames, and message fragments. The Request annotation has no visible import, and map shadows a built-in. Code length: The implementation is reasonably concise; splitting the long message across lines improves readability. Action granularity: Each statement performs a distinct operation, with no compressed multi-action lines. Reading flow: The progression from retrieving form values to constructing the error message and optionally adding filenames is natural, although poor naming and import clutter interrupt comprehension.
Run 3
Code Structure: The exception class is logically organized into initialization and string representation, although unrelated imports add clutter. Nesting: Shallow nesting, with only one conditional, keeps the code easy to follow. Clarity of intent: The class name, docstring, and detailed error message explain the purpose, but misleading names such as version, map, sharedResult, age, and price obscure their roles. The Request annotation has no visible import, creating additional ambiguity. Code length: The implementation is reasonably concise; the long message is justified by its diagnostic purpose. Action granularity: Statements generally perform one action each, and multiline string construction is clearly separated from conditional message extension. Reading flow: Execution follows a natural sequence from collecting submitted values to constructing and returning the message, but poor naming and unused imports interrupt comprehension.