Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/plugins/standard/OptionsNannyPlugin.py

@@ -0,0 +1,158 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Standard plug-in to tell user about needed or useful options for packages.
+
+When certain GUI packages are used, disabling the console may or may not be what
+the user wants, or even be required, as e.g. "wx" on macOS will crash unless the
+console is disabled. This reads Yaml configuration.
+"""
+
+from nuitka.Options import (
+    isOnefileMode,
+    isStandaloneMode,
+    shallCreateAppBundle,
+)
+from nuitka.plugins.YamlPluginBase import NuitkaYamlPluginBase
+from nuitka.utils.Utils import isMacOS
+
+
+class NuitkaPluginOptionsNanny(NuitkaYamlPluginBase):
+    plugin_name = "options-nanny"
+    plugin_desc = (
+        "Inform the user about potential problems as per package configuration files."
+    )
+    plugin_category = "core"
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    def sysexitIllegalOptionValue(self, full_name, option, value):
+        self.sysexit(
+            "Illegal value for package '%s' option '%s' ('%s')"
+            % (full_name, option, value)
+        )
+
+    def _checkSupportedVersion(self, full_name, support_info, description, condition):
+        # Configured to not report, default value.
+        if support_info == "ignore":
+            return
+
+        if support_info == "parameter":
+            message = "Module has parameter: " + description
+        elif support_info == "plugin":
+            message = "Module has plugin consideration: " + description
+        else:
+            if condition != "True":
+                problem_desc = (
+                    " with incomplete support due to condition '%s'" % condition
+                )
+            else:
+                problem_desc = " with incomplete support"
+
+            message = "Using module '%s' (version %s)%s: %s" % (
+                full_name,
+                ".".join(str(d) for d in self.getPackageVersion(full_name)),
+                problem_desc,
+                description,
+            )
+
+        if support_info == "error":
+            self.sysexit(message)
+        elif support_info in ("warning", "parameter", "plugin"):
+            self.warning(message)
+        elif support_info == "info":
+            self.info(message)
+        else:
+            self.sysexit(
+                "Error, unknown support_info level '%s' for module '%s'"
+                % full_name.asString()
+            )
+
+    def _checkMacOSBundleMode(self, full_name, macos_bundle):
+        if macos_bundle == "yes":
+            if isStandaloneMode() and not shallCreateAppBundle():
+                self.sysexit(
+                    """\
+Error, package '%s' requires '--mode=app' to be used or else it cannot work."""
+                    % full_name
+                )
+        elif macos_bundle == "no":
+            pass
+        elif macos_bundle == "recommend":
+            if not shallCreateAppBundle():
+                self.info(
+                    """\
+Note, when using '%s', consider using '--mode=app' 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
+                )
+        else:
+            self.sysexitIllegalOptionValue(full_name, "macos_bundle", macos_bundle)
+
+    def _checkMacOSBundleOnefileMode(self, full_name, macos_bundle_as_onefile):
+        if macos_bundle_as_onefile == "yes":
+            if isStandaloneMode() and shallCreateAppBundle() and not isOnefileMode():
+                self.sysexit(
+                    """\
+Error, package '%s' requires '--onefile' to be used on top of '--macos-create-app-bundle' or else it cannot work."""
+                    % full_name
+                )
+        elif macos_bundle_as_onefile == "no":
+            pass
+        else:
+            self.sysexitIllegalOptionValue(
+                full_name, "macos_bundle_onefile_mode", macos_bundle_as_onefile
+            )
+
+    # TODO: Definitely the wrong function to use, but we migrated this out of
+    # implicit imports, where it was done there.
+    def getImplicitImports(self, module):
+        full_name = module.getFullName()
+
+        for options_config in self.config.get(full_name, section="options"):
+            for check in options_config.get("checks", ()):
+                condition = check.get("when", "True")
+
+                if self.evaluateCondition(full_name=full_name, condition=condition):
+                    self._checkSupportedVersion(
+                        full_name=full_name,
+                        support_info=check.get("support_info", "ignore"),
+                        description=check.get("description", "not given"),
+                        condition=condition,
+                    )
+
+                    if isMacOS():
+                        self._checkMacOSBundleMode(
+                            full_name=full_name,
+                            macos_bundle=check.get("macos_bundle", "no"),
+                        )
+
+                        self._checkMacOSBundleOnefileMode(
+                            full_name=full_name,
+                            macos_bundle_as_onefile=check.get(
+                                "macos_bundle_as_onefile", "no"
+                            ),
+                        )
+
+        return ()
+
+
+#     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/PbrPlugin.py

@@ -0,0 +1,62 @@
+#     Copyright 2025, Jorj McKie, mailto:<jorj.x.mckie@outlook.de> find license text at end of file
+
+
+""" Standard plug-in to make pbr module work when compiled.
+
+The pbr module needs to find a version number in compiled mode. The value
+itself seems less important than the fact that some value does exist.
+"""
+
+from nuitka import Options
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+
+
+class NuitkaPluginPbrWorkarounds(NuitkaPluginBase):
+    """This is to make pbr module work when compiled with Nuitka."""
+
+    plugin_name = "pbr-compat"
+    plugin_desc = "Required by the 'pbr' package in standalone mode."
+    plugin_category = "package-support"
+
+    @classmethod
+    def isRelevant(cls):
+        return Options.isStandaloneMode()
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    @staticmethod
+    def createPreModuleLoadCode(module):
+        full_name = module.getFullName()
+
+        if full_name == "pbr.packaging":
+            code = """\
+import os
+version = os.getenv(
+        "PBR_VERSION",
+        os.getenv("OSLO_PACKAGE_VERSION"))
+if not version:
+    os.environ["OSLO_PACKAGE_VERSION"] = "1.0"
+"""
+            return (
+                code,
+                """\
+Monkey patching "pbr" version number.""",
+            )
+
+
+#     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/PkgResourcesPlugin.py

@@ -0,0 +1,162 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Standard plug-in to handle pkg_resource special needs.
+
+Nuitka can detect some things that "pkg_resources" may not even be able to during
+runtime, but that is done by nodes and optimization. But there are other things,
+that need special case, e.g. the registration of the loader class.
+"""
+
+import re
+
+from nuitka.__past__ import PermissionError  # pylint: disable=redefined-builtin
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.PythonVersions import python_version
+from nuitka.utils.Utils import withNoDeprecationWarning, withNoWarning
+
+
+class NuitkaPluginResources(NuitkaPluginBase):
+    plugin_name = "pkg-resources"
+    plugin_desc = "Workarounds for 'pkg_resources'."
+    plugin_category = "package-support"
+
+    def __init__(self):
+        with withNoWarning():
+            try:
+                import pkg_resources
+            except (ImportError, RuntimeError, PermissionError):
+                self.pkg_resources = None
+            else:
+                self.pkg_resources = pkg_resources
+
+        try:
+            if python_version >= 0x380:
+                from importlib import metadata
+            else:
+                import importlib_metadata as metadata
+        except (ImportError, SyntaxError, RuntimeError):
+            self.metadata = None
+        else:
+            self.metadata = metadata
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    def _handleEasyInstallEntryScript(self, dist, group, name):
+        module_name = None
+        main_name = None
+
+        # First try metadata, which is what the runner also does first.
+        if self.metadata:
+            dist = self.metadata.distribution(dist.partition("==")[0])
+
+            for entry_point in dist.entry_points:
+                if entry_point.group == group and entry_point.name == name:
+                    try:
+                        module_name = entry_point.module
+                        main_name = entry_point.attr
+                    except AttributeError:
+                        match = entry_point.pattern.match(entry_point.value)
+
+                        module_name = match.group("module")
+                        main_name = match.group("attr")
+
+                    break
+
+        if module_name is None and self.pkg_resources:
+            with withNoDeprecationWarning():
+                entry_point = self.pkg_resources.get_entry_info(dist, group, name)
+
+            module_name = entry_point.module_name
+            main_name = entry_point.name
+
+        if module_name is None:
+            self.sysexit(
+                "Error, failed to resolve easy install entry script, is the installation broken?"
+            )
+
+        return r"""
+import sys, re
+sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+import %(module_name)s
+sys.exit(%(module_name)s.%(main_name)s)
+""" % {
+            "module_name": module_name,
+            "main_name": main_name,
+        }
+
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
+        if module_name == "__main__":
+            match = re.search(
+                "\n# EASY-INSTALL-ENTRY-SCRIPT: '(.*?)','(.*?)','(.*?)'", source_code
+            )
+
+            if match is not None:
+                self.info(
+                    "Detected easy install entry script, compile time detecting entry point."
+                )
+
+                return self._handleEasyInstallEntryScript(*match.groups())
+
+        return source_code
+
+    def createPostModuleLoadCode(self, module):
+        """Create code to load after a module was successfully imported.
+
+        For pkg_resources we need to register a provider.
+        """
+        if module.getFullName() == "pkg_resources":
+            code = """\
+from __future__ import absolute_import
+
+import os
+from pkg_resources import register_loader_type, EggProvider
+
+class NuitkaProvider(EggProvider):
+    def _has(self, path):
+        return os.path.exists(path)
+
+    def _isdir(self, path):
+        return os.path.isdir(path)
+
+    def _listdir(self, path):
+        return os.listdir(path)
+
+    def get_resource_stream(self, manager, resource_name):
+        return open(self._fn(self.module_path, resource_name), 'rb')
+
+    def _get(self, path):
+        with open(path, 'rb') as stream:
+            return stream.read()
+
+assert __loader__.__class__.__name__ == "nuitka_module_loader", __loader__
+
+register_loader_type(__loader__.__class__, NuitkaProvider)
+"""
+
+            yield (
+                code,
+                """Registering Nuitka loader with "pkg_resources".""",
+            )
+
+    def decideCompilation(self, module_name):
+        if module_name == "pkg_resources-postLoad":
+            return "compiled"
+
+
+#     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/PlaywrightPlugin.py

@@ -0,0 +1,179 @@
+#     Copyright 2025, Kevin Rodriguez <mailto:turcioskevinr@gmail.com> find license text at end of file
+
+
+""" Plugin for Playwright.
+
+spell-checker: ignore Playwright
+"""
+
+import os
+
+from nuitka.Options import isStandaloneMode
+from nuitka.plugins.PluginBase import NuitkaPluginBase
+
+# We use chrom to identify either chrome or chromium
+# spell-checker: ignore chrom
+
+
+class NuitkaPluginPlaywright(NuitkaPluginBase):
+    """This class represents the main logic of the plugin."""
+
+    plugin_name = "playwright"
+    plugin_desc = "Required by 'playwright' package."
+    plugin_category = "package-support"
+
+    def __init__(self, include_browsers):
+        self.include_browsers = list(include_browsers)
+        self.installed_browsers = None
+
+    @staticmethod
+    def isAlwaysEnabled():
+        return True
+
+    @staticmethod
+    def isRelevant():
+        return isStandaloneMode()
+
+    @classmethod
+    def addPluginCommandLineOptions(cls, group):
+        group.add_option(
+            "--playwright-include-browser",
+            action="append",
+            dest="include_browsers",
+            default=[],
+            help="""\
+Playwright browser to include by name. Can be specified multiple
+times. Use "all" to include all installed browsers or use "none"
+to exclude all browsers.""",
+        )
+
+    def _getPlaywrightPath(self):
+        """Determine the path of the playwright module."""
+        info = self.locateModule("playwright")
+
+        if info is None:
+            self.sysexit("Error, it seems 'playwright' is not installed or broken.")
+
+        return info
+
+    def _getPlaywrightRegistryDirectory(self):
+        # this is a port of playwright's JS script which determines where the browsers are installed
+
+        env_defined = os.environ.get("PLAYWRIGHT_BROWSERS_PATH")
+        path_home = os.path.expanduser("~")
+        playwright_module_path = self._getPlaywrightPath()
+
+        result = os.path.join(
+            playwright_module_path, "driver", "package", ".local-browsers"
+        )
+
+        # TODO: This is seemingly a test for non-empty directory, which we should
+        # then add to FileOperations.
+
+        if os.path.exists(result) and next(os.scandir(result), False):
+            return result
+        elif env_defined == "0":
+            return result
+        elif env_defined:
+            result = os.path.normpath(env_defined)
+        else:
+            cache_directory = ""
+            if os.name == "posix":
+                cache_directory = os.environ.get(
+                    "XDG_CACHE_HOME", os.path.join(path_home, ".cache")
+                )
+            elif os.name == "darwin":
+                cache_directory = os.path.join(path_home, "Library", "Caches")
+            elif os.name == "nt":
+                cache_directory = os.environ.get(
+                    "LOCALAPPDATA", os.path.join(path_home, "AppData", "Local")
+                )
+
+            result = os.path.join(cache_directory, "ms-playwright")
+
+        if not os.path.isabs(result):
+            init_cwd = os.environ.get("INIT_CWD") or os.getcwd()
+            result = os.path.join(os.path.abspath(init_cwd), result)
+
+        return result
+
+    def getInstalledPlaywrightBrowsers(self):
+        registry_directory = self._getPlaywrightRegistryDirectory()
+        if not os.path.exists(registry_directory):
+            return
+
+        # TODO: Seems useless use of os.scandir, our helper for listing a directory
+        # would be better to use.
+        browsers_installed = [
+            browser
+            for browser in os.scandir(registry_directory)
+            if browser.name != ".links"
+        ]
+        self.installed_browsers = {}
+        for browser in browsers_installed:
+            self.installed_browsers[browser.name] = browser
+
+    def considerDataFiles(self, module):
+        if module.getFullName() != "playwright":
+            return
+
+        self.getInstalledPlaywrightBrowsers()
+
+        self.info("Including browsers: %s" % ", ".join(self.include_browsers))
+        if "none" in self.include_browsers:
+            return
+        if "all" in self.include_browsers:
+            self.include_browsers = self.installed_browsers
+        elif "ffmpeg" not in self.include_browsers and any(
+            browser.startswith("chrom") for browser in self.include_browsers
+        ):
+            for browser in self.installed_browsers:
+                if "ffmpeg" in self.installed_browsers[browser].name:
+                    self.include_browsers.append(browser)
+                    self.info(
+                        "Including 'ffmpeg' for chromium-based browser. It is required by playwright."
+                    )
+                    break
+
+        for browser in self.include_browsers:
+            if browser not in self.installed_browsers:
+                msg = (
+                    "Error, requested to include browser '%s' that was not found, the list of installed ones is '%s'."
+                    % (
+                        browser,
+                        ", ".join(self.installed_browsers),
+                    )
+                )
+                self.sysexit(msg)
+
+            msg = "Including '%s' from '%s'." % (
+                browser,
+                self.installed_browsers[browser].path,
+            )
+            self.info(msg)
+
+            yield self.makeIncludedDataDirectory(
+                source_path=self.installed_browsers[browser],
+                dest_path=os.path.join(
+                    "playwright", "driver", "package", ".local-browsers", browser
+                ),
+                reason="Playwright browser '%s'" % browser,
+                tags="playwright",
+                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.