Nuitka-winsvc 2.3.11__cp311-cp311-win_amd64.whl → 2.4.5__cp311-cp311-win_amd64.whl

nuitka/tools/testing/run_nuitka_tests/__main__.py

@@ -299,15 +299,6 @@ Do not use Python2.6 even if available on the system. Default is %default.""",
 Do not use Python2.7 even if available on the system. Default is %default.""",
     )
 
-    parser.add_option(
-        "--no-python3.3",
-        action="store_true",
-        dest="no33",
-        default=False,
-        help="""\
-Do not use Python3.3 even if available on the system. Default is %default.""",
-    )
-
     parser.add_option(
         "--no-python3.4",
         action="store_true",
@@ -437,8 +428,6 @@ Enforce the use of MinGW64 on Windows. Defaults to off.""",
             options.no26 = True
         if sys.version_info[0:2] != (2, 7):
             options.no27 = True
-        if sys.version_info[0:2] != (3, 3):
-            options.no33 = True
         if sys.version_info[0:2] != (3, 4):
             options.no34 = True
         if sys.version_info[0:2] != (3, 5):
@@ -586,8 +575,6 @@ def main():
             return False
         if command == "python2.7" and options.no27:
             return False
-        if command == "python3.3" and options.no33:
-            return False
         if command == "python3.4" and options.no34:
             return False
         if command == "python3.5" and options.no35:
@@ -613,8 +600,6 @@ def main():
             return True
         if command == "python2.7" and sys.version_info[0:2] == (2, 7):
             return True
-        if command == "python3.3" and sys.version_info[0:2] == (3, 3):
-            return True
         if command == "python3.4" and sys.version_info[0:2] == (3, 4):
             return True
         if command == "python3.5" and sys.version_info[0:2] == (3, 5):
@@ -975,11 +960,6 @@ def main():
     else:
         my_print("Cannot execute tests with Python 2.7, disabled or not installed.")
 
-    if checkExecutableCommand("python3.3"):
-        execute_tests("python3.3-nodebug", "python3.3", "")
-    else:
-        my_print("Cannot execute tests with Python 3.3, disabled or not installed.")
-
     if checkExecutableCommand("python3.4"):
         execute_tests("python3.4-nodebug", "python3.4", "")
     else:

nuitka/tools/watch/AutoStage.py

@@ -0,0 +1,144 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Stage changes in Nuitka-Watch automatically
+
+This aims at recognizing unimportant changes automatically and is used
+for larger report format migrations in the future potentially.
+"""
+
+from optparse import OptionParser
+
+from nuitka.tools.quality.Git import (
+    getCheckoutFileChangeDesc,
+    getFileHashContent,
+    putFileHashContent,
+    updateGitFile,
+)
+from nuitka.TreeXML import fromString, toString
+from nuitka.utils.FileOperations import getFileContents, withTemporaryFile
+
+options = None
+
+
+def findMatchingNode(root, search_node):
+    """Find a node matching the given one in a XML root."""
+    nodes = []
+
+    node = search_node
+    while node is not None:
+        nodes.insert(0, node)
+
+        node = node.getparent()
+
+    # Root is easy and hard coded.
+    current = root
+    del nodes[0]
+
+    for node in nodes:
+        node_tag = node.tag
+
+        if node_tag == "module":
+            attrib_name = "name"
+        elif node_tag == "optimization-time":
+            attrib_name = "pass"
+        else:
+            assert False, (node, current)
+
+        attrib_value = node.attrib[attrib_name]
+
+        for candidate in current.findall(node_tag):
+            try:
+                candidate_value = candidate.attrib[attrib_name]
+            except KeyError:
+                assert False, current
+
+            if candidate_value == attrib_value:
+                current = candidate
+                break
+        else:
+            return None
+
+    return current
+
+
+def onCompilationReportChange(filename, git_stage):
+    print("Working on", filename)
+
+    new_report = fromString(getFileContents(filename, mode="rb"), use_lxml=True)
+    old_git_contents = getFileHashContent(git_stage["src_hash"])
+
+    old_report = fromString(old_git_contents, use_lxml=True)
+
+    new_nuitka_version = new_report.attrib["nuitka_version"]
+    changed = False
+    if old_report.attrib["nuitka_version"] != new_nuitka_version:
+        old_report.attrib["nuitka_version"] = new_nuitka_version
+
+        changed = True
+
+    if options.accept_optimization_time:
+        for new_node in new_report.xpath("//module/optimization-time"):
+            old_node = findMatchingNode(old_report, new_node)
+
+            if old_node is not None:
+                old_node.getparent().replace(old_node, new_node)
+
+    if changed:
+        new_git_contents = toString(old_report)
+        with withTemporaryFile(mode="w", delete=False) as output_file:
+            tmp_filename = output_file.name
+            output_file.write(new_git_contents)
+            output_file.close()
+
+        new_hash_value = putFileHashContent(tmp_filename)
+
+        if git_stage["src_hash"] != new_hash_value:
+            updateGitFile(filename, git_stage["src_hash"], new_hash_value, staged=False)
+
+
+def onFileChange(git_stage):
+    filename = git_stage["src_path"]
+
+    if filename.endswith("compilation-report.xml"):
+        onCompilationReportChange(filename=filename, git_stage=git_stage)
+
+
+def main():
+    # Cheating in this singleton and not passing options,
+    # pylint: disable=global-statement
+    global options
+
+    parser = OptionParser()
+
+    parser.add_option(
+        "--accept-optimization-time",
+        action="store_true",
+        dest="accept_optimization_time",
+        default=False,
+        help="""Accept module optimization-time changes.""",
+    )
+
+    options, _positional_args = parser.parse_args()
+
+    for git_stage in getCheckoutFileChangeDesc(staged=False):
+        onFileChange(git_stage=git_stage)
+
+
+if __name__ == "__main__":
+    main()
+
+#     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/tools/watch/__main__.py

@@ -8,6 +8,7 @@ of Nuitka changes on PyPI packages.
 """
 
 import os
+import subprocess
 import sys
 from optparse import OptionParser
 
@@ -25,10 +26,12 @@ from nuitka.utils.Execution import (
 )
 from nuitka.utils.FileOperations import (
     changeTextFileContents,
+    deleteFile,
     getFileContents,
     getFileList,
     listDir,
     makePath,
+    putTextFileContents,
     relpath,
     withDirectoryChange,
 )
@@ -219,6 +222,28 @@ def _updatePacmanFile(installed_python, case_data, dry_run, result_path):
     return changed_pipenv_file, pipenv_filename
 
 
+def _execPipenvCommand(installed_python, command, retry=False):
+    try:
+        check_call(
+            [
+                installed_python.getPythonExe(),
+                "-m",
+                "pipenv",
+                command,
+                "--python",
+                installed_python.getPythonExe(),
+            ],
+            logger=watch_logger,
+        )
+    except subprocess.CalledProcessError:
+        if command in ("install", "update") and not retry:
+            _execPipenvCommand(installed_python, "--rm")
+            _execPipenvCommand(installed_python, command)
+
+        else:
+            raise
+
+
 def _updatePipenvLockFile(
     installed_python, dry_run, pipenv_filename_full, no_pipenv_update
 ):
@@ -229,16 +254,7 @@ def _updatePipenvLockFile(
                 % pipenv_filename_full
             )
 
-            check_call(
-                [
-                    installed_python.getPythonExe(),
-                    "-m",
-                    "pipenv",
-                    "install",
-                    "--python",
-                    installed_python.getPythonExe(),
-                ]
-            )
+            _execPipenvCommand(installed_python, "install")
 
         elif not dry_run:
             watch_logger.info(
@@ -246,16 +262,7 @@ def _updatePipenvLockFile(
                 % pipenv_filename_full
             )
 
-            check_call(
-                [
-                    installed_python.getPythonExe(),
-                    "-m",
-                    "pipenv",
-                    "update",
-                    "--python",
-                    installed_python.getPythonExe(),
-                ]
-            )
+            _execPipenvCommand(installed_python, "update")
     else:
         watch_logger.info(
             "Working with pipenv file '%s' to install virtualenv, may take a while."
@@ -293,9 +300,11 @@ def _updatePacmanLockFile():
     return pacman_lock_filename
 
 
-def _compileCase(case_data, case_dir, installed_python, lock_filename):
+def _compileCase(case_data, case_dir, installed_python, lock_filename, jobs):
     preferred_package_type = installed_python.getPreferredPackageType()
 
+    extra_options = []
+
     if preferred_package_type == "pip":
         run_command = [
             installed_python.getPythonExe(),
@@ -306,15 +315,16 @@ def _compileCase(case_data, case_dir, installed_python, lock_filename):
             installed_python.getPythonExe(),
             "python",
         ]
-        extra_options = []
     elif preferred_package_type == "pacman":
         run_command = ["python"]
 
-        # TODO: Bug in MSYS2 ccache, avoid using that.
-        extra_options = ["--disable-ccache"]
+        extra_options.append("--disable-ccache")
     else:
         assert False
 
+    if jobs is not None:
+        extra_options.append("--jobs=%s" % jobs)
+
     check_call(
         run_command
         + [
@@ -347,6 +357,14 @@ def _compileCase(case_data, case_dir, installed_python, lock_filename):
         with open("compiled-stderr.txt", "wb") as output:
             output.write(stderr)
 
+        if exit_nuitka == 0:
+            deleteFile("compiled-exit.txt", must_exist=False)
+        else:
+            putTextFileContents(
+                filename="compiled-exit.txt",
+                contents=str(exit_nuitka),
+            )
+
         if exit_nuitka != 0:
             sys.exit(
                 "Error, failed to execute %s with code %d." % (binaries[0], exit_nuitka)
@@ -361,6 +379,7 @@ def _updateCase(
     nuitka_update_mode,
     installed_python,
     result_path,
+    jobs,
 ):
     # Many details and cases due to package method being handled here.
     # pylint: disable=too-many-branches,too-many-locals
@@ -404,6 +423,8 @@ def _updateCase(
         with withDirectoryChange(result_path):
             # Update or create lockfile of pipenv.
             lock_filename = _updatePacmanLockFile()
+    else:
+        assert False, preferred_package_type
 
     # Check if compilation is required.
     with withDirectoryChange(result_path):
@@ -433,12 +454,15 @@ def _updateCase(
 
                         need_compile = True
                     elif old_nuitka_version == nuitka_version:
-                        watch_logger.info(
-                            "Skipping compilation with identical Nuitka for '%s'."
-                            % pipenv_filename_full
-                        )
+                        if old_report_root.attrib["completion"] != "yes":
+                            need_compile = True
+                        else:
+                            watch_logger.info(
+                                "Skipping compilation with identical Nuitka for '%s'."
+                                % pipenv_filename_full
+                            )
 
-                        need_compile = False
+                            need_compile = False
                     else:
                         watch_logger.info(
                             "Skipping compilation of old Nuitka %s result with Nuitka %s for '%s'."
@@ -455,16 +479,26 @@ def _updateCase(
         else:
             need_compile = True
 
+        if not need_compile:
+            if os.path.exists("compiled-exit.txt"):
+                watch_logger.info(
+                    "Enforcing compilation of compiled program that failed to run."
+                )
+                need_compile = True
+
         if need_compile:
             _compileCase(
                 case_data=case_data,
                 case_dir=case_dir,
                 installed_python=installed_python,
                 lock_filename=lock_filename,
+                jobs=jobs,
             )
 
 
-def updateCase(case_dir, case_data, dry_run, no_pipenv_update, nuitka_update_mode):
+def updateCase(
+    case_dir, case_data, dry_run, no_pipenv_update, nuitka_update_mode, jobs
+):
     case_name = case_data["case"]
 
     watch_logger.info("Consider '%s' ... " % case_name)
@@ -520,10 +554,11 @@ def updateCase(case_dir, case_data, dry_run, no_pipenv_update, nuitka_update_mod
             nuitka_update_mode=nuitka_update_mode,
             installed_python=installed_python,
             result_path=result_path,
+            jobs=jobs,
         )
 
 
-def updateCases(case_dir, dry_run, no_pipenv_update, nuitka_update_mode):
+def updateCases(case_dir, dry_run, no_pipenv_update, nuitka_update_mode, jobs):
     for case_data in parseYaml(getFileContents("case.yml", mode="rb")):
         updateCase(
             case_dir=case_dir,
@@ -531,6 +566,7 @@ def updateCases(case_dir, dry_run, no_pipenv_update, nuitka_update_mode):
             dry_run=dry_run,
             no_pipenv_update=no_pipenv_update,
             nuitka_update_mode=nuitka_update_mode,
+            jobs=jobs,
         )
 
 
@@ -603,6 +639,16 @@ Recompile even if the versions seems not changed. Default %default.""",
 PR to create. Default not making a PR.""",
     )
 
+    parser.add_option(
+        "--jobs",
+        action="store",
+        dest="jobs",
+        default=None,
+        help="""\
+Argument for jobs, in order to be nice use negative values
+to reserve cores.""",
+    )
+
     options, positional_args = parser.parse_args()
 
     assert len(positional_args) <= 1, positional_args
@@ -650,10 +696,11 @@ PR to create. Default not making a PR.""",
 
             with withDirectoryChange(os.path.dirname(case_filename)):
                 updateCases(
-                    os.path.dirname(case_filename),
+                    case_dir=os.path.dirname(case_filename),
                     dry_run=options.dry_run,
                     no_pipenv_update=options.no_pipenv_update,
                     nuitka_update_mode=options.nuitka_update_mode,
+                    jobs=options.jobs,
                 )
 
         if pr_category is not None: