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

nuitka/build/SconsInterface.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Scons interface.
 
 Interaction with scons. Find the binary, and run it with a set of given
@@ -31,29 +17,41 @@ import sys
 from nuitka import Options, Tracing
 from nuitka.__past__ import unicode
 from nuitka.containers.OrderedDicts import OrderedDict
-from nuitka.Options import getOnefileChildGraceTime, isOnefileMode
+from nuitka.Options import (
+    getOnefileChildGraceTime,
+    isExperimental,
+    isOnefileMode,
+)
 from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonFlavors import (
     isAnacondaPython,
     isMSYS2MingwPython,
     isNuitkaPython,
+    isSelfCompiledPythonUninstalled,
 )
 from nuitka.PythonVersions import (
     getSystemPrefixPath,
-    getTargetPythonDLLPath,
     python_version,
+    python_version_str,
 )
+from nuitka.utils.AppDirs import getCacheDirEnvironmentVariableName
+from nuitka.utils.Download import getDownloadCacheDir, getDownloadCacheName
 from nuitka.utils.Execution import (
     getExecutablePath,
     withEnvironmentVarsOverridden,
 )
 from nuitka.utils.FileOperations import (
+    areSamePaths,
+    changeFilenameExtension,
     deleteFile,
     getDirectoryRealPath,
     getExternalUsePath,
     getWindowsShortPathName,
     hasFilenameExtension,
     listDir,
+    makePath,
+    putTextFileContents,
+    renameFile,
     withDirectoryChange,
 )
 from nuitka.utils.InstalledPythons import findInstalledPython
@@ -66,7 +64,7 @@ from nuitka.utils.Utils import (
 )
 
 from .SconsCaching import checkCachingSuccess
-from .SconsUtils import flushSconsReports
+from .SconsUtils import flushSconsReports, getSconsReportValue
 
 
 def getSconsDataPath():
@@ -90,7 +88,7 @@ def _getSconsBinaryCall():
 
     inline_path = os.path.join(_getSconsInlinePath(), "bin", "scons.py")
 
-    if os.path.exists(inline_path):
+    if os.path.exists(inline_path) and not isExperimental("force-system-scons"):
         return [
             _getPythonForSconsExePath(),
             "-W",
@@ -118,7 +116,17 @@ def _getPythonForSconsExePath():
     if python_exe is not None:
         return python_exe
 
-    scons_supported_pythons = ("3.5", "3.6", "3.7", "3.8", "3.9", "3.10", "3.11")
+    scons_supported_pythons = (
+        "3.5",
+        "3.6",
+        "3.7",
+        "3.8",
+        "3.9",
+        "3.10",
+        "3.11",
+        "3.12",
+        "3.13",
+    )
     if not isWin32Windows():
         scons_supported_pythons += ("2.7", "2.6")
 
@@ -150,14 +158,7 @@ Anaconda Python.
 
 
 @contextlib.contextmanager
-def _setupSconsEnvironment2(scons_filename):
-    is_backend = scons_filename == "Backend.scons"
-
-    if is_backend and isWin32Windows() and not Options.shallUseStaticLibPython():
-        # On Win32, we use the Python.DLL path for some things. We pass it
-        # via environment variable
-        os.environ["NUITKA_PYTHON_DLL_PATH"] = getTargetPythonDLLPath()
-
+def _setupSconsEnvironment2():
     os.environ["NUITKA_PYTHON_EXE_PATH"] = sys.executable
 
     # Remove environment variables that can only harm if we have to switch
@@ -179,6 +180,14 @@ def _setupSconsEnvironment2(scons_filename):
 
     os.environ["NUITKA_PACKAGE_DIR"] = os.path.abspath(nuitka.__path__[0])
 
+    # When downloading in Scons, use the external path.
+    if isWin32Windows():
+        download_cache_dir = getDownloadCacheDir()
+        makePath(download_cache_dir)
+        os.environ[getCacheDirEnvironmentVariableName(getDownloadCacheName())] = (
+            getExternalUsePath(download_cache_dir)
+        )
+
     yield
 
     if old_pythonpath is not None:
@@ -187,16 +196,13 @@ def _setupSconsEnvironment2(scons_filename):
     if old_pythonhome is not None:
         os.environ["PYTHONHOME"] = old_pythonhome
 
-    if "NUITKA_PYTHON_DLL_PATH" in os.environ:
-        del os.environ["NUITKA_PYTHON_DLL_PATH"]
-
     del os.environ["NUITKA_PYTHON_EXE_PATH"]
 
     del os.environ["NUITKA_PACKAGE_DIR"]
 
 
 @contextlib.contextmanager
-def _setupSconsEnvironment(scons_filename):
+def _setupSconsEnvironment():
     """Setup the scons execution environment.
 
     For the target Python we provide "NUITKA_PYTHON_DLL_PATH" to see where the
@@ -215,7 +221,7 @@ def _setupSconsEnvironment(scons_filename):
         change_dir = None
 
     with withDirectoryChange(change_dir, allow_none=True):
-        with _setupSconsEnvironment2(scons_filename=scons_filename):
+        with _setupSconsEnvironment2():
             yield
 
 
@@ -270,8 +276,63 @@ def _buildSconsCommand(options, scons_filename):
     return scons_command
 
 
+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"
+
+    putTextFileContents(
+        filename=os.path.join(source_dir, scons_debug_python_name),
+        contents="""\
+# -*- coding: utf-8 -*-
+
+import sys
+import os
+import subprocess
+
+exit_code = subprocess.call(
+    %(scons_command)r,
+    env=%(env)r,
+    shell=False
+)"""
+        % {"scons_command": scons_command, "env": dict(os.environ)},
+        encoding="utf8",
+    )
+
+    if isWin32Windows():
+        script_extension = ".bat"
+
+        script_prelude = """\
+cd "%~dp0"
+                    """
+    else:
+        script_extension = ".sh"
+
+        script_prelude = """\
+#!/bin/bash
+cd "${0%/*}"
+"""
+
+    putTextFileContents(
+        filename=os.path.join(
+            source_dir,
+            changeFilenameExtension(scons_debug_python_name, script_extension),
+        ),
+        contents="""\
+%(script_prelude)s
+
+'%(scons_python)s' '%(scons_debug_script_name)s'
+"""
+        % {
+            "script_prelude": script_prelude,
+            "scons_python": scons_command[0],
+            "scons_debug_script_name": scons_debug_python_name,
+        },
+        encoding="utf8",
+    )
+
+
 def runScons(options, env_values, scons_filename):
-    with _setupSconsEnvironment(scons_filename):
+    with _setupSconsEnvironment():
         env_values["_NUITKA_BUILD_DEFINITIONS_CATALOG"] = ",".join(env_values.keys())
 
         if "source_dir" in options and Options.shallCompileWithoutBuildDirectory():
@@ -282,10 +343,9 @@ def runScons(options, env_values, scons_filename):
             options = copy.deepcopy(options)
             source_dir = options["source_dir"]
             options["source_dir"] = "."
-            options["result_name"] = getExternalUsePath(
-                options["result_name"], only_dirname=True
-            )
             options["nuitka_src"] = getExternalUsePath(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
@@ -310,13 +370,37 @@ def runScons(options, env_values, scons_filename):
         Tracing.flushStandardOutputs()
 
         with withEnvironmentVarsOverridden(env_values):
-            result = subprocess.call(scons_command, shell=False, cwd=source_dir)
+            # Create debug script to quickly re-run this step only.
+            if source_dir is not None:
+                _createSconsDebugScript(
+                    source_dir=source_dir, scons_command=scons_command
+                )
+
+                source_dir = getExternalUsePath(source_dir)
+            try:
+                result = subprocess.call(scons_command, shell=False, cwd=source_dir)
+            except KeyboardInterrupt:
+                Tracing.scons_logger.sysexit("User interrupted scons build.")
 
         # TODO: Actually this should only flush one of these, namely the one for
         # current source_dir.
         flushSconsReports()
 
         if "source_dir" in options and result == 0:
+            if "result_exe" in options:
+                scons_created_exe = getSconsReportValue(
+                    source_dir or options["source_dir"], "TARGET"
+                )
+
+                if not os.path.exists(scons_created_exe):
+                    Tracing.scons_logger.sysexit(
+                        "Error, scons failed to create the expected file %r. "
+                        % scons_created_exe
+                    )
+
+                if not areSamePaths(options["result_exe"], scons_created_exe):
+                    renameFile(scons_created_exe, orig_result_exe)
+
             checkCachingSuccess(source_dir or options["source_dir"])
 
         return result == 0
@@ -331,6 +415,7 @@ def asBoolStr(value):
 def cleanSconsDirectory(source_dir):
     """Clean scons build directory."""
 
+    # spell-checker: ignore gcda
     extensions = (
         ".bin",
         ".c",
@@ -377,11 +462,16 @@ def setCommonSconsOptions(options):
     # Scons gets transported many details, that we express as variables, and
     # 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
 
     options["python_prefix"] = getDirectoryRealPath(getSystemPrefixPath())
 
     options["experimental"] = ",".join(Options.getExperimentalIndications())
 
+    options["debug_modes"] = ",".join(Options.getDebugModeIndications())
+
     options["no_deployment"] = ",".join(Options.getNoDeploymentIndications())
 
     if Options.shallRunInDebugger():
@@ -408,8 +498,8 @@ def setCommonSconsOptions(options):
     if Options.shallDisableCCacheUsage():
         options["disable_ccache"] = asBoolStr(True)
 
-    if Options.shallDisableConsoleWindow() and Options.mayDisableConsoleWindow():
-        options["disable_console"] = asBoolStr(True)
+    if isWin32Windows() and Options.getWindowsConsoleMode() != "attach":
+        options["console_mode"] = Options.getWindowsConsoleMode()
 
     if Options.getLtoMode() != "auto":
         options["lto_mode"] = Options.getLtoMode()
@@ -426,6 +516,9 @@ def setCommonSconsOptions(options):
     if isMSYS2MingwPython():
         options["msys2_mingw_python"] = asBoolStr(True)
 
+    if isSelfCompiledPythonUninstalled():
+        options["self_compiled_python_uninstalled"] = asBoolStr(True)
+
     cpp_defines = Plugins.getPreprocessorSymbols()
     if cpp_defines:
         options["cpp_defines"] = ",".join(
@@ -455,17 +548,13 @@ def setCommonSconsOptions(options):
 
         options["macos_min_version"] = macos_min_version
 
-        macos_target_arch = Options.getMacOSTargetArch()
-
-        if macos_target_arch == "universal":
-            Tracing.general.sysexit(
-                "Cannot create universal macOS binaries (yet), please pick an arch and create two binaries."
-            )
-
-        options["macos_target_arch"] = macos_target_arch
+        options["macos_target_arch"] = Options.getMacOSTargetArch()
 
     options["target_arch"] = getArchitecture()
 
+    if Options.getFcfProtectionMode() != "auto":
+        options["cf_protection"] = Options.getFcfProtectionMode()
+
     env_values = OrderedDict()
 
     string_values = Options.getWindowsVersionInfoStrings()
@@ -481,12 +570,8 @@ def setCommonSconsOptions(options):
 
     if product_version is None:
         product_version = file_version
-    if product_version is not None:
-        product_version = ".".join(str(d) for d in product_version)
     if file_version is None:
         file_version = product_version
-    else:
-        file_version = ".".join(str(d) for d in file_version)
 
     if product_version != file_version:
         effective_version = "%s-%s" % (
@@ -514,3 +599,19 @@ def setCommonSconsOptions(options):
         )
 
     return env_values
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/build/SconsProgress.py

@@ -1,27 +1,12 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Progress bar for Scons compilation part.
 
 This does only the interfacing with tracing and collection of information.
 
 """
 
-
 from nuitka.Progress import (
     closeProgressBar,
     enableProgressBar,
@@ -90,3 +75,19 @@ Slow C linking detected, used %.0fs so far, consider using '--lto=no' \
 for faster linking, or '--lto=yes"' to disable this message. """
                 % delta_time
             )
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/build/SconsSpawn.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Spawning processes.
 
 This is to replace the standard spawn implementation with one that tracks the
@@ -36,7 +22,7 @@ from .SconsProgress import (
     reportSlowCompilation,
     updateSconsProgressBar,
 )
-from .SconsUtils import decodeData
+from .SconsUtils import decodeData, reportSconsUnexpectedOutput
 
 
 # Thread class to run a command
@@ -128,6 +114,12 @@ surely happen again."""
     )
 
 
+def _getNoSuchCommandErrorMessage():
+    import ctypes
+
+    return ctypes.WinError(3).args[1]
+
+
 # To work around Windows not supporting command lines of greater than 10K by
 # default:
 def _getWindowsSpawnFunction(env, module_mode, source_files):
@@ -168,6 +160,9 @@ def _getWindowsSpawnFunction(env, module_mode, source_files):
                 closeSconsProgressBar()
                 raise exception
 
+        if rv != 0:
+            closeSconsProgressBar()
+
         if cmd == "link":
             data = _filterMsvcLinkOutput(
                 env=env, module_mode=module_mode, data=data, exit_code=rv
@@ -189,20 +184,31 @@ def _getWindowsSpawnFunction(env, module_mode, source_files):
             )
 
         if data is not None and data.rstrip():
-            my_print("Unexpected output from this command:", style="yellow")
-            my_print(cmdline, style="yellow")
+            my_print("Unexpected output from this command:", style="scons-unexpected")
+            my_print(cmdline, style="scons-unexpected")
 
             if str is not bytes:
                 data = decodeData(data)
 
-            my_print(data, style="yellow", end="" if data.endswith("\n") else "\n")
+            my_print(
+                data, style="scons-unexpected", end="" if data.endswith("\n") else "\n"
+            )
+
+            reportSconsUnexpectedOutput(env, cmdline, stdout=data, stderr=None)
 
         if err:
             if str is not bytes:
                 err = decodeData(err)
 
             err = "\r\n".join(
-                line for line in err.split("\r\n") if not isIgnoredError(line)
+                line
+                for line in err.split("\r\n")
+                if not isIgnoredError(line)
+                if not (
+                    env.mingw_mode
+                    and env.lto_mode
+                    and line == _getNoSuchCommandErrorMessage()
+                )
             )
 
             if err:
@@ -212,7 +218,9 @@ def _getWindowsSpawnFunction(env, module_mode, source_files):
                     _raiseCorruptedObjectFilesExit(cache_name="ccache")
 
                 err += "\r\n"
-                my_print(err, style="yellow", end="")
+                my_print(err, style="scons-unexpected", end="")
+
+                reportSconsUnexpectedOutput(env, cmdline, stdout=None, stderr=err)
 
         return rv
 
@@ -290,11 +298,11 @@ length parameter; this could be due to transposed parameters"""
     return False
 
 
-def subprocess_spawn(args):
-    sh, _cmd, args, env = args
+def subprocess_spawn(env, args):
+    sh, _cmd, args, os_env = args
 
     _stdout, stderr, exit_code = executeProcess(
-        command=[sh, "-c", " ".join(args)], env=env
+        command=[sh, "-c", " ".join(args)], env=os_env
     )
 
     if str is not bytes:
@@ -317,15 +325,18 @@ def subprocess_spawn(args):
         if exit_code != 0 and "terminated with signal 11" in line:
             exit_code = -11
 
-        my_print(line, style="yellow", file=sys.stderr)
+        my_print(line, style="scons-unexpected", file=sys.stderr)
+
+        reportSconsUnexpectedOutput(env, args, stdout=None, stderr=line)
 
     return exit_code
 
 
 class SpawnThread(threading.Thread):
-    def __init__(self, *args):
+    def __init__(self, env, *args):
         threading.Thread.__init__(self)
 
+        self.env = env
         self.args = args
 
         self.timer_report = TimerReport(
@@ -346,7 +357,7 @@ class SpawnThread(threading.Thread):
         try:
             # execute the command, queue the result
             with self.timer_report:
-                self.result = subprocess_spawn(self.args)
+                self.result = subprocess_spawn(env=self.env, args=self.args)
         except Exception as e:  # will rethrow all, pylint: disable=broad-except
             self.exception = e
 
@@ -355,7 +366,7 @@ class SpawnThread(threading.Thread):
 
 
 def _runSpawnMonitored(env, sh, cmd, args, os_env):
-    thread = SpawnThread(sh, cmd, args, os_env)
+    thread = SpawnThread(env, sh, cmd, args, os_env)
     thread.start()
 
     # Allow 6 minutes before warning for long compile time.
@@ -385,9 +396,11 @@ def _getWrappedSpawnFunction(env):
 
         if exception:
             closeSconsProgressBar()
-
             raise exception
 
+        if result != 0:
+            closeSconsProgressBar()
+
         # Segmentation fault should give a clear error.
         if result == -11:
             scons_logger.sysexit(
@@ -402,10 +415,26 @@ it or using '--clang' option."""
     return spawnCommand
 
 
-def enableSpawnMonitoring(env, win_target, module_mode, source_files):
-    if win_target:
+def enableSpawnMonitoring(env, module_mode, source_files):
+    if os.name == "nt":
         env["SPAWN"] = _getWindowsSpawnFunction(
             env=env, module_mode=module_mode, source_files=source_files
         )
     else:
         env["SPAWN"] = _getWrappedSpawnFunction(env=env)
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.