Nuitka-winsvc 2.4.11__cp311-cp311-win_amd64.whl → 2.5.6__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersStrings.c

@@ -121,7 +121,7 @@ PyObject *BUILTIN_ORD(PyObject *value) {
         return NULL;
     }
 
-    return PyInt_FromLong(result);
+    return Nuitka_PyInt_FromLong(result);
 }
 
 #if PYTHON_VERSION >= 0x300

nuitka/build/static_src/HelpersTuples.c

@@ -26,7 +26,7 @@ PyObject *MAKE_TUPLE_EMPTY(PyThreadState *tstate, Py_ssize_t size) {
     struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
     struct _Py_tuple_freelist *state = &freelists->tuples;
     PyTupleObject **items = state->items;
-    int(*numfree) = state->numfree;
+    int *numfree = state->numfree;
 #endif
 
 #if PYTHON_VERSION < 0x3b0
@@ -117,7 +117,7 @@ PyObject *TUPLE_COPY(PyThreadState *tstate, PyObject *tuple) {
     assert(PyTuple_CheckExact(tuple));
 
     Py_ssize_t size = PyTuple_GET_SIZE(tuple);
-    PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, size);
 
     if (unlikely(result == NULL)) {
         return NULL;

nuitka/build/static_src/HelpersTypes.c

@@ -33,8 +33,15 @@ bool Nuitka_Type_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
 
         return false;
     } else {
-        // Fallback for uninitialized classes to API usage
-        return PyType_IsSubtype(a, b) != 0;
+        // Fallback for uninitialized classes to base class scan
+        do {
+            if (a == b) {
+                return true;
+            }
+            a = a->tp_base;
+        } while (a != NULL);
+
+        return (b == &PyBaseObject_Type);
     }
 }
 
@@ -202,6 +209,8 @@ static PyTypeObject *getTypeAliasType(void) {
 }
 
 PyObject *MAKE_TYPE_ALIAS(PyObject *name, PyObject *type_params, PyObject *compute_value) {
+    // TODO: For Python 3.13 we can use the intrinsic.
+
     typealiasobject *ta = Nuitka_GC_New(getTypeAliasType());
 
     // TODO: Lets follow Python new inline function in the future, this is 3.12
@@ -216,6 +225,93 @@ PyObject *MAKE_TYPE_ALIAS(PyObject *name, PyObject *type_params, PyObject *compu
 
     return (PyObject *)ta;
 }
+
+typedef struct {
+    PyObject_HEAD PyObject *name;
+    PyObject *bound;
+    PyObject *evaluate_bound;
+    PyObject *constraints;
+    PyObject *evaluate_constraints;
+    bool covariant;
+    bool contravariant;
+    bool infer_variance;
+} typevarobject;
+
+static typevarobject *_Nuitka_typevar_alloc(PyThreadState *tstate, PyObject *name, PyObject *bound,
+                                            PyObject *evaluate_bound, PyObject *constraints,
+                                            PyObject *evaluate_constraints, bool covariant, bool contravariant,
+                                            bool infer_variance, PyObject *module) {
+    PyTypeObject *tp = tstate->interp->cached_objects.typevar_type;
+    typevarobject *result = Nuitka_GC_New(tp);
+
+    result->name = Py_NewRef(name);
+
+    result->bound = Py_XNewRef(bound);
+    result->evaluate_bound = Py_XNewRef(evaluate_bound);
+    result->constraints = Py_XNewRef(constraints);
+    result->evaluate_constraints = Py_XNewRef(evaluate_constraints);
+
+    result->covariant = covariant;
+    result->contravariant = contravariant;
+    result->infer_variance = infer_variance;
+
+    Nuitka_GC_Track(result);
+
+    // TODO: Not seen yet.
+    if (unlikely(module != NULL)) {
+        if (PyObject_SetAttrString((PyObject *)result, "__module__", module) < 0) {
+            Py_DECREF(result);
+            return NULL;
+        }
+    }
+
+    return result;
+}
+
+PyObject *MAKE_TYPE_VAR(PyThreadState *tstate, PyObject *name) {
+    // TODO: For Python 3.13 this would work.
+    // return _PyIntrinsics_UnaryFunctions[INTRINSIC_TYPEVAR].func(tstate, name);
+
+    return (PyObject *)_Nuitka_typevar_alloc(tstate, name, NULL, NULL, NULL, NULL, false, false, true, NULL);
+}
+
+static PyTypeObject *_getTypeGenericAliasType(void) {
+    static PyTypeObject *type_generic_alias_type = NULL;
+
+    if (type_generic_alias_type == NULL) {
+
+        PyObject *typing_module = PyImport_ImportModule("_typing");
+        CHECK_OBJECT(typing_module);
+
+        type_generic_alias_type = (PyTypeObject *)PyObject_GetAttrString(typing_module, "_GenericAlias");
+        CHECK_OBJECT(type_generic_alias_type);
+    }
+
+    return type_generic_alias_type;
+}
+
+static PyObject *_Nuitka_unpack_typevartuples(PyObject *params) {
+    assert(PyTuple_Check(params));
+
+    // TODO: Not implemented yet.
+
+    return Py_NewRef(params);
+}
+
+PyObject *MAKE_TYPE_GENERIC(PyThreadState *tstate, PyObject *params) {
+    CHECK_OBJECT(params);
+    PyObject *unpacked_params = _Nuitka_unpack_typevartuples(params);
+    CHECK_OBJECT(unpacked_params);
+
+    PyObject *args[2] = {(PyObject *)tstate->interp->cached_objects.generic_type, unpacked_params};
+
+    PyObject *called = (PyObject *)_getTypeGenericAliasType();
+
+    PyObject *result = CALL_FUNCTION_WITH_ARGS2(tstate, called, args);
+    Py_DECREF(unpacked_params);
+    return result;
+}
+
 #endif
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.

nuitka/build/static_src/MainProgram.c

@@ -8,7 +8,7 @@
  * For multiprocessing, joblib, loky there is things here that will
  * allow them to fork properly with their intended entry points.
  *
- * spell-checker: ignore joblib loky
+ * spell-checker: ignore joblib loky anyio platlibdir
  *
  */
 
@@ -16,6 +16,10 @@
 #include <windows.h>
 #endif
 
+#if defined(__APPLE__)
+#include <unistd.h>
+#endif
+
 #include "nuitka/prelude.h"
 
 #ifndef __IDE_ONLY__
@@ -32,6 +36,7 @@
 #define SYSFLAG_BYTES_WARNING 0
 #define SYSFLAG_UTF8 0
 #define SYSFLAG_UNBUFFERED 0
+#define SYSFLAG_DONTWRITEBYTECODE 0
 #define NUITKA_MAIN_MODULE_NAME "__main__"
 #define NUITKA_MAIN_IS_PACKAGE_BOOL false
 #define _NUITKA_ATTACH_CONSOLE_WINDOW 1
@@ -49,11 +54,11 @@
 #define NUITKA_STANDARD_HANDLES_EARLY 0
 #endif
 
-#if defined(_WIN32) && defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
+#if defined(_WIN32) && (defined(_NUITKA_ATTACH_CONSOLE_WINDOW) || defined(_NUITKA_HIDE_CONSOLE_WINDOW))
 #include "HelpersConsole.c"
 #endif
 
-extern PyCodeObject *codeobj_main;
+extern PyCodeObject *code_objects_main;
 
 /* For later use in "Py_GetArgcArgv" we expose the needed value  */
 #if PYTHON_VERSION >= 0x300
@@ -67,7 +72,7 @@ static int orig_argc;
 extern void copyFrozenModulesTo(struct _frozen *destination);
 
 // The original frozen modules list.
-#if PYTHON_VERSION < 0x340
+#if PYTHON_VERSION < 0x300
 static struct _frozen *old_frozen = NULL;
 #else
 static struct _frozen const *old_frozen = NULL;
@@ -369,9 +374,13 @@ static int loky_joblib_parent_pid_arg = 0;
 #else
 static bool is_joblib_popen_loky_posix = false;
 #endif
+
 // This is a joblib resource tracker if not -1
 static int loky_resource_tracker_arg = -1;
 
+// This is a "anyio.to_process" fork
+static bool is_anyio_to_process = false;
+
 // Parse the command line parameters to decide if it's a multiprocessing usage
 // or something else special.
 #if _NUITKA_NATIVE_WCHAR_ARGV == 0
@@ -381,7 +390,7 @@ static void setCommandLineParameters(int argc, wchar_t **argv) {
 #endif
 #ifdef _NUITKA_EXPERIMENTAL_DEBUG_SELF_FORKING
 #if _NUITKA_NATIVE_WCHAR_ARGV == 0
-    printf("Commandline: ");
+    printf("Command line: ");
     for (int i = 0; i < argc; i++) {
         if (i != 0) {
             printf(" ");
@@ -390,7 +399,7 @@ static void setCommandLineParameters(int argc, wchar_t **argv) {
     }
     printf("\n");
 #else
-    wprintf(L"Commandline: '%lS' %d\n", GetCommandLineW(), argc);
+    wprintf(L"Command line: '%lS' %d\n", GetCommandLineW(), argc);
 #endif
 #endif
 
@@ -454,16 +463,22 @@ static void setCommandLineParameters(int argc, wchar_t **argv) {
 #endif
         }
 
-#if !defined(_WIN32)
         if ((i + 1 < argc) && (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-m") == 0)) {
+#if !defined(_WIN32)
             // The joblib loky posix popen is launching like this.
             if (strcmpFilename(argv[i + 1], FILENAME_EMPTY_STR "joblib.externals.loky.backend.popen_loky_posix") == 0) {
                 is_joblib_popen_loky_posix = true;
                 break;
             }
-        }
 #endif
 
+            // The anyio.to_process module is launching like this.
+            if (strcmpFilename(argv[i + 1], FILENAME_EMPTY_STR "anyio.to_process") == 0) {
+                is_anyio_to_process = true;
+                break;
+            }
+        }
+
 #if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_SELF_EXECUTION)
         if ((strcmpFilename(argv[i], FILENAME_EMPTY_STR "-c") == 0) ||
             (strcmpFilename(argv[i], FILENAME_EMPTY_STR "-m") == 0)) {
@@ -725,6 +740,10 @@ static bool shallSetOutputHandleToNull(char const *name) {
     if (strcmp(name, "stderr") == 0) {
         return true;
     }
+#elif defined(NUITKA_FORCED_STDERR_PATH) || defined(NUITKA_FORCED_STDERR_NONE_BOOL)
+    if (strcmp(name, "stderr") == 0) {
+        return false;
+    }
 #endif
 
     PyObject *sys_std_handle = Nuitka_SysGetObject(name);
@@ -808,6 +827,7 @@ static void setInputOutputHandles(PyThreadState *tstate) {
 // better, and force it to utf-8, it often becomes platform IO for no good
 // reason.
 #if NUITKA_STANDARD_HANDLES_EARLY == 1 && PYTHON_VERSION >= 0x370
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Early handles.");
 #if defined(NUITKA_FORCED_STDOUT_PATH) || defined(NUITKA_FORCED_STDERR_PATH)
     PyObject *args = MAKE_DICT_EMPTY(tstate);
 
@@ -815,34 +835,40 @@ static void setInputOutputHandles(PyThreadState *tstate) {
     DICT_SET_ITEM(args, const_str_plain_line_buffering, Py_True);
 
 #if defined(NUITKA_FORCED_STDOUT_PATH)
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forced stdout update.");
     {
         PyObject *sys_stdout = Nuitka_SysGetObject("stdout");
 
         PyObject *method = LOOKUP_ATTRIBUTE(tstate, sys_stdout, const_str_plain_reconfigure);
         CHECK_OBJECT(method);
 
-        PyObject *result = CALL_FUNCTION_WITH_KEYARGS(tstate, method, args);
+        PyObject *result = CALL_FUNCTION_WITH_KW_ARGS(tstate, method, args);
         CHECK_OBJECT(result);
     }
 #endif
 
 #if defined(NUITKA_FORCED_STDERR_PATH)
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forced stderr update.");
     {
         PyObject *sys_stderr = Nuitka_SysGetObject("stderr");
+        if (sys_stderr != Py_None) {
+            PyObject *method = LOOKUP_ATTRIBUTE(tstate, sys_stderr, const_str_plain_reconfigure);
+            CHECK_OBJECT(method);
 
-        PyObject *method = LOOKUP_ATTRIBUTE(tstate, sys_stderr, const_str_plain_reconfigure);
-        CHECK_OBJECT(method);
-
-        PyObject *result = CALL_FUNCTION_WITH_KEYARGS(tstate, method, args);
-        CHECK_OBJECT(result);
+            PyObject *result = CALL_FUNCTION_WITH_KW_ARGS(tstate, method, args);
+            CHECK_OBJECT(result);
+        }
     }
 #endif
 
     Py_DECREF(args);
 #endif
+
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Done with early handles.");
 #endif
 
 #if NUITKA_STANDARD_HANDLES_EARLY == 0
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Late handles.");
 #if defined(NUITKA_FORCED_STDOUT_PATH)
     {
 #if defined(_WIN32)
@@ -885,22 +911,37 @@ static void setInputOutputHandles(PyThreadState *tstate) {
         PyObject *devnull_filename = Nuitka_String_FromString("/dev/null");
 #endif
 
+        NUITKA_PRINT_TRACE("setInputOutputHandles(): Considering stdin.");
+
         if (shallSetOutputHandleToNull("stdin")) {
+            NUITKA_PRINT_TRACE("setInputOutputHandles(): Set stdin to NULL file.");
+
             // CPython core requires stdin to be buffered due to methods usage, and it won't matter
             // here much.
             PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "r", true, encoding);
+            CHECK_OBJECT(stdin_file);
 
             setStdinHandle(tstate, stdin_file);
         }
 
+        NUITKA_PRINT_TRACE("setInputOutputHandles(): Considering stdout.");
+
         if (shallSetOutputHandleToNull("stdout")) {
+            NUITKA_PRINT_TRACE("setInputOutputHandles(): Set stdout to NULL file.");
+
             PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding);
+            CHECK_OBJECT(stdout_file);
 
             setStdoutHandle(tstate, stdout_file);
         }
 
+        NUITKA_PRINT_TRACE("setInputOutputHandles(): Considering stderr.");
+
         if (shallSetOutputHandleToNull("stderr")) {
+            NUITKA_PRINT_TRACE("setInputOutputHandles(): Set stderr to NULL file.");
+
             PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding);
+            CHECK_OBJECT(stderr_file);
 
             setStderrHandle(tstate, stderr_file);
         }
@@ -909,10 +950,12 @@ static void setInputOutputHandles(PyThreadState *tstate) {
     }
 
 #if NUITKA_FORCED_STDOUT_NONE_BOOL
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forcing stdout to None.");
     setStdoutHandle(tstate, Py_None);
 #endif
 
 #if NUITKA_FORCED_STDERR_NONE_BOOL
+    NUITKA_PRINT_TRACE("setInputOutputHandles(): Forcing stderr to None.");
     setStderrHandle(tstate, Py_None);
 #endif
 
@@ -1069,12 +1112,11 @@ static void changeStandardHandleTarget(int std_handle_id, FILE *std_handle, file
             abort();
         }
 
-        int int_res = dup2(os_handle, fileno(std_handle));
+        int _int_res = dup2(os_handle, fileno(std_handle));
 
-        // Without a console, this is normal.
-        if (int_res == -1) {
-            perror("_open_osfhandle");
-            abort();
+        if (_int_res == -1) {
+            // Note: Without a console, this is normal to get no file number to
+            // work with.
         }
 
         close(os_handle);
@@ -1137,6 +1179,14 @@ extern char const *getBinaryFilenameHostEncoded(bool resolve_symlinks);
 PyAPI_FUNC(void) PySys_AddWarnOption(const wchar_t *s);
 #endif
 
+// Preserve and provide the original argv[0] as recorded by the bootstrap stage.
+static environment_char_t const *original_argv0 = NULL;
+
+PyObject *getOriginalArgv0Object(void) {
+    assert(original_argv0 != NULL);
+    return Nuitka_String_FromFilename(original_argv0);
+}
+
 #ifdef _NUITKA_WINMAIN_ENTRY_POINT
 int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lpCmdLine, int nCmdShow) {
     /* MSVC, MINGW64 */
@@ -1145,6 +1195,9 @@ int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lp
 #else
 #if defined(_WIN32)
 int wmain(int argc, wchar_t **argv) {
+#if defined(_NUITKA_HIDE_CONSOLE_WINDOW)
+    hideConsoleIfSpawned();
+#endif
 #else
 int main(int argc, char **argv) {
 #endif
@@ -1170,6 +1223,19 @@ int main(int argc, char **argv) {
     inheritAttachedConsole();
 #endif
 
+#ifdef _NUITKA_MACOS_BUNDLE
+    {
+        char *current_dir = getcwd(NULL, -1);
+
+        if (strcmp(current_dir, "/") == 0) {
+            chdir(getBinaryDirectoryHostEncoded(false));
+            chdir("../../../");
+        }
+
+        free(current_dir);
+    }
+#endif
+
     // Set up stdout/stderr according to user specification.
 #if NUITKA_STANDARD_HANDLES_EARLY == 1
 #if defined(NUITKA_FORCED_STDOUT_PATH)
@@ -1242,7 +1308,7 @@ int main(int argc, char **argv) {
     Py_InspectFlag = 0;
     Py_InteractiveFlag = 0;
     Py_OptimizeFlag = SYSFLAG_OPTIMIZE;
-    Py_DontWriteBytecodeFlag = 0;
+    Py_DontWriteBytecodeFlag = SYSFLAG_DONTWRITEBYTECODE;
     Py_NoUserSiteDirectory = SYSFLAG_NO_SITE;
     Py_IgnoreEnvironmentFlag = 0;
     Py_VerboseFlag = SYSFLAG_VERBOSE;
@@ -1285,9 +1351,26 @@ int main(int argc, char **argv) {
     /* Initial command line handling only. */
 
 // Make sure, we use the absolute program path for argv[0]
-#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 0
+#if _NUITKA_NATIVE_WCHAR_ARGV == 0
+    original_argv0 = argv[0];
+#if !defined(_NUITKA_ONEFILE_MODE)
     argv[0] = (char *)getBinaryFilenameHostEncoded(false);
 #endif
+#endif
+
+#if defined(_NUITKA_ONEFILE_MODE)
+    {
+        environment_char_t const *parent_original_argv0 = getEnvironmentVariable("NUITKA_ORIGINAL_ARGV0");
+
+        // If forked from the parent process, it's set, otherwise fall back
+        // to standalone executable binary name as set above.
+        if (parent_original_argv0 != NULL) {
+            original_argv0 = strdupFilename(parent_original_argv0);
+
+            unsetEnvironmentVariable("NUITKA_ORIGINAL_ARGV0");
+        }
+    }
+#endif
 
 #if PYTHON_VERSION >= 0x300 && _NUITKA_NATIVE_WCHAR_ARGV == 0
     NUITKA_PRINT_TRACE("main(): Calling convertCommandLineParameters.");
@@ -1300,8 +1383,11 @@ orig_argv = argv;
 #endif
 
 // Make sure, we use the absolute program path for argv[0]
-#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 1 && PYTHON_VERSION >= 0x300
+#if _NUITKA_NATIVE_WCHAR_ARGV == 1
+    original_argv0 = argv[0];
+#if PYTHON_VERSION >= 0x300 && !defined(_NUITKA_ONEFILE_MODE)
     orig_argv[0] = (wchar_t *)getBinaryFilenameWideChars(false);
+#endif
 #endif
 
     // Make sure the compiled path of Python is replaced.
@@ -1347,7 +1433,7 @@ orig_argv = argv;
 #endif
 
 // Workaround older Python not handling stream setup on redirected files properly.
-#if PYTHON_VERSION >= 0x340 && PYTHON_VERSION < 0x380
+#if PYTHON_VERSION >= 0x300 && PYTHON_VERSION < 0x380
     {
         char const *encoding = NULL;
 
@@ -1567,8 +1653,13 @@ orig_argv = argv;
 
 #if PYTHON_VERSION >= 0x300
     NUITKA_PRINT_TRACE("main(): Calling patchInspectModule().");
+
+// TODO: Python3.13 NoGIL: This is causing errors during bytecode import
+// that are unexplained.
+#if !defined(Py_GIL_DISABLED)
     patchInspectModule(tstate);
 #endif
+#endif
 
 #if PYTHON_VERSION >= 0x300 && SYSFLAG_NO_RANDOMIZATION == 1
     NUITKA_PRINT_TRACE("main(): Reverting to initial 'PYTHONHASHSEED' value.");
@@ -1632,13 +1723,13 @@ orig_argv = argv;
         } else {
             char const *kw_keys[] = {"pipe_handle", "parent_pid"};
             PyObject *kw_values[] = {
-                PyLong_FromLong(loky_joblib_pipe_handle_arg),
-                PyLong_FromLong(loky_joblib_parent_pid_arg),
+                Nuitka_PyLong_FromLong(loky_joblib_pipe_handle_arg),
+                Nuitka_PyLong_FromLong(loky_joblib_parent_pid_arg),
             };
 
             PyObject *kw_args = MAKE_DICT_X_CSTR(kw_keys, kw_values, sizeof(kw_values) / sizeof(PyObject *));
 
-            CALL_FUNCTION_WITH_KEYARGS(tstate, main_function, kw_args);
+            CALL_FUNCTION_WITH_KW_ARGS(tstate, main_function, kw_args);
         }
 
         int exit_code = HANDLE_PROGRAM_EXIT(tstate);
@@ -1672,7 +1763,8 @@ orig_argv = argv;
         PyObject *main_function = PyObject_GetAttrString(resource_tracker_module, "main");
         CHECK_OBJECT(main_function);
 
-        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function, PyInt_FromLong(multiprocessing_resource_tracker_arg));
+        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function,
+                                      Nuitka_PyInt_FromLong(multiprocessing_resource_tracker_arg));
 
         int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
@@ -1687,12 +1779,24 @@ orig_argv = argv;
         PyObject *main_function = PyObject_GetAttrString(resource_tracker_module, "main");
         CHECK_OBJECT(main_function);
 
-        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function, PyInt_FromLong(loky_resource_tracker_arg));
+        CALL_FUNCTION_WITH_SINGLE_ARG(tstate, main_function, Nuitka_PyInt_FromLong(loky_resource_tracker_arg));
 
         int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 
         NUITKA_PRINT_TRACE("main(): Calling 'joblib.externals.loky.backend.resource_tracker' Py_Exit.");
         Py_Exit(exit_code);
+    } else if (unlikely(is_anyio_to_process)) {
+        PyObject *anyio_module = EXECUTE_MAIN_MODULE(tstate, "anyio.to_process", false);
+
+        PyObject *main_function = PyObject_GetAttrString(anyio_module, "process_worker");
+        CHECK_OBJECT(main_function);
+
+        CALL_FUNCTION_NO_ARGS(tstate, main_function);
+
+        int exit_code = HANDLE_PROGRAM_EXIT(tstate);
+
+        NUITKA_PRINT_TRACE("main(): Calling 'anyio.to_process' Py_Exit.");
+        Py_Exit(exit_code);
     } else {
 #endif
 #if defined(_NUITKA_ONEFILE_MODE) && defined(_WIN32)

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -95,10 +95,12 @@ static char *appendModuleNameAsPath(char *buffer, char const *module_name, size_
 #if defined(_WIN32) && defined(_NUITKA_STANDALONE)
 
 static void appendModuleNameAsPathW(wchar_t *buffer, PyObject *module_name, size_t buffer_size) {
-    wchar_t const *module_name_wstr = PyUnicode_AsWideCharString(module_name, NULL);
+    Py_ssize_t size;
+    wchar_t const *module_name_wstr = Nuitka_UnicodeAsWideString(module_name, &size);
 
-    while (*module_name_wstr != 0) {
+    while (size > 0) {
         wchar_t c = *module_name_wstr++;
+        size -= 1;
 
         if (c == L'.') {
             c = SEP_L;
@@ -117,15 +119,11 @@ static void patchCodeObjectPaths(PyCodeObject *code_object, PyObject *module_pat
     code_object->co_filename = module_path;
     Py_INCREF(module_path);
 
-#ifndef PY_NOGIL
     Py_ssize_t consts_count = PyTuple_GET_SIZE(code_object->co_consts);
 
     for (Py_ssize_t i = 0; i < consts_count; i++) {
         PyObject *constant = PyTuple_GET_ITEM(code_object->co_consts, i);
-#else
-    for (Py_ssize_t i = 0; i < code_object->co_nconsts; i++) {
-        PyObject *constant = code_object->co_constants[i];
-#endif
+
         if (PyCode_Check(constant)) {
             patchCodeObjectPaths((PyCodeObject *)constant, module_path);
         }
@@ -404,7 +402,7 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
 
                 if (strncmp(filename_str, module_relative_name_str, strlen(module_relative_name_str)) == 0 &&
                     filename_str[strlen(module_relative_name_str)] == '.') {
-                    LIST_APPEND1(candidates, PyTuple_Pack(2, path_element, filename));
+                    LIST_APPEND1(candidates, MAKE_TUPLE2(tstate, path_element, filename));
                 }
             }
         }
@@ -474,11 +472,7 @@ static PyObject *callIntoInstalledExtensionModule(PyThreadState *tstate, PyObjec
     // create the string needed.
     assert(PyUnicode_CheckExact(extension_module_filename));
 
-#if PYTHON_VERSION < 0x300
-    wchar_t const *extension_module_filename_str = PyUnicode_AS_UNICODE(extension_module_filename);
-#else
-    wchar_t const *extension_module_filename_str = PyUnicode_AsWideCharString(extension_module_filename, NULL);
-#endif
+    wchar_t const *extension_module_filename_str = Nuitka_UnicodeAsWideString(extension_module_filename, NULL);
 #else
     char const *extension_module_filename_str = Nuitka_String_AsString(extension_module_filename);
 #endif
@@ -687,7 +681,7 @@ extern _Thread_local const char *pkgcontext;
 static const char *NuitkaImport_SwapPackageContext(const char *new_context) {
 // TODO: The locking APIs for 3.13 give errors here that are not explained
 // yet.
-#if PYTHON_VERSION >= 0x3c0 && PYTHON_VERSION < 0x3d0
+#if PYTHON_VERSION >= 0x3c0
     // spell-checker: ignore pkgcontext
     const char *old_context = _PyRuntime.imports.pkgcontext;
     _PyRuntime.imports.pkgcontext = new_context;
@@ -906,10 +900,11 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 
         Py_DECREF(path_list);
 
+        SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_True);
+
         Nuitka_SetModule(full_name_obj, module);
         Py_DECREF(full_name_obj);
 
-        SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_True);
         res = PyModule_ExecDef(module, def);
         SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_False);
 
@@ -940,7 +935,7 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 
         SET_ATTRIBUTE(tstate, module, const_str_plain___spec__, spec_value);
 
-        // Fixup __package__ after load. It seems some modules ignore _Py_PackageContext value.
+        // Fixup "__package__" after load. It seems some modules ignore _Py_PackageContext value.
         // so we patch it up here if it's None, but a package was specified.
         if (package != NULL) {
             PyObject *package_name = LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___package__);
@@ -961,6 +956,10 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     if (likely(def != NULL)) {
         def->m_base.m_init = entrypoint;
     }
+
+#if PYTHON_VERSION >= 0x3d0
+    Nuitka_SetModuleString(full_name, module);
+#endif
 #else
     PyModuleDef *def = PyModule_GetDef(module);
 
@@ -1044,7 +1043,7 @@ static void loadTriggeredModule(PyThreadState *tstate, char const *name, char co
     }
 }
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 static void _fixupSpecAttribute(PyThreadState *tstate, PyObject *module) {
     PyObject *spec_value = LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___spec__);
 
@@ -1469,7 +1468,7 @@ static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPat
     return result;
 }
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 
 static PyObject *_nuitka_loader_repr_module(PyObject *self, PyObject *args, PyObject *kwds) {
     PyObject *module;
@@ -1846,7 +1845,7 @@ static PyMethodDef Nuitka_Loader_methods[] = {
     {"find_module", (PyCFunction)_nuitka_loader_find_module, METH_STATIC | METH_VARARGS | METH_KEYWORDS, NULL},
     {"load_module", (PyCFunction)_nuitka_loader_load_module, METH_STATIC | METH_VARARGS | METH_KEYWORDS, NULL},
     {"is_package", (PyCFunction)_nuitka_loader_is_package, METH_STATIC | METH_VARARGS | METH_KEYWORDS, NULL},
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     {"module_repr", (PyCFunction)_nuitka_loader_repr_module, METH_STATIC | METH_VARARGS | METH_KEYWORDS, NULL},
     {"find_spec", (PyCFunction)_nuitka_loader_find_spec, METH_STATIC | METH_VARARGS | METH_KEYWORDS, NULL},
 #endif