Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/tools/watch/AutoStage.py

@@ -0,0 +1,145 @@
+#     Copyright 2025, 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)
+                changed = True
+
+    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/Common.py

@@ -0,0 +1,55 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Shared code for nuitka-watch backends.
+
+"""
+
+import os
+import sys
+
+
+def getPlatformRequirements(installed_python, case_data):
+    requirements = list(case_data["requirements"])
+
+    # Nuitka house keeping, these are from setup.py but we ignore onefile needs
+    # as that is not currently covered in watches.
+    # spell-checker: ignore orderedset,imageio
+    needs_onefile = False
+
+    if installed_python.getHexVersion() >= 0x370:
+        requirements.append("ordered-set >= 4.1.0")
+    if installed_python.getHexVersion() < 0x300:
+        requirements.append("subprocess32")
+    if needs_onefile and installed_python.getHexVersion() >= 0x370:
+        requirements.append("zstandard >= 0.15")
+    if (
+        os.name != "nt"
+        and sys.platform != "darwin"
+        and installed_python.getHexVersion() < 0x370
+    ):
+        requirements.append("orderedset >= 2.0.3")
+    if sys.platform == "darwin" and installed_python.getHexVersion() < 0x370:
+        requirements.append("orderedset >= 2.0.3")
+
+    # For icon conversion.
+    if case_data.get("icons", "no") == "yes":
+        requirements.append("imageio")
+
+    return requirements
+
+
+#     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/Conda.py

@@ -0,0 +1,125 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Conda backend for maintaining locked package state with nuitka-watch. """
+
+from nuitka.utils.Execution import check_call, executeToolChecked
+from nuitka.utils.FileOperations import changeTextFileContents
+from nuitka.utils.Utils import isWin32Windows
+
+from .Common import getPlatformRequirements
+
+
+def _getCaseEnvironmentName(installed_python, case_data):
+    return "nuitka-watch-case-%(python_version)s-%(case)s" % {
+        "python_version": installed_python.getPythonVersion(),
+        "case": case_data["case"],
+    }
+
+
+def getCondaRunCommand(installed_python, case_data):
+    return [
+        "conda",
+        "run",
+        "--live-stream",
+        "-n",
+        _getCaseEnvironmentName(installed_python=installed_python, case_data=case_data),
+        "python",
+    ]
+
+
+# spell-checker: ignore opencv
+_package_name_table = {
+    "dask_ml": "dask-ml",
+    "opencv-python-headless": "opencv",
+    "opencv-python": "opencv",
+}
+
+
+def _translatePyPIPackageName(package_name):
+    for key, value in _package_name_table.items():
+        package_name = package_name.replace(key, value)
+
+    return package_name
+
+
+def updateCondaEnvironmentFile(installed_python, case_data):
+    conda_env_filename = "environment.yml"
+    conda_package_requirements = ["python=%s" % installed_python.getPythonVersion()]
+
+    if not isWin32Windows():
+        conda_package_requirements.append("libpython-static")
+
+    for requirement in getPlatformRequirements(
+        installed_python=installed_python, case_data=case_data
+    ):
+        # Ignore spaces in requirements.
+        requirement = requirement.replace(" ", "")
+
+        # TODO: Ought to work on the package name only, but
+        # we get away with bad code here for now.
+        requirement = _translatePyPIPackageName(requirement)
+
+        conda_package_requirements.append(requirement)
+
+    changeTextFileContents(
+        conda_env_filename,
+        """\
+name: "%(name)s"
+dependencies:
+%(conda_package_requirements)s
+"""
+        % {
+            "name": _getCaseEnvironmentName(
+                installed_python=installed_python, case_data=case_data
+            ),
+            "conda_package_requirements": "\n".join(
+                "  - %s" % conda_package_requirement
+                for conda_package_requirement in conda_package_requirements
+            ),
+        },
+    )
+
+
+def updateCondaEnvironmentLockFile(logger, installed_python, case_data):
+    conda_lock_filename = "environment.lock"
+
+    check_call(
+        ["conda", "env", "update", "-f", "environment.yml", "--prune"],
+        logger=logger,
+    )
+
+    conda_output = executeToolChecked(
+        logger=logger,
+        command=[
+            "conda",
+            "env",
+            "export",
+            "-n",
+            _getCaseEnvironmentName(
+                installed_python=installed_python, case_data=case_data
+            ),
+        ],
+        absence_message="needs conda to query package status on Anaconda Python",
+        decoding=str is not bytes,
+    )
+
+    changeTextFileContents(filename=conda_lock_filename, contents=conda_output)
+
+    return conda_lock_filename
+
+
+#     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/GitHub.py

@@ -0,0 +1,113 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" GitHub interfacing for nuitka-watch. """
+
+import os
+import sys
+
+from nuitka.tools.quality.Git import getModifiedPaths, getRemoteURL
+from nuitka.Tracing import tools_logger
+from nuitka.utils.Execution import callProcess, check_call
+
+
+def checkInNuitkaWatch():
+    remote_url = getRemoteURL("origin")
+    assert remote_url in (
+        "git@github.com:Nuitka/Nuitka-Watch.git",
+        "https://github.com/Nuitka/Nuitka-Watch",
+    ), remote_url
+    assert os.path.exists(".git")
+
+
+def createNuitkaWatchPR(category, description):
+    checkInNuitkaWatch()
+
+    modified_files = list(getModifiedPaths())
+
+    if not modified_files:
+        tools_logger.sysexit("Nothing to do", exit_code=0)
+
+    changed_flavors = set()
+
+    for modified_file in modified_files:
+        if os.path.basename(modified_file) == "compilation-report.xml":
+            flavor = os.path.basename(os.path.dirname(modified_file))
+            changed_flavors.add(flavor)
+
+    if not changed_flavors:
+        tools_logger.sysexit("No changes in compilation reports, only other things.")
+
+    if len(changed_flavors) != 1:
+        tools_logger.sysexit("Only a single flavor is supported at a time currently.")
+
+    (changed_flavor,) = changed_flavors
+
+    tools_logger.info(
+        "Detected changes for %s in results of '%s'." % (description, changed_flavor)
+    )
+
+    commit_message = """
+Changes for %s in results of '%s'
+
+This change is automatically generated and the result of executing %s on
+current Nuitka-Watch state.
+""" % (
+        description,
+        changed_flavor,
+        " ".join(sys.argv),
+    )
+
+    branch_name = "auto-%s-%s" % (category, changed_flavor)
+
+    # May not exist of course.
+    callProcess(["git", "branch", "-D", branch_name])
+
+    check_call(["git", "branch", branch_name])
+
+    check_call(["git", "checkout", branch_name])
+
+    check_call(["git", "add", "."])
+
+    check_call(["git", "commit", "-m", commit_message])
+
+    check_call(["git", "checkout", "main"])
+
+    tools_logger.info("Change is now on branch '%s'." % branch_name)
+
+
+if __name__ == "__main__":
+    # TODO: This runner should be directly used from nuitka-watch binary,
+    # but for development purposes, we keep it separately accessible.
+
+    from optparse import OptionParser
+
+    parser = OptionParser()
+
+    parser.add_option(
+        "--desc",
+        action="store",
+        dest="desc",
+        help="""\
+Description of the change, e.g. "Nuitka update 1.9.3".""",
+    )
+
+    options, positional_args = parser.parse_args()
+    assert not positional_args
+
+    createNuitkaWatchPR(category="hotfix", description=options.desc)
+
+#     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/Pacman.py

@@ -0,0 +1,73 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Pacman backend for maintaining locked package state with nuitka-watch. """
+
+from nuitka.utils.Execution import check_call, executeToolChecked
+from nuitka.utils.FileOperations import changeTextFileContents, openTextFile
+
+from .Common import getPlatformRequirements
+
+
+def updatePacmanFile(installed_python, case_data):
+    pacman_filename = "Pacman.txt"
+    pacman_package_requirements = []
+
+    for requirement in getPlatformRequirements(
+        installed_python=installed_python, case_data=case_data
+    ):
+        # Ignore spaces in requirements.
+        requirement = requirement.replace(" ", "")
+
+        pacman_package_requirements.append(requirement)
+
+    changeTextFileContents(
+        pacman_filename,
+        """\
+%(python_version)s
+%(pacman_package_requirements)s
+"""
+        % {
+            "pacman_package_requirements": "\n".join(pacman_package_requirements),
+            "python_version": installed_python.getPythonVersion(),
+        },
+    )
+
+    return pacman_filename
+
+
+def updatePacmanLockFile(logger):
+    pacman_lock_filename = "Pacman.lock"
+
+    with openTextFile("Pacman.txt", "r") as pacman_env_file:
+        check_call(["pacman", "-S", "-"], stdin=pacman_env_file)
+
+    pacman_output = executeToolChecked(
+        logger=logger,
+        command=["pacman", "-Qe"],
+        absence_message="needs pacman to query package status on MSYS2",
+        decoding=str is not bytes,
+    )
+    pacman_output = "\n".join(
+        line.replace(" ", "=") for line in pacman_output.splitlines()
+    )
+
+    changeTextFileContents(filename=pacman_lock_filename, contents=pacman_output)
+
+    return pacman_lock_filename
+
+
+#     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/Pipenv.py

@@ -0,0 +1,145 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Pipenv backend for maintaining locked package state with nuitka-watch. """
+
+import os
+import subprocess
+
+from nuitka.utils.Execution import check_call
+from nuitka.utils.FileOperations import changeTextFileContents
+
+from .Common import getPlatformRequirements
+
+
+def _execPipenvCommand(logger, installed_python, command, retry=False):
+    try:
+        check_call(
+            [
+                installed_python.getPythonExe(),
+                "-m",
+                "pipenv",
+                command,
+                "--python",
+                installed_python.getPythonExe(),
+            ],
+            logger=logger,
+        )
+    except subprocess.CalledProcessError:
+        if command in ("install", "update", "sync") and not retry:
+            _execPipenvCommand(
+                logger=logger, installed_python=installed_python, command="--rm"
+            )
+            _execPipenvCommand(
+                logger=logger,
+                installed_python=installed_python,
+                command=command,
+                retry=True,
+            )
+        elif command == "--rm":
+            # Can fail if it doesn't exist.
+            pass
+        else:
+            raise
+
+
+def updatePipenvFile(installed_python, case_data):
+    pipenv_filename = "Pipfile"
+    pipenv_package_requirements = []
+
+    for requirement in getPlatformRequirements(
+        installed_python=installed_python, case_data=case_data
+    ):
+        # Ignore spaces in requirements.
+        requirement = requirement.replace(" ", "")
+
+        if all(char not in requirement for char in "=><"):
+            pipenv_package_requirements.append('"%s" = "*"' % requirement)
+        else:
+            operator_index = min(
+                requirement.find(char) for char in "=><" if char in requirement
+            )
+
+            pipenv_package_requirements.append(
+                '"%s" = "%s"'
+                % (requirement[:operator_index], requirement[operator_index:])
+            )
+
+    # TODO: Other indexes, e.g. nvidia might be needed too
+    changeTextFileContents(
+        pipenv_filename,
+        """\
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[requires]
+python_version = "%(python_version)s"
+
+[packages]
+%(pipenv_package_requirements)s
+"""
+        % {
+            "pipenv_package_requirements": "\n".join(pipenv_package_requirements),
+            "python_version": installed_python.getPythonVersion(),
+        },
+    )
+
+    return pipenv_filename
+
+
+def updatePipenvLockFile(
+    logger, installed_python, pipenv_filename_full, no_pipenv_update
+):
+    if os.path.exists("Pipfile.lock"):
+        if no_pipenv_update:
+            logger.info(
+                "Keeping existing lock file with pipenv file '%s'."
+                % pipenv_filename_full
+            )
+
+            _execPipenvCommand(
+                logger=logger, installed_python=installed_python, command="sync"
+            )
+
+        else:
+            logger.info(
+                "Working with existing pipenv file '%s' to update virtualenv, may take a while."
+                % pipenv_filename_full
+            )
+
+            _execPipenvCommand(
+                logger=logger, installed_python=installed_python, command="update"
+            )
+    else:
+        logger.info(
+            "Working with pipenv file '%s' to install virtualenv, may take a while."
+            % pipenv_filename_full
+        )
+
+        _execPipenvCommand(
+            logger=logger, installed_python=installed_python, command="install"
+        )
+
+    return "Pipfile.lock"
+
+
+def deletePipenvEnvironment(logger, installed_python):
+    _execPipenvCommand(logger=logger, installed_python=installed_python, command="--rm")
+
+
+#     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/__init__.py

@@ -0,0 +1,19 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
+#     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.