Function postProcessDiscriminatorDefaultsForPython

scripts/codegen/python.ts:498–648

* For each discriminated-union variant class, replace the dataclass-level * discriminator field (e.g. ``kind: PermissionDecisionApproveOnceKind``) with * a class-level constant (e.g. ``kind: ClassVar[str] = "approve-once"``). * This lets users construct variants without supplying the discriminato

(
    code: string,
    unions: ResolvedRefBasedUnion[]
)

 * and ``to_dict`` to emit the constant directly.
 */
function postProcessDiscriminatorDefaultsForPython(
    code: string,
    unions: ResolvedRefBasedUnion[]
): string {
    // Build variant lookup: variant class name → { prop, value }.
    const variantInfo = new Map<string, { prop: string; value: string }>();
    for (const union of unions) {
        for (const d of union.dispatch) {
            // First-wins; multiple unions referencing the same variant share a
            // discriminator/value pair anyway.
            if (!variantInfo.has(d.typeName)) {
                variantInfo.set(d.typeName, { prop: union.discriminatorProp, value: d.value });
            }
        }
    }
    if (variantInfo.size === 0) return code;

    const lines = code.split("\n");
    const out: string[] = [];
    let usedClassVar = false;

    let i = 0;
    while (i < lines.length) {
        const line = lines[i];
        const classMatch = line.match(/^class (\w+)[:\(]/);
        if (!classMatch) {
            out.push(line);
            i++;
            continue;
        }
        const className = classMatch[1];
        const info = variantInfo.get(className);
        if (!info) {
            out.push(line);
            i++;
            continue;
        }

        // Find the bounds of this class block: everything indented under it.
        const classStart = i;
        let classEnd = i + 1;
        while (classEnd < lines.length) {
            const ln = lines[classEnd];
            if (
                /^class \w/.test(ln) ||
                /^def \w/.test(ln) ||
                ln === "@dataclass" ||
                /^# (?:Experimental|Deprecated|Internal):/.test(ln) ||
                ln.startsWith("@dataclass(")
            ) {
                break;
            }
            classEnd++;
        }
        const block = lines.slice(classStart, classEnd);

        // Locate the discriminator field declaration. Quicktype emits
        // `    kind: PermissionDecisionApproveOnceKind` while the