Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -0,0 +1,710 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Main module code templates
+
+This for the main program in case of executables, the module templates and
+stuff related to importing, and of course the generated code license.
+
+"""
+
+template_global_copyright = """\
+/* Generated code for Python module '%(module_identifier)s'
+ * created by Nuitka version %(version)s
+ *
+ * This code is in part copyright %(year)s Kay Hayen.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"""
+
+template_module_body_template = r"""
+#include "nuitka/prelude.h"
+
+#include "nuitka/unfreezing.h"
+
+#include "__helpers.h"
+
+/* The "module_%(module_identifier)s" is a Python object pointer of module type.
+ *
+ * Note: For full compatibility with CPython, every module variable access
+ * needs to go through it except for cases where the module cannot possibly
+ * have changed in the mean time.
+ */
+
+PyObject *module_%(module_identifier)s;
+PyDictObject *moduledict_%(module_identifier)s;
+
+/* The declarations of module constants used, if any. */
+static PyObject *mod_consts[%(constants_count)d];
+#ifndef __NUITKA_NO_ASSERT__
+static Py_hash_t mod_consts_hash[%(constants_count)d];
+#endif
+
+static PyObject *module_filename_obj = NULL;
+
+/* Indicator if this modules private constants were created yet. */
+static bool constants_created = false;
+
+/* Function to create module private constants. */
+static void createModuleConstants(PyThreadState *tstate) {
+    if (constants_created == false) {
+        loadConstantsBlob(tstate, &mod_consts[0], UN_TRANSLATE(%(module_const_blob_name)s));
+        constants_created = true;
+
+#ifndef __NUITKA_NO_ASSERT__
+        for (int i = 0; i < %(constants_count)d; i++) {
+            mod_consts_hash[i] = DEEP_HASH(tstate, mod_consts[i]);
+        }
+#endif
+    }
+}
+
+// We want to be able to initialize the "__main__" constants in any case.
+#if %(is_dunder_main)s
+void createMainModuleConstants(PyThreadState *tstate) {
+    createModuleConstants(tstate);
+}
+#endif
+
+/* Function to verify module private constants for non-corruption. */
+#ifndef __NUITKA_NO_ASSERT__
+void checkModuleConstants_%(module_identifier)s(PyThreadState *tstate) {
+    // The module may not have been used at all, then ignore this.
+    if (constants_created == false) return;
+
+    for (int i = 0; i < %(constants_count)d; i++) {
+        assert(mod_consts_hash[i] == DEEP_HASH(tstate, mod_consts[i]));
+        CHECK_OBJECT_DEEP(mod_consts[i]);
+    }
+}
+#endif
+
+// Helper to preserving module variables for Python3.11+
+#if %(module_variable_accessors_count)d
+#if PYTHON_VERSION >= 0x3c0
+NUITKA_MAY_BE_UNUSED static uint32_t _Nuitka_PyDictKeys_GetVersionForCurrentState(PyInterpreterState *interp, PyDictKeysObject *dk)
+{
+    if (dk->dk_version != 0) {
+        return dk->dk_version;
+    }
+    uint32_t result = interp->dict_state.next_keys_version++;
+    dk->dk_version = result;
+    return result;
+}
+#elif PYTHON_VERSION >= 0x3b0
+static uint32_t _Nuitka_next_dict_keys_version = 2;
+
+NUITKA_MAY_BE_UNUSED static uint32_t _Nuitka_PyDictKeys_GetVersionForCurrentState(PyDictKeysObject *dk)
+{
+    if (dk->dk_version != 0) {
+        return dk->dk_version;
+    }
+    uint32_t result = _Nuitka_next_dict_keys_version++;
+    dk->dk_version = result;
+    return result;
+}
+#endif
+#endif
+
+// Accessors to module variables.
+%(module_variable_accessors)s
+
+#if !defined(_NUITKA_EXPERIMENTAL_NEW_CODE_OBJECTS)
+// The module code objects.
+%(module_code_objects_decl)s
+
+static void createModuleCodeObjects(void) {
+%(module_code_objects_init)s
+}
+#endif
+
+// The module function declarations.
+%(module_functions_decl)s
+
+// The module function definitions.
+%(module_functions_code)s
+
+extern void _initCompiledCellType();
+extern void _initCompiledGeneratorType();
+extern void _initCompiledFunctionType();
+extern void _initCompiledMethodType();
+extern void _initCompiledFrameType();
+
+extern PyTypeObject Nuitka_Loader_Type;
+
+#ifdef _NUITKA_PLUGIN_DILL_ENABLED
+// Provide a way to create find a function via its C code and create it back
+// in another process, useful for multiprocessing extensions like dill
+extern void registerDillPluginTables(PyThreadState *tstate, char const *module_name, PyMethodDef *reduce_compiled_function, PyMethodDef *create_compiled_function);
+
+static function_impl_code const function_table_%(module_identifier)s[] = {
+%(module_function_table_entries)s
+    NULL
+};
+
+static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
+    PyObject *func;
+
+    if (!PyArg_ParseTuple(args, "O:reduce_compiled_function", &func, NULL)) {
+        return NULL;
+    }
+
+    if (Nuitka_Function_Check(func) == false) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "not a compiled function");
+        return NULL;
+    }
+
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)func;
+
+    return Nuitka_Function_GetFunctionState(function, function_table_%(module_identifier)s);
+}
+
+static PyMethodDef _method_def_reduce_compiled_function = {"reduce_compiled_function", (PyCFunction)_reduce_compiled_function,
+                                                           METH_VARARGS, NULL};
+
+
+static PyObject *_create_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
+    CHECK_OBJECT_DEEP(args);
+
+    PyObject *function_index;
+    PyObject *code_object_desc;
+    PyObject *defaults;
+    PyObject *kw_defaults;
+    PyObject *doc;
+    PyObject *constant_return_value;
+    PyObject *function_qualname;
+    PyObject *closure;
+    PyObject *annotations;
+    PyObject *func_dict;
+
+    if (!PyArg_ParseTuple(args, "OOOOOOOOOO:create_compiled_function", &function_index, &code_object_desc, &defaults, &kw_defaults, &doc, &constant_return_value, &function_qualname, &closure, &annotations, &func_dict, NULL)) {
+        return NULL;
+    }
+
+    return (PyObject *)Nuitka_Function_CreateFunctionViaCodeIndex(
+        module_%(module_identifier)s,
+        function_qualname,
+        function_index,
+        code_object_desc,
+        constant_return_value,
+        defaults,
+        kw_defaults,
+        doc,
+        closure,
+        annotations,
+        func_dict,
+        function_table_%(module_identifier)s,
+        sizeof(function_table_%(module_identifier)s) / sizeof(function_impl_code)
+    );
+}
+
+static PyMethodDef _method_def_create_compiled_function = {
+    "create_compiled_function",
+    (PyCFunction)_create_compiled_function,
+    METH_VARARGS, NULL
+};
+
+
+#endif
+
+// Actual name might be different when loaded as a package.
+#if _NUITKA_MODULE_MODE && %(is_top)d
+static char const *module_full_name = %(module_name_cstr)s;
+#endif
+
+// Internal entry point for module code.
+PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *module, struct Nuitka_MetaPathBasedLoaderEntry const *loader_entry) {
+    // Report entry to PGO.
+    PGO_onModuleEntered("%(module_identifier)s");
+
+    // Store the module for future use.
+    module_%(module_identifier)s = module;
+
+    moduledict_%(module_identifier)s = MODULE_DICT(module_%(module_identifier)s);
+
+    // Modules can be loaded again in case of errors, avoid the init being done again.
+    static bool init_done = false;
+
+    if (init_done == false) {
+#if _NUITKA_MODULE_MODE && %(is_top)d
+        // In case of an extension module loaded into a process, we need to call
+        // initialization here because that's the first and potentially only time
+        // we are going called.
+#if PYTHON_VERSION > 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+        initNuitkaAllocators();
+#endif
+        // Initialize the constant values used.
+        _initBuiltinModule();
+
+        PyObject *real_module_name = PyObject_GetAttrString(module, "__name__");
+        CHECK_OBJECT(real_module_name);
+        module_full_name = strdup(Nuitka_String_AsString(real_module_name));
+
+        createGlobalConstants(tstate, real_module_name);
+
+        /* Initialize the compiled types of Nuitka. */
+        _initCompiledCellType();
+        _initCompiledGeneratorType();
+        _initCompiledFunctionType();
+        _initCompiledMethodType();
+        _initCompiledFrameType();
+
+        _initSlotCompare();
+#if PYTHON_VERSION >= 0x270
+        _initSlotIterNext();
+#endif
+
+        patchTypeComparison();
+
+        // Enable meta path based loader if not already done.
+#ifdef _NUITKA_TRACE
+        PRINT_STRING("%(module_identifier)s: Calling setupMetaPathBasedLoader().\n");
+#endif
+        setupMetaPathBasedLoader(tstate);
+#if %(module_def_size)s >= 0
+#ifdef _NUITKA_TRACE
+        PRINT_STRING("%(module_identifier)s: Calling updateMetaPathBasedLoaderModuleRoot().\n");
+#endif
+        updateMetaPathBasedLoaderModuleRoot(module_full_name);
+#endif
+
+
+#if PYTHON_VERSION >= 0x300
+        patchInspectModule(tstate);
+#endif
+
+#endif
+
+        /* The constants only used by this module are created now. */
+        NUITKA_PRINT_TRACE("%(module_identifier)s: Calling createModuleConstants().\n");
+        createModuleConstants(tstate);
+
+#if !defined(_NUITKA_EXPERIMENTAL_NEW_CODE_OBJECTS)
+        createModuleCodeObjects();
+#endif
+        init_done = true;
+    }
+
+#if _NUITKA_MODULE_MODE && %(is_top)d
+    PyObject *pre_load = IMPORT_EMBEDDED_MODULE(tstate, %(module_name_cstr)s "-preLoad");
+    if (pre_load == NULL) {
+        return NULL;
+    }
+#endif
+
+    // PRINT_STRING("in init%(module_identifier)s\n");
+
+#ifdef _NUITKA_PLUGIN_DILL_ENABLED
+    {
+        char const *module_name_c;
+        if (loader_entry != NULL) {
+            module_name_c = loader_entry->name;
+        } else {
+            PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+            module_name_c = Nuitka_String_AsString(module_name);
+        }
+
+        registerDillPluginTables(tstate, module_name_c, &_method_def_reduce_compiled_function, &_method_def_create_compiled_function);
+    }
+#endif
+
+    // Set "__compiled__" to what version information we have.
+    UPDATE_STRING_DICT0(
+        moduledict_%(module_identifier)s,
+        (Nuitka_StringObject *)const_str_plain___compiled__,
+        Nuitka_dunder_compiled_value
+    );
+
+    // Update "__package__" value to what it ought to be.
+    {
+#if %(is_dunder_main)s
+        UPDATE_STRING_DICT0(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___package__,
+            %(dunder_main_package)s
+        );
+#elif %(is_package)s
+        PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+
+        UPDATE_STRING_DICT0(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___package__,
+            module_name
+        );
+#else
+
+#if PYTHON_VERSION < 0x300
+        PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+        char const *module_name_cstr = PyString_AS_STRING(module_name);
+
+        char const *last_dot = strrchr(module_name_cstr, '.');
+
+        if (last_dot != NULL) {
+            UPDATE_STRING_DICT1(
+                moduledict_%(module_identifier)s,
+                (Nuitka_StringObject *)const_str_plain___package__,
+                PyString_FromStringAndSize(module_name_cstr, last_dot - module_name_cstr)
+            );
+        }
+#else
+        PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+        Py_ssize_t dot_index = PyUnicode_Find(module_name, const_str_dot, 0, PyUnicode_GetLength(module_name), -1);
+
+        if (dot_index != -1) {
+            UPDATE_STRING_DICT1(
+                moduledict_%(module_identifier)s,
+                (Nuitka_StringObject *)const_str_plain___package__,
+                PyUnicode_Substring(module_name, 0, dot_index)
+            );
+        }
+#endif
+#endif
+    }
+
+    CHECK_OBJECT(module_%(module_identifier)s);
+
+    // 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.
+
+    if (GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___builtins__) == NULL) {
+        PyObject *value = (PyObject *)builtin_module;
+
+        // Check if main module, not a dict then but the module itself.
+#if _NUITKA_MODULE_MODE || !%(is_dunder_main)s
+        value = PyModule_GetDict(value);
+#endif
+
+        UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___builtins__, value);
+    }
+
+    PyObject *module_loader = Nuitka_Loader_New(loader_entry);
+    UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___loader__, module_loader);
+
+#if PYTHON_VERSION >= 0x300
+// Set the "__spec__" value
+
+#if %(is_dunder_main)s
+    // Main modules just get "None" as spec.
+    UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___spec__, Py_None);
+#else
+    // Other modules get a "ModuleSpec" from the standard mechanism.
+    {
+        PyObject *bootstrap_module = getImportLibBootstrapModule();
+        CHECK_OBJECT(bootstrap_module);
+
+        PyObject *_spec_from_module = PyObject_GetAttrString(bootstrap_module, "_spec_from_module");
+        CHECK_OBJECT(_spec_from_module);
+
+        PyObject *spec_value = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, _spec_from_module, module_%(module_identifier)s);
+        Py_DECREF(_spec_from_module);
+
+        // We can assume this to never fail, or else we are in trouble anyway.
+        // CHECK_OBJECT(spec_value);
+
+        if (spec_value == NULL) {
+            PyErr_PrintEx(0);
+            abort();
+        }
+
+        // Mark the execution in the "__spec__" value.
+        SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_True);
+
+#if _NUITKA_MODULE_MODE && %(is_top)d && %(module_def_size)s >= 0
+        // Set our loader object in the "__spec__" value.
+        SET_ATTRIBUTE(tstate, spec_value, const_str_plain_loader, module_loader);
+#endif
+
+        UPDATE_STRING_DICT1(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___spec__, spec_value);
+    }
+#endif
+#endif
+
+    // Temp variables if any
+%(temps_decl)s
+
+    // Module init code if any
+%(module_init_codes)s
+
+    // Module code.
+%(module_codes)s
+
+    // Report to PGO about leaving the module without error.
+    PGO_onModuleExit("%(module_identifier)s", false);
+
+#if _NUITKA_MODULE_MODE && %(is_top)d
+    {
+        PyObject *post_load = IMPORT_EMBEDDED_MODULE(tstate, %(module_name_cstr)s "-postLoad");
+        if (post_load == NULL) {
+            return NULL;
+        }
+    }
+#endif
+
+    Py_INCREF(module_%(module_identifier)s);
+    return module_%(module_identifier)s;
+%(module_exit)s
+"""
+
+template_module_external_entry_point = r"""
+
+/* Visibility definitions to make the DLL entry point exported */
+#if defined(__GNUC__)
+
+#if PYTHON_VERSION < 0x300
+
+#if defined(_WIN32)
+#define NUITKA_MODULE_INIT_FUNCTION __declspec(dllexport) PyMODINIT_FUNC
+#else
+#define NUITKA_MODULE_INIT_FUNCTION PyMODINIT_FUNC __attribute__((visibility("default")))
+#endif
+
+#else
+
+#if defined(_WIN32)
+#define NUITKA_MODULE_INIT_FUNCTION __declspec(dllexport) PyObject *
+#else
+
+#ifdef __cplusplus
+#define NUITKA_MODULE_INIT_FUNCTION extern "C" __attribute__((visibility("default"))) PyObject *
+#else
+#define NUITKA_MODULE_INIT_FUNCTION __attribute__((visibility("default"))) PyObject *
+#endif
+
+#endif
+#endif
+
+#else
+#define NUITKA_MODULE_INIT_FUNCTION PyMODINIT_FUNC
+#endif
+
+static PyObject *orig_dunder_file_value;
+
+#if PYTHON_VERSION >= 0x300
+static setattrofunc orig_PyModule_Type_tp_setattro;
+
+/* This is used one time only. */
+static int Nuitka_TopLevelModule_tp_setattro(PyObject *module, PyObject *name, PyObject *value) {
+    PyModule_Type.tp_setattro = orig_PyModule_Type_tp_setattro;
+
+    if (orig_dunder_file_value != NULL) {
+        UPDATE_STRING_DICT0(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___file__,
+            orig_dunder_file_value
+        );
+    }
+
+    // Prevent "__spec__" update as well.
+#if PYTHON_VERSION >= 0x300
+    if (PyUnicode_Check(name) && PyUnicode_Compare(name, const_str_plain___spec__) == 0) {
+        return 0;
+    }
+#endif
+
+    return orig_PyModule_Type_tp_setattro(module, name, value);
+}
+#endif
+
+#if PYTHON_VERSION >= 0x300
+static struct PyModuleDef mdef_%(module_identifier)s = {
+    PyModuleDef_HEAD_INIT,
+    NULL,                /* m_name, filled later */
+    NULL,                /* m_doc */
+    %(module_def_size)s, /* m_size */
+    NULL,                /* m_methods */
+    NULL,                /* m_slots */
+    NULL,                /* m_traverse */
+    NULL,                /* m_clear */
+    NULL,                /* m_free */
+};
+#endif
+
+#if PYTHON_VERSION < 0x300
+static void onModuleFileValueRelease(void *v) {
+    if (orig_dunder_file_value != NULL) {
+        UPDATE_STRING_DICT0(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___file__,
+            orig_dunder_file_value
+        );
+    }
+}
+#endif
+
+/* The exported interface to CPython. On import of the module, this function
+ * gets called. It has to have an exact function name, in cases it's a shared
+ * library export.
+ */
+
+extern struct Nuitka_MetaPathBasedLoaderEntry const *getLoaderEntry(char const *name);
+
+static PyObject *%(module_dll_entry_point)s_phase2(PyObject *module) {
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *result = modulecode_%(module_identifier)s(tstate, module, getLoaderEntry(%(module_name_cstr)s));
+
+#if PYTHON_VERSION < 0x300
+    // Our "__file__" value will not be respected by CPython and one
+    // way we can avoid it, is by having a capsule type, that when
+    // it gets released, we are called and repair the value.
+
+    if (HAS_ERROR_OCCURRED(tstate) == false) {
+        orig_dunder_file_value = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, (PyObject *)moduledict_%(module_identifier)s, const_str_plain___file__);
+
+        PyObject *fake_file_value = PyCObject_FromVoidPtr(NULL, onModuleFileValueRelease);
+
+        UPDATE_STRING_DICT1(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___file__,
+            fake_file_value
+        );
+    }
+#else
+    if (result != NULL) {
+        // Make sure we undo the change of the "__file__" attribute during importing. We do not
+        // know how to achieve it for Python2 though. TODO: Find something for Python2 too.
+        orig_PyModule_Type_tp_setattro = PyModule_Type.tp_setattro;
+        PyModule_Type.tp_setattro = Nuitka_TopLevelModule_tp_setattro;
+
+        orig_dunder_file_value = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, (PyObject *)moduledict_%(module_identifier)s, const_str_plain___file__);
+    }
+#endif
+
+    return result;
+}
+
+#if %(module_def_size)s >= 0
+static int %(module_dll_entry_point)s_slot(PyObject *module) {
+    PyObject *result = %(module_dll_entry_point)s_phase2(module);
+
+    if (unlikely(result == NULL)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+#endif
+
+NUITKA_MODULE_INIT_FUNCTION (%(module_dll_entry_point)s)(void) {
+#if PYTHON_VERSION < 0x3c0
+    if (_Py_PackageContext != NULL) {
+        if (strcmp(module_full_name, _Py_PackageContext) != 0) {
+            module_full_name = strdup(_Py_PackageContext);
+        }
+    }
+#endif
+
+#if PYTHON_VERSION < 0x300
+    PyObject *module = Py_InitModule4(
+        module_full_name,        // 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
+    mdef_%(module_identifier)s.m_name = module_full_name;
+
+#if %(module_def_size)s == -1
+    PyObject *module = PyModule_Create(&mdef_%(module_identifier)s);
+    CHECK_OBJECT(module);
+
+    {
+        NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModuleString(module_full_name, module);
+        assert(res != false);
+    }
+
+#endif
+#endif
+
+#if %(module_def_size)s >= 0
+    static PyModuleDef_Slot _module_slots[] = {
+        {Py_mod_exec, (void *)%(module_dll_entry_point)s_slot},
+        {0, NULL}
+    };
+
+    mdef_%(module_identifier)s.m_slots = _module_slots;
+
+    return PyModuleDef_Init(&mdef_%(module_identifier)s);
+#elif PYTHON_VERSION >= 0x300
+    return %(module_dll_entry_point)s_phase2(module);
+#else
+    %(module_dll_entry_point)s_phase2(module);
+#endif
+}
+"""
+
+template_module_exception_exit = """\
+    module_exception_exit:
+
+#if _NUITKA_MODULE_MODE && %(is_top)d
+    {
+        PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+
+        if (module_name != NULL) {
+            Nuitka_DelModule(tstate, module_name);
+        }
+    }
+#endif
+    PGO_onModuleExit("%(module_identifier)s", false);
+
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
+    return NULL;
+}"""
+
+template_module_no_exception_exit = """\
+}"""
+
+template_helper_impl_decl = """\
+// This file contains helper functions that are automatically created from
+// templates.
+
+#include "nuitka/prelude.h"
+
+extern PyObject *callPythonFunction(PyObject *func, PyObject *const *args, int count);
+
+"""
+
+template_header_guard = """\
+#ifndef %(header_guard_name)s
+#define %(header_guard_name)s
+
+%(header_body)s
+#endif
+"""
+
+from . import TemplateDebugWrapper  # isort:skip
+
+TemplateDebugWrapper.checkDebug(globals())
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.