@babelize/engine 0.0.0-stage → 0.1.2

package/dist/django/python-extract.js

@@ -0,0 +1,619 @@
+"use strict";
+/**
+ * Django Python extraction.
+ *
+ * Finds two kinds of strings in a .py file:
+ *
+ *  1. Strings already marked for translation — `_()`, `gettext()`,
+ *     `gettext_lazy()`, `ngettext()`, `pgettext()`, `npgettext()` and their
+ *     lazy/legacy variants, under whatever local names the file imports them
+ *     as. These go into the catalogue as-is.
+ *
+ *  2. Hardcoded user-facing strings in places Django renders to users, which
+ *     the injector wraps with gettext / gettext_lazy:
+ *       - verbose_name, verbose_name_plural, help_text, label, empty_label,
+ *         empty_value_display keyword arguments; `description=` on
+ *         @admin.action / @admin.display; `message=` on validators;
+ *       - labels in `choices` (CHOICES lists, choices=, TextChoices members);
+ *       - error_messages dicts and widget attrs (placeholder, title, …);
+ *       - messages.info/success/… and ModelAdmin.message_user() text,
+ *         ValidationError messages — and string variables passed to them;
+ *       - text returned by template tags and filters (templatetags/*.py).
+ *
+ * Everything else (dict keys, identifiers, log lines, URLs, codes) is left
+ * alone: wrapping a string that is not shown to users changes behaviour.
+ * f-strings become `_("… %(name)s …") % {"name": expr}`; f-strings this can't
+ * rewrite safely are reported, not guessed at.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeNaturalLanguage = looksLikeNaturalLanguage;
+exports.extractDjangoPython = extractDjangoPython;
+const python_lexer_1 = require("./python-lexer");
+const types_1 = require("./types");
+const CANONICAL = {
+    gettext: 'gettext', ugettext: 'gettext',
+    gettext_lazy: 'gettext_lazy', ugettext_lazy: 'gettext_lazy',
+    gettext_noop: 'gettext_noop', ugettext_noop: 'gettext_noop',
+    ngettext: 'ngettext', ungettext: 'ngettext',
+    ngettext_lazy: 'ngettext_lazy', ungettext_lazy: 'ngettext_lazy',
+    pgettext: 'pgettext', pgettext_lazy: 'pgettext_lazy',
+    npgettext: 'npgettext', npgettext_lazy: 'npgettext_lazy',
+};
+/** Argument positions (and keyword names) of each gettext function. */
+const SIGNATURES = {
+    gettext: { singular: 0 }, gettext_lazy: { singular: 0 }, gettext_noop: { singular: 0 },
+    ngettext: { singular: 0, plural: 1 }, ngettext_lazy: { singular: 0, plural: 1 },
+    pgettext: { ctx: 0, singular: 1 }, pgettext_lazy: { ctx: 0, singular: 1 },
+    npgettext: { ctx: 0, singular: 1, plural: 2 }, npgettext_lazy: { ctx: 0, singular: 1, plural: 2 },
+};
+const KEYWORDS = new Set([
+    'if', 'elif', 'else', 'while', 'for', 'in', 'not', 'and', 'or', 'is', 'return', 'yield', 'lambda', 'assert',
+    'del', 'with', 'as', 'raise', 'from', 'import', 'await', 'print', 'case', 'match', 'except', 'global', 'nonlocal',
+]);
+/** Keyword arguments whose string value Django shows to users. */
+const UI_KWARGS = new Set(['verbose_name', 'verbose_name_plural', 'help_text', 'label', 'empty_label', 'empty_value_display']);
+/** Keys of widget `attrs` dicts that hold visible text. */
+const UI_ATTR_KEYS = new Set(['placeholder', 'title', 'aria-label', 'alt', 'aria-description']);
+const MESSAGE_FUNCS = /^messages\.(?:debug|info|success|warning|error)$/;
+/** Local names for django.utils.translation functions, from the file's imports. */
+function importAliases(tokens) {
+    const names = new Map();
+    const modules = new Set(['django.utils.translation']);
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.type !== 'name')
+            continue;
+        if (t.value === 'from') {
+            // from django.utils.translation import a as b, c
+            let j = i + 1;
+            let mod = '';
+            while (j < tokens.length && (tokens[j].type === 'name' || tokens[j].value === '.') && tokens[j].value !== 'import')
+                mod += tokens[j++].value;
+            if (tokens[j]?.value !== 'import')
+                continue;
+            j++;
+            const paren = tokens[j]?.value === '(';
+            if (paren)
+                j++;
+            const line = tokens[j]?.line;
+            while (j < tokens.length) {
+                const n = tokens[j];
+                if (n.type !== 'name') {
+                    if (n.value === ',') {
+                        j++;
+                        continue;
+                    }
+                    break;
+                }
+                if (!paren && n.line !== line && tokens[j - 1]?.value !== ',')
+                    break;
+                let local = n.value;
+                const imported = n.value;
+                if (tokens[j + 1]?.value === 'as' && tokens[j + 2]?.type === 'name') {
+                    local = tokens[j + 2].value;
+                    j += 3;
+                }
+                else {
+                    j++;
+                }
+                if (mod === 'django.utils.translation' && CANONICAL[imported])
+                    names.set(local, CANONICAL[imported]);
+                if (mod === 'django.utils' && imported === 'translation')
+                    modules.add(local);
+                if (tokens[j]?.value === ',')
+                    j++;
+                else
+                    break;
+            }
+        }
+        else if (t.value === 'import' && (i === 0 || tokens[i - 1].line !== t.line || tokens[i - 1].value !== 'from')) {
+            // import django.utils.translation as tr
+            let j = i + 1;
+            let mod = '';
+            while (j < tokens.length && (tokens[j].type === 'name' || tokens[j].value === '.') && tokens[j].value !== 'as' && tokens[j].line === t.line)
+                mod += tokens[j++].value;
+            if (mod === 'django.utils.translation') {
+                if (tokens[j]?.value === 'as' && tokens[j + 1]?.type === 'name')
+                    modules.add(tokens[j + 1].value);
+                else
+                    modules.add('django.utils.translation');
+            }
+        }
+    }
+    return { names, modules };
+}
+function resolveGettext(callee, aliases) {
+    if (!callee)
+        return null;
+    if (callee === '_')
+        return 'gettext';
+    const local = aliases.names.get(callee);
+    if (local)
+        return local;
+    const dot = callee.lastIndexOf('.');
+    if (dot > 0) {
+        const mod = callee.slice(0, dot);
+        const fn = callee.slice(dot + 1);
+        if (aliases.modules.has(mod) && CANONICAL[fn])
+            return CANONICAL[fn];
+    }
+    return null;
+}
+/** Dotted name ending at token index `end` (inclusive), e.g. `forms.ValidationError`. */
+function dottedNameBefore(tokens, end) {
+    if (tokens[end]?.type !== 'name' || KEYWORDS.has(tokens[end].value))
+        return undefined;
+    const parts = [tokens[end].value];
+    let k = end - 1;
+    while (k >= 1 && tokens[k].value === '.' && tokens[k - 1].type === 'name') {
+        parts.unshift(tokens[k - 1].value);
+        k -= 2;
+    }
+    return parts.join('.');
+}
+/** A string that reads as words, not an identifier, path or code. */
+function looksLikeNaturalLanguage(text) {
+    const t = text.trim();
+    if (t.length < 2 || !/\p{L}/u.test(t))
+        return false;
+    // A capitalized word ("Available", "E-book") reads as a label, not a code.
+    const capitalizedWord = /^\p{Lu}[\p{L}'-]*$/u.test(t) && /\p{Ll}/u.test(t) && !t.includes('_');
+    if (/^[\w.:/-]+$/.test(t) && !capitalizedWord)
+        return false; // snake_case, paths, urls, codes
+    if (/\.(?:html?|txt|css|js|py|json|xml|png|jpe?g|svg)$/i.test(t))
+        return false;
+    if (/^https?:\/\//.test(t))
+        return false;
+    return /\s/.test(t) || capitalizedWord || /^\p{Lu}\p{Ll}+[.!?]?$/u.test(t);
+}
+/** Name for an f-string field in `%(name)s` form. */
+function fieldName(expr) {
+    const e = expr.trim();
+    let m = /^(?:[A-Za-z_]\w*\.)*([A-Za-z_]\w*)$/.exec(e);
+    if (m)
+        return m[1];
+    m = /^(?:[A-Za-z_]\w*\.)*(?:get_)?([A-Za-z_]\w*)\(\)$/.exec(e);
+    if (m)
+        return m[1];
+    m = /^len\(\s*(?:[A-Za-z_]\w*\.)*([A-Za-z_]\w*)\s*\)$/.exec(e);
+    if (m)
+        return `${m[1]}_count`;
+    m = /^(?:[A-Za-z_][\w.]*)\[\s*['"]([A-Za-z_]\w*)['"]\s*\]$/.exec(e);
+    if (m)
+        return m[1];
+    return null;
+}
+/**
+ * Value of an implicit-concatenation group of string tokens. Returns a
+ * string reason when the group can't be turned into a msgid.
+ */
+function groupValue(src, tokens, first, last) {
+    const toks = tokens.slice(first, last + 1).filter((t) => t.type === 'string');
+    if (toks.some((t) => t.str.bytes))
+        return 'bytes literal';
+    const isF = toks.some((t) => t.str.f);
+    const original = src.slice(tokens[first].start, tokens[last].end);
+    if (!isF) {
+        const msgid = toks.map((t) => (0, python_lexer_1.decodePythonString)(src.slice(t.str.bodyStart, t.str.bodyEnd), t.str.raw)).join('');
+        return { msgid, inner: original, suffix: '', isF: false };
+    }
+    let msgid = '';
+    const fields = [];
+    for (const t of toks) {
+        const body = src.slice(t.str.bodyStart, t.str.bodyEnd);
+        if (!t.str.f) {
+            msgid += (0, python_lexer_1.decodePythonString)(body, t.str.raw).replace(/%/g, '%%');
+            continue;
+        }
+        const parts = (0, python_lexer_1.parseFString)(body, t.str.raw);
+        if (!parts)
+            return 'f-string with nested format fields';
+        for (const p of parts) {
+            if (p.kind === 'text') {
+                msgid += p.value.replace(/%/g, '%%');
+                continue;
+            }
+            if (p.debug)
+                return 'f-string with a self-documenting {expr=} field';
+            if (p.conversion && p.conversion !== 's')
+                return `f-string field with !${p.conversion} conversion`;
+            let spec = 's';
+            if (p.formatSpec !== undefined && p.formatSpec !== '') {
+                const sm = /^(\d*)(?:\.(\d+))?([dfs])$/.exec(p.formatSpec);
+                if (!sm)
+                    return `f-string field with format spec ":${p.formatSpec}"`;
+                spec = `${sm[1]}${sm[2] !== undefined ? `.${sm[2]}` : ''}${sm[3]}`;
+            }
+            const base = fieldName(p.value);
+            if (!base)
+                return `f-string field {${p.value}} is too complex to name`;
+            const existing = fields.find((f) => f.expr === p.value);
+            let name = existing?.name;
+            if (!name) {
+                name = base;
+                for (let n = 2; fields.some((f) => f.name === name); n++)
+                    name = `${base}${n}`;
+                fields.push({ name, expr: p.value });
+            }
+            msgid += `%(${name})${spec}`;
+        }
+    }
+    if (fields.length === 0) {
+        const plain = msgid.replace(/%%/g, '%');
+        return { msgid: plain, inner: (0, python_lexer_1.pythonStringLiteral)(plain), suffix: '', isF: true };
+    }
+    const dict = fields.map((f) => `${(0, python_lexer_1.pythonStringLiteral)(f.name)}: ${f.expr.replace(/\s*\n\s*/g, ' ')}`).join(', ');
+    return { msgid, inner: (0, python_lexer_1.pythonStringLiteral)(msgid), suffix: ` % {${dict}}`, isF: true };
+}
+function extractDjangoPython(src, options) {
+    const tokens = (0, python_lexer_1.tokenizePython)(src);
+    const lines = (0, python_lexer_1.logicalLines)(src, tokens);
+    const aliases = importAliases(tokens);
+    const isTemplateTags = /(^|[\\/])templatetags[\\/]/.test(options.filePath);
+    const findings = [];
+    const unwired = [];
+    const groups = [];
+    /** Function id → variable names passed as a user-facing message. */
+    const messageVars = new Map();
+    /** Token index → token position in the global array. */
+    const indexOf = new Map();
+    tokens.forEach((t, i) => indexOf.set(t, i));
+    const scope = [];
+    let nextScopeId = 1;
+    const ignoredLines = new Set();
+    for (const t of tokens)
+        if (t.type === 'comment' && /babelize[:-]\s*ignore/i.test(t.value))
+            ignoredLines.add(t.line);
+    for (const ln of lines) {
+        while (scope.length && scope[scope.length - 1].indent >= ln.indent)
+            scope.pop();
+        const toks = ln.tokens;
+        let headerKind = null;
+        let headerColon = -1;
+        const firstWord = toks[0].value === 'async' ? toks[1]?.value : toks[0].value;
+        if (firstWord === 'def' || firstWord === 'class') {
+            headerKind = firstWord;
+            let depth = 0;
+            for (let k = 0; k < toks.length; k++) {
+                const v = toks[k].value;
+                if (toks[k].type === 'op' && (v === '(' || v === '[' || v === '{'))
+                    depth++;
+                else if (toks[k].type === 'op' && (v === ')' || v === ']' || v === '}'))
+                    depth--;
+                else if (depth === 0 && v === ':' && toks[k].type === 'op') {
+                    headerColon = k;
+                    break;
+                }
+            }
+        }
+        const outerInFunction = scope.some((s) => s.kind === 'def');
+        const outerFunc = [...scope].reverse().find((s) => s.kind === 'def');
+        const outerClass = scope.length && scope[scope.length - 1].kind === 'class' ? scope[scope.length - 1] : undefined;
+        let headerFrame = null;
+        if (headerKind) {
+            let bases;
+            if (headerKind === 'class') {
+                const open = toks.findIndex((t) => t.value === '(');
+                if (open !== -1 && open < headerColon)
+                    bases = src.slice(toks[open].end, toks[headerColon - 1].start);
+            }
+            headerFrame = { kind: headerKind, indent: ln.indent, id: nextScopeId++, bases };
+        }
+        const comments = ln.comments
+            .map((c) => c.value.replace(/^#\s?/, '').trim())
+            .filter((c) => /^translators\b/i.test(c));
+        // Walk the statement's tokens with a bracket stack.
+        const frames = [];
+        let assignTarget;
+        let assignAt = -1;
+        let topElemIndex = 0;
+        let topElemCount = 1;
+        const stmtGroups = [];
+        for (let k = 0; k < toks.length; k++) {
+            const tok = toks[k];
+            const gi = indexOf.get(tok);
+            const top = frames[frames.length - 1];
+            if (tok.type === 'op' && (tok.value === '(' || tok.value === '[' || tok.value === '{')) {
+                const prev = toks[k - 1];
+                const callable = prev && (prev.type === 'string' || (prev.type === 'name' && !KEYWORDS.has(prev.value)) || prev.value === ')' || prev.value === ']');
+                const kind = tok.value === '('
+                    ? (callable ? 'call' : 'tuple')
+                    : tok.value === '['
+                        ? (callable ? 'subscript' : 'list')
+                        : 'set';
+                const callee = kind === 'call' && prev?.type === 'name' ? dottedNameBefore(tokens, indexOf.get(prev)) : undefined;
+                const frame = {
+                    open: tok.value, kind, callee, argIndex: 0, isDictValue: false, argStart: k + 1, args: new Map(),
+                    parent: top, ownerKw: top?.kw, ownerArgIndex: top?.argIndex, ownerIsDictValue: top?.isDictValue,
+                    ownerDictKey: top?.dictKey, ownerElemIndex: top ? top.argIndex : topElemIndex,
+                    assignTarget: !top && assignAt !== -1 ? assignTarget : undefined, startTok: k,
+                };
+                // An empty `()` call still counts its single argument slot.
+                frames.push(frame);
+                continue;
+            }
+            if (tok.type === 'op' && (tok.value === ')' || tok.value === ']' || tok.value === '}')) {
+                const closing = frames.pop();
+                if (closing?.kind === 'call') {
+                    const fn = resolveGettext(closing.callee, aliases);
+                    if (fn)
+                        emitWrapped(closing, fn, ln.comments);
+                }
+                continue;
+            }
+            if (tok.type === 'op' && tok.value === ',') {
+                if (top) {
+                    top.argIndex++;
+                    top.kw = undefined;
+                    top.isDictValue = false;
+                    top.dictKey = undefined;
+                    top.argStart = k + 1;
+                }
+                else if (assignAt !== -1) {
+                    topElemIndex++;
+                    topElemCount++;
+                }
+                continue;
+            }
+            if (tok.type === 'op' && tok.value === ':' && top && (top.kind === 'set' || top.kind === 'dict') && !top.isDictValue) {
+                top.kind = 'dict';
+                top.isDictValue = true;
+                const keyToks = toks.slice(top.argStart, k);
+                if (keyToks.length > 0 && keyToks.every((t) => t.type === 'string' && !t.str.f && !t.str.bytes)) {
+                    top.dictKey = keyToks.map((t) => (0, python_lexer_1.decodePythonString)(src.slice(t.str.bodyStart, t.str.bodyEnd), t.str.raw)).join('');
+                }
+                continue;
+            }
+            if (tok.type === 'op' && tok.value === '=') {
+                if (top?.kind === 'call' && k === top.argStart + 1 && toks[k - 1].type === 'name') {
+                    top.kw = toks[k - 1].value;
+                    top.argStart = k + 1;
+                }
+                else if (!top && assignAt === -1) {
+                    assignAt = k;
+                    // `x = …`, `self.x = …`, `x: int = …`
+                    let end = k - 1;
+                    const colon = toks.slice(0, k).findIndex((t) => t.value === ':');
+                    if (colon !== -1)
+                        end = colon - 1;
+                    const target = toks.slice(0, end + 1);
+                    if (target.length && target.every((t, idx) => (idx % 2 === 0 ? t.type === 'name' : t.value === '.'))) {
+                        assignTarget = target.map((t) => t.value).join('');
+                    }
+                    topElemIndex = 0;
+                    topElemCount = 1;
+                }
+                continue;
+            }
+            if (tok.type === 'string') {
+                // Implicit concatenation: consecutive string tokens form one value.
+                let last = k;
+                while (toks[last + 1]?.type === 'string')
+                    last++;
+                const inBody = headerKind && headerColon !== -1 && k > headerColon;
+                const inFunction = outerInFunction || (!!inBody && headerKind === 'def');
+                const funcId = inBody && headerKind === 'def' ? headerFrame.id : outerFunc?.id ?? null;
+                const group = {
+                    first: gi,
+                    last: indexOf.get(toks[last]),
+                    // Snapshot: frames keep mutating (argIndex, kw) as the walk goes on.
+                    frames: frames.map((fr) => ({ ...fr })),
+                    prev: toks[k - 1],
+                    next: toks[last + 1],
+                    nextNext: toks[last + 2],
+                    assignTarget: frames.length === 0 && assignAt !== -1 ? assignTarget : undefined,
+                    topElemIndex,
+                    topElemCount,
+                    statementKeyword: toks[0].type === 'name' ? toks[0].value : undefined,
+                    inFunction,
+                    funcId,
+                    classBases: !inFunction ? (inBody && headerKind === 'class' ? headerFrame.bases : outerClass?.bases) : undefined,
+                    inClass: !inFunction && ((!!inBody && headerKind === 'class') || !!outerClass),
+                    line: tok.line,
+                    comments,
+                };
+                // Whole-argument strings of a call are remembered for gettext extraction.
+                if (top?.kind === 'call' && top.argStart === k && (toks[last + 1]?.value === ',' || toks[last + 1]?.value === ')')) {
+                    const v = groupValue(src, tokens, gi, group.last);
+                    if (typeof v !== 'string' && !v.isF)
+                        top.args.set(top.kw ?? top.argIndex, { value: v.msgid, line: tok.line });
+                }
+                stmtGroups.push(group);
+                k = last;
+                continue;
+            }
+            if (tok.type === 'name' && top?.kind === 'call' && top.argStart === k && toks[k + 1]?.value !== '(' && toks[k + 1]?.value !== '=') {
+                // `raise ValidationError(msg)` / `messages.info(request, msg.format(…))`
+                const fnId = inFunctionId();
+                if (fnId !== null && isMessageArg(top)) {
+                    if (!messageVars.has(fnId))
+                        messageVars.set(fnId, new Set());
+                    messageVars.get(fnId).add(tok.value);
+                }
+            }
+        }
+        // Unclosed frames at the end of a line (shouldn't happen in valid code).
+        groups.push(...stmtGroups);
+        if (headerFrame)
+            scope.push(headerFrame);
+        function inFunctionId() {
+            if (headerKind === 'def' && headerColon !== -1)
+                return headerFrame.id;
+            return outerFunc?.id ?? null;
+        }
+    }
+    function emitWrapped(frame, fn, lineComments) {
+        const sig = SIGNATURES[fn];
+        const get = (pos, ...kws) => {
+            if (pos === undefined)
+                return undefined;
+            for (const kw of kws)
+                if (frame.args.has(kw))
+                    return frame.args.get(kw);
+            return frame.args.get(pos);
+        };
+        const singular = get(sig.singular, 'message', 'singular', 'msgid');
+        if (!singular)
+            return; // dynamic msgid (a variable): nothing to extract
+        const plural = sig.plural !== undefined ? get(sig.plural, 'plural') : undefined;
+        const ctx = sig.ctx !== undefined ? get(sig.ctx, 'context') : undefined;
+        if (sig.plural !== undefined && !plural)
+            return;
+        if (sig.ctx !== undefined && !ctx)
+            return;
+        const message = {
+            msgid: singular.value,
+            msgidPlural: plural?.value,
+            msgctxt: ctx?.value,
+            flags: (0, types_1.formatFlags)(singular.value, plural?.value),
+            comments: lineComments.map((c) => c.value.replace(/^#\s?/, '').trim()).filter((c) => /^translators\b/i.test(c)),
+        };
+        if (!message.msgid)
+            return;
+        findings.push({ message, line: singular.line, wrapped: true });
+    }
+    function isMessageArg(frame) {
+        const callee = frame.callee ?? '';
+        if (MESSAGE_FUNCS.test(callee))
+            return frame.argIndex === 1 && !frame.kw || frame.kw === 'message';
+        if (callee === 'messages.add_message')
+            return frame.argIndex === 2 && !frame.kw || frame.kw === 'message';
+        if (/(?:^|\.)message_user$/.test(callee))
+            return frame.argIndex === 1 && !frame.kw || frame.kw === 'message';
+        if (/ValidationError$/.test(callee))
+            return frame.argIndex === 0 && !frame.kw || frame.kw === 'message';
+        return false;
+    }
+    /** Is this the root of a choices definition? */
+    function isChoicesRoot(f) {
+        if (!f)
+            return false;
+        if (f.parent === undefined && f.assignTarget && /(?:^|\.)[A-Z0-9_]*CHOICES$/i.test(f.assignTarget))
+            return true;
+        if (f.parent?.kind === 'call' && f.ownerKw === 'choices')
+            return true;
+        return false;
+    }
+    /** Why (if at all) a hardcoded string group should be wrapped. */
+    function wrapReason(g, text) {
+        const f = g.frames[g.frames.length - 1];
+        if (f?.kind === 'call') {
+            if (f.kw && UI_KWARGS.has(f.kw))
+                return 'ui';
+            if (f.kw === 'description' && /(?:^|\.)(?:action|display)$/.test(f.callee ?? ''))
+                return 'ui';
+            if (f.kw === 'message' && /(?:Validator|ValidationError)$/.test(f.callee ?? ''))
+                return 'ui';
+            if (isMessageArg(f))
+                return 'ui';
+            return null;
+        }
+        if (f?.kind === 'dict' && f.isDictValue) {
+            if (f.parent?.kind === 'call' && f.ownerKw === 'error_messages')
+                return 'ui';
+            if (!f.parent && f.assignTarget && /(?:^|\.)(?:default_)?error_messages$/.test(f.assignTarget))
+                return 'ui';
+            if (f.parent?.kind === 'call' && f.ownerKw === 'attrs' && f.dictKey && UI_ATTR_KEYS.has(f.dictKey))
+                return 'ui';
+            if (isChoicesRoot(f))
+                return 'ui';
+            if (isTemplateTags && looksLikeNaturalLanguage(text) && g.frames.length === 1)
+                return 'natural';
+            return null;
+        }
+        if (f && (f.kind === 'tuple' || f.kind === 'list')) {
+            // ("value", "Label") inside a choices list/tuple — or an optgroup label.
+            const container = f.parent;
+            const isLabel = f.kind === 'tuple' && f.argIndex === 1;
+            const isGroupLabel = f.kind === 'tuple' && f.argIndex === 0 && g.next?.value === ',' && (g.nextNext?.value === '[' || g.nextNext?.value === '(');
+            if (isLabel || isGroupLabel) {
+                let c = container;
+                // Walk up through optgroup nesting: list > tuple(elem 1) > list …
+                while (c) {
+                    if (isChoicesRoot(c))
+                        return 'ui';
+                    if ((c.kind === 'list' || c.kind === 'tuple') && c.parent && (c.parent.kind === 'tuple' && c.ownerElemIndex === 1)) {
+                        c = c.parent.parent;
+                        continue;
+                    }
+                    break;
+                }
+            }
+            return null;
+        }
+        if (!f) {
+            // TextChoices members: NAME = "code", "Label"
+            if (g.classBases && /\b(?:TextChoices|IntegerChoices|Choices)\b/.test(g.classBases) && g.assignTarget &&
+                /^[A-Z][A-Z0-9_]*$/.test(g.assignTarget) && g.topElemIndex >= 1) {
+                return 'ui';
+            }
+            if (g.assignTarget && /(?:^|\.)short_description$/.test(g.assignTarget))
+                return 'ui';
+            // class Meta: verbose_name = "…" / AppConfig.verbose_name
+            if (g.inClass && g.assignTarget && /^verbose_name(?:_plural)?$/.test(g.assignTarget))
+                return 'ui';
+            if (isTemplateTags && g.inFunction && g.statementKeyword === 'return' && looksLikeNaturalLanguage(text))
+                return 'natural';
+            if (g.funcId !== null && g.assignTarget && messageVars.get(g.funcId)?.has(g.assignTarget) && looksLikeNaturalLanguage(text)) {
+                return 'natural';
+            }
+        }
+        return null;
+    }
+    const ALLOWED_PREV = new Set(['(', ',', '[', '{', '=', ':', 'return', 'else', 'yield']);
+    const ALLOWED_NEXT = new Set([')', ',', ']', '}', 'if', 'else', '%']);
+    for (const g of groups) {
+        if (ignoredLines.has(g.line))
+            continue;
+        // Strings inside a gettext call were handled as wrapped messages.
+        if (g.frames.some((f) => f.kind === 'call' && resolveGettext(f.callee, aliases)))
+            continue;
+        const value = groupValue(src, tokens, g.first, g.last);
+        const text = typeof value === 'string' ? src.slice(tokens[g.first].start, tokens[g.last].end) : value.msgid;
+        // Dict keys and the like are never text.
+        const f = g.frames[g.frames.length - 1];
+        if (f?.kind === 'dict' || f?.kind === 'set') {
+            if (!f.isDictValue || g.next?.value === ':')
+                continue;
+        }
+        if (g.next?.value === ':' && !(f && f.kind === 'subscript'))
+            continue;
+        if (f?.kind === 'subscript')
+            continue;
+        const reason = wrapReason(g, typeof value === 'string' ? '' : value.msgid);
+        if (!reason)
+            continue;
+        const prevOk = !g.prev || ALLOWED_PREV.has(g.prev.value);
+        const nextIsFormat = g.next?.value === '.' && g.nextNext?.value === 'format';
+        const nextOk = !g.next || ALLOWED_NEXT.has(g.next.value) || nextIsFormat;
+        if (typeof value === 'string') {
+            unwired.push({ line: g.line, text, reason: `not wrapped: ${value}` });
+            continue;
+        }
+        if (!/\p{L}/u.test(value.msgid) || !value.msgid.trim())
+            continue;
+        if (!prevOk || !nextOk) {
+            unwired.push({ line: g.line, text: value.msgid, reason: 'not wrapped: the string is part of a larger expression (concatenation or operator); wrap the whole sentence with gettext yourself' });
+            continue;
+        }
+        if (value.isF && (nextIsFormat || g.next?.value === '%')) {
+            unwired.push({ line: g.line, text: value.msgid, reason: 'not wrapped: f-string followed by further formatting' });
+            continue;
+        }
+        findings.push({
+            message: { msgid: value.msgid, flags: (0, types_1.formatFlags)(value.msgid), comments: g.comments },
+            line: g.line,
+            wrapped: false,
+            edit: {
+                kind: 'python',
+                start: tokens[g.first].start,
+                end: tokens[g.last].end,
+                lazy: !g.inFunction,
+                inner: value.inner,
+                suffix: value.suffix,
+            },
+        });
+    }
+    findings.sort((a, b) => a.line - b.line);
+    return { findings, unwired };
+}