@shortlink-org/portolan 0.2.4 → 0.3.0

package/plugins/extract-django/extract.py

@@ -74,7 +74,7 @@ def extract(input_: Input, opts: Options, b: Builder, cwd: str = "") -> None:
     endpoint_apps = routed_applications(project, applications, route_table)
     endpoints = []
     for app in endpoint_apps:
-        endpoints += [(app, endpoint) for endpoint in transport.read_endpoints(app, b, route_table)]
+        endpoints += [(app, endpoint) for endpoint in transport.read_endpoints(app, b, route_table, project)]
     serializer_registry = serializers_module.read(project, endpoint_apps)
     auth_registry = auth_module.Registry(project, opts.settings, b)
 
@@ -169,8 +169,6 @@ def extract(input_: Input, opts: Options, b: Builder, cwd: str = "") -> None:
     }
 
     fragment = {
-        "generatedAt": input_.generated_at,
-        "commit": input_.commit,
         "contexts": [
             {
                 "id": context,
@@ -223,8 +221,6 @@ def extract(input_: Input, opts: Options, b: Builder, cwd: str = "") -> None:
     )
     store_id = "%s.%s" % (svc_id, effective_store)
     stores_fragment = {
-        "generatedAt": input_.generated_at,
-        "commit": input_.commit,
         "contexts": [
             {
                 "id": context,
@@ -296,7 +292,7 @@ def http_contracts(endpoints, svc_id: str, source: str) -> List[Dict[str, Any]]:
     grouped: Dict[str, List[Any]] = {}
     apps: Dict[str, Any] = {}
     for app, endpoint in endpoints:
-        if not endpoint.verb or not endpoint.path:
+        if not endpoint.path:
             continue
         grouped.setdefault(app.dotted, []).append(endpoint)
         apps[app.dotted] = app
@@ -313,6 +309,10 @@ def http_contracts(endpoints, svc_id: str, source: str) -> List[Dict[str, Any]]:
             method = {"name": name}
             if endpoint.doc:
                 method["doc"] = endpoint.doc
+            # A mounted route whose verb no declaration proves keeps its path
+            # with the method empty: the route is a fact of the URLConf, the
+            # verb is explicitly unknown, and the merge will not match an
+            # outbound call against it until somebody declares it.
             method["http"] = {"method": endpoint.verb, "path": endpoint.path}
             methods.append(method)
         if not methods:
@@ -332,7 +332,21 @@ def openapi_document(endpoints, service_name: str, b: Builder, serializer_regist
     tags = set()
     operation_ids = set()
     for app, endpoint in sorted(endpoints, key=lambda item: (item[1].path, item[1].verb, item[0].label, item[1].id)):
-        if not endpoint.path or not endpoint.verb:
+        if not endpoint.path:
+            continue
+        if not endpoint.verb:
+            # The path is mounted; which verb answers there is not written
+            # down. A path item without operations says exactly that, where
+            # inventing a GET would be read as a fact.
+            path_item = paths.setdefault(endpoint.path, {})
+            path_item.setdefault("summary", title(endpoint.action))
+            path_item.setdefault(
+                "description",
+                "Mounted in URLConf by %s, but no HTTP verb is declared in source; no operation is inferred." % endpoint.route_source,
+            )
+            path_item.setdefault("x-portolan-inferred", True)
+            path_item.setdefault("x-portolan-source", endpoint.route_source)
+            path_item.setdefault("x-portolan-verb", "unknown")
             continue
         method = endpoint.verb.lower()
         path_item = paths.setdefault(endpoint.path, {})

package/plugins/extract-django/extract_test.py

@@ -10,6 +10,7 @@ import ast
 import json
 import os
 import sys
+import tempfile
 import unittest
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -35,7 +36,7 @@ OPTIONS = {
 def run(options):
     b = Builder()
     extract(
-        Input(root=FIXTURE, output=FIXTURE + "/portolan", commit="abc1234", generated_at="2026-09-05T00:00:00Z"),
+        Input(root=FIXTURE, output=FIXTURE + "/portolan"),
         Options.of(options),
         b,
         cwd=ROOT,
@@ -193,11 +194,63 @@ class Fragment(unittest.TestCase):
         self.assertIn("ledger_ledgerentry", tables)
         self.assertIn("ledger_auditrecord", tables)
         self.assertNotIn("ledger_ledgerentryproxy", tables)
-        self.assertNotIn("persists", tables["ledger_ledgerentry"])
+        self.assertEqual(tables["ledger_ledgerentry"]["persists"], {"aggregate": "shop.billing.models-ledger", "block": "shop.billing.models-ledger.ledger-entry"})
         self.assertNotIn("role", tables["ledger_ledgerentry"])
         service = json.loads(self.files["domain.json"])["contexts"][0]["services"][0]
         self.assertFalse(any(aggregate["slug"] == "ledger-entry" for aggregate in service["aggregates"]))
 
+    def test_ambiguous_apps_keep_all_concrete_models_without_requiring_a_root(self):
+        service = json.loads(self.files["domain.json"])["contexts"][0]["services"][0]
+        group = next(a for a in service["aggregates"] if a["slug"] == "models-ledger")
+        self.assertEqual(group["kind"], "model-group")
+        self.assertEqual(group["root"], "")
+        self.assertEqual([m["name"] for m in group["entities"]], ["LedgerEntry", "AuditRecord"])
+        self.assertNotIn("lifecycle", group)
+        self.assertFalse(any("models to choose from" in w.message or (w.ref == group["id"] and "no services module" in w.message) for w in self.warnings))
+
+    def test_rootless_group_keeps_app_operations_and_events_once(self):
+        with tempfile.TemporaryDirectory() as root:
+            app = os.path.join(root, "records")
+            os.mkdir(app)
+            for name, source in {
+                "models.py": "from django.db import models\nclass Alpha(models.Model):\n    name = models.CharField(max_length=30)\nclass Beta(models.Model):\n    owner = models.ForeignKey(Alpha, on_delete=models.CASCADE)\n",
+                "services.py": "def list_records():\n    return []\n",
+                "events.py": 'from dataclasses import dataclass\n@dataclass\nclass RecordsChanged:\n    name = "records.Changed"\n    record_id: int\n',
+            }.items():
+                with open(os.path.join(app, name), "w") as handle:
+                    handle.write(source)
+            builder = Builder()
+            extract(Input(root=root), Options.of({"context": "shop", "service": "records"}), builder, cwd=ROOT)
+            fragment = json.loads(next(f.contents for f in builder.files if f.name == "domain.json"))
+            groups = fragment["contexts"][0]["services"][0]["aggregates"]
+            self.assertEqual(len(groups), 1)
+            self.assertEqual(groups[0]["kind"], "model-group")
+            self.assertEqual(len(groups[0]["entities"]), 2)
+            self.assertEqual([op["id"] for op in groups[0]["operations"]], ["ListRecords"])
+            self.assertEqual([event["name"] for event in groups[0]["events"]], ["RecordsChanged"])
+
+    def test_explicit_root_replaces_the_group_without_duplicating_models(self):
+        files, warnings = run(dict(OPTIONS, aggregates={"ledger": "LedgerEntry"}))
+        self.assertFalse(any("models to choose from" in w.message for w in warnings))
+        service = json.loads(files["domain.json"])["contexts"][0]["services"][0]
+        aggregate = next(a for a in service["aggregates"] if a["slug"] == "ledger-entry")
+        self.assertEqual(aggregate["entities"][0]["name"], "LedgerEntry")
+        self.assertNotIn("kind", aggregate)
+        self.assertFalse(any(a["slug"] == "models-ledger" for a in service["aggregates"]))
+        store = json.loads(files["stores.json"])["stores"][0]
+        table = next(t for t in store["tables"] if t["name"] == "ledger_ledgerentry")
+        self.assertEqual(table["role"], "aggregate-root")
+
+    def test_invalid_or_proxy_root_offers_a_replacement(self):
+        for root in ["Missing", "LedgerEntryProxy", "RecordBase"]:
+            files, warnings = run(dict(OPTIONS, aggregates={"ledger": root}))
+            service = json.loads(files["domain.json"])["contexts"][0]["services"][0]
+            group = next(a for a in service["aggregates"] if a["slug"] == "models-ledger")
+            self.assertEqual(len(group["entities"]), 2)
+            warning = next(w for w in warnings if "aggregates names" in w.message)
+            candidates = json.loads(warning.message.split("; aggregate candidates: ")[1])
+            self.assertEqual([m["name"] for m in candidates["models"]], ["AuditRecord", "LedgerEntry"])
+
     def test_abstract_fields_custom_postgres_fields_and_unresolved_relations_are_described(self):
         store = json.loads(self.files["stores.json"])["stores"][0]
         table = next(table for table in store["tables"] if table["name"] == "ledger_ledgerentry")

package/plugins/extract-django/lifecycle.py

@@ -160,6 +160,8 @@ def movers(model: ModelDef, status: str, choices: Dict[str, Dict[str, str]], eve
 
 def read(agg: Aggregate, events: Dict[str, object], b) -> Optional[Dict[str, object]]:
     model = agg.root
+    if model is None:
+        return None
     status = status_field(model)
     if status is None:
         return None

package/plugins/extract-django/operations.py

@@ -87,7 +87,7 @@ def read_use_cases(agg: Aggregate, b) -> List[UseCase]:
                     kind="command" if writes(node) else "query",
                 )
             )
-    if not out:
+    if not out and agg.root is not None:
         b.warn(agg.id, "no services module under %s: the aggregate has no operations, only whatever the views do inline" % agg.app.rel)
     return sorted(out, key=lambda u: u.id)
 

package/plugins/extract-django/routing_test.py

@@ -96,11 +96,70 @@ class Maintenance:
     @classmethod
     def fetch(cls, request):
         return None
+
+from django.http import HttpResponseNotAllowed
+from django.utils.decorators import method_decorator
+from django.views.decorators.http import require_GET, require_http_methods
+from rest_framework.decorators import api_view
+from .helpers import ensure_post, guarded
+
+class Planet:
+    @classmethod
+    @require_http_methods(["POST"])
+    def fetch(cls, request):
+        return None
+
+    @classmethod
+    @ensure_post
+    def refresh(cls, request):
+        return None
+
+    @classmethod
+    def reindex(cls, request):
+        if request.method != "PUT":
+            return HttpResponseNotAllowed(["PUT"])
+        return None
+
+    @classmethod
+    def status(cls, request):
+        return guarded(request, cls._status)
+
+    @classmethod
+    def _status(cls):
+        return None
+
+@method_decorator(require_GET, name="dispatch")
+class Reports:
+    @classmethod
+    def summary(cls, request):
+        return None
+
+class Exports:
+    http_method_names = ["patch", "options", "head"]
+
+    @classmethod
+    def run(cls, request):
+        return None
+
+@api_view(["GET", "POST"])
+def toggle(request):
+    return None
+''',
+            "orders/helpers.py": '''
+from django.views.decorators.http import require_POST
+
+def ensure_post(view):
+    return require_POST(view)
+
+def guarded(request, handler):
+    if request.method.lower() in ("delete", "patch"):
+        return handler()
+    return None
 ''',
             "orders/urls.py": '''
 from django.urls import path, re_path
 from rest_framework.routers import DefaultRouter
-from .views import Health, Maintenance, OrderDetail, OrderList, OrderViewSet
+from .views import Exports, Health, Maintenance, OrderDetail, OrderList, OrderViewSet, Planet, Reports, toggle
 
 router = DefaultRouter()
 router.register("orders", OrderViewSet, basename="order")
@@ -109,6 +168,13 @@ urlpatterns = [
     path("manual/<uuid:pk>/", OrderDetail.as_view(), name="order-detail"),
     re_path(r"^health/(?P<region>[^/]+)/$", Health.get),
     path("maintenance/fetch", Maintenance.fetch),
+    path("planet/fetch", Planet.fetch),
+    path("planet/refresh", Planet.refresh),
+    path("planet/reindex", Planet.reindex),
+    path("planet/status", Planet.status),
+    path("reports/summary", Reports.summary),
+    path("exports/run", Exports.run),
+    path("toggle/", toggle),
 ] + router.urls
 ''',
         }
@@ -163,6 +229,48 @@ urlpatterns = [
         parameter = spec["paths"]["/api/v2/manual/{pk}/"]["get"]["parameters"][0]
         self.assertEqual(parameter["schema"], {"type": "string", "format": "uuid"})
 
+    def test_a_mounted_method_takes_its_verb_from_what_the_code_declares(self):
+        routes = routing.read(self.project)
+        app = apps.discover(self.project, ["orders"])[0]
+        b = Builder()
+        endpoints = transport.read_endpoints(app, b, routes, self.project)
+        verbs = {}
+        for item in endpoints:
+            verbs.setdefault(item.path, set()).add(item.verb)
+        # Each tier of evidence, from the handler outwards.
+        self.assertEqual(verbs["/api/v2/planet/fetch"], {"POST"})  # @require_http_methods on the handler
+        self.assertEqual(verbs["/api/v2/reports/summary"], {"GET"})  # @method_decorator(require_GET, name="dispatch") on the class
+        self.assertEqual(verbs["/api/v2/exports/run"], {"PATCH"})  # http_method_names, less HEAD and OPTIONS
+        self.assertEqual(verbs["/api/v2/planet/reindex"], {"PUT"})  # a branch on request.method
+        self.assertEqual(verbs["/api/v2/planet/refresh"], {"POST"})  # a project decorator that applies require_POST
+        self.assertEqual(verbs["/api/v2/planet/status"], {"DELETE", "PATCH"})  # a wrapper the handler hands request to
+        self.assertEqual(verbs["/api/v2/toggle/"], {"GET", "POST"})  # every method @api_view lists, not the first
+        fetch = next(item for item in endpoints if item.path == "/api/v2/planet/fetch")
+        self.assertTrue(fetch.verb_source.startswith("decorator at orders/views.py:"), fetch.verb_source)
+        status = {item.id: item.verb_source for item in endpoints if item.path == "/api/v2/planet/status"}
+        self.assertEqual(sorted(status), ["api_v2_planet_status", "api_v2_planet_status_patch"])
+        self.assertTrue(all(source.startswith("wrapper guarded at orders/helpers.py:") for source in status.values()), status)
+
+        # No tier speaks for Maintenance.fetch: the verb is unknown, and the
+        # route stays in the model saying so instead of disappearing.
+        self.assertEqual(verbs["/api/v2/maintenance/fetch"], {""})
+        self.assertEqual(
+            [w.message.split(";")[0] for w in b.warnings if w.ref == "orders/urls.py:12"],
+            ["Maintenance.fetch is mounted as an HTTP view, but no HTTP verb is declared"],
+        )
+        pairs = [(app, item) for item in endpoints]
+        contracts = http_contracts(pairs, "shop.orders", "orders/portolan/openapi.inferred.yaml")
+        methods = {method["name"]: method["http"] for method in contracts[0]["methods"]}
+        self.assertEqual(methods["api_v2_maintenance_fetch"], {"method": "", "path": "/api/v2/maintenance/fetch"})
+        self.assertEqual(methods["api_v2_planet_status_patch"], {"method": "PATCH", "path": "/api/v2/planet/status"})
+        spec = openapi_document(pairs, "Orders", Builder())
+        unknown = spec["paths"]["/api/v2/maintenance/fetch"]
+        self.assertEqual(unknown["x-portolan-verb"], "unknown")
+        self.assertEqual(unknown["x-portolan-source"], "orders/urls.py:12")
+        self.assertFalse({"get", "post", "put", "patch", "delete"} & set(unknown))
+        self.assertIn("post", spec["paths"]["/api/v2/planet/fetch"])
+        self.assertEqual(sorted(spec["paths"]["/api/v2/planet/status"]), ["delete", "patch"])
+
     def test_queryset_and_serializer_metadata_resolve_the_inherited_action_model(self):
         routes = routing.read(self.project)
         app = apps.discover(self.project, ["orders"])[0]

package/plugins/extract-django/store.py

@@ -345,7 +345,7 @@ def model_table(
         columns,
         indexes(model, name, by_field),
         {"aggregate": aggregate.id, "block": block} if aggregate is not None else None,
-        "aggregate-root" if aggregate is not None and model is aggregate.root else "child" if aggregate is not None else "",
+        "aggregate-root" if aggregate is not None and model is aggregate.root else "child" if aggregate is not None and aggregate.root is not None else "",
         meta_str(model, "verbose_name"),
     )
 

package/plugins/extract-django/transport.py

@@ -11,12 +11,13 @@ from __future__ import annotations
 import ast
 import re
 from dataclasses import dataclass, field as dc_field
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 
+import verbs as verbs_module
 from apps import App
 from ids import slug
 from routing import Route, Routes
-from source import Module, const_str, doc, dotted, keyword, methods
+from source import Module, Project, const_str, doc, dotted, keyword, methods
 
 # The actions a ViewSet has without writing one.
 ACTIONS = {
@@ -61,6 +62,10 @@ class Endpoint:
     doc: str = ""
     use_cases: List[str] = dc_field(default_factory=list)
     path_parameters: Dict[str, str] = dc_field(default_factory=dict)
+    # Where the verb was read when the handler's name did not say it: a
+    # decorator, ``http_method_names``, a ``request.method`` branch or a
+    # project wrapper, with the file:line. Empty when the verb is unknown.
+    verb_source: str = ""
 
 
 def basenames(app: App) -> Dict[str, str]:
@@ -95,18 +100,29 @@ def view_name(name: str) -> str:
     return slug(name).replace("-", "_")
 
 
-def verb_of(node: ast.AST, action: str) -> str:
-    decorator = None
+HANDLER_NAMES = ("get", "post", "put", "patch", "delete")
+
+
+def verbs_of(node: ast.AST, action: str) -> Tuple[str, ...]:
+    """The verbs a handler answers by its own declaration: every method an
+    ``@action``/``@api_view`` lists, else what its conventional name means.
+    Empty for a handler whose name is the project's own."""
     for dec in getattr(node, "decorator_list", []):
         if isinstance(dec, ast.Call) and dotted(dec.func).split(".")[-1] in ("action", "api_view"):
-            decorator = dec
-    if decorator is not None:
-        methods_arg = keyword(decorator, "methods")
-        if methods_arg is None and decorator.args:
-            methods_arg = decorator.args[0]
-        if isinstance(methods_arg, (ast.List, ast.Tuple, ast.Set)) and methods_arg.elts:
-            return const_str(methods_arg.elts[0]).upper()
-    return ACTIONS.get(action, "" if action not in ("get", "post", "put", "patch", "delete") else action.upper())
+            listed = verbs_module.listed_verbs(dec)
+            if listed:
+                return listed
+    if action in ACTIONS:
+        return (ACTIONS[action],)
+    return (action.upper(),) if action in HANDLER_NAMES else ()
+
+
+def is_action(node: ast.AST) -> bool:
+    return any(isinstance(dec, ast.Call) and dotted(dec.func).split(".")[-1] == "action" for dec in getattr(node, "decorator_list", []))
+
+
+def is_api_view(node: ast.AST) -> bool:
+    return any(isinstance(dec, ast.Call) and dotted(dec.func).split(".")[-1] == "api_view" for dec in getattr(node, "decorator_list", []))
 
 
 def route_base(route: Route, fallback: str) -> str:
@@ -134,8 +150,10 @@ def action_path(route: Route, node: ast.AST, action: str) -> str:
     return base + ("/{id}" if detail else "") + ("/" + suffix if action not in ACTIONS else "") + "/"
 
 
-def endpoint(node: ast.AST, module: Module, view: str, action: str, verb: str, base: str, route: Optional[Route], description: str = "") -> Endpoint:
+def endpoint(node: ast.AST, module: Module, view: str, action: str, verb: str, base: str, route: Optional[Route], description: str = "", suffix: str = "", verb_source: str = "") -> Endpoint:
     ident = base if base == action or base.endswith("_" + action) else "%s_%s" % (base, action)
+    if suffix:
+        ident = "%s_%s" % (ident, suffix)
     return Endpoint(
         id=ident,
         action=action,
@@ -147,11 +165,30 @@ def endpoint(node: ast.AST, module: Module, view: str, action: str, verb: str, b
         route_source=route.source if route else "",
         doc=description,
         path_parameters=dict(route.parameters) if route else {},
+        verb_source=verb_source,
     )
 
 
-def read_endpoints(app: App, b, routes: Optional[Routes] = None) -> List[Endpoint]:
+def unknown_verb(b, route: Route) -> None:
+    b.warn(
+        route.source,
+        "%s is mounted as an HTTP view, but no HTTP verb is declared; the route is kept with its verb unknown and no operation is inferred for it. "
+        "Declare the verb with require_http_methods, @api_view, http_method_names or a branch on request.method" % route.view,
+    )
+
+
+def expand(handler: ast.AST, module: Module, view: str, action: str, verb_list: Tuple[str, ...], base: str, route: Optional[Route], description: str, verb_source: str) -> List[Endpoint]:
+    """One endpoint per verb. The first keeps the plain id; a second verb on
+    the same handler is told apart by the verb, ``planet_fetch_post``."""
+    out = []
+    for index, verb in enumerate(verb_list):
+        out.append(endpoint(handler, module, view, action, verb, base, route, description, suffix=verb.lower() if index else "", verb_source=verb_source))
+    return out
+
+
+def read_endpoints(app: App, b, routes: Optional[Routes] = None, project: Optional[Project] = None) -> List[Endpoint]:
     registered = basenames(app)
+    reader = verbs_module.Reader(project)
     out: List[Endpoint] = []
     for module in app.package("views"):
         for node in module.classes():
@@ -165,62 +202,71 @@ def read_endpoints(app: App, b, routes: Optional[Routes] = None) -> List[Endpoin
                 base = view_name(node.name)
                 b.warn(module.rel, "%s is registered by no router in %s/urls.py; its endpoints are named after the class" % (node.name, app.rel))
             handlers = {handler.name: handler for handler in methods(node)}
-            declared = []
+            method_routes: Dict[str, List[Route]] = {}
+            for route in mounted:
+                if "." in route.view:
+                    method_routes.setdefault(route.view.split(".", 1)[1], []).append(route)
+            # (action, verbs, handler, doc, where the verb was read)
+            declared: List[Tuple[str, Tuple[str, ...], ast.AST, str, str]] = []
             for handler in handlers.values():
                 if handler.name.startswith("_"):
                     continue
-                is_action = any(
-                    isinstance(dec, ast.Call) and dotted(dec.func).split(".")[-1] == "action" for dec in getattr(handler, "decorator_list", [])
-                )
-                if handler.name not in ACTIONS and not is_action and handler.name not in ("get", "post", "put", "patch", "delete"):
-                    # A plain Django class may expose an arbitrarily named
-                    # method directly in URLConf (`Planet.fetch`). The route
-                    # proves the HTTP entrypoint but, without a method
-                    # decorator or request-method branch, not one particular
-                    # verb. Keep it as a flow root and leave it out of the
-                    # inferred OpenAPI contract.
-                    if handler.name not in {
-                        route.view.split(".", 1)[1]
-                        for route in mounted
-                        if "." in route.view
-                    }:
-                        continue
-                declared.append((handler.name, verb_of(handler, handler.name), handler, doc(handler)))
+                verb_list = verbs_of(handler, handler.name)
+                verb_source = ""
+                if not verb_list and not is_action(handler) and handler.name not in method_routes:
+                    continue
+                if not verb_list:
+                    # A plain class may expose an arbitrarily named method
+                    # directly in URLConf (`Planet.fetch`). The route proves
+                    # the HTTP entrypoint; the verb is read off what the
+                    # handler, its class or a project wrapper declares, and
+                    # is left unknown - never guessed - when none of them does.
+                    evidence = reader.for_handler(module, handler, node)
+                    if evidence is not None:
+                        verb_list, verb_source = evidence.verbs, "%s at %s" % (evidence.rule, evidence.source)
+                    else:
+                        verb_list = ("",)
+                declared.append((handler.name, verb_list, handler, doc(handler), verb_source))
             inherited = []
             for inherited_base in bases:
                 inherited += GENERIC_ACTIONS.get(inherited_base, [])
             for action, verb in inherited:
-                same_direct_handler = mounted and all(not route.router for route in mounted) and any(item[1] == verb for item in declared)
+                same_direct_handler = mounted and all(not route.router for route in mounted) and any(verb in item[1] for item in declared)
                 if action not in handlers and not any(item[0] == action for item in declared) and not same_direct_handler:
-                    declared.append((action, verb, node, doc(node)))
+                    declared.append((action, (verb,), node, doc(node), ""))
             class_routes = routes.for_view(module.dotted, node.name) if routes else []
-            method_routes = {route.view.split(".", 1)[1]: route for route in mounted if "." in route.view}
             if not class_routes and not method_routes:
-                for action, verb, handler, description in declared:
-                    out.append(endpoint(handler, module, node.name, action, verb, base or view_name(node.name), None, description))
+                for action, verb_list, handler, description, verb_source in declared:
+                    out += expand(handler, module, node.name, action, verb_list, base or view_name(node.name), None, description, verb_source)
                 continue
-            for action, verb, handler, description in declared:
-                targets = class_routes or ([method_routes[action]] if action in method_routes else [])
-                for route in targets:
-                    if not verb:
-                        b.warn(
-                            route.source,
-                            "%s is mounted as an HTTP view, but no HTTP verb is declared; its flow is extracted and the route is omitted from inferred OpenAPI"
-                            % route.view,
-                        )
-                    out.append(endpoint(handler, module, node.name, action, verb, route_base(route, base or view_name(node.name)), route, description))
+            for action, verb_list, handler, description, verb_source in declared:
+                for route in class_routes or method_routes.get(action, []):
+                    if "" in verb_list:
+                        unknown_verb(b, route)
+                    out += expand(handler, module, node.name, action, verb_list, route_base(route, base or view_name(node.name)), route, description, verb_source)
         for node in module.functions():
             mounted = routes.for_view(module.dotted, node.name) if routes else []
-            if not mounted and not any(isinstance(dec, ast.Call) and dotted(dec.func).split(".")[-1] == "api_view" for dec in getattr(node, "decorator_list", [])):
+            if not mounted and not is_api_view(node):
                 continue
-            verb = verb_of(node, node.name)
-            if not verb:
+            verb_list = verbs_of(node, node.name)
+            verb_source = ""
+            if not verb_list:
+                evidence = reader.for_handler(module, node)
+                if evidence is not None:
+                    verb_list, verb_source = evidence.verbs, "%s at %s" % (evidence.rule, evidence.source)
+                elif mounted:
+                    verb_list = ("",)
+                else:
+                    continue
+            if not mounted:
+                for verb in verb_list:
+                    out.append(Endpoint(id=node.name, action=node.name, view="", verb=verb, node=node, module=module, doc=doc(node), verb_source=verb_source))
                 continue
-            if mounted:
-                for route in mounted:
-                    out.append(endpoint(node, module, "", verb.lower(), verb, route_base(route, node.name), route, doc(node)))
-            else:
-                out.append(Endpoint(id=node.name, action=node.name, view="", verb=verb, node=node, module=module, doc=doc(node)))
+            for route in mounted:
+                if "" in verb_list:
+                    unknown_verb(b, route)
+                for verb in verb_list:
+                    out.append(endpoint(node, module, "", verb.lower() or node.name, verb, route_base(route, node.name), route, doc(node), verb_source=verb_source))
     unique = {}
     for found in out:
         unique[(found.id, found.verb, found.path, found.module.rel)] = found