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

nuitka/plugins/PluginBase.py

@@ -28,10 +28,12 @@ it being used.
 
 import ast
 import functools
+import imp
 import inspect
 import os
 import sys
 
+from nuitka import Options
 from nuitka.__past__ import getMetaClassBase
 from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.containers.OrderedSets import OrderedSet
@@ -61,7 +63,10 @@ from nuitka.Options import (
     shallShowExecutedCommands,
 )
 from nuitka.PythonFlavors import isAnacondaPython, isDebianPackagePython
-from nuitka.PythonVersions import getSupportedPythonVersions, python_version
+from nuitka.PythonVersions import (
+    getTestExecutionPythonVersions,
+    python_version,
+)
 from nuitka.Tracing import plugins_logger
 from nuitka.utils.Distributions import isDistributionCondaPackage
 from nuitka.utils.Execution import NuitkaCalledProcessError, check_output
@@ -84,6 +89,10 @@ _warned_unused_plugins = set()
 # TODO: Could share data cache with meta data nodes
 _package_versions = {}
 
+# Populated during plugin instance creation from their tags given by
+# "getEvaluationConditionControlTags" value.
+control_tags = {}
+
 
 def _convertVersionToTuple(version_str):
     def numberize(v):
@@ -418,10 +427,13 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return ()
 
-    def onModuleEncounter(self, module_name, module_filename, module_kind):
+    def onModuleEncounter(
+        self, using_module_name, module_name, module_filename, module_kind
+    ):
         """Help decide whether to include a module.
 
         Args:
+            using_module_name: module that does this (can be None if user)
             module_name: full module name
             module_filename: filename
             module_kind: one of "py", "extension" (shared library)
@@ -432,7 +444,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         return None
 
     def onModuleRecursion(
-        self, module_name, module_filename, module_kind, using_module, source_ref
+        self, module_name, module_filename, module_kind, using_module_name, source_ref
     ):
         """React to recursion to a module coming up.
 
@@ -440,7 +452,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
             module_name: full module name
             module_filename: filename
             module_kind: one of "py", "extension" (shared library)
-            using_module: module object that does the usage (None if it is a user choice)
+            using_module_name: name of module that does the usage (None if it is a user choice)
             source_ref: code making the import (None if it is a user choice)
         Returns:
             None
@@ -1066,9 +1078,12 @@ except ImportError:
         ).key
 
     def onFunctionBodyParsing(self, module_name, function_name, body):
-        """Provide a different function body for the function of that module."""
+        """Provide a different function body for the function of that module.
+
+        Should return a boolean, indicating if any actual change was done.
+        """
         # Virtual method, pylint: disable=no-self-use,unused-argument
-        return None
+        return False
 
     def getCacheContributionValues(self, module_name):
         """Provide values that represent the include of a plugin on the compilation.
@@ -1095,7 +1110,11 @@ except ImportError:
         """Provide package version of a distribution."""
         return _getPackageVersion(distribution_name)
 
-    def evaluateCondition(self, full_name, condition, control_tags=()):
+    def getEvaluationConditionControlTags(self):
+        # Virtual method, pylint: disable=no-self-use
+        return {}
+
+    def evaluateCondition(self, full_name, condition):
         # Note: Caching makes no sense yet, this should all be very fast and
         # cache themselves. TODO: Allow plugins to contribute their own control
         # tag values during creation and during certain actions.
@@ -1125,6 +1144,8 @@ except ImportError:
                 "no_asserts": hasPythonFlagNoAsserts(),
                 "no_docstrings": hasPythonFlagNoDocStrings(),
                 "no_annotations": hasPythonFlagNoAnnotations(),
+                # Querying package properties
+                "has_builtin_module": imp.is_builtin,
             }
         )
 
@@ -1137,7 +1158,7 @@ except ImportError:
                 }
             )
 
-        versions = getSupportedPythonVersions()
+        versions = getTestExecutionPythonVersions()
 
         for version in versions:
             big, major = version.split(".")
@@ -1154,6 +1175,9 @@ except ImportError:
         try:
             result = eval(condition, context)
         except Exception as e:  # Catch all the things, pylint: disable=broad-except
+            if Options.is_debug:
+                raise
+
             self.sysexit(
                 "Error, failed to evaluate condition '%s' in this context, exception was '%s'."
                 % (condition, e)

nuitka/plugins/Plugins.py

@@ -57,7 +57,7 @@ from nuitka.utils.ModuleNames import (
     pre_module_load_trigger_name,
 )
 
-from .PluginBase import NuitkaPluginBase
+from .PluginBase import NuitkaPluginBase, control_tags
 
 # Maps plugin name to plugin instances.
 active_plugins = OrderedDict()
@@ -127,12 +127,30 @@ def _addActivePlugin(plugin_class, args, force=False):
 
     active_plugins[plugin_name] = plugin_instance
 
+    is_gui_toolkit_plugin = getattr(plugin_class, "plugin_gui_toolkit", False)
+
     # Singleton, pylint: disable=global-statement
     global has_active_gui_toolkit_plugin
-    has_active_gui_toolkit_plugin = has_active_gui_toolkit_plugin or getattr(
-        plugin_class, "plugin_gui_toolkit", False
+    has_active_gui_toolkit_plugin = (
+        has_active_gui_toolkit_plugin or is_gui_toolkit_plugin
     )
 
+    # Do GUI toolkit exclusion control tags generically. You may have two of
+    # them and we don't want them to override each other.
+    if is_gui_toolkit_plugin:
+        for binding_name in getGUIBindingNames():
+            is_matching = binding_name.lower() == plugin_class.binding_name.lower()
+
+            tag_name = "use_%s" % binding_name.lower()
+
+            # Set if matching, set to False only if not matching and not already set.
+            if is_matching:
+                control_tags[tag_name] = True
+            elif is_matching not in control_tags:
+                control_tags[tag_name] = False
+
+    control_tags.update(plugin_instance.getEvaluationConditionControlTags())
+
 
 def getActivePlugins():
     """Return list of active plugins.
@@ -146,6 +164,7 @@ def getActivePlugins():
 
 
 def getActiveQtPlugin():
+    """Get active Qt plugin name."""
     for plugin_name in getQtPluginNames():
         if hasActivePlugin(plugin_name):
             if hasActivePlugin(plugin_name):
@@ -154,6 +173,16 @@ def getActiveQtPlugin():
     return None
 
 
+def getActiveQtPluginBindingName():
+    """Get active Qt plugin binding name."""
+    plugin_name = getActiveQtPlugin()
+
+    if plugin_name is None:
+        return None
+    else:
+        return getPluginClass(plugin_name).binding_name
+
+
 def getQtBindingNames():
     return ("PySide", "PySide2", "PySide6", "PyQt4", "PyQt5", "PyQt6")
 
@@ -162,6 +191,10 @@ def getOtherGUIBindingNames():
     return ("wx", "tkinter", "Tkinter")
 
 
+def getGUIBindingNames():
+    return getQtBindingNames() + getOtherGUIBindingNames()
+
+
 def getQtPluginNames():
     return tuple(qt_binding_name.lower() for qt_binding_name in getQtBindingNames())
 
@@ -428,6 +461,7 @@ class Plugins(object):
 
             # This will get back to all other plugins allowing them to inhibit it though.
             decision, reason = Recursion.decideRecursion(
+                using_module_name=module.getFullName(),
                 module_filename=module_filename,
                 module_name=full_name,
                 module_kind=module_kind,
@@ -439,7 +473,7 @@ class Plugins(object):
                     module_name=full_name,
                     module_filename=module_filename,
                     module_kind=module_kind,
-                    using_module=module,
+                    using_module_name=module.module_name,
                     source_ref=module.getSourceReference(),
                     reason=reason,
                 )
@@ -969,12 +1003,13 @@ class Plugins(object):
         return bytecode
 
     @staticmethod
-    def onModuleEncounter(module_name, module_filename, module_kind):
+    def onModuleEncounter(using_module_name, module_name, module_filename, module_kind):
         result = None
         deciding_plugins = []
 
         for plugin in getActivePlugins():
             must_recurse = plugin.onModuleEncounter(
+                using_module_name=using_module_name,
                 module_name=module_name,
                 module_filename=module_filename,
                 module_kind=module_kind,
@@ -1002,14 +1037,14 @@ class Plugins(object):
 
     @staticmethod
     def onModuleRecursion(
-        module_name, module_filename, module_kind, using_module, source_ref
+        module_name, module_filename, module_kind, using_module_name, source_ref
     ):
         for plugin in getActivePlugins():
             plugin.onModuleRecursion(
                 module_name=module_name,
                 module_filename=module_filename,
                 module_kind=module_kind,
-                using_module=using_module,
+                using_module_name=using_module_name,
                 source_ref=source_ref,
             )
 
@@ -1281,6 +1316,8 @@ class Plugins(object):
         module_name = provider.getParentModule().getFullName()
 
         for plugin in getActivePlugins():
+            # TODO: Could record what functions got modified by what plugin
+            # and in what way checking the return value
             plugin.onFunctionBodyParsing(
                 module_name=module_name,
                 function_name=function_name,

nuitka/plugins/standard/AntiBloatPlugin.py

@@ -33,7 +33,7 @@ from nuitka.plugins.PluginBase import NuitkaPluginBase
 from nuitka.utils.ModuleNames import ModuleName
 from nuitka.utils.Yaml import getYamlPackageConfiguration
 
-# spell-checker: ignore dask,numba
+# spell-checker: ignore dask,numba,statsmodels,matplotlib
 
 _mode_choices = ("error", "warning", "nofollow", "allow")
 
@@ -86,47 +86,66 @@ class NuitkaPluginAntiBloat(NuitkaPluginBase):
         self.control_tags = OrderedDict()
 
         if noinclude_setuptools_mode != "allow":
-            self.handled_modules["setuptools"] = noinclude_setuptools_mode
-            self.handled_modules["setuptools_scm"] = noinclude_setuptools_mode
+            self.handled_modules["setuptools"] = noinclude_setuptools_mode, "setuptools"
+            self.handled_modules["setuptools_scm"] = (
+                noinclude_setuptools_mode,
+                "setuptools",
+            )
         else:
             self.control_tags["use_setuptools"] = True
 
         if noinclude_pytest_mode != "allow":
-            self.handled_modules["_pytest"] = noinclude_pytest_mode
-            self.handled_modules["pytest"] = noinclude_pytest_mode
-            self.handled_modules["py"] = noinclude_pytest_mode
-            self.handled_modules["nose2"] = noinclude_pytest_mode
-            self.handled_modules["nose"] = noinclude_pytest_mode
+            self.handled_modules["_pytest"] = noinclude_pytest_mode, "pytest"
+            self.handled_modules["pytest"] = noinclude_pytest_mode, "pytest"
+            self.handled_modules["py"] = noinclude_pytest_mode, "pytest"
+            self.handled_modules["nose2"] = noinclude_pytest_mode, "pytest"
+            self.handled_modules["nose"] = noinclude_pytest_mode, "pytest"
+            self.handled_modules["statsmodels.tools._testing"] = (
+                noinclude_pytest_mode,
+                "pytest",
+            )
         else:
             self.control_tags["use_pytest"] = True
 
         if noinclude_unittest_mode != "allow":
-            self.handled_modules["unittest"] = noinclude_unittest_mode
-            self.handled_modules["doctest"] = noinclude_unittest_mode
+            self.handled_modules["unittest"] = noinclude_unittest_mode, "unittest"
+            self.handled_modules["doctest"] = noinclude_unittest_mode, "unittest"
         else:
             self.control_tags["use_unittest"] = True
 
         if noinclude_ipython_mode != "allow":
-            self.handled_modules["IPython"] = noinclude_ipython_mode
+            self.handled_modules["IPython"] = noinclude_ipython_mode, "IPython"
+            self.handled_modules["matplotlib_inline.backend_inline"] = (
+                noinclude_ipython_mode,
+                "IPython",
+            )
         else:
             self.control_tags["use_ipython"] = True
 
         if noinclude_dask_mode != "allow":
-            self.handled_modules["dask"] = noinclude_dask_mode
+            self.handled_modules["dask"] = noinclude_dask_mode, "dask"
+            self.handled_modules["distributed"] = noinclude_dask_mode, "dask"
         else:
             self.control_tags["use_dask"] = True
 
         if noinclude_numba_mode != "allow":
-            self.handled_modules["numba"] = noinclude_numba_mode
-            self.handled_modules["sparse"] = noinclude_numba_mode
+            self.handled_modules["numba"] = noinclude_numba_mode, "numba"
+            self.handled_modules["sparse"] = noinclude_numba_mode, "numba"
+            self.handled_modules["stumpy"] = noinclude_numba_mode, "numba"
+            self.handled_modules["pandas.core._numba.kernels"] = (
+                noinclude_numba_mode,
+                "numba",
+            )
         else:
             self.control_tags["use_numba"] = True
 
         for custom_choice in custom_choices:
-            if ":" not in custom_choice:
+            if custom_choice.count(":") != 1:
                 self.sysexit(
-                    "Error, malformed value '%s' for '--noinclude-custom-mode' used."
-                    % custom_choice
+                    """\
+Error, malformed value '%s' for '--noinclude-custom-mode' used. It has to be of \
+form 'module_name:[%s]'."""
+                    % (custom_choice, "|".join(_mode_choices))
                 )
 
             module_name, mode = custom_choice.rsplit(":", 1)
@@ -137,19 +156,40 @@ class NuitkaPluginAntiBloat(NuitkaPluginBase):
                     % (mode, custom_choice)
                 )
 
-            self.handled_modules[ModuleName(module_name)] = mode
+            self.handled_modules[ModuleName(module_name)] = mode, module_name
 
             if mode == "allow":
                 self.control_tags["use_%s" % module_name] = True
 
+        self.handled_module_namespaces = {}
+
+        for handled_module_name, (
+            mode,
+            intended_module_name,
+        ) in self.handled_modules.items():
+            if mode == "warning":
+                if intended_module_name not in self.handled_module_namespaces:
+                    self.handled_module_namespaces[intended_module_name] = set()
+                self.handled_module_namespaces[intended_module_name].add(
+                    handled_module_name
+                )
+
         self.warnings_given = set()
 
+    def getEvaluationConditionControlTags(self):
+        return self.control_tags
+
     def getCacheContributionValues(self, module_name):
         config = self.config.get(module_name, section="anti-bloat")
 
         if config:
             yield str(config)
 
+            # TODO: Until we can change the evaluation to tell us exactly what
+            # control tag values were used, we have to make this one. We sort
+            # the values, to try and have order changes in code not matter.
+            yield str(tuple(sorted(self.handled_modules.items())))
+
     @classmethod
     def addPluginCommandLineOptions(cls, group):
         group.add_option(
@@ -382,10 +422,7 @@ which can and should be a top level package and then one choice, "error",
     def onModuleSourceCode(self, module_name, source_code):
         for anti_bloat_config in self.config.get(module_name, section="anti-bloat"):
             if self.evaluateCondition(
-                full_name=module_name,
-                condition=anti_bloat_config.get("when", "True"),
-                # Allow disabling config for a module with matching control tags.
-                control_tags=self.control_tags,
+                full_name=module_name, condition=anti_bloat_config.get("when", "True")
             ):
                 source_code = self._onModuleSourceCode(
                     module_name=module_name,
@@ -414,79 +451,105 @@ which can and should be a top level package and then one choice, "error",
                 function_name,
             )
 
-        if replace_code is not None:
-            if not context_ready:
-                exec(context_code, context)
-                context_ready = True
+        if replace_code is None:
+            return False
 
-            try:
-                replacement = eval(replace_code, context)
-            except Exception as e:  # pylint: disable=broad-except
-                self.sysexit(
-                    "Error, cannot evaluate code '%s' in '%s' due to: %s"
-                    % (replace_code, context_code, e)
-                )
+        if not context_ready:
+            exec(context_code, context)
+            context_ready = True
 
-            # Single node is required, extract the generated module body with
-            # single expression only statement value or a function body.
-            replacement = ast.parse(replacement).body[0]
-
-            if type(replacement) is ast.Expr:
-                if type(replacement.value) is ast.Lambda:
-                    body[:] = [ast.Return(replacement.value.body)]
-                else:
-                    body[:] = [ast.Return(replacement.value)]
-            elif type(replacement) is ast.Raise:
-                body[:] = [replacement]
+        try:
+            replacement = eval(replace_code, context)
+        except Exception as e:  # pylint: disable=broad-except
+            self.sysexit(
+                "Error, cannot evaluate code '%s' in '%s' due to: %s"
+                % (replace_code, context_code, e)
+            )
+
+        # Single node is required, extract the generated module body with
+        # single expression only statement value or a function body.
+        replacement = ast.parse(replacement).body[0]
+
+        if type(replacement) is ast.Expr:
+            if type(replacement.value) is ast.Lambda:
+                body[:] = [ast.Return(replacement.value.body)]
             else:
-                body[:] = replacement.body
+                body[:] = [ast.Return(replacement.value)]
+        elif type(replacement) is ast.Raise:
+            body[:] = [replacement]
+        else:
+            body[:] = replacement.body
 
-            if self.show_changes:
-                self.info(
-                    "Updated module '%s' function '%s'."
-                    % (module_name.asString(), function_name)
-                )
+        if self.show_changes:
+            self.info(
+                "Updated module '%s' function '%s'."
+                % (module_name.asString(), function_name)
+            )
+
+        return True
 
     def onFunctionBodyParsing(self, module_name, function_name, body):
+        result = False
+
         config = self.config.get(module_name, section="anti-bloat")
 
         if config:
             for anti_bloat_config in config:
-                self._onFunctionBodyParsing(
+                if self._onFunctionBodyParsing(
                     module_name=module_name,
                     anti_bloat_config=anti_bloat_config,
                     function_name=function_name,
                     body=body,
-                )
+                ):
+                    result = True
+
+        return result
 
     def onModuleRecursion(
-        self, module_name, module_filename, module_kind, using_module, source_ref
+        self, module_name, module_filename, module_kind, using_module_name, source_ref
     ):
-        for handled_module_name, mode in self.handled_modules.items():
+        # This will allow "unittest.mock" to pass these things.
+        if module_name == "unittest.mock" and module_name not in self.handled_modules:
+            return
+
+        for handled_module_name, (
+            mode,
+            intended_module_name,
+        ) in self.handled_modules.items():
+            # This will ignore internal usages. In case of error, e.g. above unittest
+            # could cause them to happen.
+            if using_module_name is not None and using_module_name.hasNamespace(
+                handled_module_name
+            ):
+                return
+
             if module_name.hasNamespace(handled_module_name):
                 # Make sure the compilation aborts or warns if asked to
                 if mode == "error":
-                    raise NuitkaForbiddenImportEncounter(module_name)
-                if mode == "warning" and (
-                    (
-                        using_module is None
-                        or not using_module.getFullName().hasNamespace(
-                            handled_module_name
-                        )
+                    raise NuitkaForbiddenImportEncounter(
+                        module_name, intended_module_name
                     )
-                    and source_ref is not None
-                ):
+                if mode == "warning" and source_ref is not None:
+                    if using_module_name.hasOneOfNamespaces(
+                        self.handled_module_namespaces[intended_module_name]
+                    ):
+                        continue
+
                     key = (
-                        handled_module_name,
-                        using_module,
+                        module_name,
+                        using_module_name,
                         source_ref.getLineNumber(),
                     )
+
                     if key not in self.warnings_given:
                         self.warning(
-                            "Undesirable import of '%s' in '%s' (at '%s') encountered. It may slow down compilation."
+                            """\
+Undesirable import of '%s' (intending to avoid '%s') in \
+'%s' (at '%s') encountered. It may slow down compilation."""
                             % (
                                 handled_module_name,
-                                using_module.getFullName(),
+                                intended_module_name,
+                                using_module_name,
                                 source_ref.getAsString(),
                             ),
                             mnemonic="unwanted-module",
@@ -494,26 +557,57 @@ which can and should be a top level package and then one choice, "error",
 
                         self.warnings_given.add(key)
 
-    def onModuleEncounter(self, module_name, module_filename, module_kind):
-        for handled_module_name, mode in self.handled_modules.items():
+    def onModuleEncounter(
+        self, using_module_name, module_name, module_filename, module_kind
+    ):
+        for handled_module_name, (
+            mode,
+            intended_module_name,
+        ) in self.handled_modules.items():
             if module_name.hasNamespace(handled_module_name):
                 # Either issue a warning, or pretend the module doesn't exist for standalone or
                 # at least will not be included.
                 if mode == "nofollow":
                     if self.show_changes:
                         self.info(
-                            "Forcing import of '%s' to not be followed." % module_name
+                            "Forcing import of '%s' (intending to avoid '%s') to not be followed."
+                            % (module_name, intended_module_name)
                         )
                     return (
                         False,
-                        "user requested to not follow '%s' import" % module_name,
+                        "user requested to not follow '%s' (intending to avoid '%s') import"
+                        % (module_name, intended_module_name),
                     )
 
+        if using_module_name is not None:
+            config = self.config.get(using_module_name, section="anti-bloat")
+
+            if config:
+                for anti_bloat_config in config:
+                    match, reason = module_name.matchesToShellPatterns(
+                        anti_bloat_config.get("no-auto-follow", ())
+                    )
+
+                    if match:
+                        if self.evaluateCondition(
+                            full_name=module_name,
+                            condition=anti_bloat_config.get("when", "True"),
+                        ):
+
+                            return (
+                                False,
+                                "according to yaml 'no-auto-follow' configuration of '%s' and '%s'"
+                                % (using_module_name, reason),
+                            )
+
         # Do not provide an opinion about it.
         return None
 
     def decideCompilation(self, module_name):
-        for handled_module_name, mode in self.handled_modules.items():
+        for handled_module_name, (
+            mode,
+            _intended_module_name,
+        ) in self.handled_modules.items():
             if mode != "bytecode":
                 continue
 

nuitka/plugins/standard/DataFilesPlugin.py

@@ -23,9 +23,11 @@ import os
 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.PythonFlavors import isDebianPackagePython
+from nuitka.utils.Distributions import getDistribution
 from nuitka.utils.FileOperations import (
     changeFilenameExtension,
     getFileList,
@@ -168,6 +170,14 @@ class NuitkaPluginDataFileCollector(NuitkaPluginBase):
                     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)
+
     def considerDataFiles(self, module):
         full_name = module.getFullName()
 

nuitka/plugins/standard/DllFilesPlugin.py

@@ -157,8 +157,7 @@ class NuitkaPluginDllFiles(NuitkaPluginBase):
     def _handleDllConfigByCode(self, dll_config, full_name, dest_path, count):
         # The "when" is at that level too for these.
         if not self.evaluateCondition(
-            full_name=full_name,
-            condition=dll_config.get("when", "True"),
+            full_name=full_name, condition=dll_config.get("when", "True")
         ):
             return