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

nuitka/plugins/Plugins.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
+
+
 """
 
 Plugins: Welcome to Nuitka! This is your shortest way to become part of it.
@@ -39,6 +25,7 @@ from nuitka.__past__ import basestring, iter_modules
 from nuitka.build.DataComposerInterface import deriveModuleConstantsBlobName
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.containers.OrderedSets import OrderedSet
+from nuitka.Errors import NuitkaSyntaxError
 from nuitka.freezer.IncludedDataFiles import IncludedDataFile
 from nuitka.freezer.IncludedEntryPoints import IncludedEntryPoint
 from nuitka.ModuleRegistry import addUsedModule
@@ -119,10 +106,8 @@ def _addActivePlugin(plugin_class, args, force=False):
     else:
         plugin_args = {}
 
-    try:
+    with withPluginProblemReporting(plugin_class, "plugin initialization", ()):
         plugin_instance = plugin_class(**plugin_args)
-    except TypeError as e:
-        plugin_class.sysexit("Problem initializing plugin: %s" % e)
 
     assert isinstance(plugin_instance, NuitkaPluginBase), plugin_instance
 
@@ -440,7 +425,7 @@ class Plugins(object):
             except Exception:
                 plugin.warning(
                     "Problem locating '%s' for implicit imports of '%s'."
-                    % (module.getFullName(), full_name)
+                    % (full_name, module.getFullName())
                 )
                 raise
 
@@ -465,8 +450,8 @@ class Plugins(object):
 
     @staticmethod
     def _reportImplicitImports(plugin, module, implicit_imports):
-        from nuitka.importing import Recursion
         from nuitka.importing.Importing import getModuleNameAndKindFromFilename
+        from nuitka.importing.Recursion import decideRecursion, recurseTo
 
         for full_name, module_filename in implicit_imports:
             # TODO: The module_kind should be forwarded from previous in the class using locateModule code.
@@ -475,7 +460,7 @@ class Plugins(object):
             )
 
             # This will get back to all other plugins allowing them to inhibit it though.
-            decision, decision_reason = Recursion.decideRecursion(
+            decision, decision_reason = decideRecursion(
                 using_module_name=module.getFullName(),
                 module_filename=module_filename,
                 module_name=full_name,
@@ -483,7 +468,7 @@ class Plugins(object):
             )
 
             if decision:
-                imported_module = Recursion.recurseTo(
+                imported_module = recurseTo(
                     module_name=full_name,
                     module_filename=module_filename,
                     module_kind=module_kind,
@@ -827,7 +812,6 @@ class Plugins(object):
     def onModuleDiscovered(cls, module):
         # We offer plugins many ways to provide extra stuff
         # pylint: disable=too-many-locals,too-many-statements
-
         full_name = module.getFullName()
 
         def _untangleLoadDescription(description):
@@ -840,8 +824,9 @@ class Plugins(object):
 
                 for desc in description:
                     if desc is None:
-                        pass
-                    elif len(desc) == 2:
+                        continue
+
+                    if len(desc) == 2:
                         code, reason = desc
                         flags = ()
                     else:
@@ -870,6 +855,12 @@ class Plugins(object):
         post_module_load_descriptions = []
         fake_module_descriptions = []
 
+        if module.isMainModule():
+            plugin = None
+            pre_module_load_descriptions.extend(
+                _untangleLoadDescription(_getMainModulePreloadCodes())
+            )
+
         for plugin in getActivePlugins():
             plugin.onModuleDiscovered(module)
 
@@ -972,7 +963,7 @@ class Plugins(object):
                 fake_modules[full_name].append((fake_module, plugin, reason))
 
     @staticmethod
-    def onModuleSourceCode(module_name, source_code):
+    def onModuleSourceCode(module_name, source_filename, source_code):
         assert type(module_name) is ModuleName
         assert type(source_code) is str
 
@@ -980,7 +971,11 @@ class Plugins(object):
 
         for plugin in getActivePlugins():
             with withPluginModuleNameProblemReporting(plugin, module_name):
-                new_source_code = plugin.onModuleSourceCode(module_name, source_code)
+                new_source_code = plugin.onModuleSourceCode(
+                    module_name=module_name,
+                    source_filename=source_filename,
+                    source_code=source_code,
+                )
                 if new_source_code is not None and new_source_code != source_code:
                     source_code = new_source_code
                     contributing_plugins.add(plugin)
@@ -1039,6 +1034,52 @@ class Plugins(object):
 
         return result, deciding_plugins
 
+    module_usage_looked_ahead_cache = set()
+
+    @classmethod
+    def onModuleUsageLookAhead(cls, module_name, module_filename, module_kind):
+        if module_name in cls.module_usage_looked_ahead_cache:
+            return
+
+        cls.module_usage_looked_ahead_cache.add(module_name)
+
+        # Lazy load the source code if a plugin wants it, the pre_load caches
+        # the result for later usage.
+        def getModuleSourceCode():
+            if module_kind != "py":
+                return None
+
+            from nuitka.tree.SourceHandling import readSourceCodeFromFilename
+
+            if os.path.isdir(module_filename):
+                source_filename = os.path.join(module_filename, "__init__.py")
+            else:
+                source_filename = module_filename
+
+            if not os.path.isfile(source_filename):
+                return None
+
+            try:
+                return readSourceCodeFromFilename(
+                    module_name=module_name,
+                    source_filename=source_filename,
+                    pre_load=True,
+                )
+            except SyntaxError as e:
+                # Look ahead just not possible.
+                raise NuitkaSyntaxError(e)
+
+        try:
+            for plugin in getActivePlugins():
+                plugin.onModuleUsageLookAhead(
+                    module_name=module_name,
+                    module_filename=module_filename,
+                    module_kind=module_kind,
+                    get_module_source=getModuleSourceCode,
+                )
+        except NuitkaSyntaxError:
+            pass
+
     @staticmethod
     def onModuleRecursion(
         module_name, module_filename, module_kind, using_module_name, source_ref, reason
@@ -1217,7 +1258,7 @@ class Plugins(object):
                 # We order per plugin, but from the plugins, lets just take a dict
                 # and achieve determinism by ordering the files by name.
                 for key, value in sorted(value.items()):
-                    if (for_onefile and not "onefile_" in key) or (
+                    if (for_onefile and "onefile_" not in key) or (
                         not for_onefile and "onefile_" in key
                     ):
                         continue
@@ -1303,9 +1344,9 @@ class Plugins(object):
 
     @classmethod
     def encodeDataComposerName(cls, name):
+        # Encoding needs to match generated source code output.
         if str is not bytes:
-            # Encoding needs to match generated source code output.
-            name = name.encode("latin1")
+            name = name.encode("utf8")
 
         for plugin in getActivePlugins():
             r = plugin.encodeDataComposerName(name)
@@ -1329,6 +1370,19 @@ class Plugins(object):
                 body=body,
             )
 
+    @classmethod
+    def onClassBodyParsing(cls, provider, class_name, node):
+        module_name = provider.getParentModule().getFullName()
+
+        for plugin in getActivePlugins():
+            # TODO: Could record what classes got modified by what plugin
+            # and in what way checking the return value
+            plugin.onClassBodyParsing(
+                module_name=module_name,
+                class_name=class_name,
+                node=node,
+            )
+
     @classmethod
     def getCacheContributionValues(cls, module_name):
         for plugin in getActivePlugins():
@@ -1336,42 +1390,133 @@ class Plugins(object):
                 yield value
 
     @classmethod
-    def decideAllowOutsideDependencies(cls, module_name):
-        if not Options.isExperimental("no-outside-dependencies"):
-            return None
+    def getExtraConstantDefaultPopulation(cls):
+        for plugin in getActivePlugins():
+            for value in plugin.getExtraConstantDefaultPopulation():
+                yield value
 
-        result = None
+    @classmethod
+    def _decideWithoutDisagreement(
+        cls,
+        method_name,
+        call_per_plugin,
+        legal_values,
+        abstain_values,
+        get_default_value,
+    ):
+        result = abstain_values[0]
         plugin_name = None
 
-        if module_name is not None:
-            for plugin in getActivePlugins():
-                value = plugin.decideAllowOutsideDependencies(module_name)
+        for plugin in getActivePlugins():
+            value = call_per_plugin(plugin)
 
-                if value is True:
-                    if result is False:
-                        plugin.sysexit(
-                            "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
-                            % plugin_name
-                        )
+            if value not in legal_values:
+                plugin.sysexit(
+                    "Error, can only return '%s' from '%s' not %r"
+                    % (legal_values, method_name, value)
+                )
 
-                    result = True
+            if value in abstain_values:
+                continue
+
+            if value != result:
+                if result in abstain_values:
+                    result = value
                     plugin_name = plugin.plugin_name
+                else:
+                    plugin.sysexit(
+                        "Error, conflicting value '%s' with plug-in '%s' value '%s'."
+                        % (value, plugin_name, result)
+                    )
+        if result in abstain_values:
+            result = get_default_value()
 
-                elif value is False:
-                    if result is False:
-                        plugin.sysexit(
-                            "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
-                            % plugin_name
-                        )
+        return result
 
-                    result = False
-                    plugin_name = plugin.plugin_name
-                elif value is not None:
+    decide_annotations_cache = {}
+
+    @classmethod
+    def decideAnnotations(cls, module_name):
+        # For Python2 it's not a thing.
+        if str is bytes:
+            return False
+
+        if module_name not in cls.decide_annotations_cache:
+            cls.decide_annotations_cache[module_name] = cls._decideWithoutDisagreement(
+                call_per_plugin=lambda plugin: plugin.decideAnnotations(module_name),
+                legal_values=(None, True, False),
+                abstain_values=(None,),
+                method_name="decideAnnotations",
+                get_default_value=lambda: not Options.hasPythonFlagNoAnnotations(),
+            )
+
+        return cls.decide_annotations_cache[module_name]
+
+    decide_doc_strings_cache = {}
+
+    @classmethod
+    def decideDocStrings(cls, module_name):
+        if module_name not in cls.decide_doc_strings_cache:
+            cls.decide_doc_strings_cache[module_name] = cls._decideWithoutDisagreement(
+                call_per_plugin=lambda plugin: plugin.decideDocStrings(module_name),
+                legal_values=(None, True, False),
+                abstain_values=(None,),
+                method_name="decideDocStrings",
+                get_default_value=lambda: not Options.hasPythonFlagNoDocStrings(),
+            )
+
+        return cls.decide_doc_strings_cache[module_name]
+
+    decide_assertions_cache = {}
+
+    @classmethod
+    def decideAssertions(cls, module_name):
+        if module_name not in cls.decide_assertions_cache:
+            cls.decide_assertions_cache[module_name] = cls._decideWithoutDisagreement(
+                call_per_plugin=lambda plugin: plugin.decideAssertions(module_name),
+                legal_values=(None, True, False),
+                abstain_values=(None,),
+                method_name="decideAssertions",
+                get_default_value=lambda: not Options.hasPythonFlagNoAsserts(),
+            )
+
+        return cls.decide_assertions_cache[module_name]
+
+    @classmethod
+    def decideAllowOutsideDependencies(cls, module_name):
+        result = None
+        plugin_name = None
+
+        assert module_name is not None
+
+        for plugin in getActivePlugins():
+            value = plugin.decideAllowOutsideDependencies(module_name)
+
+            if value is True:
+                if result is False:
                     plugin.sysexit(
-                        "Error, can only return True, False, None from 'decideAllowOutsideDependencies' not %r"
-                        % value
+                        "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
+                        % plugin_name
                     )
 
+                result = True
+                plugin_name = plugin.plugin_name
+
+            elif value is False:
+                if result is False:
+                    plugin.sysexit(
+                        "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
+                        % plugin_name
+                    )
+
+                result = False
+                plugin_name = plugin.plugin_name
+            elif value is not None:
+                plugin.sysexit(
+                    "Error, can only return True, False, None from 'decideAllowOutsideDependencies' not %r"
+                    % value
+                )
+
         return result
 
     @classmethod
@@ -1381,7 +1526,7 @@ class Plugins(object):
         # Not a DLL filename, then it cannot be true, but it's kind of strange
         # to get asked.
         if dll_basename is None:
-            return False
+            return None, None
 
         result = None
         plugin_name = None
@@ -1735,3 +1880,41 @@ def replaceTriggerModule(old, new):
 def isTriggerModule(module):
     """Decide of a module is a trigger module."""
     return module in pre_modules.values() or module in post_modules.values()
+
+
+# TODO: Make this a dedicated thing generally.
+def _getMainModulePreloadCodes():
+    forced_runtime_env_variable_values = tuple(
+        Options.getForcedRuntimeEnvironmentVariableValues()
+    )
+    if not forced_runtime_env_variable_values:
+        return
+
+    result = ["import os"]
+
+    for (
+        forced_runtime_env_variable_name,
+        forced_runtime_env_variable_value,
+    ) in forced_runtime_env_variable_values:
+        result.append(
+            "os.environ['%s'] = '%s'"
+            % (forced_runtime_env_variable_name, forced_runtime_env_variable_value)
+        )
+
+    yield ("\n".join(result), "forcing environment variable(s)")
+
+
+#     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/YamlPluginBase.py

@@ -0,0 +1,121 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+"""
+Plugins: Welcome to Nuitka! This is your shortest way to become part of it.
+
+This is to provide the base class for all Yaml plugins. These deal with the
+configuration files of Nuitka.
+"""
+
+from nuitka.utils.Yaml import getYamlPackageConfiguration
+
+from .PluginBase import NuitkaPluginBase
+
+
+class NuitkaYamlPluginBase(NuitkaPluginBase):
+    """Nuitka base class for all plugins that use yaml config"""
+
+    def __init__(self):
+        self.config = getYamlPackageConfiguration()
+
+    def getYamlConfigItem(
+        self, module_name, section, item_name, decide_relevant, default, recursive
+    ):
+        while True:
+            module_configs = self.config.get(module_name, section=section)
+
+            if module_configs is not None:
+                for module_config in module_configs:
+                    config_item = module_config.get(item_name, default)
+
+                    # Avoid condition, if the item is not relevant
+                    if decide_relevant is not None and not decide_relevant(config_item):
+                        continue
+
+                    if not self.evaluateCondition(
+                        full_name=module_name,
+                        condition=module_config.get("when", "True"),
+                    ):
+                        continue
+
+                    if recursive:
+                        yield module_name, config_item
+                    else:
+                        yield config_item
+
+            if not recursive:
+                break
+
+            module_name = module_name.getPackageName()
+            if not module_name:
+                break
+
+    def getYamlConfigItemItems(
+        self, module_name, section, item_name, decide_relevant, recursive
+    ):
+        def dict_decide_relevant(item_dict):
+            if not item_dict:
+                return False
+
+            if decide_relevant is None:
+                return True
+
+            for key, value in item_dict.items():
+                if decide_relevant(key, value):
+                    return True
+
+            return False
+
+        for item_config in self.getYamlConfigItem(
+            module_name=module_name,
+            section=section,
+            item_name=item_name,
+            decide_relevant=dict_decide_relevant,
+            default={},
+            recursive=recursive,
+        ):
+            if recursive:
+                for key, value in item_config[1].items():
+                    if decide_relevant(key, value):
+                        yield item_config[0], key, value
+            else:
+                for key, value in item_config.items():
+                    if decide_relevant(key, value):
+                        yield key, value
+
+    def getYamlConfigItemSet(
+        self, module_name, section, item_name, decide_relevant, recursive
+    ):
+        for item_config in self.getYamlConfigItem(
+            module_name=module_name,
+            section=section,
+            item_name=item_name,
+            decide_relevant=None,
+            default=(),
+            recursive=recursive,
+        ):
+            if recursive:
+                for value in item_config[1]:
+                    if decide_relevant is None or decide_relevant(value):
+                        yield item_config[0], value
+            else:
+                for value in item_config:
+                    if decide_relevant is None or decide_relevant(value):
+                        yield value
+
+
+#     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/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
-#
-""" Dummy file to make this directory a package. """