Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/plugins/standard/KivyPlugin.py

@@ -0,0 +1,141 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Details see below in class definition.
+"""
+
+from nuitka.Options import isStandaloneMode
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+
+
+class NuitkaPluginKivy(NuitkaPluginBase):
+    """This class represents the main logic of the plugin."""
+
+    plugin_name = "kivy"
+    plugin_desc = "Required by 'kivy' package."
+    plugin_category = "package-support"
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    @classmethod
+    def isRelevant(cls):
+        """One time only check: may this plugin be required?
+
+        Returns:
+            True if this is a standalone compilation.
+        """
+        return isStandaloneMode()
+
+    def _getKivyInformation(self):
+        setup_codes = r"""
+import kivy.core.image
+import kivy.core.text
+# Prevent Window from being created at compile time.
+kivy.core.core_select_lib=(lambda *args, **kwargs: None)
+import kivy.core.window
+
+# Kivy has packages designed to provide these on Windows
+try:
+    from kivy_deps.sdl2 import dep_bins as sdl2_dep_bins
+except ImportError:
+    sdl2_dep_bins = []
+try:
+    from kivy_deps.glew import dep_bins as glew_dep_bins
+except ImportError:
+    glew_dep_bins = []
+"""
+        info = self.queryRuntimeInformationMultiple(
+            info_name="kivy_info",
+            setup_codes=setup_codes,
+            values=(
+                ("libs_loaded", "kivy.core.image.libs_loaded"),
+                ("window_impl", "kivy.core.window.window_impl"),
+                ("label_libs", "kivy.core.text.label_libs"),
+                ("sdl2_dep_bins", "sdl2_dep_bins"),
+                ("glew_dep_bins", "glew_dep_bins"),
+            ),
+        )
+
+        if info is None:
+            self.sysexit("Error, it seems Kivy is not installed.")
+
+        return info
+
+    def getImplicitImports(self, module):
+        # 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()
+
+        if full_name == "kivy.core.image":
+            for module_name in self._getKivyInformation().libs_loaded:
+                yield full_name.getChildNamed(module_name)
+        elif full_name == "kivy.core.window":
+            # TODO: It seems only one is actually picked, so this could be made
+            # to also reflect decision making.
+            for _, module_name, _ in self._getKivyInformation().window_impl:
+                yield full_name.getChildNamed(module_name)
+        elif full_name == "kivy.core.text":
+            for _, module_name, _ in self._getKivyInformation().label_libs:
+                yield full_name.getChildNamed(module_name)
+        elif full_name == "kivy.core.window.window_sdl2":
+            yield "kivy.core.window._window_sdl2"
+        elif full_name == "kivy.core.window._window_sdl2":
+            yield "kivy.core.window.window_info"
+        elif full_name == "kivy.core.window.window_x11":
+            yield "kivy.core.window.window_info"
+        elif full_name == "kivy.graphics.cgl":
+            yield "kivy.graphics.cgl_backend"
+        elif full_name == "kivy.graphics.cgl_backend":
+            yield "kivy.graphics.cgl_backend.cgl_glew"
+            yield "kivy.graphics.cgl_backend.cgl_sdl2"
+        elif full_name == "kivy.graphics.cgl_backend.cgl_glew":
+            yield "kivy.graphics.cgl_backend.cgl_gl"
+
+    def getExtraDlls(self, module):
+        """Copy extra shared libraries or data for this installation.
+
+        Args:
+            module: module object
+        Yields:
+            DLL entry point objects
+        """
+
+        full_name = module.getFullName()
+
+        if full_name == "kivy":
+            kivy_info = self._getKivyInformation()
+
+            kivy_dlls = []
+            for dll_folder in kivy_info.sdl2_dep_bins + kivy_info.glew_dep_bins:
+                kivy_dlls.extend(self.locateDLLsInDirectory(dll_folder))
+
+            for full_path, target_filename, _dll_extension in kivy_dlls:
+                yield self.makeDllEntryPoint(
+                    source_path=full_path,
+                    dest_path=target_filename,
+                    module_name=full_name,
+                    package_name=full_name,
+                    reason="needed by 'kivy'",
+                )
+
+            self.reportFileCount(full_name, len(kivy_dlls))
+
+
+#     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/MatplotlibPlugin.py

@@ -0,0 +1,256 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Matplotlib standard plugin module. """
+
+import os
+
+from nuitka.Options import isStandaloneMode
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.plugins.Plugins import (
+    getActiveQtPlugin,
+    getActiveQtPluginBindingName,
+    hasActivePlugin,
+)
+from nuitka.utils.Execution import NuitkaCalledProcessError
+from nuitka.utils.FileOperations import getFileContentByLine
+from nuitka.utils.Jinja2 import renderTemplateFromString
+from nuitka.utils.Utils import isMacOS
+
+# spell-checker: ignore matplotlib, scipy, scikit, matplotlibrc, matplotlibdata
+# spell-checker: ignore mpl_toolkits, tkagg, MPLBACKEND
+
+
+class NuitkaPluginMatplotlib(NuitkaPluginBase):
+    """This class represents the main logic of the plugin.
+
+    This is a plugin to ensure scripts using numpy, scipy, matplotlib, pandas,
+    scikit-learn, etc. work well in standalone mode.
+
+    While there already are relevant entries in the "ImplicitImports.py" plugin,
+    this plugin copies any additional binary or data files required by many
+    installations.
+
+    """
+
+    plugin_name = "matplotlib"  # Nuitka knows us by this name
+    plugin_desc = "Required for 'matplotlib' module."
+    plugin_category = "package-support"
+
+    @staticmethod
+    def isAlwaysEnabled():
+        """Request to be always enabled."""
+
+        return True
+
+    @classmethod
+    def isRelevant(cls):
+        """Check whether plugin might be required.
+
+        Returns:
+            True if this is a standalone compilation.
+        """
+        return isStandaloneMode()
+
+    def _getMatplotlibInfo(self):
+        """Determine the filename of matplotlibrc and the default backend, etc.
+
+        Notes:
+            There might exist a local version outside 'matplotlib/mpl-data' which
+            we then must use instead. Determine its name by asking matplotlib.
+        """
+        try:
+            info = self.queryRuntimeInformationMultiple(
+                info_name="matplotlib_info",
+                setup_codes="""
+from matplotlib import matplotlib_fname, get_backend, __version__
+try:
+    from matplotlib import get_data_path
+except ImportError:
+    from matplotlib import _get_data_path as get_data_path
+from inspect import getsource
+""",
+                values=(
+                    ("matplotlibrc_filename", "matplotlib_fname()"),
+                    ("backend", "get_backend()"),
+                    ("data_path", "get_data_path()"),
+                    ("matplotlib_version", "__version__"),
+                ),
+            )
+        except NuitkaCalledProcessError as e:
+            self.debug("Exception during detection: %s" % str(e))
+
+            if "MPLBACKEND" not in os.environ:
+                self.sysexit(
+                    """\
+Error, failed to detect matplotlib backend. Please set 'MPLBACKEND' \
+environment variable during compilation.""",
+                    mnemonic="""\
+https://matplotlib.org/stable/users/installing/environment_variables_faq.html#envvar-MPLBACKEND""",
+                )
+
+            raise
+
+        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):
+        # Make sure the used Qt namespace is included in compilation, mostly for
+        # accelerated mode, but also to prevent people from accidentally
+        # removing it.
+        if module.getFullName() != "matplotlib":
+            return
+
+        matplotlib_info = self._getMatplotlibInfo()
+
+        # Make sure, the default backend is included.
+        yield "matplotlib.backends.backend_%s" % matplotlib_info.backend.lower()
+
+    def considerDataFiles(self, module):
+        if module.getFullName() != "matplotlib":
+            return
+
+        matplotlib_info = self._getMatplotlibInfo()
+
+        if not os.path.isdir(matplotlib_info.data_path):
+            self.sysexit(
+                "mpl-data missing, matplotlib installation appears to be broken"
+            )
+
+        self.info(
+            "Using %s backend '%s'."
+            % (
+                (
+                    "configuration file or default"
+                    if "MPLBACKEND" not in os.environ
+                    else "as per 'MPLBACKEND' environment variable"
+                ),
+                matplotlib_info.backend,
+            )
+        )
+
+        # Include the "mpl-data" files.
+        yield self.makeIncludedDataDirectory(
+            source_path=matplotlib_info.data_path,
+            dest_path=os.path.join("matplotlib", "mpl-data"),
+            ignore_dirs=("sample_data",),
+            ignore_filenames=("matplotlibrc",),
+            reason="package data for 'matplotlib",
+            tags="mpl-data",
+        )
+
+        # Handle the config file with an update.
+        new_lines = []  # new config file lines
+
+        found = False  # checks whether backend definition encountered
+        for line in getFileContentByLine(matplotlib_info.matplotlibrc_filename):
+            line = line.rstrip()
+
+            # omit meaningless lines
+            if line.startswith("#") and matplotlib_info.matplotlib_version < "3":
+                continue
+
+            new_lines.append(line)
+
+            if line.startswith(("backend ", "backend:")):
+                # old config file has a backend definition
+                found = True
+
+        if not found and matplotlib_info.matplotlib_version < "4":
+            # Set the backend, so even if it was run time determined, we now enforce it.
+            new_lines.append("backend: %s" % matplotlib_info.backend)
+
+        yield self.makeIncludedGeneratedDataFile(
+            data="\n".join(new_lines),
+            dest_path=os.path.join("matplotlib", "mpl-data", "matplotlibrc"),
+            reason="updated matplotlib config file with backend to use",
+        )
+
+    def onModuleEncounter(
+        self, using_module_name, module_name, module_filename, module_kind
+    ):
+        if module_name.hasNamespace("mpl_toolkits"):
+            return True, "Needed by matplotlib"
+
+        # some special handling for matplotlib:
+        # depending on whether 'tk-inter' resp. 'qt-plugins' are enabled,
+        # their matplotlib backends are included.
+        if module_name in (
+            "matplotlib.backends.backend_tk",
+            "matplotlib.backends.backend_tkagg",
+            "matplotlib.backend.tkagg",
+        ):
+            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"
+
+    def createPreModuleLoadCode(self, module):
+        """Method called when a module is being imported.
+
+        Notes:
+            If full name equals "matplotlib" we insert code to set the
+            environment variable that e.g. Debian versions of matplotlib
+            use.
+
+        Args:
+            module: the module object
+        Returns:
+            Code to insert and descriptive text (tuple), or (None, None).
+        """
+
+        # The version may not need the environment variable.
+        if module.getFullName() == "matplotlib":
+            code = renderTemplateFromString(
+                r"""
+import os
+os.environ["MATPLOTLIBDATA"] = os.path.join(__nuitka_binary_dir, "matplotlib", "mpl-data")
+os.environ["MATPLOTLIBRC"] = os.path.join(__nuitka_binary_dir, "matplotlib", "mpl-data", "matplotlibrc")
+os.environ["MPLBACKEND"] = "{{matplotlib_info.backend}}"
+{% if qt_binding_name %}
+os.environ["QT_API"] = "{{qt_binding_name}}"
+{% endif %}
+""",
+                matplotlib_info=self._getMatplotlibInfo(),
+                qt_binding_name=getActiveQtPluginBindingName(),
+            )
+            return (
+                code,
+                "Setting environment variables for 'matplotlib' to find package configuration.",
+            )
+
+    def decideCompilation(self, module_name):
+        # The C code for macOS requires Python functions rather than compiled
+        # ones, let it have its way
+        if isMacOS() and module_name == "matplotlib.backend_bases":
+            return "bytecode"
+
+
+#     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/MultiprocessingPlugin.py

@@ -0,0 +1,199 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Standard plug-in to make multiprocessing and joblib work well.
+
+On Windows, the multiprocessing modules forks new processes which then have
+to start from scratch. This won't work if there is no "sys.executable" to
+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,anyio
+"""
+
+from nuitka import Options
+from nuitka.ModuleRegistry import (
+    getModuleInclusionInfoByName,
+    getRootTopModule,
+)
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.PythonVersions import python_version
+from nuitka.tree.SourceHandling import readSourceCodeFromFilename
+from nuitka.utils.ModuleNames import ModuleName
+
+
+class NuitkaPluginMultiprocessingWorkarounds(NuitkaPluginBase):
+    """This is to make multiprocessing work with Nuitka and use compiled code.
+
+    When running in accelerated mode, it's not good to fork a new Python
+    instance to run other code, as that won't be accelerated. And when
+    run in standalone mode, there may not even be a Python, but it's the
+    same principle.
+
+    So by default, this module is on and works around the behavior of the
+    "multiprocessing.forking/multiprocessing.spawn/multiprocessing.manager"
+    expectations.
+    """
+
+    plugin_name = "multiprocessing"
+    plugin_desc = "Required by Python's 'multiprocessing' module."
+    plugin_category = "package-support"
+
+    @classmethod
+    def isRelevant(cls):
+        return not Options.shallMakeModule()
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    @staticmethod
+    def createPreModuleLoadCode(module):
+        full_name = module.getFullName()
+
+        if full_name in ("multiprocessing", "anyio"):
+            yield (
+                """\
+import sys, os
+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"),
+                """\
+Monkey patching "%s" load environment."""
+                % full_name,
+            )
+
+    @staticmethod
+    def createPostModuleLoadCode(module):
+        full_name = module.getFullName()
+
+        if full_name == "multiprocessing":
+            yield (
+                """\
+try:
+    from multiprocessing.forking import ForkingPickler
+except ImportError:
+    from multiprocessing.reduction import ForkingPickler
+
+class C:
+   def f():
+       pass
+
+def _reduce_compiled_method(m):
+    if m.im_self is None:
+        return getattr, (m.im_class, m.im_func.__name__)
+    else:
+        return getattr, (m.im_self, m.im_func.__name__)
+
+ForkingPickler.register(type(C().f), _reduce_compiled_method)
+if str is bytes:
+    ForkingPickler.register(type(C.f), _reduce_compiled_method)
+""",
+                """\
+Monkey patching "multiprocessing" for compiled methods.""",
+            )
+
+    @staticmethod
+    def createFakeModuleDependency(module):
+        full_name = module.getFullName()
+
+        if full_name != "multiprocessing":
+            return
+
+        # First, build the module node and then read again from the
+        # source code.
+        root_module = getRootTopModule()
+
+        module_name = ModuleName("__parents_main__")
+
+        source_code = readSourceCodeFromFilename(module_name, root_module.getFilename())
+
+        # 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 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 >= 0x300:
+            source_code += """
+def __nuitka_freeze_support():
+    import sys
+
+    # Not needed, and can crash from minor __file__ differences, depending on invocation
+    import multiprocessing.spawn
+    multiprocessing.spawn._fixup_main_from_path = lambda mod_name : None
+
+    # This is a variant of freeze_support that will work for multiprocessing and
+    # joblib equally well.
+    kwds = {}
+    args = []
+    for arg in sys.argv[2:]:
+        try:
+            name, value = arg.split('=')
+        except ValueError:
+            name = "pipe_handle"
+            value = arg
+
+        if value == 'None':
+            kwds[name] = None
+        else:
+            kwds[name] = int(value)
+
+    # Otherwise main module names will not work.
+    sys.modules["__main__"] = sys.modules["__parents_main__"]
+
+    multiprocessing.spawn.spawn_main(*args, **kwds)
+__nuitka_freeze_support()
+"""
+        else:
+            source_code += """
+__import__("sys").modules["__main__"] = __import__("sys").modules[__name__]
+__import__("multiprocessing.forking").forking.freeze_support()"""
+
+        yield (
+            module_name,
+            source_code,
+            root_module.getCompileTimeFilename(),
+            "Auto enable multiprocessing freeze support",
+        )
+
+    def onModuleEncounter(
+        self, using_module_name, module_name, module_filename, module_kind
+    ):
+        # Enforce recursion in to multiprocessing for accelerated mode, which
+        # would normally avoid this.
+        if module_name.hasNamespace("multiprocessing"):
+            return True, "Multiprocessing plugin needs this to monkey patch it."
+
+    def decideCompilation(self, module_name):
+        if module_name.hasNamespace("multiprocessing"):
+            return "bytecode"
+
+        # TODO: Make this demoted too.
+        # or module_name in( "multiprocessing-preLoad", "multiprocessing-postLoad"):
+
+    @staticmethod
+    def getPreprocessorSymbols():
+        if getModuleInclusionInfoByName("__parents_main__"):
+            return {"_NUITKA_PLUGIN_MULTIPROCESSING_ENABLED": "1"}
+
+
+#     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/NumpyPlugin.py

@@ -0,0 +1,35 @@
+#     Copyright 2025, Jorj McKie, mailto:<jorj.x.mckie@outlook.de> find license text at end of file
+
+
+""" Details see below in class definition.
+"""
+
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+
+
+class NuitkaPluginNumpy(NuitkaPluginBase):
+    """This plugin is now not doing anything anymore."""
+
+    plugin_name = "numpy"  # Nuitka knows us by this name
+    plugin_desc = "Deprecated, was once required by the numpy package"
+    plugin_category = "package-support,obsolete"
+
+    @classmethod
+    def isDeprecated(cls):
+        return 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.