Nuitka-winsvc 2.5.1__cp311-cp311-win_amd64.whl → 2.6__cp311-cp311-win_amd64.whl

nuitka/build/SconsCaching.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Caching of C compiler output.
@@ -98,6 +98,7 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
                         message="Nuitka will make use of ccache to speed up repeated compilation.",
                         reject=None,
                         assume_yes_for_downloads=assume_yes_for_downloads,
+                        download_ok=True,
                     )
 
     else:
@@ -282,11 +283,12 @@ def _getCcacheStatistics(ccache_logfile):
         # can be matched against it.
         commands = {}
 
-        # Due to upstream issues, lines in the log might have different encodings.
-        # All command and result lines use the platform's default encoding,
-        # so we follow this to ensure these lines are correct.
-        # Unrecognized characters are replaced by byte values, e.g. "\xde\xad"
-        for line in getFileContentByLine(ccache_logfile, errors="backslashreplace"):
+        # Due to upstream ccache issues, lines in the log might have different
+        # encodings, but latin1 will always work and was chosen to write this
+        # file therefore.
+        for line in getFileContentByLine(
+            ccache_logfile, encoding="latin1", errors="backslashreplace"
+        ):
             match = re_command.match(line)
 
             if match:
@@ -321,7 +323,7 @@ def _getCcacheStatistics(ccache_logfile):
                     all_text = []
 
                     for line2 in getFileContentByLine(
-                        ccache_logfile, errors="backslashreplace"
+                        ccache_logfile, encoding="latin1", errors="backslashreplace"
                     ):
                         match = re_anything.match(line2)
 

nuitka/build/SconsCompilerSettings.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ This contains the tuning of the compilers towards defined goals.
@@ -211,6 +211,22 @@ version for lto mode (>= 4.6). Disabled."""
         lto_mode = False
         reason = "gcc 4.6 is doesn't have good enough LTO support"
 
+    if (
+        lto_mode
+        and env.gcc_mode
+        and not env.clang_mode
+        and not isWin32Windows()
+        and not isMacOS()
+        and getExecutablePath("make", env=env) is None
+    ):
+        scons_logger.warning(
+            """\
+The gcc compiler for LTO mode requires 'make' to be installed \
+for parallel linking to be used, compilation might be a lot \
+slower without it.
+"""
+        )
+
     if env.gcc_mode and lto_mode:
         if env.clang_mode:
             env.Append(CCFLAGS=["-flto"])
@@ -246,16 +262,17 @@ version for lto mode (>= 4.6). Disabled."""
 
     env.lto_mode = lto_mode
     env.orig_lto_mode = orig_lto_mode
+    env.pgo_mode = pgo_mode
 
     # PGO configuration
-    _enablePgoSettings(env, pgo_mode)
+    _enablePgoSettings(env)
 
 
 _python311_min_msvc_version = (14, 3)
 
 
 def checkWindowsCompilerFound(
-    env, target_arch, clang_mode, msvc_version, assume_yes_for_downloads
+    env, target_arch, clang_mode, msvc_version, assume_yes_for_downloads, download_ok
 ):
     """Remove compiler of wrong arch or too old gcc and replace with downloaded winlibs gcc."""
     # Many cases to deal with, pylint: disable=too-many-branches,too-many-statements
@@ -397,6 +414,7 @@ For Python version %s MSVC %s or later is required, not %s which is too old."""
             compiler_path = getCachedDownloadedMinGW64(
                 target_arch=target_arch,
                 assume_yes_for_downloads=assume_yes_for_downloads,
+                download_ok=download_ok,
             )
 
             if compiler_path is not None:
@@ -435,6 +453,12 @@ def decideConstantsBlobResourceMode(env, module_mode):
     elif isMacOS():
         resource_mode = "mac_section"
         reason = "default for macOS"
+    elif env.gcc_mode and env.clang_mode and env.clang_version >= (19,):
+        resource_mode = "c23_embed"
+        reason = "default for newer clang"
+    elif env.gcc_mode and not env.clang_mode and env.gcc_version >= (15,):
+        resource_mode = "c23_embed"
+        reason = "default for newer gcc"
     elif env.lto_mode and env.gcc_mode and not env.clang_mode:
         if module_mode:
             resource_mode = "code"
@@ -526,7 +550,7 @@ unsigned char const *getConstantsBlobData(void) {
                 ),
             ]
         )
-    elif resource_mode == "code":
+    elif resource_mode in ("code", "c23_embed"):
         # Indicate "code" resource mode.
         env.Append(CPPDEFINES=["_NUITKA_CONSTANTS_FROM_CODE"])
 
@@ -549,19 +573,22 @@ unsigned char constant_bin_data[] =\n{\n
 """
                 )
 
-                with open(blob_filename, "rb") as f:
-                    content = f.read()
-                for count, stream_byte in enumerate(content):
-                    if count % 16 == 0:
-                        if count > 0:
-                            output.write("\n")
+                if resource_mode == "code":
+                    with open(blob_filename, "rb") as f:
+                        content = f.read()
+                    for count, stream_byte in enumerate(content):
+                        if count % 16 == 0:
+                            if count > 0:
+                                output.write("\n")
 
-                        output.write("   ")
+                            output.write("   ")
 
-                    if str is bytes:
-                        stream_byte = ord(stream_byte)
+                        if str is bytes:
+                            stream_byte = ord(stream_byte)
 
-                    output.write(" 0x%02x," % stream_byte)
+                        output.write(" 0x%02x," % stream_byte)
+                else:
+                    output.write('#embed "%s"\n' % blob_filename)
 
                 output.write("\n};\n")
 
@@ -810,10 +837,8 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
     if env.mingw_mode and env.target_arch == "x86_64" and env.python_version < (3, 12):
         env.Append(CPPDEFINES=["MS_WIN64"])
 
-    # For shell API usage to lookup app folders we need this. Note that on Windows ARM
-    # we didn't manage to have a "shell32.lib" that is not considered corrupt, so we
-    # have to do this.
-    if env.msvc_mode and env.target_arch != "arm64":
+    # For shell API usage to lookup app folders we need this.
+    if env.msvc_mode:
         env.Append(LIBS=["Shell32", "Advapi32"])
 
     # Since Fedora 36, the system Python will not link otherwise.
@@ -839,13 +864,13 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
             env.Append(LIBS="z")
 
 
-def _enablePgoSettings(env, pgo_mode):
-    if pgo_mode == "no":
+def _enablePgoSettings(env):
+    if env.pgo_mode == "no":
         env.progressbar_name = "Backend"
-    elif pgo_mode == "python":
+    elif env.pgo_mode == "python":
         env.progressbar_name = "Python Profile"
         env.Append(CPPDEFINES=["_NUITKA_PGO_PYTHON"])
-    elif pgo_mode == "generate":
+    elif env.pgo_mode == "generate":
         env.progressbar_name = "Profile"
         env.Append(CPPDEFINES=["_NUITKA_PGO_GENERATE"])
 
@@ -862,7 +887,7 @@ def _enablePgoSettings(env, pgo_mode):
             scons_logger.sysexit(
                 "Error, PGO not supported for '%s' compiler." % env.the_cc_name
             )
-    elif pgo_mode == "use":
+    elif env.pgo_mode == "use":
         env.progressbar_name = "Backend"
 
         env.Append(CPPDEFINES=["_NUITKA_PGO_USE"])
@@ -884,8 +909,6 @@ def _enablePgoSettings(env, pgo_mode):
     else:
         assert False, env.pgo_mode
 
-    env.pgo_mode = pgo_mode
-
 
 def _enableDebugSystemSettings(env, job_count):
     if env.unstripped_mode:
@@ -1002,15 +1025,15 @@ def reportCCompiler(env, context, output_func):
             ".".join(str(d) for d in env.gcc_version),
         )
     elif isClangName(env.the_cc_name):
-        clang_version = myDetectVersion(env, env.the_cc_name)
-        if clang_version is None:
-            clang_version = "not found"
-        else:
-            clang_version = ".".join(str(d) for d in clang_version)
+        env.clang_version = myDetectVersion(env, env.the_cc_name)
 
         cc_output = "%s %s" % (
             env.the_cc_name,
-            clang_version,
+            (
+                ".".join(str(d) for d in env.clang_version)
+                if env.clang_version is not None
+                else "not found"
+            ),
         )
     else:
         cc_output = env.the_cc_name

nuitka/build/SconsHacks.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Hacks for scons that we apply.
@@ -170,7 +170,7 @@ def getEnhancedToolDetect():
     return myDetect
 
 
-def makeGccUseLinkerFile(source_files, module_mode, env):
+def makeGccUseLinkerFile(env, source_files):
     tmp_linker_filename = os.path.join(env.source_dir, "@link_input.txt")
 
     # Note: For Windows, it's done in mingw.py because of its use of
@@ -188,7 +188,7 @@ def makeGccUseLinkerFile(source_files, module_mode, env):
     with openTextFile(tmp_linker_filename, "w") as tmpfile:
         for filename in source_files:
             filename = ".".join(filename.split(".")[:-1]) + (
-                ".os" if module_mode and os.name != "nt" else ".o"
+                ".os" if env.module_mode and os.name != "nt" else ".o"
             )
 
             if os.name == "nt":

nuitka/build/SconsInterface.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Scons interface.
@@ -18,9 +18,16 @@ from nuitka import Options, Tracing
 from nuitka.__past__ import unicode
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.Options import (
+    getDebugModeIndications,
+    getExperimentalIndications,
+    getJobLimit,
     getOnefileChildGraceTime,
+    getPythonPathForScons,
+    isDeploymentMode,
     isExperimental,
     isOnefileMode,
+    isShowScons,
+    shallCompileWithoutBuildDirectory,
 )
 from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonFlavors import (
@@ -31,6 +38,7 @@ from nuitka.PythonFlavors import (
 )
 from nuitka.PythonVersions import (
     getSystemPrefixPath,
+    isPythonWithGil,
     python_version,
     python_version_str,
 )
@@ -111,7 +119,7 @@ def _getPythonForSconsExePath():
 
     Scons needs it as it doesn't support all Python versions.
     """
-    python_exe = Options.getPythonPathForScons()
+    python_exe = getPythonPathForScons()
 
     if python_exe is not None:
         return python_exe
@@ -234,7 +242,7 @@ def _buildSconsCommand(options, scons_filename):
 
     scons_command = _getSconsBinaryCall()
 
-    if not Options.isShowScons():
+    if not isShowScons():
         scons_command.append("--quiet")
 
     scons_command += [
@@ -243,14 +251,14 @@ def _buildSconsCommand(options, scons_filename):
         getExternalUsePath(os.path.join(getSconsDataPath(), scons_filename)),
         # Parallel compilation.
         "--jobs",
-        str(Options.getJobLimit()),
+        str(getJobLimit()),
         # Do not warn about deprecation from Scons
         "--warn=no-deprecated",
         # Don't load "site_scons" at all.
         "--no-site-dir",
     ]
 
-    if Options.isShowScons():
+    if isShowScons():
         scons_command.append("--debug=stacktrace")
 
     # Python2, encoding unicode values
@@ -280,6 +288,14 @@ def _createSconsDebugScript(source_dir, scons_command):
     # we wrote debug shell script only if build process called, not "--version" call.
     scons_debug_python_name = "scons-debug.py"
 
+    # Reduce environment variables from unusable stuff that is also very runtime
+    # dependent, spell-checker: ignore COLORTERM
+    env = OrderedDict(
+        (key, value)
+        for (key, value) in os.environ.items()
+        if not key.startswith(("VSCODE", "GIT", "WSL", "COLORTERM", "TERM"))
+    )
+
     putTextFileContents(
         filename=os.path.join(source_dir, scons_debug_python_name),
         contents="""\
@@ -291,10 +307,13 @@ import subprocess
 
 exit_code = subprocess.call(
     %(scons_command)r,
-    env=%(env)r,
+    env={%(env)s}
     shell=False
 )"""
-        % {"scons_command": scons_command, "env": dict(os.environ)},
+        % {
+            "scons_command": scons_command,
+            "env": ",".join("%r: %r" % (key, value) for key, value in env.items()),
+        },
         encoding="utf8",
     )
 
@@ -331,24 +350,26 @@ cd "${0%/*}"
     )
 
 
-def runScons(options, env_values, scons_filename):
+def runScons(scons_options, env_values, scons_filename):
     with _setupSconsEnvironment():
         env_values["_NUITKA_BUILD_DEFINITIONS_CATALOG"] = ",".join(env_values.keys())
 
-        if "source_dir" in options and Options.shallCompileWithoutBuildDirectory():
+        if "source_dir" in scons_options and shallCompileWithoutBuildDirectory():
             # Make sure we become non-local, by changing all paths to be
             # absolute, but ones that can be resolved by any program
             # externally, as the Python of Scons may not be good at unicode.
 
-            options = copy.deepcopy(options)
-            source_dir = options["source_dir"]
-            options["source_dir"] = "."
-            options["nuitka_src"] = getExternalUsePath(options["nuitka_src"])
+            scons_options = copy.deepcopy(scons_options)
+            source_dir = scons_options["source_dir"]
+            scons_options["source_dir"] = "."
+            scons_options["nuitka_src"] = getExternalUsePath(
+                scons_options["nuitka_src"]
+            )
 
-            orig_result_exe = options.get("result_exe")
-            if "result_exe" in options:
-                options["result_exe"] = getExternalUsePath(
-                    options["result_exe"], only_dirname=True
+            orig_result_exe = scons_options.get("result_exe")
+            if "result_exe" in scons_options:
+                scons_options["result_exe"] = getExternalUsePath(
+                    scons_options["result_exe"], only_dirname=True
                 )
 
         else:
@@ -361,10 +382,10 @@ def runScons(options, env_values, scons_filename):
         env_values["NUITKA_QUIET"] = "1" if Tracing.is_quiet else "0"
 
         scons_command = _buildSconsCommand(
-            options=options, scons_filename=scons_filename
+            options=scons_options, scons_filename=scons_filename
         )
 
-        if Options.isShowScons():
+        if isShowScons():
             Tracing.scons_logger.info("Scons command: %s" % " ".join(scons_command))
 
         Tracing.flushStandardOutputs()
@@ -386,10 +407,10 @@ def runScons(options, env_values, scons_filename):
         # current source_dir.
         flushSconsReports()
 
-        if "source_dir" in options and result == 0:
-            if "result_exe" in options:
+        if "source_dir" in scons_options and result == 0:
+            if "result_exe" in scons_options:
                 scons_created_exe = getSconsReportValue(
-                    source_dir or options["source_dir"], "TARGET"
+                    source_dir or scons_options["source_dir"], "TARGET"
                 )
 
                 if not os.path.exists(scons_created_exe):
@@ -398,10 +419,10 @@ def runScons(options, env_values, scons_filename):
                         % scons_created_exe
                     )
 
-                if not areSamePaths(options["result_exe"], scons_created_exe):
+                if not areSamePaths(scons_options["result_exe"], scons_created_exe):
                     renameFile(scons_created_exe, orig_result_exe)
 
-            checkCachingSuccess(source_dir or options["source_dir"])
+            checkCachingSuccess(source_dir or scons_options["source_dir"])
 
         return result == 0
 
@@ -458,85 +479,90 @@ def cleanSconsDirectory(source_dir):
                 check(path)
 
 
-def setCommonSconsOptions(options):
+def getCommonSconsOptions():
     # Scons gets transported many details, that we express as variables, and
-    # have checks for them, leading to many branches and statements,
+    # have checks for them, leading to many branches and statements.
     # pylint: disable=too-many-branches,too-many-statements
-    options["nuitka_src"] = getSconsDataPath()
 
-    options["python_version"] = python_version_str
+    scons_options = OrderedDict()
 
-    options["python_prefix"] = getDirectoryRealPath(getSystemPrefixPath())
+    scons_options["nuitka_src"] = getSconsDataPath()
 
-    options["experimental"] = ",".join(Options.getExperimentalIndications())
+    scons_options["python_version"] = python_version_str
 
-    options["debug_modes"] = ",".join(Options.getDebugModeIndications())
+    scons_options["python_prefix"] = getDirectoryRealPath(getSystemPrefixPath())
 
-    options["no_deployment"] = ",".join(Options.getNoDeploymentIndications())
+    scons_options["experimental"] = ",".join(getExperimentalIndications())
+
+    scons_options["debug_modes"] = ",".join(getDebugModeIndications())
+
+    scons_options["deployment"] = asBoolStr(isDeploymentMode())
+
+    scons_options["no_deployment"] = ",".join(Options.getNoDeploymentIndications())
 
     if Options.shallRunInDebugger():
-        options["full_names"] = asBoolStr(True)
+        scons_options["full_names"] = asBoolStr(True)
 
     if Options.assumeYesForDownloads():
-        options["assume_yes_for_downloads"] = asBoolStr(True)
+        scons_options["assume_yes_for_downloads"] = asBoolStr(True)
 
     if not Options.shallUseProgressBar():
-        options["progress_bar"] = asBoolStr(False)
+        scons_options["progress_bar"] = asBoolStr(False)
 
     if Options.isClang():
-        options["clang_mode"] = asBoolStr(True)
+        scons_options["clang_mode"] = asBoolStr(True)
 
     if Options.isShowScons():
-        options["show_scons"] = asBoolStr(True)
+        scons_options["show_scons"] = asBoolStr(True)
 
     if Options.isMingw64():
-        options["mingw_mode"] = asBoolStr(True)
+        scons_options["mingw_mode"] = asBoolStr(True)
 
     if Options.getMsvcVersion():
-        options["msvc_version"] = Options.getMsvcVersion()
+        scons_options["msvc_version"] = Options.getMsvcVersion()
 
     if Options.shallDisableCCacheUsage():
-        options["disable_ccache"] = asBoolStr(True)
+        scons_options["disable_ccache"] = asBoolStr(True)
 
     if isWin32Windows() and Options.getWindowsConsoleMode() != "attach":
-        options["console_mode"] = Options.getWindowsConsoleMode()
+        scons_options["console_mode"] = Options.getWindowsConsoleMode()
 
     if Options.getLtoMode() != "auto":
-        options["lto_mode"] = Options.getLtoMode()
+        scons_options["lto_mode"] = Options.getLtoMode()
 
     if isWin32OrPosixWindows() or isMacOS():
-        options["noelf_mode"] = asBoolStr(True)
+        scons_options["noelf_mode"] = asBoolStr(True)
 
     if Options.isUnstripped():
-        options["unstripped_mode"] = asBoolStr(True)
+        scons_options["unstripped_mode"] = asBoolStr(True)
 
     if isAnacondaPython():
-        options["anaconda_python"] = asBoolStr(True)
+        scons_options["anaconda_python"] = asBoolStr(True)
 
     if isMSYS2MingwPython():
-        options["msys2_mingw_python"] = asBoolStr(True)
+        scons_options["msys2_mingw_python"] = asBoolStr(True)
 
     if isSelfCompiledPythonUninstalled():
-        options["self_compiled_python_uninstalled"] = asBoolStr(True)
+        scons_options["self_compiled_python_uninstalled"] = asBoolStr(True)
 
     cpp_defines = Plugins.getPreprocessorSymbols()
     if cpp_defines:
-        options["cpp_defines"] = ",".join(
+        scons_options["cpp_defines"] = ",".join(
             "%s%s%s" % (key, "=" if value else "", value or "")
             for key, value in cpp_defines.items()
         )
 
     cpp_include_dirs = Plugins.getExtraIncludeDirectories()
     if cpp_include_dirs:
-        options["cpp_include_dirs"] = ",".join(cpp_include_dirs)
+        scons_options["cpp_include_dirs"] = ",".join(cpp_include_dirs)
 
     link_dirs = Plugins.getExtraLinkDirectories()
     if link_dirs:
-        options["link_dirs"] = ",".join(link_dirs)
+        scons_options["link_dirs"] = ",".join(link_dirs)
 
     link_libraries = Plugins.getExtraLinkLibraries()
     if link_libraries:
-        options["link_libraries"] = ",".join(link_libraries)
+        scons_options["link_libraries"] = ",".join(link_libraries)
 
     if isMacOS():
         macos_min_version = detectBinaryMinMacOS(sys.executable)
@@ -546,14 +572,14 @@ def setCommonSconsOptions(options):
                 "Could not detect minimum macOS version for '%s'." % sys.executable
             )
 
-        options["macos_min_version"] = macos_min_version
+        scons_options["macos_min_version"] = macos_min_version
 
-        options["macos_target_arch"] = Options.getMacOSTargetArch()
+        scons_options["macos_target_arch"] = Options.getMacOSTargetArch()
 
-    options["target_arch"] = getArchitecture()
+    scons_options["target_arch"] = getArchitecture()
 
     if Options.getFcfProtectionMode() != "auto":
-        options["cf_protection"] = Options.getFcfProtectionMode()
+        scons_options["cf_protection"] = Options.getFcfProtectionMode()
 
     env_values = OrderedDict()
 
@@ -598,7 +624,11 @@ def setCommonSconsOptions(options):
             getOnefileChildGraceTime()
         )
 
-    return env_values
+    return scons_options, env_values
+
+
+def setPythonTargetOptions(scons_options):
+    scons_options["gil_mode"] = asBoolStr(isPythonWithGil())
 
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/SconsProgress.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Progress bar for Scons compilation part.
@@ -48,10 +48,17 @@ def updateSconsProgressBar():
     if _current == _total:
         closeSconsProgressBar()
 
-        scons_logger.info(
-            "%s linking program with %d files (no progress information available for this stage)."
-            % (_stage, _total)
-        )
+        message = "%s C linking" % _stage
+
+        if _total > 1:
+            message += (
+                " with %d files (no progress information available for this stage)"
+                % _total
+            )
+
+        message += "."
+
+        scons_logger.info(message)
 
 
 def closeSconsProgressBar():

nuitka/build/SconsSpawn.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Spawning processes.
@@ -415,10 +415,10 @@ it or using '--clang' option."""
     return spawnCommand
 
 
-def enableSpawnMonitoring(env, module_mode, source_files):
+def enableSpawnMonitoring(env, source_files):
     if os.name == "nt":
         env["SPAWN"] = _getWindowsSpawnFunction(
-            env=env, module_mode=module_mode, source_files=source_files
+            env=env, module_mode=env.module_mode, source_files=source_files
         )
     else:
         env["SPAWN"] = _getWrappedSpawnFunction(env=env)

nuitka/build/SconsUtils.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Helper functions for the scons file.
@@ -20,8 +20,10 @@ from nuitka.Tracing import scons_details_logger, scons_logger
 from nuitka.utils.Execution import executeProcess
 from nuitka.utils.FileOperations import (
     changeFilenameExtension,
+    deleteFile,
     getFileContentByLine,
     getFilenameExtension,
+    getNormalizedPath,
     getWindowsShortPathName,
     hasFilenameExtension,
     isFilesystemEncodable,
@@ -854,6 +856,23 @@ def addBinaryBlobSection(env, blob_filename, section_name):
         assert False
 
 
+def makeResultPathFileSystemEncodable(env, result_exe):
+    deleteFile(result_exe, must_exist=False)
+
+    if os.name == "nt" and not isFilesystemEncodable(result_exe):
+        result_exe = os.path.join(
+            os.path.dirname(result_exe),
+            "_nuitka_temp.pyd" if env.module_mode else "_nuitka_temp.exe",
+        )
+
+        if not isFilesystemEncodable(result_exe):
+            result_exe = getNormalizedPath(os.path.relpath(result_exe))
+
+            deleteFile(result_exe, must_exist=False)
+
+    return result_exe
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/build/__init__.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Dummy file to make this directory a package. """