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 and readable. It has a clear single-purpose class with a focused responsibility: providing a better error message for a specific debugging scenario. The nesting is minimal, with only one conditional block, keeping the logic flat and easy to follow. Variable and method names are descriptive, and the error message construction is logical. The code is concise—no unnecessary lines or complex abstractions. Each action (checking form matches, building strings, joining) is on its own line, improving readability. The reading flow is natural: from the class docstring, to the constructor's error message building, to the string representation. Minor potential improvements could include slightly better grouping of the f-strings, but overall the code is highly readable.
Run 3
The code is well-structured and readable. It uses clear naming, docstrings, and typing. The exception class has a single responsibility and constructs a useful error message logically. Line length is managed with string concatenation, and nesting is minimal with only one conditional. The reading flow is natural: initialization, message building, conditional addition, string rendering. Minor drawbacks: string assembly via list and join is slightly verbose for the simple case, and the triple-purpose inheritance (KeyError, AssertionError) may be non-obvious without context. Overall intent is clear and the code is maintainable.
Run 1
Code Structure: The exception class is logically organized, with message construction in __init__ and string representation in __str__. Several unused imports add clutter, and Request is not imported in the snippet. Nesting: Only one shallow conditional keeps the code easy to follow. Clarity of intent: The descriptive class name, docstring, and explicit error message clearly explain its purpose; buf is slightly generic. Code length: The implementation is concise, with most length devoted to useful diagnostic text. Action granularity: Each statement performs one clear operation, and multiline strings improve readability without combining unrelated actions. Reading flow: The sequence naturally progresses from checking submitted form values to building the message and exposing it through __str__.
Run 2
Code Structure: The exception class cleanly separates message construction from string representation. Nesting: Only one shallow conditional keeps control flow simple. Clarity of intent: Descriptive names, type annotations, and a helpful docstring make the purpose clear, although Request is not imported in the snippet and several imports are unused. Code length: The implementation is concise; most of its length supports a detailed diagnostic message. Action granularity: Each statement performs a distinct operation, with no crowded multi-action lines. Reading flow: The sequence from inspecting form data to constructing and returning the message is natural. Minor distractions include unused imports, limited spacing around top-level declarations, and the long message split across several string literals.
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 flat and easy to follow. Clarity of intent: The descriptive class name, docstring, and explicit error message clearly explain its purpose; however, Request is not imported in the snippet, and several imports appear unused. Code length: The implementation is compact, although the lengthy message dominates the code. Action granularity: Statements generally perform one action each, with readable multiline formatting for strings. Reading flow: Execution flows naturally from retrieving form values to building the message and optionally adding filenames. Minor spacing issues between imports and the class, along with unused imports, slightly reduce readability.