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

nuitka/plugins/standard/ConsiderPyLintAnnotationsPlugin.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
+
+
 """ Standard plug-in to take advantage of pylint or PyDev annotations.
 
 Nuitka can detect some things that PyLint and PyDev will complain about too,
@@ -31,7 +17,6 @@ to grow both.
 
 """
 
-
 import re
 
 from nuitka.__past__ import intern
@@ -83,7 +68,7 @@ if False:
     class NuitkaPluginDetectorPylintEclipseAnnotations(NuitkaPluginBase):
         detector_for = NuitkaPluginPylintEclipseAnnotations
 
-        def onModuleSourceCode(self, module_name, source_code):
+        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."
@@ -91,3 +76,19 @@ if False:
 
             # 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

@@ -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
+
+
 """ Standard plug-in to find data files.
 
 """
@@ -25,7 +11,7 @@ import pkgutil
 from nuitka import Options
 from nuitka.code_generation.ConstantCodes import addDistributionMetadataValue
 from nuitka.containers.OrderedSets import OrderedSet
-from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
 from nuitka.PythonFlavors import isDebianPackagePython
 from nuitka.utils.Distributions import getDistribution
 from nuitka.utils.FileOperations import (
@@ -33,17 +19,13 @@ from nuitka.utils.FileOperations import (
     getFileList,
     resolveShellPatternToFilenames,
 )
-from nuitka.utils.Yaml import getYamlPackageConfiguration
 
 
-class NuitkaPluginDataFileCollector(NuitkaPluginBase):
+class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
     plugin_name = "data-files"
 
     plugin_desc = "Include data files specified by package configuration files."
 
-    def __init__(self):
-        self.config = getYamlPackageConfiguration()
-
     @classmethod
     def isRelevant(cls):
         return Options.isStandaloneMode()
@@ -54,7 +36,7 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
 
     def _considerDataFiles(self, module, data_file_config):
         # Many details and cases to deal with
-        # pylint: disable=too-many-branches,too-many-locals
+        # pylint: disable=too-many-branches,too-many-locals,too-many-statements
 
         module_name = module.getFullName()
         module_folder = module.getCompileTimeDirectory()
@@ -63,7 +45,11 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
 
         # Default to near module or inside package folder.
         if target_dir is None:
-            if module.isCompiledPythonPackage() or module.isUncompiledPythonPackage():
+            if (
+                module.isCompiledPythonPackage()
+                or module.isUncompiledPythonPackage()
+                or module.isExtensionModulePackage()
+            ):
                 target_dir = module_name.asPath()
             else:
                 package_name = module_name.getPackageName()
@@ -83,6 +69,14 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
 
             # 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):
@@ -107,7 +101,7 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
 
             for empty_dir in empty_dirs:
                 yield self.makeIncludedEmptyDirectory(
-                    dest_path=os.path.join(target_dir, empty_dir),
+                    dest_path=os.path.normpath(os.path.join(target_dir, empty_dir)),
                     reason="empty dir needed for %r" % module_name.asString(),
                     tags="config",
                 )
@@ -130,7 +124,7 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
         if dirs is not None:
             if type(dirs) is not list or not dirs:
                 self.sysexit(
-                    "Error, requiring list below 'empty_dirs_structure' entry for '%s' entry."
+                    "Error, requiring list below 'dirs' entry for '%s' entry."
                     % module_name
                 )
 
@@ -140,12 +134,33 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
                 if os.path.isdir(source_path):
                     yield self.makeIncludedDataDirectory(
                         source_path=source_path,
-                        dest_path=os.path.join(target_dir, data_dir),
+                        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":
@@ -176,7 +191,12 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
             distribution = getDistribution(distribution_name)
 
             if distribution is not None:
-                addDistributionMetadataValue(distribution_name, distribution)
+                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()
@@ -273,3 +293,19 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
                 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

@@ -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
+
+
 """ Support for delvewheel, details in below class definitions.
 
 """
@@ -22,7 +8,7 @@
 import os
 import re
 
-from nuitka import Options
+from nuitka.Options import isStandaloneMode
 from nuitka.plugins.PluginBase import NuitkaPluginBase
 from nuitka.PythonFlavors import isAnacondaPython
 from nuitka.utils.FileOperations import listDllFilesFromDirectory
@@ -56,14 +42,14 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
 
     @staticmethod
     def isRelevant():
-        return Options.isStandaloneMode()
+        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_code):
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
         # Avoid regular expression match if possible.
         if "_delvewheel_" not in source_code:
             return None
@@ -89,7 +75,7 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
 
         # Fake the "__file__" to the proper value to the exec.
         exec_globals = {
-            "__file__": self.locateModule(module_name) + "\\__init__.py",
+            "__file__": source_filename,
             "add_dll_directory": self._add_dll_directory,
         }
 
@@ -119,11 +105,16 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
         self.dll_directories[module_name] = self.dll_directory
 
         if self.dll_directories[module_name]:
-            self.info(
-                "Detected usage of 'delvewheel' version '%s' in module '%s'."
-                % (delvewheel_version, module_name.asString())
+            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()
 
@@ -136,6 +127,23 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
                     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 2024, 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/dill-postLoad.py

@@ -0,0 +1,256 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+# Plugin dill-compat has this as post load code for the "dill" package.
+# Not supposed to be good code,
+# pylint: disable=invalid-name,missing-module-docstring,protected-access
+# pylint: disable=too-many-branches,too-many-statements,used-before-assignment
+from types import CodeType
+
+# spell-checker: ignore kwdefaults,globalvars
+# Nuitka will optimize this away, but VS code will warn about them otherwise.
+from typing import TYPE_CHECKING
+
+import dill._dill
+
+if str is bytes:
+    import __builtin__ as builtins  # Python2 code, pylint: disable=import-error
+else:
+    import builtins
+
+if TYPE_CHECKING:
+    compiled_function_tables = {}
+
+
+class ForCompiledTypeLookups:
+    def for_compiled_type(self):
+        pass
+
+
+compiled_function = type(ForCompiledTypeLookups.for_compiled_type)
+compiled_method = type(ForCompiledTypeLookups().for_compiled_type)
+assert "__compiled__" in globals()
+
+dill_version = tuple(int(d) for d in dill.__version__.split("."))
+
+
+# Compiled methods need to be created.
+@dill.register(compiled_method)
+def save_compiled_method(pickler, obj):
+    if str is not bytes:
+        pickler.save_reduce(compiled_method, (obj.__func__, obj.__self__), obj=obj)
+    else:
+        pickler.save_reduce(
+            compiled_method, (obj.im_func, obj.im_self, obj.im_class), obj=obj
+        )
+
+
+if str is bytes:
+
+    def _create_compiled_function2(module_name, func_values, func_dict, func_defaults):
+        if module_name not in compiled_function_tables:
+            __import__(module_name)
+
+        # This gets the "_create_compiled_function" of the module and calls it.
+        func = compiled_function_tables[module_name][1](*func_values)
+        if func_dict:
+            for key, value in func_dict.items():
+                func[key] = value
+
+        func.__defaults__ = func_defaults
+
+        return func
+
+
+if str is not bytes:
+
+    def _create_compiled_function3(
+        module_name, func_values, func_dict, func_defaults, func_kwdefaults
+    ):
+        if module_name not in compiled_function_tables:
+            __import__(module_name)
+
+        func = compiled_function_tables[module_name][1](*func_values)
+        if func_dict:
+            for key, value in func_dict.items():
+                func[key] = value
+
+        func.__defaults__ = func_defaults
+        func.__kwdefaults__ = func_kwdefaults
+
+        return func
+
+
+# Compiled methods might have to be created as well. This is very closely following
+# the code of "dill._dill.save_function" that is intended to do things for the
+# uncompiled function.
+@dill.register(compiled_function)
+def save_compiled_function(pickler, obj):
+    # Complex beast, pylint: disable=too-many-locals
+
+    if dill_version >= (0, 3):
+        if not dill._dill._locate_function(obj, pickler):
+            if type(obj.__code__) is not CodeType:
+                # Some PyPy builtin functions have no module name, and thus are not
+                # able to be located
+                module_name = getattr(obj, "__module__", None)
+                if module_name is None:
+                    module_name = builtins.__name__
+
+                _module = dill._dill._import_module(module_name, safe=True)
+
+            _recurse = getattr(pickler, "_recurse", None)
+            _postproc = getattr(pickler, "_postproc", None)
+            _main_modified = getattr(pickler, "_main_modified", None)
+            _original_main = getattr(pickler, "_original_main", builtins)
+
+            postproc_list = []
+            if _recurse:
+                # recurse to get all globals referred to by obj
+                from dill.detect import globalvars
+
+                globs_copy = globalvars(obj, recurse=True, builtin=True)
+
+                # Add the name of the module to the globs dictionary to prevent
+                # the duplication of the dictionary. Pickle the unpopulated
+                # globals dictionary and set the remaining items after the function
+                # is created to correctly handle recursion.
+                globs = {"__name__": obj.__module__}
+            else:
+                globs_copy = obj.__globals__
+
+                # If the globals is the __dict__ from the module being saved as a
+                # session, substitute it by the dictionary being actually saved.
+                if _main_modified and globs_copy is _original_main.__dict__:
+                    globs_copy = getattr(pickler, "_main", _original_main).__dict__
+                    globs = globs_copy
+                # If the globals is a module __dict__, do not save it in the pickle.
+                elif (
+                    globs_copy is not None
+                    and obj.__module__ is not None
+                    and getattr(
+                        dill._dill._import_module(obj.__module__, True),
+                        "__dict__",
+                        None,
+                    )
+                    is globs_copy
+                ):
+                    globs = globs_copy
+                else:
+                    globs = {"__name__": obj.__module__}
+
+            if globs_copy is not None and globs is not globs_copy:
+                # In the case that the globals are copied, we need to ensure that
+                # the globals dictionary is updated when all objects in the
+                # dictionary are already created.
+                glob_ids = {id(g) for g in globs_copy.values()}
+                for stack_element in _postproc:
+                    if stack_element in glob_ids:
+                        _postproc[stack_element].append(
+                            (dill._dill._setitems, (globs, globs_copy))
+                        )
+                        break
+                else:
+                    postproc_list.append((dill._dill._setitems, (globs, globs_copy)))
+
+            state_dict = {}
+            for fattrname in ("__doc__", "__kwdefaults__", "__annotations__"):
+                fattr = getattr(obj, fattrname, None)
+                if fattr is not None:
+                    state_dict[fattrname] = fattr
+            if obj.__qualname__ != obj.__name__:
+                state_dict["__qualname__"] = obj.__qualname__
+            if "__name__" not in globs or obj.__module__ != globs["__name__"]:
+                state_dict["__module__"] = obj.__module__
+
+            pickler.save_reduce(
+                _create_compiled_function3,
+                (
+                    obj.__module__,
+                    # This gets the "_reduce_compiled_function" of the module and calls it.
+                    compiled_function_tables[obj.__module__][0](obj),
+                    obj.__dict__,
+                    obj.__defaults__,
+                    obj.__kwdefaults__,
+                ),
+            )
+        else:
+            name = getattr(obj, "__qualname__", getattr(obj, "__name__", None))
+            dill._dill.StockPickler.save_global(pickler, obj, name=name)
+    else:
+        if not dill._dill._locate_function(obj):
+            stack = dill._dill.stack
+
+            _byref = getattr(pickler, "_byref", None)
+            _recurse = getattr(pickler, "_recurse", None)
+            _memo = (id(obj) in stack) and (_recurse is not None)
+            stack[id(obj)] = len(stack), obj
+
+            if str is not bytes:
+                # Python3
+                _super = ("super" in getattr(obj.__code__, "co_names", ())) and (
+                    _byref is not None
+                )
+                if _super:
+                    pickler._byref = True
+                if _memo:
+                    pickler._recurse = False
+
+                pickler.save_reduce(
+                    _create_compiled_function3,
+                    (
+                        obj.__module__,
+                        compiled_function_tables[obj.__module__][0](obj),
+                        obj.__dict__,
+                        obj.__defaults__,
+                        obj.__kwdefaults__,
+                    ),
+                )
+            else:
+                # Python2
+                _super = (
+                    ("super" in getattr(obj.__code__, "co_names", ()))
+                    and (_byref is not None)
+                    and getattr(pickler, "_recurse", False)
+                )
+                if _super:
+                    pickler._byref = True
+                if _memo:
+                    pickler._recurse = False
+
+                pickler.save_reduce(
+                    _create_compiled_function2,
+                    (
+                        obj.__module__,
+                        compiled_function_tables[obj.__module__][0](obj),
+                        obj.__dict__,
+                        obj.__defaults__,
+                    ),
+                )
+
+            if _super:
+                pickler._byref = _byref
+            if _memo:
+                pickler._recurse = _recurse
+        else:
+            dill._dill.StockPickler.save_global(pickler, obj)
+
+
+if __compiled__.standalone:  # pylint: disable=undefined-variable
+    builtins.compiled_method = compiled_method
+    builtins.compiled_function = compiled_function
+
+#     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.