Nuitka-winsvc 2.5.6__cp311-cp311-win_amd64.whl → 2.6.5__cp311-cp311-win_amd64.whl

nuitka/plugins/PluginBase.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """
@@ -150,7 +150,7 @@ def _getEvaluationContext():
             "android32": isAndroidBasedLinux() and sys.maxsize < 2**32,
             "android64": isAndroidBasedLinux() and sys.maxsize >= 2**64 - 1,
             "anaconda": isAnacondaPython(),
-            "is_conda_package": isDistributionCondaPackage,
+            "is_conda_package": _isCondaPackage,
             "debian_python": isDebianPackagePython(),
             "nuitka_python": isNuitkaPython(),
             "standalone": isStandaloneMode(),
@@ -266,6 +266,12 @@ def _getDistributionNameFromPackageName(package_name):
         return getDistributionName(distribution)
 
 
+def _isCondaPackage(package_name):
+    distribution_name = _getDistributionNameFromPackageName(package_name)
+
+    return isDistributionCondaPackage(distribution_name)
+
+
 def _getPackageVersion(distribution_name):
     if distribution_name not in _package_versions:
         try:
@@ -446,6 +452,21 @@ class NuitkaPluginBase(getMetaClassBase("Plugin", require_slots=False)):
         """Is this a detection plugin, i.e. one which is only there to inform."""
         return hasattr(cls, "detector_for")
 
+    @classmethod
+    def hasCategory(cls, category):
+        return category in cls.getCategories()
+
+    @classmethod
+    def getCategories(cls):
+        plugin_category = getattr(cls, "plugin_category", None)
+
+        if plugin_category is None:
+            result = ()
+        else:
+            result = plugin_category.split(",")
+
+        return OrderedSet(sorted(result))
+
     @classmethod
     def addPluginCommandLineOptions(cls, group):
         # Call group.add_option() here.
@@ -1280,7 +1301,8 @@ import sys
 
 try:
 %(setup_codes)s
-except ImportError:
+except ImportError as e:
+    sys.stderr.write("\n%%s" %% repr(e))
     sys.exit(38)
 try:
 %(query_codes)s
@@ -1302,6 +1324,11 @@ except Exception as e:
             feedback = check_output([sys.executable, "-c", cmd], env=env)
         except NuitkaCalledProcessError as e:
             if e.returncode == 38:
+                self.warning(
+                    "Import error (not installed?) during compile time command execution: %s"
+                    % e.stderr.splitlines()[-1]
+                )
+
                 return None
 
             if Options.is_debug:
@@ -1414,7 +1441,8 @@ except Exception as e:
     ):
         if self.isValueForEvaluation(expression):
             return self.evaluateExpression(
-                full_name=full_name,
+                config_module_name=full_name,
+                module_name=full_name,
                 expression=expression,
                 config_name=config_name,
                 extra_context=extra_context,
@@ -1435,6 +1463,8 @@ except Exception as e:
                 if declarations and self.evaluateCondition(
                     full_name=full_name,
                     condition=constant_config.get("when", "True"),
+                    allow_constants=False,
+                    allow_variables=False,
                 ):
                     for constant_name, constant_value in declarations.items():
                         constants[constant_name] = self.evaluateExpressionOrConstant(
@@ -1471,6 +1501,8 @@ except Exception as e:
                 if self.evaluateCondition(
                     full_name=full_name,
                     condition=variable_config.get("when", "True"),
+                    allow_constants=True,
+                    allow_variables=False,
                 ):
                     setup_codes.extend(
                         "%s=%r" % (constant_name, constant_value)
@@ -1513,19 +1545,28 @@ except Exception as e:
         return _module_config_variables[full_name]
 
     def evaluateExpression(
-        self, full_name, expression, config_name, extra_context, single_value
+        self,
+        config_module_name,
+        module_name,
+        expression,
+        config_name,
+        extra_context,
+        single_value,
     ):
         context = _makeEvaluationContext(
-            logger=self, full_name=full_name, config_name=config_name
+            logger=self, full_name=config_module_name, config_name=config_name
         )
 
         def get_variable(variable_name):
             assert type(variable_name) is str, variable_name
 
-            result = self.getExpressionVariables(full_name=full_name)[variable_name]
+            result = self.getExpressionVariables(full_name=config_module_name)[
+                variable_name
+            ]
 
             addModuleInfluencingVariable(
-                module_name=full_name,
+                module_name=module_name,
+                config_module_name=config_module_name,
                 plugin_name=self.plugin_name,
                 variable_name=variable_name,
                 control_tags=context.used_tags,
@@ -1537,7 +1578,9 @@ except Exception as e:
         def get_constant(constant_name):
             assert type(constant_name) is str, constant_name
 
-            result = self.getExpressionConstants(full_name=full_name)[constant_name]
+            result = self.getExpressionConstants(full_name=config_module_name)[
+                constant_name
+            ]
 
             # TODO: Record the constant value in report.
 
@@ -1547,13 +1590,13 @@ except Exception as e:
         context["get_constant"] = get_constant
 
         def get_parameter(parameter_name, default):
-            result = Options.getModuleParameter(full_name, parameter_name)
+            result = Options.getModuleParameter(config_module_name, parameter_name)
 
             if result is None:
                 result = default
 
             self.addModuleInfluencingParameter(
-                module_name=full_name,
+                module_name=config_module_name,
                 parameter_name=parameter_name,
                 condition_tags_used=context.used_tags,
                 result=result,
@@ -1582,16 +1625,16 @@ except Exception as e:
         if type(result) not in (str, unicode):
             if single_value:
                 self._checkStrResult(
-                    value=result, expression=expression, full_name=full_name
+                    value=result, expression=expression, full_name=config_module_name
                 )
             else:
                 self._checkSequenceResult(
-                    value=result, expression=expression, full_name=full_name
+                    value=result, expression=expression, full_name=config_module_name
                 )
 
                 for v in result:
                     self._checkStrResult(
-                        value=v, expression=expression, full_name=full_name
+                        value=v, expression=expression, full_name=config_module_name
                     )
 
                 # Make it immutable in case it's a list.
@@ -1603,7 +1646,7 @@ except Exception as e:
         if type(value) not in (str, unicode):
             self.sysexit(
                 """\
-Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result but '%s'"""
+Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result, but '%s'"""
                 % (expression, full_name, type(value))
             )
 
@@ -1615,7 +1658,9 @@ Error, expression '%s' for module '%s' did not evaluate to 'tuple[str]' or 'list
                 % (expression, full_name)
             )
 
-    def evaluateCondition(self, full_name, condition):
+    def evaluateCondition(
+        self, full_name, condition, allow_constants=True, allow_variables=True
+    ):
         # 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.
@@ -1629,6 +1674,36 @@ Error, expression '%s' for module '%s' did not evaluate to 'tuple[str]' or 'list
             logger=self, full_name=full_name, config_name="'when' configuration"
         )
 
+        def get_variable(variable_name):
+            assert type(variable_name) is str, variable_name
+
+            result = self.getExpressionVariables(full_name=full_name)[variable_name]
+
+            addModuleInfluencingVariable(
+                module_name=full_name,
+                config_module_name=full_name,
+                plugin_name=self.plugin_name,
+                variable_name=variable_name,
+                control_tags=context.used_tags,
+                result=result,
+            )
+
+            return result
+
+        def get_constant(constant_name):
+            assert type(constant_name) is str, constant_name
+
+            result = self.getExpressionConstants(full_name=full_name)[constant_name]
+
+            # TODO: Record the constant value in report.
+
+            return result
+
+        if allow_constants:
+            context["get_constant"] = get_constant
+        if allow_variables:
+            context["get_variable"] = get_variable
+
         def get_parameter(parameter_name, default):
             result = Options.getModuleParameter(full_name, parameter_name)
 

nuitka/plugins/Plugins.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """
@@ -51,7 +51,7 @@ from .PluginBase import NuitkaPluginBase, control_tags
 # Maps plugin name to plugin instances.
 active_plugins = OrderedDict()
 plugin_name2plugin_classes = {}
-plugin_options = {}
+plugin_options = OrderedDict()
 plugin_values = {}
 user_plugins = OrderedSet()
 
@@ -414,7 +414,7 @@ class Plugins(object):
                 if not checkModuleName(v):
                     plugin.sysexit(
                         "Plugin '%s' returned an invalid module name, not %r (for module '%s')"
-                        % (plugin, v, module.getFullName())
+                        % (plugin.plugin_name, v, module.getFullName())
                     )
 
                 yield ModuleName(v)
@@ -603,7 +603,7 @@ class Plugins(object):
     def onOnefileFinished(filename):
         """Let plugins post-process the onefile executable in onefile mode"""
         for plugin in getActivePlugins():
-            plugin.onStandaloneDistributionFinished(filename)
+            plugin.onOnefileFinished(filename)
 
     @staticmethod
     def onBootstrapBinary(filename):
@@ -1680,17 +1680,37 @@ def loadPlugins():
         loadStandardPluginClasses()
 
 
-def addStandardPluginCommandLineOptions(parser):
+# TODO: Use in more places.
+def _keyPluginForSort(plugin_class):
+    return plugin_class.getCategories(), plugin_class.plugin_name
+
+
+def _keyPluginForSort2(item):
+    _plugin_name, (plugin_class, _plugin_detector) = item
+
+    return _keyPluginForSort(plugin_class)
+
+
+def addStandardPluginCommandLineOptions(parser, plugin_help_mode):
     loadPlugins()
 
     for _plugin_name, (plugin_class, _plugin_detector) in sorted(
-        plugin_name2plugin_classes.items()
+        plugin_name2plugin_classes.items(), key=_keyPluginForSort2
     ):
         if plugin_class.isAlwaysEnabled():
-            _addPluginCommandLineOptions(
-                parser=parser,
-                plugin_class=plugin_class,
-            )
+            if not plugin_help_mode or not plugin_class.hasCategory("package-support"):
+                _addPluginCommandLineOptions(
+                    parser=parser,
+                    plugin_class=plugin_class,
+                    plugin_help_mode=plugin_help_mode,
+                )
+        else:
+            if plugin_help_mode:
+                _addPluginCommandLineOptions(
+                    parser=parser,
+                    plugin_class=plugin_class,
+                    plugin_help_mode=plugin_help_mode,
+                )
 
 
 def activatePlugins():
@@ -1772,11 +1792,27 @@ def activatePlugins():
             _addActivePlugin(plugin_detector, args=False)
 
 
-def _addPluginCommandLineOptions(parser, plugin_class):
+def _addPluginCommandLineOptions(parser, plugin_class, plugin_help_mode):
     plugin_name = plugin_class.plugin_name
 
     if plugin_name not in plugin_options:
-        option_group = OptionGroup(parser, "Plugin options of '%s'" % plugin_name)
+        plugin_display_name = repr(plugin_name)
+
+        if plugin_help_mode:
+            # Ignore duplicate per design givers.
+            if plugin_name in ("pyside2", "pyqt6", "pyqt5"):
+                return
+
+            if plugin_name == "pyside6":
+                plugin_display_name = (
+                    "'pyside6' (same for 'pyside2', 'pyqt6', 'pyqt5' plugins)"
+                )
+
+        option_group = OptionGroup(
+            parser,
+            "Plugin options of %s (categories: %s)"
+            % (plugin_display_name, ", ".join(plugin_class.getCategories())),
+        )
         try:
             plugin_class.addPluginCommandLineOptions(option_group)
         except OptionConflictError as e:
@@ -1799,7 +1835,7 @@ def _addPluginCommandLineOptions(parser, plugin_class):
             plugin_options[plugin_name] = ()
 
 
-def addPluginCommandLineOptions(parser, plugin_names):
+def addPluginCommandLineOptions(parser, plugin_names, plugin_help_mode):
     """Add option group for the plugin to the parser.
 
     Notes:
@@ -1813,12 +1849,19 @@ def addPluginCommandLineOptions(parser, plugin_names):
     """
     for plugin_name in plugin_names:
         plugin_class = getPluginClass(plugin_name)
-        _addPluginCommandLineOptions(parser=parser, plugin_class=plugin_class)
+        _addPluginCommandLineOptions(
+            parser=parser, plugin_class=plugin_class, plugin_help_mode=plugin_help_mode
+        )
 
 
 def addUserPluginCommandLineOptions(parser, filename):
     plugin_class = loadUserPlugin(filename)
-    _addPluginCommandLineOptions(parser=parser, plugin_class=plugin_class)
+    _addPluginCommandLineOptions(
+        parser=parser,
+        plugin_class=plugin_class,
+        # List those user plugins always.
+        plugin_help_mode=True,
+    )
 
     user_plugins.add(plugin_class)
 

nuitka/plugins/YamlPluginBase.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """

nuitka/plugins/__init__.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Dummy file to make this directory a package. """

nuitka/plugins/standard/AntiBloatPlugin.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Standard plug-in to avoid bloat at compile time.
@@ -31,6 +31,7 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
     plugin_desc = (
         "Patch stupid imports out of widely used library modules source codes."
     )
+    plugin_category = "core"
 
     @staticmethod
     def isAlwaysEnabled():
@@ -396,42 +397,69 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
 
         return dict(self.context_codes[context_code])
 
-    def _onModuleSourceCode(self, module_name, anti_bloat_config, source_code):
-        # Complex dealing with many cases, pylint: disable=too-many-branches
+    def _onModuleSourceCodeReplacement(
+        self,
+        config_module_name,
+        module_name,
+        source_code,
+        config_name,
+        extra_context,
+        replace_code,
+        replace_src,
+    ):
+        if replace_code:
+            replace_dst = self.evaluateExpression(
+                config_module_name=config_module_name,
+                module_name=module_name,
+                expression=replace_code,
+                config_name="module '%s' config '%s'"
+                % (config_module_name, config_name),
+                extra_context=extra_context,
+                single_value=True,
+            )
+        else:
+            replace_dst = ""
+
+        return source_code, source_code.replace(replace_src, replace_dst)
 
+    def _onModuleSourceCode(
+        self,
+        config_module_name,
+        module_name,
+        config_prefix,
+        anti_bloat_config,
+        source_code,
+    ):
+        # Complex dealing with many cases, pylint: disable=too-many-branches,too-many-locals
         description = anti_bloat_config.get("description", "description not given")
 
         # To allow detection if it did anything.
         change_count = 0
 
         for replace_src, replace_code in (
-            anti_bloat_config.get("replacements") or {}
+            anti_bloat_config.get(config_prefix + "replacements") or {}
         ).items():
             # Avoid the eval, if the replace doesn't hit.
             if replace_src not in source_code:
                 continue
 
-            if replace_code:
-                replace_dst = self.evaluateExpression(
-                    full_name=module_name,
-                    expression=replace_code,
-                    config_name="module '%s' config 'replacements'" % module_name,
-                    extra_context=self._getContextCode(
-                        module_name=module_name, anti_bloat_config=anti_bloat_config
-                    ),
-                    single_value=True,
-                )
-            else:
-                replace_dst = ""
-
-            old = source_code
-            source_code = source_code.replace(replace_src, replace_dst)
+            old, source_code = self._onModuleSourceCodeReplacement(
+                config_module_name=config_module_name,
+                module_name=module_name,
+                source_code=source_code,
+                config_name=config_prefix + "replacements",
+                extra_context=self._getContextCode(
+                    module_name=module_name, anti_bloat_config=anti_bloat_config
+                ),
+                replace_src=replace_src,
+                replace_code=replace_code,
+            )
 
             if old != source_code:
                 change_count += 1
 
         for replace_src, replace_dst in (
-            anti_bloat_config.get("replacements_plain") or {}
+            anti_bloat_config.get(config_prefix + "replacements_plain") or {}
         ).items():
             old = source_code
             source_code = source_code.replace(replace_src, replace_dst)
@@ -440,7 +468,7 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
                 change_count += 1
 
         for replace_src, replace_dst in (
-            anti_bloat_config.get("replacements_re") or {}
+            anti_bloat_config.get(config_prefix + "replacements_re") or {}
         ).items():
             old = source_code
             source_code = re.sub(replace_src, replace_dst, source_code, re.S)
@@ -450,31 +478,49 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
             elif isExperimental("display-anti-bloat-mismatches"):
                 self.info("No match in %s no match %r" % (module_name, replace_src))
 
-        append_code = anti_bloat_config.get("append_result", "")
-        if type(append_code) in (tuple, list):
-            append_code = "\n".join(append_code)
+        # These have no global variants.
+        if config_prefix == "":
+            append_code = anti_bloat_config.get("append_result", "")
+            if type(append_code) in (tuple, list):
+                append_code = "\n".join(append_code)
 
-        if append_code:
-            append_result = self.evaluateExpression(
-                full_name=module_name,
-                expression=append_code,
-                config_name="module '%s' config 'append_code'" % module_name,
-                extra_context=self._getContextCode(
-                    module_name=module_name, anti_bloat_config=anti_bloat_config
-                ),
-                single_value=True,
-            )
+            if append_code:
+                append_result = self.evaluateExpression(
+                    config_module_name=module_name,
+                    module_name=module_name,
+                    expression=append_code,
+                    config_name="module '%s' config 'append_code'" % module_name,
+                    extra_context=self._getContextCode(
+                        module_name=module_name, anti_bloat_config=anti_bloat_config
+                    ),
+                    single_value=True,
+                )
 
-            source_code += "\n" + append_result
-            change_count += 1
+                source_code += "\n" + append_result
+                change_count += 1
+
+            append_plain = anti_bloat_config.get("append_plain", "")
+            if type(append_plain) in (tuple, list):
+                append_plain = "\n".join(append_plain)
 
-        append_plain = anti_bloat_config.get("append_plain", "")
-        if type(append_plain) in (tuple, list):
-            append_plain = "\n".join(append_plain)
+            if append_plain:
+                source_code += "\n" + append_plain
+                change_count += 1
 
-        if append_plain:
-            source_code += "\n" + append_plain
-            change_count += 1
+            module_code = anti_bloat_config.get("module_code", None)
+
+            if module_code is not None:
+                # Cannot be mixed.
+                assert not change_count
+
+                if self.show_changes:
+                    self.info(
+                        "Handling module '%s' with full replacement : %s."
+                        % (module_name.asString(), description)
+                    )
+
+                source_code = module_code
+                change_count = 1
 
         if change_count > 0 and self.show_changes:
             self.info(
@@ -482,31 +528,39 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
                 % (module_name.asString(), change_count, description)
             )
 
-        module_code = anti_bloat_config.get("module_code", None)
-
-        if module_code is not None:
-            assert not change_count
-
-            if self.show_changes:
-                self.info(
-                    "Handling module '%s' with full replacement : %s."
-                    % (module_name.asString(), description)
-                )
-
-            source_code = module_code
-
         return source_code
 
     def onModuleSourceCode(self, module_name, source_filename, 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")
+        config_module_name = module_name
+        while True:
+            for anti_bloat_config in self.config.get(
+                config_module_name, section="anti-bloat"
             ):
-                source_code = self._onModuleSourceCode(
-                    module_name=module_name,
-                    anti_bloat_config=anti_bloat_config,
-                    source_code=source_code,
-                )
+                if self.evaluateCondition(
+                    full_name=config_module_name,
+                    condition=anti_bloat_config.get("when", "True"),
+                ):
+                    if config_module_name == module_name:
+                        source_code = self._onModuleSourceCode(
+                            config_module_name=config_module_name,
+                            module_name=module_name,
+                            anti_bloat_config=anti_bloat_config,
+                            config_prefix="",
+                            source_code=source_code,
+                        )
+
+                    source_code = self._onModuleSourceCode(
+                        config_module_name=config_module_name,
+                        module_name=module_name,
+                        anti_bloat_config=anti_bloat_config,
+                        config_prefix="global_",
+                        source_code=source_code,
+                    )
+
+            config_module_name = config_module_name.getPackageName()
+
+            if not config_module_name:
+                break
 
         return source_code
 
@@ -525,7 +579,8 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
             return False
 
         replacement = self.evaluateExpression(
-            full_name=module_name,
+            config_module_name=module_name,
+            module_name=module_name,
             expression=replace_code,
             config_name="module '%s' config 'change_function' of '%s'"
             % (module_name, function_name),
@@ -593,7 +648,8 @@ class %(class_name)s:
             return False
 
         replacement = self.evaluateExpression(
-            full_name=module_name,
+            config_module_name=module_name,
+            module_name=module_name,
             expression=replace_code,
             config_name="module '%s' config 'change_class' of '%s'"
             % (module_name, class_name),
@@ -708,6 +764,22 @@ class %(class_name)s:
         ):
             self.no_follows[no_follow_pattern] = (config_of_module_name, description)
 
+    def _needsWarning(self, key):
+        if key in self.warnings_given:
+            return False
+
+        (
+            module_name,
+            using_module_name,
+            line_number,
+        ) = key
+
+        for parent_package in module_name.getParentPackageNames():
+            if (parent_package, using_module_name, line_number) in self.warnings_given:
+                return False
+
+        return True
+
     def onModuleRecursion(
         self,
         module_name,
@@ -775,7 +847,7 @@ class %(class_name)s:
                         source_ref.getLineNumber(),
                     )
 
-                    if key not in self.warnings_given:
+                    if self._needsWarning(key):
                         if handled_module_name == intended_module_name:
                             handled_module_name_desc = "'%s'" % handled_module_name
                         else: