Nuitka-winsvc 2.3.11__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/plugins/Plugins.py

@@ -106,7 +106,7 @@ def _addActivePlugin(plugin_class, args, force=False):
     else:
         plugin_args = {}
 
-    with withPluginProblemReporting(plugin_class, "Plugin initialization failed", ()):
+    with withPluginProblemReporting(plugin_class, "plugin initialization", ()):
         plugin_instance = plugin_class(**plugin_args)
 
     assert isinstance(plugin_instance, NuitkaPluginBase), plugin_instance
@@ -824,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:
@@ -1394,6 +1395,93 @@ class Plugins(object):
             for value in plugin.getExtraConstantDefaultPopulation():
                 yield value
 
+    @classmethod
+    def _decideWithoutDisagreement(
+        cls,
+        method_name,
+        call_per_plugin,
+        legal_values,
+        abstain_values,
+        get_default_value,
+    ):
+        result = abstain_values[0]
+        plugin_name = None
+
+        for plugin in getActivePlugins():
+            value = call_per_plugin(plugin)
+
+            if value not in legal_values:
+                plugin.sysexit(
+                    "Error, can only return '%s' from '%s' not %r"
+                    % (legal_values, method_name, value)
+                )
+
+            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()
+
+        return result
+
+    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

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/standard/AntiBloatPlugin.py

@@ -14,7 +14,8 @@ import re
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.Errors import NuitkaForbiddenImportEncounter
 from nuitka.ModuleRegistry import getModuleByName
-from nuitka.plugins.PluginBase import NuitkaYamlPluginBase
+from nuitka.Options import isExperimental
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
 from nuitka.utils.ModuleNames import ModuleName
 
 # spell-checker: ignore dask,numba,statsmodels,matplotlib,sqlalchemy,ipykernel
@@ -40,6 +41,7 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
         noinclude_setuptools_mode,
         noinclude_pytest_mode,
         noinclude_unittest_mode,
+        noinclude_pydoc_mode,
         noinclude_ipython_mode,
         noinclude_dask_mode,
         noinclude_numba_mode,
@@ -47,7 +49,8 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
         custom_choices,
         show_changes,
     ):
-        # Many details, due to many repetitive arguments, pylint: disable=too-many-branches,too-many-statements
+        # Many details, due to many repetitive arguments,
+        # pylint: disable=too-many-branches,too-many-locals,too-many-statements
 
         NuitkaYamlPluginBase.__init__(self)
 
@@ -60,6 +63,8 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
             noinclude_pytest_mode = noinclude_default_mode
         if noinclude_unittest_mode is None:
             noinclude_unittest_mode = noinclude_default_mode
+        if noinclude_pydoc_mode is None:
+            noinclude_pydoc_mode = noinclude_default_mode
         if noinclude_ipython_mode is None:
             noinclude_ipython_mode = noinclude_default_mode
         if noinclude_dask_mode is None:
@@ -102,6 +107,10 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
                 noinclude_setuptools_mode,
                 "setuptools",
             )
+            self.handled_modules["numpy.distutils"] = (
+                noinclude_setuptools_mode,
+                "setuptools",
+            )
         else:
             self.control_tags["use_setuptools"] = True
 
@@ -173,6 +182,11 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
         else:
             self.control_tags["use_dask"] = True
 
+        if noinclude_pydoc_mode != "allow":
+            self.handled_modules["pydoc"] = noinclude_pydoc_mode, "pydoc"
+        else:
+            self.control_tags["use_pydoc"] = True
+
         if noinclude_numba_mode != "allow":
             self.handled_modules["numba"] = noinclude_numba_mode, "numba"
             self.handled_modules["sparse"] = noinclude_numba_mode, "numba"
@@ -289,6 +303,17 @@ What to do if a unittest import is encountered. This package can be big with
 dependencies, and should definitely be avoided.""",
         )
 
+        group.add_option(
+            "--noinclude-pydoc-mode",
+            action="store",
+            dest="noinclude_pydoc_mode",
+            choices=_mode_choices,
+            default=None,
+            help="""\
+What to do if a pydoc import is encountered. This package use is mark of useless
+code for deployments and should be avoided.""",
+        )
+
         group.add_option(
             "--noinclude-IPython-mode",
             action="store",
@@ -375,8 +400,8 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
         # To allow detection if it did anything.
         change_count = 0
 
-        for replace_src, replace_code in anti_bloat_config.get(
-            "replacements", {}
+        for replace_src, replace_code in (
+            anti_bloat_config.get("replacements") or {}
         ).items():
             # Avoid the eval, if the replace doesn't hit.
             if replace_src not in source_code:
@@ -401,8 +426,8 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
             if old != source_code:
                 change_count += 1
 
-        for replace_src, replace_dst in anti_bloat_config.get(
-            "replacements_plain", {}
+        for replace_src, replace_dst in (
+            anti_bloat_config.get("replacements_plain") or {}
         ).items():
             old = source_code
             source_code = source_code.replace(replace_src, replace_dst)
@@ -410,14 +435,16 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
             if old != source_code:
                 change_count += 1
 
-        for replace_src, replace_dst in anti_bloat_config.get(
-            "replacements_re", {}
+        for replace_src, replace_dst in (
+            anti_bloat_config.get("replacements_re") or {}
         ).items():
             old = source_code
-            source_code = re.sub(replace_src, replace_dst, source_code)
+            source_code = re.sub(replace_src, replace_dst, source_code, re.S)
 
             if old != source_code:
                 change_count += 1
+            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):
@@ -604,30 +631,62 @@ class %(class_name)s:
         return result
 
     def _getModuleBloatModeOverrides(self, using_module_name, intended_module_name):
-        while 1:
-            config = self.config.get(using_module_name, section="anti-bloat")
+        # Finding a matching configuration aborts the search, not finding one
+        # means default behavior should apply.
+        for _config_module_name, bloat_mode_overrides in self.getYamlConfigItem(
+            module_name=using_module_name,
+            section="anti-bloat",
+            item_name="bloat-mode-overrides",
+            default={},
+            decide_relevant=(lambda config_item: intended_module_name in config_item),
+            recursive=True,
+        ):
+            return bloat_mode_overrides[intended_module_name]
 
-            if config:
-                for anti_bloat_config in config:
-                    bloat_mode_overrides = anti_bloat_config.get(
-                        "bloat-mode-overrides", ()
-                    )
+        return None
 
-                    if not bloat_mode_overrides:
-                        continue
+    def decideAnnotations(self, module_name):
+        # Finding a matching configuration aborts the search, not finding one
+        # means default behavior should apply.
+        for _config_module_name, annotations_config_value in self.getYamlConfigItem(
+            module_name=module_name,
+            section="anti-bloat",
+            item_name="annotations",
+            default=None,
+            decide_relevant=(lambda config_item: config_item in ("yes", "no")),
+            recursive=True,
+        ):
+            return annotations_config_value == "yes"
 
-                    if self.evaluateCondition(
-                        full_name=intended_module_name,
-                        condition=anti_bloat_config.get("when", "True"),
-                    ):
-                        for module_name, mode in bloat_mode_overrides.items():
-                            if module_name == intended_module_name:
-                                return mode
+        return None
+
+    def decideDocStrings(self, module_name):
+        # Finding a matching configuration aborts the search, not finding one
+        # means default behavior should apply.
+        for _config_module_name, doc_strings_config_value in self.getYamlConfigItem(
+            module_name=module_name,
+            section="anti-bloat",
+            item_name="doc_strings",
+            default=None,
+            decide_relevant=(lambda config_item: config_item in ("yes", "no")),
+            recursive=True,
+        ):
+            return doc_strings_config_value == "yes"
 
-            using_module_name = using_module_name.getPackageName()
+        return None
 
-            if not using_module_name:
-                break
+    def decideAsserts(self, module_name):
+        # Finding a matching configuration aborts the search, not finding one
+        # means default behavior should apply.
+        for _config_module_name, asserts_config_value in self.getYamlConfigItem(
+            module_name=module_name,
+            section="anti-bloat",
+            item_name="asserts",
+            default=None,
+            decide_relevant=(lambda config_item: config_item in ("yes", "no")),
+            recursive=True,
+        ):
+            return asserts_config_value == "yes"
 
         return None
 

nuitka/plugins/standard/DataFilesPlugin.py

@@ -11,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 NuitkaYamlPluginBase
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
 from nuitka.PythonFlavors import isDebianPackagePython
 from nuitka.utils.Distributions import getDistribution
 from nuitka.utils.FileOperations import (
@@ -45,7 +45,11 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
 
         # 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()
@@ -97,7 +101,7 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
 
             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 +134,7 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
                 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",
@@ -150,7 +154,7 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
                 if os.path.isdir(source_path):
                     yield self.makeIncludedDataDirectory(
                         source_path=source_path,
-                        dest_path=os.path.join(target_dir, raw_dir),
+                        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",
@@ -187,7 +191,12 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
             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()

nuitka/plugins/standard/DelvewheelPlugin.py

@@ -8,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
@@ -42,7 +42,7 @@ 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.
@@ -75,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,
         }
 
@@ -111,6 +111,10 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
                 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()
 

nuitka/plugins/standard/DllFilesPlugin.py

@@ -13,7 +13,7 @@ import os
 import sys
 
 from nuitka.Options import isStandaloneMode
-from nuitka.plugins.PluginBase import NuitkaYamlPluginBase
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
 from nuitka.PythonVersions import python_version
 from nuitka.utils.Distributions import (
     getDistributionFromModuleName,
@@ -41,7 +41,7 @@ class NuitkaPluginDllFiles(NuitkaYamlPluginBase):
     def isRelevant():
         return isStandaloneMode()
 
-    def _handleDllConfigFromFilenames(self, dest_path, dll_config, full_name):
+    def _handleDllConfigFromFilenames(self, dll_config, full_name, dest_path):
         # A lot of details here, pylint: disable=too-many-locals
 
         # The "when" is at that level too for these.
@@ -260,7 +260,9 @@ conditions are missing, or this version of the module needs treatment added."""
                 full_name=full_name, condition=dll_config.get("when", "True")
             ):
                 for dll_entry_point in self._handleDllConfig(
-                    dll_config=dll_config, full_name=full_name, count=count
+                    dll_config=dll_config,
+                    full_name=full_name,
+                    count=count,
                 ):
                     yield dll_entry_point
                     found += 1

nuitka/plugins/standard/ImplicitImports.py

@@ -15,7 +15,7 @@ import os
 from nuitka.__past__ import iter_modules, unicode
 from nuitka.importing.Importing import locateModule
 from nuitka.importing.Recursion import decideRecursion
-from nuitka.plugins.PluginBase import NuitkaYamlPluginBase
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
 from nuitka.utils.ModuleNames import ModuleName
 from nuitka.utils.Utils import isMacOS, isWin32Windows
 
@@ -84,6 +84,31 @@ class NuitkaPluginImplicitImports(NuitkaYamlPluginBase):
 
         yield current
 
+    def _resolveImplicitImportsConfig(self, full_name, dependency):
+        if "(" in dependency:
+            value = self.evaluateExpression(
+                full_name=full_name,
+                expression=dependency,
+                config_name="depends value",
+                extra_context=None,
+                single_value=False,
+            )
+
+            if type(value) in (str, unicode):
+                value = (value,)
+
+            for v in value:
+                if "*" in v or "?" in v:
+                    for resolved in self._resolveModulePattern(v):
+                        yield resolved
+                else:
+                    yield v
+        elif "*" in dependency or "?" in dependency:
+            for resolved in self._resolveModulePattern(dependency):
+                yield resolved
+        else:
+            yield dependency
+
     def _handleImplicitImportsConfig(self, module, config):
         full_name = module.getFullName()
 
@@ -102,25 +127,11 @@ class NuitkaPluginImplicitImports(NuitkaYamlPluginBase):
                 else:
                     dependency = full_name.getSiblingNamed(dependency[1:]).asString()
 
-            if "(" in dependency:
-                value = self.evaluateExpression(
-                    full_name=full_name,
-                    expression=dependency,
-                    config_name="depends value",
-                    extra_context=None,
-                    single_value=False,
-                )
-
-                if type(value) in (str, unicode):
-                    value = (value,)
-
-                for v in value:
-                    yield v
-            elif "*" in dependency or "?" in dependency:
-                for resolved in self._resolveModulePattern(dependency):
-                    yield resolved
-            else:
-                yield dependency
+            for value in self._resolveImplicitImportsConfig(
+                full_name=full_name,
+                dependency=dependency,
+            ):
+                yield value
 
     def _getImportsByFullname(self, module, full_name):
         """Provides names of modules to imported implicitly."""
@@ -255,6 +266,9 @@ class NuitkaPluginImplicitImports(NuitkaYamlPluginBase):
             elif full_name == crypto_module_name + ".Cipher.PKCS1_v1_5":
                 yield crypto_module_name + ".Cipher._pkcs1_decode"
 
+            elif full_name == crypto_module_name + ".Cipher.PKCS1_OAEP":
+                yield crypto_module_name + ".Cipher._pkcs1_decode"
+
             elif full_name == crypto_module_name + ".Math._IntegerCustom":
                 yield crypto_module_name + ".Math._modexp"
 

nuitka/plugins/standard/MatplotlibPlugin.py

@@ -75,7 +75,9 @@ from inspect import getsource
                     ("matplotlib_version", "__version__"),
                 ),
             )
-        except NuitkaCalledProcessError:
+        except NuitkaCalledProcessError as e:
+            self.debug("Exception during detection: %r" % e)
+
             if "MPLBACKEND" not in os.environ:
                 self.sysexit(
                     """\

nuitka/plugins/standard/MultiprocessingPlugin.py

@@ -124,10 +124,10 @@ Monkey patching "multiprocessing" for compiled methods.""",
 
         # For the call stack, this may look bad or different to what CPython
         # does, but such is life. The forking module was split up into multiple
-        # modules in Python 3.4 so this is doubled. TODO: Move the version check
+        # modules in Python3 so this is doubled. TODO: Move the version check
         # into the code and let Nuitka compile time optimize it, which will also
         # make sure joblib support is there for Python2 as well.
-        if python_version >= 0x340:
+        if python_version >= 0x300:
             source_code += """
 def __nuitka_freeze_support():
     import sys

nuitka/plugins/standard/OptionsNannyPlugin.py

@@ -13,7 +13,7 @@ from nuitka.Options import (
     isStandaloneMode,
     shallCreateAppBundle,
 )
-from nuitka.plugins.PluginBase import NuitkaYamlPluginBase
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
 from nuitka.utils.Utils import isMacOS