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, request: Request, key: str) -> None:
form_matches = request.form.getlist(key)
buf = [
f"You tried to access the file {key!r} in the request.files"
" dictionary but it does not exist. The mimetype for the"
f" request is {request.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 form_matches:
names = ", ".join(repr(x) for x in form_matches)
buf.append(
"\n\nThe browser instead transmitted some file names. "
f"This was submitted: {names}"
)
self.msg = "".join(buf)
def __str__(self) -> str:
return self.msg
Run 1
The code is well-structured and readable. It uses clear imports, logical class definition, and a focused exception class with a single responsibility. The constructor builds an error message via a list of strings, which is a clean approach. Nesting is minimal (one conditional), and each line generally performs one logical action. The f-strings and multi-line string concatenation are readable, though the mixing of f-strings and plain string concatenation slightly interrupts flow. The class docstring explains intent clearly. Minor deductions: 'AssertionError' in the base classes is unusual and could confuse readers; 'form_matches' could be more descriptively named. Overall, the code is concise, well-organized, and easy to follow.
Run 2
The code is well-structured with clear separation of concerns — a custom exception class with a focused, single responsibility. It is flatly organized with no deep nesting, and the control flow is straightforward. Naming is descriptive, and the docstring clearly explains intent. The code is concise for what it does, though the multi-line f-string construction is slightly verbose but improves readability of the final error message. Action granularity is appropriate — each line does one logical step, especially in the list-building section. Reading flow is natural: setup, conditional, then message assembly. Minor deductions for slightly fragmented string concatenation and mixing f-strings with plain strings, which slightly disrupts visual flow, but overall the code is highly readable and maintainable.
Run 3
The code is highly readable with clear structure, minimal nesting, and a single responsibility per method. The custom exception class is logically organized, with the constructor building a helpful error message through a list and join operation. Nested logic is limited to one conditional block. Intent is clear: provide a more descriptive error for missing file keys in requests. Line lengths are reasonable, and each action is on its own line. The reading flow is natural, from error context to message construction to final string output. Minor deductions: the conditional appending to 'buf' could be slightly clearer, and 'self.msg' is initialized implicitly rather than declared in the signature, but overall readability is excellent.
Run 1
Code Structure: The exception class cleanly separates message construction from string representation, though several imports are unused and Request is not visibly defined. Nesting: Only one shallow conditional keeps complexity low. Clarity of intent: The descriptive class name, docstring, and informative error message make the purpose clear; buf and msg are slightly abbreviated. Code length: Compact overall, with most length devoted to useful diagnostic text rather than unnecessary logic. Action granularity: Each statement performs a focused action, and multiline string construction remains readable. Reading flow: Execution proceeds naturally from inspecting form data to constructing the message, optionally adding filenames, and storing the result.
Run 2
Code Structure: The exception class is logically organized, with initialization and string representation separated cleanly. Nesting: Only one shallow conditional keeps complexity low. Clarity of intent: The descriptive class name, docstring, and explicit error message clearly communicate its debugging purpose, though Request is not imported in the snippet and several imports are unused. Code length: The implementation is concise; most of its length comes from helpful diagnostic text. Action granularity: Each statement performs a focused action, and multiline string construction remains readable. Reading flow: Execution naturally progresses from collecting form values to assembling the message and exposing it through __str__. Minor weaknesses include the generic name buf and limited spacing between top-level sections.
Run 3
Code Structure: The exception class is logically organized, with message construction in __init__ and rendering in __str__. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: Descriptive names, type annotations, and the class docstring clearly communicate the debugging purpose, though Request is not imported in the snippet and several imports are unused. Code length: The implementation is concise; most of its length comes from a useful diagnostic message. Action granularity: Statements generally perform one action each, and multiline string construction remains readable. Reading flow: Execution proceeds naturally from gathering form values to composing the base message, adding optional details, and storing the result. Minor drawbacks include the generic name buf and limited spacing between top-level sections.