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

nuitka/plugins/PluginBase.py

@@ -172,7 +172,11 @@ def _getEvaluationContext():
             # Iterating packages
             "iterate_modules": _iterate_module_names,
             # Locating package directories
-            "_get_module_directory": _getModuleDirectory,
+            "get_module_directory": _getModuleDirectory,
+            # Checking module presence
+            "has_module": _hasModule,
+            # Getting data files contents
+            "get_data": _getPackageData,
             # Querying package properties
             "has_builtin_module": isBuiltinModuleName,
             # Architectures
@@ -326,6 +330,22 @@ def _getModuleDirectory(module_name):
     return module_filename
 
 
+def _hasModule(module_name):
+    from nuitka.importing.Importing import locateModule
+
+    _module_name, _module_filename, _module_kind, finding = locateModule(
+        module_name=ModuleName(module_name), parent_package=None, level=0
+    )
+
+    return finding != "not-found"
+
+
+def _getPackageData(package_name, resource):
+    from nuitka.utils.PackageResources import getPackageData
+
+    return getPackageData(package_name=ModuleName(package_name), resource=resource)
+
+
 def _iterate_module_names(package_name):
     package_name = ModuleName(package_name)
     package_path = _getModuleDirectory(module_name=package_name)
@@ -1251,21 +1271,25 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
             setup_codes = setup_codes.splitlines()
 
         if not setup_codes:
-            setup_codes = ["pass"]
+            setup_codes = ("pass",)
 
         cmd = r"""\
 from __future__ import print_function
 from __future__ import absolute_import
+import sys
 
 try:
 %(setup_codes)s
 except ImportError:
-    import sys
     sys.exit(38)
+try:
 %(query_codes)s
+except Exception as e:
+    sys.stderr.write("\n%%s" %% repr(e))
+    sys.exit(39)
 """ % {
             "setup_codes": "\n".join("   %s" % line for line in setup_codes),
-            "query_codes": "\n".join(query_codes),
+            "query_codes": "\n".join("   %s" % line for line in query_codes),
         }
 
         if shallShowExecutedCommands():
@@ -1283,6 +1307,16 @@ except ImportError:
             if Options.is_debug:
                 self.info(cmd, keep_format=True)
 
+            if e.returncode == 39:
+                # TODO: Recognize the ModuleNotFoundError or ImportError exceptions
+                # and output the missing module.
+                self.warning(
+                    "Exception during compile time command execution: %s"
+                    % e.stderr.splitlines()[-1]
+                )
+
+                return None
+
             raise
 
         if str is not bytes:  # We want to work with strings, that's hopefully OK.
@@ -1469,7 +1503,7 @@ except ImportError:
 
                     if info is None:
                         self.sysexit(
-                            "Error, failed to evaluate variables for %s." % full_name
+                            "Error, failed to evaluate variables for '%s'." % full_name
                         )
 
                     variables.update(info.asDict())
@@ -1541,38 +1575,46 @@ except ImportError:
                     raise
 
                 self.sysexit(
-                    "Error, failed to evaluate expression %r in this context, exception was '%s'."
+                    "Error, failed to evaluate expression %r in this context, exception was '%r'."
                     % (expression, e)
                 )
 
         if type(result) not in (str, unicode):
             if single_value:
-                self.sysexit(
-                    """\
-Error, expression '%s' for module '%s' did not evaluate to 'str' result."""
-                    % (expression, full_name)
+                self._checkStrResult(
+                    value=result, expression=expression, full_name=full_name
                 )
             else:
-                if type(result) not in (tuple, list):
-                    self.sysexit(
-                        """\
-Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result."""
-                        % (expression, full_name)
-                    )
+                self._checkSequenceResult(
+                    value=result, expression=expression, full_name=full_name
+                )
 
                 for v in result:
-                    if type(v) not in (str, unicode):
-                        self.sysexit(
-                            """\
-Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result."""
-                            % (expression, full_name)
-                        )
+                    self._checkStrResult(
+                        value=v, expression=expression, full_name=full_name
+                    )
 
                 # Make it immutable in case it's a list.
                 result = tuple(result)
 
         return result
 
+    def _checkStrResult(self, value, expression, full_name):
+        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'"""
+                % (expression, full_name, type(value))
+            )
+
+    def _checkSequenceResult(self, value, expression, full_name):
+        if type(value) not in (tuple, list):
+            self.sysexit(
+                """\
+Error, expression '%s' for module '%s' did not evaluate to 'tuple[str]' or 'list[str]' result."""
+                % (expression, full_name)
+            )
+
     def evaluateCondition(self, full_name, condition):
         # Note: Caching makes no sense yet, this should all be very fast and
         # cache themselves. TODO: Allow plugins to contribute their own control

nuitka/plugins/Plugins.py

@@ -33,6 +33,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.Tracing import plugins_logger, printLine
 from nuitka.utils.FileOperations import (
     getDllBasename,
+    getNormalizedPath,
     makePath,
     putTextFileContents,
 )
@@ -259,6 +260,16 @@ Error, unknown plug-in '%s' in wrong case referenced, use '%s' instead."""
     return plugin_name2plugin_classes[plugin_name][0]
 
 
+def hasPluginName(plugin_name):
+    # First, load plugin classes, to know what we are talking about.
+    loadPlugins()
+
+    # Backward compatibility.
+    plugin_name = Options.getPluginNameConsideringRenames(plugin_name)
+
+    return plugin_name in plugin_name2plugin_classes
+
+
 def _addPluginClass(plugin_class, detector):
     plugin_name = plugin_class.plugin_name
 
@@ -784,9 +795,11 @@ class Plugins(object):
 
         try:
             trigger_module = buildModule(
-                module_filename=os.path.join(
-                    os.path.dirname(module.getCompileTimeFilename()),
-                    module_name.asPath() + ".py",
+                module_filename=getNormalizedPath(
+                    os.path.join(
+                        os.path.dirname(module.getCompileTimeFilename()),
+                        module_name.asPath() + ".py",
+                    )
                 ),
                 module_name=module_name,
                 reason="trigger",

nuitka/plugins/standard/AntiBloatPlugin.py

@@ -18,7 +18,7 @@ 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
+# spell-checker: ignore dask,numba,statsmodels,matplotlib,sqlalchemy,ipykernel,pyximport
 
 _mode_choices = ("error", "warning", "nofollow", "allow")
 
@@ -111,6 +111,10 @@ class NuitkaPluginAntiBloat(NuitkaYamlPluginBase):
                 noinclude_setuptools_mode,
                 "setuptools",
             )
+            self.handled_modules["wheel.util"] = (
+                noinclude_setuptools_mode,
+                "setuptools",
+            )
         else:
             self.control_tags["use_setuptools"] = True
 
@@ -267,7 +271,7 @@ form 'module_name:[%s]'."""
             dest="show_changes",
             default=False,
             help="""\
-Annotate what changes are by the plugin done.""",
+Annotate what changes are done by the plugin.""",
         )
 
         group.add_option(
@@ -411,7 +415,7 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
                 replace_dst = self.evaluateExpression(
                     full_name=module_name,
                     expression=replace_code,
-                    config_name="module '%s' config 'replacements' " % module_name,
+                    config_name="module '%s' config 'replacements'" % module_name,
                     extra_context=self._getContextCode(
                         module_name=module_name, anti_bloat_config=anti_bloat_config
                     ),
@@ -556,10 +560,10 @@ Error, cannot exec module '%s', context code '%s' due to: %s"""
     def onFunctionBodyParsing(self, module_name, function_name, body):
         result = False
 
-        config = self.config.get(module_name, section="anti-bloat")
-
-        if config:
-            for anti_bloat_config in config:
+        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")
+            ):
                 if self._onFunctionBodyParsing(
                     module_name=module_name,
                     anti_bloat_config=anti_bloat_config,
@@ -604,7 +608,7 @@ class %(class_name)s:
         replacement = ast.parse(replacement).body[0]
 
         node.body[:] = replacement.body
-        node.bases = replacement.bases
+        node.bases[:] = replacement.bases
 
         if self.show_changes:
             self.info(
@@ -616,10 +620,10 @@ class %(class_name)s:
     def onClassBodyParsing(self, module_name, class_name, node):
         result = False
 
-        config = self.config.get(module_name, section="anti-bloat")
-
-        if config:
-            for anti_bloat_config in config:
+        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")
+            ):
                 if self._onClassBodyParsing(
                     module_name=module_name,
                     anti_bloat_config=anti_bloat_config,
@@ -869,6 +873,13 @@ slow down compilation."""
             if module_name.hasNamespace(handled_module_name):
                 return "bytecode"
 
+        # TODO: Detect effective "change_class" and "change_function"
+        # configuration for standard library modules, but often enough we are
+        # happy to let the bytecode not have the effect, but for these ones it's
+        # required. TODO: Make the compilation mode part of the config.
+        if module_name == "xmlrpc.server":
+            return "compiled"
+
     def onModuleCompleteSet(self, module_set):
         # TODO: Maybe have an entry point that works on the set of names
         # instead, we are not looking at the modules, and most plugins probably

nuitka/plugins/standard/DllFilesPlugin.py

@@ -41,6 +41,72 @@ class NuitkaPluginDllFiles(NuitkaYamlPluginBase):
     def isRelevant():
         return isStandaloneMode()
 
+    def _handleDllConfigBySources(self, dll_config, full_name, dest_path):
+        # The "when" is at that level too for these.
+        if not self.evaluateCondition(
+            full_name=full_name, condition=dll_config.get("when", "True")
+        ):
+            return
+
+        config_name = "module '%s' DLL config" % full_name
+
+        source_paths = []
+
+        for source_path in dll_config.get("source_paths", ()):
+            value = self.evaluateExpressionOrConstant(
+                full_name=full_name,
+                expression=source_path,
+                config_name=config_name,
+                extra_context=None,
+                single_value=False,
+            )
+
+            if type(value) is str:
+                source_paths.append(value)
+            else:
+                source_paths.extend(value)
+
+        dest_names = []
+
+        for dest_name in dll_config.get("dest_names", ()):
+            value = self.evaluateExpressionOrConstant(
+                full_name=full_name,
+                expression=dest_name,
+                config_name=config_name,
+                extra_context=None,
+                single_value=False,
+            )
+
+            if type(value) is str:
+                dest_names.append(value)
+            else:
+                dest_names.extend(value)
+
+        assert len(source_paths) == len(dest_names), (source_paths, dest_names)
+
+        module_filename = self.locateModule(full_name)
+
+        if os.path.isdir(module_filename):
+            if dest_path is None:
+                dest_path = full_name.asPath()
+        else:
+            if dest_path is None:
+                dest_path = os.path.join(full_name.asPath(), "..")
+
+        for source_path, dest_name in zip(source_paths, dest_names):
+            yield self.makeDllEntryPoint(
+                source_path=source_path,
+                dest_path=os.path.normpath(
+                    os.path.join(
+                        dest_path,
+                        dest_name,
+                    )
+                ),
+                module_name=full_name,
+                package_name=full_name,
+                reason="Yaml config of '%s'" % full_name.asString(),
+            )
+
     def _handleDllConfigFromFilenames(self, dll_config, full_name, dest_path):
         # A lot of details here, pylint: disable=too-many-locals
 
@@ -159,7 +225,7 @@ class NuitkaPluginDllFiles(NuitkaYamlPluginBase):
         dest_path = os.path.normpath(dest_path)
 
         if executable:
-            yield self.makeExeEntryPoint(
+            return self.makeExeEntryPoint(
                 source_path=filename,
                 dest_path=dest_path,
                 module_name=full_name,
@@ -167,7 +233,7 @@ class NuitkaPluginDllFiles(NuitkaYamlPluginBase):
                 reason="Yaml config of '%s'" % full_name.asString(),
             )
         else:
-            yield self.makeDllEntryPoint(
+            return self.makeDllEntryPoint(
                 source_path=filename,
                 dest_path=dest_path,
                 module_name=full_name,
@@ -217,6 +283,16 @@ conditions are missing, or this version of the module needs treatment added."""
 
         found = False
 
+        if "from_sources" in dll_config:
+            for result in self._handleDllConfigBySources(
+                dll_config=dll_config.get("from_sources"),
+                full_name=full_name,
+                dest_path=dest_path,
+            ):
+                yield result
+
+            found = True
+
         if "by_code" in dll_config:
             for result in self._handleDllConfigByCode(
                 dll_config=dll_config.get("by_code"),

nuitka/plugins/standard/ImplicitImports.py

@@ -102,7 +102,7 @@ class NuitkaPluginImplicitImports(NuitkaYamlPluginBase):
                     for resolved in self._resolveModulePattern(v):
                         yield resolved
                 else:
-                    yield v
+                    yield ModuleName(v)
         elif "*" in dependency or "?" in dependency:
             for resolved in self._resolveModulePattern(dependency):
                 yield resolved
@@ -317,8 +317,6 @@ class NuitkaPluginImplicitImports(NuitkaYamlPluginBase):
         for config_package_dir in config.get("package-dirs", ()):
             yield os.path.normpath(os.path.join(package_dir, "..", config_package_dir))
 
-            yield package_dir
-
         for config_package_name in config.get("package-paths", ()):
             module_filename = self.locateModule(config_package_name)
 
@@ -361,19 +359,7 @@ class NuitkaPluginImplicitImports(NuitkaYamlPluginBase):
                     yield item
 
     def onModuleSourceCode(self, module_name, source_filename, source_code):
-        # Too much code here, pylint: disable=too-many-branches
         # TODO: Move the ones that would be possible to yaml config,
-        # e.g. the numexpr hack.
-
-        if module_name == "numexpr.cpuinfo":
-            # We cannot intercept "is" tests, but need it to be "isinstance",
-            # so we patch it on the file. TODO: This is only temporary, in
-            # the future, we may use optimization that understands the right
-            # hand size of the "is" argument well enough to allow for our
-            # type too.
-            source_code = source_code.replace(
-                "type(attr) is types.MethodType", "isinstance(attr, types.MethodType)"
-            )
 
         if module_name == "site":
             if source_code.startswith("def ") or source_code.startswith("class "):
@@ -555,6 +541,10 @@ __file__ = (__nuitka_binary_dir + '%ssite.py') if '__nuitka_binary_dir' in dict(
                 ):
                     code = "\n".join(entry.get("pre-import-code"))
 
+                    # TODO: Add a description to the Yaml file.
+                    yield code, """\
+According to Yaml 'pre-import-code' configuration."""
+
         for entry in self.config.get(full_name, section="import-hacks"):
             if "force-environment-variables" in entry:
                 if self.evaluateCondition(

nuitka/plugins/standard/KivyPlugin.py

@@ -6,7 +6,6 @@
 
 from nuitka.Options import isStandaloneMode
 from nuitka.plugins.PluginBase import NuitkaPluginBase
-from nuitka.utils.Utils import isMacOS, isWin32Windows
 
 
 class NuitkaPluginKivy(NuitkaPluginBase):
@@ -64,7 +63,9 @@ except ImportError:
         return info
 
     def getImplicitImports(self, module):
-        # Using branches to dispatch, pylint: disable=too-many-branches
+        # TODO: Move this all to yaml configuration, we now can
+        # query Kivy installation and use variables to solve some
+        # of the more difficult ones.
 
         full_name = module.getFullName()
 
@@ -92,16 +93,6 @@ except ImportError:
             yield "kivy.graphics.cgl_backend.cgl_sdl2"
         elif full_name == "kivy.graphics.cgl_backend.cgl_glew":
             yield "kivy.graphics.cgl_backend.cgl_gl"
-        elif full_name == "kivymd.app":
-            yield self.locateModules("kivymd.uix")
-        elif full_name == "kivy.core.clipboard":
-            if isWin32Windows():
-                yield "kivy.core.clipboard.clipboard_winctypes"
-            if isMacOS():
-                if self.locateModule("pyobjus"):
-                    yield "kivy.core.clipboard.clipboard_nspaste"
-                else:
-                    yield "kivy.core.clipboard.clipboard_sdl2"
 
     def getExtraDlls(self, module):
         """Copy extra shared libraries or data for this installation.

nuitka/plugins/standard/MatplotlibPlugin.py

@@ -8,6 +8,7 @@ import os
 from nuitka.Options import isStandaloneMode
 from nuitka.plugins.PluginBase import NuitkaPluginBase
 from nuitka.plugins.Plugins import (
+    getActiveQtPlugin,
     getActiveQtPluginBindingName,
     hasActivePlugin,
 )
@@ -76,7 +77,7 @@ from inspect import getsource
                 ),
             )
         except NuitkaCalledProcessError as e:
-            self.debug("Exception during detection: %r" % e)
+            self.debug("Exception during detection: %s" % str(e))
 
             if "MPLBACKEND" not in os.environ:
                 self.sysexit(
@@ -92,6 +93,15 @@ https://matplotlib.org/stable/users/installing/environment_variables_faq.html#en
         if info is None:
             self.sysexit("Error, it seems 'matplotlib' is not installed or broken.")
 
+        # Auto correct for using tk-inter the system setting.
+        if "tk" not in info.backend.lower() and hasActivePlugin("tk-inter"):
+            info = info.replace(backend="TkAgg")
+
+        if info.backend == "QtAgg" and getActiveQtPlugin() is None:
+            self.sysexit(
+                "Error, cannot use 'QtAgg' without a plugin for Qt binding active, use e.g. '--enable-plugin=pyside6'."
+            )
+
         return info
 
     def getImplicitImports(self, module):
@@ -183,6 +193,7 @@ https://matplotlib.org/stable/users/installing/environment_variables_faq.html#en
             if hasActivePlugin("tk-inter"):
                 return True, "Needed for tkinter matplotlib backend"
 
+        # For Qt binding, include matplotlib backend, spell-checker: ignore qtagg
         if module_name == "matplotlib.backends.backend_qtagg":
             if getActiveQtPluginBindingName() is not None:
                 return True, "Needed for qt matplotlib backend"

nuitka/plugins/standard/MultiprocessingPlugin.py

@@ -9,7 +9,7 @@ point to a "Python.exe" and won't use compiled code by default.
 
 The issue applies to accelerated and standalone mode alike.
 
-spell-checker: ignore joblib
+spell-checker: ignore joblib,anyio
 """
 
 from nuitka import Options
@@ -51,28 +51,21 @@ class NuitkaPluginMultiprocessingWorkarounds(NuitkaPluginBase):
     def createPreModuleLoadCode(module):
         full_name = module.getFullName()
 
-        # TODO: Replace the setting of "sys.frozen" with a change to the source code of the
-        # modules we want to affect from this plugin, it's a huge impact on compatibility
-        # with other things potentially. We should do it, once the anti-bloat engine is
-        # reusable or supports conditional replacements based on plugin activity and is
-        # always on.
-        if full_name == "multiprocessing":
-            code = """\
+        if full_name in ("multiprocessing", "anyio"):
+            yield (
+                """\
 import sys, os
-sys.frozen = 1
 argv0 = sys.argv[0]
 if sys.platform == "win32" and not os.path.exists(argv0) and not argv0.endswith(".exe"):
     argv0 += ".exe"
 
 sys.executable = %s
 sys._base_executable = sys.executable
-""" % (
-                "__nuitka_binary_exe" if Options.isStandaloneMode() else "argv0"
-            )
-            return (
-                code,
+"""
+                % ("__nuitka_binary_exe" if Options.isStandaloneMode() else "argv0"),
                 """\
-Monkey patching "multiprocessing" load environment.""",
+Monkey patching "%s" load environment."""
+                % full_name,
             )
 
     @staticmethod
@@ -80,7 +73,8 @@ Monkey patching "multiprocessing" load environment.""",
         full_name = module.getFullName()
 
         if full_name == "multiprocessing":
-            code = """\
+            yield (
+                """\
 try:
     from multiprocessing.forking import ForkingPickler
 except ImportError:
@@ -99,10 +93,7 @@ def _reduce_compiled_method(m):
 ForkingPickler.register(type(C().f), _reduce_compiled_method)
 if str is bytes:
     ForkingPickler.register(type(C.f), _reduce_compiled_method)
-"""
-
-            return (
-                code,
+""",
                 """\
 Monkey patching "multiprocessing" for compiled methods.""",
             )

nuitka/plugins/standard/OptionsNannyPlugin.py

@@ -81,15 +81,16 @@ Error, package '%s' requires '--macos-create-app-bundle' to be used or else it c
         elif macos_bundle == "no":
             pass
         elif macos_bundle == "recommend":
-            self.info(
-                """\
+            if not shallCreateAppBundle():
+                self.info(
+                    """\
 Note, when using '%s', consider using '--macos-create-app-bundle' option. \
 Otherwise high resolution will not be available and a terminal window will \
 open. However for debugging, terminal output is the easiest way to see \
 informative traceback and error information, so launch it from there if \
 possible."""
-                % full_name
-            )
+                    % full_name
+                )
         else:
             self.sysexitIllegalOptionValue(full_name, "macos_bundle", macos_bundle)