Python

0) _compound_statement¶

NodeTypeWithSubtypes(
    type="_compound_statement",
    named=True,
    subtypes=[
        NodeType(named=True, type="class_definition"),
        NodeType(named=True, type="decorated_definition"),
        NodeType(named=True, type="for_statement"),
        NodeType(named=True, type="function_definition"),
        NodeType(named=True, type="if_statement"),
        NodeType(named=True, type="match_statement"),
        NodeType(named=True, type="try_statement"),
        NodeType(named=True, type="while_statement"),
        NodeType(named=True, type="with_statement"),
    ],
)

1) _simple_statement¶

NodeTypeWithSubtypes(
    type="_simple_statement",
    named=True,
    subtypes=[
        NodeType(named=True, type="assert_statement"),
        NodeType(named=True, type="break_statement"),
        NodeType(named=True, type="continue_statement"),
        NodeType(named=True, type="delete_statement"),
        NodeType(named=True, type="exec_statement"),
        NodeType(named=True, type="expression_statement"),
        NodeType(named=True, type="future_import_statement"),
        NodeType(named=True, type="global_statement"),
        NodeType(named=True, type="import_from_statement"),
        NodeType(named=True, type="import_statement"),
        NodeType(named=True, type="nonlocal_statement"),
        NodeType(named=True, type="pass_statement"),
        NodeType(named=True, type="print_statement"),
        NodeType(named=True, type="raise_statement"),
        NodeType(named=True, type="return_statement"),
        NodeType(named=True, type="type_alias_statement"),
    ],
)

2) expression¶

NodeTypeWithSubtypes(
    type="expression",
    named=True,
    subtypes=[
        NodeType(named=True, type="as_pattern"),
        NodeType(named=True, type="boolean_operator"),
        NodeType(named=True, type="comparison_operator"),
        NodeType(named=True, type="conditional_expression"),
        NodeType(named=True, type="lambda"),
        NodeType(named=True, type="named_expression"),
        NodeType(named=True, type="not_operator"),
        NodeType(named=True, type="primary_expression"),
    ],
)

3) parameter¶

NodeTypeWithSubtypes(
    type="parameter",
    named=True,
    subtypes=[
        NodeType(named=True, type="default_parameter"),
        NodeType(named=True, type="dictionary_splat_pattern"),
        NodeType(named=True, type="identifier"),
        NodeType(named=True, type="keyword_separator"),
        NodeType(named=True, type="list_splat_pattern"),
        NodeType(named=True, type="positional_separator"),
        NodeType(named=True, type="tuple_pattern"),
        NodeType(named=True, type="typed_default_parameter"),
        NodeType(named=True, type="typed_parameter"),
    ],
)

4) pattern¶

NodeTypeWithSubtypes(
    type="pattern",
    named=True,
    subtypes=[
        NodeType(named=True, type="attribute"),
        NodeType(named=True, type="identifier"),
        NodeType(named=True, type="list_pattern"),
        NodeType(named=True, type="list_splat_pattern"),
        NodeType(named=True, type="subscript"),
        NodeType(named=True, type="tuple_pattern"),
    ],
)

5) primary_expression¶

NodeTypeWithSubtypes(
    type="primary_expression",
    named=True,
    subtypes=[
        NodeType(named=True, type="attribute"),
        NodeType(named=True, type="await"),
        NodeType(named=True, type="binary_operator"),
        NodeType(named=True, type="call"),
        NodeType(named=True, type="concatenated_string"),
        NodeType(named=True, type="dictionary"),
        NodeType(named=True, type="dictionary_comprehension"),
        NodeType(named=True, type="ellipsis"),
        NodeType(named=True, type="false"),
        NodeType(named=True, type="float"),
        NodeType(named=True, type="generator_expression"),
        NodeType(named=True, type="identifier"),
        NodeType(named=True, type="integer"),
        NodeType(named=True, type="list"),
        NodeType(named=True, type="list_comprehension"),
        NodeType(named=True, type="list_splat"),
        NodeType(named=True, type="none"),
        NodeType(named=True, type="parenthesized_expression"),
        NodeType(named=True, type="set"),
        NodeType(named=True, type="set_comprehension"),
        NodeType(named=True, type="string"),
        NodeType(named=True, type="subscript"),
        NodeType(named=True, type="true"),
        NodeType(named=True, type="tuple"),
        NodeType(named=True, type="unary_operator"),
    ],
)

6) aliased_import¶

NodeTypeWithFields(
    type="aliased_import",
    named=True,
    fields={
        "alias": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="dotted_name")],
        ),
    },
)

7) argument_list¶

NodeTypeWithFieldsAndChildren(
    type="argument_list",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="dictionary_splat"),
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="keyword_argument"),
            NodeType(named=True, type="list_splat"),
            NodeType(named=True, type="parenthesized_expression"),
        ],
    ),
)

8) as_pattern¶

NodeTypeWithFieldsAndChildren(
    type="as_pattern",
    named=True,
    fields={
        "alias": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="as_pattern_target")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="case_pattern"),
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="identifier"),
        ],
    ),
)

9) assert_statement¶

NodeTypeWithFieldsAndChildren(
    type="assert_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

10) assignment¶

NodeTypeWithFields(
    type="assignment",
    named=True,
    fields={
        "left": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="pattern"),
                NodeType(named=True, type="pattern_list"),
            ],
        ),
        "right": NodeSchema(
            multiple=False,
            required=False,
            types=[
                NodeType(named=True, type="assignment"),
                NodeType(named=True, type="augmented_assignment"),
                NodeType(named=True, type="expression"),
                NodeType(named=True, type="expression_list"),
                NodeType(named=True, type="pattern_list"),
                NodeType(named=True, type="yield"),
            ],
        ),
        "type": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="type")],
        ),
    },
)

11) attribute¶

NodeTypeWithFields(
    type="attribute",
    named=True,
    fields={
        "attribute": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "object": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="primary_expression")],
        ),
    },
)

12) augmented_assignment¶

NodeTypeWithFields(
    type="augmented_assignment",
    named=True,
    fields={
        "left": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="pattern"),
                NodeType(named=True, type="pattern_list"),
            ],
        ),
        "operator": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=False, type="%="),
                NodeType(named=False, type="&="),
                NodeType(named=False, type="**="),
                NodeType(named=False, type="*="),
                NodeType(named=False, type="+="),
                NodeType(named=False, type="-="),
                NodeType(named=False, type="//="),
                NodeType(named=False, type="/="),
                NodeType(named=False, type="<<="),
                NodeType(named=False, type=">>="),
                NodeType(named=False, type="@="),
                NodeType(named=False, type="^="),
                NodeType(named=False, type="|="),
            ],
        ),
        "right": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="assignment"),
                NodeType(named=True, type="augmented_assignment"),
                NodeType(named=True, type="expression"),
                NodeType(named=True, type="expression_list"),
                NodeType(named=True, type="pattern_list"),
                NodeType(named=True, type="yield"),
            ],
        ),
    },
)

13) await¶

NodeTypeWithFieldsAndChildren(
    type="await",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="primary_expression")],
    ),
)

14) binary_operator¶

NodeTypeWithFields(
    type="binary_operator",
    named=True,
    fields={
        "left": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="primary_expression")],
        ),
        "operator": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=False, type="%"),
                NodeType(named=False, type="&"),
                NodeType(named=False, type="*"),
                NodeType(named=False, type="**"),
                NodeType(named=False, type="+"),
                NodeType(named=False, type="-"),
                NodeType(named=False, type="/"),
                NodeType(named=False, type="//"),
                NodeType(named=False, type="<<"),
                NodeType(named=False, type=">>"),
                NodeType(named=False, type="@"),
                NodeType(named=False, type="^"),
                NodeType(named=False, type="|"),
            ],
        ),
        "right": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="primary_expression")],
        ),
    },
)

15) block¶

NodeTypeWithFieldsAndChildren(
    type="block",
    named=True,
    fields={
        "alternative": NodeSchema(
            multiple=True,
            required=False,
            types=[NodeType(named=True, type="case_clause")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="_compound_statement"),
            NodeType(named=True, type="_simple_statement"),
        ],
    ),
)

16) boolean_operator¶

NodeTypeWithFields(
    type="boolean_operator",
    named=True,
    fields={
        "left": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
        "operator": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=False, type="and"),
                NodeType(named=False, type="or"),
            ],
        ),
        "right": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

17) break_statement¶

NodeTypeWithFields(type="break_statement", named=True, fields={})

18) call¶

NodeTypeWithFields(
    type="call",
    named=True,
    fields={
        "arguments": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="argument_list"),
                NodeType(named=True, type="generator_expression"),
            ],
        ),
        "function": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="primary_expression")],
        ),
    },
)

19) case_clause¶

NodeTypeWithFieldsAndChildren(
    type="case_clause",
    named=True,
    fields={
        "consequence": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
        "guard": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="if_clause")],
        ),
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="case_pattern")],
    ),
)

20) case_pattern¶

NodeTypeWithFieldsAndChildren(
    type="case_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[
            NodeType(named=True, type="as_pattern"),
            NodeType(named=True, type="class_pattern"),
            NodeType(named=True, type="complex_pattern"),
            NodeType(named=True, type="concatenated_string"),
            NodeType(named=True, type="dict_pattern"),
            NodeType(named=True, type="dotted_name"),
            NodeType(named=True, type="false"),
            NodeType(named=True, type="float"),
            NodeType(named=True, type="integer"),
            NodeType(named=True, type="keyword_pattern"),
            NodeType(named=True, type="list_pattern"),
            NodeType(named=True, type="none"),
            NodeType(named=True, type="splat_pattern"),
            NodeType(named=True, type="string"),
            NodeType(named=True, type="true"),
            NodeType(named=True, type="tuple_pattern"),
            NodeType(named=True, type="union_pattern"),
        ],
    ),
)

21) chevron¶

NodeTypeWithFieldsAndChildren(
    type="chevron",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

22) class_definition¶

NodeTypeWithFields(
    type="class_definition",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "superclasses": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="argument_list")],
        ),
        "type_parameters": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="type_parameter")],
        ),
    },
)

23) class_pattern¶

NodeTypeWithFieldsAndChildren(
    type="class_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="case_pattern"),
            NodeType(named=True, type="dotted_name"),
        ],
    ),
)

24) comparison_operator¶

NodeTypeWithFieldsAndChildren(
    type="comparison_operator",
    named=True,
    fields={
        "operators": NodeSchema(
            multiple=True,
            required=True,
            types=[
                NodeType(named=False, type="!="),
                NodeType(named=False, type="<"),
                NodeType(named=False, type="<="),
                NodeType(named=False, type="<>"),
                NodeType(named=False, type="=="),
                NodeType(named=False, type=">"),
                NodeType(named=False, type=">="),
                NodeType(named=False, type="in"),
                NodeType(named=False, type="is"),
                NodeType(named=False, type="is not"),
                NodeType(named=False, type="not in"),
            ],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="primary_expression")],
    ),
)

25) complex_pattern¶

NodeTypeWithFieldsAndChildren(
    type="complex_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="float"),
            NodeType(named=True, type="integer"),
        ],
    ),
)

26) concatenated_string¶

NodeTypeWithFieldsAndChildren(
    type="concatenated_string",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="string")],
    ),
)

27) conditional_expression¶

NodeTypeWithFieldsAndChildren(
    type="conditional_expression",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

28) constrained_type¶

NodeTypeWithFieldsAndChildren(
    type="constrained_type",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="type")],
    ),
)

29) continue_statement¶

NodeTypeWithFields(type="continue_statement", named=True, fields={})

30) decorated_definition¶

NodeTypeWithFieldsAndChildren(
    type="decorated_definition",
    named=True,
    fields={
        "definition": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="class_definition"),
                NodeType(named=True, type="function_definition"),
            ],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="decorator")],
    ),
)

31) decorator¶

NodeTypeWithFieldsAndChildren(
    type="decorator",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

32) default_parameter¶

NodeTypeWithFields(
    type="default_parameter",
    named=True,
    fields={
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="identifier"),
                NodeType(named=True, type="tuple_pattern"),
            ],
        ),
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

33) delete_statement¶

NodeTypeWithFieldsAndChildren(
    type="delete_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="expression_list"),
        ],
    ),
)

34) dict_pattern¶

NodeTypeWithFieldsAndChildren(
    type="dict_pattern",
    named=True,
    fields={
        "key": NodeSchema(
            multiple=True,
            required=False,
            types=[
                NodeType(named=False, type="-"),
                NodeType(named=False, type="_"),
                NodeType(named=True, type="class_pattern"),
                NodeType(named=True, type="complex_pattern"),
                NodeType(named=True, type="concatenated_string"),
                NodeType(named=True, type="dict_pattern"),
                NodeType(named=True, type="dotted_name"),
                NodeType(named=True, type="false"),
                NodeType(named=True, type="float"),
                NodeType(named=True, type="integer"),
                NodeType(named=True, type="list_pattern"),
                NodeType(named=True, type="none"),
                NodeType(named=True, type="splat_pattern"),
                NodeType(named=True, type="string"),
                NodeType(named=True, type="true"),
                NodeType(named=True, type="tuple_pattern"),
                NodeType(named=True, type="union_pattern"),
            ],
        ),
        "value": NodeSchema(
            multiple=True,
            required=False,
            types=[NodeType(named=True, type="case_pattern")],
        ),
    },
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[NodeType(named=True, type="splat_pattern")],
    ),
)

35) dictionary¶

NodeTypeWithFieldsAndChildren(
    type="dictionary",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="dictionary_splat"),
            NodeType(named=True, type="pair"),
        ],
    ),
)

36) dictionary_comprehension¶

NodeTypeWithFieldsAndChildren(
    type="dictionary_comprehension",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="pair")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="for_in_clause"),
            NodeType(named=True, type="if_clause"),
        ],
    ),
)

37) dictionary_splat¶

NodeTypeWithFieldsAndChildren(
    type="dictionary_splat",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

38) dictionary_splat_pattern¶

NodeTypeWithFieldsAndChildren(
    type="dictionary_splat_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="attribute"),
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="subscript"),
        ],
    ),
)

39) dotted_name¶

NodeTypeWithFieldsAndChildren(
    type="dotted_name",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="identifier")],
    ),
)

40) elif_clause¶

NodeTypeWithFields(
    type="elif_clause",
    named=True,
    fields={
        "condition": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
        "consequence": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
    },
)

41) else_clause¶

NodeTypeWithFields(
    type="else_clause",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        )
    },
)

42) except_clause¶

NodeTypeWithFieldsAndChildren(
    type="except_clause",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="block"),
            NodeType(named=True, type="expression"),
        ],
    ),
)

43) except_group_clause¶

NodeTypeWithFieldsAndChildren(
    type="except_group_clause",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="block"),
            NodeType(named=True, type="expression"),
        ],
    ),
)

44) exec_statement¶

NodeTypeWithFieldsAndChildren(
    type="exec_statement",
    named=True,
    fields={
        "code": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="identifier"),
                NodeType(named=True, type="string"),
            ],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[NodeType(named=True, type="expression")],
    ),
)

45) expression_list¶

NodeTypeWithFieldsAndChildren(
    type="expression_list",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

46) expression_statement¶

NodeTypeWithFieldsAndChildren(
    type="expression_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="assignment"),
            NodeType(named=True, type="augmented_assignment"),
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="yield"),
        ],
    ),
)

47) finally_clause¶

NodeTypeWithFieldsAndChildren(
    type="finally_clause",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="block")],
    ),
)

48) for_in_clause¶

NodeTypeWithFields(
    type="for_in_clause",
    named=True,
    fields={
        "left": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="pattern"),
                NodeType(named=True, type="pattern_list"),
            ],
        ),
        "right": NodeSchema(
            multiple=True,
            required=True,
            types=[
                NodeType(named=False, type=","),
                NodeType(named=True, type="expression"),
            ],
        ),
    },
)

49) for_statement¶

NodeTypeWithFields(
    type="for_statement",
    named=True,
    fields={
        "alternative": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="else_clause")],
        ),
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
        "left": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="pattern"),
                NodeType(named=True, type="pattern_list"),
            ],
        ),
        "right": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="expression"),
                NodeType(named=True, type="expression_list"),
            ],
        ),
    },
)

50) format_expression¶

NodeTypeWithFields(
    type="format_expression",
    named=True,
    fields={
        "expression": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="expression"),
                NodeType(named=True, type="expression_list"),
                NodeType(named=True, type="pattern_list"),
                NodeType(named=True, type="yield"),
            ],
        ),
        "format_specifier": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="format_specifier")],
        ),
        "type_conversion": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="type_conversion")],
        ),
    },
)

51) format_specifier¶

NodeTypeWithFieldsAndChildren(
    type="format_specifier",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[NodeType(named=True, type="format_expression")],
    ),
)

52) function_definition¶

NodeTypeWithFields(
    type="function_definition",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "parameters": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="parameters")],
        ),
        "return_type": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="type")],
        ),
        "type_parameters": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="type_parameter")],
        ),
    },
)

53) future_import_statement¶

NodeTypeWithFields(
    type="future_import_statement",
    named=True,
    fields={
        "name": NodeSchema(
            multiple=True,
            required=True,
            types=[
                NodeType(named=True, type="aliased_import"),
                NodeType(named=True, type="dotted_name"),
            ],
        )
    },
)

54) generator_expression¶

NodeTypeWithFieldsAndChildren(
    type="generator_expression",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="for_in_clause"),
            NodeType(named=True, type="if_clause"),
        ],
    ),
)

55) generic_type¶

NodeTypeWithFieldsAndChildren(
    type="generic_type",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="type_parameter"),
        ],
    ),
)

56) global_statement¶

NodeTypeWithFieldsAndChildren(
    type="global_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="identifier")],
    ),
)

57) if_clause¶

NodeTypeWithFieldsAndChildren(
    type="if_clause",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="expression")],
    ),
)

58) if_statement¶

NodeTypeWithFields(
    type="if_statement",
    named=True,
    fields={
        "alternative": NodeSchema(
            multiple=True,
            required=False,
            types=[
                NodeType(named=True, type="elif_clause"),
                NodeType(named=True, type="else_clause"),
            ],
        ),
        "condition": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
        "consequence": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
    },
)

59) import_from_statement¶

NodeTypeWithFieldsAndChildren(
    type="import_from_statement",
    named=True,
    fields={
        "module_name": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="dotted_name"),
                NodeType(named=True, type="relative_import"),
            ],
        ),
        "name": NodeSchema(
            multiple=True,
            required=False,
            types=[
                NodeType(named=True, type="aliased_import"),
                NodeType(named=True, type="dotted_name"),
            ],
        ),
    },
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[NodeType(named=True, type="wildcard_import")],
    ),
)

60) import_prefix¶

NodeTypeWithFields(type="import_prefix", named=True, fields={})

61) import_statement¶

NodeTypeWithFields(
    type="import_statement",
    named=True,
    fields={
        "name": NodeSchema(
            multiple=True,
            required=True,
            types=[
                NodeType(named=True, type="aliased_import"),
                NodeType(named=True, type="dotted_name"),
            ],
        )
    },
)

62) interpolation¶

NodeTypeWithFields(
    type="interpolation",
    named=True,
    fields={
        "expression": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=True, type="expression"),
                NodeType(named=True, type="expression_list"),
                NodeType(named=True, type="pattern_list"),
                NodeType(named=True, type="yield"),
            ],
        ),
        "format_specifier": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="format_specifier")],
        ),
        "type_conversion": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="type_conversion")],
        ),
    },
)

63) keyword_argument¶

NodeTypeWithFields(
    type="keyword_argument",
    named=True,
    fields={
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

64) keyword_pattern¶

NodeTypeWithFieldsAndChildren(
    type="keyword_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="class_pattern"),
            NodeType(named=True, type="complex_pattern"),
            NodeType(named=True, type="concatenated_string"),
            NodeType(named=True, type="dict_pattern"),
            NodeType(named=True, type="dotted_name"),
            NodeType(named=True, type="false"),
            NodeType(named=True, type="float"),
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="integer"),
            NodeType(named=True, type="list_pattern"),
            NodeType(named=True, type="none"),
            NodeType(named=True, type="splat_pattern"),
            NodeType(named=True, type="string"),
            NodeType(named=True, type="true"),
            NodeType(named=True, type="tuple_pattern"),
            NodeType(named=True, type="union_pattern"),
        ],
    ),
)

65) keyword_separator¶

NodeTypeWithFields(type="keyword_separator", named=True, fields={})

66) lambda¶

NodeTypeWithFields(
    type="lambda",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
        "parameters": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="lambda_parameters")],
        ),
    },
)

67) lambda_parameters¶

NodeTypeWithFieldsAndChildren(
    type="lambda_parameters",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="parameter")],
    ),
)

68) list¶

NodeTypeWithFieldsAndChildren(
    type="list",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="list_splat"),
            NodeType(named=True, type="parenthesized_list_splat"),
            NodeType(named=True, type="yield"),
        ],
    ),
)

69) list_comprehension¶

NodeTypeWithFieldsAndChildren(
    type="list_comprehension",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="for_in_clause"),
            NodeType(named=True, type="if_clause"),
        ],
    ),
)

70) list_pattern¶

NodeTypeWithFieldsAndChildren(
    type="list_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="case_pattern"),
            NodeType(named=True, type="pattern"),
        ],
    ),
)

71) list_splat¶

NodeTypeWithFieldsAndChildren(
    type="list_splat",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="attribute"),
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="subscript"),
        ],
    ),
)

72) list_splat_pattern¶

NodeTypeWithFieldsAndChildren(
    type="list_splat_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="attribute"),
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="subscript"),
        ],
    ),
)

73) match_statement¶

NodeTypeWithFields(
    type="match_statement",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
        "subject": NodeSchema(
            multiple=True,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

74) member_type¶

NodeTypeWithFieldsAndChildren(
    type="member_type",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="type"),
        ],
    ),
)

75) module¶

NodeTypeWithFieldsAndChildren(
    type="module",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="_compound_statement"),
            NodeType(named=True, type="_simple_statement"),
        ],
    ),
)

76) named_expression¶

NodeTypeWithFields(
    type="named_expression",
    named=True,
    fields={
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

77) nonlocal_statement¶

NodeTypeWithFieldsAndChildren(
    type="nonlocal_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="identifier")],
    ),
)

78) not_operator¶

NodeTypeWithFields(
    type="not_operator",
    named=True,
    fields={
        "argument": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        )
    },
)

79) pair¶

NodeTypeWithFields(
    type="pair",
    named=True,
    fields={
        "key": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

80) parameters¶

NodeTypeWithFieldsAndChildren(
    type="parameters",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[NodeType(named=True, type="parameter")],
    ),
)

81) parenthesized_expression¶

NodeTypeWithFieldsAndChildren(
    type="parenthesized_expression",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="list_splat"),
            NodeType(named=True, type="parenthesized_expression"),
            NodeType(named=True, type="yield"),
        ],
    ),
)

82) parenthesized_list_splat¶

NodeTypeWithFieldsAndChildren(
    type="parenthesized_list_splat",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="list_splat"),
            NodeType(named=True, type="parenthesized_expression"),
        ],
    ),
)

83) pass_statement¶

NodeTypeWithFields(type="pass_statement", named=True, fields={})

84) pattern_list¶

NodeTypeWithFieldsAndChildren(
    type="pattern_list",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="pattern")],
    ),
)

85) positional_separator¶

NodeTypeWithFields(type="positional_separator", named=True, fields={})

86) print_statement¶

NodeTypeWithFieldsAndChildren(
    type="print_statement",
    named=True,
    fields={
        "argument": NodeSchema(
            multiple=True,
            required=False,
            types=[NodeType(named=True, type="expression")],
        )
    },
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[NodeType(named=True, type="chevron")],
    ),
)

87) raise_statement¶

NodeTypeWithFieldsAndChildren(
    type="raise_statement",
    named=True,
    fields={
        "cause": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="expression")],
        )
    },
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="expression_list"),
        ],
    ),
)

88) relative_import¶

NodeTypeWithFieldsAndChildren(
    type="relative_import",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="dotted_name"),
            NodeType(named=True, type="import_prefix"),
        ],
    ),
)

89) return_statement¶

NodeTypeWithFieldsAndChildren(
    type="return_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="expression_list"),
        ],
    ),
)

90) set¶

NodeTypeWithFieldsAndChildren(
    type="set",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="list_splat"),
            NodeType(named=True, type="parenthesized_list_splat"),
            NodeType(named=True, type="yield"),
        ],
    ),
)

91) set_comprehension¶

NodeTypeWithFieldsAndChildren(
    type="set_comprehension",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="for_in_clause"),
            NodeType(named=True, type="if_clause"),
        ],
    ),
)

92) slice¶

NodeTypeWithFieldsAndChildren(
    type="slice",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[NodeType(named=True, type="expression")],
    ),
)

93) splat_pattern¶

NodeTypeWithFieldsAndChildren(
    type="splat_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[NodeType(named=True, type="identifier")],
    ),
)

94) splat_type¶

NodeTypeWithFieldsAndChildren(
    type="splat_type",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="identifier")],
    ),
)

95) string¶

NodeTypeWithFieldsAndChildren(
    type="string",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="interpolation"),
            NodeType(named=True, type="string_content"),
            NodeType(named=True, type="string_end"),
            NodeType(named=True, type="string_start"),
        ],
    ),
)

96) string_content¶

NodeTypeWithFieldsAndChildren(
    type="string_content",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="escape_interpolation"),
            NodeType(named=True, type="escape_sequence"),
        ],
    ),
)

97) subscript¶

NodeTypeWithFields(
    type="subscript",
    named=True,
    fields={
        "subscript": NodeSchema(
            multiple=True,
            required=True,
            types=[
                NodeType(named=True, type="expression"),
                NodeType(named=True, type="slice"),
            ],
        ),
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="primary_expression")],
        ),
    },
)

98) try_statement¶

NodeTypeWithFieldsAndChildren(
    type="try_statement",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        )
    },
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[
            NodeType(named=True, type="else_clause"),
            NodeType(named=True, type="except_clause"),
            NodeType(named=True, type="except_group_clause"),
            NodeType(named=True, type="finally_clause"),
        ],
    ),
)

99) tuple¶

NodeTypeWithFieldsAndChildren(
    type="tuple",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="list_splat"),
            NodeType(named=True, type="parenthesized_list_splat"),
            NodeType(named=True, type="yield"),
        ],
    ),
)

100) tuple_pattern¶

NodeTypeWithFieldsAndChildren(
    type="tuple_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="case_pattern"),
            NodeType(named=True, type="pattern"),
        ],
    ),
)

101) type¶

NodeTypeWithFieldsAndChildren(
    type="type",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="constrained_type"),
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="generic_type"),
            NodeType(named=True, type="member_type"),
            NodeType(named=True, type="splat_type"),
            NodeType(named=True, type="union_type"),
        ],
    ),
)

102) type_alias_statement¶

NodeTypeWithFieldsAndChildren(
    type="type_alias_statement",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="type")],
    ),
)

103) type_parameter¶

NodeTypeWithFieldsAndChildren(
    type="type_parameter",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="type")],
    ),
)

104) typed_default_parameter¶

NodeTypeWithFields(
    type="typed_default_parameter",
    named=True,
    fields={
        "name": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="identifier")],
        ),
        "type": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="type")],
        ),
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

105) typed_parameter¶

NodeTypeWithFieldsAndChildren(
    type="typed_parameter",
    named=True,
    fields={
        "type": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="type")],
        )
    },
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[
            NodeType(named=True, type="dictionary_splat_pattern"),
            NodeType(named=True, type="identifier"),
            NodeType(named=True, type="list_splat_pattern"),
        ],
    ),
)

106) unary_operator¶

NodeTypeWithFields(
    type="unary_operator",
    named=True,
    fields={
        "argument": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="primary_expression")],
        ),
        "operator": NodeSchema(
            multiple=False,
            required=True,
            types=[
                NodeType(named=False, type="+"),
                NodeType(named=False, type="-"),
                NodeType(named=False, type="~"),
            ],
        ),
    },
)

107) union_pattern¶

NodeTypeWithFieldsAndChildren(
    type="union_pattern",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=False,
        types=[
            NodeType(named=True, type="class_pattern"),
            NodeType(named=True, type="complex_pattern"),
            NodeType(named=True, type="concatenated_string"),
            NodeType(named=True, type="dict_pattern"),
            NodeType(named=True, type="dotted_name"),
            NodeType(named=True, type="false"),
            NodeType(named=True, type="float"),
            NodeType(named=True, type="integer"),
            NodeType(named=True, type="list_pattern"),
            NodeType(named=True, type="none"),
            NodeType(named=True, type="splat_pattern"),
            NodeType(named=True, type="string"),
            NodeType(named=True, type="true"),
            NodeType(named=True, type="tuple_pattern"),
            NodeType(named=True, type="union_pattern"),
        ],
    ),
)

108) union_type¶

NodeTypeWithFieldsAndChildren(
    type="union_type",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="type")],
    ),
)

109) while_statement¶

NodeTypeWithFields(
    type="while_statement",
    named=True,
    fields={
        "alternative": NodeSchema(
            multiple=False,
            required=False,
            types=[NodeType(named=True, type="else_clause")],
        ),
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        ),
        "condition": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        ),
    },
)

110) wildcard_import¶

NodeTypeWithFields(type="wildcard_import", named=True, fields={})

111) with_clause¶

NodeTypeWithFieldsAndChildren(
    type="with_clause",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=True,
        required=True,
        types=[NodeType(named=True, type="with_item")],
    ),
)

112) with_item¶

NodeTypeWithFields(
    type="with_item",
    named=True,
    fields={
        "value": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="expression")],
        )
    },
)

113) with_statement¶

NodeTypeWithFieldsAndChildren(
    type="with_statement",
    named=True,
    fields={
        "body": NodeSchema(
            multiple=False,
            required=True,
            types=[NodeType(named=True, type="block")],
        )
    },
    children=NodeSchema(
        multiple=False,
        required=True,
        types=[NodeType(named=True, type="with_clause")],
    ),
)

114) yield¶

NodeTypeWithFieldsAndChildren(
    type="yield",
    named=True,
    fields={},
    children=NodeSchema(
        multiple=False,
        required=False,
        types=[
            NodeType(named=True, type="expression"),
            NodeType(named=True, type="expression_list"),
        ],
    ),
)

115) !=¶

NodeTypeNamed(type="!=", named=False)

116) %¶

NodeTypeNamed(type="%", named=False)

117) %=¶

NodeTypeNamed(type="%=", named=False)

118) &¶

NodeTypeNamed(type="&", named=False)

119) &=¶

NodeTypeNamed(type="&=", named=False)

120) (¶

NodeTypeNamed(type="(", named=False)

121) )¶

NodeTypeNamed(type=")", named=False)

122) *¶

NodeTypeNamed(type="*", named=False)

123) **¶

NodeTypeNamed(type="**", named=False)

124) **=¶

NodeTypeNamed(type="**=", named=False)

125) *=¶

NodeTypeNamed(type="*=", named=False)

126) +¶

NodeTypeNamed(type="+", named=False)

127) +=¶

NodeTypeNamed(type="+=", named=False)

128) ,¶

NodeTypeNamed(type=",", named=False)

129) -¶

NodeTypeNamed(type="-", named=False)

130) -=¶

NodeTypeNamed(type="-=", named=False)

131) ->¶

NodeTypeNamed(type="->", named=False)

132) .¶

NodeTypeNamed(type=".", named=False)

133) /¶

NodeTypeNamed(type="/", named=False)

134) //¶

NodeTypeNamed(type="//", named=False)

135) //=¶

NodeTypeNamed(type="//=", named=False)

136) /=¶

NodeTypeNamed(type="/=", named=False)

137) :¶

NodeTypeNamed(type=":", named=False)

138) :=¶

NodeTypeNamed(type=":=", named=False)

139) ;¶

NodeTypeNamed(type=";", named=False)

140) <¶

NodeTypeNamed(type="<", named=False)

141) <<¶

NodeTypeNamed(type="<<", named=False)

142) <<=¶

NodeTypeNamed(type="<<=", named=False)

143) <=¶

NodeTypeNamed(type="<=", named=False)

144) <>¶

NodeTypeNamed(type="<>", named=False)

145) =¶

NodeTypeNamed(type="=", named=False)

146) ==¶

NodeTypeNamed(type="==", named=False)

147) >¶

NodeTypeNamed(type=">", named=False)

148) >=¶

NodeTypeNamed(type=">=", named=False)

149) >>¶

NodeTypeNamed(type=">>", named=False)

150) >>=¶

NodeTypeNamed(type=">>=", named=False)

151) @¶

NodeTypeNamed(type="@", named=False)

152) @=¶

NodeTypeNamed(type="@=", named=False)

153) [¶

NodeTypeNamed(type="[", named=False)

## 154) \

NodeTypeNamed(type="\\", named=False)

155) ]¶

NodeTypeNamed(type="]", named=False)

156) ^¶

NodeTypeNamed(type="^", named=False)

157) ^=¶

NodeTypeNamed(type="^=", named=False)

158) _¶

NodeTypeNamed(type="_", named=False)

159) future¶

NodeTypeNamed(type="__future__", named=False)

160) and¶

NodeTypeNamed(type="and", named=False)

161) as¶

NodeTypeNamed(type="as", named=False)

162) assert¶

NodeTypeNamed(type="assert", named=False)

163) async¶

NodeTypeNamed(type="async", named=False)

164) await¶

NodeTypeNamed(type="await", named=False)

165) break¶

NodeTypeNamed(type="break", named=False)

166) case¶

NodeTypeNamed(type="case", named=False)

167) class¶

NodeTypeNamed(type="class", named=False)

168) comment¶

NodeTypeNamed(type="comment", named=True)

169) continue¶

NodeTypeNamed(type="continue", named=False)

170) def¶

NodeTypeNamed(type="def", named=False)

171) del¶

NodeTypeNamed(type="del", named=False)

172) elif¶

NodeTypeNamed(type="elif", named=False)

173) ellipsis¶

NodeTypeNamed(type="ellipsis", named=True)

174) else¶

NodeTypeNamed(type="else", named=False)

175) escape_interpolation¶

NodeTypeNamed(type="escape_interpolation", named=True)

176) escape_sequence¶

NodeTypeNamed(type="escape_sequence", named=True)

177) except¶

NodeTypeNamed(type="except", named=False)

178) except*¶

NodeTypeNamed(type="except*", named=False)

179) exec¶

NodeTypeNamed(type="exec", named=False)

180) false¶

NodeTypeNamed(type="false", named=True)

181) finally¶

NodeTypeNamed(type="finally", named=False)

182) float¶

NodeTypeNamed(type="float", named=True)

183) for¶

NodeTypeNamed(type="for", named=False)

184) from¶

NodeTypeNamed(type="from", named=False)

185) global¶

NodeTypeNamed(type="global", named=False)

186) identifier¶

NodeTypeNamed(type="identifier", named=True)

187) if¶

NodeTypeNamed(type="if", named=False)

188) import¶

NodeTypeNamed(type="import", named=False)

189) in¶

NodeTypeNamed(type="in", named=False)

190) integer¶

NodeTypeNamed(type="integer", named=True)

191) is¶

NodeTypeNamed(type="is", named=False)

192) is not¶

NodeTypeNamed(type="is not", named=False)

193) lambda¶

NodeTypeNamed(type="lambda", named=False)

194) line_continuation¶

NodeTypeNamed(type="line_continuation", named=True)

195) match¶

NodeTypeNamed(type="match", named=False)

196) none¶

NodeTypeNamed(type="none", named=True)

197) nonlocal¶

NodeTypeNamed(type="nonlocal", named=False)

198) not¶

NodeTypeNamed(type="not", named=False)

199) not in¶

NodeTypeNamed(type="not in", named=False)

200) or¶

NodeTypeNamed(type="or", named=False)

201) pass¶

NodeTypeNamed(type="pass", named=False)

202) print¶

NodeTypeNamed(type="print", named=False)

203) raise¶

NodeTypeNamed(type="raise", named=False)

204) return¶

NodeTypeNamed(type="return", named=False)

205) string_end¶

NodeTypeNamed(type="string_end", named=True)

206) string_start¶

NodeTypeNamed(type="string_start", named=True)

207) true¶

NodeTypeNamed(type="true", named=True)

208) try¶

NodeTypeNamed(type="try", named=False)

209) type¶

NodeTypeNamed(type="type", named=False)

210) type_conversion¶

NodeTypeNamed(type="type_conversion", named=True)

211) while¶

NodeTypeNamed(type="while", named=False)

212) with¶

NodeTypeNamed(type="with", named=False)

213) yield¶

NodeTypeNamed(type="yield", named=False)

214) {¶

NodeTypeNamed(type="{", named=False)

215) |¶

NodeTypeNamed(type="|", named=False)

216) |=¶

NodeTypeNamed(type="|=", named=False)

217) }¶

NodeTypeNamed(type="}", named=False)

218) ~¶

NodeTypeNamed(type="~", named=False)