Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -77,7 +77,7 @@ static bool hasFrozenModule(char const *name) {
     return true;
 }
 
-static char *appendModulenameAsPath(char *buffer, char const *module_name, size_t buffer_size) {
+static char *appendModuleNameAsPath(char *buffer, char const *module_name, size_t buffer_size) {
     // Skip to the end
     while (*buffer != 0) {
         buffer++;
@@ -105,7 +105,7 @@ static char *appendModulenameAsPath(char *buffer, char const *module_name, size_
 
 #if defined(_WIN32) && defined(_NUITKA_STANDALONE)
 
-static void appendModulenameAsPathW(wchar_t *buffer, char const *module_name, size_t buffer_size) {
+static void appendModuleNameAsPathW(wchar_t *buffer, char const *module_name, size_t buffer_size) {
     // Skip to the end
     while (*buffer != 0) {
         buffer++;
@@ -150,7 +150,7 @@ static void patchCodeObjectPaths(PyCodeObject *code_object, PyObject *module_pat
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_RELATIVE_PATH_FROM_NAME(char const *name, bool is_package, bool dir_only) {
     char buffer[MAXPATHLEN + 1] = {0};
 
-    appendModulenameAsPath(buffer, name, sizeof(buffer));
+    appendModuleNameAsPath(buffer, name, sizeof(buffer));
 
     if (dir_only == false) {
         if (is_package) {
@@ -184,15 +184,17 @@ static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_o
                                           bool is_package) {
     assert(code_object != NULL);
 
-    bool b_res = Nuitka_SetModuleString(name, module);
-    assert(b_res != false);
+    {
+        NUITKA_MAY_BE_UNUSED bool b_res = Nuitka_SetModuleString(name, module);
+        assert(b_res != false);
+    }
 
     char buffer[MAXPATHLEN + 1] = {0};
 
     PyObject *module_path_entry = NULL;
 
     if (is_package) {
-        appendModulenameAsPath(buffer, name, sizeof(buffer));
+        appendModuleNameAsPath(buffer, name, sizeof(buffer));
         PyObject *module_path_entry_base = Nuitka_String_FromString(buffer);
 
         module_path_entry = MAKE_RELATIVE_PATH(module_path_entry_base);
@@ -201,7 +203,7 @@ static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_o
         appendCharSafe(buffer, SEP, sizeof(buffer));
         appendStringSafe(buffer, "__init__.py", sizeof(buffer));
     } else {
-        appendModulenameAsPath(buffer, name, sizeof(buffer));
+        appendModuleNameAsPath(buffer, name, sizeof(buffer));
         appendStringSafe(buffer, ".py", sizeof(buffer));
     }
 
@@ -386,7 +388,7 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
     PyObject *candidates = MAKE_LIST_EMPTY(0);
 
     // Search only relative to the parent name of course.
-    char const *module_relname_str = Nuitka_String_AsString(module_name) + strlen(parent_module_name) + 1;
+    char const *module_relative_name_str = Nuitka_String_AsString(module_name) + strlen(parent_module_name) + 1;
 
     Py_ssize_t parent_path_size = PyList_GET_SIZE(parent_path);
 
@@ -408,8 +410,8 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
             if (Nuitka_String_CheckExact(filename)) {
                 char const *filename_str = Nuitka_String_AsString(filename);
 
-                if (strncmp(filename_str, module_relname_str, strlen(module_relname_str)) == 0 &&
-                    filename_str[strlen(module_relname_str)] == '.') {
+                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));
                 }
             }
@@ -419,7 +421,7 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
 #if 0
     PRINT_STRING("CANDIDATES:");
     PRINT_STRING(Nuitka_String_AsString(module_name));
-    PRINT_STRING(module_relname_str);
+    PRINT_STRING(module_relative_name_str);
     PRINT_ITEM(candidates);
     PRINT_NEW_LINE();
 #endif
@@ -442,7 +444,7 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
 
             char const *candidate_str = Nuitka_String_AsString(candidate);
 
-            if (strcmp(suffix_str, candidate_str + strlen(module_relname_str)) == 0) {
+            if (strcmp(suffix_str, candidate_str + strlen(module_relative_name_str)) == 0) {
                 PyObject *fullpath = JOIN_PATH2(directory, candidate);
 
                 if (installed_extension_modules == NULL) {
@@ -723,6 +725,8 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 #else
     // This code would work for all versions, we are avoiding access to interpreter
     // structure internals of 3.8 or higher.
+    // spell-checker: ignore getdlopenflags,dlopenflags
+
     static PyObject *dlopenflags_object = NULL;
     if (dlopenflags_object == NULL) {
         dlopenflags_object = CALL_FUNCTION_NO_ARGS(tstate, Nuitka_SysGetObject("getdlopenflags"));
@@ -985,14 +989,14 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
 
         appendWStringSafeW(filename, getBinaryDirectoryWideChars(true), sizeof(filename) / sizeof(wchar_t));
         appendCharSafeW(filename, SEP, sizeof(filename) / sizeof(wchar_t));
-        appendModulenameAsPathW(filename, entry->name, sizeof(filename) / sizeof(wchar_t));
+        appendModuleNameAsPathW(filename, entry->name, sizeof(filename) / sizeof(wchar_t));
         appendStringSafeW(filename, ".pyd", sizeof(filename) / sizeof(wchar_t));
 #else
         char filename[MAXPATHLEN + 1] = {0};
 
         appendStringSafe(filename, getBinaryDirectoryHostEncoded(true), sizeof(filename));
         appendCharSafe(filename, SEP, sizeof(filename));
-        appendModulenameAsPath(filename, entry->name, sizeof(filename));
+        appendModuleNameAsPath(filename, entry->name, sizeof(filename));
         appendStringSafe(filename, ".so", sizeof(filename));
 
 #endif
@@ -1027,15 +1031,20 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
         assert((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) == 0);
         assert(entry->python_initfunc);
 
-        bool res = Nuitka_SetModule(module_name, module);
-        assert(res != false);
+        {
+            NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModule(module_name, module);
+            assert(res != false);
+        }
 
         // Run the compiled module code, we get the module returned.
+#if PYTHON_VERSION < 0x300
+        NUITKA_MAY_BE_UNUSED
+#endif
         PyObject *result = entry->python_initfunc(tstate, module, entry);
         CHECK_OBJECT_X(result);
 
-#if PYTHON_VERSION >= 0x340
-        if (result != NULL) {
+#if PYTHON_VERSION >= 0x300
+        if (likely(result != NULL)) {
             _fixupSpecAttribute(tstate, result);
         }
 #endif
@@ -1822,8 +1831,8 @@ static PyObject *Nuitka_Loader_get__module__(struct Nuitka_LoaderObject *loader,
     return result;
 }
 
-static PyGetSetDef Nuitka_Loader_getsets[] = {{(char *)"__module__", (getter)Nuitka_Loader_get__module__, NULL, NULL},
-                                              {NULL}};
+static PyGetSetDef Nuitka_Loader_tp_getset[] = {{(char *)"__module__", (getter)Nuitka_Loader_get__module__, NULL, NULL},
+                                                {NULL}};
 
 PyTypeObject Nuitka_Loader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "nuitka_module_loader",
@@ -1854,7 +1863,7 @@ PyTypeObject Nuitka_Loader_Type = {
     0,                                       // tp_iternext
     Nuitka_Loader_methods,                   // tp_methods
     0,                                       // tp_members
-    Nuitka_Loader_getsets,                   // tp_getset
+    Nuitka_Loader_tp_getset,                 // tp_getset
 };
 
 /* Used by modules to register child loaders for packages. */
@@ -1924,8 +1933,11 @@ void registerMetaPathBasedUnfreezer(struct Nuitka_MetaPathBasedLoaderEntry *_loa
     Nuitka_PyType_Ready(&Nuitka_Loader_Type, NULL, true, false, false, false, false);
 
 #ifdef _NUITKA_EXE
-    int res = PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_loader_type", (PyObject *)&Nuitka_Loader_Type);
-    assert(res == 0);
+    {
+        NUITKA_MAY_BE_UNUSED int res =
+            PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_loader_type", (PyObject *)&Nuitka_Loader_Type);
+        assert(res == 0);
+    }
 #endif
 
 #if PYTHON_VERSION >= 0x370
@@ -1967,6 +1979,7 @@ void setEarlyFrozenModulesFileAttribute(PyThreadState *tstate) {
                 PyObject *file_value = MAKE_RELATIVE_PATH_FROM_NAME(Nuitka_String_AsString(key), is_package, false);
                 PyObject_SetAttr(value, const_str_plain___file__, file_value);
                 Py_DECREF(file_value);
+                CHECK_OBJECT(file_value);
             }
         }
     }

nuitka/build/static_src/MetaPathBasedLoaderImportlibMetadataDistribution.c

@@ -76,8 +76,10 @@ class nuitka_distribution(Distribution):\n\
             importlib_metadata_distribution = PyObject_GetAttrString(module, "distribution");
             CHECK_OBJECT(importlib_metadata_distribution);
 
-            bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_distribution_patch");
-            assert(bool_res != false);
+            {
+                NUITKA_MAY_BE_UNUSED bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_distribution_patch");
+                assert(bool_res != false);
+            }
 
             Py_DECREF(module);
         }

nuitka/build/static_src/MetaPathBasedLoaderResourceReaderFiles.c

@@ -137,8 +137,10 @@ static PyObject *Nuitka_ResourceReaderFiles_iterdir(struct Nuitka_ResourceReader
         CHECK_OBJECT(joined);
 
         PyObject *files_object = Nuitka_ResourceReaderFiles_New(tstate, files->m_loader_entry, joined);
-        bool res = LIST_APPEND1(files_objects, files_object);
-        assert(res);
+        {
+            NUITKA_MAY_BE_UNUSED bool res = LIST_APPEND1(files_objects, files_object);
+            assert(res);
+        }
 
         CHECK_OBJECT(files_object);
         Py_DECREF(joined);
@@ -314,6 +316,39 @@ static PyObject *Nuitka_ResourceReaderFiles_joinpath(struct Nuitka_ResourceReade
     return result;
 }
 
+//    def def as_posix(self):
+//        """
+//        Return Traversable child in self
+//        """
+//
+
+static PyObject *Nuitka_ResourceReaderFiles_as_posix(struct Nuitka_ResourceReaderFilesObject *files, PyObject *args,
+                                                     PyObject *kwds) {
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *path = _Nuitka_ResourceReaderFiles_GetPath(tstate, files);
+
+#ifdef _WIN32
+
+#if PYTHON_VERSION < 0x300
+    PyObject *result;
+
+    if (PyString_Check(path)) {
+        result = STR_REPLACE3(tstate, path, const_str_backslash, const_str_slash);
+    } else {
+        result = UNICODE_REPLACE3(tstate, path, const_str_backslash, const_str_slash);
+    }
+#else
+    PyObject *result = UNICODE_REPLACE3(tstate, path, const_str_backslash, const_str_slash);
+#endif
+
+    Py_DECREF(path);
+
+    return result;
+#else
+    return path;
+#endif
+}
+
 PyObject *Nuitka_ResourceReaderFiles_nb_truediv(struct Nuitka_ResourceReaderFilesObject *files, PyObject *arg) {
     PyObject *joined;
 
@@ -424,6 +459,7 @@ static PyMethodDef Nuitka_ResourceReaderFiles_methods[] = {
     {"__exit__", (PyCFunction)Nuitka_ResourceReaderFiles_exit, METH_VARARGS, NULL},
     {"__fspath__", (PyCFunction)Nuitka_ResourceReaderFiles_fspath, METH_NOARGS, NULL},
     {"absolute", (PyCFunction)Nuitka_ResourceReaderFiles_absolute, METH_NOARGS, NULL},
+    {"as_posix", (PyCFunction)Nuitka_ResourceReaderFiles_as_posix, METH_NOARGS, NULL},
 
     // Nuitka specific, for "importlib.resource.as_file" overload.
     {"as_file", (PyCFunction)Nuitka_ResourceReaderFiles_as_file, METH_NOARGS, NULL},

nuitka/build/static_src/OnefileBootstrap.c

@@ -84,10 +84,6 @@
 #define _NUITKA_AUTO_UPDATE_BOOL 1
 #define _NUITKA_AUTO_UPDATE_URL_SPEC "https://..."
 
-#if __APPLE__
-#define _NUITKA_PAYLOAD_FROM_MACOS_SECTION
-#endif
-
 #endif
 
 #if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
@@ -111,10 +107,15 @@
 #include "decompress/zstd_decompress_block.c"
 #endif
 
-// Some handy macro definitions, e.g. unlikely.
+// Some handy macro definitions, e.g. unlikely and NUITKA_MAY_BE_UNUSED
 #include "nuitka/hedley.h"
 #define likely(x) HEDLEY_LIKELY(x)
 #define unlikely(x) HEDLEY_UNLIKELY(x)
+#ifdef __GNUC__
+#define NUITKA_MAY_BE_UNUSED __attribute__((__unused__))
+#else
+#define NUITKA_MAY_BE_UNUSED
+#endif
 
 #include "HelpersChecksumTools.c"
 #include "HelpersFilesystemPaths.c"
@@ -134,7 +135,9 @@ static void fatalIOError(char const *message, error_code_t error_code) {
 }
 
 // Failure to expand the template for where to extract to.
-static void fatalErrorTempFiles(void) { fatalError("Error, couldn't runtime expand target path."); }
+static void fatalErrorTempFiles(void) {
+    fatalIOError("Error, couldn't unpack file to target path.", getLastErrorCode());
+}
 
 #if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
 static void fatalErrorAttachedData(void) { fatalError("Error, couldn't decode attached data."); }
@@ -142,11 +145,10 @@ static void fatalErrorAttachedData(void) { fatalError("Error, couldn't decode at
 
 static void fatalErrorHeaderAttachedData(void) { fatalError("Error, couldn't find attached data header."); }
 
-// Left over data in attached payload should not happen.
-static void fatalErrorReadAttachedData(void) { fatalError("Error, couldn't read attached data."); }
-
 // Out of memory error.
+#if !defined(_WIN32) || _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
 static void fatalErrorMemory(void) { fatalError("Error, couldn't allocate memory."); }
+#endif
 
 // Could not launch child process.
 static void fatalErrorChild(char const *message, error_code_t error_code) { fatalIOError(message, error_code); }
@@ -205,27 +207,21 @@ static void setEnvironVar(char const *var_name, char const *value) {
 
 static unsigned char const *payload_data = NULL;
 static unsigned char const *payload_current = NULL;
-static size_t stream_end_pos;
+static unsigned long long payload_size = 0;
 
-#ifdef _NUITKA_PAYLOAD_FROM_MACOS_SECTION
+#ifdef __APPLE__
 
 #include <mach-o/getsect.h>
 #include <mach-o/ldsyms.h>
 
-static unsigned char *findMacOSBinarySection(void) {
+static void initPayloadData(void) {
     const struct mach_header *header = &_mh_execute_header;
 
     unsigned long section_size;
 
-    unsigned char *result = getsectiondata(header, "payload", "payload", &section_size);
-    stream_end_pos = (size_t)section_size;
-
-    return result;
-}
-
-static void initPayloadData(void) {
-    payload_data = findMacOSBinarySection();
+    payload_data = getsectiondata(header, "payload", "payload", &section_size);
     payload_current = payload_data;
+    payload_size = section_size;
 }
 
 static void closePayloadData(void) {}
@@ -233,9 +229,12 @@ static void closePayloadData(void) {}
 #elif defined(_WIN32)
 
 static void initPayloadData(void) {
-    payload_data =
-        (const unsigned char *)LockResource(LoadResource(NULL, FindResource(NULL, MAKEINTRESOURCE(27), RT_RCDATA)));
+    HRSRC windows_resource = FindResource(NULL, MAKEINTRESOURCE(27), RT_RCDATA);
+
+    payload_data = (const unsigned char *)LockResource(LoadResource(NULL, windows_resource));
     payload_current = payload_data;
+
+    payload_size = SizeofResource(NULL, windows_resource);
 }
 
 // Note: it appears unlocking the resource is not actually foreseen.
@@ -296,10 +295,6 @@ static void releaseZSTD(void) {
 
 #endif
 
-#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
-static size_t getPosition(void) { return payload_current - payload_data; }
-#endif
-
 static void readChunk(void *buffer, size_t size) {
     // printf("Reading %d\n", size);
 
@@ -307,21 +302,8 @@ static void readChunk(void *buffer, size_t size) {
     payload_current += size;
 }
 
-#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
-static void const *readChunkPointer(size_t size) {
-    // printf("Reading %d\n", size);
-
-    void const *result = payload_current;
-    payload_current += size;
-
-    return result;
-}
-#endif
-
 static void readPayloadChunk(void *buffer, size_t size) {
-#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
-
-    // bool no_payload = false;
+#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1 && _NUITKA_ONEFILE_ARCHIVE_BOOL == 0
     bool end_of_buffer = false;
 
     // Loop until finished with asked chunk.
@@ -372,28 +354,7 @@ static void readPayloadChunk(void *buffer, size_t size) {
         if (input.size != input.pos) {
             fatalErrorAttachedData();
         }
-
-        // No input available, make it available from stream respecting end.
-        size_t to_read = ZSTD_DStreamInSize();
-        size_t payload_available = stream_end_pos - getPosition();
-
-        static size_t payload_so_far = 0;
-
-        if (payload_available == 0) {
-            continue;
-        }
-
-        if (to_read > payload_available) {
-            to_read = payload_available;
-        }
-
-        input.src = readChunkPointer(to_read);
-        input.pos = 0;
-        input.size = to_read;
-
-        payload_so_far += to_read;
     }
-
 #else
     readChunk(buffer, size);
 #endif
@@ -424,6 +385,15 @@ static unsigned long long readPayloadSizeValue(void) {
     return result;
 }
 
+#if _NUITKA_ONEFILE_ARCHIVE_BOOL == 1 && _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
+static unsigned long long readArchiveFileSizeValue(void) {
+    unsigned long long result;
+    readPayloadChunk(&result, sizeof(unsigned int));
+
+    return result;
+}
+#endif
+
 static filename_char_t readPayloadFilenameCharacter(void) {
     filename_char_t result;
 
@@ -450,6 +420,74 @@ static filename_char_t *readPayloadFilename(void) {
     return buffer;
 }
 
+static void writeContainedFile(FILE_HANDLE target_file, unsigned long long file_size) {
+#if _NUITKA_ONEFILE_ARCHIVE_BOOL == 1
+
+#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 0
+    if (target_file != FILE_HANDLE_NULL) {
+        if (writeFileChunk(target_file, payload_current, file_size) == false) {
+            fatalErrorTempFiles();
+        }
+    }
+
+    payload_current += file_size;
+#else
+    if (target_file != FILE_HANDLE_NULL) {
+
+        // Nothing available, make sure to make it available from existing input.
+        while (input.pos < input.size) {
+            // printf("available input %ld %ld\n", input.pos, input.size);
+
+            output.pos = 0;
+            output.size = ZSTD_DStreamOutSize();
+
+            size_t const ret = ZSTD_decompressStream(dest_ctx, &output, &input);
+            if (ZSTD_isError(ret)) {
+                fatalErrorAttachedData();
+            }
+
+            // printf("available output %ld %ld\n", output.pos, output.size);
+
+            if (writeFileChunk(target_file, (char const *)output.dst, output.pos) == false) {
+                fatalErrorTempFiles();
+            }
+
+            // printf("made output %ld %lld\n", output.pos, file_size);
+            file_size -= output.pos;
+            assert(file_size >= 0);
+        }
+
+        assert(file_size == 0);
+    }
+#endif
+#else
+    while (file_size > 0) {
+        static char chunk[32768];
+
+        long chunk_size;
+
+        // Doing min manually, as otherwise the compiler is confused from types.
+        if (file_size <= sizeof(chunk)) {
+            chunk_size = (long)file_size;
+        } else {
+            chunk_size = sizeof(chunk);
+        }
+
+        readPayloadChunk(chunk, chunk_size);
+
+        if (target_file != FILE_HANDLE_NULL) {
+            if (writeFileChunk(target_file, chunk, chunk_size) == false) {
+                fatalErrorTempFiles();
+            }
+        }
+
+        file_size -= chunk_size;
+    }
+
+    assert(file_size == 0);
+#endif
+}
+
 // Zero means, not yet created, created unsuccessfully, terminated already.
 #if defined(_WIN32)
 HANDLE handle_process = 0;
@@ -1019,20 +1057,18 @@ int main(int argc, char **argv) {
 
     initPayloadData();
 
-#if !defined(_NUITKA_PAYLOAD_FROM_MACOS_SECTION) && !defined(_WIN32)
+#if !defined(__APPLE__) && !defined(_WIN32)
     const off_t size_end_offset = exe_file_mapped.file_size;
 
     NUITKA_PRINT_TIMING("ONEFILE: Determining payload start position.");
 
-    unsigned long long payload_size;
+    assert(sizeof(payload_size) == sizeof(unsigned long long));
     memcpy(&payload_size, payload_data + size_end_offset - sizeof(payload_size), sizeof(payload_size));
 
     unsigned long long start_pos = size_end_offset - sizeof(payload_size) - payload_size;
 
     payload_current += start_pos;
     payload_data += start_pos;
-
-    stream_end_pos = size_end_offset - sizeof(payload_size) - start_pos;
 #endif
 
     NUITKA_PRINT_TIMING("ONEFILE: Checking header for compression.");
@@ -1044,12 +1080,20 @@ int main(int argc, char **argv) {
         fatalErrorHeaderAttachedData();
     }
 
+    NUITKA_PRINT_TIMING("ONEFILE: Header is OK.");
+
 // The 'X' stands for no compression, 'Y' is compressed, handle that.
 #if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
     if (header[2] != 'Y') {
         fatalErrorHeaderAttachedData();
     }
     initZSTD();
+
+    input.src = payload_current;
+    input.pos = 0;
+    input.size = payload_size;
+
+    assert(payload_size > 0);
 #else
     if (header[2] != 'X') {
         fatalErrorHeaderAttachedData();
@@ -1134,6 +1178,20 @@ int main(int argc, char **argv) {
         }
 #endif
 
+#if _NUITKA_ONEFILE_ARCHIVE_BOOL == 1
+#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
+        uint32_t contained_archive_file_size = readArchiveFileSizeValue();
+
+        input.src = payload_current;
+        input.pos = 0;
+        input.size = contained_archive_file_size;
+
+        output.pos = 0;
+        output.size = 0;
+
+        payload_current += contained_archive_file_size;
+#endif
+#endif
         FILE_HANDLE target_file = FILE_HANDLE_NULL;
 
         if (needs_write) {
@@ -1141,34 +1199,7 @@ int main(int argc, char **argv) {
             target_file = createFileForWritingChecked(target_path);
         }
 
-        while (file_size > 0) {
-            static char chunk[32768];
-
-            long chunk_size;
-
-            // Doing min manually, as otherwise the compiler is confused from types.
-            if (file_size <= sizeof(chunk)) {
-                chunk_size = (long)file_size;
-            } else {
-                chunk_size = sizeof(chunk);
-            }
-
-            // TODO: Does zstd support skipping data as well, such that we
-            // do not have to fully decode.
-            readPayloadChunk(chunk, chunk_size);
-
-            if (target_file != FILE_HANDLE_NULL) {
-                if (writeFileChunk(target_file, chunk, chunk_size) == false) {
-                    fatalErrorTempFiles();
-                }
-            }
-
-            file_size -= chunk_size;
-        }
-
-        if (file_size != 0) {
-            fatalErrorReadAttachedData();
-        }
+        writeContainedFile(target_file, file_size);
 
 #if !defined(_WIN32) && !defined(__MSYS__)
         if ((file_flags & 1) && (target_file != FILE_HANDLE_NULL)) {

nuitka/code_generation/CodeGeneration.py

@@ -364,8 +364,8 @@ from .VariableCodes import (
 )
 from .YieldCodes import (
     generateYieldCode,
+    generateYieldFromAwaitableCode,
     generateYieldFromCode,
-    generateYieldFromWaitableCode,
 )
 
 _generated_functions = {}
@@ -776,6 +776,7 @@ addExpressionDispatchDict(
         "EXPRESSION_FUNCTION_CREATION_OLD": generateFunctionCreationCode,
         "EXPRESSION_FUNCTION_CALL": generateFunctionCallCode,
         "EXPRESSION_FUNCTION_ERROR_STR": generateFunctionErrorStrCode,
+        "EXPRESSION_IMPORT_MODULE_BUILTIN": generateImportModuleFixedCode,
         "EXPRESSION_IMPORT_MODULE_FIXED": generateImportModuleFixedCode,
         "EXPRESSION_IMPORT_MODULE_HARD": generateImportModuleHardCode,
         "EXPRESSION_IMPORT_MODULE_NAME_HARD_MAYBE_EXISTS": generateImportModuleNameHardCode,
@@ -865,7 +866,7 @@ addExpressionDispatchDict(
         "EXPRESSION_VARIABLE_OR_BUILTIN_REF": generateVariableReferenceCode,
         "EXPRESSION_YIELD": generateYieldCode,
         "EXPRESSION_YIELD_FROM": generateYieldFromCode,
-        "EXPRESSION_YIELD_FROM_WAITABLE": generateYieldFromWaitableCode,
+        "EXPRESSION_YIELD_FROM_AWAITABLE": generateYieldFromAwaitableCode,
         "EXPRESSION_ASYNC_WAIT": generateAsyncWaitCode,
         "EXPRESSION_ASYNC_WAIT_ENTER": generateAsyncWaitCode,
         "EXPRESSION_ASYNC_WAIT_EXIT": generateAsyncWaitCode,
@@ -916,6 +917,7 @@ addExpressionDispatchDict(
         "EXPRESSION_OS_PATH_ISFILE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_OS_PATH_ISDIR_REF": generateImportModuleNameHardCode,
         "EXPRESSION_OS_PATH_BASENAME_REF": generateImportModuleNameHardCode,
+        "EXPRESSION_BUILTINS_OPEN_REF": generateImportModuleNameHardCode,
         "EXPRESSION_CTYPES_CDLL_REF": generateImportModuleNameHardCode,
         "EXPRESSION_CTYPES_CDLL_SINCE38_CALL": generateCtypesCdllCallCode,
         "EXPRESSION_CTYPES_CDLL_BEFORE38_CALL": generateCtypesCdllCallCode,

nuitka/code_generation/CodeObjectCodes.py

@@ -22,6 +22,7 @@ Right now only the creation is done here. But more should be added later on.
 
 import os
 
+from nuitka.__past__ import unicode
 from nuitka.Options import getFileReferenceMode
 from nuitka.PythonVersions import python_version
 
@@ -113,8 +114,11 @@ def getCodeObjectsInitCode(context):
     else:
         template = "module_filename_obj = MAKE_RELATIVE_PATH(%s); CHECK_OBJECT(module_filename_obj);"
 
+    if str is bytes and type(module_filename) is unicode:
+        module_filename = module_filename.encode("utf8")
+
     # The code object will not work from any other type, cannot be e.g. unicode.
-    assert type(module_filename) is str, type(module_filename)
+    assert type(module_filename) is str, (type(module_filename), module_filename)
 
     statements.append(template % (context.getConstantCode(constant=module_filename)))
 

nuitka/code_generation/ConstantCodes.py

@@ -187,3 +187,7 @@ def addDistributionMetadataValue(name, distribution):
     package_name = getDistributionTopLevelPackageNames(distribution)[0]
 
     metadata_values[name] = (package_name, metadata, entry_points)
+
+
+def getDistributionMetadataValues():
+    return sorted(tuple(metadata_values.items()))