MOD_INIT_DECL( Crypto$Util ) { #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 static bool _init_done = false; // Packages can be imported recursively in deep executables. if ( _init_done ) { return MOD_RETURN_VALUE( module_Crypto$Util ); } else { _init_done = true; } #endif #ifdef _NUITKA_MODULE // In case of a stand alone extension module, need to call initialization // the init here because that's the first and only time we are going to get // called here. // Initialize the constant values used. _initBuiltinModule(); _initConstants(); // Initialize the compiled types of Nuitka. PyType_Ready( &Nuitka_Generator_Type ); PyType_Ready( &Nuitka_Function_Type ); PyType_Ready( &Nuitka_Method_Type ); PyType_Ready( &Nuitka_Frame_Type ); #if PYTHON_VERSION < 300 initSlotCompare(); #endif patchBuiltinModule(); patchTypeComparison(); #endif #if _MODULE_UNFREEZER registerMetaPathBasedUnfreezer( meta_path_loader_entries ); #endif _initModuleConstants(); _initModuleCodeObjects(); // puts( "in initCrypto$Util" ); // Create the module object first. There are no methods initially, all are // added dynamically in actual code only. Also no "__doc__" is initially // set at this time, as it could not contain NUL characters this way, they // are instead set in early module code. No "self" for modules, we have no // use for it. #if PYTHON_VERSION < 300 module_Crypto$Util = Py_InitModule4( "Crypto.Util", // Module Name NULL, // No methods initially, all are added // dynamically in actual module code only. NULL, // No __doc__ is initially set, as it could // not contain NUL this way, added early in // actual code. NULL, // No self for modules, we don't use it. PYTHON_API_VERSION ); #else module_Crypto$Util = PyModule_Create( &mdef_Crypto$Util ); #endif moduledict_Crypto$Util = (PyDictObject *)((PyModuleObject *)module_Crypto$Util)->md_dict; assertObject( module_Crypto$Util ); // Seems to work for Python2.7 out of the box, but for Python3, the module // doesn't automatically enter "sys.modules", so do it manually. #if PYTHON_VERSION >= 300 { int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_84c8a7acde99de10deb810738421e657, module_Crypto$Util ); assert( r != -1 ); } #endif // For deep importing of a module we need to have "__builtins__", so we set // it ourselves in the same way than CPython does. Note: This must be done // before the frame object is allocated, or else it may fail. PyObject *module_dict = PyModule_GetDict( module_Crypto$Util ); if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL ) { PyObject *value = (PyObject *)builtin_module; // Check if main module, not a dict then. #if !defined(_NUITKA_EXE) || !0 value = PyModule_GetDict( value ); #endif #ifndef __NUITKA_NO_ASSERT__ int res = #endif PyDict_SetItem( module_dict, const_str_plain___builtins__, value ); assert( res == 0 ); } #if PYTHON_VERSION >= 330 #if _MODULE_UNFREEZER PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader ); #else PyDict_SetItem( module_dict, const_str_plain___loader__, Py_None ); #endif #endif // Temp variables if any PyObject *tmp_assign_source_1; PyObject *tmp_assign_source_2; PyObject *tmp_assign_source_3; PyObject *tmp_assign_source_4; PyObject *tmp_assign_source_5; // Module code. tmp_assign_source_1 = const_str_digest_2d19cbaeda533a9f2ae817323976daff; UPDATE_STRING_DICT0( moduledict_Crypto$Util, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); tmp_assign_source_2 = const_str_digest_ede8c8f1dce1a60961ad7994cb95ec71; UPDATE_STRING_DICT0( moduledict_Crypto$Util, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); tmp_assign_source_3 = LIST_COPY( const_list_str_digest_8cacdff8c7fede7c8e3e11000eea2cbe_list ); UPDATE_STRING_DICT1( moduledict_Crypto$Util, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); tmp_assign_source_4 = LIST_COPY( const_list_c9502e80b601e4836ea5b2f226787166_list ); UPDATE_STRING_DICT1( moduledict_Crypto$Util, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_4 ); tmp_assign_source_5 = const_str_digest_e716a6839c8454d1d77f5308c1bdd157; UPDATE_STRING_DICT0( moduledict_Crypto$Util, (Nuitka_StringObject *)const_str_plain___revision__, tmp_assign_source_5 ); return MOD_RETURN_VALUE( module_Crypto$Util ); }
MOD_INIT_DECL( pip$_vendor$requests$packages$urllib3$packages ) { #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 static bool _init_done = false; // Modules might be imported repeatedly, which is to be ignored. if ( _init_done ) { return MOD_RETURN_VALUE( module_pip$_vendor$requests$packages$urllib3$packages ); } else { _init_done = true; } #endif #ifdef _NUITKA_MODULE // In case of a stand alone extension module, need to call initialization // the init here because that's the first and only time we are going to get // called here. // Initialize the constant values used. _initBuiltinModule(); createGlobalConstants(); // Initialize the compiled types of Nuitka. PyType_Ready( &Nuitka_Generator_Type ); PyType_Ready( &Nuitka_Function_Type ); PyType_Ready( &Nuitka_Method_Type ); PyType_Ready( &Nuitka_Frame_Type ); #if PYTHON_VERSION >= 350 PyType_Ready( &Nuitka_Coroutine_Type ); PyType_Ready( &Nuitka_CoroutineWrapper_Type ); #endif #if PYTHON_VERSION < 300 _initSlotCompare(); #endif #if PYTHON_VERSION >= 270 _initSlotIternext(); #endif patchBuiltinModule(); patchTypeComparison(); // Enable meta path based loader if not already done. setupMetaPathBasedLoader(); #if PYTHON_VERSION >= 300 patchInspectModule(); #endif #endif createModuleConstants(); createModuleCodeObjects(); // puts( "in initpip$_vendor$requests$packages$urllib3$packages" ); // Create the module object first. There are no methods initially, all are // added dynamically in actual code only. Also no "__doc__" is initially // set at this time, as it could not contain NUL characters this way, they // are instead set in early module code. No "self" for modules, we have no // use for it. #if PYTHON_VERSION < 300 module_pip$_vendor$requests$packages$urllib3$packages = Py_InitModule4( "pip._vendor.requests.packages.urllib3.packages", // Module Name NULL, // No methods initially, all are added // dynamically in actual module code only. NULL, // No __doc__ is initially set, as it could // not contain NUL this way, added early in // actual code. NULL, // No self for modules, we don't use it. PYTHON_API_VERSION ); #else module_pip$_vendor$requests$packages$urllib3$packages = PyModule_Create( &mdef_pip$_vendor$requests$packages$urllib3$packages ); #endif moduledict_pip$_vendor$requests$packages$urllib3$packages = (PyDictObject *)((PyModuleObject *)module_pip$_vendor$requests$packages$urllib3$packages)->md_dict; CHECK_OBJECT( module_pip$_vendor$requests$packages$urllib3$packages ); // Seems to work for Python2.7 out of the box, but for Python3, the module // doesn't automatically enter "sys.modules", so do it manually. #if PYTHON_VERSION >= 300 { int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_717e0aa5e359f200231896bcbab797ab, module_pip$_vendor$requests$packages$urllib3$packages ); assert( r != -1 ); } #endif // For deep importing of a module we need to have "__builtins__", so we set // it ourselves in the same way than CPython does. Note: This must be done // before the frame object is allocated, or else it may fail. PyObject *module_dict = PyModule_GetDict( module_pip$_vendor$requests$packages$urllib3$packages ); if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL ) { PyObject *value = (PyObject *)builtin_module; // Check if main module, not a dict then. #if !defined(_NUITKA_EXE) || !0 value = PyModule_GetDict( value ); #endif #ifndef __NUITKA_NO_ASSERT__ int res = #endif PyDict_SetItem( module_dict, const_str_plain___builtins__, value ); assert( res == 0 ); } #if PYTHON_VERSION >= 330 PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader ); #endif // Temp variables if any PyObject *exception_type = NULL, *exception_value = NULL; PyTracebackObject *exception_tb = NULL; NUITKA_MAY_BE_UNUSED int exception_lineno = -1; PyObject *tmp_assign_source_1; PyObject *tmp_assign_source_2; PyObject *tmp_assign_source_3; PyObject *tmp_assign_source_4; PyObject *tmp_assign_source_5; PyObject *tmp_assign_source_6; PyObject *tmp_assign_source_7; PyObject *tmp_assign_source_8; PyObject *tmp_import_globals_1; PyObject *tmp_import_name_from_1; PyFrameObject *frame_module; // Module code. tmp_assign_source_1 = Py_None; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); tmp_assign_source_2 = const_str_digest_2fda06de9b427b74c9496097feae88ce; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); tmp_assign_source_3 = LIST_COPY( const_list_str_digest_d3e5a07139fdaf41b1ccc2e249a03040_list ); UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); tmp_assign_source_4 = Py_None; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); tmp_assign_source_5 = const_str_digest_717e0aa5e359f200231896bcbab797ab; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_5 ); tmp_assign_source_6 = PyObject_GetAttrString(PyImport_ImportModule("__future__"), "absolute_import"); UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain_absolute_import, tmp_assign_source_6 ); // Frame without reuse. frame_module = MAKE_MODULE_FRAME( codeobj_690c45c406de567b9656102a490ecf48, module_pip$_vendor$requests$packages$urllib3$packages ); // Push the new frame as the currently active one, and we should be exclusively // owning it. pushFrameStack( frame_module ); assert( Py_REFCNT( frame_module ) == 1 ); #if PYTHON_VERSION >= 340 frame_module->f_executing += 1; #endif // Framed code: tmp_import_globals_1 = ((PyModuleObject *)module_pip$_vendor$requests$packages$urllib3$packages)->md_dict; frame_module->f_lineno = 3; tmp_import_name_from_1 = IMPORT_MODULE( const_str_empty, tmp_import_globals_1, tmp_import_globals_1, const_tuple_str_plain_ssl_match_hostname_tuple, const_int_pos_1 ); if ( tmp_import_name_from_1 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 3; goto frame_exception_exit_1; } tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_ssl_match_hostname ); Py_DECREF( tmp_import_name_from_1 ); if ( tmp_assign_source_7 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 3; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain_ssl_match_hostname, tmp_assign_source_7 ); // Restore frame exception if necessary. #if 0 RESTORE_FRAME_EXCEPTION( frame_module ); #endif popFrameStack(); assertFrameObject( frame_module ); Py_DECREF( frame_module ); goto frame_no_exception_1; frame_exception_exit_1:; #if 0 RESTORE_FRAME_EXCEPTION( frame_module ); #endif if ( exception_tb == NULL ) { exception_tb = MAKE_TRACEBACK( frame_module, exception_lineno ); } else if ( exception_tb->tb_frame != frame_module ) { PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_module, exception_lineno ); traceback_new->tb_next = exception_tb; exception_tb = traceback_new; } // Put the previous frame back on top. popFrameStack(); #if PYTHON_VERSION >= 340 frame_module->f_executing -= 1; #endif Py_DECREF( frame_module ); // Return the error. goto module_exception_exit; frame_no_exception_1:; tmp_assign_source_8 = const_tuple_str_plain_ssl_match_hostname_tuple; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_8 ); return MOD_RETURN_VALUE( module_pip$_vendor$requests$packages$urllib3$packages ); module_exception_exit: RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); return MOD_RETURN_VALUE( NULL ); }
MOD_INIT_DECL( Crypto$Random$OSRNG ) { #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 static bool _init_done = false; // Packages can be imported recursively in deep executables. if ( _init_done ) { return MOD_RETURN_VALUE( module_Crypto$Random$OSRNG ); } else { _init_done = true; } #endif #ifdef _NUITKA_MODULE // In case of a stand alone extension module, need to call initialization // the init here because that's the first and only time we are going to get // called here. // Initialize the constant values used. _initBuiltinModule(); _initConstants(); // Initialize the compiled types of Nuitka. PyType_Ready( &Nuitka_Generator_Type ); PyType_Ready( &Nuitka_Function_Type ); PyType_Ready( &Nuitka_Method_Type ); PyType_Ready( &Nuitka_Frame_Type ); #if PYTHON_VERSION < 300 initSlotCompare(); #endif patchBuiltinModule(); patchTypeComparison(); #endif #if _MODULE_UNFREEZER registerMetaPathBasedUnfreezer( meta_path_loader_entries ); #endif _initModuleConstants(); _initModuleCodeObjects(); // puts( "in initCrypto$Random$OSRNG" ); // Create the module object first. There are no methods initially, all are // added dynamically in actual code only. Also no "__doc__" is initially // set at this time, as it could not contain NUL characters this way, they // are instead set in early module code. No "self" for modules, we have no // use for it. #if PYTHON_VERSION < 300 module_Crypto$Random$OSRNG = Py_InitModule4( "Crypto.Random.OSRNG", // Module Name NULL, // No methods initially, all are added // dynamically in actual module code only. NULL, // No __doc__ is initially set, as it could // not contain NUL this way, added early in // actual code. NULL, // No self for modules, we don't use it. PYTHON_API_VERSION ); #else module_Crypto$Random$OSRNG = PyModule_Create( &mdef_Crypto$Random$OSRNG ); #endif moduledict_Crypto$Random$OSRNG = (PyDictObject *)((PyModuleObject *)module_Crypto$Random$OSRNG)->md_dict; assertObject( module_Crypto$Random$OSRNG ); // Seems to work for Python2.7 out of the box, but for Python3, the module // doesn't automatically enter "sys.modules", so do it manually. #if PYTHON_VERSION >= 300 { int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_bc407d35a8cca84be9184e875aad04dc, module_Crypto$Random$OSRNG ); assert( r != -1 ); } #endif // For deep importing of a module we need to have "__builtins__", so we set // it ourselves in the same way than CPython does. Note: This must be done // before the frame object is allocated, or else it may fail. PyObject *module_dict = PyModule_GetDict( module_Crypto$Random$OSRNG ); if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL ) { PyObject *value = (PyObject *)builtin_module; // Check if main module, not a dict then. #if !defined(_NUITKA_EXE) || !0 value = PyModule_GetDict( value ); #endif #ifndef __NUITKA_NO_ASSERT__ int res = #endif PyDict_SetItem( module_dict, const_str_plain___builtins__, value ); assert( res == 0 ); } #if PYTHON_VERSION >= 330 #if _MODULE_UNFREEZER PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader ); #else PyDict_SetItem( module_dict, const_str_plain___loader__, Py_None ); #endif #endif // Temp variables if any PyObject *exception_type, *exception_value; PyTracebackObject *exception_tb; PyObject *tmp_assign_source_1; PyObject *tmp_assign_source_2; PyObject *tmp_assign_source_3; PyObject *tmp_assign_source_4; PyObject *tmp_assign_source_5; PyObject *tmp_assign_source_6; PyObject *tmp_assign_source_7; PyObject *tmp_assign_source_8; int tmp_cmp_Eq_1; int tmp_cmp_Eq_2; PyObject *tmp_compare_left_1; PyObject *tmp_compare_left_2; PyObject *tmp_compare_right_1; PyObject *tmp_compare_right_2; PyObject *tmp_hasattr_attr_1; PyObject *tmp_hasattr_source_1; PyObject *tmp_import_globals_1; PyObject *tmp_import_globals_2; PyObject *tmp_import_globals_3; PyObject *tmp_import_globals_4; PyObject *tmp_import_name_from_1; PyObject *tmp_import_name_from_2; PyObject *tmp_import_name_from_3; PyObject *tmp_make_exception_arg_1; PyObject *tmp_raise_type_1; int tmp_res; PyObject *tmp_source_name_1; PyObject *tmp_source_name_2; // Module code. tmp_assign_source_1 = const_str_digest_f01c2b13d766443866465debfd607d0e; UPDATE_STRING_DICT0( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); tmp_assign_source_2 = const_str_digest_ff978bc30768b4bce0b5b1f0a5855595; UPDATE_STRING_DICT0( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); tmp_assign_source_3 = LIST_COPY( const_list_str_digest_a10cd80b314d8fd7184d913c98d61dfa_list ); UPDATE_STRING_DICT1( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); tmp_assign_source_4 = const_str_digest_e716a6839c8454d1d77f5308c1bdd157; UPDATE_STRING_DICT0( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain___revision__, tmp_assign_source_4 ); // Frame without reuse. PyFrameObject *frame_module = MAKE_FRAME( codeobj_c96d8313b82a8f9bc4e63bebe63be847, module_Crypto$Random$OSRNG ); // Push the new frame as the currently active one, and we should be exlusively // owning it. pushFrameStack( frame_module ); assert( Py_REFCNT( frame_module ) == 1 ); #if PYTHON_VERSION >= 340 frame_module->f_executing += 1; #endif // Framed code: tmp_import_globals_1 = ((PyModuleObject *)module_Crypto$Random$OSRNG)->md_dict; frame_module->f_lineno = 29; tmp_assign_source_5 = IMPORT_MODULE( const_str_plain_os, tmp_import_globals_1, tmp_import_globals_1, Py_None, const_int_neg_1 ); if ( tmp_assign_source_5 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 29; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_os, tmp_assign_source_5 ); tmp_source_name_1 = GET_STRING_DICT_VALUE( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_os ); if (unlikely( tmp_source_name_1 == NULL )) { tmp_source_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); } if ( tmp_source_name_1 == NULL ) { exception_type = INCREASE_REFCOUNT( PyExc_NameError ); exception_value = UNSTREAM_STRING( &constant_bin[ 7477 ], 24, 0 ); exception_tb = NULL; frame_module->f_lineno = 31; goto frame_exception_exit_1; } tmp_compare_left_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_name ); if ( tmp_compare_left_1 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 31; goto frame_exception_exit_1; } tmp_compare_right_1 = const_str_plain_posix; tmp_cmp_Eq_1 = RICH_COMPARE_BOOL_EQ_NORECURSE( tmp_compare_left_1, tmp_compare_right_1 ); if ( tmp_cmp_Eq_1 == -1 ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); Py_DECREF( tmp_compare_left_1 ); frame_module->f_lineno = 31; goto frame_exception_exit_1; } Py_DECREF( tmp_compare_left_1 ); if (tmp_cmp_Eq_1 == 1) { goto branch_yes_1; } else { goto branch_no_1; } branch_yes_1:; tmp_import_globals_2 = ((PyModuleObject *)module_Crypto$Random$OSRNG)->md_dict; frame_module->f_lineno = 32; tmp_import_name_from_1 = IMPORT_MODULE( const_str_digest_c36bc412b01c803f6316b97c4821aeff, tmp_import_globals_2, tmp_import_globals_2, const_tuple_str_plain_new_tuple, const_int_neg_1 ); if ( tmp_import_name_from_1 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 32; goto frame_exception_exit_1; } tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_new ); Py_DECREF( tmp_import_name_from_1 ); if ( tmp_assign_source_6 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 32; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_new, tmp_assign_source_6 ); goto branch_end_1; branch_no_1:; tmp_source_name_2 = GET_STRING_DICT_VALUE( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_os ); if (unlikely( tmp_source_name_2 == NULL )) { tmp_source_name_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); } if ( tmp_source_name_2 == NULL ) { exception_type = INCREASE_REFCOUNT( PyExc_NameError ); exception_value = UNSTREAM_STRING( &constant_bin[ 7477 ], 24, 0 ); exception_tb = NULL; frame_module->f_lineno = 33; goto frame_exception_exit_1; } tmp_compare_left_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_name ); if ( tmp_compare_left_2 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 33; goto frame_exception_exit_1; } tmp_compare_right_2 = const_str_plain_nt; tmp_cmp_Eq_2 = RICH_COMPARE_BOOL_EQ_NORECURSE( tmp_compare_left_2, tmp_compare_right_2 ); if ( tmp_cmp_Eq_2 == -1 ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); Py_DECREF( tmp_compare_left_2 ); frame_module->f_lineno = 33; goto frame_exception_exit_1; } Py_DECREF( tmp_compare_left_2 ); if (tmp_cmp_Eq_2 == 1) { goto branch_yes_2; } else { goto branch_no_2; } branch_yes_2:; tmp_import_globals_3 = ((PyModuleObject *)module_Crypto$Random$OSRNG)->md_dict; frame_module->f_lineno = 34; tmp_import_name_from_2 = IMPORT_MODULE( const_str_digest_06dd65564ea0dd8766c2222a8271160e, tmp_import_globals_3, tmp_import_globals_3, const_tuple_str_plain_new_tuple, const_int_neg_1 ); if ( tmp_import_name_from_2 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 34; goto frame_exception_exit_1; } tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_new ); Py_DECREF( tmp_import_name_from_2 ); if ( tmp_assign_source_7 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 34; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_new, tmp_assign_source_7 ); goto branch_end_2; branch_no_2:; tmp_hasattr_source_1 = GET_STRING_DICT_VALUE( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_os ); if (unlikely( tmp_hasattr_source_1 == NULL )) { tmp_hasattr_source_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); } if ( tmp_hasattr_source_1 == NULL ) { exception_type = INCREASE_REFCOUNT( PyExc_NameError ); exception_value = UNSTREAM_STRING( &constant_bin[ 7477 ], 24, 0 ); exception_tb = NULL; frame_module->f_lineno = 35; goto frame_exception_exit_1; } tmp_hasattr_attr_1 = const_str_plain_urandom; tmp_res = PyObject_HasAttr( tmp_hasattr_source_1, tmp_hasattr_attr_1 ); if ( tmp_res == -1 ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 35; goto frame_exception_exit_1; } if (tmp_res == 1) { goto branch_yes_3; } else { goto branch_no_3; } branch_yes_3:; tmp_import_globals_4 = ((PyModuleObject *)module_Crypto$Random$OSRNG)->md_dict; frame_module->f_lineno = 36; tmp_import_name_from_3 = IMPORT_MODULE( const_str_digest_623da4fa9a2ac5457959104e083f5513, tmp_import_globals_4, tmp_import_globals_4, const_tuple_str_plain_new_tuple, const_int_neg_1 ); if ( tmp_import_name_from_3 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 36; goto frame_exception_exit_1; } tmp_assign_source_8 = IMPORT_NAME( tmp_import_name_from_3, const_str_plain_new ); Py_DECREF( tmp_import_name_from_3 ); if ( tmp_assign_source_8 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 36; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_Crypto$Random$OSRNG, (Nuitka_StringObject *)const_str_plain_new, tmp_assign_source_8 ); goto branch_end_3; branch_no_3:; tmp_make_exception_arg_1 = const_str_digest_d0d695099e39173eb72601dce2dbb05f; frame_module->f_lineno = 38; tmp_raise_type_1 = CALL_FUNCTION_WITH_ARGS1( PyExc_ImportError, tmp_make_exception_arg_1 ); if ( tmp_raise_type_1 == NULL ) { assert( ERROR_OCCURED() ); PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb ); frame_module->f_lineno = 38; goto frame_exception_exit_1; } exception_type = tmp_raise_type_1; frame_module->f_lineno = 38; RAISE_EXCEPTION_WITH_TYPE( &exception_type, &exception_value, &exception_tb ); goto frame_exception_exit_1; branch_end_3:; branch_end_2:; branch_end_1:; // Restore frame exception if necessary. #if 0 RESTORE_FRAME_EXCEPTION( frame_module ); #endif popFrameStack(); assertFrameObject( frame_module ); Py_DECREF( frame_module ); goto frame_no_exception_1; frame_exception_exit_1:; #if 0 RESTORE_FRAME_EXCEPTION( frame_module ); #endif if ( exception_tb == NULL ) { exception_tb = MAKE_TRACEBACK( INCREASE_REFCOUNT( frame_module ) ); } else if ( exception_tb->tb_frame != frame_module ) { PyTracebackObject *traceback_new = (PyTracebackObject *)MAKE_TRACEBACK( INCREASE_REFCOUNT( frame_module ) ); traceback_new->tb_next = exception_tb; exception_tb = traceback_new; } // Put the previous frame back on top. popFrameStack(); #if PYTHON_VERSION >= 340 frame_module->f_executing -= 1; #endif Py_DECREF( frame_module ); // Return the error. goto module_exception_exit; frame_no_exception_1:; return MOD_RETURN_VALUE( module_Crypto$Random$OSRNG ); module_exception_exit: PyErr_Restore( exception_type, exception_value, (PyObject *)exception_tb ); return MOD_RETURN_VALUE( NULL ); }
MOD_INIT_DECL( pyasn1$codec ) { #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 static bool _init_done = false; // Modules might be imported repeatedly, which is to be ignored. if ( _init_done ) { return MOD_RETURN_VALUE( module_pyasn1$codec ); } else { _init_done = true; } #endif #ifdef _NUITKA_MODULE // In case of a stand alone extension module, need to call initialization // the init here because that's the first and only time we are going to get // called here. // Initialize the constant values used. _initBuiltinModule(); createGlobalConstants(); // Initialize the compiled types of Nuitka. PyType_Ready( &Nuitka_Generator_Type ); PyType_Ready( &Nuitka_Function_Type ); PyType_Ready( &Nuitka_Method_Type ); PyType_Ready( &Nuitka_Frame_Type ); #if PYTHON_VERSION >= 350 PyType_Ready( &Nuitka_Coroutine_Type ); PyType_Ready( &Nuitka_CoroutineWrapper_Type ); #endif #if PYTHON_VERSION < 300 _initSlotCompare(); #endif #if PYTHON_VERSION >= 270 _initSlotIternext(); #endif patchBuiltinModule(); patchTypeComparison(); // Enable meta path based loader if not already done. setupMetaPathBasedLoader(); #if PYTHON_VERSION >= 300 patchInspectModule(); #endif #endif createModuleConstants(); createModuleCodeObjects(); // puts( "in initpyasn1$codec" ); // Create the module object first. There are no methods initially, all are // added dynamically in actual code only. Also no "__doc__" is initially // set at this time, as it could not contain NUL characters this way, they // are instead set in early module code. No "self" for modules, we have no // use for it. #if PYTHON_VERSION < 300 module_pyasn1$codec = Py_InitModule4( "pyasn1.codec", // Module Name NULL, // No methods initially, all are added // dynamically in actual module code only. NULL, // No __doc__ is initially set, as it could // not contain NUL this way, added early in // actual code. NULL, // No self for modules, we don't use it. PYTHON_API_VERSION ); #else module_pyasn1$codec = PyModule_Create( &mdef_pyasn1$codec ); #endif moduledict_pyasn1$codec = (PyDictObject *)((PyModuleObject *)module_pyasn1$codec)->md_dict; CHECK_OBJECT( module_pyasn1$codec ); // Seems to work for Python2.7 out of the box, but for Python3, the module // doesn't automatically enter "sys.modules", so do it manually. #if PYTHON_VERSION >= 300 { int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_8515a8a9f705886c1e2334d53684c902, module_pyasn1$codec ); assert( r != -1 ); } #endif // For deep importing of a module we need to have "__builtins__", so we set // it ourselves in the same way than CPython does. Note: This must be done // before the frame object is allocated, or else it may fail. PyObject *module_dict = PyModule_GetDict( module_pyasn1$codec ); if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL ) { PyObject *value = (PyObject *)builtin_module; // Check if main module, not a dict then. #if !defined(_NUITKA_EXE) || !0 value = PyModule_GetDict( value ); #endif #ifndef __NUITKA_NO_ASSERT__ int res = #endif PyDict_SetItem( module_dict, const_str_plain___builtins__, value ); assert( res == 0 ); } #if PYTHON_VERSION >= 330 PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader ); #endif // Temp variables if any PyObject *tmp_assign_source_1; PyObject *tmp_assign_source_2; PyObject *tmp_assign_source_3; PyObject *tmp_assign_source_4; PyObject *tmp_assign_source_5; // Module code. tmp_assign_source_1 = Py_None; UPDATE_STRING_DICT0( moduledict_pyasn1$codec, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); tmp_assign_source_2 = const_str_digest_3550c60f26c9e320d3e5c33f2ce0a399; UPDATE_STRING_DICT0( moduledict_pyasn1$codec, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); tmp_assign_source_3 = LIST_COPY( const_list_str_digest_3bd5a84505d22b063fd96ccc13cc7af1_list ); UPDATE_STRING_DICT1( moduledict_pyasn1$codec, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); tmp_assign_source_4 = Py_None; UPDATE_STRING_DICT0( moduledict_pyasn1$codec, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); tmp_assign_source_5 = const_str_digest_8515a8a9f705886c1e2334d53684c902; UPDATE_STRING_DICT0( moduledict_pyasn1$codec, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_5 ); return MOD_RETURN_VALUE( module_pyasn1$codec ); }
MOD_INIT_DECL( Crypto$Hash ) { #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 static bool _init_done = false; // Packages can be imported recursively in deep executables. if ( _init_done ) { return MOD_RETURN_VALUE( module_Crypto$Hash ); } else { _init_done = true; } #endif #ifdef _NUITKA_MODULE // In case of a stand alone extension module, need to call initialization // the init here because that's the first and only time we are going to get // called here. // Initialize the constant values used. _initBuiltinModule(); _initConstants(); // Initialize the compiled types of Nuitka. PyType_Ready( &Nuitka_Generator_Type ); PyType_Ready( &Nuitka_Function_Type ); PyType_Ready( &Nuitka_Method_Type ); PyType_Ready( &Nuitka_Frame_Type ); #if PYTHON_VERSION < 300 initSlotCompare(); #endif patchBuiltinModule(); patchTypeComparison(); #endif #if _MODULE_UNFREEZER registerMetaPathBasedUnfreezer( meta_path_loader_entries ); #endif _initModuleConstants(); _initModuleCodeObjects(); // puts( "in initCrypto$Hash" ); // Create the module object first. There are no methods initially, all are // added dynamically in actual code only. Also no "__doc__" is initially // set at this time, as it could not contain NUL characters this way, they // are instead set in early module code. No "self" for modules, we have no // use for it. #if PYTHON_VERSION < 300 module_Crypto$Hash = Py_InitModule4( "Crypto.Hash", // Module Name NULL, // No methods initially, all are added // dynamically in actual module code only. NULL, // No __doc__ is initially set, as it could // not contain NUL this way, added early in // actual code. NULL, // No self for modules, we don't use it. PYTHON_API_VERSION ); #else module_Crypto$Hash = PyModule_Create( &mdef_Crypto$Hash ); #endif moduledict_Crypto$Hash = (PyDictObject *)((PyModuleObject *)module_Crypto$Hash)->md_dict; assertObject( module_Crypto$Hash ); // Seems to work for Python2.7 out of the box, but for Python3, the module // doesn't automatically enter "sys.modules", so do it manually. #if PYTHON_VERSION >= 300 { int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_e6129b07f0a1ca583ba0c8c51f588cf4, module_Crypto$Hash ); assert( r != -1 ); } #endif // For deep importing of a module we need to have "__builtins__", so we set // it ourselves in the same way than CPython does. Note: This must be done // before the frame object is allocated, or else it may fail. PyObject *module_dict = PyModule_GetDict( module_Crypto$Hash ); if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL ) { PyObject *value = (PyObject *)builtin_module; // Check if main module, not a dict then. #if !defined(_NUITKA_EXE) || !0 value = PyModule_GetDict( value ); #endif #ifndef __NUITKA_NO_ASSERT__ int res = #endif PyDict_SetItem( module_dict, const_str_plain___builtins__, value ); assert( res == 0 ); } #if PYTHON_VERSION >= 330 #if _MODULE_UNFREEZER PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader ); #else PyDict_SetItem( module_dict, const_str_plain___loader__, Py_None ); #endif #endif // Temp variables if any PyObject *tmp_assign_source_1; PyObject *tmp_assign_source_2; PyObject *tmp_assign_source_3; PyObject *tmp_assign_source_4; PyObject *tmp_assign_source_5; // Module code. tmp_assign_source_1 = const_str_digest_dcaec65e2a095f43119358c6af5d8a24; UPDATE_STRING_DICT0( moduledict_Crypto$Hash, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); tmp_assign_source_2 = const_str_digest_64268c88f656906772b3f3619ec028e3; UPDATE_STRING_DICT0( moduledict_Crypto$Hash, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); tmp_assign_source_3 = LIST_COPY( const_list_str_digest_343b1d35f10c9e72cd840a07f7ee8e41_list ); UPDATE_STRING_DICT1( moduledict_Crypto$Hash, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); tmp_assign_source_4 = LIST_COPY( const_list_7ed8a6a1a45650b7cd3631c0cf0d9f4d_list ); UPDATE_STRING_DICT1( moduledict_Crypto$Hash, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_4 ); tmp_assign_source_5 = const_str_digest_e716a6839c8454d1d77f5308c1bdd157; UPDATE_STRING_DICT0( moduledict_Crypto$Hash, (Nuitka_StringObject *)const_str_plain___revision__, tmp_assign_source_5 ); return MOD_RETURN_VALUE( module_Crypto$Hash ); }