diff --git a/internal/cbm/lsp/generated/python_stdlib_data.c b/internal/cbm/lsp/generated/python_stdlib_data.c index 01eb9ad9..26cfcfa4 100644 --- a/internal/cbm/lsp/generated/python_stdlib_data.c +++ b/internal/cbm/lsp/generated/python_stdlib_data.c @@ -22,14 +22,65 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { CBMRegisteredType rt; CBMRegisteredFunc rf; + /* ===== module: _collections_abc ===== */ + static const char* py_methods_1[] = { "isdisjoint", "mapping", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "_collections_abc.dict_keys"; + rt.short_name = "dict_keys"; + rt.method_names = py_methods_1; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "_collections_abc.dict_keys.isdisjoint"; + rf.short_name = "isdisjoint"; + rf.receiver_type = "_collections_abc.dict_keys"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "_collections_abc.dict_keys.mapping"; + rf.short_name = "mapping"; + rf.receiver_type = "_collections_abc.dict_keys"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_2[] = { "mapping", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "_collections_abc.dict_values"; + rt.short_name = "dict_values"; + rt.method_names = py_methods_2; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "_collections_abc.dict_values.mapping"; + rf.short_name = "mapping"; + rf.receiver_type = "_collections_abc.dict_values"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_3[] = { "isdisjoint", "mapping", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "_collections_abc.dict_items"; + rt.short_name = "dict_items"; + rt.method_names = py_methods_3; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "_collections_abc.dict_items.isdisjoint"; + rf.short_name = "isdisjoint"; + rf.receiver_type = "_collections_abc.dict_items"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "_collections_abc.dict_items.mapping"; + rf.short_name = "mapping"; + rf.receiver_type = "_collections_abc.dict_items"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "_collections_abc.Buffer"; + rt.short_name = "Buffer"; + static const char* py_bases_4[] = { "_collections_abc.Protocol", NULL }; + rt.embedded_types = py_bases_4; + cbm_registry_add_type(reg, rt); + /* ===== module: abc ===== */ - static const char* py_methods_1[] = { "__new__", "register", NULL }; + static const char* py_methods_5[] = { "__new__", "register", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "abc.ABCMeta"; rt.short_name = "ABCMeta"; - rt.method_names = py_methods_1; - static const char* py_bases_2[] = { "abc.type", NULL }; - rt.embedded_types = py_bases_2; + rt.method_names = py_methods_5; + static const char* py_bases_6[] = { "abc.type", NULL }; + rt.embedded_types = py_bases_6; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "abc.ABCMeta.__new__"; @@ -41,22 +92,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "register"; rf.receiver_type = "abc.ABCMeta"; cbm_registry_add_func(reg, rf); - static const char* py_methods_3[] = { "__init__", NULL }; + static const char* py_methods_7[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "abc.abstractclassmethod"; rt.short_name = "abstractclassmethod"; - rt.method_names = py_methods_3; + rt.method_names = py_methods_7; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "abc.abstractclassmethod.__init__"; rf.short_name = "__init__"; rf.receiver_type = "abc.abstractclassmethod"; cbm_registry_add_func(reg, rf); - static const char* py_methods_4[] = { "__init__", NULL }; + static const char* py_methods_8[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "abc.abstractstaticmethod"; rt.short_name = "abstractstaticmethod"; - rt.method_names = py_methods_4; + rt.method_names = py_methods_8; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "abc.abstractstaticmethod.__init__"; @@ -66,8 +117,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "abc.abstractproperty"; rt.short_name = "abstractproperty"; - static const char* py_bases_5[] = { "abc.property", NULL }; - rt.embedded_types = py_bases_5; + static const char* py_bases_9[] = { "abc.property", NULL }; + rt.embedded_types = py_bases_9; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "abc.ABC"; @@ -87,13 +138,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: argparse ===== */ - static const char* py_methods_6[] = { "__init__", NULL }; + static const char* py_methods_10[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.ArgumentError"; rt.short_name = "ArgumentError"; - rt.method_names = py_methods_6; - static const char* py_bases_7[] = { "argparse.Exception", NULL }; - rt.embedded_types = py_bases_7; + rt.method_names = py_methods_10; + static const char* py_bases_11[] = { "argparse.Exception", NULL }; + rt.embedded_types = py_bases_11; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.ArgumentError.__init__"; @@ -104,11 +155,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "argparse._AttributeHolder"; rt.short_name = "_AttributeHolder"; cbm_registry_add_type(reg, rt); - static const char* py_methods_8[] = { "__init__", "register", "set_defaults", "get_default", "add_argument", "add_argument_group", "add_mutually_exclusive_group", NULL }; + static const char* py_methods_12[] = { "__init__", "register", "set_defaults", "get_default", "add_argument", "add_argument_group", "add_mutually_exclusive_group", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._ActionsContainer"; rt.short_name = "_ActionsContainer"; - rt.method_names = py_methods_8; + rt.method_names = py_methods_12; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._ActionsContainer.__init__"; @@ -145,26 +196,26 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "add_mutually_exclusive_group"; rf.receiver_type = "argparse._ActionsContainer"; cbm_registry_add_func(reg, rf); - static const char* py_methods_9[] = { "__call__", NULL }; + static const char* py_methods_13[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._FormatterClass"; rt.short_name = "_FormatterClass"; - rt.method_names = py_methods_9; - static const char* py_bases_10[] = { "argparse.Protocol", NULL }; - rt.embedded_types = py_bases_10; + rt.method_names = py_methods_13; + static const char* py_bases_14[] = { "argparse.Protocol", NULL }; + rt.embedded_types = py_bases_14; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._FormatterClass.__call__"; rf.short_name = "__call__"; rf.receiver_type = "argparse._FormatterClass"; cbm_registry_add_func(reg, rf); - static const char* py_methods_11[] = { "__init__", "parse_args", "add_subparsers", "print_usage", "print_help", "format_usage", "format_help", "parse_known_args", "convert_arg_line_to_args", "exit", "error", "parse_intermixed_args", "parse_known_intermixed_args", "_parse_known_args", "_parse_optional", NULL }; + static const char* py_methods_15[] = { "__init__", "parse_args", "add_subparsers", "print_usage", "print_help", "format_usage", "format_help", "parse_known_args", "convert_arg_line_to_args", "exit", "error", "parse_intermixed_args", "parse_known_intermixed_args", "_parse_known_args", "_parse_optional", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.ArgumentParser"; rt.short_name = "ArgumentParser"; - rt.method_names = py_methods_11; - static const char* py_bases_12[] = { "argparse._AttributeHolder", "argparse._ActionsContainer", NULL }; - rt.embedded_types = py_bases_12; + rt.method_names = py_methods_15; + static const char* py_bases_16[] = { "argparse._AttributeHolder", "argparse._ActionsContainer", NULL }; + rt.embedded_types = py_bases_16; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.ArgumentParser.__init__"; @@ -241,11 +292,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "_parse_optional"; rf.receiver_type = "argparse.ArgumentParser"; cbm_registry_add_func(reg, rf); - static const char* py_methods_13[] = { "__init__", "start_section", "end_section", "add_text", "add_usage", "add_argument", "add_arguments", "format_help", "_format_actions_usage", NULL }; + static const char* py_methods_17[] = { "__init__", "start_section", "end_section", "add_text", "add_usage", "add_argument", "add_arguments", "format_help", "_format_actions_usage", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.HelpFormatter"; rt.short_name = "HelpFormatter"; - rt.method_names = py_methods_13; + rt.method_names = py_methods_17; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.HelpFormatter.__init__"; @@ -295,34 +346,34 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.RawDescriptionHelpFormatter"; rt.short_name = "RawDescriptionHelpFormatter"; - static const char* py_bases_14[] = { "argparse.HelpFormatter", NULL }; - rt.embedded_types = py_bases_14; + static const char* py_bases_18[] = { "argparse.HelpFormatter", NULL }; + rt.embedded_types = py_bases_18; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.RawTextHelpFormatter"; rt.short_name = "RawTextHelpFormatter"; - static const char* py_bases_15[] = { "argparse.RawDescriptionHelpFormatter", NULL }; - rt.embedded_types = py_bases_15; + static const char* py_bases_19[] = { "argparse.RawDescriptionHelpFormatter", NULL }; + rt.embedded_types = py_bases_19; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.ArgumentDefaultsHelpFormatter"; rt.short_name = "ArgumentDefaultsHelpFormatter"; - static const char* py_bases_16[] = { "argparse.HelpFormatter", NULL }; - rt.embedded_types = py_bases_16; + static const char* py_bases_20[] = { "argparse.HelpFormatter", NULL }; + rt.embedded_types = py_bases_20; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.MetavarTypeHelpFormatter"; rt.short_name = "MetavarTypeHelpFormatter"; - static const char* py_bases_17[] = { "argparse.HelpFormatter", NULL }; - rt.embedded_types = py_bases_17; + static const char* py_bases_21[] = { "argparse.HelpFormatter", NULL }; + rt.embedded_types = py_bases_21; cbm_registry_add_type(reg, rt); - static const char* py_methods_18[] = { "__init__", "__call__", "format_usage", NULL }; + static const char* py_methods_22[] = { "__init__", "__call__", "format_usage", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.Action"; rt.short_name = "Action"; - rt.method_names = py_methods_18; - static const char* py_bases_19[] = { "argparse._AttributeHolder", NULL }; - rt.embedded_types = py_bases_19; + rt.method_names = py_methods_22; + static const char* py_bases_23[] = { "argparse._AttributeHolder", NULL }; + rt.embedded_types = py_bases_23; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.Action.__init__"; @@ -339,50 +390,50 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "format_usage"; rf.receiver_type = "argparse.Action"; cbm_registry_add_func(reg, rf); - static const char* py_methods_20[] = { "__init__", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "argparse.BooleanOptionalAction"; - rt.short_name = "BooleanOptionalAction"; - rt.method_names = py_methods_20; - static const char* py_bases_21[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_21; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "argparse.BooleanOptionalAction.__init__"; - rf.short_name = "__init__"; - rf.receiver_type = "argparse.BooleanOptionalAction"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_22[] = { "__init__", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "argparse.BooleanOptionalAction"; - rt.short_name = "BooleanOptionalAction"; - rt.method_names = py_methods_22; - static const char* py_bases_23[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_23; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "argparse.BooleanOptionalAction.__init__"; - rf.short_name = "__init__"; - rf.receiver_type = "argparse.BooleanOptionalAction"; - cbm_registry_add_func(reg, rf); static const char* py_methods_24[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "argparse.BooleanOptionalAction"; + rt.short_name = "BooleanOptionalAction"; + rt.method_names = py_methods_24; + static const char* py_bases_25[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_25; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "argparse.BooleanOptionalAction.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "argparse.BooleanOptionalAction"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_26[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "argparse.BooleanOptionalAction"; + rt.short_name = "BooleanOptionalAction"; + rt.method_names = py_methods_26; + static const char* py_bases_27[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_27; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "argparse.BooleanOptionalAction.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "argparse.BooleanOptionalAction"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_28[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.Namespace"; rt.short_name = "Namespace"; - rt.method_names = py_methods_24; - static const char* py_bases_25[] = { "argparse._AttributeHolder", NULL }; - rt.embedded_types = py_bases_25; + rt.method_names = py_methods_28; + static const char* py_bases_29[] = { "argparse._AttributeHolder", NULL }; + rt.embedded_types = py_bases_29; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.Namespace.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse.Namespace"; cbm_registry_add_func(reg, rf); - static const char* py_methods_26[] = { "__init__", "__call__", NULL }; + static const char* py_methods_30[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.FileType"; rt.short_name = "FileType"; - rt.method_names = py_methods_26; + rt.method_names = py_methods_30; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.FileType.__init__"; @@ -394,11 +445,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__call__"; rf.receiver_type = "argparse.FileType"; cbm_registry_add_func(reg, rf); - static const char* py_methods_27[] = { "__init__", "__call__", NULL }; + static const char* py_methods_31[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.FileType"; rt.short_name = "FileType"; - rt.method_names = py_methods_27; + rt.method_names = py_methods_31; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse.FileType.__init__"; @@ -410,26 +461,26 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__call__"; rf.receiver_type = "argparse.FileType"; cbm_registry_add_func(reg, rf); - static const char* py_methods_28[] = { "__init__", NULL }; + static const char* py_methods_32[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._ArgumentGroup"; rt.short_name = "_ArgumentGroup"; - rt.method_names = py_methods_28; - static const char* py_bases_29[] = { "argparse._ActionsContainer", NULL }; - rt.embedded_types = py_bases_29; + rt.method_names = py_methods_32; + static const char* py_bases_33[] = { "argparse._ActionsContainer", NULL }; + rt.embedded_types = py_bases_33; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._ArgumentGroup.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._ArgumentGroup"; cbm_registry_add_func(reg, rf); - static const char* py_methods_30[] = { "__init__", NULL }; + static const char* py_methods_34[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._MutuallyExclusiveGroup"; rt.short_name = "_MutuallyExclusiveGroup"; - rt.method_names = py_methods_30; - static const char* py_bases_31[] = { "argparse._ArgumentGroup", NULL }; - rt.embedded_types = py_bases_31; + rt.method_names = py_methods_34; + static const char* py_bases_35[] = { "argparse._ArgumentGroup", NULL }; + rt.embedded_types = py_bases_35; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._MutuallyExclusiveGroup.__init__"; @@ -439,42 +490,42 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._StoreAction"; rt.short_name = "_StoreAction"; - static const char* py_bases_32[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_32; + static const char* py_bases_36[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_36; cbm_registry_add_type(reg, rt); - static const char* py_methods_33[] = { "__init__", NULL }; + static const char* py_methods_37[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._StoreConstAction"; rt.short_name = "_StoreConstAction"; - rt.method_names = py_methods_33; - static const char* py_bases_34[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_34; + rt.method_names = py_methods_37; + static const char* py_bases_38[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_38; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._StoreConstAction.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._StoreConstAction"; cbm_registry_add_func(reg, rf); - static const char* py_methods_35[] = { "__init__", NULL }; + static const char* py_methods_39[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._StoreTrueAction"; rt.short_name = "_StoreTrueAction"; - rt.method_names = py_methods_35; - static const char* py_bases_36[] = { "argparse._StoreConstAction", NULL }; - rt.embedded_types = py_bases_36; + rt.method_names = py_methods_39; + static const char* py_bases_40[] = { "argparse._StoreConstAction", NULL }; + rt.embedded_types = py_bases_40; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._StoreTrueAction.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._StoreTrueAction"; cbm_registry_add_func(reg, rf); - static const char* py_methods_37[] = { "__init__", NULL }; + static const char* py_methods_41[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._StoreFalseAction"; rt.short_name = "_StoreFalseAction"; - rt.method_names = py_methods_37; - static const char* py_bases_38[] = { "argparse._StoreConstAction", NULL }; - rt.embedded_types = py_bases_38; + rt.method_names = py_methods_41; + static const char* py_bases_42[] = { "argparse._StoreConstAction", NULL }; + rt.embedded_types = py_bases_42; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._StoreFalseAction.__init__"; @@ -484,74 +535,74 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._AppendAction"; rt.short_name = "_AppendAction"; - static const char* py_bases_39[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_39; + static const char* py_bases_43[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_43; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._ExtendAction"; rt.short_name = "_ExtendAction"; - static const char* py_bases_40[] = { "argparse._AppendAction", NULL }; - rt.embedded_types = py_bases_40; + static const char* py_bases_44[] = { "argparse._AppendAction", NULL }; + rt.embedded_types = py_bases_44; cbm_registry_add_type(reg, rt); - static const char* py_methods_41[] = { "__init__", NULL }; + static const char* py_methods_45[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._AppendConstAction"; rt.short_name = "_AppendConstAction"; - rt.method_names = py_methods_41; - static const char* py_bases_42[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_42; + rt.method_names = py_methods_45; + static const char* py_bases_46[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_46; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._AppendConstAction.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._AppendConstAction"; cbm_registry_add_func(reg, rf); - static const char* py_methods_43[] = { "__init__", NULL }; + static const char* py_methods_47[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._CountAction"; rt.short_name = "_CountAction"; - rt.method_names = py_methods_43; - static const char* py_bases_44[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_44; + rt.method_names = py_methods_47; + static const char* py_bases_48[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_48; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._CountAction.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._CountAction"; cbm_registry_add_func(reg, rf); - static const char* py_methods_45[] = { "__init__", NULL }; + static const char* py_methods_49[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._HelpAction"; rt.short_name = "_HelpAction"; - rt.method_names = py_methods_45; - static const char* py_bases_46[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_46; + rt.method_names = py_methods_49; + static const char* py_bases_50[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_50; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._HelpAction.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._HelpAction"; cbm_registry_add_func(reg, rf); - static const char* py_methods_47[] = { "__init__", NULL }; + static const char* py_methods_51[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._VersionAction"; rt.short_name = "_VersionAction"; - rt.method_names = py_methods_47; - static const char* py_bases_48[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_48; + rt.method_names = py_methods_51; + static const char* py_bases_52[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_52; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._VersionAction.__init__"; rf.short_name = "__init__"; rf.receiver_type = "argparse._VersionAction"; cbm_registry_add_func(reg, rf); - static const char* py_methods_49[] = { "__init__", "add_parser", NULL }; + static const char* py_methods_53[] = { "__init__", "add_parser", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse._SubParsersAction"; rt.short_name = "_SubParsersAction"; - rt.method_names = py_methods_49; - static const char* py_bases_50[] = { "argparse.Action", NULL }; - rt.embedded_types = py_bases_50; + rt.method_names = py_methods_53; + static const char* py_bases_54[] = { "argparse.Action", NULL }; + rt.embedded_types = py_bases_54; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "argparse._SubParsersAction.__init__"; @@ -566,18 +617,163 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "argparse.ArgumentTypeError"; rt.short_name = "ArgumentTypeError"; - static const char* py_bases_51[] = { "argparse.Exception", NULL }; - rt.embedded_types = py_bases_51; + static const char* py_bases_55[] = { "argparse.Exception", NULL }; + rt.embedded_types = py_bases_55; cbm_registry_add_type(reg, rt); + /* ===== module: asyncio ===== */ + static const char* py_methods_56[] = { "__init__", "check_returncode", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.CompletedProcess"; + rt.short_name = "CompletedProcess"; + rt.method_names = py_methods_56; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.CompletedProcess.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "asyncio.CompletedProcess"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.CompletedProcess.check_returncode"; + rf.short_name = "check_returncode"; + rf.receiver_type = "asyncio.CompletedProcess"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.SubprocessError"; + rt.short_name = "SubprocessError"; + static const char* py_bases_57[] = { "subprocess.Exception", NULL }; + rt.embedded_types = py_bases_57; + cbm_registry_add_type(reg, rt); + static const char* py_methods_58[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.TimeoutExpired"; + rt.short_name = "TimeoutExpired"; + rt.method_names = py_methods_58; + static const char* py_bases_59[] = { "subprocess.SubprocessError", NULL }; + rt.embedded_types = py_bases_59; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.TimeoutExpired.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "asyncio.TimeoutExpired"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_60[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.CalledProcessError"; + rt.short_name = "CalledProcessError"; + rt.method_names = py_methods_60; + static const char* py_bases_61[] = { "subprocess.SubprocessError", NULL }; + rt.embedded_types = py_bases_61; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.CalledProcessError.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "asyncio.CalledProcessError"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_62[] = { "__init__", "poll", "wait", "communicate", "send_signal", "terminate", "kill", "__enter__", "__exit__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.Popen"; + rt.short_name = "Popen"; + rt.method_names = py_methods_62; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.poll"; + rf.short_name = "poll"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.wait"; + rf.short_name = "wait"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.communicate"; + rf.short_name = "communicate"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.send_signal"; + rf.short_name = "send_signal"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.terminate"; + rf.short_name = "terminate"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.kill"; + rf.short_name = "kill"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.Popen.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "asyncio.Popen"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_63[] = { "__init__", "copy", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.STARTUPINFO"; + rt.short_name = "STARTUPINFO"; + rt.method_names = py_methods_63; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.STARTUPINFO.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "asyncio.STARTUPINFO"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.STARTUPINFO.copy"; + rf.short_name = "copy"; + rf.receiver_type = "asyncio.STARTUPINFO"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.run"; + rf.short_name = "run"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.call"; + rf.short_name = "call"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.check_call"; + rf.short_name = "check_call"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.check_output"; + rf.short_name = "check_output"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.getstatusoutput"; + rf.short_name = "getstatusoutput"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.getoutput"; + rf.short_name = "getoutput"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.list2cmdline"; + rf.short_name = "list2cmdline"; + cbm_registry_add_func(reg, rf); + /* ===== module: asyncio.base_events ===== */ - static const char* py_methods_52[] = { "__init__", "close_clients", "abort_clients", "get_loop", "is_serving", "start_serving", "serve_forever", "sockets", "close", "wait_closed", NULL }; + static const char* py_methods_64[] = { "__init__", "close_clients", "abort_clients", "get_loop", "is_serving", "start_serving", "serve_forever", "sockets", "close", "wait_closed", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.base_events.Server"; rt.short_name = "Server"; - rt.method_names = py_methods_52; - static const char* py_bases_53[] = { "asyncio.base_events.AbstractServer", NULL }; - rt.embedded_types = py_bases_53; + rt.method_names = py_methods_64; + static const char* py_bases_65[] = { "asyncio.base_events.AbstractServer", NULL }; + rt.embedded_types = py_bases_65; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.base_events.Server.__init__"; @@ -629,13 +825,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "wait_closed"; rf.receiver_type = "asyncio.base_events.Server"; cbm_registry_add_func(reg, rf); - static const char* py_methods_54[] = { "run_forever", "run_until_complete", "stop", "is_running", "is_closed", "close", "shutdown_asyncgens", "call_soon", "call_later", "call_at", "time", "create_future", "create_task", "set_task_factory", "get_task_factory", "call_soon_threadsafe", "run_in_executor", "set_default_executor", "getaddrinfo", "getnameinfo", "create_connection", "create_server", "start_tls", "connect_accepted_socket", "sock_sendfile", "sendfile", "create_datagram_endpoint", "connect_read_pipe", "connect_write_pipe", "subprocess_shell", "subprocess_exec", "add_reader", "remove_reader", "add_writer", "remove_writer", "sock_recv", "sock_recv_into", "sock_sendall", "sock_connect", "sock_accept", "sock_recvfrom", "sock_recvfrom_into", "sock_sendto", "add_signal_handler", "remove_signal_handler", "set_exception_handler", "get_exception_handler", "default_exception_handler", "call_exception_handler", "get_debug", "set_debug", "shutdown_default_executor", NULL }; + static const char* py_methods_66[] = { "run_forever", "run_until_complete", "stop", "is_running", "is_closed", "close", "shutdown_asyncgens", "call_soon", "call_later", "call_at", "time", "create_future", "create_task", "set_task_factory", "get_task_factory", "call_soon_threadsafe", "run_in_executor", "set_default_executor", "getaddrinfo", "getnameinfo", "create_connection", "create_server", "start_tls", "connect_accepted_socket", "sock_sendfile", "sendfile", "create_datagram_endpoint", "connect_read_pipe", "connect_write_pipe", "subprocess_shell", "subprocess_exec", "add_reader", "remove_reader", "add_writer", "remove_writer", "sock_recv", "sock_recv_into", "sock_sendall", "sock_connect", "sock_accept", "sock_recvfrom", "sock_recvfrom_into", "sock_sendto", "add_signal_handler", "remove_signal_handler", "set_exception_handler", "get_exception_handler", "default_exception_handler", "call_exception_handler", "get_debug", "set_debug", "shutdown_default_executor", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.base_events.BaseEventLoop"; rt.short_name = "BaseEventLoop"; - rt.method_names = py_methods_54; - static const char* py_bases_55[] = { "asyncio.base_events.AbstractEventLoop", NULL }; - rt.embedded_types = py_bases_55; + rt.method_names = py_methods_66; + static const char* py_bases_67[] = { "asyncio.base_events.AbstractEventLoop", NULL }; + rt.embedded_types = py_bases_67; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.base_events.BaseEventLoop.run_forever"; @@ -905,13 +1101,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.base_subprocess ===== */ - static const char* py_methods_56[] = { "__init__", "get_pid", "get_pipe_transport", "send_signal", NULL }; + static const char* py_methods_68[] = { "__init__", "get_pid", "get_pipe_transport", "send_signal", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport"; rt.short_name = "BaseSubprocessTransport"; - rt.method_names = py_methods_56; - static const char* py_bases_57[] = { "transports.SubprocessTransport", NULL }; - rt.embedded_types = py_bases_57; + rt.method_names = py_methods_68; + static const char* py_bases_69[] = { "transports.SubprocessTransport", NULL }; + rt.embedded_types = py_bases_69; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport.__init__"; @@ -933,13 +1129,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "send_signal"; rf.receiver_type = "asyncio.base_subprocess.BaseSubprocessTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_58[] = { "__init__", NULL }; + static const char* py_methods_70[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.base_subprocess.WriteSubprocessPipeProto"; rt.short_name = "WriteSubprocessPipeProto"; - rt.method_names = py_methods_58; - static const char* py_bases_59[] = { "protocols.BaseProtocol", NULL }; - rt.embedded_types = py_bases_59; + rt.method_names = py_methods_70; + static const char* py_bases_71[] = { "protocols.BaseProtocol", NULL }; + rt.embedded_types = py_bases_71; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.base_subprocess.WriteSubprocessPipeProto.__init__"; @@ -949,16 +1145,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.base_subprocess.ReadSubprocessPipeProto"; rt.short_name = "ReadSubprocessPipeProto"; - static const char* py_bases_60[] = { "asyncio.base_subprocess.WriteSubprocessPipeProto", "protocols.Protocol", NULL }; - rt.embedded_types = py_bases_60; + static const char* py_bases_72[] = { "asyncio.base_subprocess.WriteSubprocessPipeProto", "protocols.Protocol", NULL }; + rt.embedded_types = py_bases_72; cbm_registry_add_type(reg, rt); /* ===== module: asyncio.constants ===== */ memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.constants._SendfileMode"; rt.short_name = "_SendfileMode"; - static const char* py_bases_61[] = { "enum.Enum", NULL }; - rt.embedded_types = py_bases_61; + static const char* py_bases_73[] = { "enum.Enum", NULL }; + rt.embedded_types = py_bases_73; cbm_registry_add_type(reg, rt); /* ===== module: asyncio.coroutines ===== */ @@ -976,24 +1172,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.events ===== */ - static const char* py_methods_62[] = { "__call__", NULL }; + static const char* py_methods_74[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events._TaskFactory"; rt.short_name = "_TaskFactory"; - rt.method_names = py_methods_62; - static const char* py_bases_63[] = { "asyncio.events.Protocol", NULL }; - rt.embedded_types = py_bases_63; + rt.method_names = py_methods_74; + static const char* py_bases_75[] = { "asyncio.events.Protocol", NULL }; + rt.embedded_types = py_bases_75; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events._TaskFactory.__call__"; rf.short_name = "__call__"; rf.receiver_type = "asyncio.events._TaskFactory"; cbm_registry_add_func(reg, rf); - static const char* py_methods_64[] = { "__init__", "cancel", "cancelled", "get_context", NULL }; + static const char* py_methods_76[] = { "__init__", "cancel", "cancelled", "get_context", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events.Handle"; rt.short_name = "Handle"; - rt.method_names = py_methods_64; + rt.method_names = py_methods_76; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events.Handle.__init__"; @@ -1015,13 +1211,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "get_context"; rf.receiver_type = "asyncio.events.Handle"; cbm_registry_add_func(reg, rf); - static const char* py_methods_65[] = { "__init__", "when", NULL }; + static const char* py_methods_77[] = { "__init__", "when", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events.TimerHandle"; rt.short_name = "TimerHandle"; - rt.method_names = py_methods_65; - static const char* py_bases_66[] = { "asyncio.events.Handle", NULL }; - rt.embedded_types = py_bases_66; + rt.method_names = py_methods_77; + static const char* py_bases_78[] = { "asyncio.events.Handle", NULL }; + rt.embedded_types = py_bases_78; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events.TimerHandle.__init__"; @@ -1033,11 +1229,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "when"; rf.receiver_type = "asyncio.events.TimerHandle"; cbm_registry_add_func(reg, rf); - static const char* py_methods_67[] = { "close", "close_clients", "abort_clients", "get_loop", "is_serving", "start_serving", "serve_forever", "wait_closed", NULL }; + static const char* py_methods_79[] = { "close", "close_clients", "abort_clients", "get_loop", "is_serving", "start_serving", "serve_forever", "wait_closed", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events.AbstractServer"; rt.short_name = "AbstractServer"; - rt.method_names = py_methods_67; + rt.method_names = py_methods_79; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events.AbstractServer.close"; @@ -1079,11 +1275,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "wait_closed"; rf.receiver_type = "asyncio.events.AbstractServer"; cbm_registry_add_func(reg, rf); - static const char* py_methods_68[] = { "run_forever", "run_until_complete", "stop", "is_running", "is_closed", "close", "shutdown_asyncgens", "call_soon", "call_later", "call_at", "time", "create_future", "create_task", "set_task_factory", "get_task_factory", "call_soon_threadsafe", "run_in_executor", "set_default_executor", "getaddrinfo", "getnameinfo", "create_connection", "create_server", "start_tls", "create_unix_server", "connect_accepted_socket", "create_unix_connection", "sock_sendfile", "sendfile", "create_datagram_endpoint", "connect_read_pipe", "connect_write_pipe", "subprocess_shell", "subprocess_exec", "add_reader", "remove_reader", "add_writer", "remove_writer", "sock_recv", "sock_recv_into", "sock_sendall", "sock_connect", "sock_accept", "sock_recvfrom", "sock_recvfrom_into", "sock_sendto", "add_signal_handler", "remove_signal_handler", "set_exception_handler", "get_exception_handler", "default_exception_handler", "call_exception_handler", "get_debug", "set_debug", "shutdown_default_executor", NULL }; + static const char* py_methods_80[] = { "run_forever", "run_until_complete", "stop", "is_running", "is_closed", "close", "shutdown_asyncgens", "call_soon", "call_later", "call_at", "time", "create_future", "create_task", "set_task_factory", "get_task_factory", "call_soon_threadsafe", "run_in_executor", "set_default_executor", "getaddrinfo", "getnameinfo", "create_connection", "create_server", "start_tls", "create_unix_server", "connect_accepted_socket", "create_unix_connection", "sock_sendfile", "sendfile", "create_datagram_endpoint", "connect_read_pipe", "connect_write_pipe", "subprocess_shell", "subprocess_exec", "add_reader", "remove_reader", "add_writer", "remove_writer", "sock_recv", "sock_recv_into", "sock_sendall", "sock_connect", "sock_accept", "sock_recvfrom", "sock_recvfrom_into", "sock_sendto", "add_signal_handler", "remove_signal_handler", "set_exception_handler", "get_exception_handler", "default_exception_handler", "call_exception_handler", "get_debug", "set_debug", "shutdown_default_executor", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events.AbstractEventLoop"; rt.short_name = "AbstractEventLoop"; - rt.method_names = py_methods_68; + rt.method_names = py_methods_80; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events.AbstractEventLoop.run_forever"; @@ -1355,11 +1551,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "shutdown_default_executor"; rf.receiver_type = "asyncio.events.AbstractEventLoop"; cbm_registry_add_func(reg, rf); - static const char* py_methods_69[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL }; + static const char* py_methods_81[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events._AbstractEventLoopPolicy"; rt.short_name = "_AbstractEventLoopPolicy"; - rt.method_names = py_methods_69; + rt.method_names = py_methods_81; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.get_event_loop"; @@ -1376,11 +1572,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "new_event_loop"; rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_70[] = { "get_event_loop", "set_event_loop", "new_event_loop", "get_child_watcher", "set_child_watcher", NULL }; + static const char* py_methods_82[] = { "get_event_loop", "set_event_loop", "new_event_loop", "get_child_watcher", "set_child_watcher", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events._AbstractEventLoopPolicy"; rt.short_name = "_AbstractEventLoopPolicy"; - rt.method_names = py_methods_70; + rt.method_names = py_methods_82; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.get_event_loop"; @@ -1407,13 +1603,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "set_child_watcher"; rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_71[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL }; + static const char* py_methods_83[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events._BaseDefaultEventLoopPolicy"; rt.short_name = "_BaseDefaultEventLoopPolicy"; - rt.method_names = py_methods_71; - static const char* py_bases_72[] = { "asyncio.events._AbstractEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_72; + rt.method_names = py_methods_83; + static const char* py_bases_84[] = { "asyncio.events._AbstractEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_84; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events._BaseDefaultEventLoopPolicy.get_event_loop"; @@ -1430,13 +1626,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "new_event_loop"; rf.receiver_type = "asyncio.events._BaseDefaultEventLoopPolicy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_73[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL }; + static const char* py_methods_85[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.events.BaseDefaultEventLoopPolicy"; rt.short_name = "BaseDefaultEventLoopPolicy"; - rt.method_names = py_methods_73; - static const char* py_bases_74[] = { "asyncio.events._AbstractEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_74; + rt.method_names = py_methods_85; + static const char* py_bases_86[] = { "asyncio.events._AbstractEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_86; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.events.BaseDefaultEventLoopPolicy.get_event_loop"; @@ -1482,47 +1678,47 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.CancelledError"; rt.short_name = "CancelledError"; - static const char* py_bases_75[] = { "asyncio.exceptions.BaseException", NULL }; - rt.embedded_types = py_bases_75; + static const char* py_bases_87[] = { "asyncio.exceptions.BaseException", NULL }; + rt.embedded_types = py_bases_87; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.TimeoutError"; rt.short_name = "TimeoutError"; - static const char* py_bases_76[] = { "asyncio.exceptions.Exception", NULL }; - rt.embedded_types = py_bases_76; + static const char* py_bases_88[] = { "asyncio.exceptions.Exception", NULL }; + rt.embedded_types = py_bases_88; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.InvalidStateError"; rt.short_name = "InvalidStateError"; - static const char* py_bases_77[] = { "asyncio.exceptions.Exception", NULL }; - rt.embedded_types = py_bases_77; + static const char* py_bases_89[] = { "asyncio.exceptions.Exception", NULL }; + rt.embedded_types = py_bases_89; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.SendfileNotAvailableError"; rt.short_name = "SendfileNotAvailableError"; - static const char* py_bases_78[] = { "asyncio.exceptions.RuntimeError", NULL }; - rt.embedded_types = py_bases_78; + static const char* py_bases_90[] = { "asyncio.exceptions.RuntimeError", NULL }; + rt.embedded_types = py_bases_90; cbm_registry_add_type(reg, rt); - static const char* py_methods_79[] = { "__init__", NULL }; + static const char* py_methods_91[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.IncompleteReadError"; rt.short_name = "IncompleteReadError"; - rt.method_names = py_methods_79; - static const char* py_bases_80[] = { "asyncio.exceptions.EOFError", NULL }; - rt.embedded_types = py_bases_80; + rt.method_names = py_methods_91; + static const char* py_bases_92[] = { "asyncio.exceptions.EOFError", NULL }; + rt.embedded_types = py_bases_92; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.exceptions.IncompleteReadError.__init__"; rf.short_name = "__init__"; rf.receiver_type = "asyncio.exceptions.IncompleteReadError"; cbm_registry_add_func(reg, rf); - static const char* py_methods_81[] = { "__init__", NULL }; + static const char* py_methods_93[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.LimitOverrunError"; rt.short_name = "LimitOverrunError"; - rt.method_names = py_methods_81; - static const char* py_bases_82[] = { "asyncio.exceptions.Exception", NULL }; - rt.embedded_types = py_bases_82; + rt.method_names = py_methods_93; + static const char* py_bases_94[] = { "asyncio.exceptions.Exception", NULL }; + rt.embedded_types = py_bases_94; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.exceptions.LimitOverrunError.__init__"; @@ -1532,8 +1728,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.exceptions.BrokenBarrierError"; rt.short_name = "BrokenBarrierError"; - static const char* py_bases_83[] = { "asyncio.exceptions.RuntimeError", NULL }; - rt.embedded_types = py_bases_83; + static const char* py_bases_95[] = { "asyncio.exceptions.RuntimeError", NULL }; + rt.embedded_types = py_bases_95; cbm_registry_add_type(reg, rt); /* ===== module: asyncio.format_helpers ===== */ @@ -1579,13 +1775,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "asyncio.locks._ContextManagerMixin"; rt.short_name = "_ContextManagerMixin"; cbm_registry_add_type(reg, rt); - static const char* py_methods_84[] = { "__init__", "locked", "acquire", "release", NULL }; + static const char* py_methods_96[] = { "__init__", "locked", "acquire", "release", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks.Lock"; rt.short_name = "Lock"; - rt.method_names = py_methods_84; - static const char* py_bases_85[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL }; - rt.embedded_types = py_bases_85; + rt.method_names = py_methods_96; + static const char* py_bases_97[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL }; + rt.embedded_types = py_bases_97; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.locks.Lock.__init__"; @@ -1607,13 +1803,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "release"; rf.receiver_type = "asyncio.locks.Lock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_86[] = { "__init__", "is_set", "set", "clear", "wait", NULL }; + static const char* py_methods_98[] = { "__init__", "is_set", "set", "clear", "wait", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks.Event"; rt.short_name = "Event"; - rt.method_names = py_methods_86; - static const char* py_bases_87[] = { "asyncio.locks._LoopBoundMixin", NULL }; - rt.embedded_types = py_bases_87; + rt.method_names = py_methods_98; + static const char* py_bases_99[] = { "asyncio.locks._LoopBoundMixin", NULL }; + rt.embedded_types = py_bases_99; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.locks.Event.__init__"; @@ -1640,13 +1836,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "wait"; rf.receiver_type = "asyncio.locks.Event"; cbm_registry_add_func(reg, rf); - static const char* py_methods_88[] = { "__init__", "locked", "acquire", "release", "wait", "wait_for", "notify", "notify_all", NULL }; + static const char* py_methods_100[] = { "__init__", "locked", "acquire", "release", "wait", "wait_for", "notify", "notify_all", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks.Condition"; rt.short_name = "Condition"; - rt.method_names = py_methods_88; - static const char* py_bases_89[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL }; - rt.embedded_types = py_bases_89; + rt.method_names = py_methods_100; + static const char* py_bases_101[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL }; + rt.embedded_types = py_bases_101; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.locks.Condition.__init__"; @@ -1688,13 +1884,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "notify_all"; rf.receiver_type = "asyncio.locks.Condition"; cbm_registry_add_func(reg, rf); - static const char* py_methods_90[] = { "__init__", "locked", "acquire", "release", NULL }; + static const char* py_methods_102[] = { "__init__", "locked", "acquire", "release", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks.Semaphore"; rt.short_name = "Semaphore"; - rt.method_names = py_methods_90; - static const char* py_bases_91[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL }; - rt.embedded_types = py_bases_91; + rt.method_names = py_methods_102; + static const char* py_bases_103[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL }; + rt.embedded_types = py_bases_103; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.locks.Semaphore.__init__"; @@ -1719,22 +1915,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks.BoundedSemaphore"; rt.short_name = "BoundedSemaphore"; - static const char* py_bases_92[] = { "asyncio.locks.Semaphore", NULL }; - rt.embedded_types = py_bases_92; + static const char* py_bases_104[] = { "asyncio.locks.Semaphore", NULL }; + rt.embedded_types = py_bases_104; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks._BarrierState"; rt.short_name = "_BarrierState"; - static const char* py_bases_93[] = { "enum.Enum", NULL }; - rt.embedded_types = py_bases_93; + static const char* py_bases_105[] = { "enum.Enum", NULL }; + rt.embedded_types = py_bases_105; cbm_registry_add_type(reg, rt); - static const char* py_methods_94[] = { "__init__", "wait", "abort", "reset", "parties", "n_waiting", "broken", NULL }; + static const char* py_methods_106[] = { "__init__", "wait", "abort", "reset", "parties", "n_waiting", "broken", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.locks.Barrier"; rt.short_name = "Barrier"; - rt.method_names = py_methods_94; - static const char* py_bases_95[] = { "asyncio.locks._LoopBoundMixin", NULL }; - rt.embedded_types = py_bases_95; + rt.method_names = py_methods_106; + static const char* py_bases_107[] = { "asyncio.locks._LoopBoundMixin", NULL }; + rt.embedded_types = py_bases_107; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.locks.Barrier.__init__"; @@ -1773,11 +1969,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.mixins ===== */ - static const char* py_methods_96[] = { "__init__", NULL }; + static const char* py_methods_108[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.mixins._LoopBoundMixin"; rt.short_name = "_LoopBoundMixin"; - rt.method_names = py_methods_96; + rt.method_names = py_methods_108; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.mixins._LoopBoundMixin.__init__"; @@ -1786,26 +1982,26 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.proactor_events ===== */ - static const char* py_methods_97[] = { "__init__", NULL }; + static const char* py_methods_109[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events._ProactorBasePipeTransport"; rt.short_name = "_ProactorBasePipeTransport"; - rt.method_names = py_methods_97; - static const char* py_bases_98[] = { "transports._FlowControlMixin", "transports.BaseTransport", NULL }; - rt.embedded_types = py_bases_98; + rt.method_names = py_methods_109; + static const char* py_bases_110[] = { "transports._FlowControlMixin", "transports.BaseTransport", NULL }; + rt.embedded_types = py_bases_110; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.proactor_events._ProactorBasePipeTransport.__init__"; rf.short_name = "__init__"; rf.receiver_type = "asyncio.proactor_events._ProactorBasePipeTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_99[] = { "__init__", NULL }; + static const char* py_methods_111[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events._ProactorReadPipeTransport"; rt.short_name = "_ProactorReadPipeTransport"; - rt.method_names = py_methods_99; - static const char* py_bases_100[] = { "asyncio.proactor_events._ProactorBasePipeTransport", "transports.ReadTransport", NULL }; - rt.embedded_types = py_bases_100; + rt.method_names = py_methods_111; + static const char* py_bases_112[] = { "asyncio.proactor_events._ProactorBasePipeTransport", "transports.ReadTransport", NULL }; + rt.embedded_types = py_bases_112; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.proactor_events._ProactorReadPipeTransport.__init__"; @@ -1815,28 +2011,28 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events._ProactorBaseWritePipeTransport"; rt.short_name = "_ProactorBaseWritePipeTransport"; - static const char* py_bases_101[] = { "asyncio.proactor_events._ProactorBasePipeTransport", "transports.WriteTransport", NULL }; - rt.embedded_types = py_bases_101; + static const char* py_bases_113[] = { "asyncio.proactor_events._ProactorBasePipeTransport", "transports.WriteTransport", NULL }; + rt.embedded_types = py_bases_113; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events._ProactorWritePipeTransport"; rt.short_name = "_ProactorWritePipeTransport"; - static const char* py_bases_102[] = { "asyncio.proactor_events._ProactorBaseWritePipeTransport", NULL }; - rt.embedded_types = py_bases_102; + static const char* py_bases_114[] = { "asyncio.proactor_events._ProactorBaseWritePipeTransport", NULL }; + rt.embedded_types = py_bases_114; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events._ProactorDuplexPipeTransport"; rt.short_name = "_ProactorDuplexPipeTransport"; - static const char* py_bases_103[] = { "asyncio.proactor_events._ProactorReadPipeTransport", "asyncio.proactor_events._ProactorBaseWritePipeTransport", "transports.Transport", NULL }; - rt.embedded_types = py_bases_103; + static const char* py_bases_115[] = { "asyncio.proactor_events._ProactorReadPipeTransport", "asyncio.proactor_events._ProactorBaseWritePipeTransport", "transports.Transport", NULL }; + rt.embedded_types = py_bases_115; cbm_registry_add_type(reg, rt); - static const char* py_methods_104[] = { "__init__", "can_write_eof", NULL }; + static const char* py_methods_116[] = { "__init__", "can_write_eof", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events._ProactorSocketTransport"; rt.short_name = "_ProactorSocketTransport"; - rt.method_names = py_methods_104; - static const char* py_bases_105[] = { "asyncio.proactor_events._ProactorReadPipeTransport", "asyncio.proactor_events._ProactorBaseWritePipeTransport", "transports.Transport", NULL }; - rt.embedded_types = py_bases_105; + rt.method_names = py_methods_116; + static const char* py_bases_117[] = { "asyncio.proactor_events._ProactorReadPipeTransport", "asyncio.proactor_events._ProactorBaseWritePipeTransport", "transports.Transport", NULL }; + rt.embedded_types = py_bases_117; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.proactor_events._ProactorSocketTransport.__init__"; @@ -1848,13 +2044,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "can_write_eof"; rf.receiver_type = "asyncio.proactor_events._ProactorSocketTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_106[] = { "__init__", "sock_recv", NULL }; + static const char* py_methods_118[] = { "__init__", "sock_recv", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.proactor_events.BaseProactorEventLoop"; rt.short_name = "BaseProactorEventLoop"; - rt.method_names = py_methods_106; - static const char* py_bases_107[] = { "base_events.BaseEventLoop", NULL }; - rt.embedded_types = py_bases_107; + rt.method_names = py_methods_118; + static const char* py_bases_119[] = { "base_events.BaseEventLoop", NULL }; + rt.embedded_types = py_bases_119; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.proactor_events.BaseProactorEventLoop.__init__"; @@ -1868,11 +2064,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.protocols ===== */ - static const char* py_methods_108[] = { "connection_made", "connection_lost", "pause_writing", "resume_writing", NULL }; + static const char* py_methods_120[] = { "connection_made", "connection_lost", "pause_writing", "resume_writing", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.protocols.BaseProtocol"; rt.short_name = "BaseProtocol"; - rt.method_names = py_methods_108; + rt.method_names = py_methods_120; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.protocols.BaseProtocol.connection_made"; @@ -1894,13 +2090,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "resume_writing"; rf.receiver_type = "asyncio.protocols.BaseProtocol"; cbm_registry_add_func(reg, rf); - static const char* py_methods_109[] = { "data_received", "eof_received", NULL }; + static const char* py_methods_121[] = { "data_received", "eof_received", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.protocols.Protocol"; rt.short_name = "Protocol"; - rt.method_names = py_methods_109; - static const char* py_bases_110[] = { "asyncio.protocols.BaseProtocol", NULL }; - rt.embedded_types = py_bases_110; + rt.method_names = py_methods_121; + static const char* py_bases_122[] = { "asyncio.protocols.BaseProtocol", NULL }; + rt.embedded_types = py_bases_122; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.protocols.Protocol.data_received"; @@ -1912,13 +2108,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "eof_received"; rf.receiver_type = "asyncio.protocols.Protocol"; cbm_registry_add_func(reg, rf); - static const char* py_methods_111[] = { "get_buffer", "buffer_updated", "eof_received", NULL }; + static const char* py_methods_123[] = { "get_buffer", "buffer_updated", "eof_received", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.protocols.BufferedProtocol"; rt.short_name = "BufferedProtocol"; - rt.method_names = py_methods_111; - static const char* py_bases_112[] = { "asyncio.protocols.BaseProtocol", NULL }; - rt.embedded_types = py_bases_112; + rt.method_names = py_methods_123; + static const char* py_bases_124[] = { "asyncio.protocols.BaseProtocol", NULL }; + rt.embedded_types = py_bases_124; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.protocols.BufferedProtocol.get_buffer"; @@ -1935,13 +2131,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "eof_received"; rf.receiver_type = "asyncio.protocols.BufferedProtocol"; cbm_registry_add_func(reg, rf); - static const char* py_methods_113[] = { "connection_made", "datagram_received", "error_received", NULL }; + static const char* py_methods_125[] = { "connection_made", "datagram_received", "error_received", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.protocols.DatagramProtocol"; rt.short_name = "DatagramProtocol"; - rt.method_names = py_methods_113; - static const char* py_bases_114[] = { "asyncio.protocols.BaseProtocol", NULL }; - rt.embedded_types = py_bases_114; + rt.method_names = py_methods_125; + static const char* py_bases_126[] = { "asyncio.protocols.BaseProtocol", NULL }; + rt.embedded_types = py_bases_126; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.protocols.DatagramProtocol.connection_made"; @@ -1958,13 +2154,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "error_received"; rf.receiver_type = "asyncio.protocols.DatagramProtocol"; cbm_registry_add_func(reg, rf); - static const char* py_methods_115[] = { "pipe_data_received", "pipe_connection_lost", "process_exited", NULL }; + static const char* py_methods_127[] = { "pipe_data_received", "pipe_connection_lost", "process_exited", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.protocols.SubprocessProtocol"; rt.short_name = "SubprocessProtocol"; - rt.method_names = py_methods_115; - static const char* py_bases_116[] = { "asyncio.protocols.BaseProtocol", NULL }; - rt.embedded_types = py_bases_116; + rt.method_names = py_methods_127; + static const char* py_bases_128[] = { "asyncio.protocols.BaseProtocol", NULL }; + rt.embedded_types = py_bases_128; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.protocols.SubprocessProtocol.pipe_data_received"; @@ -1986,28 +2182,28 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.queues.QueueEmpty"; rt.short_name = "QueueEmpty"; - static const char* py_bases_117[] = { "asyncio.queues.Exception", NULL }; - rt.embedded_types = py_bases_117; + static const char* py_bases_129[] = { "asyncio.queues.Exception", NULL }; + rt.embedded_types = py_bases_129; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.queues.QueueFull"; rt.short_name = "QueueFull"; - static const char* py_bases_118[] = { "asyncio.queues.Exception", NULL }; - rt.embedded_types = py_bases_118; + static const char* py_bases_130[] = { "asyncio.queues.Exception", NULL }; + rt.embedded_types = py_bases_130; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.queues.QueueShutDown"; rt.short_name = "QueueShutDown"; - static const char* py_bases_119[] = { "asyncio.queues.Exception", NULL }; - rt.embedded_types = py_bases_119; + static const char* py_bases_131[] = { "asyncio.queues.Exception", NULL }; + rt.embedded_types = py_bases_131; cbm_registry_add_type(reg, rt); - static const char* py_methods_120[] = { "__init__", "qsize", "maxsize", "empty", "full", "put", "put_nowait", "get", "get_nowait", "join", "task_done", "shutdown", NULL }; + static const char* py_methods_132[] = { "__init__", "qsize", "maxsize", "empty", "full", "put", "put_nowait", "get", "get_nowait", "join", "task_done", "shutdown", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.queues.Queue"; rt.short_name = "Queue"; - rt.method_names = py_methods_120; - static const char* py_bases_121[] = { "asyncio.queues._LoopBoundMixin", NULL }; - rt.embedded_types = py_bases_121; + rt.method_names = py_methods_132; + static const char* py_bases_133[] = { "asyncio.queues._LoopBoundMixin", NULL }; + rt.embedded_types = py_bases_133; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.queues.Queue.__init__"; @@ -2079,11 +2275,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_type(reg, rt); /* ===== module: asyncio.runners ===== */ - static const char* py_methods_122[] = { "__init__", "__enter__", "__exit__", "close", "get_loop", "run", NULL }; + static const char* py_methods_134[] = { "__init__", "__enter__", "__exit__", "close", "get_loop", "run", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.runners.Runner"; rt.short_name = "Runner"; - rt.method_names = py_methods_122; + rt.method_names = py_methods_134; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.runners.Runner.__init__"; @@ -2121,13 +2317,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.selector_events ===== */ - static const char* py_methods_123[] = { "__init__", "sock_recv", NULL }; + static const char* py_methods_135[] = { "__init__", "sock_recv", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.selector_events.BaseSelectorEventLoop"; rt.short_name = "BaseSelectorEventLoop"; - rt.method_names = py_methods_123; - static const char* py_bases_124[] = { "base_events.BaseEventLoop", NULL }; - rt.embedded_types = py_bases_124; + rt.method_names = py_methods_135; + static const char* py_bases_136[] = { "base_events.BaseEventLoop", NULL }; + rt.embedded_types = py_bases_136; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.selector_events.BaseSelectorEventLoop.__init__"; @@ -2144,20 +2340,20 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.sslproto.SSLProtocolState"; rt.short_name = "SSLProtocolState"; - static const char* py_bases_125[] = { "asyncio.sslproto.Enum", NULL }; - rt.embedded_types = py_bases_125; + static const char* py_bases_137[] = { "asyncio.sslproto.Enum", NULL }; + rt.embedded_types = py_bases_137; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.sslproto.AppProtocolState"; rt.short_name = "AppProtocolState"; - static const char* py_bases_126[] = { "asyncio.sslproto.Enum", NULL }; - rt.embedded_types = py_bases_126; + static const char* py_bases_138[] = { "asyncio.sslproto.Enum", NULL }; + rt.embedded_types = py_bases_138; cbm_registry_add_type(reg, rt); - static const char* py_methods_127[] = { "__init__", "context", "ssl_object", "need_ssldata", "wrapped", "do_handshake", "shutdown", "feed_eof", "feed_ssldata", "feed_appdata", NULL }; + static const char* py_methods_139[] = { "__init__", "context", "ssl_object", "need_ssldata", "wrapped", "do_handshake", "shutdown", "feed_eof", "feed_ssldata", "feed_appdata", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.sslproto._SSLPipe"; rt.short_name = "_SSLPipe"; - rt.method_names = py_methods_127; + rt.method_names = py_methods_139; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.sslproto._SSLPipe.__init__"; @@ -2209,13 +2405,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "feed_appdata"; rf.receiver_type = "asyncio.sslproto._SSLPipe"; cbm_registry_add_func(reg, rf); - static const char* py_methods_128[] = { "__init__", "get_extra_info", "write", "can_write_eof", "get_write_buffer_limits", "get_read_buffer_limits", "set_read_buffer_limits", "get_read_buffer_size", NULL }; + static const char* py_methods_140[] = { "__init__", "get_extra_info", "write", "can_write_eof", "get_write_buffer_limits", "get_read_buffer_limits", "set_read_buffer_limits", "get_read_buffer_size", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.sslproto._SSLProtocolTransport"; rt.short_name = "_SSLProtocolTransport"; - rt.method_names = py_methods_128; - static const char* py_bases_129[] = { "transports._FlowControlMixin", "transports.Transport", NULL }; - rt.embedded_types = py_bases_129; + rt.method_names = py_methods_140; + static const char* py_bases_141[] = { "transports._FlowControlMixin", "transports.Transport", NULL }; + rt.embedded_types = py_bases_141; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.__init__"; @@ -2257,13 +2453,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "get_read_buffer_size"; rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_130[] = { "__init__", "connection_lost", "eof_received", "_write_appdata", "_abort", "get_buffer", "_finalize", "_process_write_backlog", NULL }; + static const char* py_methods_142[] = { "__init__", "connection_lost", "eof_received", "_write_appdata", "_abort", "get_buffer", "_finalize", "_process_write_backlog", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.sslproto.SSLProtocol"; rt.short_name = "SSLProtocol"; - rt.method_names = py_methods_130; - static const char* py_bases_131[] = { "asyncio.sslproto._SSLProtocolBase", NULL }; - rt.embedded_types = py_bases_131; + rt.method_names = py_methods_142; + static const char* py_bases_143[] = { "asyncio.sslproto._SSLProtocolBase", NULL }; + rt.embedded_types = py_bases_143; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.sslproto.SSLProtocol.__init__"; @@ -2320,40 +2516,40 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.streams._ReaduntilBuffer"; rt.short_name = "_ReaduntilBuffer"; - static const char* py_bases_132[] = { "asyncio.streams.ReadableBuffer", "asyncio.streams.Sized", "asyncio.streams.Protocol", NULL }; - rt.embedded_types = py_bases_132; + static const char* py_bases_144[] = { "asyncio.streams.ReadableBuffer", "asyncio.streams.Sized", "asyncio.streams.Protocol", NULL }; + rt.embedded_types = py_bases_144; cbm_registry_add_type(reg, rt); - static const char* py_methods_133[] = { "__init__", NULL }; + static const char* py_methods_145[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.streams.FlowControlMixin"; rt.short_name = "FlowControlMixin"; - rt.method_names = py_methods_133; - static const char* py_bases_134[] = { "protocols.Protocol", NULL }; - rt.embedded_types = py_bases_134; + rt.method_names = py_methods_145; + static const char* py_bases_146[] = { "protocols.Protocol", NULL }; + rt.embedded_types = py_bases_146; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.streams.FlowControlMixin.__init__"; rf.short_name = "__init__"; rf.receiver_type = "asyncio.streams.FlowControlMixin"; cbm_registry_add_func(reg, rf); - static const char* py_methods_135[] = { "__init__", NULL }; + static const char* py_methods_147[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.streams.StreamReaderProtocol"; rt.short_name = "StreamReaderProtocol"; - rt.method_names = py_methods_135; - static const char* py_bases_136[] = { "asyncio.streams.FlowControlMixin", "protocols.Protocol", NULL }; - rt.embedded_types = py_bases_136; + rt.method_names = py_methods_147; + static const char* py_bases_148[] = { "asyncio.streams.FlowControlMixin", "protocols.Protocol", NULL }; + rt.embedded_types = py_bases_148; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.streams.StreamReaderProtocol.__init__"; rf.short_name = "__init__"; rf.receiver_type = "asyncio.streams.StreamReaderProtocol"; cbm_registry_add_func(reg, rf); - static const char* py_methods_137[] = { "__init__", "transport", "write", "writelines", "write_eof", "can_write_eof", "close", "is_closing", "wait_closed", "get_extra_info", "drain", "start_tls", "__del__", NULL }; + static const char* py_methods_149[] = { "__init__", "transport", "write", "writelines", "write_eof", "can_write_eof", "close", "is_closing", "wait_closed", "get_extra_info", "drain", "start_tls", "__del__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.streams.StreamWriter"; rt.short_name = "StreamWriter"; - rt.method_names = py_methods_137; + rt.method_names = py_methods_149; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.streams.StreamWriter.__init__"; @@ -2420,11 +2616,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__del__"; rf.receiver_type = "asyncio.streams.StreamWriter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_138[] = { "__init__", "exception", "set_exception", "set_transport", "feed_eof", "at_eof", "feed_data", "readline", "readuntil", "read", "readexactly", NULL }; + static const char* py_methods_150[] = { "__init__", "exception", "set_exception", "set_transport", "feed_eof", "at_eof", "feed_data", "readline", "readuntil", "read", "readexactly", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.streams.StreamReader"; rt.short_name = "StreamReader"; - rt.method_names = py_methods_138; + rt.method_names = py_methods_150; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.streams.StreamReader.__init__"; @@ -2499,13 +2695,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.subprocess ===== */ - static const char* py_methods_139[] = { "__init__", "pipe_data_received", NULL }; + static const char* py_methods_151[] = { "__init__", "pipe_data_received", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.subprocess.SubprocessStreamProtocol"; rt.short_name = "SubprocessStreamProtocol"; - rt.method_names = py_methods_139; - static const char* py_bases_140[] = { "streams.FlowControlMixin", "protocols.SubprocessProtocol", NULL }; - rt.embedded_types = py_bases_140; + rt.method_names = py_methods_151; + static const char* py_bases_152[] = { "streams.FlowControlMixin", "protocols.SubprocessProtocol", NULL }; + rt.embedded_types = py_bases_152; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.subprocess.SubprocessStreamProtocol.__init__"; @@ -2517,11 +2713,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "pipe_data_received"; rf.receiver_type = "asyncio.subprocess.SubprocessStreamProtocol"; cbm_registry_add_func(reg, rf); - static const char* py_methods_141[] = { "__init__", "returncode", "wait", "send_signal", "terminate", "kill", "communicate", NULL }; + static const char* py_methods_153[] = { "__init__", "returncode", "wait", "send_signal", "terminate", "kill", "communicate", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.subprocess.Process"; rt.short_name = "Process"; - rt.method_names = py_methods_141; + rt.method_names = py_methods_153; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.subprocess.Process.__init__"; @@ -2568,11 +2764,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.taskgroups ===== */ - static const char* py_methods_142[] = { "create_task", NULL }; + static const char* py_methods_154[] = { "create_task", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.taskgroups.TaskGroup"; rt.short_name = "TaskGroup"; - rt.method_names = py_methods_142; + rt.method_names = py_methods_154; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.taskgroups.TaskGroup.create_task"; @@ -2585,22 +2781,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "asyncio.tasks._SyncAndAsyncIterator"; rt.short_name = "_SyncAndAsyncIterator"; cbm_registry_add_type(reg, rt); - static const char* py_methods_143[] = { "__call__", NULL }; + static const char* py_methods_155[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tasks._CustomTaskConstructor"; rt.short_name = "_CustomTaskConstructor"; - rt.method_names = py_methods_143; + rt.method_names = py_methods_155; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.tasks._CustomTaskConstructor.__call__"; rf.short_name = "__call__"; rf.receiver_type = "asyncio.tasks._CustomTaskConstructor"; cbm_registry_add_func(reg, rf); - static const char* py_methods_144[] = { "__call__", NULL }; + static const char* py_methods_156[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tasks._EagerTaskFactoryType"; rt.short_name = "_EagerTaskFactoryType"; - rt.method_names = py_methods_144; + rt.method_names = py_methods_156; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.tasks._EagerTaskFactoryType.__call__"; @@ -2667,11 +2863,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.timeouts ===== */ - static const char* py_methods_145[] = { "__init__", "when", "reschedule", "expired", NULL }; + static const char* py_methods_157[] = { "__init__", "when", "reschedule", "expired", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.timeouts.Timeout"; rt.short_name = "Timeout"; - rt.method_names = py_methods_145; + rt.method_names = py_methods_157; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.timeouts.Timeout.__init__"; @@ -2706,40 +2902,40 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tools._AwaitedInfo"; rt.short_name = "_AwaitedInfo"; - static const char* py_bases_146[] = { "asyncio.tools.NamedTuple", NULL }; - rt.embedded_types = py_bases_146; + static const char* py_bases_158[] = { "asyncio.tools.NamedTuple", NULL }; + rt.embedded_types = py_bases_158; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tools._TaskInfo"; rt.short_name = "_TaskInfo"; - static const char* py_bases_147[] = { "asyncio.tools.NamedTuple", NULL }; - rt.embedded_types = py_bases_147; + static const char* py_bases_159[] = { "asyncio.tools.NamedTuple", NULL }; + rt.embedded_types = py_bases_159; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tools._CoroInfo"; rt.short_name = "_CoroInfo"; - static const char* py_bases_148[] = { "asyncio.tools.NamedTuple", NULL }; - rt.embedded_types = py_bases_148; + static const char* py_bases_160[] = { "asyncio.tools.NamedTuple", NULL }; + rt.embedded_types = py_bases_160; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tools._FrameInfo"; rt.short_name = "_FrameInfo"; - static const char* py_bases_149[] = { "asyncio.tools.NamedTuple", NULL }; - rt.embedded_types = py_bases_149; + static const char* py_bases_161[] = { "asyncio.tools.NamedTuple", NULL }; + rt.embedded_types = py_bases_161; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tools.NodeType"; rt.short_name = "NodeType"; - static const char* py_bases_150[] = { "asyncio.tools.Enum", NULL }; - rt.embedded_types = py_bases_150; + static const char* py_bases_162[] = { "asyncio.tools.Enum", NULL }; + rt.embedded_types = py_bases_162; cbm_registry_add_type(reg, rt); - static const char* py_methods_151[] = { "__init__", NULL }; + static const char* py_methods_163[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.tools.CycleFoundException"; rt.short_name = "CycleFoundException"; - rt.method_names = py_methods_151; - static const char* py_bases_152[] = { "asyncio.tools.Exception", NULL }; - rt.embedded_types = py_bases_152; + rt.method_names = py_methods_163; + static const char* py_bases_164[] = { "asyncio.tools.Exception", NULL }; + rt.embedded_types = py_bases_164; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.tools.CycleFoundException.__init__"; @@ -2772,11 +2968,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.transports ===== */ - static const char* py_methods_153[] = { "__init__", "get_extra_info", "is_closing", "close", "set_protocol", "get_protocol", NULL }; + static const char* py_methods_165[] = { "__init__", "get_extra_info", "is_closing", "close", "set_protocol", "get_protocol", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports.BaseTransport"; rt.short_name = "BaseTransport"; - rt.method_names = py_methods_153; + rt.method_names = py_methods_165; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.transports.BaseTransport.__init__"; @@ -2808,13 +3004,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "get_protocol"; rf.receiver_type = "asyncio.transports.BaseTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_154[] = { "is_reading", "pause_reading", "resume_reading", NULL }; + static const char* py_methods_166[] = { "is_reading", "pause_reading", "resume_reading", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports.ReadTransport"; rt.short_name = "ReadTransport"; - rt.method_names = py_methods_154; - static const char* py_bases_155[] = { "asyncio.transports.BaseTransport", NULL }; - rt.embedded_types = py_bases_155; + rt.method_names = py_methods_166; + static const char* py_bases_167[] = { "asyncio.transports.BaseTransport", NULL }; + rt.embedded_types = py_bases_167; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.transports.ReadTransport.is_reading"; @@ -2831,13 +3027,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "resume_reading"; rf.receiver_type = "asyncio.transports.ReadTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_156[] = { "set_write_buffer_limits", "get_write_buffer_size", "get_write_buffer_limits", "write", "writelines", "write_eof", "can_write_eof", "abort", NULL }; + static const char* py_methods_168[] = { "set_write_buffer_limits", "get_write_buffer_size", "get_write_buffer_limits", "write", "writelines", "write_eof", "can_write_eof", "abort", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports.WriteTransport"; rt.short_name = "WriteTransport"; - rt.method_names = py_methods_156; - static const char* py_bases_157[] = { "asyncio.transports.BaseTransport", NULL }; - rt.embedded_types = py_bases_157; + rt.method_names = py_methods_168; + static const char* py_bases_169[] = { "asyncio.transports.BaseTransport", NULL }; + rt.embedded_types = py_bases_169; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.transports.WriteTransport.set_write_buffer_limits"; @@ -2882,16 +3078,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports.Transport"; rt.short_name = "Transport"; - static const char* py_bases_158[] = { "asyncio.transports.ReadTransport", "asyncio.transports.WriteTransport", NULL }; - rt.embedded_types = py_bases_158; + static const char* py_bases_170[] = { "asyncio.transports.ReadTransport", "asyncio.transports.WriteTransport", NULL }; + rt.embedded_types = py_bases_170; cbm_registry_add_type(reg, rt); - static const char* py_methods_159[] = { "sendto", "abort", NULL }; + static const char* py_methods_171[] = { "sendto", "abort", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports.DatagramTransport"; rt.short_name = "DatagramTransport"; - rt.method_names = py_methods_159; - static const char* py_bases_160[] = { "asyncio.transports.BaseTransport", NULL }; - rt.embedded_types = py_bases_160; + rt.method_names = py_methods_171; + static const char* py_bases_172[] = { "asyncio.transports.BaseTransport", NULL }; + rt.embedded_types = py_bases_172; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.transports.DatagramTransport.sendto"; @@ -2903,13 +3099,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "abort"; rf.receiver_type = "asyncio.transports.DatagramTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_161[] = { "get_pid", "get_returncode", "get_pipe_transport", "send_signal", "terminate", "kill", NULL }; + static const char* py_methods_173[] = { "get_pid", "get_returncode", "get_pipe_transport", "send_signal", "terminate", "kill", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports.SubprocessTransport"; rt.short_name = "SubprocessTransport"; - rt.method_names = py_methods_161; - static const char* py_bases_162[] = { "asyncio.transports.BaseTransport", NULL }; - rt.embedded_types = py_bases_162; + rt.method_names = py_methods_173; + static const char* py_bases_174[] = { "asyncio.transports.BaseTransport", NULL }; + rt.embedded_types = py_bases_174; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.transports.SubprocessTransport.get_pid"; @@ -2941,13 +3137,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "kill"; rf.receiver_type = "asyncio.transports.SubprocessTransport"; cbm_registry_add_func(reg, rf); - static const char* py_methods_163[] = { "__init__", NULL }; + static const char* py_methods_175[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.transports._FlowControlMixin"; rt.short_name = "_FlowControlMixin"; - rt.method_names = py_methods_163; - static const char* py_bases_164[] = { "asyncio.transports.Transport", NULL }; - rt.embedded_types = py_bases_164; + rt.method_names = py_methods_175; + static const char* py_bases_176[] = { "asyncio.transports.Transport", NULL }; + rt.embedded_types = py_bases_176; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.transports._FlowControlMixin.__init__"; @@ -2956,11 +3152,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.trsock ===== */ - static const char* py_methods_165[] = { "__init__", "family", "type", "proto", "fileno", "dup", "get_inheritable", "shutdown", "getsockopt", "setsockopt", "getpeername", "getsockname", "getsockbyname", "settimeout", "gettimeout", "setblocking", "_na", "accept", "connect", "connect_ex", "bind", "listen", "makefile", "sendfile", "close", "detach", "sendmsg", "sendto", "send", "sendall", "set_inheritable", "recv_into", "recvfrom_into", "recvmsg_into", "recvmsg", "recvfrom", "recv", "__enter__", "__exit__", NULL }; + static const char* py_methods_177[] = { "__init__", "family", "type", "proto", "fileno", "dup", "get_inheritable", "shutdown", "getsockopt", "setsockopt", "getpeername", "getsockname", "getsockbyname", "settimeout", "gettimeout", "setblocking", "_na", "accept", "connect", "connect_ex", "bind", "listen", "makefile", "sendfile", "close", "detach", "sendmsg", "sendto", "send", "sendall", "set_inheritable", "recv_into", "recvfrom_into", "recvmsg_into", "recvmsg", "recvfrom", "recv", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.trsock.TransportSocket"; rt.short_name = "TransportSocket"; - rt.method_names = py_methods_165; + rt.method_names = py_methods_177; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.trsock.TransportSocket.__init__"; @@ -3159,225 +3355,146 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.unix_events ===== */ - static const char* py_methods_166[] = { "add_child_handler", "remove_child_handler", "attach_loop", "close", "__enter__", "__exit__", "is_active", NULL }; + static const char* py_methods_178[] = { "add_child_handler", "remove_child_handler", "attach_loop", "close", "__enter__", "__exit__", "is_active", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.AbstractChildWatcher"; rt.short_name = "AbstractChildWatcher"; - rt.method_names = py_methods_166; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.add_child_handler"; - rf.short_name = "add_child_handler"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.remove_child_handler"; - rf.short_name = "remove_child_handler"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.attach_loop"; - rf.short_name = "attach_loop"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.close"; - rf.short_name = "close"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__enter__"; - rf.short_name = "__enter__"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__exit__"; - rf.short_name = "__exit__"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.is_active"; - rf.short_name = "is_active"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_167[] = { "add_child_handler", "remove_child_handler", "attach_loop", "close", "__enter__", "__exit__", "is_active", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.AbstractChildWatcher"; - rt.short_name = "AbstractChildWatcher"; - rt.method_names = py_methods_167; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.add_child_handler"; - rf.short_name = "add_child_handler"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.remove_child_handler"; - rf.short_name = "remove_child_handler"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.attach_loop"; - rf.short_name = "attach_loop"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.close"; - rf.short_name = "close"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__enter__"; - rf.short_name = "__enter__"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__exit__"; - rf.short_name = "__exit__"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.is_active"; - rf.short_name = "is_active"; - rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_168[] = { "close", "is_active", "attach_loop", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.BaseChildWatcher"; - rt.short_name = "BaseChildWatcher"; - rt.method_names = py_methods_168; - static const char* py_bases_169[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_169; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.close"; - rf.short_name = "close"; - rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.is_active"; - rf.short_name = "is_active"; - rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.attach_loop"; - rf.short_name = "attach_loop"; - rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_170[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.SafeChildWatcher"; - rt.short_name = "SafeChildWatcher"; - rt.method_names = py_methods_170; - static const char* py_bases_171[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; - rt.embedded_types = py_bases_171; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__enter__"; - rf.short_name = "__enter__"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__exit__"; - rf.short_name = "__exit__"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.add_child_handler"; - rf.short_name = "add_child_handler"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.remove_child_handler"; - rf.short_name = "remove_child_handler"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_172[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.FastChildWatcher"; - rt.short_name = "FastChildWatcher"; - rt.method_names = py_methods_172; - static const char* py_bases_173[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; - rt.embedded_types = py_bases_173; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__enter__"; - rf.short_name = "__enter__"; - rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__exit__"; - rf.short_name = "__exit__"; - rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.FastChildWatcher.add_child_handler"; - rf.short_name = "add_child_handler"; - rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.FastChildWatcher.remove_child_handler"; - rf.short_name = "remove_child_handler"; - rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_174[] = { "close", "is_active", "attach_loop", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.BaseChildWatcher"; - rt.short_name = "BaseChildWatcher"; - rt.method_names = py_methods_174; - static const char* py_bases_175[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_175; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.close"; - rf.short_name = "close"; - rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.is_active"; - rf.short_name = "is_active"; - rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.attach_loop"; - rf.short_name = "attach_loop"; - rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_176[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.SafeChildWatcher"; - rt.short_name = "SafeChildWatcher"; - rt.method_names = py_methods_176; - static const char* py_bases_177[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; - rt.embedded_types = py_bases_177; - cbm_registry_add_type(reg, rt); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__enter__"; - rf.short_name = "__enter__"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__exit__"; - rf.short_name = "__exit__"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.add_child_handler"; - rf.short_name = "add_child_handler"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - memset(&rf, 0, sizeof(rf)); - rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.remove_child_handler"; - rf.short_name = "remove_child_handler"; - rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; - cbm_registry_add_func(reg, rf); - static const char* py_methods_178[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "asyncio.unix_events.FastChildWatcher"; - rt.short_name = "FastChildWatcher"; rt.method_names = py_methods_178; - static const char* py_bases_179[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; - rt.embedded_types = py_bases_179; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.add_child_handler"; + rf.short_name = "add_child_handler"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.remove_child_handler"; + rf.short_name = "remove_child_handler"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.attach_loop"; + rf.short_name = "attach_loop"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.close"; + rf.short_name = "close"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.is_active"; + rf.short_name = "is_active"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_179[] = { "add_child_handler", "remove_child_handler", "attach_loop", "close", "__enter__", "__exit__", "is_active", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.AbstractChildWatcher"; + rt.short_name = "AbstractChildWatcher"; + rt.method_names = py_methods_179; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.add_child_handler"; + rf.short_name = "add_child_handler"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.remove_child_handler"; + rf.short_name = "remove_child_handler"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.attach_loop"; + rf.short_name = "attach_loop"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.close"; + rf.short_name = "close"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.is_active"; + rf.short_name = "is_active"; + rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_180[] = { "close", "is_active", "attach_loop", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.BaseChildWatcher"; + rt.short_name = "BaseChildWatcher"; + rt.method_names = py_methods_180; + static const char* py_bases_181[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_181; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.close"; + rf.short_name = "close"; + rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.is_active"; + rf.short_name = "is_active"; + rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.attach_loop"; + rf.short_name = "attach_loop"; + rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_182[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.SafeChildWatcher"; + rt.short_name = "SafeChildWatcher"; + rt.method_names = py_methods_182; + static const char* py_bases_183[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; + rt.embedded_types = py_bases_183; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.add_child_handler"; + rf.short_name = "add_child_handler"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.remove_child_handler"; + rf.short_name = "remove_child_handler"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_184[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.FastChildWatcher"; + rt.short_name = "FastChildWatcher"; + rt.method_names = py_methods_184; + static const char* py_bases_185[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; + rt.embedded_types = py_bases_185; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__enter__"; @@ -3399,13 +3516,92 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "remove_child_handler"; rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_180[] = { "create_unix_server", NULL }; + static const char* py_methods_186[] = { "close", "is_active", "attach_loop", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.BaseChildWatcher"; + rt.short_name = "BaseChildWatcher"; + rt.method_names = py_methods_186; + static const char* py_bases_187[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_187; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.close"; + rf.short_name = "close"; + rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.is_active"; + rf.short_name = "is_active"; + rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.attach_loop"; + rf.short_name = "attach_loop"; + rf.receiver_type = "asyncio.unix_events.BaseChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_188[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.SafeChildWatcher"; + rt.short_name = "SafeChildWatcher"; + rt.method_names = py_methods_188; + static const char* py_bases_189[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; + rt.embedded_types = py_bases_189; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.add_child_handler"; + rf.short_name = "add_child_handler"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.remove_child_handler"; + rf.short_name = "remove_child_handler"; + rf.receiver_type = "asyncio.unix_events.SafeChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_190[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "asyncio.unix_events.FastChildWatcher"; + rt.short_name = "FastChildWatcher"; + rt.method_names = py_methods_190; + static const char* py_bases_191[] = { "asyncio.unix_events.BaseChildWatcher", NULL }; + rt.embedded_types = py_bases_191; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.FastChildWatcher.add_child_handler"; + rf.short_name = "add_child_handler"; + rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "asyncio.unix_events.FastChildWatcher.remove_child_handler"; + rf.short_name = "remove_child_handler"; + rf.receiver_type = "asyncio.unix_events.FastChildWatcher"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_192[] = { "create_unix_server", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events._UnixSelectorEventLoop"; rt.short_name = "_UnixSelectorEventLoop"; - rt.method_names = py_methods_180; - static const char* py_bases_181[] = { "asyncio.unix_events.BaseSelectorEventLoop", NULL }; - rt.embedded_types = py_bases_181; + rt.method_names = py_methods_192; + static const char* py_bases_193[] = { "asyncio.unix_events.BaseSelectorEventLoop", NULL }; + rt.embedded_types = py_bases_193; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events._UnixSelectorEventLoop.create_unix_server"; @@ -3415,16 +3611,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy"; rt.short_name = "_UnixDefaultEventLoopPolicy"; - static const char* py_bases_182[] = { "events._BaseDefaultEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_182; + static const char* py_bases_194[] = { "events._BaseDefaultEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_194; cbm_registry_add_type(reg, rt); - static const char* py_methods_183[] = { "get_child_watcher", "set_child_watcher", NULL }; + static const char* py_methods_195[] = { "get_child_watcher", "set_child_watcher", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy"; rt.short_name = "_UnixDefaultEventLoopPolicy"; - rt.method_names = py_methods_183; - static const char* py_bases_184[] = { "events.BaseDefaultEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_184; + rt.method_names = py_methods_195; + static const char* py_bases_196[] = { "events.BaseDefaultEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_196; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy.get_child_watcher"; @@ -3436,13 +3632,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "set_child_watcher"; rf.receiver_type = "asyncio.unix_events._UnixDefaultEventLoopPolicy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_185[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; + static const char* py_methods_197[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher"; rt.short_name = "MultiLoopChildWatcher"; - rt.method_names = py_methods_185; - static const char* py_bases_186[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_186; + rt.method_names = py_methods_197; + static const char* py_bases_198[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_198; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.is_active"; @@ -3479,13 +3675,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "attach_loop"; rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_187[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; + static const char* py_methods_199[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.ThreadedChildWatcher"; rt.short_name = "ThreadedChildWatcher"; - rt.method_names = py_methods_187; - static const char* py_bases_188[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_188; + rt.method_names = py_methods_199; + static const char* py_bases_200[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_200; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.is_active"; @@ -3522,13 +3718,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "attach_loop"; rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_189[] = { "__enter__", "__exit__", "is_active", "close", "attach_loop", "add_child_handler", "remove_child_handler", NULL }; + static const char* py_methods_201[] = { "__enter__", "__exit__", "is_active", "close", "attach_loop", "add_child_handler", "remove_child_handler", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.PidfdChildWatcher"; rt.short_name = "PidfdChildWatcher"; - rt.method_names = py_methods_189; - static const char* py_bases_190[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_190; + rt.method_names = py_methods_201; + static const char* py_bases_202[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_202; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.__enter__"; @@ -3565,13 +3761,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "remove_child_handler"; rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_191[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; + static const char* py_methods_203[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher"; rt.short_name = "MultiLoopChildWatcher"; - rt.method_names = py_methods_191; - static const char* py_bases_192[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_192; + rt.method_names = py_methods_203; + static const char* py_bases_204[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_204; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.is_active"; @@ -3608,13 +3804,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "attach_loop"; rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_193[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; + static const char* py_methods_205[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.ThreadedChildWatcher"; rt.short_name = "ThreadedChildWatcher"; - rt.method_names = py_methods_193; - static const char* py_bases_194[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_194; + rt.method_names = py_methods_205; + static const char* py_bases_206[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_206; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.is_active"; @@ -3651,13 +3847,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "attach_loop"; rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_195[] = { "__enter__", "__exit__", "is_active", "close", "attach_loop", "add_child_handler", "remove_child_handler", NULL }; + static const char* py_methods_207[] = { "__enter__", "__exit__", "is_active", "close", "attach_loop", "add_child_handler", "remove_child_handler", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.unix_events.PidfdChildWatcher"; rt.short_name = "PidfdChildWatcher"; - rt.method_names = py_methods_195; - static const char* py_bases_196[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; - rt.embedded_types = py_bases_196; + rt.method_names = py_methods_207; + static const char* py_bases_208[] = { "asyncio.unix_events.AbstractChildWatcher", NULL }; + rt.embedded_types = py_bases_208; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.__enter__"; @@ -3696,11 +3892,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.windows_events ===== */ - static const char* py_methods_197[] = { "__init__", "closed", "close", NULL }; + static const char* py_methods_209[] = { "__init__", "closed", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events.PipeServer"; rt.short_name = "PipeServer"; - rt.method_names = py_methods_197; + rt.method_names = py_methods_209; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_events.PipeServer.__init__"; @@ -3720,16 +3916,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events._WindowsSelectorEventLoop"; rt.short_name = "_WindowsSelectorEventLoop"; - static const char* py_bases_198[] = { "selector_events.BaseSelectorEventLoop", NULL }; - rt.embedded_types = py_bases_198; + static const char* py_bases_210[] = { "selector_events.BaseSelectorEventLoop", NULL }; + rt.embedded_types = py_bases_210; cbm_registry_add_type(reg, rt); - static const char* py_methods_199[] = { "__init__", "create_pipe_connection", "start_serving_pipe", NULL }; + static const char* py_methods_211[] = { "__init__", "create_pipe_connection", "start_serving_pipe", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events.ProactorEventLoop"; rt.short_name = "ProactorEventLoop"; - rt.method_names = py_methods_199; - static const char* py_bases_200[] = { "proactor_events.BaseProactorEventLoop", NULL }; - rt.embedded_types = py_bases_200; + rt.method_names = py_methods_211; + static const char* py_bases_212[] = { "proactor_events.BaseProactorEventLoop", NULL }; + rt.embedded_types = py_bases_212; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_events.ProactorEventLoop.__init__"; @@ -3746,11 +3942,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "start_serving_pipe"; rf.receiver_type = "asyncio.windows_events.ProactorEventLoop"; cbm_registry_add_func(reg, rf); - static const char* py_methods_201[] = { "__init__", "set_loop", "select", "recv", "recv_into", "recvfrom", "sendto", "send", "accept", "connect", "sendfile", "accept_pipe", "connect_pipe", "wait_for_handle", "close", "recvfrom_into", NULL }; + static const char* py_methods_213[] = { "__init__", "set_loop", "select", "recv", "recv_into", "recvfrom", "sendto", "send", "accept", "connect", "sendfile", "accept_pipe", "connect_pipe", "wait_for_handle", "close", "recvfrom_into", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events.IocpProactor"; rt.short_name = "IocpProactor"; - rt.method_names = py_methods_201; + rt.method_names = py_methods_213; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_events.IocpProactor.__init__"; @@ -3835,22 +4031,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events._WindowsSelectorEventLoopPolicy"; rt.short_name = "_WindowsSelectorEventLoopPolicy"; - static const char* py_bases_202[] = { "events._BaseDefaultEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_202; + static const char* py_bases_214[] = { "events._BaseDefaultEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_214; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events._WindowsProactorEventLoopPolicy"; rt.short_name = "_WindowsProactorEventLoopPolicy"; - static const char* py_bases_203[] = { "events._BaseDefaultEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_203; + static const char* py_bases_215[] = { "events._BaseDefaultEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_215; cbm_registry_add_type(reg, rt); - static const char* py_methods_204[] = { "get_child_watcher", "set_child_watcher", NULL }; + static const char* py_methods_216[] = { "get_child_watcher", "set_child_watcher", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events.WindowsSelectorEventLoopPolicy"; rt.short_name = "WindowsSelectorEventLoopPolicy"; - rt.method_names = py_methods_204; - static const char* py_bases_205[] = { "events.BaseDefaultEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_205; + rt.method_names = py_methods_216; + static const char* py_bases_217[] = { "events.BaseDefaultEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_217; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_events.WindowsSelectorEventLoopPolicy.get_child_watcher"; @@ -3862,13 +4058,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "set_child_watcher"; rf.receiver_type = "asyncio.windows_events.WindowsSelectorEventLoopPolicy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_206[] = { "get_child_watcher", "set_child_watcher", NULL }; + static const char* py_methods_218[] = { "get_child_watcher", "set_child_watcher", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_events.WindowsProactorEventLoopPolicy"; rt.short_name = "WindowsProactorEventLoopPolicy"; - rt.method_names = py_methods_206; - static const char* py_bases_207[] = { "events.BaseDefaultEventLoopPolicy", NULL }; - rt.embedded_types = py_bases_207; + rt.method_names = py_methods_218; + static const char* py_bases_219[] = { "events.BaseDefaultEventLoopPolicy", NULL }; + rt.embedded_types = py_bases_219; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_events.WindowsProactorEventLoopPolicy.get_child_watcher"; @@ -3882,11 +4078,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: asyncio.windows_utils ===== */ - static const char* py_methods_208[] = { "__init__", "__enter__", "__exit__", "handle", "fileno", "close", NULL }; + static const char* py_methods_220[] = { "__init__", "__enter__", "__exit__", "handle", "fileno", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_utils.PipeHandle"; rt.short_name = "PipeHandle"; - rt.method_names = py_methods_208; + rt.method_names = py_methods_220; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_utils.PipeHandle.__init__"; @@ -3918,11 +4114,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "close"; rf.receiver_type = "asyncio.windows_utils.PipeHandle"; cbm_registry_add_func(reg, rf); - static const char* py_methods_209[] = { "__init__", NULL }; + static const char* py_methods_221[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "asyncio.windows_utils.Popen"; rt.short_name = "Popen"; - rt.method_names = py_methods_209; + rt.method_names = py_methods_221; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "asyncio.windows_utils.Popen.__init__"; @@ -3935,11 +4131,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: builtins ===== */ - static const char* py_methods_210[] = { "__init__", "__getstate__", NULL }; + static const char* py_methods_222[] = { "__init__", "__getstate__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.object"; rt.short_name = "object"; - rt.method_names = py_methods_210; + rt.method_names = py_methods_222; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.object.__init__"; @@ -3951,11 +4147,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__getstate__"; rf.receiver_type = "builtins.object"; cbm_registry_add_func(reg, rf); - static const char* py_methods_211[] = { "__init__", "__call__", "__class_getitem__", NULL }; + static const char* py_methods_223[] = { "__init__", "__call__", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.staticmethod"; rt.short_name = "staticmethod"; - rt.method_names = py_methods_211; + rt.method_names = py_methods_223; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.staticmethod.__init__"; @@ -3972,11 +4168,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__class_getitem__"; rf.receiver_type = "builtins.staticmethod"; cbm_registry_add_func(reg, rf); - static const char* py_methods_212[] = { "__init__", "__class_getitem__", NULL }; + static const char* py_methods_224[] = { "__init__", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.classmethod"; rt.short_name = "classmethod"; - rt.method_names = py_methods_212; + rt.method_names = py_methods_224; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.classmethod.__init__"; @@ -3988,11 +4184,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__class_getitem__"; rf.receiver_type = "builtins.classmethod"; cbm_registry_add_func(reg, rf); - static const char* py_methods_213[] = { "__init__", "__call__", "mro", NULL }; + static const char* py_methods_225[] = { "__init__", "__call__", "mro", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.type"; rt.short_name = "type"; - rt.method_names = py_methods_213; + rt.method_names = py_methods_225; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.type.__init__"; @@ -4009,22 +4205,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "mro"; rf.receiver_type = "builtins.type"; cbm_registry_add_func(reg, rf); - static const char* py_methods_214[] = { "__init__", NULL }; + static const char* py_methods_226[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.super"; rt.short_name = "super"; - rt.method_names = py_methods_214; + rt.method_names = py_methods_226; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.super.__init__"; rf.short_name = "__init__"; rf.receiver_type = "builtins.super"; cbm_registry_add_func(reg, rf); - static const char* py_methods_215[] = { "as_integer_ratio", "real", "imag", "numerator", "denominator", "conjugate", "bit_length", "bit_count", "to_bytes", "from_bytes", "is_integer", "__round__", NULL }; + static const char* py_methods_227[] = { "as_integer_ratio", "real", "imag", "numerator", "denominator", "conjugate", "bit_length", "bit_count", "to_bytes", "from_bytes", "is_integer", "__round__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.int"; rt.short_name = "int"; - rt.method_names = py_methods_215; + rt.method_names = py_methods_227; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.int.as_integer_ratio"; @@ -4086,11 +4282,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__round__"; rf.receiver_type = "builtins.int"; cbm_registry_add_func(reg, rf); - static const char* py_methods_216[] = { "as_integer_ratio", "hex", "is_integer", "fromhex", "real", "imag", "conjugate", "from_number", NULL }; + static const char* py_methods_228[] = { "as_integer_ratio", "hex", "is_integer", "fromhex", "real", "imag", "conjugate", "from_number", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.float"; rt.short_name = "float"; - rt.method_names = py_methods_216; + rt.method_names = py_methods_228; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.float.as_integer_ratio"; @@ -4132,11 +4328,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "from_number"; rf.receiver_type = "builtins.float"; cbm_registry_add_func(reg, rf); - static const char* py_methods_217[] = { "real", "imag", "conjugate", "__complex__", "from_number", NULL }; + static const char* py_methods_229[] = { "real", "imag", "conjugate", "__complex__", "from_number", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.complex"; rt.short_name = "complex"; - rt.method_names = py_methods_217; + rt.method_names = py_methods_229; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.complex.real"; @@ -4166,20 +4362,20 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins._FormatMapMapping"; rt.short_name = "_FormatMapMapping"; - static const char* py_bases_218[] = { "builtins.Protocol", NULL }; - rt.embedded_types = py_bases_218; + static const char* py_bases_230[] = { "builtins.Protocol", NULL }; + rt.embedded_types = py_bases_230; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins._TranslateTable"; rt.short_name = "_TranslateTable"; - static const char* py_bases_219[] = { "builtins.Protocol", NULL }; - rt.embedded_types = py_bases_219; + static const char* py_bases_231[] = { "builtins.Protocol", NULL }; + rt.embedded_types = py_bases_231; cbm_registry_add_type(reg, rt); - static const char* py_methods_220[] = { "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalnum", "isalpha", "isascii", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "replace", "removeprefix", "removesuffix", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", "maketrans", NULL }; + static const char* py_methods_232[] = { "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalnum", "isalpha", "isascii", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "replace", "removeprefix", "removesuffix", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", "maketrans", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.str"; rt.short_name = "str"; - rt.method_names = py_methods_220; + rt.method_names = py_methods_232; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.str.capitalize"; @@ -4416,11 +4612,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "maketrans"; rf.receiver_type = "builtins.str"; cbm_registry_add_func(reg, rf); - static const char* py_methods_221[] = { "capitalize", "center", "count", "decode", "endswith", "expandtabs", "find", "hex", "index", "isalnum", "isalpha", "isascii", "isdigit", "islower", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "replace", "removeprefix", "removesuffix", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", "fromhex", "maketrans", "__bytes__", NULL }; + static const char* py_methods_233[] = { "capitalize", "center", "count", "decode", "endswith", "expandtabs", "find", "hex", "index", "isalnum", "isalpha", "isascii", "isdigit", "islower", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "replace", "removeprefix", "removesuffix", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", "fromhex", "maketrans", "__bytes__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.bytes"; rt.short_name = "bytes"; - rt.method_names = py_methods_221; + rt.method_names = py_methods_233; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.bytes.capitalize"; @@ -4637,11 +4833,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__bytes__"; rf.receiver_type = "builtins.bytes"; cbm_registry_add_func(reg, rf); - static const char* py_methods_222[] = { "__init__", "append", "capitalize", "center", "count", "copy", "decode", "endswith", "expandtabs", "extend", "find", "hex", "index", "insert", "isalnum", "isalpha", "isascii", "isdigit", "islower", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "pop", "remove", "removeprefix", "removesuffix", "replace", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "take_bytes", "upper", "zfill", "fromhex", "maketrans", "resize", NULL }; + static const char* py_methods_234[] = { "__init__", "append", "capitalize", "center", "count", "copy", "decode", "endswith", "expandtabs", "extend", "find", "hex", "index", "insert", "isalnum", "isalpha", "isascii", "isdigit", "islower", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "pop", "remove", "removeprefix", "removesuffix", "replace", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "take_bytes", "upper", "zfill", "fromhex", "maketrans", "resize", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.bytearray"; rt.short_name = "bytearray"; - rt.method_names = py_methods_222; + rt.method_names = py_methods_234; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.bytearray.__init__"; @@ -4898,11 +5094,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "resize"; rf.receiver_type = "builtins.bytearray"; cbm_registry_add_func(reg, rf); - static const char* py_methods_223[] = { "format", "itemsize", "shape", "strides", "suboffsets", "readonly", "ndim", "obj", "c_contiguous", "f_contiguous", "contiguous", "nbytes", "__enter__", "__exit__", "cast", "tobytes", "tolist", "toreadonly", "release", "hex", "index", "count", "__class_getitem__", NULL }; + static const char* py_methods_235[] = { "format", "itemsize", "shape", "strides", "suboffsets", "readonly", "ndim", "obj", "c_contiguous", "f_contiguous", "contiguous", "nbytes", "__enter__", "__exit__", "cast", "tobytes", "tolist", "toreadonly", "release", "hex", "index", "count", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.memoryview"; rt.short_name = "memoryview"; - rt.method_names = py_methods_223; + rt.method_names = py_methods_235; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.memoryview.format"; @@ -5022,14 +5218,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.bool"; rt.short_name = "bool"; - static const char* py_bases_224[] = { "builtins.int", NULL }; - rt.embedded_types = py_bases_224; + static const char* py_bases_236[] = { "builtins.int", NULL }; + rt.embedded_types = py_bases_236; cbm_registry_add_type(reg, rt); - static const char* py_methods_225[] = { "start", "step", "stop", "__hash__", "indices", "__class_getitem__", NULL }; + static const char* py_methods_237[] = { "start", "step", "stop", "__hash__", "indices", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.slice"; rt.short_name = "slice"; - rt.method_names = py_methods_225; + rt.method_names = py_methods_237; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.slice.start"; @@ -5061,11 +5257,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__class_getitem__"; rf.receiver_type = "builtins.slice"; cbm_registry_add_func(reg, rf); - static const char* py_methods_226[] = { "count", "index", NULL }; + static const char* py_methods_238[] = { "count", "index", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.tuple"; rt.short_name = "tuple"; - rt.method_names = py_methods_226; + rt.method_names = py_methods_238; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.tuple.count"; @@ -5077,22 +5273,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "index"; rf.receiver_type = "builtins.tuple"; cbm_registry_add_func(reg, rf); - static const char* py_methods_227[] = { "__new__", NULL }; + static const char* py_methods_239[] = { "__new__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.function"; rt.short_name = "function"; - rt.method_names = py_methods_227; + rt.method_names = py_methods_239; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.function.__new__"; rf.short_name = "__new__"; rf.receiver_type = "builtins.function"; cbm_registry_add_func(reg, rf); - static const char* py_methods_228[] = { "__init__", "copy", "append", "extend", "pop", "index", "count", "insert", "remove", "sort", NULL }; + static const char* py_methods_240[] = { "__init__", "copy", "append", "extend", "pop", "index", "count", "insert", "remove", "sort", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.list"; rt.short_name = "list"; - rt.method_names = py_methods_228; + rt.method_names = py_methods_240; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.list.__init__"; @@ -5144,11 +5340,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "sort"; rf.receiver_type = "builtins.list"; cbm_registry_add_func(reg, rf); - static const char* py_methods_229[] = { "__init__", "copy", "keys", "values", "items", "fromkeys", "get", "pop", "__or__", "__ror__", NULL }; + static const char* py_methods_241[] = { "__init__", "copy", "keys", "values", "items", "fromkeys", "get", "pop", "__or__", "__ror__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.dict"; rt.short_name = "dict"; - rt.method_names = py_methods_229; + rt.method_names = py_methods_241; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.dict.__init__"; @@ -5200,11 +5396,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__ror__"; rf.receiver_type = "builtins.dict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_230[] = { "__init__", "copy", "fromkeys", "get", "keys", "values", "items", NULL }; + static const char* py_methods_242[] = { "__init__", "copy", "fromkeys", "get", "keys", "values", "items", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.frozendict"; rt.short_name = "frozendict"; - rt.method_names = py_methods_230; + rt.method_names = py_methods_242; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.frozendict.__init__"; @@ -5241,11 +5437,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "items"; rf.receiver_type = "builtins.frozendict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_231[] = { "__init__", "add", "copy", "difference", "difference_update", "discard", "intersection", "intersection_update", "isdisjoint", "issubset", "issuperset", "remove", "symmetric_difference", "symmetric_difference_update", "union", "update", NULL }; + static const char* py_methods_243[] = { "__init__", "add", "copy", "difference", "difference_update", "discard", "intersection", "intersection_update", "isdisjoint", "issubset", "issuperset", "remove", "symmetric_difference", "symmetric_difference_update", "union", "update", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.set"; rt.short_name = "set"; - rt.method_names = py_methods_231; + rt.method_names = py_methods_243; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.set.__init__"; @@ -5327,11 +5523,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "update"; rf.receiver_type = "builtins.set"; cbm_registry_add_func(reg, rf); - static const char* py_methods_232[] = { "copy", "difference", "intersection", "isdisjoint", "issubset", "issuperset", "symmetric_difference", "union", NULL }; + static const char* py_methods_244[] = { "copy", "difference", "intersection", "isdisjoint", "issubset", "issuperset", "symmetric_difference", "union", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.frozenset"; rt.short_name = "frozenset"; - rt.method_names = py_methods_232; + rt.method_names = py_methods_244; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.frozenset.copy"; @@ -5377,11 +5573,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "builtins.enumerate"; rt.short_name = "enumerate"; cbm_registry_add_type(reg, rt); - static const char* py_methods_233[] = { "start", "stop", "step", "count", "index", NULL }; + static const char* py_methods_245[] = { "start", "stop", "step", "count", "index", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.range"; rt.short_name = "range"; - rt.method_names = py_methods_233; + rt.method_names = py_methods_245; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.range.start"; @@ -5408,11 +5604,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "index"; rf.receiver_type = "builtins.range"; cbm_registry_add_func(reg, rf); - static const char* py_methods_234[] = { "__init__", "getter", "setter", "deleter", NULL }; + static const char* py_methods_246[] = { "__init__", "getter", "setter", "deleter", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.property"; rt.short_name = "property"; - rt.method_names = py_methods_234; + rt.method_names = py_methods_246; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.property.__init__"; @@ -5446,11 +5642,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "builtins._GetItemIterable"; rt.short_name = "_GetItemIterable"; cbm_registry_add_type(reg, rt); - static const char* py_methods_235[] = { "__new__", NULL }; + static const char* py_methods_247[] = { "__new__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.map"; rt.short_name = "map"; - rt.method_names = py_methods_235; + rt.method_names = py_methods_247; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.map.__new__"; @@ -5460,8 +5656,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins._SupportsWriteAndFlush"; rt.short_name = "_SupportsWriteAndFlush"; - static const char* py_bases_236[] = { "builtins.SupportsFlush", NULL }; - rt.embedded_types = py_bases_236; + static const char* py_bases_248[] = { "builtins.SupportsFlush", NULL }; + rt.embedded_types = py_bases_248; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins._SupportsPow2"; @@ -5494,18 +5690,18 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins._SupportsSumWithNoDefaultGiven"; rt.short_name = "_SupportsSumWithNoDefaultGiven"; - static const char* py_bases_237[] = { "builtins.Protocol", NULL }; - rt.embedded_types = py_bases_237; + static const char* py_bases_249[] = { "builtins.Protocol", NULL }; + rt.embedded_types = py_bases_249; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.zip"; rt.short_name = "zip"; cbm_registry_add_type(reg, rt); - static const char* py_methods_238[] = { "__init__", "with_traceback", "add_note", NULL }; + static const char* py_methods_250[] = { "__init__", "with_traceback", "add_note", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.BaseException"; rt.short_name = "BaseException"; - rt.method_names = py_methods_238; + rt.method_names = py_methods_250; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.BaseException.__init__"; @@ -5525,58 +5721,58 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.GeneratorExit"; rt.short_name = "GeneratorExit"; - static const char* py_bases_239[] = { "builtins.BaseException", NULL }; - rt.embedded_types = py_bases_239; + static const char* py_bases_251[] = { "builtins.BaseException", NULL }; + rt.embedded_types = py_bases_251; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.KeyboardInterrupt"; rt.short_name = "KeyboardInterrupt"; - static const char* py_bases_240[] = { "builtins.BaseException", NULL }; - rt.embedded_types = py_bases_240; + static const char* py_bases_252[] = { "builtins.BaseException", NULL }; + rt.embedded_types = py_bases_252; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.SystemExit"; rt.short_name = "SystemExit"; - static const char* py_bases_241[] = { "builtins.BaseException", NULL }; - rt.embedded_types = py_bases_241; + static const char* py_bases_253[] = { "builtins.BaseException", NULL }; + rt.embedded_types = py_bases_253; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.Exception"; rt.short_name = "Exception"; - static const char* py_bases_242[] = { "builtins.BaseException", NULL }; - rt.embedded_types = py_bases_242; + static const char* py_bases_254[] = { "builtins.BaseException", NULL }; + rt.embedded_types = py_bases_254; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.StopIteration"; rt.short_name = "StopIteration"; - static const char* py_bases_243[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_243; + static const char* py_bases_255[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_255; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.OSError"; rt.short_name = "OSError"; - static const char* py_bases_244[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_244; + static const char* py_bases_256[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_256; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ArithmeticError"; rt.short_name = "ArithmeticError"; - static const char* py_bases_245[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_245; + static const char* py_bases_257[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_257; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.AssertionError"; rt.short_name = "AssertionError"; - static const char* py_bases_246[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_246; + static const char* py_bases_258[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_258; cbm_registry_add_type(reg, rt); - static const char* py_methods_247[] = { "__init__", NULL }; + static const char* py_methods_259[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.AttributeError"; rt.short_name = "AttributeError"; - rt.method_names = py_methods_247; - static const char* py_bases_248[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_248; + rt.method_names = py_methods_259; + static const char* py_bases_260[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_260; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.AttributeError.__init__"; @@ -5586,22 +5782,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.BufferError"; rt.short_name = "BufferError"; - static const char* py_bases_249[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_249; + static const char* py_bases_261[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_261; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.EOFError"; rt.short_name = "EOFError"; - static const char* py_bases_250[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_250; + static const char* py_bases_262[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_262; cbm_registry_add_type(reg, rt); - static const char* py_methods_251[] = { "__init__", NULL }; + static const char* py_methods_263[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ImportError"; rt.short_name = "ImportError"; - rt.method_names = py_methods_251; - static const char* py_bases_252[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_252; + rt.method_names = py_methods_263; + static const char* py_bases_264[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_264; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.ImportError.__init__"; @@ -5611,28 +5807,28 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ImportCycleError"; rt.short_name = "ImportCycleError"; - static const char* py_bases_253[] = { "builtins.ImportError", NULL }; - rt.embedded_types = py_bases_253; + static const char* py_bases_265[] = { "builtins.ImportError", NULL }; + rt.embedded_types = py_bases_265; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.LookupError"; rt.short_name = "LookupError"; - static const char* py_bases_254[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_254; + static const char* py_bases_266[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_266; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.MemoryError"; rt.short_name = "MemoryError"; - static const char* py_bases_255[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_255; + static const char* py_bases_267[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_267; cbm_registry_add_type(reg, rt); - static const char* py_methods_256[] = { "__init__", NULL }; + static const char* py_methods_268[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.NameError"; rt.short_name = "NameError"; - rt.method_names = py_methods_256; - static const char* py_bases_257[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_257; + rt.method_names = py_methods_268; + static const char* py_bases_269[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_269; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.NameError.__init__"; @@ -5642,28 +5838,28 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ReferenceError"; rt.short_name = "ReferenceError"; - static const char* py_bases_258[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_258; + static const char* py_bases_270[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_270; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.RuntimeError"; rt.short_name = "RuntimeError"; - static const char* py_bases_259[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_259; + static const char* py_bases_271[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_271; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.StopAsyncIteration"; rt.short_name = "StopAsyncIteration"; - static const char* py_bases_260[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_260; + static const char* py_bases_272[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_272; cbm_registry_add_type(reg, rt); - static const char* py_methods_261[] = { "__init__", NULL }; + static const char* py_methods_273[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.SyntaxError"; rt.short_name = "SyntaxError"; - rt.method_names = py_methods_261; - static const char* py_bases_262[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_262; + rt.method_names = py_methods_273; + static const char* py_bases_274[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_274; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.SyntaxError.__init__"; @@ -5673,216 +5869,216 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.SystemError"; rt.short_name = "SystemError"; - static const char* py_bases_263[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_263; + static const char* py_bases_275[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_275; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.TypeError"; rt.short_name = "TypeError"; - static const char* py_bases_264[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_264; + static const char* py_bases_276[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_276; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ValueError"; rt.short_name = "ValueError"; - static const char* py_bases_265[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_265; + static const char* py_bases_277[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_277; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.FloatingPointError"; rt.short_name = "FloatingPointError"; - static const char* py_bases_266[] = { "builtins.ArithmeticError", NULL }; - rt.embedded_types = py_bases_266; + static const char* py_bases_278[] = { "builtins.ArithmeticError", NULL }; + rt.embedded_types = py_bases_278; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.OverflowError"; rt.short_name = "OverflowError"; - static const char* py_bases_267[] = { "builtins.ArithmeticError", NULL }; - rt.embedded_types = py_bases_267; + static const char* py_bases_279[] = { "builtins.ArithmeticError", NULL }; + rt.embedded_types = py_bases_279; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ZeroDivisionError"; rt.short_name = "ZeroDivisionError"; - static const char* py_bases_268[] = { "builtins.ArithmeticError", NULL }; - rt.embedded_types = py_bases_268; + static const char* py_bases_280[] = { "builtins.ArithmeticError", NULL }; + rt.embedded_types = py_bases_280; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ModuleNotFoundError"; rt.short_name = "ModuleNotFoundError"; - static const char* py_bases_269[] = { "builtins.ImportError", NULL }; - rt.embedded_types = py_bases_269; + static const char* py_bases_281[] = { "builtins.ImportError", NULL }; + rt.embedded_types = py_bases_281; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.IndexError"; rt.short_name = "IndexError"; - static const char* py_bases_270[] = { "builtins.LookupError", NULL }; - rt.embedded_types = py_bases_270; + static const char* py_bases_282[] = { "builtins.LookupError", NULL }; + rt.embedded_types = py_bases_282; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.KeyError"; rt.short_name = "KeyError"; - static const char* py_bases_271[] = { "builtins.LookupError", NULL }; - rt.embedded_types = py_bases_271; + static const char* py_bases_283[] = { "builtins.LookupError", NULL }; + rt.embedded_types = py_bases_283; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UnboundLocalError"; rt.short_name = "UnboundLocalError"; - static const char* py_bases_272[] = { "builtins.NameError", NULL }; - rt.embedded_types = py_bases_272; + static const char* py_bases_284[] = { "builtins.NameError", NULL }; + rt.embedded_types = py_bases_284; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.BlockingIOError"; rt.short_name = "BlockingIOError"; - static const char* py_bases_273[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_273; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.ChildProcessError"; - rt.short_name = "ChildProcessError"; - static const char* py_bases_274[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_274; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.ConnectionError"; - rt.short_name = "ConnectionError"; - static const char* py_bases_275[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_275; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.BrokenPipeError"; - rt.short_name = "BrokenPipeError"; - static const char* py_bases_276[] = { "builtins.ConnectionError", NULL }; - rt.embedded_types = py_bases_276; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.ConnectionAbortedError"; - rt.short_name = "ConnectionAbortedError"; - static const char* py_bases_277[] = { "builtins.ConnectionError", NULL }; - rt.embedded_types = py_bases_277; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.ConnectionRefusedError"; - rt.short_name = "ConnectionRefusedError"; - static const char* py_bases_278[] = { "builtins.ConnectionError", NULL }; - rt.embedded_types = py_bases_278; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.ConnectionResetError"; - rt.short_name = "ConnectionResetError"; - static const char* py_bases_279[] = { "builtins.ConnectionError", NULL }; - rt.embedded_types = py_bases_279; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.FileExistsError"; - rt.short_name = "FileExistsError"; - static const char* py_bases_280[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_280; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.FileNotFoundError"; - rt.short_name = "FileNotFoundError"; - static const char* py_bases_281[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_281; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.InterruptedError"; - rt.short_name = "InterruptedError"; - static const char* py_bases_282[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_282; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.IsADirectoryError"; - rt.short_name = "IsADirectoryError"; - static const char* py_bases_283[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_283; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.NotADirectoryError"; - rt.short_name = "NotADirectoryError"; - static const char* py_bases_284[] = { "builtins.OSError", NULL }; - rt.embedded_types = py_bases_284; - cbm_registry_add_type(reg, rt); - memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.PermissionError"; - rt.short_name = "PermissionError"; static const char* py_bases_285[] = { "builtins.OSError", NULL }; rt.embedded_types = py_bases_285; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.ProcessLookupError"; - rt.short_name = "ProcessLookupError"; + rt.qualified_name = "builtins.ChildProcessError"; + rt.short_name = "ChildProcessError"; static const char* py_bases_286[] = { "builtins.OSError", NULL }; rt.embedded_types = py_bases_286; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); - rt.qualified_name = "builtins.TimeoutError"; - rt.short_name = "TimeoutError"; + rt.qualified_name = "builtins.ConnectionError"; + rt.short_name = "ConnectionError"; static const char* py_bases_287[] = { "builtins.OSError", NULL }; rt.embedded_types = py_bases_287; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.BrokenPipeError"; + rt.short_name = "BrokenPipeError"; + static const char* py_bases_288[] = { "builtins.ConnectionError", NULL }; + rt.embedded_types = py_bases_288; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.ConnectionAbortedError"; + rt.short_name = "ConnectionAbortedError"; + static const char* py_bases_289[] = { "builtins.ConnectionError", NULL }; + rt.embedded_types = py_bases_289; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.ConnectionRefusedError"; + rt.short_name = "ConnectionRefusedError"; + static const char* py_bases_290[] = { "builtins.ConnectionError", NULL }; + rt.embedded_types = py_bases_290; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.ConnectionResetError"; + rt.short_name = "ConnectionResetError"; + static const char* py_bases_291[] = { "builtins.ConnectionError", NULL }; + rt.embedded_types = py_bases_291; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.FileExistsError"; + rt.short_name = "FileExistsError"; + static const char* py_bases_292[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_292; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.FileNotFoundError"; + rt.short_name = "FileNotFoundError"; + static const char* py_bases_293[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_293; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.InterruptedError"; + rt.short_name = "InterruptedError"; + static const char* py_bases_294[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_294; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.IsADirectoryError"; + rt.short_name = "IsADirectoryError"; + static const char* py_bases_295[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_295; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.NotADirectoryError"; + rt.short_name = "NotADirectoryError"; + static const char* py_bases_296[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_296; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.PermissionError"; + rt.short_name = "PermissionError"; + static const char* py_bases_297[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_297; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.ProcessLookupError"; + rt.short_name = "ProcessLookupError"; + static const char* py_bases_298[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_298; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "builtins.TimeoutError"; + rt.short_name = "TimeoutError"; + static const char* py_bases_299[] = { "builtins.OSError", NULL }; + rt.embedded_types = py_bases_299; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.NotImplementedError"; rt.short_name = "NotImplementedError"; - static const char* py_bases_288[] = { "builtins.RuntimeError", NULL }; - rt.embedded_types = py_bases_288; + static const char* py_bases_300[] = { "builtins.RuntimeError", NULL }; + rt.embedded_types = py_bases_300; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.RecursionError"; rt.short_name = "RecursionError"; - static const char* py_bases_289[] = { "builtins.RuntimeError", NULL }; - rt.embedded_types = py_bases_289; + static const char* py_bases_301[] = { "builtins.RuntimeError", NULL }; + rt.embedded_types = py_bases_301; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.IndentationError"; rt.short_name = "IndentationError"; - static const char* py_bases_290[] = { "builtins.SyntaxError", NULL }; - rt.embedded_types = py_bases_290; + static const char* py_bases_302[] = { "builtins.SyntaxError", NULL }; + rt.embedded_types = py_bases_302; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.TabError"; rt.short_name = "TabError"; - static const char* py_bases_291[] = { "builtins.IndentationError", NULL }; - rt.embedded_types = py_bases_291; + static const char* py_bases_303[] = { "builtins.IndentationError", NULL }; + rt.embedded_types = py_bases_303; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UnicodeError"; rt.short_name = "UnicodeError"; - static const char* py_bases_292[] = { "builtins.ValueError", NULL }; - rt.embedded_types = py_bases_292; + static const char* py_bases_304[] = { "builtins.ValueError", NULL }; + rt.embedded_types = py_bases_304; cbm_registry_add_type(reg, rt); - static const char* py_methods_293[] = { "__init__", NULL }; + static const char* py_methods_305[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UnicodeDecodeError"; rt.short_name = "UnicodeDecodeError"; - rt.method_names = py_methods_293; - static const char* py_bases_294[] = { "builtins.UnicodeError", NULL }; - rt.embedded_types = py_bases_294; + rt.method_names = py_methods_305; + static const char* py_bases_306[] = { "builtins.UnicodeError", NULL }; + rt.embedded_types = py_bases_306; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.UnicodeDecodeError.__init__"; rf.short_name = "__init__"; rf.receiver_type = "builtins.UnicodeDecodeError"; cbm_registry_add_func(reg, rf); - static const char* py_methods_295[] = { "__init__", NULL }; + static const char* py_methods_307[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UnicodeEncodeError"; rt.short_name = "UnicodeEncodeError"; - rt.method_names = py_methods_295; - static const char* py_bases_296[] = { "builtins.UnicodeError", NULL }; - rt.embedded_types = py_bases_296; + rt.method_names = py_methods_307; + static const char* py_bases_308[] = { "builtins.UnicodeError", NULL }; + rt.embedded_types = py_bases_308; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.UnicodeEncodeError.__init__"; rf.short_name = "__init__"; rf.receiver_type = "builtins.UnicodeEncodeError"; cbm_registry_add_func(reg, rf); - static const char* py_methods_297[] = { "__init__", NULL }; + static const char* py_methods_309[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UnicodeTranslateError"; rt.short_name = "UnicodeTranslateError"; - rt.method_names = py_methods_297; - static const char* py_bases_298[] = { "builtins.UnicodeError", NULL }; - rt.embedded_types = py_bases_298; + rt.method_names = py_methods_309; + static const char* py_bases_310[] = { "builtins.UnicodeError", NULL }; + rt.embedded_types = py_bases_310; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.UnicodeTranslateError.__init__"; @@ -5892,82 +6088,82 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.Warning"; rt.short_name = "Warning"; - static const char* py_bases_299[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_299; + static const char* py_bases_311[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_311; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UserWarning"; rt.short_name = "UserWarning"; - static const char* py_bases_300[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_300; + static const char* py_bases_312[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_312; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.DeprecationWarning"; rt.short_name = "DeprecationWarning"; - static const char* py_bases_301[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_301; + static const char* py_bases_313[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_313; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.SyntaxWarning"; rt.short_name = "SyntaxWarning"; - static const char* py_bases_302[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_302; + static const char* py_bases_314[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_314; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.RuntimeWarning"; rt.short_name = "RuntimeWarning"; - static const char* py_bases_303[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_303; + static const char* py_bases_315[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_315; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.FutureWarning"; rt.short_name = "FutureWarning"; - static const char* py_bases_304[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_304; + static const char* py_bases_316[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_316; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.PendingDeprecationWarning"; rt.short_name = "PendingDeprecationWarning"; - static const char* py_bases_305[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_305; + static const char* py_bases_317[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_317; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ImportWarning"; rt.short_name = "ImportWarning"; - static const char* py_bases_306[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_306; + static const char* py_bases_318[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_318; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.UnicodeWarning"; rt.short_name = "UnicodeWarning"; - static const char* py_bases_307[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_307; + static const char* py_bases_319[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_319; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.BytesWarning"; rt.short_name = "BytesWarning"; - static const char* py_bases_308[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_308; + static const char* py_bases_320[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_320; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ResourceWarning"; rt.short_name = "ResourceWarning"; - static const char* py_bases_309[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_309; + static const char* py_bases_321[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_321; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.EncodingWarning"; rt.short_name = "EncodingWarning"; - static const char* py_bases_310[] = { "builtins.Warning", NULL }; - rt.embedded_types = py_bases_310; + static const char* py_bases_322[] = { "builtins.Warning", NULL }; + rt.embedded_types = py_bases_322; cbm_registry_add_type(reg, rt); - static const char* py_methods_311[] = { "__init__", "message", "exceptions", "subgroup", "split", "derive", NULL }; + static const char* py_methods_323[] = { "__init__", "message", "exceptions", "subgroup", "split", "derive", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.BaseExceptionGroup"; rt.short_name = "BaseExceptionGroup"; - rt.method_names = py_methods_311; - static const char* py_bases_312[] = { "builtins.BaseException", NULL }; - rt.embedded_types = py_bases_312; + rt.method_names = py_methods_323; + static const char* py_bases_324[] = { "builtins.BaseException", NULL }; + rt.embedded_types = py_bases_324; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.BaseExceptionGroup.__init__"; @@ -5999,13 +6195,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "derive"; rf.receiver_type = "builtins.BaseExceptionGroup"; cbm_registry_add_func(reg, rf); - static const char* py_methods_313[] = { "__init__", "exceptions", "subgroup", "split", NULL }; + static const char* py_methods_325[] = { "__init__", "exceptions", "subgroup", "split", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.ExceptionGroup"; rt.short_name = "ExceptionGroup"; - rt.method_names = py_methods_313; - static const char* py_bases_314[] = { "builtins.Exception", NULL }; - rt.embedded_types = py_bases_314; + rt.method_names = py_methods_325; + static const char* py_bases_326[] = { "builtins.Exception", NULL }; + rt.embedded_types = py_bases_326; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.ExceptionGroup.__init__"; @@ -6030,8 +6226,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "builtins.PythonFinalizationError"; rt.short_name = "PythonFinalizationError"; - static const char* py_bases_315[] = { "builtins.RuntimeError", NULL }; - rt.embedded_types = py_bases_315; + static const char* py_bases_327[] = { "builtins.RuntimeError", NULL }; + rt.embedded_types = py_bases_327; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "builtins.abs"; @@ -6207,11 +6403,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: collections ===== */ - static const char* py_methods_316[] = { "__init__", "copy", "fromkeys", "get", NULL }; + static const char* py_methods_328[] = { "__init__", "copy", "fromkeys", "get", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.UserDict"; rt.short_name = "UserDict"; - rt.method_names = py_methods_316; + rt.method_names = py_methods_328; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.UserDict.__init__"; @@ -6233,11 +6429,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "get"; rf.receiver_type = "collections.UserDict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_317[] = { "__init__", "append", "insert", "pop", "remove", "copy", "count", "index", "sort", "extend", NULL }; + static const char* py_methods_329[] = { "__init__", "append", "insert", "pop", "remove", "copy", "count", "index", "sort", "extend", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.UserList"; rt.short_name = "UserList"; - rt.method_names = py_methods_317; + rt.method_names = py_methods_329; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.UserList.__init__"; @@ -6289,11 +6485,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "extend"; rf.receiver_type = "collections.UserList"; cbm_registry_add_func(reg, rf); - static const char* py_methods_318[] = { "__init__", "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalpha", "isalnum", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "isascii", "join", "ljust", "lower", "lstrip", "partition", "removeprefix", "removesuffix", "replace", "rfind", "rindex", "rjust", "rpartition", "rstrip", "split", "rsplit", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", NULL }; + static const char* py_methods_330[] = { "__init__", "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalpha", "isalnum", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "isascii", "join", "ljust", "lower", "lstrip", "partition", "removeprefix", "removesuffix", "replace", "rfind", "rindex", "rjust", "rpartition", "rstrip", "split", "rsplit", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.UserString"; rt.short_name = "UserString"; - rt.method_names = py_methods_318; + rt.method_names = py_methods_330; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.UserString.__init__"; @@ -6530,11 +6726,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "zfill"; rf.receiver_type = "collections.UserString"; cbm_registry_add_func(reg, rf); - static const char* py_methods_319[] = { "maxlen", "__init__", "append", "appendleft", "copy", "count", "extend", "extendleft", "insert", "index", "pop", "popleft", "remove", "rotate", NULL }; + static const char* py_methods_331[] = { "maxlen", "__init__", "append", "appendleft", "copy", "count", "extend", "extendleft", "insert", "index", "pop", "popleft", "remove", "rotate", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.deque"; rt.short_name = "deque"; - rt.method_names = py_methods_319; + rt.method_names = py_methods_331; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.deque.maxlen"; @@ -6606,11 +6802,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "rotate"; rf.receiver_type = "collections.deque"; cbm_registry_add_func(reg, rf); - static const char* py_methods_320[] = { "__init__", "copy", "elements", "most_common", "fromkeys", "subtract", "update", "total", NULL }; + static const char* py_methods_332[] = { "__init__", "copy", "elements", "most_common", "fromkeys", "subtract", "update", "total", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.Counter"; rt.short_name = "Counter"; - rt.method_names = py_methods_320; + rt.method_names = py_methods_332; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.Counter.__init__"; @@ -6676,11 +6872,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "collections._odict_values"; rt.short_name = "_odict_values"; cbm_registry_add_type(reg, rt); - static const char* py_methods_321[] = { "popitem", "move_to_end", "copy", "keys", "items", "values", "fromkeys", "setdefault", "pop", "__or__", "__ror__", NULL }; + static const char* py_methods_333[] = { "popitem", "move_to_end", "copy", "keys", "items", "values", "fromkeys", "setdefault", "pop", "__or__", "__ror__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.OrderedDict"; rt.short_name = "OrderedDict"; - rt.method_names = py_methods_321; + rt.method_names = py_methods_333; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.OrderedDict.popitem"; @@ -6737,11 +6933,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__ror__"; rf.receiver_type = "collections.OrderedDict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_322[] = { "__init__", "copy", NULL }; + static const char* py_methods_334[] = { "__init__", "copy", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.defaultdict"; rt.short_name = "defaultdict"; - rt.method_names = py_methods_322; + rt.method_names = py_methods_334; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.defaultdict.__init__"; @@ -6753,11 +6949,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "copy"; rf.receiver_type = "collections.defaultdict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_323[] = { "__init__", "new_child", "parents", "get", "setdefault", "pop", "copy", "fromkeys", NULL }; + static const char* py_methods_335[] = { "__init__", "new_child", "parents", "get", "setdefault", "pop", "copy", "fromkeys", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "collections.ChainMap"; rt.short_name = "ChainMap"; - rt.method_names = py_methods_323; + rt.method_names = py_methods_335; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "collections.ChainMap.__init__"; @@ -6804,14 +7000,815 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "namedtuple"; cbm_registry_add_func(reg, rf); + /* ===== module: collections.abc ===== */ + static const char* py_methods_336[] = { "isdisjoint", "mapping", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "collections.abc.dict_keys"; + rt.short_name = "dict_keys"; + rt.method_names = py_methods_336; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "collections.abc.dict_keys.isdisjoint"; + rf.short_name = "isdisjoint"; + rf.receiver_type = "collections.abc.dict_keys"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "collections.abc.dict_keys.mapping"; + rf.short_name = "mapping"; + rf.receiver_type = "collections.abc.dict_keys"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_337[] = { "mapping", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "collections.abc.dict_values"; + rt.short_name = "dict_values"; + rt.method_names = py_methods_337; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "collections.abc.dict_values.mapping"; + rf.short_name = "mapping"; + rf.receiver_type = "collections.abc.dict_values"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_338[] = { "isdisjoint", "mapping", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "collections.abc.dict_items"; + rt.short_name = "dict_items"; + rt.method_names = py_methods_338; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "collections.abc.dict_items.isdisjoint"; + rf.short_name = "isdisjoint"; + rf.receiver_type = "collections.abc.dict_items"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "collections.abc.dict_items.mapping"; + rf.short_name = "mapping"; + rf.receiver_type = "collections.abc.dict_items"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "collections.abc.Buffer"; + rt.short_name = "Buffer"; + static const char* py_bases_339[] = { "_collections_abc.Protocol", NULL }; + rt.embedded_types = py_bases_339; + cbm_registry_add_type(reg, rt); + + /* ===== module: concurrent.futures._base ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.Error"; + rt.short_name = "Error"; + static const char* py_bases_340[] = { "concurrent.futures._base.Exception", NULL }; + rt.embedded_types = py_bases_340; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.CancelledError"; + rt.short_name = "CancelledError"; + static const char* py_bases_341[] = { "concurrent.futures._base.Error", NULL }; + rt.embedded_types = py_bases_341; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.TimeoutError"; + rt.short_name = "TimeoutError"; + static const char* py_bases_342[] = { "concurrent.futures._base.Error", NULL }; + rt.embedded_types = py_bases_342; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.InvalidStateError"; + rt.short_name = "InvalidStateError"; + static const char* py_bases_343[] = { "concurrent.futures._base.Error", NULL }; + rt.embedded_types = py_bases_343; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.BrokenExecutor"; + rt.short_name = "BrokenExecutor"; + static const char* py_bases_344[] = { "concurrent.futures._base.RuntimeError", NULL }; + rt.embedded_types = py_bases_344; + cbm_registry_add_type(reg, rt); + static const char* py_methods_345[] = { "cancel", "cancelled", "running", "done", "add_done_callback", "result", "set_running_or_notify_cancel", "set_result", "exception", "set_exception", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.Future"; + rt.short_name = "Future"; + rt.method_names = py_methods_345; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.cancel"; + rf.short_name = "cancel"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.cancelled"; + rf.short_name = "cancelled"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.running"; + rf.short_name = "running"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.done"; + rf.short_name = "done"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.add_done_callback"; + rf.short_name = "add_done_callback"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.result"; + rf.short_name = "result"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.set_running_or_notify_cancel"; + rf.short_name = "set_running_or_notify_cancel"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.set_result"; + rf.short_name = "set_result"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.exception"; + rf.short_name = "exception"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Future.set_exception"; + rf.short_name = "set_exception"; + rf.receiver_type = "concurrent.futures._base.Future"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_346[] = { "submit", "map", "shutdown", "__enter__", "__exit__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.Executor"; + rt.short_name = "Executor"; + rt.method_names = py_methods_346; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Executor.submit"; + rf.short_name = "submit"; + rf.receiver_type = "concurrent.futures._base.Executor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Executor.map"; + rf.short_name = "map"; + rf.receiver_type = "concurrent.futures._base.Executor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Executor.shutdown"; + rf.short_name = "shutdown"; + rf.receiver_type = "concurrent.futures._base.Executor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Executor.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "concurrent.futures._base.Executor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.Executor.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "concurrent.futures._base.Executor"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_347[] = { "result", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base._AsCompletedFuture"; + rt.short_name = "_AsCompletedFuture"; + rt.method_names = py_methods_347; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._AsCompletedFuture.result"; + rf.short_name = "result"; + rf.receiver_type = "concurrent.futures._base._AsCompletedFuture"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base.DoneAndNotDoneFutures"; + rt.short_name = "DoneAndNotDoneFutures"; + static const char* py_bases_348[] = { "concurrent.futures._base.NamedTuple", NULL }; + rt.embedded_types = py_bases_348; + cbm_registry_add_type(reg, rt); + static const char* py_methods_349[] = { "add_result", "add_exception", "add_cancelled", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base._Waiter"; + rt.short_name = "_Waiter"; + rt.method_names = py_methods_349; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._Waiter.add_result"; + rf.short_name = "add_result"; + rf.receiver_type = "concurrent.futures._base._Waiter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._Waiter.add_exception"; + rf.short_name = "add_exception"; + rf.receiver_type = "concurrent.futures._base._Waiter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._Waiter.add_cancelled"; + rf.short_name = "add_cancelled"; + rf.receiver_type = "concurrent.futures._base._Waiter"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base._AsCompletedWaiter"; + rt.short_name = "_AsCompletedWaiter"; + static const char* py_bases_350[] = { "concurrent.futures._base._Waiter", NULL }; + rt.embedded_types = py_bases_350; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base._FirstCompletedWaiter"; + rt.short_name = "_FirstCompletedWaiter"; + static const char* py_bases_351[] = { "concurrent.futures._base._Waiter", NULL }; + rt.embedded_types = py_bases_351; + cbm_registry_add_type(reg, rt); + static const char* py_methods_352[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base._AllCompletedWaiter"; + rt.short_name = "_AllCompletedWaiter"; + rt.method_names = py_methods_352; + static const char* py_bases_353[] = { "concurrent.futures._base._Waiter", NULL }; + rt.embedded_types = py_bases_353; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._AllCompletedWaiter.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures._base._AllCompletedWaiter"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_354[] = { "__init__", "__enter__", "__exit__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures._base._AcquireFutures"; + rt.short_name = "_AcquireFutures"; + rt.method_names = py_methods_354; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._AcquireFutures.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures._base._AcquireFutures"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._AcquireFutures.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "concurrent.futures._base._AcquireFutures"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base._AcquireFutures.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "concurrent.futures._base._AcquireFutures"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.as_completed"; + rf.short_name = "as_completed"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures._base.wait"; + rf.short_name = "wait"; + cbm_registry_add_func(reg, rf); + + /* ===== module: concurrent.futures.interpreter ===== */ + static const char* py_methods_355[] = { "__call__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.interpreter._TaskFunc"; + rt.short_name = "_TaskFunc"; + rt.method_names = py_methods_355; + static const char* py_bases_356[] = { "concurrent.futures.interpreter.Protocol", NULL }; + rt.embedded_types = py_bases_356; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter._TaskFunc.__call__"; + rf.short_name = "__call__"; + rf.receiver_type = "concurrent.futures.interpreter._TaskFunc"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_357[] = { "prepare", "__init__", "run", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.interpreter.WorkerContext"; + rt.short_name = "WorkerContext"; + rt.method_names = py_methods_357; + static const char* py_bases_358[] = { "concurrent.futures.interpreter.ThreadWorkerContext", NULL }; + rt.embedded_types = py_bases_358; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter.WorkerContext.prepare"; + rf.short_name = "prepare"; + rf.receiver_type = "concurrent.futures.interpreter.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter.WorkerContext.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.interpreter.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter.WorkerContext.run"; + rf.short_name = "run"; + rf.receiver_type = "concurrent.futures.interpreter.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.interpreter.BrokenInterpreterPool"; + rt.short_name = "BrokenInterpreterPool"; + static const char* py_bases_359[] = { "concurrent.futures.interpreter.BrokenThreadPool", NULL }; + rt.embedded_types = py_bases_359; + cbm_registry_add_type(reg, rt); + static const char* py_methods_360[] = { "prepare_context", "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.interpreter.InterpreterPoolExecutor"; + rt.short_name = "InterpreterPoolExecutor"; + rt.method_names = py_methods_360; + static const char* py_bases_361[] = { "concurrent.futures.interpreter.ThreadPoolExecutor", NULL }; + rt.embedded_types = py_bases_361; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter.InterpreterPoolExecutor.prepare_context"; + rf.short_name = "prepare_context"; + rf.receiver_type = "concurrent.futures.interpreter.InterpreterPoolExecutor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter.InterpreterPoolExecutor.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.interpreter.InterpreterPoolExecutor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.interpreter.do_call"; + rf.short_name = "do_call"; + cbm_registry_add_func(reg, rf); + + /* ===== module: concurrent.futures.process ===== */ + static const char* py_methods_362[] = { "close", "wakeup", "clear", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._ThreadWakeup"; + rt.short_name = "_ThreadWakeup"; + rt.method_names = py_methods_362; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ThreadWakeup.close"; + rf.short_name = "close"; + rf.receiver_type = "concurrent.futures.process._ThreadWakeup"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ThreadWakeup.wakeup"; + rf.short_name = "wakeup"; + rf.receiver_type = "concurrent.futures.process._ThreadWakeup"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ThreadWakeup.clear"; + rf.short_name = "clear"; + rf.receiver_type = "concurrent.futures.process._ThreadWakeup"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_363[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._RemoteTraceback"; + rt.short_name = "_RemoteTraceback"; + rt.method_names = py_methods_363; + static const char* py_bases_364[] = { "concurrent.futures.process.Exception", NULL }; + rt.embedded_types = py_bases_364; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._RemoteTraceback.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._RemoteTraceback"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_365[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._ExceptionWithTraceback"; + rt.short_name = "_ExceptionWithTraceback"; + rt.method_names = py_methods_365; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExceptionWithTraceback.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._ExceptionWithTraceback"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_366[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._WorkItem"; + rt.short_name = "_WorkItem"; + rt.method_names = py_methods_366; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._WorkItem.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._WorkItem"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_367[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._ResultItem"; + rt.short_name = "_ResultItem"; + rt.method_names = py_methods_367; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ResultItem.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._ResultItem"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_368[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._CallItem"; + rt.short_name = "_CallItem"; + rt.method_names = py_methods_368; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._CallItem.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._CallItem"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_369[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._SafeQueue"; + rt.short_name = "_SafeQueue"; + rt.method_names = py_methods_369; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._SafeQueue.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._SafeQueue"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_370[] = { "__init__", "run", "add_call_item_to_queue", "wait_result_broken_or_wakeup", "process_result_item", "is_shutting_down", "terminate_broken", "flag_executor_shutting_down", "shutdown_workers", "join_executor_internals", "get_n_children_alive", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process._ExecutorManagerThread"; + rt.short_name = "_ExecutorManagerThread"; + rt.method_names = py_methods_370; + static const char* py_bases_371[] = { "concurrent.futures.process.Thread", NULL }; + rt.embedded_types = py_bases_371; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.run"; + rf.short_name = "run"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.add_call_item_to_queue"; + rf.short_name = "add_call_item_to_queue"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.wait_result_broken_or_wakeup"; + rf.short_name = "wait_result_broken_or_wakeup"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.process_result_item"; + rf.short_name = "process_result_item"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.is_shutting_down"; + rf.short_name = "is_shutting_down"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.terminate_broken"; + rf.short_name = "terminate_broken"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.flag_executor_shutting_down"; + rf.short_name = "flag_executor_shutting_down"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.shutdown_workers"; + rf.short_name = "shutdown_workers"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.join_executor_internals"; + rf.short_name = "join_executor_internals"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.get_n_children_alive"; + rf.short_name = "get_n_children_alive"; + rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process.BrokenProcessPool"; + rt.short_name = "BrokenProcessPool"; + static const char* py_bases_372[] = { "concurrent.futures.process.BrokenExecutor", NULL }; + rt.embedded_types = py_bases_372; + cbm_registry_add_type(reg, rt); + static const char* py_methods_373[] = { "__init__", "kill_workers", "terminate_workers", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.process.ProcessPoolExecutor"; + rt.short_name = "ProcessPoolExecutor"; + rt.method_names = py_methods_373; + static const char* py_bases_374[] = { "concurrent.futures.process.Executor", NULL }; + rt.embedded_types = py_bases_374; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process.ProcessPoolExecutor.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.process.ProcessPoolExecutor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process.ProcessPoolExecutor.kill_workers"; + rf.short_name = "kill_workers"; + rf.receiver_type = "concurrent.futures.process.ProcessPoolExecutor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.process.ProcessPoolExecutor.terminate_workers"; + rf.short_name = "terminate_workers"; + rf.receiver_type = "concurrent.futures.process.ProcessPoolExecutor"; + cbm_registry_add_func(reg, rf); + + /* ===== module: concurrent.futures.thread ===== */ + static const char* py_methods_375[] = { "__call__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.thread._ResolveTaskFunc"; + rt.short_name = "_ResolveTaskFunc"; + rt.method_names = py_methods_375; + static const char* py_bases_376[] = { "concurrent.futures.thread.Protocol", NULL }; + rt.embedded_types = py_bases_376; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread._ResolveTaskFunc.__call__"; + rf.short_name = "__call__"; + rf.receiver_type = "concurrent.futures.thread._ResolveTaskFunc"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_377[] = { "prepare", "__init__", "initialize", "finalize", "run", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.thread.WorkerContext"; + rt.short_name = "WorkerContext"; + rt.method_names = py_methods_377; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.WorkerContext.prepare"; + rf.short_name = "prepare"; + rf.receiver_type = "concurrent.futures.thread.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.WorkerContext.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.thread.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.WorkerContext.initialize"; + rf.short_name = "initialize"; + rf.receiver_type = "concurrent.futures.thread.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.WorkerContext.finalize"; + rf.short_name = "finalize"; + rf.receiver_type = "concurrent.futures.thread.WorkerContext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.WorkerContext.run"; + rf.short_name = "run"; + rf.receiver_type = "concurrent.futures.thread.WorkerContext"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_378[] = { "__init__", "run", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.thread._WorkItem"; + rt.short_name = "_WorkItem"; + rt.method_names = py_methods_378; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread._WorkItem.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.thread._WorkItem"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread._WorkItem.run"; + rf.short_name = "run"; + rf.receiver_type = "concurrent.futures.thread._WorkItem"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_379[] = { "__init__", "run", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.thread._WorkItem"; + rt.short_name = "_WorkItem"; + rt.method_names = py_methods_379; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread._WorkItem.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.thread._WorkItem"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread._WorkItem.run"; + rf.short_name = "run"; + rf.receiver_type = "concurrent.futures.thread._WorkItem"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.thread.BrokenThreadPool"; + rt.short_name = "BrokenThreadPool"; + static const char* py_bases_380[] = { "concurrent.futures.thread.BrokenExecutor", NULL }; + rt.embedded_types = py_bases_380; + cbm_registry_add_type(reg, rt); + static const char* py_methods_381[] = { "prepare_context", "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.futures.thread.ThreadPoolExecutor"; + rt.short_name = "ThreadPoolExecutor"; + rt.method_names = py_methods_381; + static const char* py_bases_382[] = { "concurrent.futures.thread.Executor", NULL }; + rt.embedded_types = py_bases_382; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.ThreadPoolExecutor.prepare_context"; + rf.short_name = "prepare_context"; + rf.receiver_type = "concurrent.futures.thread.ThreadPoolExecutor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.futures.thread.ThreadPoolExecutor.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.futures.thread.ThreadPoolExecutor"; + cbm_registry_add_func(reg, rf); + + /* ===== module: concurrent.interpreters ===== */ + static const char* py_methods_383[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters.ExecutionFailed"; + rt.short_name = "ExecutionFailed"; + rt.method_names = py_methods_383; + static const char* py_bases_384[] = { "concurrent.interpreters.InterpreterError", NULL }; + rt.embedded_types = py_bases_384; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.ExecutionFailed.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "concurrent.interpreters.ExecutionFailed"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_385[] = { "id", "whence", "is_running", "close", "prepare_main", "exec", "call", "call_in_thread", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters.Interpreter"; + rt.short_name = "Interpreter"; + rt.method_names = py_methods_385; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.id"; + rf.short_name = "id"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.whence"; + rf.short_name = "whence"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.is_running"; + rf.short_name = "is_running"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.close"; + rf.short_name = "close"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.prepare_main"; + rf.short_name = "prepare_main"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.exec"; + rf.short_name = "exec"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.call"; + rf.short_name = "call"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.Interpreter.call_in_thread"; + rf.short_name = "call_in_thread"; + rf.receiver_type = "concurrent.interpreters.Interpreter"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.create"; + rf.short_name = "create"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.list_all"; + rf.short_name = "list_all"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.get_current"; + rf.short_name = "get_current"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters.get_main"; + rf.short_name = "get_main"; + cbm_registry_add_func(reg, rf); + + /* ===== module: concurrent.interpreters._crossinterp ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters._crossinterp.ItemInterpreterDestroyed"; + rt.short_name = "ItemInterpreterDestroyed"; + static const char* py_bases_386[] = { "concurrent.interpreters._crossinterp.Exception", NULL }; + rt.embedded_types = py_bases_386; + cbm_registry_add_type(reg, rt); + static const char* py_methods_387[] = { "singleton", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters._crossinterp.UnboundItem"; + rt.short_name = "UnboundItem"; + rt.method_names = py_methods_387; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._crossinterp.UnboundItem.singleton"; + rf.short_name = "singleton"; + rf.receiver_type = "concurrent.interpreters._crossinterp.UnboundItem"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._crossinterp.serialize_unbound"; + rf.short_name = "serialize_unbound"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._crossinterp.resolve_unbound"; + rf.short_name = "resolve_unbound"; + cbm_registry_add_func(reg, rf); + + /* ===== module: concurrent.interpreters._queues ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters._queues.QueueEmpty"; + rt.short_name = "QueueEmpty"; + static const char* py_bases_388[] = { "concurrent.interpreters._queues.QueueError", "queue.Empty", NULL }; + rt.embedded_types = py_bases_388; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters._queues.QueueFull"; + rt.short_name = "QueueFull"; + static const char* py_bases_389[] = { "concurrent.interpreters._queues.QueueError", "queue.Full", NULL }; + rt.embedded_types = py_bases_389; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters._queues.ItemInterpreterDestroyed"; + rt.short_name = "ItemInterpreterDestroyed"; + static const char* py_bases_390[] = { "concurrent.interpreters._queues.QueueError", "_crossinterp.ItemInterpreterDestroyed", NULL }; + rt.embedded_types = py_bases_390; + cbm_registry_add_type(reg, rt); + static const char* py_methods_391[] = { "id", "unbounditems", "maxsize", "empty", "full", "qsize", "put", "put_nowait", "get", "get_nowait", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "concurrent.interpreters._queues.Queue"; + rt.short_name = "Queue"; + rt.method_names = py_methods_391; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.id"; + rf.short_name = "id"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.unbounditems"; + rf.short_name = "unbounditems"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.maxsize"; + rf.short_name = "maxsize"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.empty"; + rf.short_name = "empty"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.full"; + rf.short_name = "full"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.qsize"; + rf.short_name = "qsize"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.put"; + rf.short_name = "put"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.put_nowait"; + rf.short_name = "put_nowait"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.get"; + rf.short_name = "get"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.Queue.get_nowait"; + rf.short_name = "get_nowait"; + rf.receiver_type = "concurrent.interpreters._queues.Queue"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.create"; + rf.short_name = "create"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "concurrent.interpreters._queues.list_all"; + rf.short_name = "list_all"; + cbm_registry_add_func(reg, rf); + /* ===== module: contextlib ===== */ - static const char* py_methods_324[] = { "__enter__", "__exit__", NULL }; + static const char* py_methods_392[] = { "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.AbstractContextManager"; rt.short_name = "AbstractContextManager"; - rt.method_names = py_methods_324; - static const char* py_bases_325[] = { "contextlib.ABC", NULL }; - rt.embedded_types = py_bases_325; + rt.method_names = py_methods_392; + static const char* py_bases_393[] = { "contextlib.ABC", NULL }; + rt.embedded_types = py_bases_393; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.AbstractContextManager.__enter__"; @@ -6826,49 +7823,49 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.AbstractAsyncContextManager"; rt.short_name = "AbstractAsyncContextManager"; - static const char* py_bases_326[] = { "contextlib.ABC", NULL }; - rt.embedded_types = py_bases_326; + static const char* py_bases_394[] = { "contextlib.ABC", NULL }; + rt.embedded_types = py_bases_394; cbm_registry_add_type(reg, rt); - static const char* py_methods_327[] = { "__call__", NULL }; + static const char* py_methods_395[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.ContextDecorator"; rt.short_name = "ContextDecorator"; - rt.method_names = py_methods_327; + rt.method_names = py_methods_395; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.ContextDecorator.__call__"; rf.short_name = "__call__"; rf.receiver_type = "contextlib.ContextDecorator"; cbm_registry_add_func(reg, rf); - static const char* py_methods_328[] = { "__init__", NULL }; + static const char* py_methods_396[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._GeneratorContextManagerBase"; rt.short_name = "_GeneratorContextManagerBase"; - rt.method_names = py_methods_328; + rt.method_names = py_methods_396; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._GeneratorContextManagerBase.__init__"; rf.short_name = "__init__"; rf.receiver_type = "contextlib._GeneratorContextManagerBase"; cbm_registry_add_func(reg, rf); - static const char* py_methods_329[] = { "__exit__", NULL }; + static const char* py_methods_397[] = { "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._GeneratorContextManager"; rt.short_name = "_GeneratorContextManager"; - rt.method_names = py_methods_329; - static const char* py_bases_330[] = { "contextlib.ContextDecorator", NULL }; - rt.embedded_types = py_bases_330; + rt.method_names = py_methods_397; + static const char* py_bases_398[] = { "contextlib.ContextDecorator", NULL }; + rt.embedded_types = py_bases_398; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._GeneratorContextManager.__exit__"; rf.short_name = "__exit__"; rf.receiver_type = "contextlib._GeneratorContextManager"; cbm_registry_add_func(reg, rf); - static const char* py_methods_331[] = { "__call__", NULL }; + static const char* py_methods_399[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.AsyncContextDecorator"; rt.short_name = "AsyncContextDecorator"; - rt.method_names = py_methods_331; + rt.method_names = py_methods_399; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.AsyncContextDecorator.__call__"; @@ -6878,27 +7875,27 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._AsyncGeneratorContextManager"; rt.short_name = "_AsyncGeneratorContextManager"; - static const char* py_bases_332[] = { "contextlib.AsyncContextDecorator", NULL }; - rt.embedded_types = py_bases_332; + static const char* py_bases_400[] = { "contextlib.AsyncContextDecorator", NULL }; + rt.embedded_types = py_bases_400; cbm_registry_add_type(reg, rt); - static const char* py_methods_333[] = { "close", NULL }; + static const char* py_methods_401[] = { "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._SupportsClose"; rt.short_name = "_SupportsClose"; - rt.method_names = py_methods_333; - static const char* py_bases_334[] = { "contextlib.Protocol", NULL }; - rt.embedded_types = py_bases_334; + rt.method_names = py_methods_401; + static const char* py_bases_402[] = { "contextlib.Protocol", NULL }; + rt.embedded_types = py_bases_402; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._SupportsClose.close"; rf.short_name = "close"; rf.receiver_type = "contextlib._SupportsClose"; cbm_registry_add_func(reg, rf); - static const char* py_methods_335[] = { "__init__", "__exit__", NULL }; + static const char* py_methods_403[] = { "__init__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.closing"; rt.short_name = "closing"; - rt.method_names = py_methods_335; + rt.method_names = py_methods_403; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.closing.__init__"; @@ -6910,35 +7907,35 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "contextlib.closing"; cbm_registry_add_func(reg, rf); - static const char* py_methods_336[] = { "aclose", NULL }; + static const char* py_methods_404[] = { "aclose", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._SupportsAclose"; rt.short_name = "_SupportsAclose"; - rt.method_names = py_methods_336; - static const char* py_bases_337[] = { "contextlib.Protocol", NULL }; - rt.embedded_types = py_bases_337; + rt.method_names = py_methods_404; + static const char* py_bases_405[] = { "contextlib.Protocol", NULL }; + rt.embedded_types = py_bases_405; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._SupportsAclose.aclose"; rf.short_name = "aclose"; rf.receiver_type = "contextlib._SupportsAclose"; cbm_registry_add_func(reg, rf); - static const char* py_methods_338[] = { "__init__", NULL }; + static const char* py_methods_406[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.aclosing"; rt.short_name = "aclosing"; - rt.method_names = py_methods_338; + rt.method_names = py_methods_406; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.aclosing.__init__"; rf.short_name = "__init__"; rf.receiver_type = "contextlib.aclosing"; cbm_registry_add_func(reg, rf); - static const char* py_methods_339[] = { "__init__", "__exit__", NULL }; + static const char* py_methods_407[] = { "__init__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.suppress"; rt.short_name = "suppress"; - rt.method_names = py_methods_339; + rt.method_names = py_methods_407; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.suppress.__init__"; @@ -6950,13 +7947,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "contextlib.suppress"; cbm_registry_add_func(reg, rf); - static const char* py_methods_340[] = { "write", "flush", NULL }; + static const char* py_methods_408[] = { "write", "flush", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._SupportsRedirect"; rt.short_name = "_SupportsRedirect"; - rt.method_names = py_methods_340; - static const char* py_bases_341[] = { "contextlib.Protocol", NULL }; - rt.embedded_types = py_bases_341; + rt.method_names = py_methods_408; + static const char* py_bases_409[] = { "contextlib.Protocol", NULL }; + rt.embedded_types = py_bases_409; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._SupportsRedirect.write"; @@ -6968,11 +7965,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "flush"; rf.receiver_type = "contextlib._SupportsRedirect"; cbm_registry_add_func(reg, rf); - static const char* py_methods_342[] = { "__init__", "__exit__", NULL }; + static const char* py_methods_410[] = { "__init__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._RedirectStream"; rt.short_name = "_RedirectStream"; - rt.method_names = py_methods_342; + rt.method_names = py_methods_410; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._RedirectStream.__init__"; @@ -6992,11 +7989,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "contextlib.redirect_stderr"; rt.short_name = "redirect_stderr"; cbm_registry_add_type(reg, rt); - static const char* py_methods_343[] = { "enter_context", "push", "callback", "pop_all", NULL }; + static const char* py_methods_411[] = { "enter_context", "push", "callback", "pop_all", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib._BaseExitStack"; rt.short_name = "_BaseExitStack"; - rt.method_names = py_methods_343; + rt.method_names = py_methods_411; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib._BaseExitStack.enter_context"; @@ -7022,11 +8019,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "contextlib._BaseExitStackAbstract"; rt.short_name = "_BaseExitStackAbstract"; cbm_registry_add_type(reg, rt); - static const char* py_methods_344[] = { "close", "__enter__", "__exit__", NULL }; + static const char* py_methods_412[] = { "close", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.ExitStack"; rt.short_name = "ExitStack"; - rt.method_names = py_methods_344; + rt.method_names = py_methods_412; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.ExitStack.close"; @@ -7043,11 +8040,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "contextlib.ExitStack"; cbm_registry_add_func(reg, rf); - static const char* py_methods_345[] = { "enter_async_context", "push_async_exit", "push_async_callback", "aclose", NULL }; + static const char* py_methods_413[] = { "enter_async_context", "push_async_exit", "push_async_callback", "aclose", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.AsyncExitStack"; rt.short_name = "AsyncExitStack"; - rt.method_names = py_methods_345; + rt.method_names = py_methods_413; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.AsyncExitStack.enter_async_context"; @@ -7069,11 +8066,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "aclose"; rf.receiver_type = "contextlib.AsyncExitStack"; cbm_registry_add_func(reg, rf); - static const char* py_methods_346[] = { "__init__", "__enter__", "__exit__", NULL }; + static const char* py_methods_414[] = { "__init__", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.nullcontext"; rt.short_name = "nullcontext"; - rt.method_names = py_methods_346; + rt.method_names = py_methods_414; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.nullcontext.__init__"; @@ -7090,11 +8087,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "contextlib.nullcontext"; cbm_registry_add_func(reg, rf); - static const char* py_methods_347[] = { "__init__", "__enter__", "__exit__", NULL }; + static const char* py_methods_415[] = { "__init__", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "contextlib.chdir"; rt.short_name = "chdir"; - rt.method_names = py_methods_347; + rt.method_names = py_methods_415; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "contextlib.chdir.__init__"; @@ -7128,8 +8125,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "copy.Error"; rt.short_name = "Error"; - static const char* py_bases_348[] = { "copy.Exception", NULL }; - rt.embedded_types = py_bases_348; + static const char* py_bases_416[] = { "copy.Exception", NULL }; + rt.embedded_types = py_bases_416; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "copy.deepcopy"; @@ -7145,13 +8142,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: dataclasses ===== */ - static const char* py_methods_349[] = { "__call__", NULL }; + static const char* py_methods_417[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses._DataclassFactory"; rt.short_name = "_DataclassFactory"; - rt.method_names = py_methods_349; - static const char* py_bases_350[] = { "dataclasses.Protocol", NULL }; - rt.embedded_types = py_bases_350; + rt.method_names = py_methods_417; + static const char* py_bases_418[] = { "dataclasses.Protocol", NULL }; + rt.embedded_types = py_bases_418; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "dataclasses._DataclassFactory.__call__"; @@ -7161,29 +8158,29 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses._MISSING_TYPE"; rt.short_name = "_MISSING_TYPE"; - static const char* py_bases_351[] = { "enum.Enum", NULL }; - rt.embedded_types = py_bases_351; + static const char* py_bases_419[] = { "enum.Enum", NULL }; + rt.embedded_types = py_bases_419; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses.KW_ONLY"; rt.short_name = "KW_ONLY"; cbm_registry_add_type(reg, rt); - static const char* py_methods_352[] = { "__call__", NULL }; + static const char* py_methods_420[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses._DefaultFactory"; rt.short_name = "_DefaultFactory"; - rt.method_names = py_methods_352; + rt.method_names = py_methods_420; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "dataclasses._DefaultFactory.__call__"; rf.short_name = "__call__"; rf.receiver_type = "dataclasses._DefaultFactory"; cbm_registry_add_func(reg, rf); - static const char* py_methods_353[] = { "__init__", NULL }; + static const char* py_methods_421[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses.Field"; rt.short_name = "Field"; - rt.method_names = py_methods_353; + rt.method_names = py_methods_421; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "dataclasses.Field.__init__"; @@ -7193,14 +8190,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses.FrozenInstanceError"; rt.short_name = "FrozenInstanceError"; - static const char* py_bases_354[] = { "dataclasses.AttributeError", NULL }; - rt.embedded_types = py_bases_354; + static const char* py_bases_422[] = { "dataclasses.AttributeError", NULL }; + rt.embedded_types = py_bases_422; cbm_registry_add_type(reg, rt); - static const char* py_methods_355[] = { "__init__", NULL }; + static const char* py_methods_423[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "dataclasses.InitVar"; rt.short_name = "InitVar"; - rt.method_names = py_methods_355; + rt.method_names = py_methods_423; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "dataclasses.InitVar.__init__"; @@ -7241,11 +8238,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: datetime ===== */ - static const char* py_methods_356[] = { "tzname", "utcoffset", "dst", "fromutc", NULL }; + static const char* py_methods_424[] = { "tzname", "utcoffset", "dst", "fromutc", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime.tzinfo"; rt.short_name = "tzinfo"; - rt.method_names = py_methods_356; + rt.method_names = py_methods_424; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime.tzinfo.tzname"; @@ -7267,13 +8264,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "fromutc"; rf.receiver_type = "datetime.tzinfo"; cbm_registry_add_func(reg, rf); - static const char* py_methods_357[] = { "tzname", "utcoffset", "dst", NULL }; + static const char* py_methods_425[] = { "tzname", "utcoffset", "dst", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime.timezone"; rt.short_name = "timezone"; - rt.method_names = py_methods_357; - static const char* py_bases_358[] = { "datetime.tzinfo", NULL }; - rt.embedded_types = py_bases_358; + rt.method_names = py_methods_425; + static const char* py_bases_426[] = { "datetime.tzinfo", NULL }; + rt.embedded_types = py_bases_426; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime.timezone.tzname"; @@ -7290,11 +8287,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "dst"; rf.receiver_type = "datetime.timezone"; cbm_registry_add_func(reg, rf); - static const char* py_methods_359[] = { "year", "week", "weekday", NULL }; + static const char* py_methods_427[] = { "year", "week", "weekday", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime._IsoCalendarDate"; rt.short_name = "_IsoCalendarDate"; - rt.method_names = py_methods_359; + rt.method_names = py_methods_427; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime._IsoCalendarDate.year"; @@ -7311,11 +8308,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "weekday"; rf.receiver_type = "datetime._IsoCalendarDate"; cbm_registry_add_func(reg, rf); - static const char* py_methods_360[] = { "fromtimestamp", "today", "fromordinal", "fromisoformat", "fromisocalendar", "year", "month", "day", "ctime", "strptime", "strftime", "isoformat", "timetuple", "toordinal", "__replace__", "replace", "weekday", "isoweekday", "isocalendar", NULL }; + static const char* py_methods_428[] = { "fromtimestamp", "today", "fromordinal", "fromisoformat", "fromisocalendar", "year", "month", "day", "ctime", "strptime", "strftime", "isoformat", "timetuple", "toordinal", "__replace__", "replace", "weekday", "isoweekday", "isocalendar", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime.date"; rt.short_name = "date"; - rt.method_names = py_methods_360; + rt.method_names = py_methods_428; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime.date.fromtimestamp"; @@ -7412,11 +8409,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "isocalendar"; rf.receiver_type = "datetime.date"; cbm_registry_add_func(reg, rf); - static const char* py_methods_361[] = { "hour", "minute", "second", "microsecond", "tzinfo", "fold", "isoformat", "fromisoformat", "strptime", "strftime", "utcoffset", "tzname", "dst", "__replace__", "replace", NULL }; + static const char* py_methods_429[] = { "hour", "minute", "second", "microsecond", "tzinfo", "fold", "isoformat", "fromisoformat", "strptime", "strftime", "utcoffset", "tzname", "dst", "__replace__", "replace", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime.time"; rt.short_name = "time"; - rt.method_names = py_methods_361; + rt.method_names = py_methods_429; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime.time.hour"; @@ -7493,11 +8490,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "replace"; rf.receiver_type = "datetime.time"; cbm_registry_add_func(reg, rf); - static const char* py_methods_362[] = { "days", "seconds", "microseconds", "total_seconds", NULL }; + static const char* py_methods_430[] = { "days", "seconds", "microseconds", "total_seconds", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime.timedelta"; rt.short_name = "timedelta"; - rt.method_names = py_methods_362; + rt.method_names = py_methods_430; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime.timedelta.days"; @@ -7519,13 +8516,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "total_seconds"; rf.receiver_type = "datetime.timedelta"; cbm_registry_add_func(reg, rf); - static const char* py_methods_363[] = { "hour", "minute", "second", "microsecond", "tzinfo", "fold", "fromtimestamp", "utcfromtimestamp", "now", "utcnow", "combine", "timestamp", "utctimetuple", "date", "time", "timetz", "__replace__", "replace", "astimezone", "isoformat", "strptime", "utcoffset", "tzname", "dst", NULL }; + static const char* py_methods_431[] = { "hour", "minute", "second", "microsecond", "tzinfo", "fold", "fromtimestamp", "utcfromtimestamp", "now", "utcnow", "combine", "timestamp", "utctimetuple", "date", "time", "timetz", "__replace__", "replace", "astimezone", "isoformat", "strptime", "utcoffset", "tzname", "dst", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "datetime.datetime"; rt.short_name = "datetime"; - rt.method_names = py_methods_363; - static const char* py_bases_364[] = { "datetime.date", NULL }; - rt.embedded_types = py_bases_364; + rt.method_names = py_methods_431; + static const char* py_bases_432[] = { "datetime.date", NULL }; + rt.embedded_types = py_bases_432; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "datetime.datetime.hour"; @@ -7649,33 +8646,33 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: enum ===== */ - static const char* py_methods_365[] = { "__init__", NULL }; + static const char* py_methods_433[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.nonmember"; rt.short_name = "nonmember"; - rt.method_names = py_methods_365; + rt.method_names = py_methods_433; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.nonmember.__init__"; rf.short_name = "__init__"; rf.receiver_type = "enum.nonmember"; cbm_registry_add_func(reg, rf); - static const char* py_methods_366[] = { "__init__", NULL }; + static const char* py_methods_434[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.member"; rt.short_name = "member"; - rt.method_names = py_methods_366; + rt.method_names = py_methods_434; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.member.__init__"; rf.short_name = "__init__"; rf.receiver_type = "enum.member"; cbm_registry_add_func(reg, rf); - static const char* py_methods_367[] = { "__init__", "update", "member_names", NULL }; + static const char* py_methods_435[] = { "__init__", "update", "member_names", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum._EnumDict"; rt.short_name = "_EnumDict"; - rt.method_names = py_methods_367; + rt.method_names = py_methods_435; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum._EnumDict.__init__"; @@ -7692,13 +8689,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "member_names"; rf.receiver_type = "enum._EnumDict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_368[] = { "__new__", "__contains__", "__call__", "__signature__", NULL }; + static const char* py_methods_436[] = { "__new__", "__contains__", "__call__", "__signature__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.EnumMeta"; rt.short_name = "EnumMeta"; - rt.method_names = py_methods_368; - static const char* py_bases_369[] = { "enum.type", NULL }; - rt.embedded_types = py_bases_369; + rt.method_names = py_methods_436; + static const char* py_bases_437[] = { "enum.type", NULL }; + rt.embedded_types = py_bases_437; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.EnumMeta.__new__"; @@ -7723,14 +8720,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.property"; rt.short_name = "property"; - static const char* py_bases_370[] = { "types.DynamicClassAttribute", NULL }; - rt.embedded_types = py_bases_370; + static const char* py_bases_438[] = { "types.DynamicClassAttribute", NULL }; + rt.embedded_types = py_bases_438; cbm_registry_add_type(reg, rt); - static const char* py_methods_371[] = { "name", "value", "__copy__", "__deepcopy__", "__signature__", "_add_value_alias_", "_add_alias_", NULL }; + static const char* py_methods_439[] = { "name", "value", "__copy__", "__deepcopy__", "__signature__", "_add_value_alias_", "_add_alias_", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.Enum"; rt.short_name = "Enum"; - rt.method_names = py_methods_371; + rt.method_names = py_methods_439; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.Enum.name"; @@ -7770,42 +8767,42 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.ReprEnum"; rt.short_name = "ReprEnum"; - static const char* py_bases_372[] = { "enum.Enum", NULL }; - rt.embedded_types = py_bases_372; + static const char* py_bases_440[] = { "enum.Enum", NULL }; + rt.embedded_types = py_bases_440; cbm_registry_add_type(reg, rt); - static const char* py_methods_373[] = { "value", NULL }; + static const char* py_methods_441[] = { "value", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.IntEnum"; rt.short_name = "IntEnum"; - rt.method_names = py_methods_373; - static const char* py_bases_374[] = { "enum.int", "enum.ReprEnum", NULL }; - rt.embedded_types = py_bases_374; + rt.method_names = py_methods_441; + static const char* py_bases_442[] = { "enum.int", "enum.ReprEnum", NULL }; + rt.embedded_types = py_bases_442; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.IntEnum.value"; rf.short_name = "value"; rf.receiver_type = "enum.IntEnum"; cbm_registry_add_func(reg, rf); - static const char* py_methods_375[] = { "value", NULL }; + static const char* py_methods_443[] = { "value", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.IntEnum"; rt.short_name = "IntEnum"; - rt.method_names = py_methods_375; - static const char* py_bases_376[] = { "enum.int", "enum._IntEnumBase", NULL }; - rt.embedded_types = py_bases_376; + rt.method_names = py_methods_443; + static const char* py_bases_444[] = { "enum.int", "enum._IntEnumBase", NULL }; + rt.embedded_types = py_bases_444; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.IntEnum.value"; rf.short_name = "value"; rf.receiver_type = "enum.IntEnum"; cbm_registry_add_func(reg, rf); - static const char* py_methods_377[] = { "name", "value", "__iter__", "__len__", NULL }; + static const char* py_methods_445[] = { "name", "value", "__iter__", "__len__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.Flag"; rt.short_name = "Flag"; - rt.method_names = py_methods_377; - static const char* py_bases_378[] = { "enum.Enum", NULL }; - rt.embedded_types = py_bases_378; + rt.method_names = py_methods_445; + static const char* py_bases_446[] = { "enum.Enum", NULL }; + rt.embedded_types = py_bases_446; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.Flag.name"; @@ -7827,13 +8824,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__len__"; rf.receiver_type = "enum.Flag"; cbm_registry_add_func(reg, rf); - static const char* py_methods_379[] = { "value", NULL }; + static const char* py_methods_447[] = { "value", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.StrEnum"; rt.short_name = "StrEnum"; - rt.method_names = py_methods_379; - static const char* py_bases_380[] = { "enum.str", "enum.ReprEnum", NULL }; - rt.embedded_types = py_bases_380; + rt.method_names = py_methods_447; + static const char* py_bases_448[] = { "enum.str", "enum.ReprEnum", NULL }; + rt.embedded_types = py_bases_448; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.StrEnum.value"; @@ -7843,14 +8840,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.EnumCheck"; rt.short_name = "EnumCheck"; - static const char* py_bases_381[] = { "enum.StrEnum", NULL }; - rt.embedded_types = py_bases_381; + static const char* py_bases_449[] = { "enum.StrEnum", NULL }; + rt.embedded_types = py_bases_449; cbm_registry_add_type(reg, rt); - static const char* py_methods_382[] = { "__init__", "__call__", NULL }; + static const char* py_methods_450[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.verify"; rt.short_name = "verify"; - rt.method_names = py_methods_382; + rt.method_names = py_methods_450; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.verify.__init__"; @@ -7865,32 +8862,32 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.FlagBoundary"; rt.short_name = "FlagBoundary"; - static const char* py_bases_383[] = { "enum.StrEnum", NULL }; - rt.embedded_types = py_bases_383; + static const char* py_bases_451[] = { "enum.StrEnum", NULL }; + rt.embedded_types = py_bases_451; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.IntFlag"; rt.short_name = "IntFlag"; - static const char* py_bases_384[] = { "enum.int", "enum.ReprEnum", "enum.Flag", NULL }; - rt.embedded_types = py_bases_384; + static const char* py_bases_452[] = { "enum.int", "enum.ReprEnum", "enum.Flag", NULL }; + rt.embedded_types = py_bases_452; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.IntFlag"; rt.short_name = "IntFlag"; - static const char* py_bases_385[] = { "enum.int", "enum.ReprEnum", "enum.Flag", NULL }; - rt.embedded_types = py_bases_385; + static const char* py_bases_453[] = { "enum.int", "enum.ReprEnum", "enum.Flag", NULL }; + rt.embedded_types = py_bases_453; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.IntFlag"; rt.short_name = "IntFlag"; - static const char* py_bases_386[] = { "enum.int", "enum.Flag", NULL }; - rt.embedded_types = py_bases_386; + static const char* py_bases_454[] = { "enum.int", "enum.Flag", NULL }; + rt.embedded_types = py_bases_454; cbm_registry_add_type(reg, rt); - static const char* py_methods_387[] = { "value", NULL }; + static const char* py_methods_455[] = { "value", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "enum.auto"; rt.short_name = "auto"; - rt.method_names = py_methods_387; + rt.method_names = py_methods_455; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "enum.auto.value"; @@ -7938,20 +8935,20 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools._CacheInfo"; rt.short_name = "_CacheInfo"; - static const char* py_bases_388[] = { "functools.NamedTuple", NULL }; - rt.embedded_types = py_bases_388; + static const char* py_bases_456[] = { "functools.NamedTuple", NULL }; + rt.embedded_types = py_bases_456; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools._CacheParameters"; rt.short_name = "_CacheParameters"; - static const char* py_bases_389[] = { "functools.TypedDict", NULL }; - rt.embedded_types = py_bases_389; + static const char* py_bases_457[] = { "functools.TypedDict", NULL }; + rt.embedded_types = py_bases_457; cbm_registry_add_type(reg, rt); - static const char* py_methods_390[] = { "__call__", "cache_info", "cache_clear", "cache_parameters", NULL }; + static const char* py_methods_458[] = { "__call__", "cache_info", "cache_clear", "cache_parameters", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools._lru_cache_wrapper"; rt.short_name = "_lru_cache_wrapper"; - rt.method_names = py_methods_390; + rt.method_names = py_methods_458; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools._lru_cache_wrapper.__call__"; @@ -7973,33 +8970,33 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "cache_parameters"; rf.receiver_type = "functools._lru_cache_wrapper"; cbm_registry_add_func(reg, rf); - static const char* py_methods_391[] = { "__call__", NULL }; + static const char* py_methods_459[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools._Wrapped"; rt.short_name = "_Wrapped"; - rt.method_names = py_methods_391; + rt.method_names = py_methods_459; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools._Wrapped.__call__"; rf.short_name = "__call__"; rf.receiver_type = "functools._Wrapped"; cbm_registry_add_func(reg, rf); - static const char* py_methods_392[] = { "__call__", NULL }; + static const char* py_methods_460[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools._Wrapper"; rt.short_name = "_Wrapper"; - rt.method_names = py_methods_392; + rt.method_names = py_methods_460; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools._Wrapper.__call__"; rf.short_name = "__call__"; rf.receiver_type = "functools._Wrapper"; cbm_registry_add_func(reg, rf); - static const char* py_methods_393[] = { "func", "args", "keywords", "__call__", NULL }; + static const char* py_methods_461[] = { "func", "args", "keywords", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools.partial"; rt.short_name = "partial"; - rt.method_names = py_methods_393; + rt.method_names = py_methods_461; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools.partial.func"; @@ -8021,11 +9018,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__call__"; rf.receiver_type = "functools.partial"; cbm_registry_add_func(reg, rf); - static const char* py_methods_394[] = { "__new__", "__init__", NULL }; + static const char* py_methods_462[] = { "__new__", "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools.partialmethod"; rt.short_name = "partialmethod"; - rt.method_names = py_methods_394; + rt.method_names = py_methods_462; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools.partialmethod.__new__"; @@ -8037,11 +9034,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__init__"; rf.receiver_type = "functools.partialmethod"; cbm_registry_add_func(reg, rf); - static const char* py_methods_395[] = { "dispatch", "register", "__call__", NULL }; + static const char* py_methods_463[] = { "dispatch", "register", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools._SingleDispatchCallable"; rt.short_name = "_SingleDispatchCallable"; - rt.method_names = py_methods_395; + rt.method_names = py_methods_463; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools._SingleDispatchCallable.dispatch"; @@ -8058,11 +9055,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__call__"; rf.receiver_type = "functools._SingleDispatchCallable"; cbm_registry_add_func(reg, rf); - static const char* py_methods_396[] = { "__init__", "register", NULL }; + static const char* py_methods_464[] = { "__init__", "register", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools.singledispatchmethod"; rt.short_name = "singledispatchmethod"; - rt.method_names = py_methods_396; + rt.method_names = py_methods_464; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools.singledispatchmethod.__init__"; @@ -8074,11 +9071,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "register"; rf.receiver_type = "functools.singledispatchmethod"; cbm_registry_add_func(reg, rf); - static const char* py_methods_397[] = { "__init__", NULL }; + static const char* py_methods_465[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "functools.cached_property"; rt.short_name = "cached_property"; - rt.method_names = py_methods_397; + rt.method_names = py_methods_465; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "functools.cached_property.__init__"; @@ -8122,18 +9119,1004 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "cache"; cbm_registry_add_func(reg, rf); + /* ===== module: http ===== */ + static const char* py_methods_466[] = { "phrase", "description", "is_informational", "is_success", "is_redirection", "is_client_error", "is_server_error", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.HTTPStatus"; + rt.short_name = "HTTPStatus"; + rt.method_names = py_methods_466; + static const char* py_bases_467[] = { "http.IntEnum", NULL }; + rt.embedded_types = py_bases_467; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.phrase"; + rf.short_name = "phrase"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.description"; + rf.short_name = "description"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.is_informational"; + rf.short_name = "is_informational"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.is_success"; + rf.short_name = "is_success"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.is_redirection"; + rf.short_name = "is_redirection"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.is_client_error"; + rf.short_name = "is_client_error"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPStatus.is_server_error"; + rf.short_name = "is_server_error"; + rf.receiver_type = "http.HTTPStatus"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_468[] = { "description", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.HTTPMethod"; + rt.short_name = "HTTPMethod"; + rt.method_names = py_methods_468; + static const char* py_bases_469[] = { "http.StrEnum", NULL }; + rt.embedded_types = py_bases_469; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.HTTPMethod.description"; + rf.short_name = "description"; + rf.receiver_type = "http.HTTPMethod"; + cbm_registry_add_func(reg, rf); + + /* ===== module: http.client ===== */ + static const char* py_methods_470[] = { "getallmatchingheaders", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.HTTPMessage"; + rt.short_name = "HTTPMessage"; + rt.method_names = py_methods_470; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPMessage.getallmatchingheaders"; + rf.short_name = "getallmatchingheaders"; + rf.receiver_type = "http.client.HTTPMessage"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_471[] = { "__init__", "peek", "read", "read1", "readinto", "readline", "getheader", "getheaders", "isclosed", "__enter__", "__exit__", "info", "geturl", "getcode", "begin", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.HTTPResponse"; + rt.short_name = "HTTPResponse"; + rt.method_names = py_methods_471; + static const char* py_bases_472[] = { "io.BufferedIOBase", "http.client.BinaryIO", NULL }; + rt.embedded_types = py_bases_472; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.peek"; + rf.short_name = "peek"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.read"; + rf.short_name = "read"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.read1"; + rf.short_name = "read1"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.readinto"; + rf.short_name = "readinto"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.readline"; + rf.short_name = "readline"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.getheader"; + rf.short_name = "getheader"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.getheaders"; + rf.short_name = "getheaders"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.isclosed"; + rf.short_name = "isclosed"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.__enter__"; + rf.short_name = "__enter__"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.info"; + rf.short_name = "info"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.getcode"; + rf.short_name = "getcode"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPResponse.begin"; + rf.short_name = "begin"; + rf.receiver_type = "http.client.HTTPResponse"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_473[] = { "__init__", "request", "getresponse", "set_debuglevel", "get_proxy_response_headers", "set_tunnel", "connect", "close", "putrequest", "putheader", "endheaders", "send", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.HTTPConnection"; + rt.short_name = "HTTPConnection"; + rt.method_names = py_methods_473; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.request"; + rf.short_name = "request"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.getresponse"; + rf.short_name = "getresponse"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.set_debuglevel"; + rf.short_name = "set_debuglevel"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.get_proxy_response_headers"; + rf.short_name = "get_proxy_response_headers"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.set_tunnel"; + rf.short_name = "set_tunnel"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.connect"; + rf.short_name = "connect"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.close"; + rf.short_name = "close"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.putrequest"; + rf.short_name = "putrequest"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.putheader"; + rf.short_name = "putheader"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.endheaders"; + rf.short_name = "endheaders"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPConnection.send"; + rf.short_name = "send"; + rf.receiver_type = "http.client.HTTPConnection"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_474[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.HTTPSConnection"; + rt.short_name = "HTTPSConnection"; + rt.method_names = py_methods_474; + static const char* py_bases_475[] = { "http.client.HTTPConnection", NULL }; + rt.embedded_types = py_bases_475; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.HTTPSConnection.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.HTTPSConnection"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.HTTPException"; + rt.short_name = "HTTPException"; + static const char* py_bases_476[] = { "http.client.Exception", NULL }; + rt.embedded_types = py_bases_476; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.NotConnected"; + rt.short_name = "NotConnected"; + static const char* py_bases_477[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_477; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.InvalidURL"; + rt.short_name = "InvalidURL"; + static const char* py_bases_478[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_478; + cbm_registry_add_type(reg, rt); + static const char* py_methods_479[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.UnknownProtocol"; + rt.short_name = "UnknownProtocol"; + rt.method_names = py_methods_479; + static const char* py_bases_480[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_480; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.UnknownProtocol.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.UnknownProtocol"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.UnknownTransferEncoding"; + rt.short_name = "UnknownTransferEncoding"; + static const char* py_bases_481[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_481; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.UnimplementedFileMode"; + rt.short_name = "UnimplementedFileMode"; + static const char* py_bases_482[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_482; + cbm_registry_add_type(reg, rt); + static const char* py_methods_483[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.IncompleteRead"; + rt.short_name = "IncompleteRead"; + rt.method_names = py_methods_483; + static const char* py_bases_484[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_484; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.IncompleteRead.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.IncompleteRead"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.ImproperConnectionState"; + rt.short_name = "ImproperConnectionState"; + static const char* py_bases_485[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_485; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.CannotSendRequest"; + rt.short_name = "CannotSendRequest"; + static const char* py_bases_486[] = { "http.client.ImproperConnectionState", NULL }; + rt.embedded_types = py_bases_486; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.CannotSendHeader"; + rt.short_name = "CannotSendHeader"; + static const char* py_bases_487[] = { "http.client.ImproperConnectionState", NULL }; + rt.embedded_types = py_bases_487; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.ResponseNotReady"; + rt.short_name = "ResponseNotReady"; + static const char* py_bases_488[] = { "http.client.ImproperConnectionState", NULL }; + rt.embedded_types = py_bases_488; + cbm_registry_add_type(reg, rt); + static const char* py_methods_489[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.BadStatusLine"; + rt.short_name = "BadStatusLine"; + rt.method_names = py_methods_489; + static const char* py_bases_490[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_490; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.BadStatusLine.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.BadStatusLine"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_491[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.LineTooLong"; + rt.short_name = "LineTooLong"; + rt.method_names = py_methods_491; + static const char* py_bases_492[] = { "http.client.HTTPException", NULL }; + rt.embedded_types = py_bases_492; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.LineTooLong.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.client.LineTooLong"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.client.RemoteDisconnected"; + rt.short_name = "RemoteDisconnected"; + static const char* py_bases_493[] = { "http.client.ConnectionResetError", "http.client.BadStatusLine", NULL }; + rt.embedded_types = py_bases_493; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.client.parse_headers"; + rf.short_name = "parse_headers"; + cbm_registry_add_func(reg, rf); + + /* ===== module: http.cookiejar ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.LoadError"; + rt.short_name = "LoadError"; + static const char* py_bases_494[] = { "http.cookiejar.OSError", NULL }; + rt.embedded_types = py_bases_494; + cbm_registry_add_type(reg, rt); + static const char* py_methods_495[] = { "__init__", "add_cookie_header", "extract_cookies", "set_policy", "make_cookies", "set_cookie", "set_cookie_if_ok", "clear", "clear_session_cookies", "clear_expired_cookies", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.CookieJar"; + rt.short_name = "CookieJar"; + rt.method_names = py_methods_495; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.add_cookie_header"; + rf.short_name = "add_cookie_header"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.extract_cookies"; + rf.short_name = "extract_cookies"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.set_policy"; + rf.short_name = "set_policy"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.make_cookies"; + rf.short_name = "make_cookies"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.set_cookie"; + rf.short_name = "set_cookie"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.set_cookie_if_ok"; + rf.short_name = "set_cookie_if_ok"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.clear"; + rf.short_name = "clear"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.clear_session_cookies"; + rf.short_name = "clear_session_cookies"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookieJar.clear_expired_cookies"; + rf.short_name = "clear_expired_cookies"; + rf.receiver_type = "http.cookiejar.CookieJar"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_496[] = { "__init__", "save", "load", "revert", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.FileCookieJar"; + rt.short_name = "FileCookieJar"; + rt.method_names = py_methods_496; + static const char* py_bases_497[] = { "http.cookiejar.CookieJar", NULL }; + rt.embedded_types = py_bases_497; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.FileCookieJar.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.cookiejar.FileCookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.FileCookieJar.save"; + rf.short_name = "save"; + rf.receiver_type = "http.cookiejar.FileCookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.FileCookieJar.load"; + rf.short_name = "load"; + rf.receiver_type = "http.cookiejar.FileCookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.FileCookieJar.revert"; + rf.short_name = "revert"; + rf.receiver_type = "http.cookiejar.FileCookieJar"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.MozillaCookieJar"; + rt.short_name = "MozillaCookieJar"; + static const char* py_bases_498[] = { "http.cookiejar.FileCookieJar", NULL }; + rt.embedded_types = py_bases_498; + cbm_registry_add_type(reg, rt); + static const char* py_methods_499[] = { "as_lwp_str", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.LWPCookieJar"; + rt.short_name = "LWPCookieJar"; + rt.method_names = py_methods_499; + static const char* py_bases_500[] = { "http.cookiejar.FileCookieJar", NULL }; + rt.embedded_types = py_bases_500; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.LWPCookieJar.as_lwp_str"; + rf.short_name = "as_lwp_str"; + rf.receiver_type = "http.cookiejar.LWPCookieJar"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_501[] = { "set_ok", "return_ok", "domain_return_ok", "path_return_ok", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.CookiePolicy"; + rt.short_name = "CookiePolicy"; + rt.method_names = py_methods_501; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookiePolicy.set_ok"; + rf.short_name = "set_ok"; + rf.receiver_type = "http.cookiejar.CookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookiePolicy.return_ok"; + rf.short_name = "return_ok"; + rf.receiver_type = "http.cookiejar.CookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookiePolicy.domain_return_ok"; + rf.short_name = "domain_return_ok"; + rf.receiver_type = "http.cookiejar.CookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.CookiePolicy.path_return_ok"; + rf.short_name = "path_return_ok"; + rf.receiver_type = "http.cookiejar.CookiePolicy"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_502[] = { "__init__", "blocked_domains", "set_blocked_domains", "is_blocked", "allowed_domains", "set_allowed_domains", "is_not_allowed", "set_ok_version", "set_ok_verifiability", "set_ok_name", "set_ok_path", "set_ok_domain", "set_ok_port", "return_ok_version", "return_ok_verifiability", "return_ok_secure", "return_ok_expires", "return_ok_port", "return_ok_domain", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.DefaultCookiePolicy"; + rt.short_name = "DefaultCookiePolicy"; + rt.method_names = py_methods_502; + static const char* py_bases_503[] = { "http.cookiejar.CookiePolicy", NULL }; + rt.embedded_types = py_bases_503; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.blocked_domains"; + rf.short_name = "blocked_domains"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_blocked_domains"; + rf.short_name = "set_blocked_domains"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.is_blocked"; + rf.short_name = "is_blocked"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.allowed_domains"; + rf.short_name = "allowed_domains"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_allowed_domains"; + rf.short_name = "set_allowed_domains"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.is_not_allowed"; + rf.short_name = "is_not_allowed"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_version"; + rf.short_name = "set_ok_version"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_verifiability"; + rf.short_name = "set_ok_verifiability"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_name"; + rf.short_name = "set_ok_name"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_path"; + rf.short_name = "set_ok_path"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_domain"; + rf.short_name = "set_ok_domain"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_port"; + rf.short_name = "set_ok_port"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_version"; + rf.short_name = "return_ok_version"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_verifiability"; + rf.short_name = "return_ok_verifiability"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_secure"; + rf.short_name = "return_ok_secure"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_expires"; + rf.short_name = "return_ok_expires"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_port"; + rf.short_name = "return_ok_port"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_domain"; + rf.short_name = "return_ok_domain"; + rf.receiver_type = "http.cookiejar.DefaultCookiePolicy"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_504[] = { "__init__", "has_nonstandard_attr", "get_nonstandard_attr", "set_nonstandard_attr", "is_expired", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookiejar.Cookie"; + rt.short_name = "Cookie"; + rt.method_names = py_methods_504; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.Cookie.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.cookiejar.Cookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.Cookie.has_nonstandard_attr"; + rf.short_name = "has_nonstandard_attr"; + rf.receiver_type = "http.cookiejar.Cookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.Cookie.get_nonstandard_attr"; + rf.short_name = "get_nonstandard_attr"; + rf.receiver_type = "http.cookiejar.Cookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.Cookie.set_nonstandard_attr"; + rf.short_name = "set_nonstandard_attr"; + rf.receiver_type = "http.cookiejar.Cookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookiejar.Cookie.is_expired"; + rf.short_name = "is_expired"; + rf.receiver_type = "http.cookiejar.Cookie"; + cbm_registry_add_func(reg, rf); + + /* ===== module: http.cookies ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookies.CookieError"; + rt.short_name = "CookieError"; + static const char* py_bases_505[] = { "http.cookies.Exception", NULL }; + rt.embedded_types = py_bases_505; + cbm_registry_add_type(reg, rt); + static const char* py_methods_506[] = { "value", "coded_value", "key", "__init__", "set", "setdefault", "update", "isReservedKey", "output", "js_output", "OutputString", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookies.Morsel"; + rt.short_name = "Morsel"; + rt.method_names = py_methods_506; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.value"; + rf.short_name = "value"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.coded_value"; + rf.short_name = "coded_value"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.key"; + rf.short_name = "key"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.set"; + rf.short_name = "set"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.setdefault"; + rf.short_name = "setdefault"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.update"; + rf.short_name = "update"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.isReservedKey"; + rf.short_name = "isReservedKey"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.output"; + rf.short_name = "output"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.js_output"; + rf.short_name = "js_output"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.Morsel.OutputString"; + rf.short_name = "OutputString"; + rf.receiver_type = "http.cookies.Morsel"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_507[] = { "__init__", "value_decode", "value_encode", "output", "js_output", "load", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookies.BaseCookie"; + rt.short_name = "BaseCookie"; + rt.method_names = py_methods_507; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.BaseCookie.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.cookies.BaseCookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.BaseCookie.value_decode"; + rf.short_name = "value_decode"; + rf.receiver_type = "http.cookies.BaseCookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.BaseCookie.value_encode"; + rf.short_name = "value_encode"; + rf.receiver_type = "http.cookies.BaseCookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.BaseCookie.output"; + rf.short_name = "output"; + rf.receiver_type = "http.cookies.BaseCookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.BaseCookie.js_output"; + rf.short_name = "js_output"; + rf.receiver_type = "http.cookies.BaseCookie"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.cookies.BaseCookie.load"; + rf.short_name = "load"; + rf.receiver_type = "http.cookies.BaseCookie"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.cookies.SimpleCookie"; + rt.short_name = "SimpleCookie"; + cbm_registry_add_type(reg, rt); + + /* ===== module: http.server ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.HTTPServer"; + rt.short_name = "HTTPServer"; + static const char* py_bases_508[] = { "socketserver.TCPServer", NULL }; + rt.embedded_types = py_bases_508; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.ThreadingHTTPServer"; + rt.short_name = "ThreadingHTTPServer"; + static const char* py_bases_509[] = { "socketserver.ThreadingMixIn", "http.server.HTTPServer", NULL }; + rt.embedded_types = py_bases_509; + cbm_registry_add_type(reg, rt); + static const char* py_methods_510[] = { "create_default_context", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server._SSLModule"; + rt.short_name = "_SSLModule"; + rt.method_names = py_methods_510; + static const char* py_bases_511[] = { "http.server.Protocol", NULL }; + rt.embedded_types = py_bases_511; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server._SSLModule.create_default_context"; + rf.short_name = "create_default_context"; + rf.receiver_type = "http.server._SSLModule"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_512[] = { "__init__", "server_activate", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.HTTPSServer"; + rt.short_name = "HTTPSServer"; + rt.method_names = py_methods_512; + static const char* py_bases_513[] = { "http.server.HTTPServer", NULL }; + rt.embedded_types = py_bases_513; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.HTTPSServer.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.server.HTTPSServer"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.HTTPSServer.server_activate"; + rf.short_name = "server_activate"; + rf.receiver_type = "http.server.HTTPSServer"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.ThreadingHTTPSServer"; + rt.short_name = "ThreadingHTTPSServer"; + static const char* py_bases_514[] = { "socketserver.ThreadingMixIn", "http.server.HTTPSServer", NULL }; + rt.embedded_types = py_bases_514; + cbm_registry_add_type(reg, rt); + static const char* py_methods_515[] = { "handle_one_request", "handle_expect_100", "send_error", "send_response", "send_header", "send_response_only", "end_headers", "flush_headers", "log_request", "log_error", "log_message", "version_string", "date_time_string", "log_date_time_string", "address_string", "parse_request", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.BaseHTTPRequestHandler"; + rt.short_name = "BaseHTTPRequestHandler"; + rt.method_names = py_methods_515; + static const char* py_bases_516[] = { "socketserver.StreamRequestHandler", NULL }; + rt.embedded_types = py_bases_516; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.handle_one_request"; + rf.short_name = "handle_one_request"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.handle_expect_100"; + rf.short_name = "handle_expect_100"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_error"; + rf.short_name = "send_error"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_response"; + rf.short_name = "send_response"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_header"; + rf.short_name = "send_header"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_response_only"; + rf.short_name = "send_response_only"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.end_headers"; + rf.short_name = "end_headers"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.flush_headers"; + rf.short_name = "flush_headers"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_request"; + rf.short_name = "log_request"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_error"; + rf.short_name = "log_error"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_message"; + rf.short_name = "log_message"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.version_string"; + rf.short_name = "version_string"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.date_time_string"; + rf.short_name = "date_time_string"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_date_time_string"; + rf.short_name = "log_date_time_string"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.address_string"; + rf.short_name = "address_string"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.BaseHTTPRequestHandler.parse_request"; + rf.short_name = "parse_request"; + rf.receiver_type = "http.server.BaseHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_517[] = { "__init__", "do_GET", "do_HEAD", "send_head", "list_directory", "translate_path", "copyfile", "guess_type", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.SimpleHTTPRequestHandler"; + rt.short_name = "SimpleHTTPRequestHandler"; + rt.method_names = py_methods_517; + static const char* py_bases_518[] = { "http.server.BaseHTTPRequestHandler", NULL }; + rt.embedded_types = py_bases_518; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.do_GET"; + rf.short_name = "do_GET"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.do_HEAD"; + rf.short_name = "do_HEAD"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.send_head"; + rf.short_name = "send_head"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.list_directory"; + rf.short_name = "list_directory"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.translate_path"; + rf.short_name = "translate_path"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.copyfile"; + rf.short_name = "copyfile"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.SimpleHTTPRequestHandler.guess_type"; + rf.short_name = "guess_type"; + rf.receiver_type = "http.server.SimpleHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_519[] = { "do_POST", "is_cgi", "is_executable", "is_python", "run_cgi", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.CGIHTTPRequestHandler"; + rt.short_name = "CGIHTTPRequestHandler"; + rt.method_names = py_methods_519; + static const char* py_bases_520[] = { "http.server.SimpleHTTPRequestHandler", NULL }; + rt.embedded_types = py_bases_520; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.do_POST"; + rf.short_name = "do_POST"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_cgi"; + rf.short_name = "is_cgi"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_executable"; + rf.short_name = "is_executable"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_python"; + rf.short_name = "is_python"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.run_cgi"; + rf.short_name = "run_cgi"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_521[] = { "do_POST", "is_cgi", "is_executable", "is_python", "run_cgi", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "http.server.CGIHTTPRequestHandler"; + rt.short_name = "CGIHTTPRequestHandler"; + rt.method_names = py_methods_521; + static const char* py_bases_522[] = { "http.server.SimpleHTTPRequestHandler", NULL }; + rt.embedded_types = py_bases_522; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.do_POST"; + rf.short_name = "do_POST"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_cgi"; + rf.short_name = "is_cgi"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_executable"; + rf.short_name = "is_executable"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_python"; + rf.short_name = "is_python"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.CGIHTTPRequestHandler.run_cgi"; + rf.short_name = "run_cgi"; + rf.receiver_type = "http.server.CGIHTTPRequestHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "http.server.executable"; + rf.short_name = "executable"; + cbm_registry_add_func(reg, rf); + /* ===== module: inspect ===== */ memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.EndOfBlock"; rt.short_name = "EndOfBlock"; - static const char* py_bases_398[] = { "inspect.Exception", NULL }; - rt.embedded_types = py_bases_398; + static const char* py_bases_523[] = { "inspect.Exception", NULL }; + rt.embedded_types = py_bases_523; cbm_registry_add_type(reg, rt); - static const char* py_methods_399[] = { "tokeneater", NULL }; + static const char* py_methods_524[] = { "tokeneater", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.BlockFinder"; rt.short_name = "BlockFinder"; - rt.method_names = py_methods_399; + rt.method_names = py_methods_524; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "inspect.BlockFinder.tokeneater"; @@ -8156,11 +10139,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "inspect._empty"; rt.short_name = "_empty"; cbm_registry_add_type(reg, rt); - static const char* py_methods_400[] = { "__init__", "parameters", "return_annotation", "bind", "bind_partial", "replace", "from_callable", "format", NULL }; + static const char* py_methods_525[] = { "__init__", "parameters", "return_annotation", "bind", "bind_partial", "replace", "from_callable", "format", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Signature"; rt.short_name = "Signature"; - rt.method_names = py_methods_400; + rt.method_names = py_methods_525; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "inspect.Signature.__init__"; @@ -8202,24 +10185,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "format"; rf.receiver_type = "inspect.Signature"; cbm_registry_add_func(reg, rf); - static const char* py_methods_401[] = { "description", NULL }; + static const char* py_methods_526[] = { "description", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect._ParameterKind"; rt.short_name = "_ParameterKind"; - rt.method_names = py_methods_401; - static const char* py_bases_402[] = { "enum.IntEnum", NULL }; - rt.embedded_types = py_bases_402; + rt.method_names = py_methods_526; + static const char* py_bases_527[] = { "enum.IntEnum", NULL }; + rt.embedded_types = py_bases_527; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "inspect._ParameterKind.description"; rf.short_name = "description"; rf.receiver_type = "inspect._ParameterKind"; cbm_registry_add_func(reg, rf); - static const char* py_methods_403[] = { "__init__", "name", "default", "kind", "annotation", "replace", NULL }; + static const char* py_methods_528[] = { "__init__", "name", "default", "kind", "annotation", "replace", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Parameter"; rt.short_name = "Parameter"; - rt.method_names = py_methods_403; + rt.method_names = py_methods_528; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "inspect.Parameter.__init__"; @@ -8251,11 +10234,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "replace"; rf.receiver_type = "inspect.Parameter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_404[] = { "args", "kwargs", "signature", "__init__", "apply_defaults", NULL }; + static const char* py_methods_529[] = { "args", "kwargs", "signature", "__init__", "apply_defaults", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.BoundArguments"; rt.short_name = "BoundArguments"; - rt.method_names = py_methods_404; + rt.method_names = py_methods_529; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "inspect.BoundArguments.args"; @@ -8285,98 +10268,98 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Arguments"; rt.short_name = "Arguments"; - static const char* py_bases_405[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_405; + static const char* py_bases_530[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_530; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.ArgSpec"; rt.short_name = "ArgSpec"; - static const char* py_bases_406[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_406; + static const char* py_bases_531[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_531; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.FullArgSpec"; rt.short_name = "FullArgSpec"; - static const char* py_bases_407[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_407; + static const char* py_bases_532[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_532; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.ArgInfo"; rt.short_name = "ArgInfo"; - static const char* py_bases_408[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_408; + static const char* py_bases_533[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_533; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.ClosureVars"; rt.short_name = "ClosureVars"; - static const char* py_bases_409[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_409; + static const char* py_bases_534[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_534; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect._Traceback"; rt.short_name = "_Traceback"; - static const char* py_bases_410[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_410; + static const char* py_bases_535[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_535; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect._FrameInfo"; rt.short_name = "_FrameInfo"; - static const char* py_bases_411[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_411; + static const char* py_bases_536[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_536; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Traceback"; rt.short_name = "Traceback"; - static const char* py_bases_412[] = { "inspect._Traceback", NULL }; - rt.embedded_types = py_bases_412; + static const char* py_bases_537[] = { "inspect._Traceback", NULL }; + rt.embedded_types = py_bases_537; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.FrameInfo"; rt.short_name = "FrameInfo"; - static const char* py_bases_413[] = { "inspect._FrameInfo", NULL }; - rt.embedded_types = py_bases_413; + static const char* py_bases_538[] = { "inspect._FrameInfo", NULL }; + rt.embedded_types = py_bases_538; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Traceback"; rt.short_name = "Traceback"; - static const char* py_bases_414[] = { "inspect._Traceback", NULL }; - rt.embedded_types = py_bases_414; + static const char* py_bases_539[] = { "inspect._Traceback", NULL }; + rt.embedded_types = py_bases_539; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.FrameInfo"; rt.short_name = "FrameInfo"; - static const char* py_bases_415[] = { "inspect._FrameInfo", NULL }; - rt.embedded_types = py_bases_415; + static const char* py_bases_540[] = { "inspect._FrameInfo", NULL }; + rt.embedded_types = py_bases_540; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Traceback"; rt.short_name = "Traceback"; - static const char* py_bases_416[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_416; + static const char* py_bases_541[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_541; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.FrameInfo"; rt.short_name = "FrameInfo"; - static const char* py_bases_417[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_417; + static const char* py_bases_542[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_542; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.Attribute"; rt.short_name = "Attribute"; - static const char* py_bases_418[] = { "inspect.NamedTuple", NULL }; - rt.embedded_types = py_bases_418; + static const char* py_bases_543[] = { "inspect.NamedTuple", NULL }; + rt.embedded_types = py_bases_543; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.ClassFoundException"; rt.short_name = "ClassFoundException"; - static const char* py_bases_419[] = { "inspect.Exception", NULL }; - rt.embedded_types = py_bases_419; + static const char* py_bases_544[] = { "inspect.Exception", NULL }; + rt.embedded_types = py_bases_544; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "inspect.BufferFlags"; rt.short_name = "BufferFlags"; - static const char* py_bases_420[] = { "enum.IntFlag", NULL }; - rt.embedded_types = py_bases_420; + static const char* py_bases_545[] = { "enum.IntFlag", NULL }; + rt.embedded_types = py_bases_545; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "inspect.getmembers"; @@ -8663,49 +10646,49 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.UnsupportedOperation"; rt.short_name = "UnsupportedOperation"; - static const char* py_bases_421[] = { "io.OSError", "io.ValueError", NULL }; - rt.embedded_types = py_bases_421; + static const char* py_bases_546[] = { "io.OSError", "io.ValueError", NULL }; + rt.embedded_types = py_bases_546; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.IOBase"; rt.short_name = "IOBase"; - static const char* py_bases_422[] = { "io._IOBase", NULL }; - rt.embedded_types = py_bases_422; + static const char* py_bases_547[] = { "io._IOBase", NULL }; + rt.embedded_types = py_bases_547; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.RawIOBase"; rt.short_name = "RawIOBase"; - static const char* py_bases_423[] = { "io._RawIOBase", "io.IOBase", NULL }; - rt.embedded_types = py_bases_423; + static const char* py_bases_548[] = { "io._RawIOBase", "io.IOBase", NULL }; + rt.embedded_types = py_bases_548; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.BufferedIOBase"; rt.short_name = "BufferedIOBase"; - static const char* py_bases_424[] = { "io._BufferedIOBase", "io.IOBase", NULL }; - rt.embedded_types = py_bases_424; + static const char* py_bases_549[] = { "io._BufferedIOBase", "io.IOBase", NULL }; + rt.embedded_types = py_bases_549; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.TextIOBase"; rt.short_name = "TextIOBase"; - static const char* py_bases_425[] = { "io._TextIOBase", "io.IOBase", NULL }; - rt.embedded_types = py_bases_425; + static const char* py_bases_550[] = { "io._TextIOBase", "io.IOBase", NULL }; + rt.embedded_types = py_bases_550; cbm_registry_add_type(reg, rt); - static const char* py_methods_426[] = { "read", NULL }; + static const char* py_methods_551[] = { "read", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.Reader"; rt.short_name = "Reader"; - rt.method_names = py_methods_426; + rt.method_names = py_methods_551; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "io.Reader.read"; rf.short_name = "read"; rf.receiver_type = "io.Reader"; cbm_registry_add_func(reg, rf); - static const char* py_methods_427[] = { "write", NULL }; + static const char* py_methods_552[] = { "write", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "io.Writer"; rt.short_name = "Writer"; - rt.method_names = py_methods_427; + rt.method_names = py_methods_552; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "io.Writer.write"; @@ -8730,11 +10713,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "itertools.accumulate"; rt.short_name = "accumulate"; cbm_registry_add_type(reg, rt); - static const char* py_methods_428[] = { "from_iterable", NULL }; + static const char* py_methods_553[] = { "from_iterable", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "itertools.chain"; rt.short_name = "chain"; - rt.method_names = py_methods_428; + rt.method_names = py_methods_553; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "itertools.chain.from_iterable"; @@ -8793,11 +10776,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "itertools.pairwise"; rt.short_name = "pairwise"; cbm_registry_add_type(reg, rt); - static const char* py_methods_429[] = { "__new__", NULL }; + static const char* py_methods_554[] = { "__new__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "itertools.batched"; rt.short_name = "batched"; - rt.method_names = py_methods_429; + rt.method_names = py_methods_554; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "itertools.batched.__new__"; @@ -8832,24 +10815,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: json.decoder ===== */ - static const char* py_methods_430[] = { "__init__", NULL }; + static const char* py_methods_555[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "json.decoder.JSONDecodeError"; rt.short_name = "JSONDecodeError"; - rt.method_names = py_methods_430; - static const char* py_bases_431[] = { "json.decoder.ValueError", NULL }; - rt.embedded_types = py_bases_431; + rt.method_names = py_methods_555; + static const char* py_bases_556[] = { "json.decoder.ValueError", NULL }; + rt.embedded_types = py_bases_556; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "json.decoder.JSONDecodeError.__init__"; rf.short_name = "__init__"; rf.receiver_type = "json.decoder.JSONDecodeError"; cbm_registry_add_func(reg, rf); - static const char* py_methods_432[] = { "__init__", "decode", "raw_decode", NULL }; + static const char* py_methods_557[] = { "__init__", "decode", "raw_decode", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "json.decoder.JSONDecoder"; rt.short_name = "JSONDecoder"; - rt.method_names = py_methods_432; + rt.method_names = py_methods_557; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "json.decoder.JSONDecoder.__init__"; @@ -8868,11 +10851,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: json.encoder ===== */ - static const char* py_methods_433[] = { "__init__", "default", "encode", "iterencode", NULL }; + static const char* py_methods_558[] = { "__init__", "default", "encode", "iterencode", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "json.encoder.JSONEncoder"; rt.short_name = "JSONEncoder"; - rt.method_names = py_methods_433; + rt.method_names = py_methods_558; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "json.encoder.JSONEncoder.__init__"; @@ -8918,37 +10901,37 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: logging ===== */ - static const char* py_methods_434[] = { "filter", NULL }; + static const char* py_methods_559[] = { "filter", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging._SupportsFilter"; rt.short_name = "_SupportsFilter"; - rt.method_names = py_methods_434; - static const char* py_bases_435[] = { "logging.Protocol", NULL }; - rt.embedded_types = py_bases_435; + rt.method_names = py_methods_559; + static const char* py_bases_560[] = { "logging.Protocol", NULL }; + rt.embedded_types = py_bases_560; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging._SupportsFilter.filter"; rf.short_name = "filter"; rf.receiver_type = "logging._SupportsFilter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_436[] = { "filter", NULL }; + static const char* py_methods_561[] = { "filter", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging._SupportsFilter"; rt.short_name = "_SupportsFilter"; - rt.method_names = py_methods_436; - static const char* py_bases_437[] = { "logging.Protocol", NULL }; - rt.embedded_types = py_bases_437; + rt.method_names = py_methods_561; + static const char* py_bases_562[] = { "logging.Protocol", NULL }; + rt.embedded_types = py_bases_562; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging._SupportsFilter.filter"; rf.short_name = "filter"; rf.receiver_type = "logging._SupportsFilter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_438[] = { "addFilter", "removeFilter", "filter", NULL }; + static const char* py_methods_563[] = { "addFilter", "removeFilter", "filter", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.Filterer"; rt.short_name = "Filterer"; - rt.method_names = py_methods_438; + rt.method_names = py_methods_563; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.Filterer.addFilter"; @@ -8965,11 +10948,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "filter"; rf.receiver_type = "logging.Filterer"; cbm_registry_add_func(reg, rf); - static const char* py_methods_439[] = { "__init__", "getLogger", "setLoggerClass", "setLogRecordFactory", NULL }; + static const char* py_methods_564[] = { "__init__", "getLogger", "setLoggerClass", "setLogRecordFactory", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.Manager"; rt.short_name = "Manager"; - rt.method_names = py_methods_439; + rt.method_names = py_methods_564; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.Manager.__init__"; @@ -8991,13 +10974,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "setLogRecordFactory"; rf.receiver_type = "logging.Manager"; cbm_registry_add_func(reg, rf); - static const char* py_methods_440[] = { "__init__", "setLevel", "isEnabledFor", "getEffectiveLevel", "getChild", "getChildren", "debug", "info", "warning", "warn", "error", "exception", "critical", "log", "addHandler", "removeHandler", "findCaller", "handle", "makeRecord", "hasHandlers", "callHandlers", NULL }; + static const char* py_methods_565[] = { "__init__", "setLevel", "isEnabledFor", "getEffectiveLevel", "getChild", "getChildren", "debug", "info", "warning", "warn", "error", "exception", "critical", "log", "addHandler", "removeHandler", "findCaller", "handle", "makeRecord", "hasHandlers", "callHandlers", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.Logger"; rt.short_name = "Logger"; - rt.method_names = py_methods_440; - static const char* py_bases_441[] = { "logging.Filterer", NULL }; - rt.embedded_types = py_bases_441; + rt.method_names = py_methods_565; + static const char* py_bases_566[] = { "logging.Filterer", NULL }; + rt.embedded_types = py_bases_566; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.Logger.__init__"; @@ -9104,13 +11087,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "callHandlers"; rf.receiver_type = "logging.Logger"; cbm_registry_add_func(reg, rf); - static const char* py_methods_442[] = { "__init__", "get_name", "set_name", "createLock", "acquire", "release", "setLevel", "setFormatter", "flush", "close", "handle", "handleError", "format", "emit", NULL }; + static const char* py_methods_567[] = { "__init__", "get_name", "set_name", "createLock", "acquire", "release", "setLevel", "setFormatter", "flush", "close", "handle", "handleError", "format", "emit", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.Handler"; rt.short_name = "Handler"; - rt.method_names = py_methods_442; - static const char* py_bases_443[] = { "logging.Filterer", NULL }; - rt.embedded_types = py_bases_443; + rt.method_names = py_methods_567; + static const char* py_bases_568[] = { "logging.Filterer", NULL }; + rt.embedded_types = py_bases_568; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.Handler.__init__"; @@ -9182,11 +11165,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "emit"; rf.receiver_type = "logging.Handler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_444[] = { "__init__", "format", "formatTime", "formatException", "formatMessage", "formatStack", "usesTime", NULL }; + static const char* py_methods_569[] = { "__init__", "format", "formatTime", "formatException", "formatMessage", "formatStack", "usesTime", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.Formatter"; rt.short_name = "Formatter"; - rt.method_names = py_methods_444; + rt.method_names = py_methods_569; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.Formatter.__init__"; @@ -9223,11 +11206,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "usesTime"; rf.receiver_type = "logging.Formatter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_445[] = { "__init__", "formatHeader", "formatFooter", "format", NULL }; + static const char* py_methods_570[] = { "__init__", "formatHeader", "formatFooter", "format", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.BufferingFormatter"; rt.short_name = "BufferingFormatter"; - rt.method_names = py_methods_445; + rt.method_names = py_methods_570; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.BufferingFormatter.__init__"; @@ -9249,11 +11232,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "format"; rf.receiver_type = "logging.BufferingFormatter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_446[] = { "__init__", "filter", NULL }; + static const char* py_methods_571[] = { "__init__", "filter", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.Filter"; rt.short_name = "Filter"; - rt.method_names = py_methods_446; + rt.method_names = py_methods_571; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.Filter.__init__"; @@ -9265,11 +11248,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "filter"; rf.receiver_type = "logging.Filter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_447[] = { "__init__", "getMessage", NULL }; + static const char* py_methods_572[] = { "__init__", "getMessage", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.LogRecord"; rt.short_name = "LogRecord"; - rt.method_names = py_methods_447; + rt.method_names = py_methods_572; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.LogRecord.__init__"; @@ -9281,11 +11264,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "getMessage"; rf.receiver_type = "logging.LogRecord"; cbm_registry_add_func(reg, rf); - static const char* py_methods_448[] = { "__init__", "process", "debug", "info", "warning", "warn", "error", "exception", "critical", "log", "isEnabledFor", "getEffectiveLevel", "setLevel", "hasHandlers", "_log", "name", "__class_getitem__", NULL }; + static const char* py_methods_573[] = { "__init__", "process", "debug", "info", "warning", "warn", "error", "exception", "critical", "log", "isEnabledFor", "getEffectiveLevel", "setLevel", "hasHandlers", "_log", "name", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.LoggerAdapter"; rt.short_name = "LoggerAdapter"; - rt.method_names = py_methods_448; + rt.method_names = py_methods_573; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.LoggerAdapter.__init__"; @@ -9372,13 +11355,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__class_getitem__"; rf.receiver_type = "logging.LoggerAdapter"; cbm_registry_add_func(reg, rf); - static const char* py_methods_449[] = { "__init__", "setStream", "__class_getitem__", NULL }; + static const char* py_methods_574[] = { "__init__", "setStream", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.StreamHandler"; rt.short_name = "StreamHandler"; - rt.method_names = py_methods_449; - static const char* py_bases_450[] = { "logging.Handler", NULL }; - rt.embedded_types = py_bases_450; + rt.method_names = py_methods_574; + static const char* py_bases_575[] = { "logging.Handler", NULL }; + rt.embedded_types = py_bases_575; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.StreamHandler.__init__"; @@ -9395,11 +11378,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__class_getitem__"; rf.receiver_type = "logging.StreamHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_451[] = { "__init__", NULL }; + static const char* py_methods_576[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.FileHandler"; rt.short_name = "FileHandler"; - rt.method_names = py_methods_451; + rt.method_names = py_methods_576; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.FileHandler.__init__"; @@ -9409,14 +11392,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.NullHandler"; rt.short_name = "NullHandler"; - static const char* py_bases_452[] = { "logging.Handler", NULL }; - rt.embedded_types = py_bases_452; + static const char* py_bases_577[] = { "logging.Handler", NULL }; + rt.embedded_types = py_bases_577; cbm_registry_add_type(reg, rt); - static const char* py_methods_453[] = { "__init__", "append", NULL }; + static const char* py_methods_578[] = { "__init__", "append", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.PlaceHolder"; rt.short_name = "PlaceHolder"; - rt.method_names = py_methods_453; + rt.method_names = py_methods_578; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.PlaceHolder.__init__"; @@ -9428,24 +11411,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "append"; rf.receiver_type = "logging.PlaceHolder"; cbm_registry_add_func(reg, rf); - static const char* py_methods_454[] = { "__init__", NULL }; + static const char* py_methods_579[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.RootLogger"; rt.short_name = "RootLogger"; - rt.method_names = py_methods_454; - static const char* py_bases_455[] = { "logging.Logger", NULL }; - rt.embedded_types = py_bases_455; + rt.method_names = py_methods_579; + static const char* py_bases_580[] = { "logging.Logger", NULL }; + rt.embedded_types = py_bases_580; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.RootLogger.__init__"; rf.short_name = "__init__"; rf.receiver_type = "logging.RootLogger"; cbm_registry_add_func(reg, rf); - static const char* py_methods_456[] = { "__init__", "usesTime", "validate", "format", NULL }; + static const char* py_methods_581[] = { "__init__", "usesTime", "validate", "format", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.PercentStyle"; rt.short_name = "PercentStyle"; - rt.method_names = py_methods_456; + rt.method_names = py_methods_581; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.PercentStyle.__init__"; @@ -9470,14 +11453,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.StrFormatStyle"; rt.short_name = "StrFormatStyle"; - static const char* py_bases_457[] = { "logging.PercentStyle", NULL }; - rt.embedded_types = py_bases_457; + static const char* py_bases_582[] = { "logging.PercentStyle", NULL }; + rt.embedded_types = py_bases_582; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.StringTemplateStyle"; rt.short_name = "StringTemplateStyle"; - static const char* py_bases_458[] = { "logging.PercentStyle", NULL }; - rt.embedded_types = py_bases_458; + static const char* py_bases_583[] = { "logging.PercentStyle", NULL }; + rt.embedded_types = py_bases_583; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.currentframe"; @@ -9580,38 +11563,38 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config._RootLoggerConfiguration"; rt.short_name = "_RootLoggerConfiguration"; - static const char* py_bases_459[] = { "logging.config.TypedDict", NULL }; - rt.embedded_types = py_bases_459; + static const char* py_bases_584[] = { "logging.config.TypedDict", NULL }; + rt.embedded_types = py_bases_584; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config._RootLoggerConfiguration"; rt.short_name = "_RootLoggerConfiguration"; - static const char* py_bases_460[] = { "logging.config.TypedDict", NULL }; - rt.embedded_types = py_bases_460; + static const char* py_bases_585[] = { "logging.config.TypedDict", NULL }; + rt.embedded_types = py_bases_585; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config._LoggerConfiguration"; rt.short_name = "_LoggerConfiguration"; - static const char* py_bases_461[] = { "logging.config._RootLoggerConfiguration", "logging.config.TypedDict", NULL }; - rt.embedded_types = py_bases_461; + static const char* py_bases_586[] = { "logging.config._RootLoggerConfiguration", "logging.config.TypedDict", NULL }; + rt.embedded_types = py_bases_586; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config._FilterConfigurationTypedDict"; rt.short_name = "_FilterConfigurationTypedDict"; - static const char* py_bases_462[] = { "logging.config.TypedDict", NULL }; - rt.embedded_types = py_bases_462; + static const char* py_bases_587[] = { "logging.config.TypedDict", NULL }; + rt.embedded_types = py_bases_587; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config._DictConfigArgs"; rt.short_name = "_DictConfigArgs"; - static const char* py_bases_463[] = { "logging.config.TypedDict", NULL }; - rt.embedded_types = py_bases_463; + static const char* py_bases_588[] = { "logging.config.TypedDict", NULL }; + rt.embedded_types = py_bases_588; cbm_registry_add_type(reg, rt); - static const char* py_methods_464[] = { "convert_with_key", "convert", NULL }; + static const char* py_methods_589[] = { "convert_with_key", "convert", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.ConvertingMixin"; rt.short_name = "ConvertingMixin"; - rt.method_names = py_methods_464; + rt.method_names = py_methods_589; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.config.ConvertingMixin.convert_with_key"; @@ -9623,13 +11606,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "convert"; rf.receiver_type = "logging.config.ConvertingMixin"; cbm_registry_add_func(reg, rf); - static const char* py_methods_465[] = { "get", "pop", NULL }; + static const char* py_methods_590[] = { "get", "pop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.ConvertingDict"; rt.short_name = "ConvertingDict"; - rt.method_names = py_methods_465; - static const char* py_bases_466[] = { "logging.config.ConvertingMixin", NULL }; - rt.embedded_types = py_bases_466; + rt.method_names = py_methods_590; + static const char* py_bases_591[] = { "logging.config.ConvertingMixin", NULL }; + rt.embedded_types = py_bases_591; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.config.ConvertingDict.get"; @@ -9641,13 +11624,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "pop"; rf.receiver_type = "logging.config.ConvertingDict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_467[] = { "pop", NULL }; + static const char* py_methods_592[] = { "pop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.ConvertingList"; rt.short_name = "ConvertingList"; - rt.method_names = py_methods_467; - static const char* py_bases_468[] = { "logging.config.ConvertingMixin", NULL }; - rt.embedded_types = py_bases_468; + rt.method_names = py_methods_592; + static const char* py_bases_593[] = { "logging.config.ConvertingMixin", NULL }; + rt.embedded_types = py_bases_593; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.config.ConvertingList.pop"; @@ -9657,20 +11640,20 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.ConvertingTuple"; rt.short_name = "ConvertingTuple"; - static const char* py_bases_469[] = { "logging.config.ConvertingMixin", NULL }; - rt.embedded_types = py_bases_469; + static const char* py_bases_594[] = { "logging.config.ConvertingMixin", NULL }; + rt.embedded_types = py_bases_594; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.ConvertingTuple"; rt.short_name = "ConvertingTuple"; - static const char* py_bases_470[] = { "logging.config.ConvertingMixin", NULL }; - rt.embedded_types = py_bases_470; + static const char* py_bases_595[] = { "logging.config.ConvertingMixin", NULL }; + rt.embedded_types = py_bases_595; cbm_registry_add_type(reg, rt); - static const char* py_methods_471[] = { "__init__", "resolve", "ext_convert", "cfg_convert", "convert", "configure_custom", "as_tuple", NULL }; + static const char* py_methods_596[] = { "__init__", "resolve", "ext_convert", "cfg_convert", "convert", "configure_custom", "as_tuple", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.BaseConfigurator"; rt.short_name = "BaseConfigurator"; - rt.method_names = py_methods_471; + rt.method_names = py_methods_596; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.config.BaseConfigurator.__init__"; @@ -9707,13 +11690,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "as_tuple"; rf.receiver_type = "logging.config.BaseConfigurator"; cbm_registry_add_func(reg, rf); - static const char* py_methods_472[] = { "configure", "configure_formatter", "configure_filter", "add_filters", "configure_handler", "add_handlers", "common_logger_config", "configure_logger", "configure_root", NULL }; + static const char* py_methods_597[] = { "configure", "configure_formatter", "configure_filter", "add_filters", "configure_handler", "add_handlers", "common_logger_config", "configure_logger", "configure_root", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.config.DictConfigurator"; rt.short_name = "DictConfigurator"; - rt.method_names = py_methods_472; - static const char* py_bases_473[] = { "logging.config.BaseConfigurator", NULL }; - rt.embedded_types = py_bases_473; + rt.method_names = py_methods_597; + static const char* py_bases_598[] = { "logging.config.BaseConfigurator", NULL }; + rt.embedded_types = py_bases_598; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.config.DictConfigurator.configure"; @@ -9782,13 +11765,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: logging.handlers ===== */ - static const char* py_methods_474[] = { "__init__", "reopenIfNeeded", NULL }; + static const char* py_methods_599[] = { "__init__", "reopenIfNeeded", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.WatchedFileHandler"; rt.short_name = "WatchedFileHandler"; - rt.method_names = py_methods_474; - static const char* py_bases_475[] = { "logging.handlers.FileHandler", NULL }; - rt.embedded_types = py_bases_475; + rt.method_names = py_methods_599; + static const char* py_bases_600[] = { "logging.handlers.FileHandler", NULL }; + rt.embedded_types = py_bases_600; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.WatchedFileHandler.__init__"; @@ -9800,13 +11783,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "reopenIfNeeded"; rf.receiver_type = "logging.handlers.WatchedFileHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_476[] = { "__init__", "rotation_filename", "rotate", NULL }; + static const char* py_methods_601[] = { "__init__", "rotation_filename", "rotate", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.BaseRotatingHandler"; rt.short_name = "BaseRotatingHandler"; - rt.method_names = py_methods_476; - static const char* py_bases_477[] = { "logging.handlers.FileHandler", NULL }; - rt.embedded_types = py_bases_477; + rt.method_names = py_methods_601; + static const char* py_bases_602[] = { "logging.handlers.FileHandler", NULL }; + rt.embedded_types = py_bases_602; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.BaseRotatingHandler.__init__"; @@ -9823,13 +11806,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "rotate"; rf.receiver_type = "logging.handlers.BaseRotatingHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_478[] = { "__init__", "doRollover", "shouldRollover", NULL }; + static const char* py_methods_603[] = { "__init__", "doRollover", "shouldRollover", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.RotatingFileHandler"; rt.short_name = "RotatingFileHandler"; - rt.method_names = py_methods_478; - static const char* py_bases_479[] = { "logging.handlers.BaseRotatingHandler", NULL }; - rt.embedded_types = py_bases_479; + rt.method_names = py_methods_603; + static const char* py_bases_604[] = { "logging.handlers.BaseRotatingHandler", NULL }; + rt.embedded_types = py_bases_604; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.RotatingFileHandler.__init__"; @@ -9846,13 +11829,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "shouldRollover"; rf.receiver_type = "logging.handlers.RotatingFileHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_480[] = { "__init__", "doRollover", "shouldRollover", "computeRollover", "getFilesToDelete", NULL }; + static const char* py_methods_605[] = { "__init__", "doRollover", "shouldRollover", "computeRollover", "getFilesToDelete", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.TimedRotatingFileHandler"; rt.short_name = "TimedRotatingFileHandler"; - rt.method_names = py_methods_480; - static const char* py_bases_481[] = { "logging.handlers.BaseRotatingHandler", NULL }; - rt.embedded_types = py_bases_481; + rt.method_names = py_methods_605; + static const char* py_bases_606[] = { "logging.handlers.BaseRotatingHandler", NULL }; + rt.embedded_types = py_bases_606; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.TimedRotatingFileHandler.__init__"; @@ -9879,13 +11862,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "getFilesToDelete"; rf.receiver_type = "logging.handlers.TimedRotatingFileHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_482[] = { "__init__", "makeSocket", "makePickle", "send", "createSocket", NULL }; + static const char* py_methods_607[] = { "__init__", "makeSocket", "makePickle", "send", "createSocket", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.SocketHandler"; rt.short_name = "SocketHandler"; - rt.method_names = py_methods_482; - static const char* py_bases_483[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_483; + rt.method_names = py_methods_607; + static const char* py_bases_608[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_608; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.SocketHandler.__init__"; @@ -9912,26 +11895,26 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "createSocket"; rf.receiver_type = "logging.handlers.SocketHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_484[] = { "makeSocket", NULL }; + static const char* py_methods_609[] = { "makeSocket", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.DatagramHandler"; rt.short_name = "DatagramHandler"; - rt.method_names = py_methods_484; - static const char* py_bases_485[] = { "logging.handlers.SocketHandler", NULL }; - rt.embedded_types = py_bases_485; + rt.method_names = py_methods_609; + static const char* py_bases_610[] = { "logging.handlers.SocketHandler", NULL }; + rt.embedded_types = py_bases_610; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.DatagramHandler.makeSocket"; rf.short_name = "makeSocket"; rf.receiver_type = "logging.handlers.DatagramHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_486[] = { "__init__", "createSocket", "encodePriority", "mapPriority", NULL }; + static const char* py_methods_611[] = { "__init__", "createSocket", "encodePriority", "mapPriority", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.SysLogHandler"; rt.short_name = "SysLogHandler"; - rt.method_names = py_methods_486; - static const char* py_bases_487[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_487; + rt.method_names = py_methods_611; + static const char* py_bases_612[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_612; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.SysLogHandler.__init__"; @@ -9953,13 +11936,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "mapPriority"; rf.receiver_type = "logging.handlers.SysLogHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_488[] = { "__init__", "getEventCategory", "getEventType", "getMessageID", NULL }; + static const char* py_methods_613[] = { "__init__", "getEventCategory", "getEventType", "getMessageID", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.NTEventLogHandler"; rt.short_name = "NTEventLogHandler"; - rt.method_names = py_methods_488; - static const char* py_bases_489[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_489; + rt.method_names = py_methods_613; + static const char* py_bases_614[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_614; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.NTEventLogHandler.__init__"; @@ -9981,13 +11964,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "getMessageID"; rf.receiver_type = "logging.handlers.NTEventLogHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_490[] = { "__init__", "getSubject", NULL }; + static const char* py_methods_615[] = { "__init__", "getSubject", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.SMTPHandler"; rt.short_name = "SMTPHandler"; - rt.method_names = py_methods_490; - static const char* py_bases_491[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_491; + rt.method_names = py_methods_615; + static const char* py_bases_616[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_616; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.SMTPHandler.__init__"; @@ -9999,13 +11982,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "getSubject"; rf.receiver_type = "logging.handlers.SMTPHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_492[] = { "__init__", "shouldFlush", NULL }; + static const char* py_methods_617[] = { "__init__", "shouldFlush", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.BufferingHandler"; rt.short_name = "BufferingHandler"; - rt.method_names = py_methods_492; - static const char* py_bases_493[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_493; + rt.method_names = py_methods_617; + static const char* py_bases_618[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_618; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.BufferingHandler.__init__"; @@ -10017,13 +12000,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "shouldFlush"; rf.receiver_type = "logging.handlers.BufferingHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_494[] = { "__init__", "setTarget", NULL }; + static const char* py_methods_619[] = { "__init__", "setTarget", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.MemoryHandler"; rt.short_name = "MemoryHandler"; - rt.method_names = py_methods_494; - static const char* py_bases_495[] = { "logging.handlers.BufferingHandler", NULL }; - rt.embedded_types = py_bases_495; + rt.method_names = py_methods_619; + static const char* py_bases_620[] = { "logging.handlers.BufferingHandler", NULL }; + rt.embedded_types = py_bases_620; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.MemoryHandler.__init__"; @@ -10035,13 +12018,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "setTarget"; rf.receiver_type = "logging.handlers.MemoryHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_496[] = { "__init__", "mapLogRecord", "getConnection", NULL }; + static const char* py_methods_621[] = { "__init__", "mapLogRecord", "getConnection", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.HTTPHandler"; rt.short_name = "HTTPHandler"; - rt.method_names = py_methods_496; - static const char* py_bases_497[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_497; + rt.method_names = py_methods_621; + static const char* py_bases_622[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_622; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.HTTPHandler.__init__"; @@ -10058,11 +12041,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "getConnection"; rf.receiver_type = "logging.handlers.HTTPHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_498[] = { "get", "put_nowait", NULL }; + static const char* py_methods_623[] = { "get", "put_nowait", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers._QueueLike"; rt.short_name = "_QueueLike"; - rt.method_names = py_methods_498; + rt.method_names = py_methods_623; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers._QueueLike.get"; @@ -10074,13 +12057,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "put_nowait"; rf.receiver_type = "logging.handlers._QueueLike"; cbm_registry_add_func(reg, rf); - static const char* py_methods_499[] = { "__init__", "prepare", "enqueue", NULL }; + static const char* py_methods_624[] = { "__init__", "prepare", "enqueue", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.QueueHandler"; rt.short_name = "QueueHandler"; - rt.method_names = py_methods_499; - static const char* py_bases_500[] = { "logging.handlers.Handler", NULL }; - rt.embedded_types = py_bases_500; + rt.method_names = py_methods_624; + static const char* py_bases_625[] = { "logging.handlers.Handler", NULL }; + rt.embedded_types = py_bases_625; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.QueueHandler.__init__"; @@ -10097,11 +12080,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "enqueue"; rf.receiver_type = "logging.handlers.QueueHandler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_501[] = { "__init__", "dequeue", "prepare", "start", "stop", "enqueue_sentinel", "handle", "__enter__", "__exit__", NULL }; + static const char* py_methods_626[] = { "__init__", "dequeue", "prepare", "start", "stop", "enqueue_sentinel", "handle", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "logging.handlers.QueueListener"; rt.short_name = "QueueListener"; - rt.method_names = py_methods_501; + rt.method_names = py_methods_626; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "logging.handlers.QueueListener.__init__"; @@ -10161,8 +12144,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "math._SupportsProdWithNoDefaultGiven"; rt.short_name = "_SupportsProdWithNoDefaultGiven"; - static const char* py_bases_502[] = { "math.Protocol", NULL }; - rt.embedded_types = py_bases_502; + static const char* py_bases_627[] = { "math.Protocol", NULL }; + rt.embedded_types = py_bases_627; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "math._SupportsTrunc"; @@ -10398,11 +12381,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.connection ===== */ - static const char* py_methods_503[] = { "__init__", "closed", "readable", "writable", "fileno", "close", "send_bytes", "send", "recv_bytes", "recv_bytes_into", "recv", "poll", "__enter__", "__exit__", NULL }; + static const char* py_methods_628[] = { "__init__", "closed", "readable", "writable", "fileno", "close", "send_bytes", "send", "recv_bytes", "recv_bytes_into", "recv", "poll", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.connection._ConnectionBase"; rt.short_name = "_ConnectionBase"; - rt.method_names = py_methods_503; + rt.method_names = py_methods_628; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.connection._ConnectionBase.__init__"; @@ -10482,11 +12465,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "multiprocessing.connection.PipeConnection"; rt.short_name = "PipeConnection"; cbm_registry_add_type(reg, rt); - static const char* py_methods_504[] = { "__init__", "accept", "close", "address", "last_accepted", "__enter__", "__exit__", NULL }; + static const char* py_methods_629[] = { "__init__", "accept", "close", "address", "last_accepted", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.connection.Listener"; rt.short_name = "Listener"; - rt.method_names = py_methods_504; + rt.method_names = py_methods_629; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.connection.Listener.__init__"; @@ -10548,32 +12531,32 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.ProcessError"; rt.short_name = "ProcessError"; - static const char* py_bases_505[] = { "multiprocessing.context.Exception", NULL }; - rt.embedded_types = py_bases_505; + static const char* py_bases_630[] = { "multiprocessing.context.Exception", NULL }; + rt.embedded_types = py_bases_630; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.BufferTooShort"; rt.short_name = "BufferTooShort"; - static const char* py_bases_506[] = { "multiprocessing.context.ProcessError", NULL }; - rt.embedded_types = py_bases_506; + static const char* py_bases_631[] = { "multiprocessing.context.ProcessError", NULL }; + rt.embedded_types = py_bases_631; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.TimeoutError"; rt.short_name = "TimeoutError"; - static const char* py_bases_507[] = { "multiprocessing.context.ProcessError", NULL }; - rt.embedded_types = py_bases_507; + static const char* py_bases_632[] = { "multiprocessing.context.ProcessError", NULL }; + rt.embedded_types = py_bases_632; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.AuthenticationError"; rt.short_name = "AuthenticationError"; - static const char* py_bases_508[] = { "multiprocessing.context.ProcessError", NULL }; - rt.embedded_types = py_bases_508; + static const char* py_bases_633[] = { "multiprocessing.context.ProcessError", NULL }; + rt.embedded_types = py_bases_633; cbm_registry_add_type(reg, rt); - static const char* py_methods_509[] = { "current_process", "parent_process", "active_children", "cpu_count", "Manager", "Pipe", "Barrier", "BoundedSemaphore", "Condition", "Event", "Lock", "RLock", "Semaphore", "Queue", "JoinableQueue", "SimpleQueue", "Pool", "RawValue", "RawArray", "Value", "Array", "freeze_support", "get_logger", "log_to_stderr", "allow_connection_pickling", "set_executable", "set_forkserver_preload", "get_context", "get_start_method", "set_start_method", "reducer", NULL }; + static const char* py_methods_634[] = { "current_process", "parent_process", "active_children", "cpu_count", "Manager", "Pipe", "Barrier", "BoundedSemaphore", "Condition", "Event", "Lock", "RLock", "Semaphore", "Queue", "JoinableQueue", "SimpleQueue", "Pool", "RawValue", "RawArray", "Value", "Array", "freeze_support", "get_logger", "log_to_stderr", "allow_connection_pickling", "set_executable", "set_forkserver_preload", "get_context", "get_start_method", "set_start_method", "reducer", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.BaseContext"; rt.short_name = "BaseContext"; - rt.method_names = py_methods_509; + rt.method_names = py_methods_634; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.context.BaseContext.current_process"; @@ -10733,16 +12716,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.Process"; rt.short_name = "Process"; - static const char* py_bases_510[] = { "multiprocessing.context.BaseProcess", NULL }; - rt.embedded_types = py_bases_510; + static const char* py_bases_635[] = { "multiprocessing.context.BaseProcess", NULL }; + rt.embedded_types = py_bases_635; cbm_registry_add_type(reg, rt); - static const char* py_methods_511[] = { "__init__", "get_start_method", "get_all_start_methods", NULL }; + static const char* py_methods_636[] = { "__init__", "get_start_method", "get_all_start_methods", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.DefaultContext"; rt.short_name = "DefaultContext"; - rt.method_names = py_methods_511; - static const char* py_bases_512[] = { "multiprocessing.context.BaseContext", NULL }; - rt.embedded_types = py_bases_512; + rt.method_names = py_methods_636; + static const char* py_bases_637[] = { "multiprocessing.context.BaseContext", NULL }; + rt.embedded_types = py_bases_637; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.context.DefaultContext.__init__"; @@ -10759,13 +12742,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "get_all_start_methods"; rf.receiver_type = "multiprocessing.context.DefaultContext"; cbm_registry_add_func(reg, rf); - static const char* py_methods_513[] = { "_Popen", NULL }; + static const char* py_methods_638[] = { "_Popen", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.SpawnProcess"; rt.short_name = "SpawnProcess"; - rt.method_names = py_methods_513; - static const char* py_bases_514[] = { "multiprocessing.context.BaseProcess", NULL }; - rt.embedded_types = py_bases_514; + rt.method_names = py_methods_638; + static const char* py_bases_639[] = { "multiprocessing.context.BaseProcess", NULL }; + rt.embedded_types = py_bases_639; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.context.SpawnProcess._Popen"; @@ -10775,32 +12758,32 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.SpawnContext"; rt.short_name = "SpawnContext"; - static const char* py_bases_515[] = { "multiprocessing.context.BaseContext", NULL }; - rt.embedded_types = py_bases_515; + static const char* py_bases_640[] = { "multiprocessing.context.BaseContext", NULL }; + rt.embedded_types = py_bases_640; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.ForkProcess"; rt.short_name = "ForkProcess"; - static const char* py_bases_516[] = { "multiprocessing.context.BaseProcess", NULL }; - rt.embedded_types = py_bases_516; + static const char* py_bases_641[] = { "multiprocessing.context.BaseProcess", NULL }; + rt.embedded_types = py_bases_641; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.ForkServerProcess"; rt.short_name = "ForkServerProcess"; - static const char* py_bases_517[] = { "multiprocessing.context.BaseProcess", NULL }; - rt.embedded_types = py_bases_517; + static const char* py_bases_642[] = { "multiprocessing.context.BaseProcess", NULL }; + rt.embedded_types = py_bases_642; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.ForkContext"; rt.short_name = "ForkContext"; - static const char* py_bases_518[] = { "multiprocessing.context.BaseContext", NULL }; - rt.embedded_types = py_bases_518; + static const char* py_bases_643[] = { "multiprocessing.context.BaseContext", NULL }; + rt.embedded_types = py_bases_643; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.context.ForkServerContext"; rt.short_name = "ForkServerContext"; - static const char* py_bases_519[] = { "multiprocessing.context.BaseContext", NULL }; - rt.embedded_types = py_bases_519; + static const char* py_bases_644[] = { "multiprocessing.context.BaseContext", NULL }; + rt.embedded_types = py_bases_644; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.context.get_spawning_popen"; @@ -10816,13 +12799,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.dummy ===== */ - static const char* py_methods_520[] = { "exitcode", "__init__", NULL }; + static const char* py_methods_645[] = { "exitcode", "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.dummy.DummyProcess"; rt.short_name = "DummyProcess"; - rt.method_names = py_methods_520; - static const char* py_bases_521[] = { "threading.Thread", NULL }; - rt.embedded_types = py_bases_521; + rt.method_names = py_methods_645; + static const char* py_bases_646[] = { "threading.Thread", NULL }; + rt.embedded_types = py_bases_646; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.dummy.DummyProcess.exitcode"; @@ -10834,22 +12817,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.dummy.DummyProcess"; cbm_registry_add_func(reg, rf); - static const char* py_methods_522[] = { "__init__", NULL }; + static const char* py_methods_647[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.dummy.Namespace"; rt.short_name = "Namespace"; - rt.method_names = py_methods_522; + rt.method_names = py_methods_647; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.dummy.Namespace.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.dummy.Namespace"; cbm_registry_add_func(reg, rf); - static const char* py_methods_523[] = { "__init__", NULL }; + static const char* py_methods_648[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.dummy.Value"; rt.short_name = "Value"; - rt.method_names = py_methods_523; + rt.method_names = py_methods_648; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.dummy.Value.__init__"; @@ -10882,11 +12865,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.dummy.connection ===== */ - static const char* py_methods_524[] = { "__enter__", "__exit__", "__init__", "close", "poll", NULL }; + static const char* py_methods_649[] = { "__enter__", "__exit__", "__init__", "close", "poll", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.dummy.connection.Connection"; rt.short_name = "Connection"; - rt.method_names = py_methods_524; + rt.method_names = py_methods_649; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.dummy.connection.Connection.__enter__"; @@ -10913,11 +12896,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "poll"; rf.receiver_type = "multiprocessing.dummy.connection.Connection"; cbm_registry_add_func(reg, rf); - static const char* py_methods_525[] = { "address", "__enter__", "__exit__", "__init__", "accept", "close", NULL }; + static const char* py_methods_650[] = { "address", "__enter__", "__exit__", "__init__", "accept", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.dummy.connection.Listener"; rt.short_name = "Listener"; - rt.method_names = py_methods_525; + rt.method_names = py_methods_650; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.dummy.connection.Listener.address"; @@ -10959,11 +12942,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.forkserver ===== */ - static const char* py_methods_526[] = { "set_forkserver_preload", "get_inherited_fds", "connect_to_new_process", "ensure_running", NULL }; + static const char* py_methods_651[] = { "set_forkserver_preload", "get_inherited_fds", "connect_to_new_process", "ensure_running", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.forkserver.ForkServer"; rt.short_name = "ForkServer"; - rt.method_names = py_methods_526; + rt.method_names = py_methods_651; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.forkserver.ForkServer.set_forkserver_preload"; @@ -10999,35 +12982,35 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.heap ===== */ - static const char* py_methods_527[] = { "__init__", NULL }; + static const char* py_methods_652[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.heap.Arena"; rt.short_name = "Arena"; - rt.method_names = py_methods_527; + rt.method_names = py_methods_652; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.heap.Arena.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.heap.Arena"; cbm_registry_add_func(reg, rf); - static const char* py_methods_528[] = { "detach", NULL }; + static const char* py_methods_653[] = { "detach", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.heap._SupportsDetach"; rt.short_name = "_SupportsDetach"; - rt.method_names = py_methods_528; - static const char* py_bases_529[] = { "multiprocessing.heap.Protocol", NULL }; - rt.embedded_types = py_bases_529; + rt.method_names = py_methods_653; + static const char* py_bases_654[] = { "multiprocessing.heap.Protocol", NULL }; + rt.embedded_types = py_bases_654; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.heap._SupportsDetach.detach"; rf.short_name = "detach"; rf.receiver_type = "multiprocessing.heap._SupportsDetach"; cbm_registry_add_func(reg, rf); - static const char* py_methods_530[] = { "__init__", "free", "malloc", NULL }; + static const char* py_methods_655[] = { "__init__", "free", "malloc", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.heap.Heap"; rt.short_name = "Heap"; - rt.method_names = py_methods_530; + rt.method_names = py_methods_655; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.heap.Heap.__init__"; @@ -11044,11 +13027,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "malloc"; rf.receiver_type = "multiprocessing.heap.Heap"; cbm_registry_add_func(reg, rf); - static const char* py_methods_531[] = { "__init__", "create_memoryview", NULL }; + static const char* py_methods_656[] = { "__init__", "create_memoryview", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.heap.BufferWrapper"; rt.short_name = "BufferWrapper"; - rt.method_names = py_methods_531; + rt.method_names = py_methods_656; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.heap.BufferWrapper.__init__"; @@ -11070,46 +13053,46 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.managers ===== */ - static const char* py_methods_532[] = { "__init__", NULL }; + static const char* py_methods_657[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.Namespace"; rt.short_name = "Namespace"; - rt.method_names = py_methods_532; + rt.method_names = py_methods_657; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.Namespace.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.managers.Namespace"; cbm_registry_add_func(reg, rf); - static const char* py_methods_533[] = { "__init__", NULL }; + static const char* py_methods_658[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.Token"; rt.short_name = "Token"; - rt.method_names = py_methods_533; + rt.method_names = py_methods_658; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.Token.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.managers.Token"; cbm_registry_add_func(reg, rf); - static const char* py_methods_534[] = { "__init__", NULL }; + static const char* py_methods_659[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.BaseProxy"; rt.short_name = "BaseProxy"; - rt.method_names = py_methods_534; + rt.method_names = py_methods_659; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.BaseProxy.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.managers.BaseProxy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_535[] = { "get", "set", NULL }; + static const char* py_methods_660[] = { "get", "set", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.ValueProxy"; rt.short_name = "ValueProxy"; - rt.method_names = py_methods_535; - static const char* py_bases_536[] = { "multiprocessing.managers.BaseProxy", NULL }; - rt.embedded_types = py_bases_536; + rt.method_names = py_methods_660; + static const char* py_bases_661[] = { "multiprocessing.managers.BaseProxy", NULL }; + rt.embedded_types = py_bases_661; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.ValueProxy.get"; @@ -11121,13 +13104,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "set"; rf.receiver_type = "multiprocessing.managers.ValueProxy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_537[] = { "copy", "get", "pop", "keys", "items", "values", "fromkeys", "__reversed__", "__or__", "__ror__", "__ior__", NULL }; + static const char* py_methods_662[] = { "copy", "get", "pop", "keys", "items", "values", "fromkeys", "__reversed__", "__or__", "__ror__", "__ior__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers._BaseDictProxy"; rt.short_name = "_BaseDictProxy"; - rt.method_names = py_methods_537; - static const char* py_bases_538[] = { "multiprocessing.managers.BaseProxy", NULL }; - rt.embedded_types = py_bases_538; + rt.method_names = py_methods_662; + static const char* py_bases_663[] = { "multiprocessing.managers.BaseProxy", NULL }; + rt.embedded_types = py_bases_663; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers._BaseDictProxy.copy"; @@ -11188,13 +13171,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "multiprocessing.managers.DictProxy"; rt.short_name = "DictProxy"; cbm_registry_add_type(reg, rt); - static const char* py_methods_539[] = { "copy", "get", "pop", "keys", "items", "values", NULL }; + static const char* py_methods_664[] = { "copy", "get", "pop", "keys", "items", "values", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.DictProxy"; rt.short_name = "DictProxy"; - rt.method_names = py_methods_539; - static const char* py_bases_540[] = { "multiprocessing.managers.BaseProxy", NULL }; - rt.embedded_types = py_bases_540; + rt.method_names = py_methods_664; + static const char* py_bases_665[] = { "multiprocessing.managers.BaseProxy", NULL }; + rt.embedded_types = py_bases_665; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.DictProxy.copy"; @@ -11226,13 +13209,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "values"; rf.receiver_type = "multiprocessing.managers.DictProxy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_541[] = { "add", "copy", "clear", "difference", "difference_update", "discard", "intersection", "intersection_update", "isdisjoint", "issubset", "issuperset", "pop", "remove", "symmetric_difference", "symmetric_difference_update", "union", "update", NULL }; + static const char* py_methods_666[] = { "add", "copy", "clear", "difference", "difference_update", "discard", "intersection", "intersection_update", "isdisjoint", "issubset", "issuperset", "pop", "remove", "symmetric_difference", "symmetric_difference_update", "union", "update", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers._BaseSetProxy"; rt.short_name = "_BaseSetProxy"; - rt.method_names = py_methods_541; - static const char* py_bases_542[] = { "multiprocessing.managers.BaseProxy", NULL }; - rt.embedded_types = py_bases_542; + rt.method_names = py_methods_666; + static const char* py_bases_667[] = { "multiprocessing.managers.BaseProxy", NULL }; + rt.embedded_types = py_bases_667; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers._BaseSetProxy.add"; @@ -11323,13 +13306,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "multiprocessing.managers.SetProxy"; rt.short_name = "SetProxy"; cbm_registry_add_type(reg, rt); - static const char* py_methods_543[] = { "append", "extend", "pop", "index", "count", "insert", "remove", "clear", "copy", "sort", NULL }; + static const char* py_methods_668[] = { "append", "extend", "pop", "index", "count", "insert", "remove", "clear", "copy", "sort", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.BaseListProxy"; rt.short_name = "BaseListProxy"; - rt.method_names = py_methods_543; - static const char* py_bases_544[] = { "multiprocessing.managers.BaseProxy", NULL }; - rt.embedded_types = py_bases_544; + rt.method_names = py_methods_668; + static const char* py_bases_669[] = { "multiprocessing.managers.BaseProxy", NULL }; + rt.embedded_types = py_bases_669; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.BaseListProxy.append"; @@ -11381,22 +13364,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "sort"; rf.receiver_type = "multiprocessing.managers.BaseListProxy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_545[] = { "__class_getitem__", NULL }; + static const char* py_methods_670[] = { "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.ListProxy"; rt.short_name = "ListProxy"; - rt.method_names = py_methods_545; + rt.method_names = py_methods_670; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.ListProxy.__class_getitem__"; rf.short_name = "__class_getitem__"; rf.receiver_type = "multiprocessing.managers.ListProxy"; cbm_registry_add_func(reg, rf); - static const char* py_methods_546[] = { "__init__", "serve_forever", "accepter", "handle_request", "serve_client", "fallback_getvalue", "fallback_str", "fallback_repr", "dummy", "debug_info", "number_of_objects", "shutdown", "create", "get_methods", "accept_connection", "incref", "decref", NULL }; + static const char* py_methods_671[] = { "__init__", "serve_forever", "accepter", "handle_request", "serve_client", "fallback_getvalue", "fallback_str", "fallback_repr", "dummy", "debug_info", "number_of_objects", "shutdown", "create", "get_methods", "accept_connection", "incref", "decref", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.Server"; rt.short_name = "Server"; - rt.method_names = py_methods_546; + rt.method_names = py_methods_671; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.Server.__init__"; @@ -11483,11 +13466,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "decref"; rf.receiver_type = "multiprocessing.managers.Server"; cbm_registry_add_func(reg, rf); - static const char* py_methods_547[] = { "__init__", "get_server", "connect", "start", "join", "address", "register", "__enter__", "__exit__", NULL }; + static const char* py_methods_672[] = { "__init__", "get_server", "connect", "start", "join", "address", "register", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.BaseManager"; rt.short_name = "BaseManager"; - rt.method_names = py_methods_547; + rt.method_names = py_methods_672; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.BaseManager.__init__"; @@ -11534,13 +13517,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "multiprocessing.managers.BaseManager"; cbm_registry_add_func(reg, rf); - static const char* py_methods_548[] = { "Barrier", "BoundedSemaphore", "Condition", "Event", "Lock", "Namespace", "Pool", "Queue", "JoinableQueue", "RLock", "Semaphore", "Array", "Value", "dict", "list", "set", NULL }; + static const char* py_methods_673[] = { "Barrier", "BoundedSemaphore", "Condition", "Event", "Lock", "Namespace", "Pool", "Queue", "JoinableQueue", "RLock", "Semaphore", "Array", "Value", "dict", "list", "set", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.SyncManager"; rt.short_name = "SyncManager"; - rt.method_names = py_methods_548; - static const char* py_bases_549[] = { "multiprocessing.managers.BaseManager", NULL }; - rt.embedded_types = py_bases_549; + rt.method_names = py_methods_673; + static const char* py_bases_674[] = { "multiprocessing.managers.BaseManager", NULL }; + rt.embedded_types = py_bases_674; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.SyncManager.Barrier"; @@ -11625,16 +13608,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.RemoteError"; rt.short_name = "RemoteError"; - static const char* py_bases_550[] = { "multiprocessing.managers.Exception", NULL }; - rt.embedded_types = py_bases_550; + static const char* py_bases_675[] = { "multiprocessing.managers.Exception", NULL }; + rt.embedded_types = py_bases_675; cbm_registry_add_type(reg, rt); - static const char* py_methods_551[] = { "track_segment", "release_segment", "list_segments", NULL }; + static const char* py_methods_676[] = { "track_segment", "release_segment", "list_segments", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.SharedMemoryServer"; rt.short_name = "SharedMemoryServer"; - rt.method_names = py_methods_551; - static const char* py_bases_552[] = { "multiprocessing.managers.Server", NULL }; - rt.embedded_types = py_bases_552; + rt.method_names = py_methods_676; + static const char* py_bases_677[] = { "multiprocessing.managers.Server", NULL }; + rt.embedded_types = py_bases_677; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.SharedMemoryServer.track_segment"; @@ -11651,13 +13634,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "list_segments"; rf.receiver_type = "multiprocessing.managers.SharedMemoryServer"; cbm_registry_add_func(reg, rf); - static const char* py_methods_553[] = { "get_server", "SharedMemory", "ShareableList", NULL }; + static const char* py_methods_678[] = { "get_server", "SharedMemory", "ShareableList", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.managers.SharedMemoryManager"; rt.short_name = "SharedMemoryManager"; - rt.method_names = py_methods_553; - static const char* py_bases_554[] = { "multiprocessing.managers.BaseManager", NULL }; - rt.embedded_types = py_bases_554; + rt.method_names = py_methods_678; + static const char* py_bases_679[] = { "multiprocessing.managers.BaseManager", NULL }; + rt.embedded_types = py_bases_679; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.managers.SharedMemoryManager.get_server"; @@ -11676,11 +13659,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.pool ===== */ - static const char* py_methods_555[] = { "__init__", "get", "wait", "ready", "successful", NULL }; + static const char* py_methods_680[] = { "__init__", "get", "wait", "ready", "successful", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.pool.ApplyResult"; rt.short_name = "ApplyResult"; - rt.method_names = py_methods_555; + rt.method_names = py_methods_680; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.pool.ApplyResult.__init__"; @@ -11707,22 +13690,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "successful"; rf.receiver_type = "multiprocessing.pool.ApplyResult"; cbm_registry_add_func(reg, rf); - static const char* py_methods_556[] = { "__init__", NULL }; + static const char* py_methods_681[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.pool.MapResult"; rt.short_name = "MapResult"; - rt.method_names = py_methods_556; + rt.method_names = py_methods_681; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.pool.MapResult.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.pool.MapResult"; cbm_registry_add_func(reg, rf); - static const char* py_methods_557[] = { "__init__", "next", NULL }; + static const char* py_methods_682[] = { "__init__", "next", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.pool.IMapIterator"; rt.short_name = "IMapIterator"; - rt.method_names = py_methods_557; + rt.method_names = py_methods_682; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.pool.IMapIterator.__init__"; @@ -11738,11 +13721,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "multiprocessing.pool.IMapUnorderedIterator"; rt.short_name = "IMapUnorderedIterator"; cbm_registry_add_type(reg, rt); - static const char* py_methods_558[] = { "__init__", "Process", "apply", "apply_async", "map", "map_async", "imap", "imap_unordered", "starmap", "starmap_async", "close", "terminate", "join", "__enter__", "__exit__", NULL }; + static const char* py_methods_683[] = { "__init__", "Process", "apply", "apply_async", "map", "map_async", "imap", "imap_unordered", "starmap", "starmap_async", "close", "terminate", "join", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.pool.Pool"; rt.short_name = "Pool"; - rt.method_names = py_methods_558; + rt.method_names = py_methods_683; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.pool.Pool.__init__"; @@ -11819,13 +13802,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "multiprocessing.pool.Pool"; cbm_registry_add_func(reg, rf); - static const char* py_methods_559[] = { "__init__", NULL }; + static const char* py_methods_684[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.pool.ThreadPool"; rt.short_name = "ThreadPool"; - rt.method_names = py_methods_559; - static const char* py_bases_560[] = { "multiprocessing.pool.Pool", NULL }; - rt.embedded_types = py_bases_560; + rt.method_names = py_methods_684; + static const char* py_bases_685[] = { "multiprocessing.pool.Pool", NULL }; + rt.embedded_types = py_bases_685; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.pool.ThreadPool.__init__"; @@ -11834,11 +13817,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.popen_fork ===== */ - static const char* py_methods_561[] = { "__init__", "duplicate_for_child", "poll", "wait", "interrupt", "terminate", "kill", "close", NULL }; + static const char* py_methods_686[] = { "__init__", "duplicate_for_child", "poll", "wait", "interrupt", "terminate", "kill", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.popen_fork.Popen"; rt.short_name = "Popen"; - rt.method_names = py_methods_561; + rt.method_names = py_methods_686; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.popen_fork.Popen.__init__"; @@ -11882,11 +13865,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.popen_forkserver ===== */ - static const char* py_methods_562[] = { "__init__", "detach", NULL }; + static const char* py_methods_687[] = { "__init__", "detach", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.popen_forkserver._DupFd"; rt.short_name = "_DupFd"; - rt.method_names = py_methods_562; + rt.method_names = py_methods_687; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.popen_forkserver._DupFd.__init__"; @@ -11901,16 +13884,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.popen_forkserver.Popen"; rt.short_name = "Popen"; - static const char* py_bases_563[] = { "popen_fork.Popen", NULL }; - rt.embedded_types = py_bases_563; + static const char* py_bases_688[] = { "popen_fork.Popen", NULL }; + rt.embedded_types = py_bases_688; cbm_registry_add_type(reg, rt); /* ===== module: multiprocessing.popen_spawn_posix ===== */ - static const char* py_methods_564[] = { "__init__", "detach", NULL }; + static const char* py_methods_689[] = { "__init__", "detach", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.popen_spawn_posix._DupFd"; rt.short_name = "_DupFd"; - rt.method_names = py_methods_564; + rt.method_names = py_methods_689; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.popen_spawn_posix._DupFd.__init__"; @@ -11925,16 +13908,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.popen_spawn_posix.Popen"; rt.short_name = "Popen"; - static const char* py_bases_565[] = { "popen_fork.Popen", NULL }; - rt.embedded_types = py_bases_565; + static const char* py_bases_690[] = { "popen_fork.Popen", NULL }; + rt.embedded_types = py_bases_690; cbm_registry_add_type(reg, rt); /* ===== module: multiprocessing.popen_spawn_win32 ===== */ - static const char* py_methods_566[] = { "__init__", "duplicate_for_child", "wait", "poll", "terminate", "close", NULL }; + static const char* py_methods_691[] = { "__init__", "duplicate_for_child", "wait", "poll", "terminate", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.popen_spawn_win32.Popen"; rt.short_name = "Popen"; - rt.method_names = py_methods_566; + rt.method_names = py_methods_691; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.__init__"; @@ -11968,11 +13951,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.process ===== */ - static const char* py_methods_567[] = { "__init__", "run", "start", "interrupt", "terminate", "kill", "close", "join", "is_alive", "exitcode", "ident", "pid", "sentinel", NULL }; + static const char* py_methods_692[] = { "__init__", "run", "start", "interrupt", "terminate", "kill", "close", "join", "is_alive", "exitcode", "ident", "pid", "sentinel", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.process.BaseProcess"; rt.short_name = "BaseProcess"; - rt.method_names = py_methods_567; + rt.method_names = py_methods_692; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.process.BaseProcess.__init__"; @@ -12053,11 +14036,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.queues ===== */ - static const char* py_methods_568[] = { "__init__", "put", "get", "qsize", "empty", "full", "get_nowait", "put_nowait", "close", "join_thread", "cancel_join_thread", "__class_getitem__", NULL }; + static const char* py_methods_693[] = { "__init__", "put", "get", "qsize", "empty", "full", "get_nowait", "put_nowait", "close", "join_thread", "cancel_join_thread", "__class_getitem__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.queues.Queue"; rt.short_name = "Queue"; - rt.method_names = py_methods_568; + rt.method_names = py_methods_693; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.queues.Queue.__init__"; @@ -12119,11 +14102,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__class_getitem__"; rf.receiver_type = "multiprocessing.queues.Queue"; cbm_registry_add_func(reg, rf); - static const char* py_methods_569[] = { "task_done", "join", NULL }; + static const char* py_methods_694[] = { "task_done", "join", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.queues.JoinableQueue"; rt.short_name = "JoinableQueue"; - rt.method_names = py_methods_569; + rt.method_names = py_methods_694; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.queues.JoinableQueue.task_done"; @@ -12135,11 +14118,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "join"; rf.receiver_type = "multiprocessing.queues.JoinableQueue"; cbm_registry_add_func(reg, rf); - static const char* py_methods_570[] = { "__init__", "close", "empty", "get", "put", NULL }; + static const char* py_methods_695[] = { "__init__", "close", "empty", "get", "put", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.queues.SimpleQueue"; rt.short_name = "SimpleQueue"; - rt.method_names = py_methods_570; + rt.method_names = py_methods_695; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.queues.SimpleQueue.__init__"; @@ -12168,13 +14151,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.reduction ===== */ - static const char* py_methods_571[] = { "__init__", "register", "dumps", NULL }; + static const char* py_methods_696[] = { "__init__", "register", "dumps", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.reduction.ForkingPickler"; rt.short_name = "ForkingPickler"; - rt.method_names = py_methods_571; - static const char* py_bases_572[] = { "pickle.Pickler", NULL }; - rt.embedded_types = py_bases_572; + rt.method_names = py_methods_696; + static const char* py_bases_697[] = { "pickle.Pickler", NULL }; + rt.embedded_types = py_bases_697; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.reduction.ForkingPickler.__init__"; @@ -12191,11 +14174,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "dumps"; rf.receiver_type = "multiprocessing.reduction.ForkingPickler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_573[] = { "__init__", "detach", NULL }; + static const char* py_methods_698[] = { "__init__", "detach", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.reduction.DupHandle"; rt.short_name = "DupHandle"; - rt.method_names = py_methods_573; + rt.method_names = py_methods_698; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.reduction.DupHandle.__init__"; @@ -12207,11 +14190,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "detach"; rf.receiver_type = "multiprocessing.reduction.DupHandle"; cbm_registry_add_func(reg, rf); - static const char* py_methods_574[] = { "__init__", NULL }; + static const char* py_methods_699[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.reduction.AbstractReducer"; rt.short_name = "AbstractReducer"; - rt.method_names = py_methods_574; + rt.method_names = py_methods_699; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.reduction.AbstractReducer.__init__"; @@ -12252,11 +14235,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.resource_sharer ===== */ - static const char* py_methods_575[] = { "__init__", "detach", NULL }; + static const char* py_methods_700[] = { "__init__", "detach", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.resource_sharer.DupSocket"; rt.short_name = "DupSocket"; - rt.method_names = py_methods_575; + rt.method_names = py_methods_700; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.resource_sharer.DupSocket.__init__"; @@ -12268,11 +14251,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "detach"; rf.receiver_type = "multiprocessing.resource_sharer.DupSocket"; cbm_registry_add_func(reg, rf); - static const char* py_methods_576[] = { "__init__", "detach", NULL }; + static const char* py_methods_701[] = { "__init__", "detach", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.resource_sharer.DupFd"; rt.short_name = "DupFd"; - rt.method_names = py_methods_576; + rt.method_names = py_methods_701; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.resource_sharer.DupFd.__init__"; @@ -12290,11 +14273,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.resource_tracker ===== */ - static const char* py_methods_577[] = { "getfd", "ensure_running", "register", "unregister", "__del__", NULL }; + static const char* py_methods_702[] = { "getfd", "ensure_running", "register", "unregister", "__del__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.resource_tracker.ResourceTracker"; rt.short_name = "ResourceTracker"; - rt.method_names = py_methods_577; + rt.method_names = py_methods_702; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.resource_tracker.ResourceTracker.getfd"; @@ -12327,11 +14310,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.shared_memory ===== */ - static const char* py_methods_578[] = { "__init__", "buf", "name", "size", "close", "unlink", NULL }; + static const char* py_methods_703[] = { "__init__", "buf", "name", "size", "close", "unlink", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.shared_memory.SharedMemory"; rt.short_name = "SharedMemory"; - rt.method_names = py_methods_578; + rt.method_names = py_methods_703; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.__init__"; @@ -12363,11 +14346,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "unlink"; rf.receiver_type = "multiprocessing.shared_memory.SharedMemory"; cbm_registry_add_func(reg, rf); - static const char* py_methods_579[] = { "__init__", "format", "count", "index", NULL }; + static const char* py_methods_704[] = { "__init__", "format", "count", "index", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.shared_memory.ShareableList"; rt.short_name = "ShareableList"; - rt.method_names = py_methods_579; + rt.method_names = py_methods_704; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.shared_memory.ShareableList.__init__"; @@ -12391,24 +14374,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.sharedctypes ===== */ - static const char* py_methods_580[] = { "__call__", NULL }; + static const char* py_methods_705[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.sharedctypes._AcquireFunc"; rt.short_name = "_AcquireFunc"; - rt.method_names = py_methods_580; - static const char* py_bases_581[] = { "multiprocessing.sharedctypes.Protocol", NULL }; - rt.embedded_types = py_bases_581; + rt.method_names = py_methods_705; + static const char* py_bases_706[] = { "multiprocessing.sharedctypes.Protocol", NULL }; + rt.embedded_types = py_bases_706; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.sharedctypes._AcquireFunc.__call__"; rf.short_name = "__call__"; rf.receiver_type = "multiprocessing.sharedctypes._AcquireFunc"; cbm_registry_add_func(reg, rf); - static const char* py_methods_582[] = { "__init__", "get_obj", "get_lock", "__enter__", "__exit__", NULL }; + static const char* py_methods_707[] = { "__init__", "get_obj", "get_lock", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase"; rt.short_name = "SynchronizedBase"; - rt.method_names = py_methods_582; + rt.method_names = py_methods_707; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase.__init__"; @@ -12511,24 +14494,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.synchronize ===== */ - static const char* py_methods_583[] = { "__init__", NULL }; + static const char* py_methods_708[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.Barrier"; rt.short_name = "Barrier"; - rt.method_names = py_methods_583; - static const char* py_bases_584[] = { "threading.Barrier", NULL }; - rt.embedded_types = py_bases_584; + rt.method_names = py_methods_708; + static const char* py_bases_709[] = { "threading.Barrier", NULL }; + rt.embedded_types = py_bases_709; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.Barrier.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.synchronize.Barrier"; cbm_registry_add_func(reg, rf); - static const char* py_methods_585[] = { "__init__", "notify", "notify_all", "wait", "wait_for", "__enter__", "__exit__", "acquire", "release", NULL }; + static const char* py_methods_710[] = { "__init__", "notify", "notify_all", "wait", "wait_for", "__enter__", "__exit__", "acquire", "release", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.Condition"; rt.short_name = "Condition"; - rt.method_names = py_methods_585; + rt.method_names = py_methods_710; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.Condition.__init__"; @@ -12575,11 +14558,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "release"; rf.receiver_type = "multiprocessing.synchronize.Condition"; cbm_registry_add_func(reg, rf); - static const char* py_methods_586[] = { "__init__", "is_set", "set", "clear", "wait", NULL }; + static const char* py_methods_711[] = { "__init__", "is_set", "set", "clear", "wait", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.Event"; rt.short_name = "Event"; - rt.method_names = py_methods_586; + rt.method_names = py_methods_711; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.Event.__init__"; @@ -12606,11 +14589,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "wait"; rf.receiver_type = "multiprocessing.synchronize.Event"; cbm_registry_add_func(reg, rf); - static const char* py_methods_587[] = { "__init__", "__enter__", "__exit__", "acquire", "release", "locked", NULL }; + static const char* py_methods_712[] = { "__init__", "__enter__", "__exit__", "acquire", "release", "locked", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.SemLock"; rt.short_name = "SemLock"; - rt.method_names = py_methods_587; + rt.method_names = py_methods_712; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.SemLock.__init__"; @@ -12642,39 +14625,39 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "locked"; rf.receiver_type = "multiprocessing.synchronize.SemLock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_588[] = { "__init__", NULL }; + static const char* py_methods_713[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.Lock"; rt.short_name = "Lock"; - rt.method_names = py_methods_588; - static const char* py_bases_589[] = { "multiprocessing.synchronize.SemLock", NULL }; - rt.embedded_types = py_bases_589; + rt.method_names = py_methods_713; + static const char* py_bases_714[] = { "multiprocessing.synchronize.SemLock", NULL }; + rt.embedded_types = py_bases_714; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.Lock.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.synchronize.Lock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_590[] = { "__init__", NULL }; + static const char* py_methods_715[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.RLock"; rt.short_name = "RLock"; - rt.method_names = py_methods_590; - static const char* py_bases_591[] = { "multiprocessing.synchronize.SemLock", NULL }; - rt.embedded_types = py_bases_591; + rt.method_names = py_methods_715; + static const char* py_bases_716[] = { "multiprocessing.synchronize.SemLock", NULL }; + rt.embedded_types = py_bases_716; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.RLock.__init__"; rf.short_name = "__init__"; rf.receiver_type = "multiprocessing.synchronize.RLock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_592[] = { "__init__", "get_value", NULL }; + static const char* py_methods_717[] = { "__init__", "get_value", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.Semaphore"; rt.short_name = "Semaphore"; - rt.method_names = py_methods_592; - static const char* py_bases_593[] = { "multiprocessing.synchronize.SemLock", NULL }; - rt.embedded_types = py_bases_593; + rt.method_names = py_methods_717; + static const char* py_bases_718[] = { "multiprocessing.synchronize.SemLock", NULL }; + rt.embedded_types = py_bases_718; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.Semaphore.__init__"; @@ -12686,13 +14669,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "get_value"; rf.receiver_type = "multiprocessing.synchronize.Semaphore"; cbm_registry_add_func(reg, rf); - static const char* py_methods_594[] = { "__init__", NULL }; + static const char* py_methods_719[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.synchronize.BoundedSemaphore"; rt.short_name = "BoundedSemaphore"; - rt.method_names = py_methods_594; - static const char* py_bases_595[] = { "multiprocessing.synchronize.Semaphore", NULL }; - rt.embedded_types = py_bases_595; + rt.method_names = py_methods_719; + static const char* py_bases_720[] = { "multiprocessing.synchronize.Semaphore", NULL }; + rt.embedded_types = py_bases_720; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.synchronize.BoundedSemaphore.__init__"; @@ -12701,11 +14684,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: multiprocessing.util ===== */ - static const char* py_methods_596[] = { "__init__", "__call__", "cancel", "still_active", NULL }; + static const char* py_methods_721[] = { "__init__", "__call__", "cancel", "still_active", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.util.Finalize"; rt.short_name = "Finalize"; - rt.method_names = py_methods_596; + rt.method_names = py_methods_721; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.util.Finalize.__init__"; @@ -12727,11 +14710,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "still_active"; rf.receiver_type = "multiprocessing.util.Finalize"; cbm_registry_add_func(reg, rf); - static const char* py_methods_597[] = { "__enter__", "__exit__", NULL }; + static const char* py_methods_722[] = { "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.util.ForkAwareThreadLock"; rt.short_name = "ForkAwareThreadLock"; - rt.method_names = py_methods_597; + rt.method_names = py_methods_722; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.util.ForkAwareThreadLock.__enter__"; @@ -12746,8 +14729,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "multiprocessing.util.ForkAwareLocal"; rt.short_name = "ForkAwareLocal"; - static const char* py_bases_598[] = { "threading.local", NULL }; - rt.embedded_types = py_bases_598; + static const char* py_bases_723[] = { "threading.local", NULL }; + rt.embedded_types = py_bases_723; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "multiprocessing.util.sub_debug"; @@ -12802,12 +14785,26 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "spawnv_passfds"; cbm_registry_add_func(reg, rf); + /* ===== module: ntpath ===== */ + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "ntpath.join"; + rf.short_name = "join"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "ntpath.realpath"; + rf.short_name = "realpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "ntpath.isreserved"; + rf.short_name = "isreserved"; + cbm_registry_add_func(reg, rf); + /* ===== module: os ===== */ - static const char* py_methods_599[] = { "__init__", "get", "pop", "setdefault", "copy", NULL }; + static const char* py_methods_724[] = { "__init__", "get", "pop", "setdefault", "copy", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os._Environ"; rt.short_name = "_Environ"; - rt.method_names = py_methods_599; + rt.method_names = py_methods_724; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os._Environ.__init__"; @@ -12834,11 +14831,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "copy"; rf.receiver_type = "os._Environ"; cbm_registry_add_func(reg, rf); - static const char* py_methods_600[] = { "st_mode", "st_ino", "st_dev", "st_nlink", "st_uid", "st_gid", "st_size", "st_atime", "st_mtime", "st_ctime", "st_atime_ns", "st_mtime_ns", "st_ctime_ns", "st_file_attributes", "st_reparse_tag", "st_blocks", "st_blksize", "st_rdev", "st_flags", NULL }; + static const char* py_methods_725[] = { "st_mode", "st_ino", "st_dev", "st_nlink", "st_uid", "st_gid", "st_size", "st_atime", "st_mtime", "st_ctime", "st_atime_ns", "st_mtime_ns", "st_ctime_ns", "st_file_attributes", "st_reparse_tag", "st_blocks", "st_blksize", "st_rdev", "st_flags", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.stat_result"; rt.short_name = "stat_result"; - rt.method_names = py_methods_600; + rt.method_names = py_methods_725; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.stat_result.st_mode"; @@ -12938,14 +14935,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.PathLike"; rt.short_name = "PathLike"; - static const char* py_bases_601[] = { "os.ABC", NULL }; - rt.embedded_types = py_bases_601; + static const char* py_bases_726[] = { "os.ABC", NULL }; + rt.embedded_types = py_bases_726; cbm_registry_add_type(reg, rt); - static const char* py_methods_602[] = { "name", "path", "inode", "is_dir", "is_file", "is_symlink", "stat", "is_junction", NULL }; + static const char* py_methods_727[] = { "name", "path", "inode", "is_dir", "is_file", "is_symlink", "stat", "is_junction", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.DirEntry"; rt.short_name = "DirEntry"; - rt.method_names = py_methods_602; + rt.method_names = py_methods_727; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.DirEntry.name"; @@ -12987,11 +14984,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "is_junction"; rf.receiver_type = "os.DirEntry"; cbm_registry_add_func(reg, rf); - static const char* py_methods_603[] = { "f_bsize", "f_frsize", "f_blocks", "f_bfree", "f_bavail", "f_files", "f_ffree", "f_favail", "f_flag", "f_namemax", "f_fsid", NULL }; + static const char* py_methods_728[] = { "f_bsize", "f_frsize", "f_blocks", "f_bfree", "f_bavail", "f_files", "f_ffree", "f_favail", "f_flag", "f_namemax", "f_fsid", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.statvfs_result"; rt.short_name = "statvfs_result"; - rt.method_names = py_methods_603; + rt.method_names = py_methods_728; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.statvfs_result.f_bsize"; @@ -13048,11 +15045,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "f_fsid"; rf.receiver_type = "os.statvfs_result"; cbm_registry_add_func(reg, rf); - static const char* py_methods_604[] = { "sysname", "nodename", "release", "version", "machine", NULL }; + static const char* py_methods_729[] = { "sysname", "nodename", "release", "version", "machine", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.uname_result"; rt.short_name = "uname_result"; - rt.method_names = py_methods_604; + rt.method_names = py_methods_729; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.uname_result.sysname"; @@ -13079,11 +15076,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "machine"; rf.receiver_type = "os.uname_result"; cbm_registry_add_func(reg, rf); - static const char* py_methods_605[] = { "columns", "lines", NULL }; + static const char* py_methods_730[] = { "columns", "lines", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.terminal_size"; rt.short_name = "terminal_size"; - rt.method_names = py_methods_605; + rt.method_names = py_methods_730; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.terminal_size.columns"; @@ -13095,11 +15092,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "lines"; rf.receiver_type = "os.terminal_size"; cbm_registry_add_func(reg, rf); - static const char* py_methods_606[] = { "__enter__", "__exit__", "close", NULL }; + static const char* py_methods_731[] = { "__enter__", "__exit__", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os._ScandirIterator"; rt.short_name = "_ScandirIterator"; - rt.method_names = py_methods_606; + rt.method_names = py_methods_731; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os._ScandirIterator.__enter__"; @@ -13116,11 +15113,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "close"; rf.receiver_type = "os._ScandirIterator"; cbm_registry_add_func(reg, rf); - static const char* py_methods_607[] = { "__init__", "close", "__enter__", "__exit__", "read", "readable", "readline", "readlines", "writable", "write", "writelines", NULL }; + static const char* py_methods_732[] = { "__init__", "close", "__enter__", "__exit__", "read", "readable", "readline", "readlines", "writable", "write", "writelines", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os._wrap_close"; rt.short_name = "_wrap_close"; - rt.method_names = py_methods_607; + rt.method_names = py_methods_732; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os._wrap_close.__init__"; @@ -13177,11 +15174,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "writelines"; rf.receiver_type = "os._wrap_close"; cbm_registry_add_func(reg, rf); - static const char* py_methods_608[] = { "user", "system", "children_user", "children_system", "elapsed", NULL }; + static const char* py_methods_733[] = { "user", "system", "children_user", "children_system", "elapsed", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.times_result"; rt.short_name = "times_result"; - rt.method_names = py_methods_608; + rt.method_names = py_methods_733; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.times_result.user"; @@ -13208,11 +15205,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "elapsed"; rf.receiver_type = "os.times_result"; cbm_registry_add_func(reg, rf); - static const char* py_methods_609[] = { "si_pid", "si_uid", "si_signo", "si_status", "si_code", NULL }; + static const char* py_methods_734[] = { "si_pid", "si_uid", "si_signo", "si_status", "si_code", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.waitid_result"; rt.short_name = "waitid_result"; - rt.method_names = py_methods_609; + rt.method_names = py_methods_734; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.waitid_result.si_pid"; @@ -13239,22 +15236,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "si_code"; rf.receiver_type = "os.waitid_result"; cbm_registry_add_func(reg, rf); - static const char* py_methods_610[] = { "sched_priority", NULL }; + static const char* py_methods_735[] = { "sched_priority", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os.sched_param"; rt.short_name = "sched_param"; - rt.method_names = py_methods_610; + rt.method_names = py_methods_735; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os.sched_param.sched_priority"; rf.short_name = "sched_priority"; rf.receiver_type = "os.sched_param"; cbm_registry_add_func(reg, rf); - static const char* py_methods_611[] = { "__init__", "close", "__enter__", "__exit__", NULL }; + static const char* py_methods_736[] = { "__init__", "close", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "os._AddedDllDirectory"; rt.short_name = "_AddedDllDirectory"; - rt.method_names = py_methods_611; + rt.method_names = py_methods_736; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "os._AddedDllDirectory.__init__"; @@ -14129,12 +16126,98 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "lchmod"; cbm_registry_add_func(reg, rf); + /* ===== module: os.path ===== */ + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.join"; + rf.short_name = "join"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.realpath"; + rf.short_name = "realpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.isreserved"; + rf.short_name = "isreserved"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.abspath"; + rf.short_name = "abspath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.basename"; + rf.short_name = "basename"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.dirname"; + rf.short_name = "dirname"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.expanduser"; + rf.short_name = "expanduser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.expandvars"; + rf.short_name = "expandvars"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.normcase"; + rf.short_name = "normcase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.normpath"; + rf.short_name = "normpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.commonpath"; + rf.short_name = "commonpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.relpath"; + rf.short_name = "relpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.split"; + rf.short_name = "split"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.splitdrive"; + rf.short_name = "splitdrive"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.splitext"; + rf.short_name = "splitext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.isabs"; + rf.short_name = "isabs"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.islink"; + rf.short_name = "islink"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.ismount"; + rf.short_name = "ismount"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.lexists"; + rf.short_name = "lexists"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.isjunction"; + rf.short_name = "isjunction"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "os.path.splitroot"; + rf.short_name = "splitroot"; + cbm_registry_add_func(reg, rf); + /* ===== module: pathlib ===== */ - static const char* py_methods_612[] = { "full_match", "parts", "drive", "root", "anchor", "name", "suffix", "suffixes", "stem", "__new__", "__init__", "as_posix", "as_uri", "is_absolute", "is_reserved", "is_relative_to", "match", "relative_to", "with_name", "with_stem", "with_suffix", "joinpath", "parents", "parent", "__class_getitem__", "with_segments", NULL }; + static const char* py_methods_737[] = { "full_match", "parts", "drive", "root", "anchor", "name", "suffix", "suffixes", "stem", "__new__", "__init__", "as_posix", "as_uri", "is_absolute", "is_reserved", "is_relative_to", "match", "relative_to", "with_name", "with_stem", "with_suffix", "joinpath", "parents", "parent", "__class_getitem__", "with_segments", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.PurePath"; rt.short_name = "PurePath"; - rt.method_names = py_methods_612; + rt.method_names = py_methods_737; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "pathlib.PurePath.full_match"; @@ -14269,22 +16352,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.PurePosixPath"; rt.short_name = "PurePosixPath"; - static const char* py_bases_613[] = { "pathlib.PurePath", NULL }; - rt.embedded_types = py_bases_613; + static const char* py_bases_738[] = { "pathlib.PurePath", NULL }; + rt.embedded_types = py_bases_738; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.PureWindowsPath"; rt.short_name = "PureWindowsPath"; - static const char* py_bases_614[] = { "pathlib.PurePath", NULL }; - rt.embedded_types = py_bases_614; + static const char* py_bases_739[] = { "pathlib.PurePath", NULL }; + rt.embedded_types = py_bases_739; cbm_registry_add_type(reg, rt); - static const char* py_methods_615[] = { "__new__", "cwd", "stat", "chmod", "from_uri", "is_dir", "is_file", "read_text", "__enter__", "__exit__", "glob", "rglob", "exists", "is_symlink", "is_socket", "is_fifo", "is_block_device", "is_char_device", "is_junction", "iterdir", "lchmod", "lstat", "mkdir", "info", "move_into", "move", "copy_into", "copy", "open", "is_mount", "readlink", "rename", "replace", "resolve", "rmdir", "symlink_to", "hardlink_to", "touch", "unlink", "home", "absolute", "expanduser", "read_bytes", "samefile", "write_bytes", "write_text", "link_to", "walk", "as_uri", NULL }; + static const char* py_methods_740[] = { "__new__", "cwd", "stat", "chmod", "from_uri", "is_dir", "is_file", "read_text", "__enter__", "__exit__", "glob", "rglob", "exists", "is_symlink", "is_socket", "is_fifo", "is_block_device", "is_char_device", "is_junction", "iterdir", "lchmod", "lstat", "mkdir", "info", "move_into", "move", "copy_into", "copy", "open", "is_mount", "readlink", "rename", "replace", "resolve", "rmdir", "symlink_to", "hardlink_to", "touch", "unlink", "home", "absolute", "expanduser", "read_bytes", "samefile", "write_bytes", "write_text", "link_to", "walk", "as_uri", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.Path"; rt.short_name = "Path"; - rt.method_names = py_methods_615; - static const char* py_bases_616[] = { "pathlib.PurePath", NULL }; - rt.embedded_types = py_bases_616; + rt.method_names = py_methods_740; + static const char* py_bases_741[] = { "pathlib.PurePath", NULL }; + rt.embedded_types = py_bases_741; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "pathlib.Path.__new__"; @@ -14534,30 +16617,30 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.PosixPath"; rt.short_name = "PosixPath"; - static const char* py_bases_617[] = { "pathlib.Path", "pathlib.PurePosixPath", NULL }; - rt.embedded_types = py_bases_617; + static const char* py_bases_742[] = { "pathlib.Path", "pathlib.PurePosixPath", NULL }; + rt.embedded_types = py_bases_742; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.WindowsPath"; rt.short_name = "WindowsPath"; - static const char* py_bases_618[] = { "pathlib.Path", "pathlib.PureWindowsPath", NULL }; - rt.embedded_types = py_bases_618; + static const char* py_bases_743[] = { "pathlib.Path", "pathlib.PureWindowsPath", NULL }; + rt.embedded_types = py_bases_743; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.UnsupportedOperation"; rt.short_name = "UnsupportedOperation"; - static const char* py_bases_619[] = { "pathlib.NotImplementedError", NULL }; - rt.embedded_types = py_bases_619; + static const char* py_bases_744[] = { "pathlib.NotImplementedError", NULL }; + rt.embedded_types = py_bases_744; cbm_registry_add_type(reg, rt); /* ===== module: pathlib.types ===== */ - static const char* py_methods_620[] = { "exists", "is_dir", "is_file", "is_symlink", NULL }; + static const char* py_methods_745[] = { "exists", "is_dir", "is_file", "is_symlink", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pathlib.types.PathInfo"; rt.short_name = "PathInfo"; - rt.method_names = py_methods_620; - static const char* py_bases_621[] = { "pathlib.types.Protocol", NULL }; - rt.embedded_types = py_bases_621; + rt.method_names = py_methods_745; + static const char* py_bases_746[] = { "pathlib.types.Protocol", NULL }; + rt.embedded_types = py_bases_746; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "pathlib.types.PathInfo.exists"; @@ -14581,11 +16664,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: pickle ===== */ - static const char* py_methods_622[] = { "raw", "release", NULL }; + static const char* py_methods_747[] = { "raw", "release", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pickle.PickleBuffer"; rt.short_name = "PickleBuffer"; - rt.method_names = py_methods_622; + rt.method_names = py_methods_747; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "pickle.PickleBuffer.raw"; @@ -14597,11 +16680,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "release"; rf.receiver_type = "pickle.PickleBuffer"; cbm_registry_add_func(reg, rf); - static const char* py_methods_623[] = { "__init__", "dump", "clear_memo", "persistent_id", "reducer_override", NULL }; + static const char* py_methods_748[] = { "__init__", "dump", "clear_memo", "persistent_id", "reducer_override", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pickle._Pickler"; rt.short_name = "_Pickler"; - rt.method_names = py_methods_623; + rt.method_names = py_methods_748; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "pickle._Pickler.__init__"; @@ -14628,11 +16711,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "reducer_override"; rf.receiver_type = "pickle._Pickler"; cbm_registry_add_func(reg, rf); - static const char* py_methods_624[] = { "__init__", "load", "find_class", "persistent_load", NULL }; + static const char* py_methods_749[] = { "__init__", "load", "find_class", "persistent_load", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "pickle._Unpickler"; rt.short_name = "_Unpickler"; - rt.method_names = py_methods_624; + rt.method_names = py_methods_749; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "pickle._Unpickler.__init__"; @@ -14663,24 +16746,106 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "decode_long"; cbm_registry_add_func(reg, rf); + /* ===== module: posixpath ===== */ + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.abspath"; + rf.short_name = "abspath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.basename"; + rf.short_name = "basename"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.dirname"; + rf.short_name = "dirname"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.expanduser"; + rf.short_name = "expanduser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.expandvars"; + rf.short_name = "expandvars"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.normcase"; + rf.short_name = "normcase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.normpath"; + rf.short_name = "normpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.commonpath"; + rf.short_name = "commonpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.join"; + rf.short_name = "join"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.realpath"; + rf.short_name = "realpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.relpath"; + rf.short_name = "relpath"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.split"; + rf.short_name = "split"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.splitdrive"; + rf.short_name = "splitdrive"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.splitext"; + rf.short_name = "splitext"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.isabs"; + rf.short_name = "isabs"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.islink"; + rf.short_name = "islink"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.ismount"; + rf.short_name = "ismount"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.lexists"; + rf.short_name = "lexists"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.isjunction"; + rf.short_name = "isjunction"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "posixpath.splitroot"; + rf.short_name = "splitroot"; + cbm_registry_add_func(reg, rf); + /* ===== module: queue ===== */ memset(&rt, 0, sizeof(rt)); rt.qualified_name = "queue.Full"; rt.short_name = "Full"; - static const char* py_bases_625[] = { "queue.Exception", NULL }; - rt.embedded_types = py_bases_625; + static const char* py_bases_750[] = { "queue.Exception", NULL }; + rt.embedded_types = py_bases_750; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "queue.ShutDown"; rt.short_name = "ShutDown"; - static const char* py_bases_626[] = { "queue.Exception", NULL }; - rt.embedded_types = py_bases_626; + static const char* py_bases_751[] = { "queue.Exception", NULL }; + rt.embedded_types = py_bases_751; cbm_registry_add_type(reg, rt); - static const char* py_methods_627[] = { "__init__", "empty", "full", "get", "get_nowait", "shutdown", "put", "put_nowait", "join", "qsize", "task_done", NULL }; + static const char* py_methods_752[] = { "__init__", "empty", "full", "get", "get_nowait", "shutdown", "put", "put_nowait", "join", "qsize", "task_done", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "queue.Queue"; rt.short_name = "Queue"; - rt.method_names = py_methods_627; + rt.method_names = py_methods_752; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "queue.Queue.__init__"; @@ -14747,24 +16912,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_type(reg, rt); /* ===== module: re ===== */ - static const char* py_methods_628[] = { "__init__", NULL }; + static const char* py_methods_753[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "re.error"; rt.short_name = "error"; - rt.method_names = py_methods_628; - static const char* py_bases_629[] = { "re.Exception", NULL }; - rt.embedded_types = py_bases_629; + rt.method_names = py_methods_753; + static const char* py_bases_754[] = { "re.Exception", NULL }; + rt.embedded_types = py_bases_754; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "re.error.__init__"; rf.short_name = "__init__"; rf.receiver_type = "re.error"; cbm_registry_add_func(reg, rf); - static const char* py_methods_630[] = { "pos", "endpos", "lastindex", "lastgroup", "string", "re", "expand", "group", "groups", "groupdict", "start", "end", "span", "regs", NULL }; + static const char* py_methods_755[] = { "pos", "endpos", "lastindex", "lastgroup", "string", "re", "expand", "group", "groups", "groupdict", "start", "end", "span", "regs", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "re.Match"; rt.short_name = "Match"; - rt.method_names = py_methods_630; + rt.method_names = py_methods_755; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "re.Match.pos"; @@ -14836,11 +17001,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "regs"; rf.receiver_type = "re.Match"; cbm_registry_add_func(reg, rf); - static const char* py_methods_631[] = { "flags", "groupindex", "groups", "pattern", "search", "match", "fullmatch", "split", "findall", "finditer", "sub", "subn", NULL }; + static const char* py_methods_756[] = { "flags", "groupindex", "groups", "pattern", "search", "match", "fullmatch", "split", "findall", "finditer", "sub", "subn", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "re.Pattern"; rt.short_name = "Pattern"; - rt.method_names = py_methods_631; + rt.method_names = py_methods_756; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "re.Pattern.flags"; @@ -14905,8 +17070,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "re.RegexFlag"; rt.short_name = "RegexFlag"; - static const char* py_bases_632[] = { "enum.IntFlag", NULL }; - rt.embedded_types = py_bases_632; + static const char* py_bases_757[] = { "enum.IntFlag", NULL }; + rt.embedded_types = py_bases_757; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "re.compile"; @@ -14961,46 +17126,46 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil.Error"; rt.short_name = "Error"; - static const char* py_bases_633[] = { "shutil.OSError", NULL }; - rt.embedded_types = py_bases_633; + static const char* py_bases_758[] = { "shutil.OSError", NULL }; + rt.embedded_types = py_bases_758; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil.SameFileError"; rt.short_name = "SameFileError"; - static const char* py_bases_634[] = { "shutil.Error", NULL }; - rt.embedded_types = py_bases_634; + static const char* py_bases_759[] = { "shutil.Error", NULL }; + rt.embedded_types = py_bases_759; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil.SpecialFileError"; rt.short_name = "SpecialFileError"; - static const char* py_bases_635[] = { "shutil.OSError", NULL }; - rt.embedded_types = py_bases_635; + static const char* py_bases_760[] = { "shutil.OSError", NULL }; + rt.embedded_types = py_bases_760; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil.ExecError"; rt.short_name = "ExecError"; - static const char* py_bases_636[] = { "shutil.OSError", NULL }; - rt.embedded_types = py_bases_636; + static const char* py_bases_761[] = { "shutil.OSError", NULL }; + rt.embedded_types = py_bases_761; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil.ReadError"; rt.short_name = "ReadError"; - static const char* py_bases_637[] = { "shutil.OSError", NULL }; - rt.embedded_types = py_bases_637; + static const char* py_bases_762[] = { "shutil.OSError", NULL }; + rt.embedded_types = py_bases_762; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil.RegistryError"; rt.short_name = "RegistryError"; - static const char* py_bases_638[] = { "shutil.Exception", NULL }; - rt.embedded_types = py_bases_638; + static const char* py_bases_763[] = { "shutil.Exception", NULL }; + rt.embedded_types = py_bases_763; cbm_registry_add_type(reg, rt); - static const char* py_methods_639[] = { "__call__", NULL }; + static const char* py_methods_764[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil._RmtreeType"; rt.short_name = "_RmtreeType"; - rt.method_names = py_methods_639; - static const char* py_bases_640[] = { "shutil.Protocol", NULL }; - rt.embedded_types = py_bases_640; + rt.method_names = py_methods_764; + static const char* py_bases_765[] = { "shutil.Protocol", NULL }; + rt.embedded_types = py_bases_765; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "shutil._RmtreeType.__call__"; @@ -15010,8 +17175,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "shutil._ntuple_diskusage"; rt.short_name = "_ntuple_diskusage"; - static const char* py_bases_641[] = { "shutil.NamedTuple", NULL }; - rt.embedded_types = py_bases_641; + static const char* py_bases_766[] = { "shutil.NamedTuple", NULL }; + rt.embedded_types = py_bases_766; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "shutil.copyfileobj"; @@ -15102,46 +17267,46 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.herror"; rt.short_name = "herror"; - static const char* py_bases_642[] = { "socket.error", NULL }; - rt.embedded_types = py_bases_642; + static const char* py_bases_767[] = { "socket.error", NULL }; + rt.embedded_types = py_bases_767; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.gaierror"; rt.short_name = "gaierror"; - static const char* py_bases_643[] = { "socket.error", NULL }; - rt.embedded_types = py_bases_643; + static const char* py_bases_768[] = { "socket.error", NULL }; + rt.embedded_types = py_bases_768; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.AddressFamily"; rt.short_name = "AddressFamily"; - static const char* py_bases_644[] = { "socket.IntEnum", NULL }; - rt.embedded_types = py_bases_644; + static const char* py_bases_769[] = { "socket.IntEnum", NULL }; + rt.embedded_types = py_bases_769; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.SocketKind"; rt.short_name = "SocketKind"; - static const char* py_bases_645[] = { "socket.IntEnum", NULL }; - rt.embedded_types = py_bases_645; + static const char* py_bases_770[] = { "socket.IntEnum", NULL }; + rt.embedded_types = py_bases_770; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.MsgFlag"; rt.short_name = "MsgFlag"; - static const char* py_bases_646[] = { "socket.IntFlag", NULL }; - rt.embedded_types = py_bases_646; + static const char* py_bases_771[] = { "socket.IntFlag", NULL }; + rt.embedded_types = py_bases_771; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.AddressInfo"; rt.short_name = "AddressInfo"; - static const char* py_bases_647[] = { "socket.IntFlag", NULL }; - rt.embedded_types = py_bases_647; + static const char* py_bases_772[] = { "socket.IntFlag", NULL }; + rt.embedded_types = py_bases_772; cbm_registry_add_type(reg, rt); - static const char* py_methods_648[] = { "read", "seek", NULL }; + static const char* py_methods_773[] = { "read", "seek", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket._SendableFile"; rt.short_name = "_SendableFile"; - rt.method_names = py_methods_648; - static const char* py_bases_649[] = { "socket.Protocol", NULL }; - rt.embedded_types = py_bases_649; + rt.method_names = py_methods_773; + static const char* py_bases_774[] = { "socket.Protocol", NULL }; + rt.embedded_types = py_bases_774; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "socket._SendableFile.read"; @@ -15153,13 +17318,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "seek"; rf.receiver_type = "socket._SendableFile"; cbm_registry_add_func(reg, rf); - static const char* py_methods_650[] = { "__init__", "__enter__", "__exit__", "dup", "accept", "makefile", "sendfile", "family", "type", "get_inheritable", "set_inheritable", NULL }; + static const char* py_methods_775[] = { "__init__", "__enter__", "__exit__", "dup", "accept", "makefile", "sendfile", "family", "type", "get_inheritable", "set_inheritable", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.socket"; rt.short_name = "socket"; - rt.method_names = py_methods_650; - static const char* py_bases_651[] = { "_socket.socket", NULL }; - rt.embedded_types = py_bases_651; + rt.method_names = py_methods_775; + static const char* py_bases_776[] = { "_socket.socket", NULL }; + rt.embedded_types = py_bases_776; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "socket.socket.__init__"; @@ -15216,13 +17381,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "set_inheritable"; rf.receiver_type = "socket.socket"; cbm_registry_add_func(reg, rf); - static const char* py_methods_652[] = { "__init__", "readinto", "write", "name", "mode", NULL }; + static const char* py_methods_777[] = { "__init__", "readinto", "write", "name", "mode", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "socket.SocketIO"; rt.short_name = "SocketIO"; - rt.method_names = py_methods_652; - static const char* py_bases_653[] = { "socket.RawIOBase", NULL }; - rt.embedded_types = py_bases_653; + rt.method_names = py_methods_777; + static const char* py_bases_778[] = { "socket.RawIOBase", NULL }; + rt.embedded_types = py_bases_778; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "socket.SocketIO.__init__"; @@ -15291,11 +17456,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: string ===== */ - static const char* py_methods_654[] = { "__init__", "substitute", "safe_substitute", "get_identifiers", "is_valid", NULL }; + static const char* py_methods_779[] = { "__init__", "substitute", "safe_substitute", "get_identifiers", "is_valid", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "string.Template"; rt.short_name = "Template"; - rt.method_names = py_methods_654; + rt.method_names = py_methods_779; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "string.Template.__init__"; @@ -15322,11 +17487,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "is_valid"; rf.receiver_type = "string.Template"; cbm_registry_add_func(reg, rf); - static const char* py_methods_655[] = { "format", "vformat", "parse", "get_field", "get_value", "check_unused_args", "format_field", "convert_field", NULL }; + static const char* py_methods_780[] = { "format", "vformat", "parse", "get_field", "get_value", "check_unused_args", "format_field", "convert_field", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "string.Formatter"; rt.short_name = "Formatter"; - rt.method_names = py_methods_655; + rt.method_names = py_methods_780; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "string.Formatter.format"; @@ -15374,11 +17539,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: string.templatelib ===== */ - static const char* py_methods_656[] = { "values", NULL }; + static const char* py_methods_781[] = { "values", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "string.templatelib.Template"; rt.short_name = "Template"; - rt.method_names = py_methods_656; + rt.method_names = py_methods_781; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "string.templatelib.Template.values"; @@ -15395,11 +17560,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: subprocess ===== */ - static const char* py_methods_657[] = { "__init__", "check_returncode", NULL }; + static const char* py_methods_782[] = { "__init__", "check_returncode", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "subprocess.CompletedProcess"; rt.short_name = "CompletedProcess"; - rt.method_names = py_methods_657; + rt.method_names = py_methods_782; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "subprocess.CompletedProcess.__init__"; @@ -15414,40 +17579,40 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "subprocess.SubprocessError"; rt.short_name = "SubprocessError"; - static const char* py_bases_658[] = { "subprocess.Exception", NULL }; - rt.embedded_types = py_bases_658; + static const char* py_bases_783[] = { "subprocess.Exception", NULL }; + rt.embedded_types = py_bases_783; cbm_registry_add_type(reg, rt); - static const char* py_methods_659[] = { "__init__", NULL }; + static const char* py_methods_784[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "subprocess.TimeoutExpired"; rt.short_name = "TimeoutExpired"; - rt.method_names = py_methods_659; - static const char* py_bases_660[] = { "subprocess.SubprocessError", NULL }; - rt.embedded_types = py_bases_660; + rt.method_names = py_methods_784; + static const char* py_bases_785[] = { "subprocess.SubprocessError", NULL }; + rt.embedded_types = py_bases_785; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "subprocess.TimeoutExpired.__init__"; rf.short_name = "__init__"; rf.receiver_type = "subprocess.TimeoutExpired"; cbm_registry_add_func(reg, rf); - static const char* py_methods_661[] = { "__init__", NULL }; + static const char* py_methods_786[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "subprocess.CalledProcessError"; rt.short_name = "CalledProcessError"; - rt.method_names = py_methods_661; - static const char* py_bases_662[] = { "subprocess.SubprocessError", NULL }; - rt.embedded_types = py_bases_662; + rt.method_names = py_methods_786; + static const char* py_bases_787[] = { "subprocess.SubprocessError", NULL }; + rt.embedded_types = py_bases_787; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "subprocess.CalledProcessError.__init__"; rf.short_name = "__init__"; rf.receiver_type = "subprocess.CalledProcessError"; cbm_registry_add_func(reg, rf); - static const char* py_methods_663[] = { "__init__", "poll", "wait", "communicate", "send_signal", "terminate", "kill", "__enter__", "__exit__", NULL }; + static const char* py_methods_788[] = { "__init__", "poll", "wait", "communicate", "send_signal", "terminate", "kill", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "subprocess.Popen"; rt.short_name = "Popen"; - rt.method_names = py_methods_663; + rt.method_names = py_methods_788; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "subprocess.Popen.__init__"; @@ -15494,11 +17659,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "subprocess.Popen"; cbm_registry_add_func(reg, rf); - static const char* py_methods_664[] = { "__init__", "copy", NULL }; + static const char* py_methods_789[] = { "__init__", "copy", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "subprocess.STARTUPINFO"; rt.short_name = "STARTUPINFO"; - rt.method_names = py_methods_664; + rt.method_names = py_methods_789; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "subprocess.STARTUPINFO.__init__"; @@ -15540,13 +17705,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: sys ===== */ - static const char* py_methods_665[] = { "debug", "inspect", "interactive", "optimize", "dont_write_bytecode", "no_user_site", "no_site", "ignore_environment", "verbose", "bytes_warning", "quiet", "hash_randomization", "isolated", "dev_mode", "utf8_mode", "warn_default_encoding", "safe_path", "gil", "thread_inherit_context", "context_aware_warnings", "int_max_str_digits", NULL }; + static const char* py_methods_790[] = { "debug", "inspect", "interactive", "optimize", "dont_write_bytecode", "no_user_site", "no_site", "ignore_environment", "verbose", "bytes_warning", "quiet", "hash_randomization", "isolated", "dev_mode", "utf8_mode", "warn_default_encoding", "safe_path", "gil", "thread_inherit_context", "context_aware_warnings", "int_max_str_digits", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._flags"; rt.short_name = "_flags"; - rt.method_names = py_methods_665; - static const char* py_bases_666[] = { "sys._UninstantiableStructseq", NULL }; - rt.embedded_types = py_bases_666; + rt.method_names = py_methods_790; + static const char* py_bases_791[] = { "sys._UninstantiableStructseq", NULL }; + rt.embedded_types = py_bases_791; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._flags.debug"; @@ -15653,11 +17818,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "int_max_str_digits"; rf.receiver_type = "sys._flags"; cbm_registry_add_func(reg, rf); - static const char* py_methods_667[] = { "max", "max_exp", "max_10_exp", "min", "min_exp", "min_10_exp", "dig", "mant_dig", "epsilon", "radix", "rounds", NULL }; + static const char* py_methods_792[] = { "max", "max_exp", "max_10_exp", "min", "min_exp", "min_10_exp", "dig", "mant_dig", "epsilon", "radix", "rounds", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._float_info"; rt.short_name = "_float_info"; - rt.method_names = py_methods_667; + rt.method_names = py_methods_792; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._float_info.max"; @@ -15714,11 +17879,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "rounds"; rf.receiver_type = "sys._float_info"; cbm_registry_add_func(reg, rf); - static const char* py_methods_668[] = { "width", "modulus", "inf", "nan", "imag", "algorithm", "hash_bits", "seed_bits", "cutoff", NULL }; + static const char* py_methods_793[] = { "width", "modulus", "inf", "nan", "imag", "algorithm", "hash_bits", "seed_bits", "cutoff", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._hash_info"; rt.short_name = "_hash_info"; - rt.method_names = py_methods_668; + rt.method_names = py_methods_793; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._hash_info.width"; @@ -15769,11 +17934,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "sys._implementation"; rt.short_name = "_implementation"; cbm_registry_add_type(reg, rt); - static const char* py_methods_669[] = { "bits_per_digit", "sizeof_digit", "default_max_str_digits", "str_digits_check_threshold", NULL }; + static const char* py_methods_794[] = { "bits_per_digit", "sizeof_digit", "default_max_str_digits", "str_digits_check_threshold", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._int_info"; rt.short_name = "_int_info"; - rt.method_names = py_methods_669; + rt.method_names = py_methods_794; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._int_info.bits_per_digit"; @@ -15795,13 +17960,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "str_digits_check_threshold"; rf.receiver_type = "sys._int_info"; cbm_registry_add_func(reg, rf); - static const char* py_methods_670[] = { "name", "lock", "version", NULL }; + static const char* py_methods_795[] = { "name", "lock", "version", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._thread_info"; rt.short_name = "_thread_info"; - rt.method_names = py_methods_670; - static const char* py_bases_671[] = { "sys._UninstantiableStructseq", NULL }; - rt.embedded_types = py_bases_671; + rt.method_names = py_methods_795; + static const char* py_bases_796[] = { "sys._UninstantiableStructseq", NULL }; + rt.embedded_types = py_bases_796; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._thread_info.name"; @@ -15818,13 +17983,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "version"; rf.receiver_type = "sys._thread_info"; cbm_registry_add_func(reg, rf); - static const char* py_methods_672[] = { "major", "minor", "micro", "releaselevel", "serial", NULL }; + static const char* py_methods_797[] = { "major", "minor", "micro", "releaselevel", "serial", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._version_info"; rt.short_name = "_version_info"; - rt.method_names = py_methods_672; - static const char* py_bases_673[] = { "sys._UninstantiableStructseq", NULL }; - rt.embedded_types = py_bases_673; + rt.method_names = py_methods_797; + static const char* py_bases_798[] = { "sys._UninstantiableStructseq", NULL }; + rt.embedded_types = py_bases_798; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._version_info.major"; @@ -15851,13 +18016,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "serial"; rf.receiver_type = "sys._version_info"; cbm_registry_add_func(reg, rf); - static const char* py_methods_674[] = { "major", "minor", "build", "platform", "service_pack", "service_pack_minor", "service_pack_major", "suite_mask", "product_type", "platform_version", NULL }; + static const char* py_methods_799[] = { "major", "minor", "build", "platform", "service_pack", "service_pack_minor", "service_pack_major", "suite_mask", "product_type", "platform_version", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._WinVersion"; rt.short_name = "_WinVersion"; - rt.method_names = py_methods_674; - static const char* py_bases_675[] = { "sys._UninstantiableStructseq", NULL }; - rt.embedded_types = py_bases_675; + rt.method_names = py_methods_799; + static const char* py_bases_800[] = { "sys._UninstantiableStructseq", NULL }; + rt.embedded_types = py_bases_800; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._WinVersion.major"; @@ -15912,14 +18077,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys.UnraisableHookArgs"; rt.short_name = "UnraisableHookArgs"; - static const char* py_bases_676[] = { "sys.Protocol", NULL }; - rt.embedded_types = py_bases_676; + static const char* py_bases_801[] = { "sys.Protocol", NULL }; + rt.embedded_types = py_bases_801; cbm_registry_add_type(reg, rt); - static const char* py_methods_677[] = { "firstiter", "finalizer", NULL }; + static const char* py_methods_802[] = { "firstiter", "finalizer", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._asyncgen_hooks"; rt.short_name = "_asyncgen_hooks"; - rt.method_names = py_methods_677; + rt.method_names = py_methods_802; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._asyncgen_hooks.firstiter"; @@ -16107,11 +18272,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: sys._monitoring ===== */ - static const char* py_methods_678[] = { "BRANCH", NULL }; + static const char* py_methods_803[] = { "BRANCH", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "sys._monitoring._events"; rt.short_name = "_events"; - rt.method_names = py_methods_678; + rt.method_names = py_methods_803; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "sys._monitoring._events.BRANCH"; @@ -16160,11 +18325,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: tempfile ===== */ - static const char* py_methods_679[] = { "__init__", "__enter__", "__exit__", "close", "fileno", "flush", "isatty", "read", "readable", "readline", "readlines", "seek", "seekable", "tell", "truncate", "writable", "write", "writelines", "closed", NULL }; + static const char* py_methods_804[] = { "__init__", "__enter__", "__exit__", "close", "fileno", "flush", "isatty", "read", "readable", "readline", "readlines", "seek", "seekable", "tell", "truncate", "writable", "write", "writelines", "closed", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "tempfile._TemporaryFileWrapper"; rt.short_name = "_TemporaryFileWrapper"; - rt.method_names = py_methods_679; + rt.method_names = py_methods_804; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "tempfile._TemporaryFileWrapper.__init__"; @@ -16261,13 +18426,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "closed"; rf.receiver_type = "tempfile._TemporaryFileWrapper"; cbm_registry_add_func(reg, rf); - static const char* py_methods_680[] = { "encoding", "newlines", "__init__", "errors", "rollover", "__enter__", "__exit__", "close", "fileno", "flush", "isatty", "read1", "readinto", "readinto1", "detach", "read", "readline", "readlines", "seek", "tell", "truncate", "write", "writelines", "readable", "seekable", "writable", NULL }; + static const char* py_methods_805[] = { "encoding", "newlines", "__init__", "errors", "rollover", "__enter__", "__exit__", "close", "fileno", "flush", "isatty", "read1", "readinto", "readinto1", "detach", "read", "readline", "readlines", "seek", "tell", "truncate", "write", "writelines", "readable", "seekable", "writable", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "tempfile.SpooledTemporaryFile"; rt.short_name = "SpooledTemporaryFile"; - rt.method_names = py_methods_680; - static const char* py_bases_681[] = { "tempfile._SpooledTemporaryFileBase", NULL }; - rt.embedded_types = py_bases_681; + rt.method_names = py_methods_805; + static const char* py_bases_806[] = { "tempfile._SpooledTemporaryFileBase", NULL }; + rt.embedded_types = py_bases_806; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "tempfile.SpooledTemporaryFile.encoding"; @@ -16399,11 +18564,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "writable"; rf.receiver_type = "tempfile.SpooledTemporaryFile"; cbm_registry_add_func(reg, rf); - static const char* py_methods_682[] = { "__init__", "cleanup", "__enter__", "__exit__", NULL }; + static const char* py_methods_807[] = { "__init__", "cleanup", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "tempfile.TemporaryDirectory"; rt.short_name = "TemporaryDirectory"; - rt.method_names = py_methods_682; + rt.method_names = py_methods_807; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "tempfile.TemporaryDirectory.__init__"; @@ -16463,11 +18628,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: threading ===== */ - static const char* py_methods_683[] = { "ident", "__init__", "start", "run", "join", "native_id", "is_alive", "isDaemon", "setDaemon", "getName", "setName", NULL }; + static const char* py_methods_808[] = { "ident", "__init__", "start", "run", "join", "native_id", "is_alive", "isDaemon", "setDaemon", "getName", "setName", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.Thread"; rt.short_name = "Thread"; - rt.method_names = py_methods_683; + rt.method_names = py_methods_808; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.Thread.ident"; @@ -16524,24 +18689,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "setName"; rf.receiver_type = "threading.Thread"; cbm_registry_add_func(reg, rf); - static const char* py_methods_684[] = { "__init__", NULL }; + static const char* py_methods_809[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading._DummyThread"; rt.short_name = "_DummyThread"; - rt.method_names = py_methods_684; - static const char* py_bases_685[] = { "threading.Thread", NULL }; - rt.embedded_types = py_bases_685; + rt.method_names = py_methods_809; + static const char* py_bases_810[] = { "threading.Thread", NULL }; + rt.embedded_types = py_bases_810; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading._DummyThread.__init__"; rf.short_name = "__init__"; rf.receiver_type = "threading._DummyThread"; cbm_registry_add_func(reg, rf); - static const char* py_methods_686[] = { "acquire", "release", "__exit__", "locked", NULL }; + static const char* py_methods_811[] = { "acquire", "release", "__exit__", "locked", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading._RLock"; rt.short_name = "_RLock"; - rt.method_names = py_methods_686; + rt.method_names = py_methods_811; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading._RLock.acquire"; @@ -16563,11 +18728,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "locked"; rf.receiver_type = "threading._RLock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_687[] = { "__init__", "__enter__", "__exit__", "acquire", "release", "locked", "wait", "wait_for", "notify", "notify_all", "notifyAll", NULL }; + static const char* py_methods_812[] = { "__init__", "__enter__", "__exit__", "acquire", "release", "locked", "wait", "wait_for", "notify", "notify_all", "notifyAll", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.Condition"; rt.short_name = "Condition"; - rt.method_names = py_methods_687; + rt.method_names = py_methods_812; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.Condition.__init__"; @@ -16624,11 +18789,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "notifyAll"; rf.receiver_type = "threading.Condition"; cbm_registry_add_func(reg, rf); - static const char* py_methods_688[] = { "__init__", "__exit__", "acquire", "__enter__", "release", NULL }; + static const char* py_methods_813[] = { "__init__", "__exit__", "acquire", "__enter__", "release", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.Semaphore"; rt.short_name = "Semaphore"; - rt.method_names = py_methods_688; + rt.method_names = py_methods_813; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.Semaphore.__init__"; @@ -16658,14 +18823,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.BoundedSemaphore"; rt.short_name = "BoundedSemaphore"; - static const char* py_bases_689[] = { "threading.Semaphore", NULL }; - rt.embedded_types = py_bases_689; + static const char* py_bases_814[] = { "threading.Semaphore", NULL }; + rt.embedded_types = py_bases_814; cbm_registry_add_type(reg, rt); - static const char* py_methods_690[] = { "is_set", "isSet", "set", "clear", "wait", NULL }; + static const char* py_methods_815[] = { "is_set", "isSet", "set", "clear", "wait", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.Event"; rt.short_name = "Event"; - rt.method_names = py_methods_690; + rt.method_names = py_methods_815; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.Event.is_set"; @@ -16692,13 +18857,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "wait"; rf.receiver_type = "threading.Event"; cbm_registry_add_func(reg, rf); - static const char* py_methods_691[] = { "__init__", "cancel", NULL }; + static const char* py_methods_816[] = { "__init__", "cancel", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.Timer"; rt.short_name = "Timer"; - rt.method_names = py_methods_691; - static const char* py_bases_692[] = { "threading.Thread", NULL }; - rt.embedded_types = py_bases_692; + rt.method_names = py_methods_816; + static const char* py_bases_817[] = { "threading.Thread", NULL }; + rt.embedded_types = py_bases_817; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.Timer.__init__"; @@ -16710,11 +18875,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "cancel"; rf.receiver_type = "threading.Timer"; cbm_registry_add_func(reg, rf); - static const char* py_methods_693[] = { "parties", "n_waiting", "broken", "__init__", "wait", "reset", "abort", NULL }; + static const char* py_methods_818[] = { "parties", "n_waiting", "broken", "__init__", "wait", "reset", "abort", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.Barrier"; rt.short_name = "Barrier"; - rt.method_names = py_methods_693; + rt.method_names = py_methods_818; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.Barrier.parties"; @@ -16754,8 +18919,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "threading.BrokenBarrierError"; rt.short_name = "BrokenBarrierError"; - static const char* py_bases_694[] = { "threading.RuntimeError", NULL }; - rt.embedded_types = py_bases_694; + static const char* py_bases_819[] = { "threading.RuntimeError", NULL }; + rt.embedded_types = py_bases_819; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "threading.active_count"; @@ -16815,13 +18980,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: time ===== */ - static const char* py_methods_695[] = { "tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst", "tm_zone", "tm_gmtoff", NULL }; + static const char* py_methods_820[] = { "tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst", "tm_zone", "tm_gmtoff", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "time.struct_time"; rt.short_name = "struct_time"; - rt.method_names = py_methods_695; - static const char* py_bases_696[] = { "time._TimeTuple", NULL }; - rt.embedded_types = py_bases_696; + rt.method_names = py_methods_820; + static const char* py_bases_821[] = { "time._TimeTuple", NULL }; + rt.embedded_types = py_bases_821; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "time.struct_time.tm_year"; @@ -16881,8 +19046,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "time._ClockInfo"; rt.short_name = "_ClockInfo"; - static const char* py_bases_697[] = { "time.Protocol", NULL }; - rt.embedded_types = py_bases_697; + static const char* py_bases_822[] = { "time.Protocol", NULL }; + rt.embedded_types = py_bases_822; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "time.asctime"; @@ -16998,11 +19163,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing._Final"; rt.short_name = "_Final"; cbm_registry_add_type(reg, rt); - static const char* py_methods_698[] = { "__infer_variance__", "__default__", "__new__", "__typing_subst__", "__typing_prepare_subst__", "has_default", "evaluate_bound", "evaluate_constraints", "evaluate_default", NULL }; + static const char* py_methods_823[] = { "__infer_variance__", "__default__", "__new__", "__typing_subst__", "__typing_prepare_subst__", "has_default", "evaluate_bound", "evaluate_constraints", "evaluate_default", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.TypeVar"; rt.short_name = "TypeVar"; - rt.method_names = py_methods_698; + rt.method_names = py_methods_823; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.TypeVar.__infer_variance__"; @@ -17052,14 +19217,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing._SpecialForm"; rt.short_name = "_SpecialForm"; - static const char* py_bases_699[] = { "typing._Final", NULL }; - rt.embedded_types = py_bases_699; + static const char* py_bases_824[] = { "typing._Final", NULL }; + rt.embedded_types = py_bases_824; cbm_registry_add_type(reg, rt); - static const char* py_methods_700[] = { "__bound__", "__covariant__", "__contravariant__", "__infer_variance__", "__default__", "has_default", "__new__", "evaluate_default", NULL }; + static const char* py_methods_825[] = { "__bound__", "__covariant__", "__contravariant__", "__infer_variance__", "__default__", "has_default", "__new__", "evaluate_default", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.TypeVarTuple"; rt.short_name = "TypeVarTuple"; - rt.method_names = py_methods_700; + rt.method_names = py_methods_825; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.TypeVarTuple.__bound__"; @@ -17101,11 +19266,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "evaluate_default"; rf.receiver_type = "typing.TypeVarTuple"; cbm_registry_add_func(reg, rf); - static const char* py_methods_701[] = { "__new__", "__init__", NULL }; + static const char* py_methods_826[] = { "__new__", "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.ParamSpecArgs"; rt.short_name = "ParamSpecArgs"; - rt.method_names = py_methods_701; + rt.method_names = py_methods_826; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.ParamSpecArgs.__new__"; @@ -17117,11 +19282,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__init__"; rf.receiver_type = "typing.ParamSpecArgs"; cbm_registry_add_func(reg, rf); - static const char* py_methods_702[] = { "__new__", "__init__", NULL }; + static const char* py_methods_827[] = { "__new__", "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.ParamSpecKwargs"; rt.short_name = "ParamSpecKwargs"; - rt.method_names = py_methods_702; + rt.method_names = py_methods_827; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.ParamSpecKwargs.__new__"; @@ -17133,11 +19298,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__init__"; rf.receiver_type = "typing.ParamSpecKwargs"; cbm_registry_add_func(reg, rf); - static const char* py_methods_703[] = { "__infer_variance__", "__default__", "__new__", "args", "kwargs", "__typing_subst__", "__typing_prepare_subst__", "has_default", "evaluate_default", NULL }; + static const char* py_methods_828[] = { "__infer_variance__", "__default__", "__new__", "args", "kwargs", "__typing_subst__", "__typing_prepare_subst__", "has_default", "evaluate_default", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.ParamSpec"; rt.short_name = "ParamSpec"; - rt.method_names = py_methods_703; + rt.method_names = py_methods_828; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.ParamSpec.__infer_variance__"; @@ -17184,11 +19349,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "evaluate_default"; rf.receiver_type = "typing.ParamSpec"; cbm_registry_add_func(reg, rf); - static const char* py_methods_704[] = { "__init__", "__call__", NULL }; + static const char* py_methods_829[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.NewType"; rt.short_name = "NewType"; - rt.method_names = py_methods_704; + rt.method_names = py_methods_829; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.NewType.__init__"; @@ -17212,13 +19377,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing._Generic"; rt.short_name = "_Generic"; cbm_registry_add_type(reg, rt); - static const char* py_methods_705[] = { "__init__", NULL }; + static const char* py_methods_830[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing._ProtocolMeta"; rt.short_name = "_ProtocolMeta"; - rt.method_names = py_methods_705; - static const char* py_bases_706[] = { "typing.ABCMeta", NULL }; - rt.embedded_types = py_bases_706; + rt.method_names = py_methods_830; + static const char* py_bases_831[] = { "typing.ABCMeta", NULL }; + rt.embedded_types = py_bases_831; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing._ProtocolMeta.__init__"; @@ -17228,32 +19393,32 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.SupportsInt"; rt.short_name = "SupportsInt"; - static const char* py_bases_707[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_707; + static const char* py_bases_832[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_832; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.SupportsFloat"; rt.short_name = "SupportsFloat"; - static const char* py_bases_708[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_708; + static const char* py_bases_833[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_833; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.SupportsComplex"; rt.short_name = "SupportsComplex"; - static const char* py_bases_709[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_709; + static const char* py_bases_834[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_834; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.SupportsBytes"; rt.short_name = "SupportsBytes"; - static const char* py_bases_710[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_710; + static const char* py_bases_835[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_835; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.SupportsIndex"; rt.short_name = "SupportsIndex"; - static const char* py_bases_711[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_711; + static const char* py_bases_836[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_836; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.SupportsAbs"; @@ -17266,14 +19431,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Sized"; rt.short_name = "Sized"; - static const char* py_bases_712[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_712; + static const char* py_bases_837[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_837; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Hashable"; rt.short_name = "Hashable"; - static const char* py_bases_713[] = { "typing.Protocol", NULL }; - rt.embedded_types = py_bases_713; + static const char* py_bases_838[] = { "typing.Protocol", NULL }; + rt.embedded_types = py_bases_838; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Iterable"; @@ -17287,11 +19452,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing.Reversible"; rt.short_name = "Reversible"; cbm_registry_add_type(reg, rt); - static const char* py_methods_714[] = { "send", "throw", "close", NULL }; + static const char* py_methods_839[] = { "send", "throw", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Generator"; rt.short_name = "Generator"; - rt.method_names = py_methods_714; + rt.method_names = py_methods_839; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.Generator.send"; @@ -17320,11 +19485,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing.Awaitable"; rt.short_name = "Awaitable"; cbm_registry_add_type(reg, rt); - static const char* py_methods_715[] = { "send", "throw", "close", NULL }; + static const char* py_methods_840[] = { "send", "throw", "close", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Coroutine"; rt.short_name = "Coroutine"; - rt.method_names = py_methods_715; + rt.method_names = py_methods_840; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.Coroutine.send"; @@ -17353,11 +19518,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing.AsyncIterator"; rt.short_name = "AsyncIterator"; cbm_registry_add_type(reg, rt); - static const char* py_methods_716[] = { "asend", "athrow", "aclose", NULL }; + static const char* py_methods_841[] = { "asend", "athrow", "aclose", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.AsyncGenerator"; rt.short_name = "AsyncGenerator"; - rt.method_names = py_methods_716; + rt.method_names = py_methods_841; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.AsyncGenerator.asend"; @@ -17382,11 +19547,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing.Collection"; rt.short_name = "Collection"; cbm_registry_add_type(reg, rt); - static const char* py_methods_717[] = { "index", "count", NULL }; + static const char* py_methods_842[] = { "index", "count", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Sequence"; rt.short_name = "Sequence"; - rt.method_names = py_methods_717; + rt.method_names = py_methods_842; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.Sequence.index"; @@ -17398,11 +19563,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "count"; rf.receiver_type = "typing.Sequence"; cbm_registry_add_func(reg, rf); - static const char* py_methods_718[] = { "insert", "append", "clear", "extend", "reverse", "pop", "remove", NULL }; + static const char* py_methods_843[] = { "insert", "append", "clear", "extend", "reverse", "pop", "remove", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.MutableSequence"; rt.short_name = "MutableSequence"; - rt.method_names = py_methods_718; + rt.method_names = py_methods_843; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.MutableSequence.insert"; @@ -17439,22 +19604,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "remove"; rf.receiver_type = "typing.MutableSequence"; cbm_registry_add_func(reg, rf); - static const char* py_methods_719[] = { "isdisjoint", NULL }; + static const char* py_methods_844[] = { "isdisjoint", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.AbstractSet"; rt.short_name = "AbstractSet"; - rt.method_names = py_methods_719; + rt.method_names = py_methods_844; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.AbstractSet.isdisjoint"; rf.short_name = "isdisjoint"; rf.receiver_type = "typing.AbstractSet"; cbm_registry_add_func(reg, rf); - static const char* py_methods_720[] = { "add", "discard", "clear", "pop", "remove", NULL }; + static const char* py_methods_845[] = { "add", "discard", "clear", "pop", "remove", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.MutableSet"; rt.short_name = "MutableSet"; - rt.method_names = py_methods_720; + rt.method_names = py_methods_845; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.MutableSet.add"; @@ -17481,63 +19646,63 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "remove"; rf.receiver_type = "typing.MutableSet"; cbm_registry_add_func(reg, rf); - static const char* py_methods_721[] = { "__init__", NULL }; + static const char* py_methods_846[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.MappingView"; rt.short_name = "MappingView"; - rt.method_names = py_methods_721; - static const char* py_bases_722[] = { "typing.Sized", NULL }; - rt.embedded_types = py_bases_722; + rt.method_names = py_methods_846; + static const char* py_bases_847[] = { "typing.Sized", NULL }; + rt.embedded_types = py_bases_847; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.MappingView.__init__"; rf.short_name = "__init__"; rf.receiver_type = "typing.MappingView"; cbm_registry_add_func(reg, rf); - static const char* py_methods_723[] = { "__init__", NULL }; + static const char* py_methods_848[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.ItemsView"; rt.short_name = "ItemsView"; - rt.method_names = py_methods_723; - static const char* py_bases_724[] = { "typing.MappingView", NULL }; - rt.embedded_types = py_bases_724; + rt.method_names = py_methods_848; + static const char* py_bases_849[] = { "typing.MappingView", NULL }; + rt.embedded_types = py_bases_849; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.ItemsView.__init__"; rf.short_name = "__init__"; rf.receiver_type = "typing.ItemsView"; cbm_registry_add_func(reg, rf); - static const char* py_methods_725[] = { "__init__", NULL }; + static const char* py_methods_850[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.KeysView"; rt.short_name = "KeysView"; - rt.method_names = py_methods_725; - static const char* py_bases_726[] = { "typing.MappingView", NULL }; - rt.embedded_types = py_bases_726; + rt.method_names = py_methods_850; + static const char* py_bases_851[] = { "typing.MappingView", NULL }; + rt.embedded_types = py_bases_851; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.KeysView.__init__"; rf.short_name = "__init__"; rf.receiver_type = "typing.KeysView"; cbm_registry_add_func(reg, rf); - static const char* py_methods_727[] = { "__init__", NULL }; + static const char* py_methods_852[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.ValuesView"; rt.short_name = "ValuesView"; - rt.method_names = py_methods_727; - static const char* py_bases_728[] = { "typing.MappingView", NULL }; - rt.embedded_types = py_bases_728; + rt.method_names = py_methods_852; + static const char* py_bases_853[] = { "typing.MappingView", NULL }; + rt.embedded_types = py_bases_853; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.ValuesView.__init__"; rf.short_name = "__init__"; rf.receiver_type = "typing.ValuesView"; cbm_registry_add_func(reg, rf); - static const char* py_methods_729[] = { "get", "items", "keys", "values", NULL }; + static const char* py_methods_854[] = { "get", "items", "keys", "values", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.Mapping"; rt.short_name = "Mapping"; - rt.method_names = py_methods_729; + rt.method_names = py_methods_854; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.Mapping.get"; @@ -17559,11 +19724,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "values"; rf.receiver_type = "typing.Mapping"; cbm_registry_add_func(reg, rf); - static const char* py_methods_730[] = { "clear", "pop", "popitem", "setdefault", "update", NULL }; + static const char* py_methods_855[] = { "clear", "pop", "popitem", "setdefault", "update", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.MutableMapping"; rt.short_name = "MutableMapping"; - rt.method_names = py_methods_730; + rt.method_names = py_methods_855; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.MutableMapping.clear"; @@ -17590,11 +19755,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "update"; rf.receiver_type = "typing.MutableMapping"; cbm_registry_add_func(reg, rf); - static const char* py_methods_731[] = { "mode", "name", "close", "closed", "fileno", "flush", "isatty", "read", "readable", "readline", "readlines", "seek", "seekable", "tell", "truncate", "writable", "write", "writelines", "__enter__", "__exit__", NULL }; + static const char* py_methods_856[] = { "mode", "name", "close", "closed", "fileno", "flush", "isatty", "read", "readable", "readline", "readlines", "seek", "seekable", "tell", "truncate", "writable", "write", "writelines", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.IO"; rt.short_name = "IO"; - rt.method_names = py_methods_731; + rt.method_names = py_methods_856; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.IO.mode"; @@ -17696,22 +19861,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "typing.IO"; cbm_registry_add_func(reg, rf); - static const char* py_methods_732[] = { "__enter__", NULL }; + static const char* py_methods_857[] = { "__enter__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.BinaryIO"; rt.short_name = "BinaryIO"; - rt.method_names = py_methods_732; + rt.method_names = py_methods_857; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.BinaryIO.__enter__"; rf.short_name = "__enter__"; rf.receiver_type = "typing.BinaryIO"; cbm_registry_add_func(reg, rf); - static const char* py_methods_733[] = { "buffer", "encoding", "errors", "line_buffering", "newlines", "__enter__", NULL }; + static const char* py_methods_858[] = { "buffer", "encoding", "errors", "line_buffering", "newlines", "__enter__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.TextIO"; rt.short_name = "TextIO"; - rt.method_names = py_methods_733; + rt.method_names = py_methods_858; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.TextIO.buffer"; @@ -17743,11 +19908,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__enter__"; rf.receiver_type = "typing.TextIO"; cbm_registry_add_func(reg, rf); - static const char* py_methods_734[] = { "__init__", "__replace__", NULL }; + static const char* py_methods_859[] = { "__init__", "__replace__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.NamedTuple"; rt.short_name = "NamedTuple"; - rt.method_names = py_methods_734; + rt.method_names = py_methods_859; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.NamedTuple.__init__"; @@ -17759,11 +19924,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__replace__"; rf.receiver_type = "typing.NamedTuple"; cbm_registry_add_func(reg, rf); - static const char* py_methods_735[] = { "copy", "setdefault", "pop", "update", "items", "keys", "values", NULL }; + static const char* py_methods_860[] = { "copy", "setdefault", "pop", "update", "items", "keys", "values", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing._TypedDict"; rt.short_name = "_TypedDict"; - rt.method_names = py_methods_735; + rt.method_names = py_methods_860; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing._TypedDict.copy"; @@ -17800,13 +19965,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "values"; rf.receiver_type = "typing._TypedDict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_736[] = { "__init__", "_evaluate", "__or__", "__ror__", NULL }; + static const char* py_methods_861[] = { "__init__", "_evaluate", "__or__", "__ror__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.ForwardRef"; rt.short_name = "ForwardRef"; - rt.method_names = py_methods_736; - static const char* py_bases_737[] = { "typing._Final", NULL }; - rt.embedded_types = py_bases_737; + rt.method_names = py_methods_861; + static const char* py_bases_862[] = { "typing._Final", NULL }; + rt.embedded_types = py_bases_862; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.ForwardRef.__init__"; @@ -17828,11 +19993,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__ror__"; rf.receiver_type = "typing.ForwardRef"; cbm_registry_add_func(reg, rf); - static const char* py_methods_738[] = { "__qualname__", "__iter__", "evaluate_value", NULL }; + static const char* py_methods_863[] = { "__qualname__", "__iter__", "evaluate_value", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing.TypeAliasType"; rt.short_name = "TypeAliasType"; - rt.method_names = py_methods_738; + rt.method_names = py_methods_863; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing.TypeAliasType.__qualname__"; @@ -17943,11 +20108,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: typing_extensions ===== */ - static const char* py_methods_739[] = { "copy", "setdefault", "pop", "update", "items", "keys", "values", NULL }; + static const char* py_methods_864[] = { "copy", "setdefault", "pop", "update", "items", "keys", "values", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions._TypedDict"; rt.short_name = "_TypedDict"; - rt.method_names = py_methods_739; + rt.method_names = py_methods_864; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions._TypedDict.copy"; @@ -17984,22 +20149,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "values"; rf.receiver_type = "typing_extensions._TypedDict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_740[] = { "__init__", NULL }; + static const char* py_methods_865[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.NamedTuple"; rt.short_name = "NamedTuple"; - rt.method_names = py_methods_740; + rt.method_names = py_methods_865; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.NamedTuple.__init__"; rf.short_name = "__init__"; rf.receiver_type = "typing_extensions.NamedTuple"; cbm_registry_add_func(reg, rf); - static const char* py_methods_741[] = { "__init__", "__call__", NULL }; + static const char* py_methods_866[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.NewType"; rt.short_name = "NewType"; - rt.method_names = py_methods_741; + rt.method_names = py_methods_866; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.NewType.__init__"; @@ -18014,38 +20179,38 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.Buffer"; rt.short_name = "Buffer"; - static const char* py_bases_742[] = { "typing_extensions.Protocol", "abc.ABC", NULL }; - rt.embedded_types = py_bases_742; + static const char* py_bases_867[] = { "typing_extensions.Protocol", "abc.ABC", NULL }; + rt.embedded_types = py_bases_867; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.SupportsInt"; rt.short_name = "SupportsInt"; - static const char* py_bases_743[] = { "typing_extensions.Protocol", NULL }; - rt.embedded_types = py_bases_743; + static const char* py_bases_868[] = { "typing_extensions.Protocol", NULL }; + rt.embedded_types = py_bases_868; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.SupportsFloat"; rt.short_name = "SupportsFloat"; - static const char* py_bases_744[] = { "typing_extensions.Protocol", NULL }; - rt.embedded_types = py_bases_744; + static const char* py_bases_869[] = { "typing_extensions.Protocol", NULL }; + rt.embedded_types = py_bases_869; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.SupportsComplex"; rt.short_name = "SupportsComplex"; - static const char* py_bases_745[] = { "typing_extensions.Protocol", NULL }; - rt.embedded_types = py_bases_745; + static const char* py_bases_870[] = { "typing_extensions.Protocol", NULL }; + rt.embedded_types = py_bases_870; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.SupportsBytes"; rt.short_name = "SupportsBytes"; - static const char* py_bases_746[] = { "typing_extensions.Protocol", NULL }; - rt.embedded_types = py_bases_746; + static const char* py_bases_871[] = { "typing_extensions.Protocol", NULL }; + rt.embedded_types = py_bases_871; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.SupportsIndex"; rt.short_name = "SupportsIndex"; - static const char* py_bases_747[] = { "typing_extensions.Protocol", NULL }; - rt.embedded_types = py_bases_747; + static const char* py_bases_872[] = { "typing_extensions.Protocol", NULL }; + rt.embedded_types = py_bases_872; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.SupportsAbs"; @@ -18055,22 +20220,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing_extensions.SupportsRound"; rt.short_name = "SupportsRound"; cbm_registry_add_type(reg, rt); - static const char* py_methods_748[] = { "read", NULL }; + static const char* py_methods_873[] = { "read", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.Reader"; rt.short_name = "Reader"; - rt.method_names = py_methods_748; + rt.method_names = py_methods_873; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.Reader.read"; rf.short_name = "read"; rf.receiver_type = "typing_extensions.Reader"; cbm_registry_add_func(reg, rf); - static const char* py_methods_749[] = { "write", NULL }; + static const char* py_methods_874[] = { "write", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.Writer"; rt.short_name = "Writer"; - rt.method_names = py_methods_749; + rt.method_names = py_methods_874; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.Writer.write"; @@ -18085,11 +20250,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "typing_extensions.CapsuleType"; rt.short_name = "CapsuleType"; cbm_registry_add_type(reg, rt); - static const char* py_methods_750[] = { "__init__", "__call__", NULL }; + static const char* py_methods_875[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.deprecated"; rt.short_name = "deprecated"; - rt.method_names = py_methods_750; + rt.method_names = py_methods_875; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.deprecated.__init__"; @@ -18101,11 +20266,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__call__"; rf.receiver_type = "typing_extensions.deprecated"; cbm_registry_add_func(reg, rf); - static const char* py_methods_751[] = { "__init__", "has_default", "__typing_subst__", NULL }; + static const char* py_methods_876[] = { "__init__", "has_default", "__typing_subst__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.TypeVar"; rt.short_name = "TypeVar"; - rt.method_names = py_methods_751; + rt.method_names = py_methods_876; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.TypeVar.__init__"; @@ -18122,11 +20287,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__typing_subst__"; rf.receiver_type = "typing_extensions.TypeVar"; cbm_registry_add_func(reg, rf); - static const char* py_methods_752[] = { "__init__", "args", "kwargs", "has_default", NULL }; + static const char* py_methods_877[] = { "__init__", "args", "kwargs", "has_default", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.ParamSpec"; rt.short_name = "ParamSpec"; - rt.method_names = py_methods_752; + rt.method_names = py_methods_877; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.ParamSpec.__init__"; @@ -18148,11 +20313,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "has_default"; rf.receiver_type = "typing_extensions.ParamSpec"; cbm_registry_add_func(reg, rf); - static const char* py_methods_753[] = { "__init__", "has_default", NULL }; + static const char* py_methods_878[] = { "__init__", "has_default", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.TypeVarTuple"; rt.short_name = "TypeVarTuple"; - rt.method_names = py_methods_753; + rt.method_names = py_methods_878; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.TypeVarTuple.__init__"; @@ -18164,22 +20329,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "has_default"; rf.receiver_type = "typing_extensions.TypeVarTuple"; cbm_registry_add_func(reg, rf); - static const char* py_methods_754[] = { "__init__", NULL }; + static const char* py_methods_879[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.TypeAliasType"; rt.short_name = "TypeAliasType"; - rt.method_names = py_methods_754; + rt.method_names = py_methods_879; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.TypeAliasType.__init__"; rf.short_name = "__init__"; rf.receiver_type = "typing_extensions.TypeAliasType"; cbm_registry_add_func(reg, rf); - static const char* py_methods_755[] = { "__init__", NULL }; + static const char* py_methods_880[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.Doc"; rt.short_name = "Doc"; - rt.method_names = py_methods_755; + rt.method_names = py_methods_880; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.Doc.__init__"; @@ -18193,14 +20358,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.Format"; rt.short_name = "Format"; - static const char* py_bases_756[] = { "enum.IntEnum", NULL }; - rt.embedded_types = py_bases_756; + static const char* py_bases_881[] = { "enum.IntEnum", NULL }; + rt.embedded_types = py_bases_881; cbm_registry_add_type(reg, rt); - static const char* py_methods_757[] = { "__init__", "__or__", "__ror__", NULL }; + static const char* py_methods_882[] = { "__init__", "__or__", "__ror__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "typing_extensions.Sentinel"; rt.short_name = "Sentinel"; - rt.method_names = py_methods_757; + rt.method_names = py_methods_882; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "typing_extensions.Sentinel.__init__"; @@ -18303,6 +20468,34 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest ===== */ + static const char* py_methods_883[] = { "asyncSetUp", "asyncTearDown", "addAsyncCleanup", "enterAsyncContext", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "unittest.IsolatedAsyncioTestCase"; + rt.short_name = "IsolatedAsyncioTestCase"; + rt.method_names = py_methods_883; + static const char* py_bases_884[] = { "unittest.async_case.TestCase", NULL }; + rt.embedded_types = py_bases_884; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "unittest.IsolatedAsyncioTestCase.asyncSetUp"; + rf.short_name = "asyncSetUp"; + rf.receiver_type = "unittest.IsolatedAsyncioTestCase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "unittest.IsolatedAsyncioTestCase.asyncTearDown"; + rf.short_name = "asyncTearDown"; + rf.receiver_type = "unittest.IsolatedAsyncioTestCase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "unittest.IsolatedAsyncioTestCase.addAsyncCleanup"; + rf.short_name = "addAsyncCleanup"; + rf.receiver_type = "unittest.IsolatedAsyncioTestCase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "unittest.IsolatedAsyncioTestCase.enterAsyncContext"; + rf.short_name = "enterAsyncContext"; + rf.receiver_type = "unittest.IsolatedAsyncioTestCase"; + cbm_registry_add_func(reg, rf); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.load_tests"; rf.short_name = "load_tests"; @@ -18312,16 +20505,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest._log._LoggingWatcher"; rt.short_name = "_LoggingWatcher"; - static const char* py_bases_758[] = { "unittest._log.NamedTuple", NULL }; - rt.embedded_types = py_bases_758; + static const char* py_bases_885[] = { "unittest._log.NamedTuple", NULL }; + rt.embedded_types = py_bases_885; cbm_registry_add_type(reg, rt); - static const char* py_methods_759[] = { "__init__", "__enter__", "__exit__", NULL }; + static const char* py_methods_886[] = { "__init__", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest._log._AssertLogsContext"; rt.short_name = "_AssertLogsContext"; - rt.method_names = py_methods_759; - static const char* py_bases_760[] = { "unittest._log._BaseTestCaseContext", NULL }; - rt.embedded_types = py_bases_760; + rt.method_names = py_methods_886; + static const char* py_bases_887[] = { "unittest._log._BaseTestCaseContext", NULL }; + rt.embedded_types = py_bases_887; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest._log._AssertLogsContext.__init__"; @@ -18340,13 +20533,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.async_case ===== */ - static const char* py_methods_761[] = { "asyncSetUp", "asyncTearDown", "addAsyncCleanup", "enterAsyncContext", NULL }; + static const char* py_methods_888[] = { "asyncSetUp", "asyncTearDown", "addAsyncCleanup", "enterAsyncContext", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase"; rt.short_name = "IsolatedAsyncioTestCase"; - rt.method_names = py_methods_761; - static const char* py_bases_762[] = { "unittest.async_case.TestCase", NULL }; - rt.embedded_types = py_bases_762; + rt.method_names = py_methods_888; + static const char* py_bases_889[] = { "unittest.async_case.TestCase", NULL }; + rt.embedded_types = py_bases_889; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase.asyncSetUp"; @@ -18370,24 +20563,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.case ===== */ - static const char* py_methods_763[] = { "__init__", NULL }; + static const char* py_methods_890[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case._BaseTestCaseContext"; rt.short_name = "_BaseTestCaseContext"; - rt.method_names = py_methods_763; + rt.method_names = py_methods_890; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case._BaseTestCaseContext.__init__"; rf.short_name = "__init__"; rf.receiver_type = "unittest.case._BaseTestCaseContext"; cbm_registry_add_func(reg, rf); - static const char* py_methods_764[] = { "__init__", "handle", NULL }; + static const char* py_methods_891[] = { "__init__", "handle", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case._AssertRaisesBaseContext"; rt.short_name = "_AssertRaisesBaseContext"; - rt.method_names = py_methods_764; - static const char* py_bases_765[] = { "unittest.case._BaseTestCaseContext", NULL }; - rt.embedded_types = py_bases_765; + rt.method_names = py_methods_891; + static const char* py_bases_892[] = { "unittest.case._BaseTestCaseContext", NULL }; + rt.embedded_types = py_bases_892; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case._AssertRaisesBaseContext.__init__"; @@ -18399,13 +20592,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "handle"; rf.receiver_type = "unittest.case._AssertRaisesBaseContext"; cbm_registry_add_func(reg, rf); - static const char* py_methods_766[] = { "__init__", NULL }; + static const char* py_methods_893[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case.SkipTest"; rt.short_name = "SkipTest"; - rt.method_names = py_methods_766; - static const char* py_bases_767[] = { "unittest.case.Exception", NULL }; - rt.embedded_types = py_bases_767; + rt.method_names = py_methods_893; + static const char* py_bases_894[] = { "unittest.case.Exception", NULL }; + rt.embedded_types = py_bases_894; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case.SkipTest.__init__"; @@ -18415,14 +20608,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case._SupportsAbsAndDunderGE"; rt.short_name = "_SupportsAbsAndDunderGE"; - static const char* py_bases_768[] = { "unittest.case.Protocol", NULL }; - rt.embedded_types = py_bases_768; + static const char* py_bases_895[] = { "unittest.case.Protocol", NULL }; + rt.embedded_types = py_bases_895; cbm_registry_add_type(reg, rt); - static const char* py_methods_769[] = { "__init__", "setUp", "tearDown", "setUpClass", "tearDownClass", "run", "__call__", "skipTest", "subTest", "debug", "_addSkip", "assertEqual", "assertNotEqual", "assertTrue", "assertFalse", "assertIs", "assertIsNot", "assertIsNone", "assertIsNotNone", "assertIn", "assertNotIn", "assertIsInstance", "assertNotIsInstance", "assertGreater", "assertGreaterEqual", "assertLess", "assertLessEqual", "assertRaises", "assertRaisesRegex", "assertWarns", "assertWarnsRegex", "assertLogs", "assertNoLogs", "assertAlmostEqual", "assertNotAlmostEqual", "assertRegex", "assertNotRegex", "assertCountEqual", "addTypeEqualityFunc", "assertMultiLineEqual", "assertSequenceEqual", "assertListEqual", "assertTupleEqual", "assertSetEqual", "assertDictEqual", "fail", "countTestCases", "defaultTestResult", "id", "shortDescription", "addCleanup", "enterContext", "doCleanups", "addClassCleanup", "doClassCleanups", "enterClassContext", "assertDictContainsSubset", "assertIsSubclass", "assertNotIsSubclass", "assertHasAttr", "assertNotHasAttr", "assertStartsWith", "assertNotStartsWith", "assertEndsWith", "assertNotEndsWith", NULL }; + static const char* py_methods_896[] = { "__init__", "setUp", "tearDown", "setUpClass", "tearDownClass", "run", "__call__", "skipTest", "subTest", "debug", "_addSkip", "assertEqual", "assertNotEqual", "assertTrue", "assertFalse", "assertIs", "assertIsNot", "assertIsNone", "assertIsNotNone", "assertIn", "assertNotIn", "assertIsInstance", "assertNotIsInstance", "assertGreater", "assertGreaterEqual", "assertLess", "assertLessEqual", "assertRaises", "assertRaisesRegex", "assertWarns", "assertWarnsRegex", "assertLogs", "assertNoLogs", "assertAlmostEqual", "assertNotAlmostEqual", "assertRegex", "assertNotRegex", "assertCountEqual", "addTypeEqualityFunc", "assertMultiLineEqual", "assertSequenceEqual", "assertListEqual", "assertTupleEqual", "assertSetEqual", "assertDictEqual", "fail", "countTestCases", "defaultTestResult", "id", "shortDescription", "addCleanup", "enterContext", "doCleanups", "addClassCleanup", "doClassCleanups", "enterClassContext", "assertDictContainsSubset", "assertIsSubclass", "assertNotIsSubclass", "assertHasAttr", "assertNotHasAttr", "assertStartsWith", "assertNotStartsWith", "assertEndsWith", "assertNotEndsWith", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case.TestCase"; rt.short_name = "TestCase"; - rt.method_names = py_methods_769; + rt.method_names = py_methods_896; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case.TestCase.__init__"; @@ -18749,13 +20942,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "assertNotEndsWith"; rf.receiver_type = "unittest.case.TestCase"; cbm_registry_add_func(reg, rf); - static const char* py_methods_770[] = { "__init__", "runTest", NULL }; + static const char* py_methods_897[] = { "__init__", "runTest", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case.FunctionTestCase"; rt.short_name = "FunctionTestCase"; - rt.method_names = py_methods_770; - static const char* py_bases_771[] = { "unittest.case.TestCase", NULL }; - rt.embedded_types = py_bases_771; + rt.method_names = py_methods_897; + static const char* py_bases_898[] = { "unittest.case.TestCase", NULL }; + rt.embedded_types = py_bases_898; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case.FunctionTestCase.__init__"; @@ -18767,13 +20960,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "runTest"; rf.receiver_type = "unittest.case.FunctionTestCase"; cbm_registry_add_func(reg, rf); - static const char* py_methods_772[] = { "__enter__", "__exit__", NULL }; + static const char* py_methods_899[] = { "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case._AssertRaisesContext"; rt.short_name = "_AssertRaisesContext"; - rt.method_names = py_methods_772; - static const char* py_bases_773[] = { "unittest.case._AssertRaisesBaseContext", NULL }; - rt.embedded_types = py_bases_773; + rt.method_names = py_methods_899; + static const char* py_bases_900[] = { "unittest.case._AssertRaisesBaseContext", NULL }; + rt.embedded_types = py_bases_900; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case._AssertRaisesContext.__enter__"; @@ -18785,13 +20978,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "unittest.case._AssertRaisesContext"; cbm_registry_add_func(reg, rf); - static const char* py_methods_774[] = { "__enter__", "__exit__", NULL }; + static const char* py_methods_901[] = { "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.case._AssertWarnsContext"; rt.short_name = "_AssertWarnsContext"; - rt.method_names = py_methods_774; - static const char* py_bases_775[] = { "unittest.case._AssertRaisesBaseContext", NULL }; - rt.embedded_types = py_bases_775; + rt.method_names = py_methods_901; + static const char* py_bases_902[] = { "unittest.case._AssertRaisesBaseContext", NULL }; + rt.embedded_types = py_bases_902; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.case._AssertWarnsContext.__enter__"; @@ -18833,11 +21026,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.loader ===== */ - static const char* py_methods_776[] = { "loadTestsFromTestCase", "loadTestsFromModule", "loadTestsFromName", "loadTestsFromNames", "getTestCaseNames", "discover", NULL }; + static const char* py_methods_903[] = { "loadTestsFromTestCase", "loadTestsFromModule", "loadTestsFromName", "loadTestsFromNames", "getTestCaseNames", "discover", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.loader.TestLoader"; rt.short_name = "TestLoader"; - rt.method_names = py_methods_776; + rt.method_names = py_methods_903; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.loader.TestLoader.loadTestsFromTestCase"; @@ -18883,24 +21076,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.main ===== */ - static const char* py_methods_777[] = { "run", NULL }; + static const char* py_methods_904[] = { "run", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.main._TestRunner"; rt.short_name = "_TestRunner"; - rt.method_names = py_methods_777; - static const char* py_bases_778[] = { "unittest.main.Protocol", NULL }; - rt.embedded_types = py_bases_778; + rt.method_names = py_methods_904; + static const char* py_bases_905[] = { "unittest.main.Protocol", NULL }; + rt.embedded_types = py_bases_905; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.main._TestRunner.run"; rf.short_name = "run"; rf.receiver_type = "unittest.main._TestRunner"; cbm_registry_add_func(reg, rf); - static const char* py_methods_779[] = { "__init__", "parseArgs", "createTests", "runTests", NULL }; + static const char* py_methods_906[] = { "__init__", "parseArgs", "createTests", "runTests", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.main.TestProgram"; rt.short_name = "TestProgram"; - rt.method_names = py_methods_779; + rt.method_names = py_methods_906; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.main.TestProgram.__init__"; @@ -18924,11 +21117,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.mock ===== */ - static const char* py_methods_780[] = { "__init__", NULL }; + static const char* py_methods_907[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._SentinelObject"; rt.short_name = "_SentinelObject"; - rt.method_names = py_methods_780; + rt.method_names = py_methods_907; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._SentinelObject.__init__"; @@ -18939,11 +21132,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "unittest.mock._Sentinel"; rt.short_name = "_Sentinel"; cbm_registry_add_type(reg, rt); - static const char* py_methods_781[] = { "__init__", "__call__", "args", "kwargs", "call_list", NULL }; + static const char* py_methods_908[] = { "__init__", "__call__", "args", "kwargs", "call_list", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._Call"; rt.short_name = "_Call"; - rt.method_names = py_methods_781; + rt.method_names = py_methods_908; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._Call.__init__"; @@ -18970,11 +21163,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "call_list"; rf.receiver_type = "unittest.mock._Call"; cbm_registry_add_func(reg, rf); - static const char* py_methods_782[] = { "__init__", "__call__", "args", "kwargs", "call_list", NULL }; + static const char* py_methods_909[] = { "__init__", "__call__", "args", "kwargs", "call_list", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._Call"; rt.short_name = "_Call"; - rt.method_names = py_methods_782; + rt.method_names = py_methods_909; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._Call.__init__"; @@ -19005,24 +21198,24 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "unittest.mock._CallList"; rt.short_name = "_CallList"; cbm_registry_add_type(reg, rt); - static const char* py_methods_783[] = { "__init__", NULL }; + static const char* py_methods_910[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.Base"; rt.short_name = "Base"; - rt.method_names = py_methods_783; + rt.method_names = py_methods_910; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.Base.__init__"; rf.short_name = "__init__"; rf.receiver_type = "unittest.mock.Base"; cbm_registry_add_func(reg, rf); - static const char* py_methods_784[] = { "__new__", "__init__", "assert_called_with", "assert_not_called", "assert_called_once_with", "assert_called", "assert_called_once", "reset_mock", "assert_any_call", "assert_has_calls", "mock_add_spec", "attach_mock", "configure_mock", "_calls_repr", NULL }; + static const char* py_methods_911[] = { "__new__", "__init__", "assert_called_with", "assert_not_called", "assert_called_once_with", "assert_called", "assert_called_once", "reset_mock", "assert_any_call", "assert_has_calls", "mock_add_spec", "attach_mock", "configure_mock", "_calls_repr", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.NonCallableMock"; rt.short_name = "NonCallableMock"; - rt.method_names = py_methods_784; - static const char* py_bases_785[] = { "unittest.mock.Base", "unittest.mock.Any", NULL }; - rt.embedded_types = py_bases_785; + rt.method_names = py_methods_911; + static const char* py_bases_912[] = { "unittest.mock.Base", "unittest.mock.Any", NULL }; + rt.embedded_types = py_bases_912; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.NonCallableMock.__new__"; @@ -19094,13 +21287,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "_calls_repr"; rf.receiver_type = "unittest.mock.NonCallableMock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_786[] = { "__init__", "__call__", NULL }; + static const char* py_methods_913[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.CallableMixin"; rt.short_name = "CallableMixin"; - rt.method_names = py_methods_786; - static const char* py_bases_787[] = { "unittest.mock.Base", NULL }; - rt.embedded_types = py_bases_787; + rt.method_names = py_methods_913; + static const char* py_bases_914[] = { "unittest.mock.Base", NULL }; + rt.embedded_types = py_bases_914; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.CallableMixin.__init__"; @@ -19115,14 +21308,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.Mock"; rt.short_name = "Mock"; - static const char* py_bases_788[] = { "unittest.mock.CallableMixin", "unittest.mock.NonCallableMock", NULL }; - rt.embedded_types = py_bases_788; + static const char* py_bases_915[] = { "unittest.mock.CallableMixin", "unittest.mock.NonCallableMock", NULL }; + rt.embedded_types = py_bases_915; cbm_registry_add_type(reg, rt); - static const char* py_methods_789[] = { "__init__", "copy", "__call__", "decoration_helper", "decorate_class", "decorate_callable", "decorate_async_callable", "get_original", "__enter__", "__exit__", "start", "stop", NULL }; + static const char* py_methods_916[] = { "__init__", "copy", "__call__", "decoration_helper", "decorate_class", "decorate_callable", "decorate_async_callable", "get_original", "__enter__", "__exit__", "start", "stop", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._patch"; rt.short_name = "_patch"; - rt.method_names = py_methods_789; + rt.method_names = py_methods_916; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._patch.__init__"; @@ -19184,22 +21377,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "stop"; rf.receiver_type = "unittest.mock._patch"; cbm_registry_add_func(reg, rf); - static const char* py_methods_790[] = { "__call__", NULL }; + static const char* py_methods_917[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._patch_pass_arg"; rt.short_name = "_patch_pass_arg"; - rt.method_names = py_methods_790; + rt.method_names = py_methods_917; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._patch_pass_arg.__call__"; rf.short_name = "__call__"; rf.receiver_type = "unittest.mock._patch_pass_arg"; cbm_registry_add_func(reg, rf); - static const char* py_methods_791[] = { "__init__", "__call__", "__enter__", "__exit__", "decorate_callable", "decorate_async_callable", "decorate_class", NULL }; + static const char* py_methods_918[] = { "__init__", "__call__", "__enter__", "__exit__", "decorate_callable", "decorate_async_callable", "decorate_class", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._patch_dict"; rt.short_name = "_patch_dict"; - rt.method_names = py_methods_791; + rt.method_names = py_methods_918; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._patch_dict.__init__"; @@ -19236,11 +21429,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "decorate_class"; rf.receiver_type = "unittest.mock._patch_dict"; cbm_registry_add_func(reg, rf); - static const char* py_methods_792[] = { "__call__", "object", "multiple", "stopall", NULL }; + static const char* py_methods_919[] = { "__call__", "object", "multiple", "stopall", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._patcher"; rt.short_name = "_patcher"; - rt.method_names = py_methods_792; + rt.method_names = py_methods_919; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._patcher.__call__"; @@ -19262,13 +21455,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "stopall"; rf.receiver_type = "unittest.mock._patcher"; cbm_registry_add_func(reg, rf); - static const char* py_methods_793[] = { "__init__", NULL }; + static const char* py_methods_920[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.MagicMixin"; rt.short_name = "MagicMixin"; - rt.method_names = py_methods_793; - static const char* py_bases_794[] = { "unittest.mock.Base", NULL }; - rt.embedded_types = py_bases_794; + rt.method_names = py_methods_920; + static const char* py_bases_921[] = { "unittest.mock.Base", NULL }; + rt.embedded_types = py_bases_921; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.MagicMixin.__init__"; @@ -19278,22 +21471,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.NonCallableMagicMock"; rt.short_name = "NonCallableMagicMock"; - static const char* py_bases_795[] = { "unittest.mock.MagicMixin", "unittest.mock.NonCallableMock", NULL }; - rt.embedded_types = py_bases_795; + static const char* py_bases_922[] = { "unittest.mock.MagicMixin", "unittest.mock.NonCallableMock", NULL }; + rt.embedded_types = py_bases_922; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.MagicMock"; rt.short_name = "MagicMock"; - static const char* py_bases_796[] = { "unittest.mock.MagicMixin", "unittest.mock.Mock", NULL }; - rt.embedded_types = py_bases_796; + static const char* py_bases_923[] = { "unittest.mock.MagicMixin", "unittest.mock.Mock", NULL }; + rt.embedded_types = py_bases_923; cbm_registry_add_type(reg, rt); - static const char* py_methods_797[] = { "__init__", "assert_awaited", "assert_awaited_once", "assert_awaited_with", "assert_awaited_once_with", "assert_any_await", "assert_has_awaits", "assert_not_awaited", "reset_mock", NULL }; + static const char* py_methods_924[] = { "__init__", "assert_awaited", "assert_awaited_once", "assert_awaited_with", "assert_awaited_once_with", "assert_any_await", "assert_has_awaits", "assert_not_awaited", "reset_mock", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.AsyncMockMixin"; rt.short_name = "AsyncMockMixin"; - rt.method_names = py_methods_797; - static const char* py_bases_798[] = { "unittest.mock.Base", NULL }; - rt.embedded_types = py_bases_798; + rt.method_names = py_methods_924; + static const char* py_bases_925[] = { "unittest.mock.Base", NULL }; + rt.embedded_types = py_bases_925; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.AsyncMockMixin.__init__"; @@ -19340,39 +21533,39 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "reset_mock"; rf.receiver_type = "unittest.mock.AsyncMockMixin"; cbm_registry_add_func(reg, rf); - static const char* py_methods_799[] = { "__init__", NULL }; + static const char* py_methods_926[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.AsyncMagicMixin"; rt.short_name = "AsyncMagicMixin"; - rt.method_names = py_methods_799; - static const char* py_bases_800[] = { "unittest.mock.MagicMixin", NULL }; - rt.embedded_types = py_bases_800; + rt.method_names = py_methods_926; + static const char* py_bases_927[] = { "unittest.mock.MagicMixin", NULL }; + rt.embedded_types = py_bases_927; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.AsyncMagicMixin.__init__"; rf.short_name = "__init__"; rf.receiver_type = "unittest.mock.AsyncMagicMixin"; cbm_registry_add_func(reg, rf); - static const char* py_methods_801[] = { "reset_mock", NULL }; + static const char* py_methods_928[] = { "reset_mock", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.AsyncMock"; rt.short_name = "AsyncMock"; - rt.method_names = py_methods_801; - static const char* py_bases_802[] = { "unittest.mock.AsyncMockMixin", "unittest.mock.AsyncMagicMixin", "unittest.mock.Mock", NULL }; - rt.embedded_types = py_bases_802; + rt.method_names = py_methods_928; + static const char* py_bases_929[] = { "unittest.mock.AsyncMockMixin", "unittest.mock.AsyncMagicMixin", "unittest.mock.Mock", NULL }; + rt.embedded_types = py_bases_929; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.AsyncMock.reset_mock"; rf.short_name = "reset_mock"; rf.receiver_type = "unittest.mock.AsyncMock"; cbm_registry_add_func(reg, rf); - static const char* py_methods_803[] = { "__init__", "create_mock", NULL }; + static const char* py_methods_930[] = { "__init__", "create_mock", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.MagicProxy"; rt.short_name = "MagicProxy"; - rt.method_names = py_methods_803; - static const char* py_bases_804[] = { "unittest.mock.Base", NULL }; - rt.embedded_types = py_bases_804; + rt.method_names = py_methods_930; + static const char* py_bases_931[] = { "unittest.mock.Base", NULL }; + rt.embedded_types = py_bases_931; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.MagicProxy.__init__"; @@ -19387,14 +21580,14 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._ANY"; rt.short_name = "_ANY"; - static const char* py_bases_805[] = { "unittest.mock.Any", NULL }; - rt.embedded_types = py_bases_805; + static const char* py_bases_932[] = { "unittest.mock.Any", NULL }; + rt.embedded_types = py_bases_932; cbm_registry_add_type(reg, rt); - static const char* py_methods_806[] = { "__init__", NULL }; + static const char* py_methods_933[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock._SpecState"; rt.short_name = "_SpecState"; - rt.method_names = py_methods_806; + rt.method_names = py_methods_933; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock._SpecState.__init__"; @@ -19404,16 +21597,16 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.PropertyMock"; rt.short_name = "PropertyMock"; - static const char* py_bases_807[] = { "unittest.mock.Mock", NULL }; - rt.embedded_types = py_bases_807; + static const char* py_bases_934[] = { "unittest.mock.Mock", NULL }; + rt.embedded_types = py_bases_934; cbm_registry_add_type(reg, rt); - static const char* py_methods_808[] = { "__init__", "reset_mock", "wait_until_called", "wait_until_any_call_with", NULL }; + static const char* py_methods_935[] = { "__init__", "reset_mock", "wait_until_called", "wait_until_any_call_with", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.ThreadingMixin"; rt.short_name = "ThreadingMixin"; - rt.method_names = py_methods_808; - static const char* py_bases_809[] = { "unittest.mock.Base", NULL }; - rt.embedded_types = py_bases_809; + rt.method_names = py_methods_935; + static const char* py_bases_936[] = { "unittest.mock.Base", NULL }; + rt.embedded_types = py_bases_936; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.ThreadingMixin.__init__"; @@ -19438,8 +21631,8 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.mock.ThreadingMock"; rt.short_name = "ThreadingMock"; - static const char* py_bases_810[] = { "unittest.mock.ThreadingMixin", "unittest.mock.MagicMixin", "unittest.mock.Mock", NULL }; - rt.embedded_types = py_bases_810; + static const char* py_bases_937[] = { "unittest.mock.ThreadingMixin", "unittest.mock.MagicMixin", "unittest.mock.Mock", NULL }; + rt.embedded_types = py_bases_937; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.mock.create_autospec"; @@ -19455,11 +21648,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.result ===== */ - static const char* py_methods_811[] = { "__init__", "printErrors", "wasSuccessful", "stop", "startTest", "stopTest", "startTestRun", "stopTestRun", "addError", "addFailure", "addSuccess", "addSkip", "addExpectedFailure", "addUnexpectedSuccess", "addSubTest", "addDuration", NULL }; + static const char* py_methods_938[] = { "__init__", "printErrors", "wasSuccessful", "stop", "startTest", "stopTest", "startTestRun", "stopTestRun", "addError", "addFailure", "addSuccess", "addSkip", "addExpectedFailure", "addUnexpectedSuccess", "addSubTest", "addDuration", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.result.TestResult"; rt.short_name = "TestResult"; - rt.method_names = py_methods_811; + rt.method_names = py_methods_938; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.result.TestResult.__init__"; @@ -19550,27 +21743,27 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.runner._SupportsWriteAndFlush"; rt.short_name = "_SupportsWriteAndFlush"; - static const char* py_bases_812[] = { "unittest.runner.SupportsFlush", "unittest.runner.Protocol", NULL }; - rt.embedded_types = py_bases_812; + static const char* py_bases_939[] = { "unittest.runner.SupportsFlush", "unittest.runner.Protocol", NULL }; + rt.embedded_types = py_bases_939; cbm_registry_add_type(reg, rt); - static const char* py_methods_813[] = { "writeln", NULL }; + static const char* py_methods_940[] = { "writeln", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.runner._TextTestStream"; rt.short_name = "_TextTestStream"; - rt.method_names = py_methods_813; - static const char* py_bases_814[] = { "unittest.runner._SupportsWriteAndFlush", "unittest.runner.Protocol", NULL }; - rt.embedded_types = py_bases_814; + rt.method_names = py_methods_940; + static const char* py_bases_941[] = { "unittest.runner._SupportsWriteAndFlush", "unittest.runner.Protocol", NULL }; + rt.embedded_types = py_bases_941; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.runner._TextTestStream.writeln"; rf.short_name = "writeln"; rf.receiver_type = "unittest.runner._TextTestStream"; cbm_registry_add_func(reg, rf); - static const char* py_methods_815[] = { "__init__", "writeln", "flush", "write", NULL }; + static const char* py_methods_942[] = { "__init__", "writeln", "flush", "write", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.runner._WritelnDecorator"; rt.short_name = "_WritelnDecorator"; - rt.method_names = py_methods_815; + rt.method_names = py_methods_942; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.runner._WritelnDecorator.__init__"; @@ -19592,13 +21785,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "write"; rf.receiver_type = "unittest.runner._WritelnDecorator"; cbm_registry_add_func(reg, rf); - static const char* py_methods_816[] = { "__init__", "getDescription", "printErrorList", NULL }; + static const char* py_methods_943[] = { "__init__", "getDescription", "printErrorList", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.runner.TextTestResult"; rt.short_name = "TextTestResult"; - rt.method_names = py_methods_816; - static const char* py_bases_817[] = { "unittest.result.TestResult", NULL }; - rt.embedded_types = py_bases_817; + rt.method_names = py_methods_943; + static const char* py_bases_944[] = { "unittest.result.TestResult", NULL }; + rt.embedded_types = py_bases_944; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.runner.TextTestResult.__init__"; @@ -19615,11 +21808,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "printErrorList"; rf.receiver_type = "unittest.runner.TextTestResult"; cbm_registry_add_func(reg, rf); - static const char* py_methods_818[] = { "__init__", "run", NULL }; + static const char* py_methods_945[] = { "__init__", "run", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.runner.TextTestRunner"; rt.short_name = "TextTestRunner"; - rt.method_names = py_methods_818; + rt.method_names = py_methods_945; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.runner.TextTestRunner.__init__"; @@ -19651,11 +21844,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { cbm_registry_add_func(reg, rf); /* ===== module: unittest.suite ===== */ - static const char* py_methods_819[] = { "__init__", "__call__", "addTest", "addTests", "run", "debug", "countTestCases", NULL }; + static const char* py_methods_946[] = { "__init__", "__call__", "addTest", "addTests", "run", "debug", "countTestCases", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.suite.BaseTestSuite"; rt.short_name = "BaseTestSuite"; - rt.method_names = py_methods_819; + rt.method_names = py_methods_946; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.suite.BaseTestSuite.__init__"; @@ -19692,13 +21885,13 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "countTestCases"; rf.receiver_type = "unittest.suite.BaseTestSuite"; cbm_registry_add_func(reg, rf); - static const char* py_methods_820[] = { "run", NULL }; + static const char* py_methods_947[] = { "run", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.suite.TestSuite"; rt.short_name = "TestSuite"; - rt.method_names = py_methods_820; - static const char* py_bases_821[] = { "unittest.suite.BaseTestSuite", NULL }; - rt.embedded_types = py_bases_821; + rt.method_names = py_methods_947; + static const char* py_bases_948[] = { "unittest.suite.BaseTestSuite", NULL }; + rt.embedded_types = py_bases_948; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.suite.TestSuite.run"; @@ -19710,26 +21903,26 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.util._SupportsDunderLT"; rt.short_name = "_SupportsDunderLT"; - static const char* py_bases_822[] = { "unittest.util.Protocol", NULL }; - rt.embedded_types = py_bases_822; + static const char* py_bases_949[] = { "unittest.util.Protocol", NULL }; + rt.embedded_types = py_bases_949; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.util._SupportsDunderGT"; rt.short_name = "_SupportsDunderGT"; - static const char* py_bases_823[] = { "unittest.util.Protocol", NULL }; - rt.embedded_types = py_bases_823; + static const char* py_bases_950[] = { "unittest.util.Protocol", NULL }; + rt.embedded_types = py_bases_950; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.util._SupportsDunderLE"; rt.short_name = "_SupportsDunderLE"; - static const char* py_bases_824[] = { "unittest.util.Protocol", NULL }; - rt.embedded_types = py_bases_824; + static const char* py_bases_951[] = { "unittest.util.Protocol", NULL }; + rt.embedded_types = py_bases_951; cbm_registry_add_type(reg, rt); memset(&rt, 0, sizeof(rt)); rt.qualified_name = "unittest.util._SupportsDunderGE"; rt.short_name = "_SupportsDunderGE"; - static const char* py_bases_825[] = { "unittest.util.Protocol", NULL }; - rt.embedded_types = py_bases_825; + static const char* py_bases_952[] = { "unittest.util.Protocol", NULL }; + rt.embedded_types = py_bases_952; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "unittest.util.safe_repr"; @@ -19752,29 +21945,1342 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "three_way_cmp"; cbm_registry_add_func(reg, rf); + /* ===== module: urllib.error ===== */ + static const char* py_methods_953[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.error.URLError"; + rt.short_name = "URLError"; + rt.method_names = py_methods_953; + static const char* py_bases_954[] = { "urllib.error.OSError", NULL }; + rt.embedded_types = py_bases_954; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.error.URLError.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.error.URLError"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_955[] = { "headers", "reason", "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.error.HTTPError"; + rt.short_name = "HTTPError"; + rt.method_names = py_methods_955; + static const char* py_bases_956[] = { "urllib.error.URLError", "urllib.error.addinfourl", NULL }; + rt.embedded_types = py_bases_956; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.error.HTTPError.headers"; + rf.short_name = "headers"; + rf.receiver_type = "urllib.error.HTTPError"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.error.HTTPError.reason"; + rf.short_name = "reason"; + rf.receiver_type = "urllib.error.HTTPError"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.error.HTTPError.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.error.HTTPError"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_957[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.error.ContentTooShortError"; + rt.short_name = "ContentTooShortError"; + rt.method_names = py_methods_957; + static const char* py_bases_958[] = { "urllib.error.URLError", NULL }; + rt.embedded_types = py_bases_958; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.error.ContentTooShortError.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.error.ContentTooShortError"; + cbm_registry_add_func(reg, rf); + + /* ===== module: urllib.parse ===== */ + static const char* py_methods_959[] = { "encode", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._ResultMixinStr"; + rt.short_name = "_ResultMixinStr"; + rt.method_names = py_methods_959; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._ResultMixinStr.encode"; + rf.short_name = "encode"; + rf.receiver_type = "urllib.parse._ResultMixinStr"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_960[] = { "decode", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._ResultMixinBytes"; + rt.short_name = "_ResultMixinBytes"; + rt.method_names = py_methods_960; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._ResultMixinBytes.decode"; + rf.short_name = "decode"; + rf.receiver_type = "urllib.parse._ResultMixinBytes"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_961[] = { "username", "password", "hostname", "port", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._NetlocResultMixinBase"; + rt.short_name = "_NetlocResultMixinBase"; + rt.method_names = py_methods_961; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._NetlocResultMixinBase.username"; + rf.short_name = "username"; + rf.receiver_type = "urllib.parse._NetlocResultMixinBase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._NetlocResultMixinBase.password"; + rf.short_name = "password"; + rf.receiver_type = "urllib.parse._NetlocResultMixinBase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._NetlocResultMixinBase.hostname"; + rf.short_name = "hostname"; + rf.receiver_type = "urllib.parse._NetlocResultMixinBase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._NetlocResultMixinBase.port"; + rf.short_name = "port"; + rf.receiver_type = "urllib.parse._NetlocResultMixinBase"; + cbm_registry_add_func(reg, rf); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._NetlocResultMixinStr"; + rt.short_name = "_NetlocResultMixinStr"; + static const char* py_bases_962[] = { "urllib.parse._ResultMixinStr", NULL }; + rt.embedded_types = py_bases_962; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._NetlocResultMixinBytes"; + rt.short_name = "_NetlocResultMixinBytes"; + static const char* py_bases_963[] = { "urllib.parse._ResultMixinBytes", NULL }; + rt.embedded_types = py_bases_963; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._DefragResultBase"; + rt.short_name = "_DefragResultBase"; + static const char* py_bases_964[] = { "urllib.parse.NamedTuple", NULL }; + rt.embedded_types = py_bases_964; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._SplitResultBase"; + rt.short_name = "_SplitResultBase"; + static const char* py_bases_965[] = { "urllib.parse.NamedTuple", NULL }; + rt.embedded_types = py_bases_965; + cbm_registry_add_type(reg, rt); + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._ParseResultBase"; + rt.short_name = "_ParseResultBase"; + static const char* py_bases_966[] = { "urllib.parse.NamedTuple", NULL }; + rt.embedded_types = py_bases_966; + cbm_registry_add_type(reg, rt); + static const char* py_methods_967[] = { "geturl", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse.DefragResult"; + rt.short_name = "DefragResult"; + rt.method_names = py_methods_967; + static const char* py_bases_968[] = { "urllib.parse._ResultMixinStr", NULL }; + rt.embedded_types = py_bases_968; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.DefragResult.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.parse.DefragResult"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_969[] = { "geturl", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse.SplitResult"; + rt.short_name = "SplitResult"; + rt.method_names = py_methods_969; + static const char* py_bases_970[] = { "urllib.parse._NetlocResultMixinStr", NULL }; + rt.embedded_types = py_bases_970; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.SplitResult.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.parse.SplitResult"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_971[] = { "geturl", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse.ParseResult"; + rt.short_name = "ParseResult"; + rt.method_names = py_methods_971; + static const char* py_bases_972[] = { "urllib.parse._NetlocResultMixinStr", NULL }; + rt.embedded_types = py_bases_972; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.ParseResult.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.parse.ParseResult"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_973[] = { "geturl", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse.DefragResultBytes"; + rt.short_name = "DefragResultBytes"; + rt.method_names = py_methods_973; + static const char* py_bases_974[] = { "urllib.parse._ResultMixinBytes", NULL }; + rt.embedded_types = py_bases_974; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.DefragResultBytes.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.parse.DefragResultBytes"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_975[] = { "geturl", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse.SplitResultBytes"; + rt.short_name = "SplitResultBytes"; + rt.method_names = py_methods_975; + static const char* py_bases_976[] = { "urllib.parse._NetlocResultMixinBytes", NULL }; + rt.embedded_types = py_bases_976; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.SplitResultBytes.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.parse.SplitResultBytes"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_977[] = { "geturl", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse.ParseResultBytes"; + rt.short_name = "ParseResultBytes"; + rt.method_names = py_methods_977; + static const char* py_bases_978[] = { "urllib.parse._NetlocResultMixinBytes", NULL }; + rt.embedded_types = py_bases_978; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.ParseResultBytes.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.parse.ParseResultBytes"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_979[] = { "__call__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.parse._QuoteVia"; + rt.short_name = "_QuoteVia"; + rt.method_names = py_methods_979; + static const char* py_bases_980[] = { "urllib.parse.Protocol", NULL }; + rt.embedded_types = py_bases_980; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse._QuoteVia.__call__"; + rf.short_name = "__call__"; + rf.receiver_type = "urllib.parse._QuoteVia"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.parse_qs"; + rf.short_name = "parse_qs"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.parse_qsl"; + rf.short_name = "parse_qsl"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.quote"; + rf.short_name = "quote"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.quote_from_bytes"; + rf.short_name = "quote_from_bytes"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.quote_plus"; + rf.short_name = "quote_plus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.unquote"; + rf.short_name = "unquote"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.unquote_to_bytes"; + rf.short_name = "unquote_to_bytes"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.unquote_plus"; + rf.short_name = "unquote_plus"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urldefrag"; + rf.short_name = "urldefrag"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urlencode"; + rf.short_name = "urlencode"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urljoin"; + rf.short_name = "urljoin"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urlparse"; + rf.short_name = "urlparse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urlsplit"; + rf.short_name = "urlsplit"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urlunparse"; + rf.short_name = "urlunparse"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.urlunsplit"; + rf.short_name = "urlunsplit"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.parse.unwrap"; + rf.short_name = "unwrap"; + cbm_registry_add_func(reg, rf); + + /* ===== module: urllib.request ===== */ + static const char* py_methods_981[] = { "full_url", "__init__", "get_method", "add_header", "add_unredirected_header", "has_header", "remove_header", "get_full_url", "set_proxy", "get_header", "header_items", "has_proxy", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.Request"; + rt.short_name = "Request"; + rt.method_names = py_methods_981; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.full_url"; + rf.short_name = "full_url"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.get_method"; + rf.short_name = "get_method"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.add_header"; + rf.short_name = "add_header"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.add_unredirected_header"; + rf.short_name = "add_unredirected_header"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.has_header"; + rf.short_name = "has_header"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.remove_header"; + rf.short_name = "remove_header"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.get_full_url"; + rf.short_name = "get_full_url"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.set_proxy"; + rf.short_name = "set_proxy"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.get_header"; + rf.short_name = "get_header"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.header_items"; + rf.short_name = "header_items"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.Request.has_proxy"; + rf.short_name = "has_proxy"; + rf.receiver_type = "urllib.request.Request"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_982[] = { "add_handler", "open", "error", "close", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.OpenerDirector"; + rt.short_name = "OpenerDirector"; + rt.method_names = py_methods_982; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.OpenerDirector.add_handler"; + rf.short_name = "add_handler"; + rf.receiver_type = "urllib.request.OpenerDirector"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.OpenerDirector.open"; + rf.short_name = "open"; + rf.receiver_type = "urllib.request.OpenerDirector"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.OpenerDirector.error"; + rf.short_name = "error"; + rf.receiver_type = "urllib.request.OpenerDirector"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.OpenerDirector.close"; + rf.short_name = "close"; + rf.receiver_type = "urllib.request.OpenerDirector"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_983[] = { "add_parent", "close", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.BaseHandler"; + rt.short_name = "BaseHandler"; + rt.method_names = py_methods_983; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.BaseHandler.add_parent"; + rf.short_name = "add_parent"; + rf.receiver_type = "urllib.request.BaseHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.BaseHandler.close"; + rf.short_name = "close"; + rf.receiver_type = "urllib.request.BaseHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_984[] = { "http_error_default", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPDefaultErrorHandler"; + rt.short_name = "HTTPDefaultErrorHandler"; + rt.method_names = py_methods_984; + static const char* py_bases_985[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_985; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPDefaultErrorHandler.http_error_default"; + rf.short_name = "http_error_default"; + rf.receiver_type = "urllib.request.HTTPDefaultErrorHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_986[] = { "redirect_request", "http_error_301", "http_error_302", "http_error_303", "http_error_307", "http_error_308", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPRedirectHandler"; + rt.short_name = "HTTPRedirectHandler"; + rt.method_names = py_methods_986; + static const char* py_bases_987[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_987; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPRedirectHandler.redirect_request"; + rf.short_name = "redirect_request"; + rf.receiver_type = "urllib.request.HTTPRedirectHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_301"; + rf.short_name = "http_error_301"; + rf.receiver_type = "urllib.request.HTTPRedirectHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_302"; + rf.short_name = "http_error_302"; + rf.receiver_type = "urllib.request.HTTPRedirectHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_303"; + rf.short_name = "http_error_303"; + rf.receiver_type = "urllib.request.HTTPRedirectHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_307"; + rf.short_name = "http_error_307"; + rf.receiver_type = "urllib.request.HTTPRedirectHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_308"; + rf.short_name = "http_error_308"; + rf.receiver_type = "urllib.request.HTTPRedirectHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_988[] = { "__init__", "http_request", "http_response", "https_request", "https_response", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPCookieProcessor"; + rt.short_name = "HTTPCookieProcessor"; + rt.method_names = py_methods_988; + static const char* py_bases_989[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_989; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPCookieProcessor.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.HTTPCookieProcessor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPCookieProcessor.http_request"; + rf.short_name = "http_request"; + rf.receiver_type = "urllib.request.HTTPCookieProcessor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPCookieProcessor.http_response"; + rf.short_name = "http_response"; + rf.receiver_type = "urllib.request.HTTPCookieProcessor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPCookieProcessor.https_request"; + rf.short_name = "https_request"; + rf.receiver_type = "urllib.request.HTTPCookieProcessor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPCookieProcessor.https_response"; + rf.short_name = "https_response"; + rf.receiver_type = "urllib.request.HTTPCookieProcessor"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_990[] = { "__init__", "proxy_open", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.ProxyHandler"; + rt.short_name = "ProxyHandler"; + rt.method_names = py_methods_990; + static const char* py_bases_991[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_991; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ProxyHandler.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.ProxyHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ProxyHandler.proxy_open"; + rf.short_name = "proxy_open"; + rf.receiver_type = "urllib.request.ProxyHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_992[] = { "add_password", "find_user_password", "is_suburi", "reduce_uri", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPPasswordMgr"; + rt.short_name = "HTTPPasswordMgr"; + rt.method_names = py_methods_992; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgr.add_password"; + rf.short_name = "add_password"; + rf.receiver_type = "urllib.request.HTTPPasswordMgr"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgr.find_user_password"; + rf.short_name = "find_user_password"; + rf.receiver_type = "urllib.request.HTTPPasswordMgr"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgr.is_suburi"; + rf.short_name = "is_suburi"; + rf.receiver_type = "urllib.request.HTTPPasswordMgr"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgr.reduce_uri"; + rf.short_name = "reduce_uri"; + rf.receiver_type = "urllib.request.HTTPPasswordMgr"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_993[] = { "add_password", "find_user_password", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPPasswordMgrWithDefaultRealm"; + rt.short_name = "HTTPPasswordMgrWithDefaultRealm"; + rt.method_names = py_methods_993; + static const char* py_bases_994[] = { "urllib.request.HTTPPasswordMgr", NULL }; + rt.embedded_types = py_bases_994; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgrWithDefaultRealm.add_password"; + rf.short_name = "add_password"; + rf.receiver_type = "urllib.request.HTTPPasswordMgrWithDefaultRealm"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgrWithDefaultRealm.find_user_password"; + rf.short_name = "find_user_password"; + rf.receiver_type = "urllib.request.HTTPPasswordMgrWithDefaultRealm"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_995[] = { "add_password", "update_authenticated", "is_authenticated", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth"; + rt.short_name = "HTTPPasswordMgrWithPriorAuth"; + rt.method_names = py_methods_995; + static const char* py_bases_996[] = { "urllib.request.HTTPPasswordMgrWithDefaultRealm", NULL }; + rt.embedded_types = py_bases_996; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth.add_password"; + rf.short_name = "add_password"; + rf.receiver_type = "urllib.request.HTTPPasswordMgrWithPriorAuth"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth.update_authenticated"; + rf.short_name = "update_authenticated"; + rf.receiver_type = "urllib.request.HTTPPasswordMgrWithPriorAuth"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth.is_authenticated"; + rf.short_name = "is_authenticated"; + rf.receiver_type = "urllib.request.HTTPPasswordMgrWithPriorAuth"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_997[] = { "__init__", "http_error_auth_reqed", "http_request", "http_response", "https_request", "https_response", "retry_http_basic_auth", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.AbstractBasicAuthHandler"; + rt.short_name = "AbstractBasicAuthHandler"; + rt.method_names = py_methods_997; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.http_error_auth_reqed"; + rf.short_name = "http_error_auth_reqed"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.http_request"; + rf.short_name = "http_request"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.http_response"; + rf.short_name = "http_response"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.https_request"; + rf.short_name = "https_request"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.https_response"; + rf.short_name = "https_response"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.retry_http_basic_auth"; + rf.short_name = "retry_http_basic_auth"; + rf.receiver_type = "urllib.request.AbstractBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_998[] = { "http_error_401", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPBasicAuthHandler"; + rt.short_name = "HTTPBasicAuthHandler"; + rt.method_names = py_methods_998; + static const char* py_bases_999[] = { "urllib.request.AbstractBasicAuthHandler", "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_999; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPBasicAuthHandler.http_error_401"; + rf.short_name = "http_error_401"; + rf.receiver_type = "urllib.request.HTTPBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1000[] = { "http_error_407", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.ProxyBasicAuthHandler"; + rt.short_name = "ProxyBasicAuthHandler"; + rt.method_names = py_methods_1000; + static const char* py_bases_1001[] = { "urllib.request.AbstractBasicAuthHandler", "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1001; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ProxyBasicAuthHandler.http_error_407"; + rf.short_name = "http_error_407"; + rf.receiver_type = "urllib.request.ProxyBasicAuthHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1002[] = { "__init__", "reset_retry_count", "http_error_auth_reqed", "retry_http_digest_auth", "get_cnonce", "get_authorization", "get_algorithm_impls", "get_entity_digest", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.AbstractDigestAuthHandler"; + rt.short_name = "AbstractDigestAuthHandler"; + rt.method_names = py_methods_1002; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.reset_retry_count"; + rf.short_name = "reset_retry_count"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.http_error_auth_reqed"; + rf.short_name = "http_error_auth_reqed"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.retry_http_digest_auth"; + rf.short_name = "retry_http_digest_auth"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_cnonce"; + rf.short_name = "get_cnonce"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_authorization"; + rf.short_name = "get_authorization"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_algorithm_impls"; + rf.short_name = "get_algorithm_impls"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_entity_digest"; + rf.short_name = "get_entity_digest"; + rf.receiver_type = "urllib.request.AbstractDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1003[] = { "http_error_401", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPDigestAuthHandler"; + rt.short_name = "HTTPDigestAuthHandler"; + rt.method_names = py_methods_1003; + static const char* py_bases_1004[] = { "urllib.request.BaseHandler", "urllib.request.AbstractDigestAuthHandler", NULL }; + rt.embedded_types = py_bases_1004; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPDigestAuthHandler.http_error_401"; + rf.short_name = "http_error_401"; + rf.receiver_type = "urllib.request.HTTPDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1005[] = { "http_error_407", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.ProxyDigestAuthHandler"; + rt.short_name = "ProxyDigestAuthHandler"; + rt.method_names = py_methods_1005; + static const char* py_bases_1006[] = { "urllib.request.BaseHandler", "urllib.request.AbstractDigestAuthHandler", NULL }; + rt.embedded_types = py_bases_1006; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ProxyDigestAuthHandler.http_error_407"; + rf.short_name = "http_error_407"; + rf.receiver_type = "urllib.request.ProxyDigestAuthHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1007[] = { "__call__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request._HTTPConnectionProtocol"; + rt.short_name = "_HTTPConnectionProtocol"; + rt.method_names = py_methods_1007; + static const char* py_bases_1008[] = { "urllib.request.Protocol", NULL }; + rt.embedded_types = py_bases_1008; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request._HTTPConnectionProtocol.__call__"; + rf.short_name = "__call__"; + rf.receiver_type = "urllib.request._HTTPConnectionProtocol"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1009[] = { "__init__", "set_http_debuglevel", "do_request_", "do_open", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.AbstractHTTPHandler"; + rt.short_name = "AbstractHTTPHandler"; + rt.method_names = py_methods_1009; + static const char* py_bases_1010[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1010; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractHTTPHandler.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.AbstractHTTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractHTTPHandler.set_http_debuglevel"; + rf.short_name = "set_http_debuglevel"; + rf.receiver_type = "urllib.request.AbstractHTTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractHTTPHandler.do_request_"; + rf.short_name = "do_request_"; + rf.receiver_type = "urllib.request.AbstractHTTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.AbstractHTTPHandler.do_open"; + rf.short_name = "do_open"; + rf.receiver_type = "urllib.request.AbstractHTTPHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1011[] = { "http_open", "http_request", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPHandler"; + rt.short_name = "HTTPHandler"; + rt.method_names = py_methods_1011; + static const char* py_bases_1012[] = { "urllib.request.AbstractHTTPHandler", NULL }; + rt.embedded_types = py_bases_1012; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPHandler.http_open"; + rf.short_name = "http_open"; + rf.receiver_type = "urllib.request.HTTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPHandler.http_request"; + rf.short_name = "http_request"; + rf.receiver_type = "urllib.request.HTTPHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1013[] = { "__init__", "https_open", "https_request", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPSHandler"; + rt.short_name = "HTTPSHandler"; + rt.method_names = py_methods_1013; + static const char* py_bases_1014[] = { "urllib.request.AbstractHTTPHandler", NULL }; + rt.embedded_types = py_bases_1014; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPSHandler.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.HTTPSHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPSHandler.https_open"; + rf.short_name = "https_open"; + rf.receiver_type = "urllib.request.HTTPSHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPSHandler.https_request"; + rf.short_name = "https_request"; + rf.receiver_type = "urllib.request.HTTPSHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1015[] = { "file_open", "get_names", "open_local_file", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.FileHandler"; + rt.short_name = "FileHandler"; + rt.method_names = py_methods_1015; + static const char* py_bases_1016[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1016; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FileHandler.file_open"; + rf.short_name = "file_open"; + rf.receiver_type = "urllib.request.FileHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FileHandler.get_names"; + rf.short_name = "get_names"; + rf.receiver_type = "urllib.request.FileHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FileHandler.open_local_file"; + rf.short_name = "open_local_file"; + rf.receiver_type = "urllib.request.FileHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1017[] = { "data_open", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.DataHandler"; + rt.short_name = "DataHandler"; + rt.method_names = py_methods_1017; + static const char* py_bases_1018[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1018; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.DataHandler.data_open"; + rf.short_name = "data_open"; + rf.receiver_type = "urllib.request.DataHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1019[] = { "__init__", "close", "endtransfer", "file_close", "init", "real_close", "retrfile", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.ftpwrapper"; + rt.short_name = "ftpwrapper"; + rt.method_names = py_methods_1019; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.close"; + rf.short_name = "close"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.endtransfer"; + rf.short_name = "endtransfer"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.file_close"; + rf.short_name = "file_close"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.init"; + rf.short_name = "init"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.real_close"; + rf.short_name = "real_close"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.ftpwrapper.retrfile"; + rf.short_name = "retrfile"; + rf.receiver_type = "urllib.request.ftpwrapper"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1020[] = { "ftp_open", "connect_ftp", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.FTPHandler"; + rt.short_name = "FTPHandler"; + rt.method_names = py_methods_1020; + static const char* py_bases_1021[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1021; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FTPHandler.ftp_open"; + rf.short_name = "ftp_open"; + rf.receiver_type = "urllib.request.FTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FTPHandler.connect_ftp"; + rf.short_name = "connect_ftp"; + rf.receiver_type = "urllib.request.FTPHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1022[] = { "setTimeout", "setMaxConns", "check_cache", "clear_cache", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.CacheFTPHandler"; + rt.short_name = "CacheFTPHandler"; + rt.method_names = py_methods_1022; + static const char* py_bases_1023[] = { "urllib.request.FTPHandler", NULL }; + rt.embedded_types = py_bases_1023; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.CacheFTPHandler.setTimeout"; + rf.short_name = "setTimeout"; + rf.receiver_type = "urllib.request.CacheFTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.CacheFTPHandler.setMaxConns"; + rf.short_name = "setMaxConns"; + rf.receiver_type = "urllib.request.CacheFTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.CacheFTPHandler.check_cache"; + rf.short_name = "check_cache"; + rf.receiver_type = "urllib.request.CacheFTPHandler"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.CacheFTPHandler.clear_cache"; + rf.short_name = "clear_cache"; + rf.receiver_type = "urllib.request.CacheFTPHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1024[] = { "unknown_open", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.UnknownHandler"; + rt.short_name = "UnknownHandler"; + rt.method_names = py_methods_1024; + static const char* py_bases_1025[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1025; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.UnknownHandler.unknown_open"; + rf.short_name = "unknown_open"; + rf.receiver_type = "urllib.request.UnknownHandler"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1026[] = { "http_response", "https_response", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.HTTPErrorProcessor"; + rt.short_name = "HTTPErrorProcessor"; + rt.method_names = py_methods_1026; + static const char* py_bases_1027[] = { "urllib.request.BaseHandler", NULL }; + rt.embedded_types = py_bases_1027; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPErrorProcessor.http_response"; + rf.short_name = "http_response"; + rf.receiver_type = "urllib.request.HTTPErrorProcessor"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.HTTPErrorProcessor.https_response"; + rf.short_name = "https_response"; + rf.receiver_type = "urllib.request.HTTPErrorProcessor"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1028[] = { "__init__", "open", "open_unknown", "retrieve", "addheader", "cleanup", "close", "http_error", "http_error_default", "open_data", "open_file", "open_ftp", "open_http", "open_https", "open_local_file", "open_unknown_proxy", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.URLopener"; + rt.short_name = "URLopener"; + rt.method_names = py_methods_1028; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open"; + rf.short_name = "open"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_unknown"; + rf.short_name = "open_unknown"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.retrieve"; + rf.short_name = "retrieve"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.addheader"; + rf.short_name = "addheader"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.cleanup"; + rf.short_name = "cleanup"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.close"; + rf.short_name = "close"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.http_error"; + rf.short_name = "http_error"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.http_error_default"; + rf.short_name = "http_error_default"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_data"; + rf.short_name = "open_data"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_file"; + rf.short_name = "open_file"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_ftp"; + rf.short_name = "open_ftp"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_http"; + rf.short_name = "open_http"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_https"; + rf.short_name = "open_https"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_local_file"; + rf.short_name = "open_local_file"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.URLopener.open_unknown_proxy"; + rf.short_name = "open_unknown_proxy"; + rf.receiver_type = "urllib.request.URLopener"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1029[] = { "prompt_user_passwd", "get_user_passwd", "http_error_301", "http_error_302", "http_error_303", "http_error_307", "http_error_308", "http_error_401", "http_error_407", "http_error_default", "redirect_internal", "retry_http_basic_auth", "retry_https_basic_auth", "retry_proxy_http_basic_auth", "retry_proxy_https_basic_auth", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.request.FancyURLopener"; + rt.short_name = "FancyURLopener"; + rt.method_names = py_methods_1029; + static const char* py_bases_1030[] = { "urllib.request.URLopener", NULL }; + rt.embedded_types = py_bases_1030; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.prompt_user_passwd"; + rf.short_name = "prompt_user_passwd"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.get_user_passwd"; + rf.short_name = "get_user_passwd"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_301"; + rf.short_name = "http_error_301"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_302"; + rf.short_name = "http_error_302"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_303"; + rf.short_name = "http_error_303"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_307"; + rf.short_name = "http_error_307"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_308"; + rf.short_name = "http_error_308"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_401"; + rf.short_name = "http_error_401"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_407"; + rf.short_name = "http_error_407"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.http_error_default"; + rf.short_name = "http_error_default"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.redirect_internal"; + rf.short_name = "redirect_internal"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.retry_http_basic_auth"; + rf.short_name = "retry_http_basic_auth"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.retry_https_basic_auth"; + rf.short_name = "retry_https_basic_auth"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.retry_proxy_http_basic_auth"; + rf.short_name = "retry_proxy_http_basic_auth"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.FancyURLopener.retry_proxy_https_basic_auth"; + rf.short_name = "retry_proxy_https_basic_auth"; + rf.receiver_type = "urllib.request.FancyURLopener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.urlopen"; + rf.short_name = "urlopen"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.install_opener"; + rf.short_name = "install_opener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.build_opener"; + rf.short_name = "build_opener"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.url2pathname"; + rf.short_name = "url2pathname"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.pathname2url"; + rf.short_name = "pathname2url"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.getproxies"; + rf.short_name = "getproxies"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.getproxies_environment"; + rf.short_name = "getproxies_environment"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.parse_http_list"; + rf.short_name = "parse_http_list"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.parse_keqv_list"; + rf.short_name = "parse_keqv_list"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.proxy_bypass"; + rf.short_name = "proxy_bypass"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.urlretrieve"; + rf.short_name = "urlretrieve"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.request.urlcleanup"; + rf.short_name = "urlcleanup"; + cbm_registry_add_func(reg, rf); + + /* ===== module: urllib.response ===== */ + static const char* py_methods_1031[] = { "__init__", "__exit__", "write", "writelines", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.response.addbase"; + rt.short_name = "addbase"; + rt.method_names = py_methods_1031; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addbase.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.response.addbase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addbase.__exit__"; + rf.short_name = "__exit__"; + rf.receiver_type = "urllib.response.addbase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addbase.write"; + rf.short_name = "write"; + rf.receiver_type = "urllib.response.addbase"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addbase.writelines"; + rf.short_name = "writelines"; + rf.receiver_type = "urllib.response.addbase"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1032[] = { "__init__", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.response.addclosehook"; + rt.short_name = "addclosehook"; + rt.method_names = py_methods_1032; + static const char* py_bases_1033[] = { "urllib.response.addbase", NULL }; + rt.embedded_types = py_bases_1033; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addclosehook.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.response.addclosehook"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1034[] = { "__init__", "info", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.response.addinfo"; + rt.short_name = "addinfo"; + rt.method_names = py_methods_1034; + static const char* py_bases_1035[] = { "urllib.response.addbase", NULL }; + rt.embedded_types = py_bases_1035; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfo.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.response.addinfo"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfo.info"; + rf.short_name = "info"; + rf.receiver_type = "urllib.response.addinfo"; + cbm_registry_add_func(reg, rf); + static const char* py_methods_1036[] = { "status", "__init__", "geturl", "info", "getcode", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.response.addinfourl"; + rt.short_name = "addinfourl"; + rt.method_names = py_methods_1036; + static const char* py_bases_1037[] = { "urllib.response.addinfo", NULL }; + rt.embedded_types = py_bases_1037; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfourl.status"; + rf.short_name = "status"; + rf.receiver_type = "urllib.response.addinfourl"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfourl.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.response.addinfourl"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfourl.geturl"; + rf.short_name = "geturl"; + rf.receiver_type = "urllib.response.addinfourl"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfourl.info"; + rf.short_name = "info"; + rf.receiver_type = "urllib.response.addinfourl"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.response.addinfourl.getcode"; + rf.short_name = "getcode"; + rf.receiver_type = "urllib.response.addinfourl"; + cbm_registry_add_func(reg, rf); + + /* ===== module: urllib.robotparser ===== */ + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.robotparser.RequestRate"; + rt.short_name = "RequestRate"; + static const char* py_bases_1038[] = { "urllib.robotparser.NamedTuple", NULL }; + rt.embedded_types = py_bases_1038; + cbm_registry_add_type(reg, rt); + static const char* py_methods_1039[] = { "__init__", "set_url", "read", "parse", "can_fetch", "mtime", "modified", "crawl_delay", "request_rate", "site_maps", NULL }; + memset(&rt, 0, sizeof(rt)); + rt.qualified_name = "urllib.robotparser.RobotFileParser"; + rt.short_name = "RobotFileParser"; + rt.method_names = py_methods_1039; + cbm_registry_add_type(reg, rt); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.__init__"; + rf.short_name = "__init__"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.set_url"; + rf.short_name = "set_url"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.read"; + rf.short_name = "read"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.parse"; + rf.short_name = "parse"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.can_fetch"; + rf.short_name = "can_fetch"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.mtime"; + rf.short_name = "mtime"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.modified"; + rf.short_name = "modified"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.crawl_delay"; + rf.short_name = "crawl_delay"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.request_rate"; + rf.short_name = "request_rate"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + memset(&rf, 0, sizeof(rf)); + rf.qualified_name = "urllib.robotparser.RobotFileParser.site_maps"; + rf.short_name = "site_maps"; + rf.receiver_type = "urllib.robotparser.RobotFileParser"; + cbm_registry_add_func(reg, rf); + /* ===== module: warnings ===== */ memset(&rt, 0, sizeof(rt)); rt.qualified_name = "warnings._OptionError"; rt.short_name = "_OptionError"; - static const char* py_bases_826[] = { "warnings.Exception", NULL }; - rt.embedded_types = py_bases_826; + static const char* py_bases_1040[] = { "warnings.Exception", NULL }; + rt.embedded_types = py_bases_1040; cbm_registry_add_type(reg, rt); - static const char* py_methods_827[] = { "__init__", NULL }; + static const char* py_methods_1041[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "warnings.WarningMessage"; rt.short_name = "WarningMessage"; - rt.method_names = py_methods_827; + rt.method_names = py_methods_1041; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "warnings.WarningMessage.__init__"; rf.short_name = "__init__"; rf.receiver_type = "warnings.WarningMessage"; cbm_registry_add_func(reg, rf); - static const char* py_methods_828[] = { "__init__", "__enter__", "__exit__", NULL }; + static const char* py_methods_1042[] = { "__init__", "__enter__", "__exit__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "warnings.catch_warnings"; rt.short_name = "catch_warnings"; - rt.method_names = py_methods_828; + rt.method_names = py_methods_1042; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "warnings.catch_warnings.__init__"; @@ -19791,11 +23297,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "__exit__"; rf.receiver_type = "warnings.catch_warnings"; cbm_registry_add_func(reg, rf); - static const char* py_methods_829[] = { "__init__", "__call__", NULL }; + static const char* py_methods_1043[] = { "__init__", "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "warnings.deprecated"; rt.short_name = "deprecated"; - rt.method_names = py_methods_829; + rt.method_names = py_methods_1043; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "warnings.deprecated.__init__"; @@ -19837,33 +23343,33 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rt.qualified_name = "weakref.ProxyType"; rt.short_name = "ProxyType"; cbm_registry_add_type(reg, rt); - static const char* py_methods_830[] = { "__call__", NULL }; + static const char* py_methods_1044[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "weakref.ReferenceType"; rt.short_name = "ReferenceType"; - rt.method_names = py_methods_830; + rt.method_names = py_methods_1044; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "weakref.ReferenceType.__call__"; rf.short_name = "__call__"; rf.receiver_type = "weakref.ReferenceType"; cbm_registry_add_func(reg, rf); - static const char* py_methods_831[] = { "__call__", NULL }; + static const char* py_methods_1045[] = { "__call__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "weakref.WeakMethod"; rt.short_name = "WeakMethod"; - rt.method_names = py_methods_831; + rt.method_names = py_methods_1045; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "weakref.WeakMethod.__call__"; rf.short_name = "__call__"; rf.receiver_type = "weakref.WeakMethod"; cbm_registry_add_func(reg, rf); - static const char* py_methods_832[] = { "__init__", "copy", "get", "keys", "values", "items", "itervaluerefs", "valuerefs", "setdefault", "pop", "update", NULL }; + static const char* py_methods_1046[] = { "__init__", "copy", "get", "keys", "values", "items", "itervaluerefs", "valuerefs", "setdefault", "pop", "update", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "weakref.WeakValueDictionary"; rt.short_name = "WeakValueDictionary"; - rt.method_names = py_methods_832; + rt.method_names = py_methods_1046; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "weakref.WeakValueDictionary.__init__"; @@ -19920,22 +23426,22 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "update"; rf.receiver_type = "weakref.WeakValueDictionary"; cbm_registry_add_func(reg, rf); - static const char* py_methods_833[] = { "__init__", NULL }; + static const char* py_methods_1047[] = { "__init__", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "weakref.KeyedRef"; rt.short_name = "KeyedRef"; - rt.method_names = py_methods_833; + rt.method_names = py_methods_1047; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "weakref.KeyedRef.__init__"; rf.short_name = "__init__"; rf.receiver_type = "weakref.KeyedRef"; cbm_registry_add_func(reg, rf); - static const char* py_methods_834[] = { "__init__", "copy", "get", "keys", "values", "items", "keyrefs", "setdefault", "pop", "update", NULL }; + static const char* py_methods_1048[] = { "__init__", "copy", "get", "keys", "values", "items", "keyrefs", "setdefault", "pop", "update", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "weakref.WeakKeyDictionary"; rt.short_name = "WeakKeyDictionary"; - rt.method_names = py_methods_834; + rt.method_names = py_methods_1048; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "weakref.WeakKeyDictionary.__init__"; @@ -19987,11 +23493,11 @@ void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) { rf.short_name = "update"; rf.receiver_type = "weakref.WeakKeyDictionary"; cbm_registry_add_func(reg, rf); - static const char* py_methods_835[] = { "__init__", "__call__", "detach", "peek", "alive", NULL }; + static const char* py_methods_1049[] = { "__init__", "__call__", "detach", "peek", "alive", NULL }; memset(&rt, 0, sizeof(rt)); rt.qualified_name = "weakref.finalize"; rt.short_name = "finalize"; - rt.method_names = py_methods_835; + rt.method_names = py_methods_1049; cbm_registry_add_type(reg, rt); memset(&rf, 0, sizeof(rf)); rf.qualified_name = "weakref.finalize.__init__"; diff --git a/internal/cbm/lsp/py_lsp.c b/internal/cbm/lsp/py_lsp.c index 6e375946..4339a772 100644 --- a/internal/cbm/lsp/py_lsp.c +++ b/internal/cbm/lsp/py_lsp.c @@ -25,6 +25,7 @@ static const CBMRegisteredFunc* py_lookup_attribute(PyLSPContext* ctx, const char* type_qn, const char* member_name); static void py_emit_resolved_call(PyLSPContext* ctx, const char* callee_qn, const char* strategy, float confidence); +static const CBMType* py_resolve_annotation(PyLSPContext* ctx, const char* ann); void py_lsp_init(PyLSPContext* ctx, CBMArena* arena, const char* source, int source_len, const CBMTypeRegistry* registry, const char* module_qn, CBMResolvedCallArray* out) { @@ -81,6 +82,36 @@ static bool import_is_from_style(const char* local_name, const char* module_qn) return true; } +/* For `import a.b.c`, also bind every dotted prefix as MODULE so that + * `a.b.c.fn()` style chained access walks correctly: `a` → MODULE(a), + * `a.b` → MODULE(a.b), `a.b.c` → MODULE(a.b.c). The underlying CBMImport + * already records local_name="c" / module_path="a.b.c"; we walk the + * prefix chain in addition. */ +static void py_bind_dotted_prefixes(PyLSPContext* ctx, const char* qn) { + if (!ctx || !qn) return; + const char* p = qn; + for (;;) { + const char* dot = strchr(p, '.'); + if (!dot) break; + size_t prefix_len = (size_t)(dot - qn); + char* prefix = (char*)cbm_arena_alloc(ctx->arena, prefix_len + 1); + if (!prefix) return; + memcpy(prefix, qn, prefix_len); + prefix[prefix_len] = '\0'; + // Also bind the *short top-level name* — for `import a.b.c`, + // the source typically writes `a.b.c.fn()` and `a` must be in + // scope as MODULE("a") (not the full QN, since attribute access + // walks one segment at a time). + const char* short_name = strrchr(prefix, '.'); + const char* bind_short = short_name ? short_name + 1 : prefix; + if (cbm_type_is_unknown(cbm_scope_lookup(ctx->current_scope, bind_short))) { + cbm_scope_bind(ctx->current_scope, bind_short, + cbm_type_module(ctx->arena, prefix)); + } + p = dot + 1; + } +} + void py_lsp_bind_imports(PyLSPContext* ctx) { if (!ctx || !ctx->current_scope) return; for (int i = 0; i < ctx->import_count; i++) { @@ -104,6 +135,15 @@ void py_lsp_bind_imports(PyLSPContext* ctx) { t = cbm_type_module(ctx->arena, qn); } cbm_scope_bind(ctx->current_scope, local, t); + // Always walk the dotted prefix chain. The CBMImport shape + // can't distinguish `import a.b.c` from `from a.b import c` + // (both produce local_name=c, module_path=a.b.c), but binding + // parent modules (`a`, `a.b`) into scope is correct in both + // cases: in the first form Python actually does this; in the + // second form the parent isn't in scope at runtime, but our + // adding it doesn't cause false positives because real source + // wouldn't reference an unimported parent module name. + py_bind_dotted_prefixes(ctx, qn); } } @@ -194,18 +234,59 @@ static const CBMType* py_literal_type(PyLSPContext* ctx, TSNode node) { return NULL; } -/* If `func_qn` is a registered function, return its return type. */ -static const CBMType* py_func_return_type(PyLSPContext* ctx, const char* func_qn) { +/* Substitute "Self" / "typing.Self" return types with the receiver type. + * Walks the type recursively so `Optional[Self]` becomes `Optional[R]`. */ +static const CBMType* py_substitute_self(PyLSPContext* ctx, const CBMType* t, + const char* receiver_qn) { + if (!t || !receiver_qn) return t; + if (t->kind == CBM_TYPE_NAMED && t->data.named.qualified_name) { + const char* qn = t->data.named.qualified_name; + if (strcmp(qn, "Self") == 0 || strcmp(qn, "typing.Self") == 0 || + strcmp(qn, "typing_extensions.Self") == 0) { + return cbm_type_named(ctx->arena, receiver_qn); + } + } + if (t->kind == CBM_TYPE_UNION) { + int n = t->data.union_type.count; + const CBMType** members = (const CBMType**)cbm_arena_alloc(ctx->arena, + (size_t)(n + 1) * sizeof(const CBMType*)); + if (!members) return t; + for (int i = 0; i < n; i++) { + members[i] = py_substitute_self(ctx, t->data.union_type.members[i], receiver_qn); + } + return cbm_type_union(ctx->arena, members, n); + } + return t; +} + +/* If `func_qn` is a registered function, return its return type. When + * called on a receiver, pass receiver_qn to substitute Self return + * types; pass NULL otherwise. */ +static const CBMType* py_func_return_type_recv(PyLSPContext* ctx, const char* func_qn, + const char* receiver_qn) { if (!ctx || !func_qn) return cbm_type_unknown(); const CBMRegisteredFunc* f = cbm_registry_lookup_func(ctx->registry, func_qn); if (!f || !f->signature) return cbm_type_unknown(); if (f->signature->kind != CBM_TYPE_FUNC) return cbm_type_unknown(); const CBMType** rets = f->signature->data.func.return_types; if (!rets || !rets[0]) return cbm_type_unknown(); - if (!rets[1]) return rets[0]; - int count = 0; - while (rets[count]) count++; - return cbm_type_tuple(ctx->arena, rets, count); + const CBMType* base; + if (!rets[1]) { + base = rets[0]; + } else { + int count = 0; + while (rets[count]) count++; + base = cbm_type_tuple(ctx->arena, rets, count); + } + if (receiver_qn) { + return py_substitute_self(ctx, base, receiver_qn); + } + return base; +} + +/* Convenience wrapper: no receiver substitution. */ +static const CBMType* py_func_return_type(PyLSPContext* ctx, const char* func_qn) { + return py_func_return_type_recv(ctx, func_qn, NULL); } static const CBMType* py_eval_expr_type(PyLSPContext* ctx, TSNode node) { @@ -237,6 +318,7 @@ static const CBMType* py_eval_expr_type(PyLSPContext* ctx, TSNode node) { TSNode attr = ts_node_child_by_field_name(node, "attribute", 9); if (ts_node_is_null(obj) || ts_node_is_null(attr)) return cbm_type_unknown(); const CBMType* obj_type = py_eval_expr_type(ctx, obj); + if (obj_type) obj_type = cbm_type_resolve_alias(obj_type); char* attr_name = py_node_text(ctx, attr); if (!attr_name || !obj_type) return cbm_type_unknown(); @@ -249,12 +331,23 @@ static const CBMType* py_eval_expr_type(PyLSPContext* ctx, TSNode node) { const char* qn = cbm_arena_sprintf(ctx->arena, "%s.%s", mod, attr_name); const CBMRegisteredType* rt = cbm_registry_lookup_type(ctx->registry, qn); if (rt) return cbm_type_named(ctx->arena, qn); + // Submodule: if any registered function/type has qn starting + // with ".." then mod.attr is itself a module. + const char* prefix = cbm_arena_sprintf(ctx->arena, "%s.", qn); + size_t prefix_len = strlen(prefix); + for (int i = 0; i < ctx->registry->func_count; i++) { + const char* fqn = ctx->registry->funcs[i].qualified_name; + if (fqn && strncmp(fqn, prefix, prefix_len) == 0) { + return cbm_type_module(ctx->arena, qn); + } + } return cbm_type_unknown(); } if (obj_type->kind == CBM_TYPE_NAMED) { const CBMRegisteredFunc* f = py_lookup_attribute(ctx, obj_type->data.named.qualified_name, attr_name); - if (f) return py_func_return_type(ctx, f->qualified_name); + if (f) return py_func_return_type_recv(ctx, f->qualified_name, + obj_type->data.named.qualified_name); } return cbm_type_unknown(); } @@ -264,6 +357,45 @@ static const CBMType* py_eval_expr_type(PyLSPContext* ctx, TSNode node) { if (ts_node_is_null(fn)) return cbm_type_unknown(); const char* fk = ts_node_type(fn); + // typing.cast(T, x) -> NAMED(T). typing.assert_type(x, T) -> type-of(x). + // Detect by the call's function expression: matches either bare `cast` / + // `assert_type` (when imported from typing) or `typing.cast` style. + bool is_cast = false; + bool is_assert_type = false; + if (strcmp(fk, "identifier") == 0) { + char* nm = py_node_text(ctx, fn); + if (nm) { + is_cast = strcmp(nm, "cast") == 0; + is_assert_type = strcmp(nm, "assert_type") == 0; + } + } else if (strcmp(fk, "attribute") == 0) { + TSNode aobj = ts_node_child_by_field_name(fn, "object", 6); + TSNode aattr = ts_node_child_by_field_name(fn, "attribute", 9); + if (!ts_node_is_null(aobj) && !ts_node_is_null(aattr) && + strcmp(ts_node_type(aobj), "identifier") == 0) { + char* mod = py_node_text(ctx, aobj); + char* nm = py_node_text(ctx, aattr); + if (mod && nm && strcmp(mod, "typing") == 0) { + is_cast = strcmp(nm, "cast") == 0; + is_assert_type = strcmp(nm, "assert_type") == 0; + } + } + } + if (is_cast || is_assert_type) { + TSNode args = ts_node_child_by_field_name(node, "arguments", 9); + if (!ts_node_is_null(args) && ts_node_named_child_count(args) >= 2) { + if (is_cast) { + TSNode type_arg = ts_node_named_child(args, 0); + char* type_text = py_node_text(ctx, type_arg); + if (type_text) return py_resolve_annotation(ctx, type_text); + } else { + // assert_type(x, T) returns x's type unchanged (it's a no-op). + TSNode val_arg = ts_node_named_child(args, 0); + return py_eval_expr_type(ctx, val_arg); + } + } + } + if (strcmp(fk, "identifier") == 0) { char* fname = py_node_text(ctx, fn); if (!fname) return cbm_type_unknown(); @@ -297,7 +429,8 @@ static const CBMType* py_eval_expr_type(PyLSPContext* ctx, TSNode node) { if (obj_type->kind == CBM_TYPE_NAMED) { const CBMRegisteredFunc* f = py_lookup_attribute(ctx, obj_type->data.named.qualified_name, attr_name); - if (f) return py_func_return_type(ctx, f->qualified_name); + if (f) return py_func_return_type_recv(ctx, f->qualified_name, + obj_type->data.named.qualified_name); } } return cbm_type_unknown(); @@ -531,9 +664,36 @@ static void py_resolve_calls_in(PyLSPContext* ctx, TSNode node) { /* Resolve a type-annotation text into a CBMType. Tries: scope lookup * (for imports / type aliases), module-qualified lookup in the registry, - * then falls back to a bare NAMED. */ + * then falls back to a bare NAMED. Strips quoted forward-reference + * wrappers like `"Foo"` and the surrounding generic-subscript noise + * (`list[int]` -> `list`). */ static const CBMType* py_resolve_annotation(PyLSPContext* ctx, const char* ann) { if (!ann || !ann[0]) return cbm_type_unknown(); + + // Strip outer quotes for forward references: `"Foo"` -> `Foo`. + size_t len = strlen(ann); + if (len >= 2 && (ann[0] == '"' || ann[0] == '\'') && ann[len - 1] == ann[0]) { + char* unquoted = (char*)cbm_arena_alloc(ctx->arena, len - 1); + if (unquoted) { + memcpy(unquoted, ann + 1, len - 2); + unquoted[len - 2] = '\0'; + return py_resolve_annotation(ctx, unquoted); + } + } + + // Strip generic subscript: `list[int]` -> `list`. The element type + // info is lost in v1; full substitution is Phase 8+. + const char* lb = strchr(ann, '['); + if (lb) { + size_t base_len = (size_t)(lb - ann); + char* base = (char*)cbm_arena_alloc(ctx->arena, base_len + 1); + if (base) { + memcpy(base, ann, base_len); + base[base_len] = '\0'; + return py_resolve_annotation(ctx, base); + } + } + const CBMType* t = cbm_scope_lookup(ctx->current_scope, ann); if (!cbm_type_is_unknown(t)) return t; if (ctx->module_qn) { @@ -541,6 +701,14 @@ static const CBMType* py_resolve_annotation(PyLSPContext* ctx, const char* ann) const CBMRegisteredType* rt = cbm_registry_lookup_type(ctx->registry, qn); if (rt) return cbm_type_named(ctx->arena, qn); } + // Common builtin names go to BUILTIN. + static const char* builtins[] = {"int", "str", "bool", "float", "bytes", + "None", "complex", "bytearray", "object", "type", NULL}; + for (int i = 0; builtins[i]; i++) { + if (strcmp(ann, builtins[i]) == 0) { + return cbm_type_builtin(ctx->arena, ann); + } + } return cbm_type_named(ctx->arena, ann); } diff --git a/scripts/gen-py-stdlib.py b/scripts/gen-py-stdlib.py index 22bcfaca..0f0145ca 100755 --- a/scripts/gen-py-stdlib.py +++ b/scripts/gen-py-stdlib.py @@ -72,6 +72,9 @@ ALLOWED_MODULES = { "threading", "multiprocessing", "queue", + "urllib", + "http", + "concurrent", } @@ -143,15 +146,21 @@ def base_qns(class_node: ast.ClassDef, module_qn: str) -> list[str]: return out -def parse_module(path: Path, module_qn: str) -> ModuleStubs: +@dataclasses.dataclass +class StarReExport: + target_module: str # e.g. "posixpath" / "ntpath" + + +def parse_module(path: Path, module_qn: str) -> tuple[ModuleStubs, list[StarReExport]]: src = path.read_text(encoding="utf-8", errors="replace") try: tree = ast.parse(src) except SyntaxError: - return ModuleStubs(module_qn=module_qn, classes=[], functions=[]) + return ModuleStubs(module_qn=module_qn, classes=[], functions=[]), [] classes: list[StubClass] = [] functions: list[StubFunction] = [] + star_imports: list[StarReExport] = [] seen_funcs: set[str] = set() def walk(body: list[ast.stmt], current_module_qn: str) -> None: @@ -176,19 +185,30 @@ def parse_module(path: Path, module_qn: str) -> ModuleStubs: short_name=name, module_qn=current_module_qn, )) + elif isinstance(node, ast.ImportFrom): + # Track `from X import *` for re-export resolution. + if node.module and any(alias.name == "*" for alias in node.names): + star_imports.append(StarReExport(target_module=node.module)) elif isinstance(node, ast.If): # Flatten version guards. walk(node.body, current_module_qn) walk(node.orelse, current_module_qn) walk(tree.body, module_qn) - return ModuleStubs(module_qn=module_qn, classes=classes, functions=functions) + return ModuleStubs(module_qn=module_qn, classes=classes, functions=functions), star_imports -def iter_module_stubs(stdlib_root: Path) -> Iterable[ModuleStubs]: +def collect_all_stubs(stdlib_root: Path) -> tuple[dict[str, ModuleStubs], dict[str, list[StarReExport]]]: + """Gather every stub in the allowlist plus any re-export targets they + pull in transitively (e.g. os.path -> posixpath -> genericpath). + Returns (modules, star_imports_per_module). """ + modules: dict[str, ModuleStubs] = {} + star_imports: dict[str, list[StarReExport]] = {} + + # First pass: walk allowlist + queue: list[tuple[Path, str]] = [] for path in sorted(stdlib_root.rglob("*.pyi")): rel = path.relative_to(stdlib_root) - # Map file path to module qn. parts = list(rel.parts) if parts[-1] == "__init__.pyi": parts.pop() @@ -202,7 +222,80 @@ def iter_module_stubs(stdlib_root: Path) -> Iterable[ModuleStubs]: if top not in ALLOWED_MODULES: continue module_qn = ".".join(parts) - yield parse_module(path, module_qn) + queue.append((path, module_qn)) + + seen_targets: set[str] = set() + while queue: + path, mod_qn = queue.pop() + if mod_qn in modules: + continue + ms, stars = parse_module(path, mod_qn) + modules[mod_qn] = ms + star_imports[mod_qn] = stars + # Enqueue re-export targets (e.g. posixpath, ntpath, genericpath) + for star in stars: + tgt = star.target_module + if tgt in seen_targets: + continue + seen_targets.add(tgt) + tgt_path = stdlib_root / (tgt.replace(".", "/") + ".pyi") + if tgt_path.is_file(): + queue.append((tgt_path, tgt)) + else: + tgt_init = stdlib_root / tgt.replace(".", "/") / "__init__.pyi" + if tgt_init.is_file(): + queue.append((tgt_init, tgt)) + + return modules, star_imports + + +def resolve_reexports(modules: dict[str, ModuleStubs], + star_imports: dict[str, list[StarReExport]]) -> None: + """For each module with `from X import *`, copy X's classes/functions + into the current module under that module's QN. Iterates to a fixed + point to handle re-export chains. """ + changed = True + iter_count = 0 + while changed and iter_count < 8: + changed = False + iter_count += 1 + for mod_qn, stars in star_imports.items(): + ms = modules[mod_qn] + for star in stars: + target = modules.get(star.target_module) + if not target: + continue + # Copy target's classes/functions under mod_qn + existing_class_names = {c.short_name for c in ms.classes} + existing_func_names = {f.short_name for f in ms.functions} + for c in target.classes: + if c.short_name in existing_class_names: + continue + ms.classes.append(StubClass( + qualified_name=f"{mod_qn}.{c.short_name}", + short_name=c.short_name, + methods=list(c.methods), + bases=list(c.bases), + )) + existing_class_names.add(c.short_name) + changed = True + for f in target.functions: + if f.short_name in existing_func_names: + continue + ms.functions.append(StubFunction( + qualified_name=f"{mod_qn}.{f.short_name}", + short_name=f.short_name, + module_qn=mod_qn, + )) + existing_func_names.add(f.short_name) + changed = True + + +def iter_module_stubs(stdlib_root: Path) -> Iterable[ModuleStubs]: + modules, star_imports = collect_all_stubs(stdlib_root) + resolve_reexports(modules, star_imports) + for mod_qn in sorted(modules.keys()): + yield modules[mod_qn] C_HEADER = """\ diff --git a/tests/test_py_lsp.c b/tests/test_py_lsp.c index 3cfe7479..66652a30 100644 --- a/tests/test_py_lsp.c +++ b/tests/test_py_lsp.c @@ -725,6 +725,120 @@ TEST(pylsp_stdlib_logging_getlogger) { PASS(); } +/* ── Round 1 — parity push ────────────────────────────────────── */ + +TEST(pylsp_round1_dotted_import_walk) { + /* `import os.path` — `os` and `os.path` should both be navigable + * through attribute access so `os.path.join('a', 'b')` resolves to + * the registered os.path.join function. */ + CBMFileResult *r = extract_py( + "import os.path\n" + "def use():\n" + " return os.path.join('a', 'b')\n"); + ASSERT_NOT_NULL(r); + int idx = find_resolved(r, "use", "join"); + ASSERT_GTE(idx, 0); + cbm_free_result(r); + PASS(); +} + +TEST(pylsp_round1_typing_cast) { + /* cast(Foo, x) returns NAMED("Foo"), enabling subsequent method + * dispatch to resolve. */ + CBMFileResult *r = extract_py( + "from typing import cast\n" + "class Foo:\n" + " def m(self):\n" + " return 1\n" + "def use(x):\n" + " f = cast(Foo, x)\n" + " return f.m()\n"); + ASSERT_NOT_NULL(r); + ASSERT_GTE(require_resolved(r, "use", "m"), 0); + cbm_free_result(r); + PASS(); +} + +TEST(pylsp_round1_assert_type_passthrough) { + /* assert_type(x, T) is a no-op at runtime; the returned value's type + * is unchanged. We type the result as type-of(x). */ + CBMFileResult *r = extract_py( + "from typing import assert_type\n" + "class Foo:\n" + " def m(self):\n" + " return 1\n" + "def use(x: Foo):\n" + " f = assert_type(x, Foo)\n" + " return f.m()\n"); + ASSERT_NOT_NULL(r); + ASSERT_GTE(require_resolved(r, "use", "m"), 0); + cbm_free_result(r); + PASS(); +} + +TEST(pylsp_round1_forward_reference) { + /* def f(x: "Foo") — quoted annotation must resolve as if unquoted. */ + CBMFileResult *r = extract_py( + "class Foo:\n" + " def m(self):\n" + " return 1\n" + "def use(x: \"Foo\"):\n" + " return x.m()\n"); + ASSERT_NOT_NULL(r); + ASSERT_GTE(require_resolved(r, "use", "m"), 0); + cbm_free_result(r); + PASS(); +} + +TEST(pylsp_round1_self_return_chains) { + /* class Builder: + * def step1(self) -> Self: return self + * def step2(self) -> Self: return self + * def build(self): return ... + * Builder().step1().step2().build() — must chain through Self. */ + CBMFileResult *r = extract_py( + "from typing import Self\n" + "class Builder:\n" + " def step1(self) -> Self:\n" + " return self\n" + " def step2(self) -> Self:\n" + " return self\n" + " def build(self):\n" + " return 1\n" + "def use():\n" + " return Builder().step1().step2().build()\n"); + ASSERT_NOT_NULL(r); + /* Each chain link should resolve. We assert the final .build() does. */ + ASSERT_GTE(require_resolved(r, "use", "build"), 0); + cbm_free_result(r); + PASS(); +} + +TEST(pylsp_round1_generic_subscript_annotation) { + /* `def f(items: list[Foo])` — the generic subscript should not + * confuse annotation resolution; we drop the [Foo] part for v1. */ + CBMFileResult *r = extract_py( + "from typing import Optional\n" + "class Foo:\n" + " def m(self):\n" + " return 1\n" + "def use(x: Optional[Foo]):\n" + " return x.m()\n"); + ASSERT_NOT_NULL(r); + /* x has type Optional which strips to Optional, then we look up + * .m on it. This SHOULD NOT resolve in v1 since Optional is just + * Union — but it shouldn't crash either. We assert no false-positive + * high-confidence resolution against an unrelated method. */ + int idx = find_resolved(r, "use", "m"); + if (idx >= 0) { + const CBMResolvedCall *rc = &r->resolved_calls.items[idx]; + /* If we did resolve, must be against Foo, not something garbage. */ + ASSERT(strstr(rc->callee_qn, "Foo") != NULL); + } + cbm_free_result(r); + PASS(); +} + /* ── Suite ─────────────────────────────────────────────────────── */ SUITE(py_lsp) { @@ -768,4 +882,11 @@ SUITE(py_lsp) { RUN_TEST(pylsp_stdlib_collections_defaultdict); RUN_TEST(pylsp_stdlib_pathlib_path_method); RUN_TEST(pylsp_stdlib_logging_getlogger); + /* Round 1 — parity push */ + RUN_TEST(pylsp_round1_dotted_import_walk); + RUN_TEST(pylsp_round1_typing_cast); + RUN_TEST(pylsp_round1_assert_type_passthrough); + RUN_TEST(pylsp_round1_forward_reference); + RUN_TEST(pylsp_round1_self_return_chains); + RUN_TEST(pylsp_round1_generic_subscript_annotation); }