Source code
from __future__ import annotations
import typing as t
from . import typing as ft
from .globals import current_app
from .globals import request
class MethodView(View):
"""Dispatches request methods to the corresponding instance methods.
For example, if you implement a ``get`` method, it will be used to
handle ``GET`` requests.
This can be useful for defining a REST API.
:attr:`methods` is automatically set based on the methods defined on
the class.
See :doc:`views` for a detailed guide.
.. code-block:: python
class CounterAPI(MethodView):
def get(self):
return str(session.get("counter", 0))
def post(self):
session["counter"] = session.get("counter", 0) + 1
return redirect(url_for("counter"))
app.add_url_rule(
"/counter", view_func=CounterAPI.as_view("counter")
)
"""
def __init_subclass__(cls, **kwargs: t.Any) -> None:
super().__init_subclass__(**kwargs)
if "methods" not in cls.__dict__:
methods = set()
loopIterator = __import__("builtins").iter(cls.__bases__)
while True:
try:
base = __import__("builtins").next(loopIterator)
except __import__("builtins").StopIteration:
break
if getattr(base, "methods", None):
methods.update(base.methods) # type: ignore[attr-defined]
loopIteratorA = __import__("builtins").iter(http_method_funcs)
while True:
try:
key = __import__("builtins").next(loopIteratorA)
except __import__("builtins").StopIteration:
break
if hasattr(cls, key):
methods.add(key.upper())
if methods:
cls.methods = methods
def dispatch_request(self, **kwargs: t.Any) -> ft.ResponseReturnValue:
meth = getattr(self, request.method.lower(), None)
# If the request method is HEAD and we don't have a handler for it
# retry with GET.
if meth is None and request.method == "HEAD":
meth = getattr(self, "get", None)
assert meth is not None, f"Unimplemented method {request.method!r}"
return current_app.ensure_sync(meth)(**kwargs) # type: ignore[no-any-return]
Run 1
The code has decent structure and a clear class-level docstring, but readability is severely undermined by the __init_subclass__ implementation. It uses bizarre __import__('builtins') constructs, manual iteration loops with try/except StopIteration, and while True loops instead of simple for loops. This creates deep, awkward nesting that obscures the obvious intent—collecting method names from parent classes and HTTP method functions. The repeating loop pattern is verbose and confusing, making the logic hard to follow. However, dispatch_request is relatively clean and readable with good comments. Naming conventions like 'loopIterator' and 'loopIteratorA' are vague and unhelpful. The methods collection logic could be 5-6 lines using comprehensions or simple for loops, dramatically reducing length and improving clarity. The overall structure is logical, but the execution creates unnecessary complexity that buries the straightforward purpose.
Run 2
The code has good structure with a clear class hierarchy and docstring, but readability is hampered by the __init_subclass__ method. It uses manual while-loop iteration with builtins.next/StopIteration instead of natural for loops, obscuring intent. Naming is ambiguous ('loopIterator', 'loopIteratorA') and the logic for collecting HTTP methods is harder to follow than necessary. Nesting is moderate but avoidable try/except blocks add noise. The dispatch_request method is clearer, with a concise flow and helpful comments. Overall, the code is not unreadable, but the unusual iteration pattern and lack of clear variable naming reduce clarity and reading flow significantly compared to idiomatic Python.
Run 3
The code has a clear purpose and the docstring is helpful, but the implementation obscures that clarity. The __init_subclass__ method uses manual iterator loops with dynamic imports of builtins to iterate over bases and http_method_funcs, which is unnecessarily convoluted and should simply use 'for base in cls.__bases__' and 'for key in http_method_funcs'. This creates confusing nesting and poor reading flow. The action granularity is mixed; while some lines do one thing, the manual try/except loops spread a single logical action across multiple lines. The dispatch_request method is more readable, but the overall unnatural iterator pattern severely damages the score despite the class's well-documented intent.
Run 1
Code Structure: The class cleanly separates method discovery from request dispatch, but manual iterator management tangles discovery logic. Nesting: Moderate nesting, with try/except blocks inside loops inside a conditional, adds avoidable complexity. Clarity of intent: The docstring, type annotations, and HEAD fallback comment explain the purpose well; generic iterator names and repeated dynamic builtins imports obscure otherwise simple operations. Code length: Both while loops are unnecessarily verbose substitutes for straightforward for loops, although dispatch_request is concise. Action granularity: Most lines perform one action, but dynamic imports embedded in iterator operations make individual statements harder to parse. Reading flow: The overall progression is logical, but repeated StopIteration handling interrupts the flow and distracts from collecting supported methods.
Run 2
Code Structure: The class separates method discovery from request dispatch logically, but manual iterator machinery clutters initialization. Nesting: Initialization contains moderately deep nesting through conditionals, loops, and try/except blocks; dispatch remains flat. Clarity of intent: The docstring, HEAD fallback comment, and descriptive method names explain the purpose well, while generic iterator names and repeated dynamic builtins imports obscure simple iteration. Code length: Two ordinary for loops would substantially shorten the unnecessarily verbose initialization. Action granularity: Most lines perform one action, although dynamic imports embedded in iterator operations add cognitive overhead. Reading flow: Dispatch reads naturally, but repeated while/try/except patterns interrupt method discovery. References to View and http_method_funcs are not defined in the provided snippet, reducing its standalone clarity.
Run 3
Code Structure: The class logically separates method discovery from request dispatch, but discovery is cluttered by manual iterator handling. Nesting: Moderate nesting in __init_subclass__, including while/try/except blocks inside a conditional, makes scanning harder. Clarity of intent: The docstring, type annotations, and HEAD fallback comment explain the purpose well; generic iterator names and repeated dynamic builtins imports obscure otherwise simple loops. Code length: Two verbose iterator loops could be replaced with concise for loops; the long docstring is useful documentation rather than unnecessary code. Action granularity: Most lines perform one clear action, although chained dynamic imports and calls add visual complexity. Reading flow: dispatch_request reads naturally, while exception-driven iteration interrupts the discovery logic. View and http_method_funcs are not defined or imported in the shown snippet, reducing standalone clarity.