Nuitka-winsvc 1.6.6__cp310-cp310-win_amd64.whl → 1.7.5__cp310-cp310-win_amd64.whl

nuitka/plugins/standard/stdlib3.nuitka-package.config.yml

@@ -93,9 +93,10 @@
     - description: 'avoid socket module usage'
       replacements_plain:
         'import socket': ''
-      change_function:
-        'make_msgid': 'un-callable'
-      when: 'not use_socket'
+        'socket.': '__import__("socket").'
+      no-auto-follow:
+        - 'socket'
+      when: 'not has_builtin_module("_socket")'
 
 - module-name: 'encodings'
   implicit-imports:
@@ -161,7 +162,6 @@
 
 - module-name: 'lib2to3.pgen2'
   data-files:
-    dest_path: 'lib2to3'
     patterns:
       - '../*.pickle'
     when: 'not debian_python'
@@ -172,6 +172,11 @@
       change_function:
         'test': "'(lambda: None)'"
 
+- module-name: 'lib2to3.refactor'
+  implicit-imports:
+    - depends:
+        - 'lib2to3.fixes.*'
+
 - module-name: 'locale'
   anti-bloat:
     - description: 'remove module ability to run as a binary'
@@ -190,6 +195,13 @@
       change_function:
         '_main': "'(lambda: None)'"
 
+- module-name: 'multiprocessing.resource_tracker'
+  anti-bloat:
+    - description: "workaround for starting 'multiprocessing resource tracker"
+      replacements_plain:
+        "args += ['-c', cmd % r]": "args += ['--multiprocessing-resource-tracker', str(r)]"
+      when: 'not module_mode'
+
 - module-name: 'pathlib'
   implicit-imports:
     - depends:

nuitka/specs/HardImportSpecs.py

@@ -104,6 +104,12 @@ importlib_resources_read_text_spec = BuiltinParameterSpec(
     default_count=2,
     type_shape=tshape_str,
 )
+importlib_resources_files_spec = BuiltinParameterSpec(
+    "importlib.resources.files",
+    ("package",),
+    default_count=0,
+)
+
 
 # os/sys functions:
 os_uname_spec = BuiltinParameterSpec(

nuitka/tools/data_composer/DataComposer.py

@@ -24,14 +24,7 @@ import struct
 import sys
 from math import copysign, isinf, isnan
 
-from nuitka.__past__ import (
-    BytesIO,
-    GenericAlias,
-    long,
-    to_byte,
-    unicode,
-    xrange,
-)
+from nuitka.__past__ import BytesIO, long, to_byte, unicode, xrange
 from nuitka.build.DataComposerInterface import deriveModuleConstantsBlobName
 from nuitka.Builtins import builtin_exception_values_list, builtin_named_values
 from nuitka.PythonVersions import (
@@ -43,6 +36,7 @@ from nuitka.PythonVersions import (
 from nuitka.Serialization import (
     BlobData,
     BuiltinAnonValue,
+    BuiltinGenericAliasValue,
     BuiltinSpecialValue,
     BuiltinUnionTypeValue,
     ConstantStreamReader,
@@ -282,11 +276,11 @@ def _writeConstantValue(output, constant_value):
         output.write(b"X")
         output.write(struct.pack("i", len(constant_value)))
         output.write(constant_value)
-    elif constant_type is GenericAlias:
+    elif constant_type is BuiltinGenericAliasValue:
         output.write(b"G")
         _last_written = None
-        _writeConstantValue(output, constant_value.__origin__)
-        _writeConstantValue(output, constant_value.__args__)
+        _writeConstantValue(output, constant_value.origin)
+        _writeConstantValue(output, constant_value.args)
     elif constant_type is BuiltinUnionTypeValue:
         output.write(b"H")
         _last_written = None
@@ -340,7 +334,7 @@ def _writeConstantStream(constants_reader):
     # TODO: Debug mode only?
     result.write(b".")
 
-    return count, struct.pack("h", count) + result.getvalue()
+    return count, struct.pack("H", count) + result.getvalue()
 
 
 crc32 = 0
@@ -401,26 +395,30 @@ def main():
     for fullpath, filename in const_files:
         data_composer_logger.info("Working on constant file '%s'." % filename)
 
-        with open(fullpath, "rb") as const_file:
-            constants_reader = ConstantStreamReader(const_file)
-            count, part = _writeConstantStream(constants_reader)
-        total += count
+        try:
+            with open(fullpath, "rb") as const_file:
+                constants_reader = ConstantStreamReader(const_file)
+                count, part = _writeConstantStream(constants_reader)
+            total += count
 
-        name = deriveModuleConstantsBlobName(filename)
+            name = deriveModuleConstantsBlobName(filename)
 
-        # Make sure that is not repeated.
-        assert name not in names, name
-        names.add(name)
+            # Make sure that is not repeated.
+            assert name not in names, name
+            names.add(name)
 
-        data_composer_logger.info(
-            "Storing %r chunk with %s values size %r." % (name, count, len(part))
-        )
+            data_composer_logger.info(
+                "Storing %r chunk with %s values size %r." % (name, count, len(part))
+            )
 
-        if str is not bytes:
-            # Encoding needs to match generated source code output.
-            name = name.encode("latin1")
+            if str is not bytes:
+                # Encoding needs to match generated source code output.
+                name = name.encode("latin1")
 
-        desc.append((name, part))
+            desc.append((name, part))
+        except Exception:
+            data_composer_logger.warning("Problem with constant file '%s'." % filename)
+            raise
 
     data_composer_logger.info("Total amount of constants is %d." % total)
 

nuitka/tools/general/find_module/FindModuleCode.py

@@ -58,7 +58,9 @@ def editModuleCode(module_search_desc):
 
             candidate = module_search_desc
 
-            while not candidate.endswith(".DIS"):
+            while not candidate.endswith(".DIS") and not os.path.basename(
+                candidate
+            ).startswith("ONEFIL"):
                 candidate = os.path.dirname(candidate)
 
             module_name = relpath(module_search_desc, start=candidate).replace(
@@ -105,4 +107,5 @@ def editModuleCode(module_search_desc):
             "code.cmd" if isWin32Windows() else "code"
         )
 
-        callProcess([visual_code_binary, module_filename])
+        if visual_code_binary:
+            callProcess([visual_code_binary, module_filename])

nuitka/tools/podman/Podman.py

@@ -0,0 +1,53 @@
+#     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.
+#
+""" Podman container usage tools. """
+
+from nuitka.utils.Execution import getExecutablePath
+from nuitka.utils.Utils import (
+    isDebianBasedLinux,
+    isFedoraBasedLinux,
+    isLinux,
+    isWin32Windows,
+)
+
+
+def getPodmanExecutablePath(logger):
+    result = getExecutablePath("podman")
+
+    if getExecutablePath("podman") is None:
+        if isWin32Windows():
+            logger.sysexit(
+                """\
+Cannot find 'podman'. Install it from \
+'https://github.com/containers/podman/blob/main/docs/tutorials/podman-for-windows.md'."""
+            )
+        elif isLinux():
+            if isDebianBasedLinux():
+                logger.sysexit(
+                    "Cannot find 'podman'. Install it with 'apt-get install podman'."
+                )
+            elif isFedoraBasedLinux():
+                logger.sysexit(
+                    "Cannot find 'podman'. Install it with 'dnf install podman'."
+                )
+            else:
+                logger.sysexit(
+                    "Cannot find 'podman'. Install it with your package manager."
+                )
+
+    return result

nuitka/tools/podman/__init__.py

@@ -0,0 +1,18 @@
+#     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.
+#
+""" Dummy file to make this directory a package. """

nuitka/tools/podman/__main__.py

@@ -0,0 +1,255 @@
+#     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.
+#
+""" Launcher for running a script inside a container
+
+"""
+
+import os
+import shutil
+import sys
+from optparse import OptionParser
+
+from nuitka.tools.release.Release import getBranchName
+from nuitka.Tracing import OurLogger
+from nuitka.utils.Execution import callProcess
+
+from .Podman import getPodmanExecutablePath
+
+containers_logger = OurLogger("Nuitka-Containers", base_style="blue")
+
+
+def parseOptions():
+    parser = OptionParser()
+
+    parser.add_option(
+        "--container-id",
+        action="store",
+        dest="container_id",
+        default="CI",
+        help="""
+Name of the container to use. Defaults to "CI" which is used for testing
+Nuitka with Linux.
+""",
+    )
+
+    parser.add_option(
+        "--no-build-container",
+        action="store_true",
+        dest="no_build_container",
+        help="""
+Do not update the the container, use it if updating was done recently.
+""",
+    )
+
+    parser.add_option(
+        "--command",
+        action="store",
+        dest="command",
+        help="""
+Command to execute, all in one value.
+""",
+    )
+
+    parser.add_option(
+        "--podman-path",
+        action="store",
+        dest="podman_path",
+        default=None,
+        help="""
+Podman binary in case you do not have it in your path.
+""",
+    )
+
+    parser.add_option(
+        "--shared-path",
+        action="append",
+        dest="shared_paths",
+        default=[],
+        help="""
+Path to share with container, use "--shared-path=src=dst" format for directory names.
+""",
+    )
+
+    parser.add_option(
+        "--network",
+        action="store_true",
+        dest="network",
+        default=False,
+        help="""
+This container run should be allowed to use network.
+""",
+    )
+
+    parser.add_option(
+        "--pbuilder",
+        action="store_true",
+        dest="pbuilder",
+        default=False,
+        help="""
+This container run should be allowed to use pbuilder.
+""",
+    )
+
+    options, positional_args = parser.parse_args()
+
+    if positional_args:
+        containers_logger.sysexit(
+            "This command takes no positional arguments, check help output."
+        )
+
+    if options.podman_path is None:
+        options.podman_path = getPodmanExecutablePath(containers_logger)
+
+        assert options.podman_path is not None
+
+    return options
+
+
+def updateContainer(podman_path, container_tag_name, container_file_path):
+    requirements_file = os.path.join(
+        os.path.dirname(__file__), "..", "..", "..", "requirements-devel.txt"
+    )
+
+    if not os.path.exists(requirements_file):
+        containers_logger.sysexit(
+            "Error, cannot find expected requirements-devel.txt file."
+        )
+
+    containers_logger.info("Updating container '%s'..." % container_tag_name)
+
+    requirements_tmp_file = os.path.join(
+        os.path.dirname(container_file_path), "requirements-devel.txt"
+    )
+
+    shutil.copy(requirements_file, requirements_tmp_file)
+
+    try:
+        command = [
+            podman_path,
+            "build",
+            # Tolerate errors checking for image download, and use old one
+            "--quiet",
+            "--pull=newer",
+            "--tag",
+            container_tag_name,
+            "-f",
+            container_file_path,
+        ]
+
+        exit_code = callProcess(command)
+
+        if exit_code:
+            containers_logger.sysexit(
+                "Failed to update container with exit code '%d'." % exit_code,
+                exit_code=exit_code,
+            )
+
+        containers_logger.info(
+            "Updated container '%s' successfully." % container_tag_name
+        )
+
+    finally:
+        os.unlink(requirements_tmp_file)
+
+
+def main():
+    options = parseOptions()
+
+    containers_logger.info(
+        "Running in container '%s' this command: %s"
+        % (options.container_id, options.command)
+    )
+
+    container_file_path = os.path.join(
+        os.path.dirname(__file__), "containers", options.container_id + ".containerfile"
+    )
+
+    if not os.path.isfile(container_file_path):
+        containers_logger.sysexit(
+            "Error, no container ID '%s' found" % options.container_id
+        )
+
+    container_tag_name = "nuitka-build-%s-%s:latest" % (
+        options.container_id.lower(),
+        getBranchName(),
+    )
+
+    if not options.no_build_container:
+        updateContainer(
+            podman_path=options.podman_path,
+            container_tag_name=container_tag_name,
+            container_file_path=container_file_path,
+        )
+
+    command = [
+        options.podman_path,
+        "run",
+        "--mount",
+        "type=bind,source=.,dst=/src,relabel=shared",
+    ]
+
+    if options.network:
+        command.append("--add-host=ssh.nuitka.net:116.202.30.188")
+    else:
+        command.append("--network=none")
+
+    # May need to allow pbuilder to create device nodes, makes the container insecure
+    # though.
+    if options.pbuilder:
+        command += ["--privileged"]
+
+    dst_paths = []
+
+    for path_desc in options.shared_paths:
+        if path_desc.count("=") == 1:
+            src_path, dst_path = path_desc.split("=")
+            flags = ""
+        else:
+            src_path, dst_path, flags = path_desc.split("=", 2)
+            flags = "," + flags
+
+        src_path = os.path.expanduser(src_path)
+
+        dst_paths.append(dst_path)
+
+        command += [
+            "--mount",
+            "type=bind,source=%s,dst=%s,relabel=shared%s" % (src_path, dst_path, flags),
+        ]
+
+    # Interactive if possible only.
+    if sys.stdout.isatty():
+        command.append("-it")
+
+    command += [
+        container_tag_name,
+        "bash",
+        "-l",
+        "-c",
+        "cd /src;" + options.command + "; exit $?",
+    ]
+
+    exit_code = callProcess(command, shell=False, logger=containers_logger)
+
+    containers_logger.sysexit(
+        "Finished container run with exit code '%d'." % exit_code, exit_code=exit_code
+    )
+
+
+if __name__ == "__main__":
+    main()

nuitka/tools/specialize/SpecializePython.py

@@ -42,6 +42,7 @@ import nuitka.specs.BuiltinStrOperationSpecs
 import nuitka.specs.BuiltinTypeOperationSpecs
 import nuitka.specs.HardImportSpecs
 import nuitka.tree.Building
+from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.nodes.ImportNodes import hard_modules_non_stdlib
 from nuitka.nodes.NodeMetaClasses import NodeCheckMetaClass
 from nuitka.nodes.shapes.BuiltinTypeShapes import (
@@ -521,7 +522,12 @@ def makeMixinName(
         for named_child in named_children
     )
 
-    mixin_name += "_".join(sorted(auto_compute_handling)).title().replace("_", "")
+    mixin_name += (
+        "_".join(sorted(auto_compute_handling))
+        .title()
+        .replace("_", "")
+        .replace(":", "")
+    )
 
     mixin_name += "_".join(sorted(node_attributes)).title().replace("_", "")
 
@@ -725,7 +731,8 @@ addFromNodes()
 
 
 def makeChildrenHavingMixinNodes():
-    # Complex stuff with many details due to 2 files and modes, pylint: disable=too-many-locals
+    # Complex stuff with many details due to 2 files and modes,
+    # pylint: disable=too-many-locals,too-many-statements
 
     filename_python = "nuitka/nodes/ChildrenHavingMixins.py"
     filename_python2 = "nuitka/nodes/ExpressionBasesGenerated.py"
@@ -833,10 +840,36 @@ from nuitka.nodes.Checkers import (
                 return result
 
             is_compute_final = pop("final")
+
             is_compute_no_raise = pop("no_raise")
+            is_compute_raise = pop("raise")
+            is_compute_raise_operation = pop("raise_operation")
+            assert (
+                is_compute_no_raise + is_compute_raise + is_compute_raise_operation < 2
+            )
+
+            if is_compute_raise:
+                raise_mode = "raise"
+            elif is_compute_no_raise:
+                raise_mode = "no_raise"
+            elif is_compute_raise_operation:
+                raise_mode = "raise_operation"
+            else:
+                raise_mode = None
+
             is_compute_statement = pop("operation")
             has_post_node_init = pop("post_init")
 
+            awaited_constant_attributes = OrderedSet(
+                value.split(":", 1)[1]
+                for value in auto_compute_handling_set
+                if value.startswith("wait_constant:")
+            )
+
+            auto_compute_handling_set -= {
+                "wait_constant:%s" % value for value in awaited_constant_attributes
+            }
+
             assert not auto_compute_handling_set, auto_compute_handling_set
 
             code = template.render(
@@ -852,8 +885,9 @@ from nuitka.nodes.Checkers import (
                 ),
                 intended_for=intended_for,
                 is_compute_final=is_compute_final,
-                is_compute_no_raise=is_compute_no_raise,
+                raise_mode=raise_mode,
                 is_compute_statement=is_compute_statement,
+                awaited_constant_attributes=awaited_constant_attributes,
                 has_post_node_init=has_post_node_init,
                 node_attributes=node_attributes,
                 len=len,

nuitka/tools/testing/RuntimeTracing.py

@@ -132,6 +132,10 @@ def _takeSystemCallTraceOutput(logger, path, command):
             if line.startswith((b"stat(", b"newfstatat(")) and b"S_IFDIR" in line:
                 continue
 
+            # Don't consider files not found.
+            if line.startswith(b"stat64(") and b"= -1" in line:
+                continue
+
             result.extend(
                 os.path.abspath(match)
                 for match in re.findall(b'"(.*?)(?:\\\\0)?"', line)

nuitka/tree/Building.py

@@ -1313,7 +1313,7 @@ def buildModule(
                         plugins_logger.warning(line)
 
                     if len(contributing_plugins) == 1:
-                        contributing_plugins[0].sysexit(
+                        next(iter(contributing_plugins)).sysexit(
                             "Making changes to '%s' that cause SyntaxError '%s'"
                             % (module_name, e)
                         )