Nuitka-winsvc 2.3.9__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/__main__.py

@@ -14,6 +14,36 @@ or package, that can contain all used modules too.
 import os
 import sys
 
+_cached_process_environments = {}
+
+
+def getLaunchingNuitkaProcessEnvironmentValue(environment_variable_name):
+    if environment_variable_name not in _cached_process_environments:
+        _cached_process_environments[environment_variable_name] = os.getenv(
+            environment_variable_name
+        )
+        if _cached_process_environments[environment_variable_name] is not None:
+            del os.environ[environment_variable_name]
+
+    value = _cached_process_environments[environment_variable_name]
+
+    if value is not None and ":" not in value:
+        value = None
+
+    if value is not None:
+        pid, value = value.split(":", 1)
+
+        try:
+            pid = int(pid)
+        except ValueError:
+            value = None
+        else:
+            if os.name != "nt":
+                if pid != os.getpid():
+                    value = None
+
+    return value
+
 
 def main():
     # PyLint for Python3 thinks we import from ourselves if we really
@@ -35,21 +65,25 @@ def main():
         )
         sys.exit(1)
 
-    if "NUITKA_BINARY_NAME" in os.environ:
-        sys.argv[0] = os.environ["NUITKA_BINARY_NAME"]
+    nuitka_binary_name = getLaunchingNuitkaProcessEnvironmentValue("NUITKA_BINARY_NAME")
+    if nuitka_binary_name is not None:
+        sys.argv[0] = nuitka_binary_name
+
+    nuitka_pythonpath_ast = getLaunchingNuitkaProcessEnvironmentValue(
+        "NUITKA_PYTHONPATH_AST"
+    )
 
-    if "NUITKA_PYTHONPATH_AST" in os.environ:
+    if nuitka_pythonpath_ast is not None:
         # Restore the PYTHONPATH gained from the site module, that we chose not
         # to have imported during compilation. For loading "ast" module, we need
         # one element, that is not necessarily in our current path, but we use
         # that to evaluate the current path.
-        sys.path = [os.environ["NUITKA_PYTHONPATH_AST"]]
+        sys.path = [nuitka_pythonpath_ast]
         import ast
 
-        del os.environ["NUITKA_PYTHONPATH_AST"]
-
-        sys.path = ast.literal_eval(os.environ["NUITKA_PYTHONPATH"])
-        del os.environ["NUITKA_PYTHONPATH"]
+        sys.path = ast.literal_eval(
+            getLaunchingNuitkaProcessEnvironmentValue("NUITKA_PYTHONPATH")
+        )
     else:
         # Remove path element added for being called via "__main__.py", this can
         # only lead to trouble, having e.g. a "distutils" in sys.path that comes
@@ -103,6 +137,13 @@ def main():
 
     warnings.simplefilter("ignore", DeprecationWarning)
 
+    # Hack, we need this to bootstrap and it's actually living in __main__
+    # module of nuitka package and renamed to where we can get at easily for
+    # other uses.
+    __import__("nuitka").getLaunchingNuitkaProcessEnvironmentValue = (
+        getLaunchingNuitkaProcessEnvironmentValue
+    )
+
     from nuitka import Options  # isort:skip
 
     Options.parseArgs()
@@ -151,11 +192,15 @@ def main():
 
 
 if __name__ == "__main__":
-    if "NUITKA_PACKAGE_HOME" in os.environ:
-        sys.path.insert(0, os.environ["NUITKA_PACKAGE_HOME"])
+    _nuitka_package_home = getLaunchingNuitkaProcessEnvironmentValue(
+        "NUITKA_PACKAGE_HOME"
+    )
+    if _nuitka_package_home is not None:
+        sys.path.insert(0, _nuitka_package_home)
 
         import nuitka  # just to have it loaded from there, pylint: disable=unused-import
 
+        assert sys.path[0] is _nuitka_package_home
         del sys.path[0]
 
     main()

nuitka/build/Backend.scons

@@ -156,6 +156,9 @@ deployment_mode = getArgumentBool("deployment", False)
 # Experimental indications. Do things that are not yet safe to do.
 no_deployment = getArgumentList("no_deployment", "")
 
+# Debug mode indications. Do check things with fine granularity.
+debug_modes = getArgumentList("debug_modes", "")
+
 # Tracing mode. Output program progress.
 trace_mode = getArgumentBool("trace_mode", False)
 
@@ -315,6 +318,7 @@ env = createEnvironment(
     target_arch=target_arch,
     experimental=experimental,
     no_deployment=no_deployment,
+    debug_modes=debug_modes,
 )
 
 scons_details_logger.info("Initial CC: %r" % env.get("CC"))
@@ -797,7 +801,7 @@ env.Append(
     ]
 )
 
-if env.standalone_mode and env.debian_python and python_version >= (3, 12):
+if env.debian_python and python_version >= (3, 12):
     env.Append(
         CPPPATH=[
             os.path.join(env.nuitka_src, "inline_copy", "python_hacl", "hacl_312"),
@@ -806,6 +810,7 @@ if env.standalone_mode and env.debian_python and python_version >= (3, 12):
             ),
         ]
     )
+
     env.Append(CPPDEFINES=["_NUITKA_INLINE_COPY_HACL"])
 
 # Set load libpython from binary directory default

nuitka/build/CCompilerVersion.scons

@@ -171,6 +171,7 @@ env = createEnvironment(
     target_arch=target_arch,
     experimental=experimental,
     no_deployment=(),
+    debug_modes=(),
 )
 
 scons_details_logger.info("Initial CC: %r" % env.get("CC"))

nuitka/build/Onefile.scons

@@ -116,6 +116,9 @@ deployment_mode = getArgumentBool("deployment", False)
 # Experimental indications. Do things that are not yet safe to do.
 no_deployment = getArgumentList("no_deployment", "")
 
+# Debug mode indications. Do check things with fine granularity.
+debug_modes = getArgumentList("debug_modes", "")
+
 # Experimental indications. Do things that are not yet safe to do.
 experimental = getArgumentList("experimental", "")
 
@@ -228,6 +231,7 @@ env = createEnvironment(
     target_arch=target_arch,
     experimental=experimental,
     no_deployment=no_deployment,
+    debug_modes=debug_modes,
 )
 
 scons_details_logger.info("Initial CC: %r" % env.get("CC"))

nuitka/build/SconsCaching.py

@@ -92,6 +92,7 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
                         url=url,
                         is_arch_specific=False,
                         specificity=url.rsplit("/", 2)[1],
+                        unzip=True,
                         flatten=True,
                         binary="ccache",
                         message="Nuitka will make use of ccache to speed up repeated compilation.",

nuitka/build/SconsCompilerSettings.py

@@ -404,6 +404,7 @@ For Python version %s MSVC %s or later is required, not %s which is too old."""
                     target_arch=target_arch,
                     experimental=env.experimental_flags,
                     no_deployment=env.no_deployment_flags,
+                    debug_modes=env.debug_modes_flags,
                 )
 
                 if clang_mode:

nuitka/build/SconsHacks.py

@@ -142,7 +142,11 @@ def myDetect(self, progs):
             return None
 
     # Note: Actually, with our inline copy, this is maybe not supposed to
-    # happen at all
+    # happen a lot at all. It's a bit hard to pass debug flag to here, or
+    # else we could assert it.
+    # for p in progs:
+    #     if p not in ("x86_64-conda-linux-gnu-gcc", "gcc", "cc", "g++"):
+    #         assert False, p
 
     return orig_detect(self, progs)
 

nuitka/build/SconsInterface.py

@@ -469,6 +469,8 @@ def setCommonSconsOptions(options):
 
     options["experimental"] = ",".join(Options.getExperimentalIndications())
 
+    options["debug_modes"] = ",".join(Options.getDebugModeIndications())
+
     options["no_deployment"] = ",".join(Options.getNoDeploymentIndications())
 
     if Options.shallRunInDebugger():

nuitka/build/SconsUtils.py

@@ -33,7 +33,7 @@ from nuitka.utils.Utils import isLinux, isMacOS, isPosixWindows, isWin32Windows
 
 def initScons():
     # Avoid localized outputs.
-    os.environ["LANG"] = "C"
+    os.environ["LC_ALL"] = "C"
 
     def no_sync(self):
         # That's a noop, pylint: disable=unused-argument
@@ -173,7 +173,7 @@ def prepareEnvironment(mingw_mode):
 
 
 def createEnvironment(
-    mingw_mode, msvc_version, target_arch, experimental, no_deployment
+    mingw_mode, msvc_version, target_arch, experimental, no_deployment, debug_modes
 ):
     from SCons.Script import Environment  # pylint: disable=I0021,import-error
 
@@ -271,6 +271,9 @@ def createEnvironment(
     _enableFlagSettings(env, "experimental", experimental)
     env.experimental_flags = experimental
 
+    _enableFlagSettings(env, "debug", debug_modes)
+    env.debug_modes_flags = debug_modes
+
     return env
 
 

nuitka/build/include/nuitka/allocator.h

@@ -108,12 +108,12 @@ static inline void _Nuitka_Py_XDECREF(PyObject *ob) {
 #if PYTHON_VERSION < 0x3c0
 #define Py_INCREF_IMMORTAL(value) Py_INCREF(value)
 #define Py_DECREF_IMMORTAL(value) Py_DECREF(value)
-#elif defined(__NUITKA_NO_ASSERT__)
-#define Py_INCREF_IMMORTAL(value)
-#define Py_DECREF_IMMORTAL(value)
-#else
+#elif defined(_NUITKA_DEBUG_DEBUG_IMMORTAL)
 #define Py_INCREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
 #define Py_DECREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#else
+#define Py_INCREF_IMMORTAL(value)
+#define Py_DECREF_IMMORTAL(value)
 #endif
 
 // Macro introduced with Python3.9 or higher, make it generally available.
@@ -134,7 +134,16 @@ static inline void Nuitka_Py_NewReference(PyObject *op) {
     _PyInterpreterState_GET()->object_state.reftotal++;
 #endif
 #endif
+#if !defined(Py_GIL_DISABLED)
     op->ob_refcnt = 1;
+#else
+    op->ob_tid = _Py_ThreadId();
+    op->_padding = 0;
+    op->ob_mutex = (struct _PyMutex){0};
+    op->ob_gc_bits = 0;
+    op->ob_ref_local = 1;
+    op->ob_ref_shared = 0;
+#endif
 }
 #else
 #define Nuitka_Py_NewReference(op) _Py_NewReference(op)
@@ -280,7 +289,20 @@ static bool inline Nuitka_GC_IS_TRACKED_X(PyObject *object) {
 
 // To allow us marking some of our own values as immortal.
 #if PYTHON_VERSION >= 0x3c0
-static void inline Py_SET_REFCNT_IMMORTAL(PyObject *object) { object->ob_refcnt = _Py_IMMORTAL_REFCNT; }
+static void inline Py_SET_REFCNT_IMMORTAL(PyObject *object) {
+    // Normally done only with 3.13, but it makes sense to do this.
+    if (_PyObject_IS_GC(object) && _PyObject_GC_IS_TRACKED(object)) {
+        Nuitka_GC_UnTrack(object);
+    }
+
+#ifdef Py_GIL_DISABLED
+    object->ob_tid = _Py_UNOWNED_TID;
+    object->ob_ref_local = _Py_IMMORTAL_REFCNT_LOCAL;
+    object->ob_ref_shared = 0;
+#else
+    object->ob_refcnt = _Py_IMMORTAL_REFCNT;
+#endif
+}
 #else
 #define Py_SET_REFCNT_IMMORTAL(object)
 #endif

nuitka/build/include/nuitka/calling.h

@@ -11,7 +11,7 @@
 // For exception test formatting and call code mostly.
 extern char const *GET_CALLABLE_NAME(PyObject *object);
 extern char const *GET_CALLABLE_DESC(PyObject *object);
-extern char const *GET_CLASS_NAME(PyObject *klass);
+extern char const *GET_CLASS_NAME(PyObject *class_object);
 extern char const *GET_INSTANCE_CLASS_NAME(PyThreadState *tstate, PyObject *instance);
 
 // Also used in generated helper code.

nuitka/build/include/nuitka/compiled_frame.h

@@ -47,44 +47,44 @@ extern struct Nuitka_FrameObject *MAKE_CLASS_FRAME(PyThreadState *tstate, PyCode
 // Create a code object for the given filename and function name
 
 #if PYTHON_VERSION < 0x300
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, argnames, freevars, arg_count)
+    makeCodeObject(filename, line, flags, function_name, arg_names, free_vars, arg_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *argnames, PyObject *freevars, int arg_count);
+                                    PyObject *arg_names, PyObject *free_vars, int arg_count);
 #elif PYTHON_VERSION < 0x380
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, argnames, freevars, arg_count, kw_only_count)
+    makeCodeObject(filename, line, flags, function_name, arg_names, free_vars, arg_count, kw_only_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *argnames, PyObject *freevars, int arg_count, int kw_only_count);
+                                    PyObject *arg_names, PyObject *free_vars, int arg_count, int kw_only_count);
 #elif PYTHON_VERSION < 0x3b0
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, argnames, freevars, arg_count, kw_only_count, pos_only_count)
+    makeCodeObject(filename, line, flags, function_name, arg_names, free_vars, arg_count, kw_only_count, pos_only_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *argnames, PyObject *freevars, int arg_count, int kw_only_count,
+                                    PyObject *arg_names, PyObject *free_vars, int arg_count, int kw_only_count,
                                     int pos_only_count);
 #else
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,             \
+    makeCodeObject(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,           \
                    kw_only_count, pos_only_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *function_qualname, PyObject *argnames, PyObject *freevars, int arg_count,
-                                    int kw_only_count, int pos_only_count);
+                                    PyObject *function_qualname, PyObject *arg_names, PyObject *free_vars,
+                                    int arg_count, int kw_only_count, int pos_only_count);
 #endif
 
 NUITKA_MAY_BE_UNUSED static inline bool isFakeCodeObject(PyCodeObject *code) {
 #if PYTHON_VERSION < 0x300
     return code->co_code == const_str_empty;
 #elif PYTHON_VERSION < 0x3b0
-    return code->co_code == const_str_empty;
-#elif PYTHON_VERSION < 0x3c0
-    return _PyCode_CODE(code)[0] == 0;
+    return code->co_code == const_bytes_empty;
 #else
-    _Py_CODEUNIT *code_unit = _PyCode_CODE(code);
-    return code_unit->op.code == 0;
+    // Starting for Python3.11, we just proper bytecode that raises
+    // "RuntimeError" itself, so this function is only used to
+    // optimize checks away.
+    return false;
 #endif
 }
 
@@ -221,11 +221,11 @@ inline static void assertThreadFrameObject(Nuitka_ThreadStateFrameType *frame) {
 #endif
 }
 
-// Mark frame as currently executed. Starting with Python 3.4 that means it
+// Mark frame as currently executed. Starting with Python 3 that means it
 // can or cannot be cleared, or should lead to a generator close. For Python2
 // this is a no-op. Using a define to spare the compile from inlining an empty
 // function.
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 
 #if PYTHON_VERSION < 0x3b0
 
@@ -253,7 +253,7 @@ static inline void Nuitka_Frame_MarkAsExecuting(struct Nuitka_FrameObject *frame
 #define Nuitka_Frame_MarkAsExecuting(frame) ;
 #endif
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 static inline void Nuitka_Frame_MarkAsNotExecuting(struct Nuitka_FrameObject *frame) {
     CHECK_OBJECT(frame);
 #if PYTHON_VERSION >= 0x3b0
@@ -269,7 +269,7 @@ static inline void Nuitka_Frame_MarkAsNotExecuting(struct Nuitka_FrameObject *fr
 #define Nuitka_PythonFrame_MarkAsExecuting(frame) ;
 #endif
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 static inline bool Nuitka_Frame_IsExecuting(struct Nuitka_FrameObject *frame) {
     CHECK_OBJECT(frame);
 #if PYTHON_VERSION >= 0x3b0
@@ -396,7 +396,7 @@ NUITKA_MAY_BE_UNUSED inline static void popFrameStack(PyThreadState *tstate) {
 
 // TODO: These can be moved to private code, once all C library is included by
 // compiled code helpers, but generators are currently not.
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 NUITKA_MAY_BE_UNUSED static void Nuitka_SetFrameGenerator(struct Nuitka_FrameObject *nuitka_frame,
                                                           PyObject *generator) {
 #if PYTHON_VERSION < 0x3b0

nuitka/build/include/nuitka/compiled_method.h

@@ -32,7 +32,7 @@ struct Nuitka_MethodObject {
 extern PyTypeObject Nuitka_Method_Type;
 
 // Make a method out of a function.
-extern PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *klass);
+extern PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *class_object);
 
 static inline bool Nuitka_Method_Check(PyObject *object) { return Py_TYPE(object) == &Nuitka_Method_Type; }
 

nuitka/build/include/nuitka/exception_groups.h

@@ -75,8 +75,6 @@ NUITKA_MAY_BE_UNUSED static int CHECK_EXCEPTION_STAR_VALID(PyThreadState *tstate
     return 0;
 }
 
-extern PyObject *const_str_plain_split;
-
 NUITKA_MAY_BE_UNUSED static int EXCEPTION_GROUP_MATCH(PyThreadState *tstate, PyObject *exc_value, PyObject *match_type,
                                                       PyObject **match, PyObject **rest) {
     // TODO: Avoid this from happening, we should not call it then.

nuitka/build/include/nuitka/helper/attributes.h

@@ -35,7 +35,7 @@ extern PyObject *LOOKUP_SPECIAL(PyThreadState *tstate, PyObject *source, PyObjec
 
 // Find an attribute in a class, Python2 only.
 #if PYTHON_VERSION < 0x300
-extern PyObject *FIND_ATTRIBUTE_IN_CLASS(PyClassObject *klass, PyObject *attr_name);
+extern PyObject *FIND_ATTRIBUTE_IN_CLASS(PyClassObject *class_object, PyObject *attr_name);
 #endif
 
 extern PyObject *LOOKUP_MODULE_VALUE(PyDictObject *module_dict, PyObject *var_name);
@@ -70,6 +70,12 @@ static inline bool hasTypeGenericSetAttr(PyTypeObject *type) {
 #endif
 }
 
+#if PYTHON_VERSION >= 0x3a0
+static inline bool Nuitka_Descr_IsData(PyObject *object) { return Py_TYPE(object)->tp_descr_set != NULL; }
+#else
+#define Nuitka_Descr_IsData(object) PyDescr_IsData(object)
+#endif
+
 #endif
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/include/nuitka/helper/subscripts.h

@@ -238,7 +238,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_SUBSCRIPT(PyThreadState *tstate, Py
 #endif
 }
 
-int MATCH_MAPPING_KEY(PyThreadState *tstate, PyObject *map, PyObject *key);
+bool MATCH_MAPPING_KEY(PyThreadState *tstate, PyObject *map, PyObject *key);
 
 NUITKA_MAY_BE_UNUSED static bool SET_SUBSCRIPT_CONST(PyThreadState *tstate, PyObject *target, PyObject *subscript,
                                                      Py_ssize_t int_subscript, PyObject *value) {

nuitka/build/include/nuitka/helpers.h

@@ -162,7 +162,7 @@ extern PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObje
 // Small helper to open files with few arguments in C.
 extern PyObject *BUILTIN_OPEN_BINARY_READ_SIMPLE(PyThreadState *tstate, PyObject *filename);
 extern PyObject *BUILTIN_OPEN_SIMPLE(PyThreadState *tstate, PyObject *filename, char const *mode, bool buffering,
-                                     PyObject *encoding);
+                                     PyObject *encoding, bool close_fd);
 
 // Small helper to read file contents with few arguments in C.
 extern PyObject *GET_FILE_BYTES(PyThreadState *tstate, PyObject *filename);
@@ -334,8 +334,8 @@ extern void patchTracebackDealloc(void);
 // Initialize value for "tp_compare" and "tp_init" defaults.
 extern void _initSlotCompare(void);
 
-// Default __init__ slot wrapper.
-extern python_initproc default_tp_init_wrapper;
+// Default __init__ slot wrapper, spell-checker: ignore initproc
+extern python_init_proc default_tp_init_wrapper;
 
 #if PYTHON_VERSION >= 0x300
 // Select the metaclass from specified one and given bases.
@@ -343,7 +343,8 @@ extern PyObject *SELECT_METACLASS(PyThreadState *tstate, PyObject *metaclass, Py
 #endif
 
 #if PYTHON_VERSION >= 0x3a0
-extern PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, Py_ssize_t max_allowed);
+extern PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, PyObject *matched_type,
+                                  Py_ssize_t positional_count, PyObject **keywords, Py_ssize_t keywords_count);
 #endif
 
 NUITKA_MAY_BE_UNUSED static PyObject *MODULE_NAME1(PyThreadState *tstate, PyObject *module) {
@@ -413,6 +414,8 @@ extern PyObject *Py_SysVersionInfo;
 
 extern PyObject *MAKE_UNION_TYPE(PyObject *args);
 
+// Our wrapper for "PyType_Ready" that takes care of trying to avoid DLL entry
+// points for generic attributes. spell-checker: ignore aiter
 extern void Nuitka_PyType_Ready(PyTypeObject *type, PyTypeObject *base, bool generic_get_attr, bool generic_set_attr,
                                 bool self_iter, bool await_self_iter, bool self_aiter);
 

nuitka/build/include/nuitka/prelude.h

@@ -27,9 +27,10 @@
 
 /* This is needed or else we can't create modules name "proc" or "func". For
  * Python3, the name collision can't happen, so we can limit it to Python2.
+   spell-checker: ignore initproc,initfunc
  */
-#define initproc python_initproc
-#define initfunc python_initfunc
+#define initproc python_init_proc
+#define initfunc python_init_func
 #define initstate python_initstate
 
 // Python 3.11 headers give these warnings
@@ -251,11 +252,6 @@ NUITKA_MAY_BE_UNUSED static inline managed_static_type_state *Nuitka_PyStaticTyp
 #define NUITKA_DYNAMIC_ARRAY_DECL(VARIABLE_NAME, ELEMENT_TYPE, COUNT) ELEMENT_TYPE VARIABLE_NAME[COUNT];
 #endif
 
-// Stringizing, to make strings out of defines use XSTRINGIZED(SOME_DEFINE) needs
-// to level of defines to work.
-#define _STRINGIZED(ARG) #ARG
-#define STRINGIZED(ARG) _STRINGIZED(ARG)
-
 /* Python3 removed PyInt instead of renaming PyLong, and PyObject_Str instead
  * of renaming PyObject_Unicode. Define this to be easily portable.
  */
@@ -415,9 +411,9 @@ extern PyThreadState *_PyThreadState_Current;
 #endif
 
 #if PYTHON_VERSION < 0x300
-#define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) ? (t)->tp_richcompare : NULL)
+#define TP_RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) ? (t)->tp_richcompare : NULL)
 #else
-#define RICHCOMPARE(t) ((t)->tp_richcompare)
+#define TP_RICHCOMPARE(t) ((t)->tp_richcompare)
 #endif
 
 // For older Python we need to define this ourselves.
@@ -522,7 +518,7 @@ extern PyObject *Nuitka_dunder_compiled_value;
 #include "nuitka_data_decoder.h"
 #else
 #define DECODE(x) assert(x)
-#define UNTRANSLATE(x) (x)
+#define UN_TRANSLATE(x) (x)
 #endif
 
 #if _NUITKA_EXPERIMENTAL_FILE_TRACING

nuitka/build/include/nuitka/printing.h

@@ -8,7 +8,9 @@
 
 extern bool PRINT_NEW_LINE(void);
 extern bool PRINT_ITEM(PyObject *object);
+extern bool PRINT_ITEM_LINE(PyObject *object);
 extern bool PRINT_STRING(char const *str);
+extern bool PRINT_STRING_W(wchar_t const *str);
 extern bool PRINT_FORMAT(char const *fmt, ...);
 extern bool PRINT_ITEM_TO(PyObject *file, PyObject *object);
 extern bool PRINT_NEW_LINE_TO(PyObject *file);

nuitka/build/include/nuitka/unfreezing.h

@@ -18,8 +18,8 @@
 
 struct Nuitka_MetaPathBasedLoaderEntry;
 
-typedef PyObject *(*module_initfunc)(PyThreadState *tstate, PyObject *module,
-                                     struct Nuitka_MetaPathBasedLoaderEntry const *loader_entry);
+typedef PyObject *(*module_init_func)(PyThreadState *tstate, PyObject *module,
+                                      struct Nuitka_MetaPathBasedLoaderEntry const *loader_entry);
 
 #if PYTHON_VERSION >= 0x370 && defined(_NUITKA_EXE) && !defined(_NUITKA_STANDALONE) &&                                 \
     defined(_NUITKA_FILE_REFERENCE_ORIGINAL_MODE)
@@ -31,7 +31,7 @@ struct Nuitka_MetaPathBasedLoaderEntry {
     char const *name;
 
     // Entry function if compiled module, otherwise NULL.
-    module_initfunc python_initfunc;
+    module_init_func python_init_func;
 
     // For bytecode modules, start and size inside the constants blob.
     int bytecode_index;
@@ -55,8 +55,8 @@ struct Nuitka_MetaPathBasedLoaderEntry {
 /* For embedded modules, register the meta path based loader. Used by main
  * program/package only.
  */
-extern void registerMetaPathBasedUnfreezer(struct Nuitka_MetaPathBasedLoaderEntry *loader_entries,
-                                           unsigned char **bytecode_data);
+extern void registerMetaPathBasedLoader(struct Nuitka_MetaPathBasedLoaderEntry *loader_entries,
+                                        unsigned char **bytecode_data);
 
 /* Create a loader object responsible for a package. */
 extern PyObject *Nuitka_Loader_New(struct Nuitka_MetaPathBasedLoaderEntry const *entry);

nuitka/build/inline_copy/tqdm/tqdm/_monitor.py

@@ -41,7 +41,10 @@ class TMonitor(Thread):
     def exit(self):
         self.was_killed.set()
         if self is not current_thread():
-            self.join()
+            if str is bytes:
+                self.join()
+            else:
+                self.join(timeout=1.0)
         return self.report()
 
     def get_instances(self):

nuitka/build/static_src/CompiledAsyncgenType.c

@@ -375,8 +375,6 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
 
         Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
 
-        tstate = PyThreadState_GET();
-
         // Remove the back frame from asyncgen if it's there.
         if (asyncgen->m_frame) {
             // assert(tstate->frame == &asyncgen->m_frame->m_frame);
@@ -1050,7 +1048,7 @@ static PyAsyncMethods Nuitka_Asyncgen_as_async = {
 
 // TODO: Set "__doc__" automatically for method clones of compiled types from
 // the documentation of built-in original type.
-static PyGetSetDef Nuitka_Asyncgen_getsetlist[] = {
+static PyGetSetDef Nuitka_Asyncgen_tp_getset[] = {
     {(char *)"__name__", (getter)Nuitka_Asyncgen_get_name, (setter)Nuitka_Asyncgen_set_name, NULL},
     {(char *)"__qualname__", (getter)Nuitka_Asyncgen_get_qualname, (setter)Nuitka_Asyncgen_set_qualname, NULL},
     {(char *)"ag_await", (getter)Nuitka_Asyncgen_get_ag_await, (setter)NULL, NULL},
@@ -1095,7 +1093,7 @@ PyTypeObject Nuitka_Asyncgen_Type = {
     0,                                                                  // tp_iternext
     Nuitka_Asyncgen_methods,                                            // tp_methods
     Nuitka_Asyncgen_members,                                            // tp_members
-    Nuitka_Asyncgen_getsetlist,                                         // tp_getset
+    Nuitka_Asyncgen_tp_getset,                                          // tp_getset
     0,                                                                  // tp_base
     0,                                                                  // tp_dict
     0,                                                                  // tp_descr_get

nuitka/build/static_src/CompiledCellType.c

@@ -182,7 +182,7 @@ static int Nuitka_Cell_set_contents(struct Nuitka_CellObject *cell, PyObject *va
 }
 #endif
 
-static PyGetSetDef Nuitka_Cell_getsetlist[] = {
+static PyGetSetDef Nuitka_Cell_tp_getset[] = {
 #if PYTHON_VERSION < 0x370
     {(char *)"cell_contents", (getter)Nuitka_Cell_get_contents, NULL, NULL},
 #else
@@ -218,12 +218,12 @@ PyTypeObject Nuitka_Cell_Type = {
 #else
     Nuitka_Cell_tp_richcompare, // tp_richcompare
 #endif
-    0,                      // tp_weaklistoffset
-    0,                      // tp_iter
-    0,                      // tp_iternext
-    0,                      // tp_methods
-    0,                      // tp_members
-    Nuitka_Cell_getsetlist, // tp_getset
+    0,                     // tp_weaklistoffset
+    0,                     // tp_iter
+    0,                     // tp_iternext
+    0,                     // tp_methods
+    0,                     // tp_members
+    Nuitka_Cell_tp_getset, // tp_getset
 };
 
 void _initCompiledCellType(void) { Nuitka_PyType_Ready(&Nuitka_Cell_Type, NULL, true, false, false, false, false); }