Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/plugins/standard/ConsiderPyLintAnnotationsPlugin.py

@@ -0,0 +1,95 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Standard plug-in to take advantage of pylint or PyDev annotations.
+
+Nuitka can detect some things that PyLint and PyDev will complain about too,
+and sometimes it's a false alarm, so people add disable markers into their
+source code. Nuitka does it itself.
+
+This tries to parse the code for these markers and uses hooks to prevent Nuitka
+from warning about things, disabled to PyLint or Eclipse. The idea is that we
+won't have another mechanism for Nuitka, but use existing ones instead.
+
+The code for this is very incomplete, barely good enough to cover Nuitka's own
+usage of PyLint markers. PyDev is still largely to be started. You are welcome
+to grow both.
+
+"""
+
+import re
+
+from nuitka.__past__ import intern
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+
+
+class NuitkaPluginPylintEclipseAnnotations(NuitkaPluginBase):
+    plugin_name = "pylint-warnings"
+    plugin_desc = "Support PyLint / PyDev linting source markers."
+    plugin_category = "feature"
+
+    def __init__(self):
+        self.line_annotations = {}
+
+    def checkModuleSourceCode(self, module_name, source_code):
+        annotations = {}
+
+        for count, line in enumerate(source_code.split("\n"), 1):
+            match = re.search(r"#.*pylint:\s*disable=\s*([\w,-]+)", line)
+
+            if match:
+                comment_only = line[: line.find("#") - 1].strip() == ""
+
+                if comment_only:
+                    # TODO: Parse block wide annotations too.
+                    pass
+                else:
+                    annotations[count] = set(
+                        intern(match.strip()) for match in match.group(1).split(",")
+                    )
+
+        # Only remember them if there were any.
+        if annotations:
+            self.line_annotations[module_name] = annotations
+
+    def suppressUnknownImportWarning(self, importing, module_name, source_ref):
+        annotations = self.line_annotations.get(importing.getFullName(), {})
+
+        line_annotations = annotations.get(source_ref.getLineNumber(), ())
+
+        if "F0401" in line_annotations or "import-error" in line_annotations:
+            return True
+
+        return False
+
+
+# Disabled until it will be actually really useful, pylint: disable=using-constant-test
+if False:
+
+    class NuitkaPluginDetectorPylintEclipseAnnotations(NuitkaPluginBase):
+        detector_for = NuitkaPluginPylintEclipseAnnotations
+
+        def onModuleSourceCode(self, module_name, source_filename, source_code):
+            if re.search(r"#\s*pylint:\s*disable=\s*(\w+)", source_code):
+                self.warnUnusedPlugin(
+                    "Understand PyLint/PyDev annotations for warnings."
+                )
+
+            # Do nothing to it.
+            return source_code
+
+
+#     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/plugins/standard/DataFilesPlugin.py

@@ -0,0 +1,311 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Standard plug-in to find data files.
+
+"""
+
+import os
+import pkgutil
+
+from nuitka import Options
+from nuitka.code_generation.ConstantCodes import addDistributionMetadataValue
+from nuitka.containers.OrderedSets import OrderedSet
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
+from nuitka.PythonFlavors import isDebianPackagePython
+from nuitka.utils.Distributions import getDistribution
+from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
+    getFileList,
+    resolveShellPatternToFilenames,
+)
+
+
+class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
+    plugin_name = "data-files"
+    plugin_desc = "Include data files specified by package configuration files."
+    plugin_category = "core"
+
+    @classmethod
+    def isRelevant(cls):
+        return Options.isStandaloneMode()
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    def _considerDataFiles(self, module, data_file_config):
+        # Many details and cases to deal with
+        # pylint: disable=too-many-branches,too-many-locals,too-many-statements
+
+        module_name = module.getFullName()
+        module_folder = module.getCompileTimeDirectory()
+
+        target_dir = data_file_config.get("dest_path")
+
+        # Default to near module or inside package folder.
+        if target_dir is None:
+            if (
+                module.isCompiledPythonPackage()
+                or module.isUncompiledPythonPackage()
+                or module.isExtensionModulePackage()
+            ):
+                target_dir = module_name.asPath()
+            else:
+                package_name = module_name.getPackageName()
+
+                if package_name is not None:
+                    target_dir = module_name.getPackageName().asPath()
+                else:
+                    target_dir = "."
+
+        patterns = data_file_config.get("patterns")
+        if patterns is not None:
+            if type(patterns) is not list or not patterns:
+                self.sysexit(
+                    "Error, requiring list below 'pattern' entry for '%s' entry."
+                    % module_name
+                )
+
+            # TODO: Pattern should be data file kind potentially.
+            for pattern in patterns:
+                pattern = self.evaluateExpressionOrConstant(
+                    full_name=module_name,
+                    expression=pattern,
+                    config_name="data file pattern for '%s'" % module_name,
+                    extra_context=None,
+                    single_value=True,
+                )
+
+                pattern = os.path.join(module_folder, pattern)
+
+                for filename in resolveShellPatternToFilenames(pattern):
+                    filename_base = os.path.relpath(filename, module_folder)
+
+                    yield self.makeIncludedDataFile(
+                        source_path=filename,
+                        dest_path=os.path.normpath(
+                            os.path.join(target_dir, filename_base)
+                        ),
+                        reason="package data for '%s'" % module_name.asString(),
+                        tags="config",
+                    )
+
+        empty_dirs = data_file_config.get("empty_dirs")
+        if empty_dirs is not None:
+            if type(empty_dirs) is not list or not empty_dirs:
+                self.sysexit(
+                    "Error, requiring list below 'empty_dirs' entry for '%s' entry."
+                    % module_name
+                )
+
+            for empty_dir in empty_dirs:
+                yield self.makeIncludedEmptyDirectory(
+                    dest_path=os.path.normpath(os.path.join(target_dir, empty_dir)),
+                    reason="empty dir needed for %r" % module_name.asString(),
+                    tags="config",
+                )
+
+        empty_dir_structures = data_file_config.get("empty_dir_structures")
+        if empty_dir_structures is not None:
+            if type(empty_dir_structures) is not list or not empty_dir_structures:
+                self.sysexit(
+                    "Error, requiring list below 'empty_dirs_structure' entry for '%s' entry."
+                    % module_name
+                )
+
+            # TODO: This ignored config dest_path, which is unused, but not consistent.
+            for included_data_file in self._getSubDirectoryFolders(
+                module, sub_dirs=empty_dir_structures
+            ):
+                yield included_data_file
+
+        dirs = data_file_config.get("dirs")
+        if dirs is not None:
+            if type(dirs) is not list or not dirs:
+                self.sysexit(
+                    "Error, requiring list below 'dirs' entry for '%s' entry."
+                    % module_name
+                )
+
+            for data_dir in dirs:
+                source_path = os.path.join(module_folder, data_dir)
+
+                if os.path.isdir(source_path):
+                    yield self.makeIncludedDataDirectory(
+                        source_path=source_path,
+                        dest_path=os.path.normpath(os.path.join(target_dir, data_dir)),
+                        reason="package data directory '%s' for %r"
+                        % (data_dir, module_name.asString()),
+                        tags="config",
+                    )
+
+        raw_dirs = data_file_config.get("raw_dirs")
+        if raw_dirs is not None:
+            if type(raw_dirs) is not list or not raw_dirs:
+                self.sysexit(
+                    "Error, requiring list below 'raw_dirs' entry for '%s' entry."
+                    % module_name
+                )
+
+            for raw_dir in raw_dirs:
+                source_path = os.path.join(module_folder, raw_dir)
+
+                if os.path.isdir(source_path):
+                    yield self.makeIncludedDataDirectory(
+                        source_path=source_path,
+                        dest_path=os.path.normpath(os.path.join(target_dir, raw_dir)),
+                        reason="package raw directory '%s' for %r"
+                        % (raw_dir, module_name.asString()),
+                        tags="config",
+                        raw=True,
+                    )
+
+        include_pyi_file = data_file_config.get("include-pyi-file")
+
+        if include_pyi_file == "yes":
+            pyi_filename = changeFilenameExtension(
+                path=module.getCompileTimeFilename(), extension=".pyi"
+            )
+
+            if os.path.exists(pyi_filename):
+                if (
+                    module.isCompiledPythonPackage()
+                    or module.isUncompiledPythonPackage()
+                ):
+                    module_path = module_name.asPath()
+                else:
+                    module_path = os.path.dirname(module_name.asPath())
+
+                yield self.makeIncludedDataFile(
+                    source_path=pyi_filename,
+                    dest_path=os.path.join(module_path, os.path.basename(pyi_filename)),
+                    reason="runtime required '.pyi' file for '%s'"
+                    % module_name.asString(),
+                    tags="config",
+                )
+
+        distribution_names = data_file_config.get("include-metadata", ())
+
+        for distribution_name in distribution_names:
+            distribution = getDistribution(distribution_name)
+
+            if distribution is not None:
+                addDistributionMetadataValue(
+                    distribution_name=distribution_name,
+                    distribution=distribution,
+                    reason="According to Yaml configuration 'include-metadata' for '%s'"
+                    % module_name.asString(),
+                )
+
+    def considerDataFiles(self, module):
+        full_name = module.getFullName()
+
+        for entry in self.config.get(full_name, section="data-files"):
+            if self.evaluateCondition(
+                full_name=full_name, condition=entry.get("when", "True")
+            ):
+                for included_data_file in self._considerDataFiles(
+                    module=module, data_file_config=entry
+                ):
+                    yield included_data_file
+
+        # TODO: Until the data files are a list and support features to do similar, namely
+        # to look up via package data interface "pkgutil.get_data" rather than file scan.
+        if full_name == "lib2to3.pygram" and isDebianPackagePython():
+            yield self.makeIncludedGeneratedDataFile(
+                data=pkgutil.get_data("lib2to3", "Grammar.txt"),
+                dest_path="lib2to3/Grammar.txt",
+                reason="package data for '%s'" % full_name,
+                tags="config",
+            )
+
+            yield self.makeIncludedGeneratedDataFile(
+                data=pkgutil.get_data("lib2to3", "PatternGrammar.txt"),
+                dest_path="lib2to3/PatternGrammar.txt",
+                reason="package data for '%s'" % full_name,
+                tags="config",
+            )
+
+    def _getSubDirectoryFolders(self, module, sub_dirs):
+        """Get dirnames in given subdirectories of the module.
+
+        Notes:
+            All dirnames in folders below one of the sub_dirs are recursively
+            retrieved and returned shortened to begin with the string of subdir.
+        Args:
+            module: module object
+            sub_dirs: sub folder name(s) - tuple
+        Returns:
+            makeIncludedEmptyDirectory of found dirnames.
+        """
+
+        module_dir = module.getCompileTimeDirectory()
+        file_list = []
+
+        data_dirs = [os.path.join(module_dir, subdir) for subdir in sub_dirs]
+
+        # Gather the full file list, probably makes no sense to include bytecode files
+        file_list = sum(
+            (
+                getFileList(
+                    data_dir, ignore_dirs=("__pycache__",), ignore_suffixes=(".pyc",)
+                )
+                for data_dir in data_dirs
+            ),
+            [],
+        )
+
+        if not file_list:
+            msg = "No files or folders found for '%s' in subfolder(s) '%s' (%r)." % (
+                module.getFullName(),
+                sub_dirs,
+                data_dirs,
+            )
+            self.warning(msg)
+
+        is_package = (
+            module.isCompiledPythonPackage() or module.isUncompiledPythonPackage()
+        )
+
+        # We need to preserve the package target path in the dist folder.
+        if is_package:
+            package_part = module.getFullName().asPath()
+        else:
+            package = module.getFullName().getPackageName()
+
+            if package is None:
+                package_part = ""
+            else:
+                package_part = package.asPath()
+
+        item_set = OrderedSet()
+
+        for f in file_list:
+            target = os.path.join(package_part, os.path.relpath(f, module_dir))
+
+            dir_name = os.path.dirname(target)
+            item_set.add(dir_name)
+
+        for dest_path in item_set:
+            yield self.makeIncludedEmptyDirectory(
+                dest_path=dest_path,
+                reason="Subdirectories of module %s" % module.getFullName(),
+                tags="config",
+            )
+
+
+#     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/plugins/standard/DelvewheelPlugin.py

@@ -0,0 +1,150 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Support for delvewheel, details in below class definitions.
+
+"""
+
+import os
+import re
+
+from nuitka.Options import isStandaloneMode
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.PythonFlavors import isAnacondaPython
+from nuitka.utils.FileOperations import listDllFilesFromDirectory
+
+# spell-checker: ignore delvewheel
+
+
+class NuitkaPluginDelvewheel(NuitkaPluginBase):
+    """This class represents the main logic of the delvewheel plugin.
+
+    This is a plugin to ensure that delvewheel DLLs are loading properly in
+    standalone mode. This needed to include the correct DLLs to the correct
+    place.
+    """
+
+    plugin_name = "delvewheel"  # Nuitka knows us by this name
+    plugin_desc = (
+        "Required for 'support' of delvewheel using packages in standalone mode."
+    )
+    plugin_category = "core"
+
+    def __init__(self):
+        # Special DLL directories if detected for a module.
+        self.dll_directories = {}
+
+        # Temporary variable when capturing current DLL directory of a module.
+        self.dll_directory = None
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    @staticmethod
+    def isRelevant():
+        return isStandaloneMode()
+
+    # This is used by our exec below, to capture the dll directory without using a free
+    # variable.
+    def _add_dll_directory(self, arg):
+        self.dll_directory = arg
+
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
+        # Avoid regular expression match if possible.
+        if "_delvewheel_" not in source_code:
+            return None
+
+        match = re.search(
+            r"(def _delvewheel_(?:init_)?patch_(.*?)\(\):\n.*?_delvewheel_(?:init_)?patch_\2\(\))",
+            source_code,
+            re.S,
+        )
+
+        if not match:
+            return None
+
+        delvewheel_version = match.group(2).replace("_", ".")
+
+        code = match.group(1)
+
+        code = code.replace("os.add_dll_directory", "add_dll_directory")
+        code = code.replace("sys.version_info[:2] >= (3, 8)", "True")
+        code = code.replace("sys.version_info[:2] >= (3, 10)", "True")
+
+        self.dll_directory = None
+
+        # Fake the "__file__" to the proper value to the exec.
+        exec_globals = {
+            "__file__": source_filename,
+            "add_dll_directory": self._add_dll_directory,
+        }
+
+        self.dll_directory = None
+
+        # We believe this should be the easiest, pylint: disable=exec-used
+        exec(code, exec_globals)
+
+        # Copy it over. For Anaconda we allow exceptions, when it's not an
+        # Anaconda package, but a PyPI package, those mixes are acting strange.
+        if not isAnacondaPython():
+            assert self.dll_directory is not None, module_name
+
+        # At least the "scs" package puts the top level package folder there
+        # even with there being no DLLs anywhere, maybe a wrong usage of
+        # delvewheel SCS, maybe only on Windows.
+        if self.dll_directory is not None:
+            self.dll_directory = os.path.normpath(self.dll_directory)
+
+            if os.path.basename(self.dll_directory) in (
+                "site-packages",
+                "dist-packages",
+                "vendor-packages",
+            ):
+                self.dll_directory = None
+
+        self.dll_directories[module_name] = self.dll_directory
+
+        if self.dll_directories[module_name]:
+            self.addModuleInfluencingDetection(
+                module_name=module_name,
+                detection_name="delvewheel_version",
+                detection_value=delvewheel_version,
+            )
+
+    def getModuleSpecificDllPaths(self, module_name):
+        if module_name in self.dll_directories:
+            yield self.dll_directories[module_name]
+
+    def getExtraDlls(self, module):
+        full_name = module.getFullName()
+
+        dll_directory = self.dll_directories.get(full_name)
+
+        if dll_directory is not None:
+            for dll_filename, dll_basename in listDllFilesFromDirectory(dll_directory):
+                yield self.makeDllEntryPoint(
+                    source_path=dll_filename,
+                    dest_path=os.path.join(
+                        os.path.basename(dll_directory), dll_basename
+                    ),
+                    module_name=full_name,
+                    package_name=full_name,
+                    reason="needed by '%s'" % full_name.asString(),
+                )
+
+
+#     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/plugins/standard/DillPlugin/DillPlugin.c

@@ -0,0 +1,37 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+// C code for use when the dill-plugin is active
+
+#include "nuitka/prelude.h"
+
+void registerDillPluginTables(PyThreadState *tstate, char const *module_name, PyMethodDef *reduce_compiled_function,
+                              PyMethodDef *create_compiled_function) {
+    PyObject *function_tables = PyObject_GetAttrString((PyObject *)builtin_module, "compiled_function_tables");
+
+    if (function_tables == NULL) {
+        CLEAR_ERROR_OCCURRED(tstate);
+
+        function_tables = MAKE_DICT_EMPTY(tstate);
+        PyObject_SetAttrString((PyObject *)builtin_module, "compiled_function_tables", function_tables);
+    }
+
+    PyObject *funcs = MAKE_TUPLE2_0(tstate, PyCFunction_New(reduce_compiled_function, NULL),
+                                    PyCFunction_New(create_compiled_function, NULL));
+
+    PyDict_SetItemString(function_tables, module_name, funcs);
+}
+
+//     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/plugins/standard/DillPlugin/cloudpickle-postLoad.py

@@ -0,0 +1,67 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+# pylint: disable=missing-module-docstring,protected-access,used-before-assignment
+
+# spell-checker: ignore kwdefaults,globalvars
+
+# Nuitka will optimize this away, but VS code will warn about them otherwise.
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    compiled_function_tables = {}
+
+try:
+    import cloudpickle
+except ImportError:
+    pass
+else:
+
+    def _create_compiled_function(module_name, func_values):
+        if module_name not in compiled_function_tables:
+            __import__(module_name)
+
+        # This gets the "_create_compiled_function" of the module and calls it.
+        return compiled_function_tables[module_name][1](*func_values)
+
+    orig_dynamic_function_reduce = (
+        cloudpickle.cloudpickle.Pickler._dynamic_function_reduce
+    )
+
+    def _dynamic_function_reduce(self, func):
+        if type(func).__name__ != "compiled_function":
+            return orig_dynamic_function_reduce(self, func)
+
+        try:
+            module_name = func.__module__
+        except AttributeError:
+            return orig_dynamic_function_reduce(self, func)
+        else:
+            if module_name not in compiled_function_tables:
+                return orig_dynamic_function_reduce(self, func)
+
+            return (
+                _create_compiled_function,
+                (
+                    module_name,
+                    # This gets the "_reduce_compiled_function" of the module and calls it.
+                    compiled_function_tables[module_name][0](func),
+                ),
+            )
+
+    cloudpickle.cloudpickle.Pickler._dynamic_function_reduce = _dynamic_function_reduce
+
+#     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.