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

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
 
 

nuitka/plugins/standard/PySidePyQtPlugin.py

@@ -1433,7 +1433,7 @@ class NuitkaPluginNoQt(NuitkaPluginBase):
     """This is a plugins for suppression of all Qt binding plugins."""
 
     plugin_name = "no-qt"
-    plugin_desc = "Disable all Qt bindings for standalone mode."
+    plugin_desc = "Disable inclusion of all Qt bindings."
 
     warned_about = set()
 
@@ -1442,22 +1442,21 @@ class NuitkaPluginNoQt(NuitkaPluginBase):
     ):
         top_package_name = module_name.getTopLevelPackageName()
 
-        if isStandaloneMode():
-            if top_package_name in getQtBindingNames():
-                if top_package_name not in self.warned_about:
-                    self.info(
-                        """\
+        if top_package_name in getQtBindingNames():
+            if isStandaloneMode() and top_package_name not in self.warned_about:
+                self.info(
+                    """\
 Unwanted import of '%(unwanted)s' that is forbidden encountered, preventing \
 its use. As a result an "ImportError" might be given at run time. Uninstall \
 it for full compatible behavior with the uncompiled code to debug it."""
-                        % {
-                            "unwanted": top_package_name,
-                        }
-                    )
+                    % {
+                        "unwanted": top_package_name,
+                    }
+                )
 
-                    self.warned_about.add(top_package_name)
+                self.warned_about.add(top_package_name)
 
-                return (False, "Not included due to all Qt bindings disallowed.")
+            return (False, "Not included due to all Qt bindings disallowed.")
 
     def getEvaluationConditionControlTags(self):
         return {"use_noqt": True}

nuitka/plugins/standard/SpacyPlugin.py

@@ -0,0 +1,136 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Plugin for spacy.
+
+spell-checker: ignore spacy
+"""
+
+from nuitka.code_generation.ConstantCodes import addDistributionMetadataValue
+from nuitka.containers.OrderedSets import OrderedSet
+from nuitka.Options import isStandaloneMode
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.utils.Distributions import getEntryPointGroup
+from nuitka.utils.ModuleNames import ModuleName
+
+
+class NuitkaPluginSpacy(NuitkaPluginBase):
+    """This class represents the main logic of the plugin."""
+
+    plugin_name = "spacy"
+    plugin_desc = "Required by 'spacy' package."
+
+    def __init__(self, include_language_models):
+        self.include_language_models = tuple(
+            ModuleName(include_language_model)
+            for include_language_model in include_language_models
+        )
+        self.available_language_models = None
+
+        self.used_language_model_names = None
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    @staticmethod
+    def isRelevant():
+        return isStandaloneMode()
+
+    @classmethod
+    def addPluginCommandLineOptions(cls, group):
+        group.add_option(
+            "--spacy-language-model",
+            action="append",
+            dest="include_language_models",
+            default=[],
+            help="""\
+Spacy language models to use. Can be specified multiple times. Use 'all' to
+include all downloaded models.""",
+        )
+
+    def _getInstalledSpaceLanguageModels(self):
+        if self.available_language_models is None:
+            self.available_language_models = tuple(
+                entry_point.module_name
+                for entry_point in sorted(getEntryPointGroup("spacy_models"))
+            )
+
+        return self.available_language_models
+
+    def getImplicitImports(self, module):
+        if module.getFullName() == "spacy":
+            self.used_language_model_names = OrderedSet()
+
+            if "all" in self.include_language_models:
+                self.used_language_model_names.update(
+                    self._getInstalledSpaceLanguageModels()
+                )
+            else:
+                for include_language_model_name in self.include_language_models:
+                    if (
+                        include_language_model_name
+                        in self._getInstalledSpaceLanguageModels()
+                    ):
+                        self.used_language_model_names.add(include_language_model_name)
+                    else:
+                        self.sysexit(
+                            """\
+Error, requested to include language model '%s' that was \
+not found, the list of installed ones is '%s'."""
+                            % (
+                                include_language_model_name,
+                                ",".join(self._getInstalledSpaceLanguageModels()),
+                            )
+                        )
+
+            if not self.used_language_model_names:
+                self.warning(
+                    """\
+No language models included. Use the option '--spacy-language-model=language_model_name' to \
+include one. Use 'all' to include all downloaded ones, or select from the list of installed \
+ones: %s"""
+                    % ",".join(self._getInstalledSpaceLanguageModels())
+                )
+
+            for used_language_model_name in self.used_language_model_names:
+                yield used_language_model_name
+
+    def considerDataFiles(self, module):
+        if module.getFullName() == "spacy":
+            # Do not use it accidentally for anything else
+            del module
+
+            for used_language_model_name in self.used_language_model_names:
+                # Meta data is required for language models to be accepted.
+                addDistributionMetadataValue(
+                    distribution_name=used_language_model_name.asString(),
+                    distribution=None,
+                    reason="for 'spacy' to locate the language model",
+                )
+
+                module_folder = self.locateModule(used_language_model_name)
+
+                yield self.makeIncludedDataDirectory(
+                    source_path=module_folder,
+                    dest_path=used_language_model_name.asPath(),
+                    reason="model data for %r" % (used_language_model_name.asString()),
+                    tags="spacy",
+                    raw=True,
+                )
+
+
+#     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.