@shortlink-org/portolan 0.2.4 → 0.4.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")
@@ -250,6 +303,19 @@ class Reading(unittest.TestCase):
         self.assertEqual([b["name"] for b in self.aggregate["entities"]], ["Invoice", "InvoiceLine"])
         self.assertEqual([b["name"] for b in self.aggregate["valueObjects"]], ["Money"])
 
+    def test_a_model_field_states_its_rules_and_whether_it_must_be_given(self):
+        invoice = next(b for b in self.aggregate["entities"] if b["name"] == "Invoice")
+        fields = {f["name"]: f for f in invoice["fields"]}
+        self.assertEqual(fields["number"].get("rules"), [{"name": "max_len", "value": "32"}, {"name": "unique"}])
+        self.assertNotIn("required", fields["number"])  # null=True: the model lets it be absent
+        self.assertEqual(fields["currency"], {"name": "currency", "type": "CharField", "doc": "", "required": True, "rules": [{"name": "max_len", "value": "3"}]})
+        self.assertEqual(
+            fields["status"].get("rules"),
+            [{"name": "max_len", "value": "16"}, {"name": "in", "value": "draft, issued, paid, void"}],
+        )
+        self.assertNotIn("required", fields["status"])  # a default fills it
+        self.assertEqual(fields["id"].get("rules"), [{"name": "format", "value": "uuid"}])
+
     def test_a_service_function_is_an_operation_and_a_write_makes_it_a_command(self):
         kinds = {o["id"]: o["kind"] for o in self.aggregate["operations"]}
         self.assertEqual(kinds["IssueInvoice"], "command")

package/plugins/extract-django/lifecycle.py

@@ -15,8 +15,9 @@ from dataclasses import dataclass, field as dc_field
 from typing import Dict, List, Optional, Tuple
 
 import catalog
+from choices import choice_tables
 from domain import Aggregate, ModelDef
-from source import assigned, bases, const_str, dotted, inner_class, keyword, methods
+from source import assigned, const_str, dotted, keyword, methods
 
 
 @dataclass
@@ -28,25 +29,6 @@ class Move:
     sources: List[str] = dc_field(default_factory=list)  # the states it may be made from, when the decorator says
 
 
-def choices_of(model: ModelDef, name: str) -> Dict[str, str]:
-    """A TextChoices class, as member name to the value stored in the column."""
-    node = inner_class(model.node, name)
-    if node is None:
-        for other in model.module.classes():
-            if other.name == name:
-                node = other
-                break
-    if node is None or not any(b.split(".")[-1].endswith("Choices") for b in bases(node)):
-        return {}
-    out = {}
-    for member, value, _ in assigned(node):
-        if isinstance(value, ast.Constant) and isinstance(value.value, str):
-            out[member] = value.value
-        elif isinstance(value, ast.Tuple) and value.elts and isinstance(value.elts[0], ast.Constant):
-            out[member] = value.elts[0].value
-    return out
-
-
 def state_of(node: ast.AST, choices: Dict[str, Dict[str, str]]) -> str:
     """`Status.DRAFT` or `"draft"`, either way the value in the column."""
     literal = const_str(node)
@@ -71,14 +53,6 @@ def status_field(model: ModelDef) -> Optional[str]:
     return "status" if model.field("status") else None
 
 
-def choice_tables(model: ModelDef) -> Dict[str, Dict[str, str]]:
-    out = {}
-    for node in list(model.node.body) + list(model.module.tree.body):
-        if isinstance(node, ast.ClassDef) and any(b.split(".")[-1].endswith("Choices") for b in bases(node)):
-            out[node.name] = choices_of(model, node.name)
-    return out
-
-
 def declared_table(model: ModelDef, choices: Dict[str, Dict[str, str]]) -> Dict[str, List[str]]:
     """`TRANSITIONS = {Status.DRAFT: [Status.ISSUED], ...}`, in the order written."""
     for name, value, _ in assigned(model.node):
@@ -160,6 +134,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/main.py

@@ -25,6 +25,7 @@ HERE = os.path.dirname(os.path.abspath(__file__))
 DESCRIPTOR = {
     "name": "extract-django",
     "summary": "Reads a Django service by its applications - models, events, services, DRF views, receivers, clients - into a catalog fragment, and its models into the store they are the schema of.",
+    "category": "code",
     "phases": ["extract"],
 }
 

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/rules.py

@@ -0,0 +1,154 @@
+"""What a model field says a value must satisfy, in the catalog's words.
+
+A Django model states its rules in the field call: `CharField(max_length=3,
+unique=True, choices=Status.choices, validators=[MinValueValidator(0)])`. The
+catalog has one vocabulary for these across every source (portolan.0015), so
+`max_length` is `max_len` here as `minLength` is in an OpenAPI document and
+`min_len` in a proto, and the page says all three the same way.
+
+The model is the source of truth for `required`: a field must be given when a
+row is made unless the class fills it in (`default`, `auto_now`, an auto id),
+lets it be empty (`blank`) or lets it be absent (`null`). What a serializer or
+a form adds on top is that layer's word, not the model's, and is not read here.
+"""
+
+from __future__ import annotations
+
+import ast
+from typing import Dict, List, Optional
+
+import catalog
+from choices import choice_tables
+from source import assigned, dotted, keyword, keyword_bool
+
+# The field classes whose name is itself a rule on the value.
+FORMATS = {
+    "EmailField": "email",
+    "URLField": "uri",
+    "UUIDField": "uuid",
+    "GenericIPAddressField": "ip",
+}
+NON_NEGATIVE = {"PositiveIntegerField", "PositiveBigIntegerField", "PositiveSmallIntegerField"}
+
+# Never required: the database numbers an auto id, a bool is False when not
+# given, and a many-to-many is a table of its own with no row to be missing.
+NEVER_REQUIRED = {"AutoField", "BigAutoField", "SmallAutoField", "BooleanField", "ManyToManyField"}
+
+# Options under which the model itself fills or excuses the value.
+FILLED_OR_EXCUSED = ("blank", "null", "auto_now", "auto_now_add")
+
+VALIDATORS = {
+    "MinValueValidator": "gte",
+    "MaxValueValidator": "lte",
+    "MinLengthValidator": "min_len",
+    "MaxLengthValidator": "max_len",
+    "RegexValidator": "pattern",
+}
+
+
+def rules_of(f, model) -> Dict[str, object]:
+    """`required` and `rules` for `catalog.field`, as keyword arguments; an
+    empty dict when the field says nothing about its value."""
+    out: Dict[str, object] = {}
+    if required(f):
+        out["required"] = True
+    found = rules(f, model)
+    if found:
+        out["rules"] = found
+    return out
+
+
+def required(f) -> bool:
+    if f.kind in NEVER_REQUIRED:
+        return False
+    if any(keyword_bool(f.call, option) for option in FILLED_OR_EXCUSED):
+        return False
+    return keyword(f.call, "default") is None
+
+
+def rules(f, model) -> List[Dict[str, str]]:
+    """The rules in the order the source states them: what the field class
+    says first, then the options as written."""
+    out = []
+    if f.kind in FORMATS:
+        out.append(catalog.rule("format", FORMATS[f.kind]))
+    if f.kind in NON_NEGATIVE:
+        out.append(catalog.rule("gte", "0"))
+    for kw in f.call.keywords:
+        if kw.arg == "max_length":
+            length = f.integer("max_length")
+            if length is not None:
+                out.append(catalog.rule("max_len", str(length)))
+        elif kw.arg == "unique" and keyword_bool(f.call, "unique"):
+            out.append(catalog.rule("unique"))
+        elif kw.arg == "choices":
+            values = choice_values(kw.value, model)
+            if values:
+                out.append(catalog.rule("in", ", ".join(values)))
+        elif kw.arg == "validators":
+            out.extend(validator_rules(kw.value))
+    return out
+
+
+def choice_values(node: ast.AST, model, depth: int = 0) -> List[str]:
+    """The values a `choices=` option allows, in the order it lists them.
+
+    `Status.choices` reads the Choices class; a literal list of pairs or of
+    bare values reads the value of each pair, descending into a group's own
+    list; a name reads the module-level constant it is assigned. Anything
+    else - a call, an import the module does not define - yields nothing, and
+    nothing is what the field then says, rather than an empty `in`.
+    """
+    if depth > 3:
+        return []
+    if isinstance(node, ast.Attribute) and node.attr == "choices":
+        table = choice_tables(model).get(dotted(node.value).split(".")[-1], {})
+        return list(table.values())
+    if isinstance(node, (ast.List, ast.Tuple)):
+        out: List[str] = []
+        for item in node.elts:
+            if isinstance(item, ast.Constant) and not isinstance(item.value, bool):
+                out.append(str(item.value))
+            elif isinstance(item, (ast.List, ast.Tuple)) and item.elts:
+                first = item.elts[0]
+                second = item.elts[1] if len(item.elts) > 1 else None
+                if isinstance(second, (ast.List, ast.Tuple)):
+                    out.extend(choice_values(second, model, depth + 1))  # a group: (label, [pairs])
+                elif isinstance(first, ast.Constant) and not isinstance(first.value, bool):
+                    out.append(str(first.value))
+                elif isinstance(first, ast.Attribute):
+                    value = choice_member(first, model)
+                    if value:
+                        out.append(value)
+        return out
+    if isinstance(node, ast.Name):
+        for name, value, _ in assigned(model.module.tree):
+            if name == node.id:
+                return choice_values(value, model, depth + 1)
+    return []
+
+
+def choice_member(node: ast.Attribute, model) -> Optional[str]:
+    """`Status.DRAFT` in a literal list of pairs: the member's stored value."""
+    table = choice_tables(model).get(dotted(node.value).split(".")[-1], {})
+    return table.get(node.attr)
+
+
+def validator_rules(node: ast.AST) -> List[Dict[str, str]]:
+    """`validators=[MinValueValidator(0), RegexValidator(r"^[A-Z]+$")]`: the
+    validators the catalog has words for, with the bound they were given. A
+    validator built from a name the module computes, or a regex meant to be
+    NOT matched, is left out rather than guessed."""
+    if not isinstance(node, (ast.List, ast.Tuple)):
+        return []
+    out = []
+    for item in node.elts:
+        if not isinstance(item, ast.Call):
+            continue
+        rule = VALIDATORS.get(dotted(item.func).split(".")[-1])
+        if rule is None or keyword_bool(item, "inverse_match"):
+            continue
+        given = item.args[0] if item.args else keyword(item, "limit_value") or keyword(item, "regex")
+        if isinstance(given, ast.Constant) and not isinstance(given.value, bool):
+            out.append(catalog.rule(rule, str(given.value)))
+    return out