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):
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 mostly clear and logically structured. Class definition is simple, with a single method and a string representation method. The error message construction uses a list and conditional append, which is readable. However, there are some minor issues: the inheritance from two exceptions (KeyError and AssertionError) is unusual and could confuse readers; the parameters are not type-annotated despite importing typing; the 'request' parameter is not used for form_matches, so the flow from request to form_matches lacks clarity; long f-string formatting lines reduce readability slightly. Nesting is minimal, action granularity is decent, but reading flow could be improved with better type hints and a comment explaining the custom exception's purpose.
Run 2
The code is generally readable with a clear class definition and logical error message construction. Structure is good: the __init__ method builds a list of message parts and joins them, which is clean. Nesting is minimal (one if block). However, clarity of intent is slightly reduced by inheriting from both KeyError and AssertionError, which is unusual and may confuse readers. Action granularity is mostly good, though the long list construction with mixed string concatenation and f-strings in the buf assignment could be split for easier reading. The reading flow is natural: error context, optional file names, then message assembly. Overall, the code is concise and well-organized, but the dual inheritance and slightly dense message-building section keep it from being exceptional.
Run 3
The code is well-structured with clear separation of concerns and follows Python conventions. The class definition is clean, with a single-purpose constructor and string method. Nesting is minimal (one conditional), and the logic flows naturally from error diagnosis to message construction. Variable names are descriptive (form_matches, buf, names), and action granularity is appropriate—each list append and string join is on its own line. Type hints improve clarity. Minor deductions: the mixed use of f-strings and regular strings in the error message list is slightly inconsistent, and the class inheritance from both KeyError and AssertionError could be briefly documented to clarify intent. Overall, the code is readable and maintainable.
Run 1
Code Structure: The exception class is logically organized, separating message construction from string representation, though several imports are unused. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: The descriptive class name, type annotations, and informative error message clearly convey its purpose; however, Request is not imported in the snippet, and buf is a generic name. Code length: The implementation is concise, with most lines devoted to useful diagnostic text, although excess blank lines add clutter. Action granularity: Each statement performs one distinct action, making execution easy to track. Reading flow: The progression from checking submitted form values to building and returning the message is natural. Mixed string quoting and the lengthy concatenated message slightly interrupt visual consistency.
Run 2
Code Structure: The exception class is logically organized, with message construction in __init__ and representation in __str__, though several imports appear unused. Nesting: Only one shallow conditional keeps complexity low. Clarity of intent: Descriptive names and an informative error message clearly explain the purpose; the missing Request import and unexplained dual inheritance slightly reduce clarity. Code length: The implementation is concise, although the long error message dominates the code and excess blank lines add noise. Action granularity: Each statement performs a distinct operation, with no compressed multi-action lines. Reading flow: Execution proceeds naturally from collecting form values to building the message and optionally adding context, but mixed quoting and split string literals mildly interrupt reading.
Run 3
Code Structure: The exception class is logically organized, with message construction in __init__ and presentation in __str__, though unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: The class name and detailed error message clearly communicate its purpose; abbreviated names such as buf and the unresolved Request annotation slightly reduce clarity. Code length: The implementation is concise, although the long diagnostic message occupies much of it. Action granularity: Each statement performs a distinct action, with no compressed multi-action lines. Reading flow: The sequence from checking form data to building and returning the message is natural. Excess blank space after the class declaration and fragmented string literals create minor visual distractions.