Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/utils/InstalledPythons.py

@@ -0,0 +1,254 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Provide installed Pythons with module availability checks. """
+
+import os
+import sys
+
+from nuitka.containers.OrderedSets import OrderedSet
+from nuitka.PythonFlavors import isAnacondaPython, isMSYS2MingwPython
+from nuitka.PythonVersions import (
+    getInstalledPythonRegistryPaths,
+    python_version_str,
+)
+
+from .Execution import (
+    NuitkaCalledProcessError,
+    check_output,
+    getExecutablePath,
+)
+from .FileOperations import getDirectoryRealPath
+from .Utils import isWin32Windows
+
+
+class InstalledPython(object):
+    def __init__(self, python_exe, python_version):
+        self.python_exe = python_exe
+        self.python_version = python_version
+
+    def __repr__(self):
+        return "<InstalledPython '%s' version '%s'>" % (
+            self.python_exe,
+            self.python_version,
+        )
+
+    def getPythonExe(self):
+        return self.python_exe
+
+    def getPythonVersion(self):
+        return self.python_version
+
+    def getHexVersion(self):
+        major, minor = self.python_version.split(".")
+        return int(major) * 256 + int(minor) * 16
+
+    def isAnacondaPython(self):
+        if self.python_exe == sys.executable:
+            return isAnacondaPython()
+
+        # TODO: May not yet work really.
+        return os.path.exists(
+            os.path.join(os.path.dirname(self.python_exe), "..", "conda-meta")
+        )
+
+    def isMSYS2MingwPython(self):
+        if self.python_exe == sys.executable:
+            return isMSYS2MingwPython()
+
+        # TODO: May not yet work really.
+        return (
+            os.path.exists(
+                os.path.join(os.path.dirname(self.python_exe), "..", "..", "msys2.ini")
+            )
+            and os.path.basename(os.path.dirname(self.python_exe)) == "mingw64"
+        )
+
+    def getPreferredPackageType(self):
+        if self.isAnacondaPython():
+            return "conda"
+        elif self.isMSYS2MingwPython():
+            return "pacman"
+        else:
+            return "pip"
+
+    # Necessary for Python 2.7, otherwise SyntaxError is given on exec.
+    @staticmethod
+    def _exec(code, context):
+        # We can trust our own code there, pylint: disable=exec-used
+        exec(code.replace("print", "catch_print"), context)
+
+    def checkUsability(self, module_name, module_version):
+        # very many cases and return driven
+        # pylint: disable=too-many-branches,too-many-return-statements
+
+        if module_name is None:
+            return True
+
+        test_code = "import %s" % module_name
+
+        if module_version is not None:
+            test_code += ";print(%s.__version__)" % module_name
+
+        test_code += ";print('OK')"
+
+        if self.python_exe != sys.executable:
+            try:
+                output = check_output([self.python_exe, "-c", test_code])
+            except NuitkaCalledProcessError:
+                return False
+            except OSError:
+                return False
+
+            output = output.splitlines()
+        else:
+            output = []
+
+            def catch_print(value):
+                output.append(value)
+
+            try:
+                self._exec(code=test_code, context={"catch_print": catch_print})
+            except ImportError:
+                return False
+
+            if str is not bytes:
+                output = [line.encode("utf8") for line in output]
+
+        if output[-1] != b"OK":
+            return False
+
+        if module_version is not None:
+            detected_version = output[-2].split(b".")
+
+            if str is not bytes:
+                module_version = module_version.encode("utf8")
+
+            for detected_part, wanted_part in zip(
+                detected_version, module_version.split(b".")
+            ):
+                if int(detected_part) < int(wanted_part):
+                    return False
+
+        return True
+
+
+_installed_pythons = {}
+
+
+def _getPythonInstallPathsWindows(python_version):
+    """Find Python installation on Windows.
+
+    Find a Python installation, first try a few
+    guesses for their paths, then look into registry for user or system wide
+    installations.
+    """
+    seen = set()
+
+    # Shortcuts for the default installation directories, to avoid going to
+    # registry at all unless necessary. Any Python2 will do for Scons, so it
+    # might be avoided entirely.
+
+    candidate = r"c:\python%s\python.exe" % python_version.replace(".", "")
+
+    if os.path.isfile(candidate):
+        candidate = os.path.join(
+            getDirectoryRealPath(os.path.dirname(candidate)),
+            os.path.basename(candidate),
+        )
+
+        yield candidate
+
+        seen.add(candidate)
+
+    for candidate in getInstalledPythonRegistryPaths(python_version):
+        if candidate not in seen:
+            seen.add(candidate)
+            yield candidate
+
+
+def findPythons(python_version, module_name=None, module_version=None):
+    """Find all Python installations for a specific version."""
+
+    if python_version not in _installed_pythons:
+        result = OrderedSet()
+
+        if python_version == python_version_str:
+            result.add(
+                InstalledPython(
+                    python_exe=sys.executable, python_version=python_version
+                )
+            )
+
+        if isWin32Windows():
+            result.update(
+                InstalledPython(python_exe=python_exe, python_version=python_version)
+                for python_exe in _getPythonInstallPathsWindows(python_version)
+            )
+
+        candidate = getExecutablePath("python" + python_version)
+        if candidate is not None:
+            result.add(
+                InstalledPython(python_exe=candidate, python_version=python_version)
+            )
+
+        _installed_pythons[python_version] = result
+
+    return tuple(
+        sorted(
+            (
+                candidate
+                for candidate in _installed_pythons[python_version]
+                if candidate.checkUsability(
+                    module_name=module_name, module_version=module_version
+                )
+            ),
+            key=lambda c: c.getPythonExe(),
+        )
+    )
+
+
+def findInstalledPython(python_versions, module_name, module_version):
+    python_versions = list(python_versions)
+    python_versions.sort(
+        key=lambda python_version: python_version != python_version_str
+    )
+
+    # Make sure the current Python version is scanned for if acceptable.
+    if python_version_str in python_versions:
+        findPythons(python_version_str)
+
+    # Attempt to prefer scanned versions.
+    for python_version in python_versions:
+        for candidate in _installed_pythons.get(python_version, ()):
+            if module_name is None or candidate.checkUsability(
+                module_name=module_name, module_version=module_version
+            ):
+                return candidate
+
+    # Attempt to find so far not scanned versions.
+    for python_version in python_versions:
+        if python_version not in _installed_pythons:
+            for candidate in findPythons(python_version):
+                if module_name is None or candidate.checkUsability(
+                    module_name=module_name, module_version=module_version
+                ):
+                    return candidate
+
+    return None
+
+
+#     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/utils/InstanceCounters.py

@@ -0,0 +1,86 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Instance counter primitives
+
+We don't use a meta class as it's unnecessary complex, and portable meta classes
+have their difficulties, and want to count classes, who already have a meta
+class.
+
+This is going to expanded with time.
+
+"""
+
+from nuitka.Options import isShowMemory
+from nuitka.Tracing import printIndented, printLine
+
+counted_inits = {}
+counted_dels = {}
+
+
+def isCountingInstances():
+    return isShowMemory()
+
+
+def counted_init(init):
+    if isShowMemory():
+
+        def wrapped_init(self, *args, **kw):
+            name = self.__class__.__name__
+            assert type(name) is str
+
+            if name not in counted_inits:
+                counted_inits[name] = 0
+
+            counted_inits[name] += 1
+
+            init(self, *args, **kw)
+
+        return wrapped_init
+    else:
+        return init
+
+
+def _wrapped_del(self):
+    # This cannot be necessary, because in program finalization, the
+    # global variables were assign to None.
+    if counted_dels is None:
+        return
+
+    name = self.__class__.__name__
+    assert type(name) is str
+
+    if name not in counted_dels:
+        counted_dels[name] = 0
+
+    counted_dels[name] += 1
+
+
+def counted_del():
+    assert isShowMemory()
+
+    return _wrapped_del
+
+
+def printStats():
+    printLine("Init/del/alive calls:")
+
+    for name, count in sorted(counted_inits.items()):
+        dels = counted_dels.get(name, 0)
+        printIndented(1, name, count, dels, count - dels)
+
+
+#     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/utils/Jinja2.py

@@ -0,0 +1,158 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Jinja folklore wrappers and handling of inline copy usage.
+
+"""
+
+import sys
+
+from nuitka.__past__ import unicode
+
+from .Importing import importFromInlineCopy
+
+environments = {}
+
+
+def unlikely_if(value):
+    if value:
+        return "unlikely"
+    else:
+        return ""
+
+
+def unlikely_or_likely_from(value):
+    if value:
+        return "unlikely"
+    else:
+        return "likely"
+
+
+_jinja2 = None
+_markupsafe = None
+
+# For pkg resources, we need to keep a reference, after we delete it from
+# "sys.modules" again.
+
+_loaded_pkg_resources = None
+
+
+def getJinja2Package():
+    global _jinja2, _markupsafe, _loaded_pkg_resources  # singleton package using a cache, pylint: disable=global-statement
+
+    # Import dependencies, sadly we get to manage this ourselves.
+    if _markupsafe is None:
+        _markupsafe = importFromInlineCopy("markupsafe", must_exist=True)
+
+    # Newer Jinja2 may not use it, but we load it and remove it, so it
+    # does not interfere with anything else.
+    if "pkg_resources" not in sys.modules:
+        if _loaded_pkg_resources is None:
+            _loaded_pkg_resources = importFromInlineCopy(
+                "pkg_resources", must_exist=False
+            )
+
+    if _jinja2 is None:
+        _jinja2 = importFromInlineCopy("jinja2", must_exist=True)
+
+    # Unload if it was us loading it, as the inline copy is incomplete.
+    if _loaded_pkg_resources is not None and "pkg_resources" in sys.modules:
+        del sys.modules["pkg_resources"]
+
+    return _jinja2
+
+
+def getEnvironment(package_name, template_subdir, extensions):
+    key = package_name, template_subdir, extensions
+
+    if key not in environments:
+        jinja2 = getJinja2Package()
+
+        if package_name is not None:
+            loader = jinja2.PackageLoader(package_name, template_subdir)
+        elif template_subdir is not None:
+            loader = jinja2.FileSystemLoader(template_subdir)
+        else:
+            loader = jinja2.BaseLoader()
+
+        env = jinja2.Environment(
+            loader=loader,
+            extensions=extensions,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        # For shared global functions.
+        env.globals.update(
+            {
+                "unlikely_if": unlikely_if,
+                "unlikely_or_likely_from": unlikely_or_likely_from,
+            }
+        )
+
+        env.undefined = jinja2.StrictUndefined
+
+        environments[key] = env
+
+    return environments[key]
+
+
+def getTemplate(
+    package_name, template_name, template_subdir="templates", extensions=()
+):
+    return getEnvironment(
+        package_name=package_name,
+        template_subdir=template_subdir,
+        extensions=extensions,
+    ).get_template(template_name)
+
+
+def getTemplateC(
+    package_name, template_name, template_subdir="templates_c", extensions=()
+):
+    return getEnvironment(
+        package_name=package_name,
+        template_subdir=template_subdir,
+        extensions=extensions,
+    ).get_template(template_name)
+
+
+def getTemplateFromString(template_str):
+    return getEnvironment(
+        package_name=None, template_subdir=None, extensions=()
+    ).from_string(template_str.strip())
+
+
+_template_cache = {}
+
+
+def renderTemplateFromString(template_str, **kwargs):
+    # Avoid recreating templates, hoping to save some time.
+    if template_str not in _template_cache:
+        _template_cache[template_str] = getTemplateFromString(template_str)
+
+    result = _template_cache[template_str].render(**kwargs)
+
+    # Jinja produces unicode value, but our emission wants str, or else
+    # it messes up. TODO: We might switch to unicode one day or bytes
+    # for Python3 one day, but that seems to much work.
+    if str is not unicode:
+        return result.encode("utf8")
+    else:
+        return result
+
+
+#     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/utils/Json.py

@@ -0,0 +1,40 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Utils module to provide helper for our common json operations.
+
+"""
+
+from __future__ import absolute_import
+
+import json
+
+from .FileOperations import getFileContents, openTextFile
+
+
+def loadJsonFromFilename(filename):
+    try:
+        return json.loads(getFileContents(filename))
+    except ValueError:
+        return None
+
+
+def writeJsonToFilename(filename, contents, indent=2):
+    with openTextFile(filename, "w") as output:
+        json.dump(contents, output, indent=indent, sort_keys=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.

nuitka/utils/MacOSApp.py

@@ -0,0 +1,134 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" For macOS application bundle creation
+
+"""
+
+import os
+
+from nuitka import Options, OutputDirectories
+from nuitka.containers.OrderedDicts import OrderedDict
+
+from .FileOperations import copyFile, makePath, openTextFile
+from .Images import convertImageToIconFormat
+
+
+def createPlistInfoFile(logger, onefile):
+    # Many details, pylint: disable=too-many-branches,too-many-locals
+    import plistlib
+
+    if Options.isStandaloneMode():
+        bundle_dir = os.path.dirname(OutputDirectories.getStandaloneDirectoryPath())
+    else:
+        bundle_dir = os.path.dirname(
+            OutputDirectories.getResultRunFilename(onefile=onefile)
+        )
+
+    result_filename = OutputDirectories.getResultFullpath(onefile=onefile)
+    app_name = Options.getMacOSAppName() or os.path.basename(result_filename)
+
+    executable_name = os.path.basename(
+        OutputDirectories.getResultFullpath(onefile=Options.isOnefileMode())
+    )
+
+    signed_app_name = Options.getMacOSSignedAppName() or app_name
+    app_version = Options.getMacOSAppVersion() or "1.0"
+
+    infos = OrderedDict(
+        [
+            ("CFBundleDisplayName", app_name),
+            ("CFBundleName", app_name),
+            ("CFBundleIdentifier", signed_app_name),
+            ("CFBundleExecutable", executable_name),
+            ("CFBundleInfoDictionaryVersion", "6.0"),
+            ("CFBundlePackageType", "APPL"),  # spell-checker: ignore appl
+            ("CFBundleShortVersionString", app_version),
+        ]
+    )
+
+    icon_paths = Options.getMacOSIconPaths()
+
+    if icon_paths:
+        assert len(icon_paths) == 1
+        icon_path = icon_paths[0]
+
+        # Convert to single macOS .icns file if necessary
+        # spell-checker: ignore icns
+        if not icon_path.endswith(".icns"):
+            logger.info(
+                "File '%s' is not in macOS icon format, converting to it." % icon_path
+            )
+
+            icon_build_path = os.path.join(
+                OutputDirectories.getSourceDirectoryPath(onefile=onefile),
+                "icons",
+            )
+            makePath(icon_build_path)
+            converted_icon_path = os.path.join(
+                icon_build_path,
+                "Icons.icns",
+            )
+
+            convertImageToIconFormat(
+                logger=logger,
+                image_filename=icon_path,
+                converted_icon_filename=converted_icon_path,
+            )
+            icon_path = converted_icon_path
+
+        icon_name = os.path.basename(icon_path)
+        resources_dir = os.path.join(bundle_dir, "Resources")
+        makePath(resources_dir)
+
+        copyFile(icon_path, os.path.join(resources_dir, icon_name))
+
+        infos["CFBundleIconFile"] = icon_name
+
+    # Console mode, which is why we have to use bundle in the first place typically.
+    if Options.isMacOSBackgroundApp():
+        infos["LSBackgroundOnly"] = True
+    elif Options.isMacOSUiElementApp():
+        infos["LSUIElement"] = True  # spell-checker: ignore LSUI
+    else:
+        infos["NSHighResolutionCapable"] = True
+
+    if Options.shallMacOSProhibitMultipleInstances():
+        infos["LSMultipleInstancesProhibited"] = True
+
+    legal_text = Options.getLegalInformation()
+
+    if legal_text is not None:
+        infos["NSHumanReadableCopyright"] = legal_text
+
+    for resource_name, resource_desc in Options.getMacOSAppProtectedResourcesAccesses():
+        if resource_name in infos:
+            logger.sysexit("Duplicate value for '%s' is not allowed." % resource_name)
+
+        infos[resource_name] = resource_desc
+
+    filename = os.path.join(bundle_dir, "Info.plist")
+
+    if str is bytes:
+        plist_contents = plistlib.writePlistToString(infos)
+    else:
+        plist_contents = plistlib.dumps(infos)
+
+    with openTextFile(filename=filename, mode="wb") as plist_file:
+        plist_file.write(plist_contents)
+
+
+#     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.