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

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -23,7 +23,7 @@ stuff related to importing, and of course the generated code license.
 """
 
 template_global_copyright = """\
-/* Generated code for Python module '%(module_name)s'
+/* Generated code for Python module '%(module_identifier)s'
  * created by Nuitka version %(version)s
  *
  * This code is in part copyright %(year)s Kay Hayen.
@@ -130,47 +130,36 @@ extern PyTypeObject Nuitka_Loader_Type;
 // 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);
 
-function_impl_code functable_%(module_identifier)s[] = {
+static function_impl_code const function_table_%(module_identifier)s[] = {
 %(module_function_table_entries)s
     NULL
 };
 
-static char const *_reduce_compiled_function_argnames[] = {
-    "func",
-    NULL
-};
-
 static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
     PyObject *func;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:reduce_compiled_function", (char **)_reduce_compiled_function_argnames, &func, NULL)) {
+    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_STATE(tstate, PyExc_TypeError, "not a compiled function");
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "not a compiled function");
         return NULL;
     }
 
     struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)func;
 
-    function_impl_code *current = functable_%(module_identifier)s;
-    int offset = 0;
+    int offset = Nuitka_Function_GetFunctionCodeIndex(function, function_table_%(module_identifier)s);
 
-    while (*current != NULL) {
-        if (*current == function->m_c_code) {
-            break;
-        }
-
-        current += 1;
-        offset += 1;
-    }
-
-    if (*current == NULL) {
+    if (unlikely(offset == -1)) {
         PyThreadState *tstate = PyThreadState_GET();
-
+#if 0
+        PRINT_STRING("Looking for:");
+        PRINT_ITEM(func);
+        PRINT_NEW_LINE();
+#endif
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "Cannot find compiled function in module.");
         return NULL;
     }
@@ -185,11 +174,30 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
 
     CHECK_OBJECT_DEEP(code_object_desc);
 
-    PyObject *result = MAKE_TUPLE_EMPTY(4);
+
+    PyObject *result = MAKE_TUPLE_EMPTY(6);
     PyTuple_SET_ITEM(result, 0, PyLong_FromLong(offset));
     PyTuple_SET_ITEM(result, 1, code_object_desc);
     PyTuple_SET_ITEM0(result, 2, function->m_defaults);
-    PyTuple_SET_ITEM0(result, 3, function->m_doc != NULL ? function->m_doc : Py_None);
+#if PYTHON_VERSION >= 0x300
+    PyTuple_SET_ITEM0(result, 3, function->m_kwdefaults ? function->m_kwdefaults : Py_None);
+#else
+    PyTuple_SET_ITEM0(result, 3, Py_None);
+#endif
+    PyTuple_SET_ITEM0(result, 4, function->m_doc != NULL ? function->m_doc : Py_None);
+
+    if (offset == -5) {
+        CHECK_OBJECT(function->m_constant_return_value);
+        PyTuple_SET_ITEM0(result, 5, function->m_constant_return_value);
+    } else {
+        PyTuple_SET_ITEM0(result, 5, Py_None);
+    }
+
+#if PYTHON_VERSION >= 0x300
+    PyTuple_SET_ITEM0(result, 6, function->m_qualname);
+#else
+    PyTuple_SET_ITEM0(result, 6, Py_None);
+#endif
 
     CHECK_OBJECT_DEEP(result);
 
@@ -197,92 +205,48 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
 }
 
 static PyMethodDef _method_def_reduce_compiled_function = {"reduce_compiled_function", (PyCFunction)_reduce_compiled_function,
-                                                           METH_VARARGS | METH_KEYWORDS, NULL};
-
-static char const *_create_compiled_function_argnames[] = {
-    "func",
-    "code_object_desc",
-    "defaults",
-    "doc",
-    NULL
-};
+                                                           METH_VARARGS, NULL};
 
 
 static PyObject *_create_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
     CHECK_OBJECT_DEEP(args);
 
-    PyObject *func;
+    PyObject *function_index;
     PyObject *code_object_desc;
     PyObject *defaults;
+    PyObject *kw_defaults;
     PyObject *doc;
+    PyObject *constant_return_value;
+    PyObject *function_qualname;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOO:create_compiled_function", (char **)_create_compiled_function_argnames, &func, &code_object_desc, &defaults, &doc, NULL)) {
-        return NULL;
-    }
-
-    int offset = PyLong_AsLong(func);
-
-    if (offset == -1 && HAS_ERROR_OCCURRED(tstate)) {
+    if (!PyArg_ParseTuple(args, "OOOOOO:create_compiled_function", &function_index, &code_object_desc, &defaults, &kw_defaults, &doc, &constant_return_value, &function_qualname, NULL)) {
         return NULL;
     }
 
-    if (offset > sizeof(functable_%(module_identifier)s) || offset < 0) {
-        SET_CURRENT_EXCEPTION_TYPE0_STR_STATE(tstate, PyExc_TypeError, "Wrong offset for compiled function.");
-        return NULL;
-    }
-
-    PyObject *filename = PyTuple_GET_ITEM(code_object_desc, 0);
-    PyObject *function_name = PyTuple_GET_ITEM(code_object_desc, 1);
-    PyObject *line = PyTuple_GET_ITEM(code_object_desc, 2);
-    int line_int = PyLong_AsLong(line);
-    assert(!HAS_ERROR_OCCURRED(tstate));
-
-    PyObject *argnames = PyTuple_GET_ITEM(code_object_desc, 3);
-    PyObject *arg_count = PyTuple_GET_ITEM(code_object_desc, 4);
-    int arg_count_int = PyLong_AsLong(arg_count);
-    assert(!HAS_ERROR_OCCURRED(tstate));
-    PyObject *flags = PyTuple_GET_ITEM(code_object_desc, 5);
-    int flags_int = PyLong_AsLong(flags);
-    assert(!HAS_ERROR_OCCURRED(tstate));
-
-    PyCodeObject *code_object = MAKE_CODE_OBJECT(
-        filename,
-        line_int,
-        flags_int,
-        function_name,
-        function_name, // TODO: function_qualname
-        argnames,
-        NULL, // freevars
-        arg_count_int,
-        0, // TODO: Missing kw_only_count
-        0 // TODO: Missing pos_only_count
-    );
-
-    struct Nuitka_FunctionObject *result = Nuitka_Function_New(
-        functable_%(module_identifier)s[offset],
-        code_object->co_name,
 #if PYTHON_VERSION >= 0x300
-        NULL, // TODO: Not transferring qualname yet
-#endif
-        code_object,
-        defaults,
-#if PYTHON_VERSION >= 0x300
-        NULL, // kwdefaults are done on the outside currently
-        NULL, // TODO: Not transferring annotations
+    if (kw_defaults == Py_None) {
+        kw_defaults = NULL;
+    }
 #endif
+
+    return (PyObject *)Nuitka_Function_CreateFunctionViaCodeIndex(
         module_%(module_identifier)s,
+        function_qualname,
+        function_index,
+        code_object_desc,
+        constant_return_value,
+        defaults,
+        kw_defaults,
         doc,
-        NULL,
-        0
+        function_table_%(module_identifier)s,
+        sizeof(function_table_%(module_identifier)s) / sizeof(function_impl_code)
     );
-
-    return (PyObject *)result;
 }
 
 static PyMethodDef _method_def_create_compiled_function = {
     "create_compiled_function",
     (PyCFunction)_create_compiled_function,
-    METH_VARARGS | METH_KEYWORDS, NULL
+    METH_VARARGS, NULL
 };
 
 
@@ -291,7 +255,7 @@ static PyMethodDef _method_def_create_compiled_function = {
 // 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_name)s");
+    PGO_onModuleEntered("%(module_identifier)s");
 
     // Store the module for future use.
     module_%(module_identifier)s = module;
@@ -325,7 +289,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
 
         // Enable meta path based loader if not already done.
 #ifdef _NUITKA_TRACE
-        PRINT_STRING("%(module_name)s: Calling setupMetaPathBasedLoader().\n");
+        PRINT_STRING("%(module_identifier)s: Calling setupMetaPathBasedLoader().\n");
 #endif
         setupMetaPathBasedLoader(tstate);
 
@@ -336,7 +300,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
 #endif
 
         /* The constants only used by this module are created now. */
-        NUITKA_PRINT_TRACE("%(module_name)s: Calling createModuleConstants().\n");
+        NUITKA_PRINT_TRACE("%(module_identifier)s: Calling createModuleConstants().\n");
         createModuleConstants(tstate);
 
         createModuleCodeObjects();
@@ -465,7 +429,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
 %(module_code)s
 
     // Report to PGO about leaving the module without error.
-    PGO_onModuleExit("%(module_name)s", false);
+    PGO_onModuleExit("%(module_identifier)s", false);
 
     Py_INCREF(module_%(module_identifier)s);
     return module_%(module_identifier)s;
@@ -560,7 +524,7 @@ static struct PyModuleDef mdef_%(module_identifier)s = {
  */
 
 // Actual name might be different when loaded as a package.
-static char const *module_full_name = "%(module_name)s";
+static char const *module_full_name = %(module_name_cstr)s;
 
 MOD_INIT_DECL(%(module_identifier)s) {
     if (_Py_PackageContext != NULL) {
@@ -583,8 +547,10 @@ MOD_INIT_DECL(%(module_identifier)s) {
     PyObject *module = PyModule_Create(&mdef_%(module_identifier)s);
     CHECK_OBJECT(module);
 
-    bool res = Nuitka_SetModuleString(module_full_name, module);
-    assert(res != false);
+    {
+        NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModuleString(module_full_name, module);
+        assert(res != false);
+    }
 #endif
 
     PyThreadState *tstate = PyThreadState_GET();

nuitka/code_generation/templates_c/HelperDictionaryCopy.c.j2

@@ -41,7 +41,7 @@ else
             PyObject *value = entry->me_value;
             {{ per_value_code }}
 
-            int res = PyDict_SetItem({{ result }}, key, value);
+            NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem({{ result }}, key, value);
             assert(res == 0);
 
 {% if value_ref == 1 %}
@@ -241,7 +241,7 @@ else
 
                 {{ per_value_code }}
 
-                int res = PyDict_SetItem({{ result }}, key, value);
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem({{ result }}, key, value);
                 assert(res == 0);
 
 {% if value_ref == 1 %}
@@ -263,7 +263,7 @@ else
 
             {{ per_value_code }}
 
-            int res = PyDict_SetItem({{ result }}, key, value);
+            NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem({{ result }}, key, value);
             assert(res == 0);
 
 {% if value_ref == 1 %}

nuitka/code_generation/templates_c/HelperOperationComparisonUnicode.c.j2

@@ -46,7 +46,7 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
     } else {
         int kind1 = PyUnicode_KIND(a);
         if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
@@ -54,7 +54,7 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
 
         int kind2 = PyUnicode_KIND(b);
         if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);

nuitka/distutils/DistutilCommands.py

@@ -323,6 +323,9 @@ class build(distutils.command.build.build):
                 for option, value in toml_options.get("nuitka", {}).items():
                     command.extend(self._parseOptionsEntry(option, value))
 
+                for option, value in toml_options.get("tool.nuitka", {}).items():
+                    command.extend(self._parseOptionsEntry(option, value))
+
             # Process any extra options from setuptools
             if "nuitka" in self.distribution.command_options:
                 for option, value in self.distribution.command_options[

nuitka/finalizations/FinalizeMarkups.py

@@ -136,7 +136,7 @@ class FinalizeMarkups(VisitorNoopMixin):
             if (
                 node.isExpressionYield()
                 or node.isExpressionYieldFrom()
-                or node.isExpressionYieldFromWaitable()
+                or node.isExpressionYieldFromAwaitable()
             ):
                 search = node.getParent()
 

nuitka/freezer/DependsExe.py

@@ -53,6 +53,7 @@ def getDependsExePath():
         depends_url = "https://dependencywalker.com/depends22_x64.zip"
 
     return getCachedDownload(
+        name="dependency walker",
         url=depends_url,
         is_arch_specific=getArchitecture(),
         binary="depends.exe",
@@ -216,7 +217,7 @@ SxS
                 "-f1",
                 "-pa1",
                 "-ps1",
-                binary_filename,
+                getExternalUsePath(binary_filename),
             ),
             external_cwd=True,
         )

nuitka/freezer/DllDependenciesPosix.py

@@ -28,7 +28,11 @@ from nuitka.PythonFlavors import isAnacondaPython
 from nuitka.Tracing import inclusion_logger
 from nuitka.utils.Execution import executeProcess, withEnvironmentPathAdded
 from nuitka.utils.SharedLibraries import getSharedLibraryRPATH
-from nuitka.utils.Utils import isAlpineLinux, isPosixWindows
+from nuitka.utils.Utils import (
+    isAlpineLinux,
+    isAndroidBasedLinux,
+    isPosixWindows,
+)
 
 from .DllDependenciesCommon import getLdLibraryPath
 
@@ -204,6 +208,9 @@ _linux_dll_ignore_list = [
     # The DRM layer should also be taken from the OS in question and won't
     # allow loading native drivers otherwise.
     "libdrm.so",
+    # The zlib can be assumed to be everywhere, and outside dependencies
+    # may actually load it.
+    "libz.so",
 ]
 
 if isAnacondaPython() or isAlpineLinux():
@@ -211,3 +218,6 @@ if isAnacondaPython() or isAlpineLinux():
     # so they have to be included.
     # Alpine linux does not include `libstdc++.so` by default.
     _linux_dll_ignore_list.remove("libstdc++.so")
+
+if isAndroidBasedLinux():
+    _linux_dll_ignore_list.remove("libz.so")

nuitka/freezer/IncludedEntryPoints.py

@@ -37,7 +37,7 @@ from nuitka.utils.FileOperations import (
     isRelativePath,
 )
 from nuitka.utils.Importing import getSharedLibrarySuffix
-from nuitka.utils.ModuleNames import ModuleName
+from nuitka.utils.ModuleNames import ModuleName, checkModuleName
 from nuitka.utils.SharedLibraries import getDLLVersion
 
 IncludedEntryPoint = collections.namedtuple(
@@ -47,6 +47,7 @@ IncludedEntryPoint = collections.namedtuple(
         "kind",
         "source_path",
         "dest_path",
+        "module_name",
         "package_name",
         "executable",
         "reason",
@@ -56,7 +57,7 @@ IncludedEntryPoint = collections.namedtuple(
 
 # Since inheritance is not a thing with namedtuple, have factory functions
 def _makeIncludedEntryPoint(
-    logger, kind, source_path, dest_path, package_name, reason, executable
+    logger, kind, source_path, dest_path, module_name, package_name, reason, executable
 ):
     if package_name is not None:
         package_name = ModuleName(package_name)
@@ -70,23 +71,30 @@ def _makeIncludedEntryPoint(
     assert not hasFilenameExtension(path=source_path, extensions=(".qml", ".json"))
 
     return IncludedEntryPoint(
-        logger,
-        kind,
-        source_path,
-        os.path.normpath(dest_path),
-        package_name,
-        executable,
-        reason,
+        logger=logger,
+        kind=kind,
+        source_path=source_path,
+        dest_path=os.path.normpath(dest_path),
+        module_name=module_name,
+        package_name=package_name,
+        executable=executable,
+        reason=reason,
     )
 
 
 def _makeDllOrExeEntryPoint(
-    logger, kind, source_path, dest_path, package_name, reason, executable
+    logger, kind, source_path, dest_path, module_name, package_name, reason, executable
 ):
     assert type(dest_path) not in (tuple, list)
     assert type(source_path) not in (tuple, list)
     assert isRelativePath(dest_path), dest_path
     assert ".dist" not in dest_path, dest_path
+    if module_name is not None:
+        assert checkModuleName(module_name), module_name
+        module_name = ModuleName(module_name)
+    if package_name is not None:
+        assert checkModuleName(package_name), package_name
+        package_name = ModuleName(package_name)
 
     if not os.path.isfile(source_path):
         logger.sysexit(
@@ -99,42 +107,52 @@ def _makeDllOrExeEntryPoint(
         kind=kind,
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=executable,
     )
 
 
-def makeExtensionModuleEntryPoint(logger, source_path, dest_path, package_name, reason):
+def makeExtensionModuleEntryPoint(
+    logger, source_path, dest_path, module_name, package_name, reason
+):
     return _makeDllOrExeEntryPoint(
         logger=logger,
         kind="extension",
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=False,
     )
 
 
-def makeDllEntryPoint(logger, source_path, dest_path, package_name, reason):
+def makeDllEntryPoint(
+    logger, source_path, dest_path, module_name, package_name, reason
+):
     return _makeDllOrExeEntryPoint(
         logger=logger,
         kind="dll",
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=False,
     )
 
 
-def makeExeEntryPoint(logger, source_path, dest_path, package_name, reason):
+def makeExeEntryPoint(
+    logger, source_path, dest_path, module_name, package_name, reason
+):
     return _makeDllOrExeEntryPoint(
         logger=logger,
         kind="exe",
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=True,
@@ -147,6 +165,7 @@ def makeMainExecutableEntryPoint(dest_path):
         kind="executable",
         source_path=dest_path,
         dest_path=os.path.basename(dest_path),
+        module_name=None,
         package_name=None,
         reason="main binary",
         executable=True,
@@ -159,6 +178,7 @@ def _makeIgnoredEntryPoint(entry_point):
         kind=entry_point.kind + "_ignored",
         source_path=entry_point.source_path,
         dest_path=entry_point.dest_path,
+        module_name=entry_point.module_name,
         package_name=entry_point.package_name,
         reason=entry_point.reason,
         executable=entry_point.executable,
@@ -176,7 +196,7 @@ def _getTopLevelPackageName(package_name):
 
 
 def _warnNonIdenticalEntryPoints(entry_point1, entry_point2):
-    # Well know case, where they duplicate all the DLLs, seems to work well
+    # Well know cases, where they duplicate all the DLLs, seems to work well
     # enough to not report this. TODO: When we are adding to the report, it
     # ought to be still added. spell-checker: ignore scipy
     if frozenset(
@@ -187,10 +207,27 @@ def _warnNonIdenticalEntryPoints(entry_point1, entry_point2):
     ) == frozenset(("numpy", "scipy")):
         return
 
+    if frozenset(
+        (
+            _getTopLevelPackageName(entry_point1.package_name),
+            _getTopLevelPackageName(entry_point2.package_name),
+        )
+    ) == frozenset(("av", "cv2")):
+        return
+
+    def _describe(entry_point):
+        if entry_point.package_name:
+            return "'%s' of package '%s'" % (
+                entry_point.source_path,
+                entry_point.package_name,
+            )
+        else:
+            return "'%s'" % entry_point.source_path
+
     inclusion_logger.warning(
         """\
-Ignoring non-identical DLLs for '%s', '%s' different from '%s'. Using first one and hoping for the best."""
-        % (entry_point1.dest_path, entry_point1.source_path, entry_point2.source_path)
+Ignoring non-identical DLLs for %s, %s different from %s. Using first one and hoping for the best."""
+        % (entry_point1.dest_path, _describe(entry_point1), _describe(entry_point2))
     )
 
 
@@ -291,6 +328,7 @@ def addExtensionModuleEntryPoint(module):
             source_path=module.getFilename(),
             dest_path=module.getFullName().asPath()
             + getSharedLibrarySuffix(preferred=False),
+            module_name=module.getFullName(),
             package_name=module.getFullName().getPackageName(),
             reason="required extension module for CPython library startup"
             if module.isTechnical()

nuitka/freezer/Onefile.py

@@ -27,7 +27,6 @@ from nuitka import Options, OutputDirectories
 from nuitka.build.SconsInterface import (
     asBoolStr,
     cleanSconsDirectory,
-    getSconsDataPath,
     runScons,
     setCommonSconsOptions,
 )
@@ -69,7 +68,7 @@ def packDistFolderToOnefile(dist_dir):
     Plugins.onOnefileFinished(onefile_output_filename)
 
 
-def _runOnefileScons(onefile_compression):
+def _runOnefileScons(onefile_compression, onefile_archive):
     source_dir = OutputDirectories.getSourceDirectoryPath(onefile=True)
 
     # Let plugins do their thing for onefile mode too.
@@ -81,7 +80,6 @@ def _runOnefileScons(onefile_compression):
         "source_dir": source_dir,
         "debug_mode": asBoolStr(Options.is_debug),
         "trace_mode": asBoolStr(Options.shallTraceExecution()),
-        "nuitka_src": getSconsDataPath(),
         "onefile_splash_screen": asBoolStr(
             Options.getWindowsSplashScreen() is not None
         ),
@@ -93,6 +91,7 @@ def _runOnefileScons(onefile_compression):
     env_values["_NUITKA_ONEFILE_TEMP_BOOL"] = "1" if isOnefileTempDirMode() else "0"
     env_values["_NUITKA_ONEFILE_COMPRESSION_BOOL"] = "1" if onefile_compression else "0"
     env_values["_NUITKA_ONEFILE_BUILD_BOOL"] = "1" if onefile_compression else "0"
+    env_values["_NUITKA_ONEFILE_ARCHIVE_BOOL"] = "1" if onefile_archive else "0"
 
     # Allow plugins to build definitions.
     env_values.update(Plugins.getBuildDefinitions())
@@ -173,6 +172,8 @@ def runOnefileCompressor(
             onefile_output_filename=onefile_output_filename,
             start_binary=start_binary,
             expect_compression=compressor_python is not None,
+            as_archive=Options.shallOnefileAsArchive(),
+            use_compression_cache=not Options.shallDisableCompressionCacheUsage(),
             file_checksums=file_checksums,
             win_path_sep=win_path_sep,
             low_memory=Options.isLowMemory(),
@@ -206,6 +207,8 @@ def runOnefileCompressor(
                     str(file_checksums),
                     str(win_path_sep),
                     str(Options.isLowMemory()),
+                    str(Options.shallOnefileAsArchive()),
+                    str(not Options.shallDisableCompressionCacheUsage()),
                 ],
                 shell=False,
             )
@@ -243,6 +246,7 @@ def packDistFolderToOnefileBootstrap(onefile_output_filename, dist_dir):
     # Create the bootstrap binary for unpacking.
     _runOnefileScons(
         onefile_compression=compressor_python is not None,
+        onefile_archive=Options.shallOnefileAsArchive(),
     )
 
     if isWin32Windows():