Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/utils/Shebang.py

@@ -0,0 +1,113 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Utils to work with shebang lines.
+
+"""
+
+import os
+import re
+
+
+def getShebangFromSource(source_code):
+    """Given source code, extract the shebang (#!) part.
+
+    Notes:
+        This function is less relevant on Windows, because it will not use
+        this method of determining the execution. Still scripts aimed at
+        multiple platforms will contain it and it can be used to e.g. guess
+        the Python version expected, if it is a Python script at all.
+
+        There are variants of the function that will work on filenames instead.
+    Args:
+        source_code: The source code as a unicode string
+    Returns:
+        The binary and arguments that the kernel will use (Linux and compatible).
+    """
+
+    if source_code.startswith("#!"):
+        shebang = re.match(r"^#!\s*(.*?)\n", source_code)
+
+        if shebang is not None:
+            shebang = shebang.group(0).rstrip("\n")
+    else:
+        shebang = None
+
+    return shebang
+
+
+def getShebangFromFile(filename):
+    """Given a filename, extract the shebang (#!) part from it.
+
+    Notes:
+        This function is less relevant on Windows, because it will not use
+        this method of determining the execution. Still scripts aimed at
+        multiple platforms will contain it and it can be used to e.g. guess
+        the Python version expected, if it is a Python script at all.
+
+        There are variants of the function that will work on file content
+        instead.
+    Args:
+        filename: The filename to get the shebang of
+    Returns:
+        The binary that the kernel will use (Linux and compatible).
+    """
+
+    with open(filename, "rb") as f:
+        source_code = f.readline()
+
+        if str is not bytes:
+            try:
+                source_code = source_code.decode("utf8")
+            except UnicodeDecodeError:
+                source_code = ""
+
+        return getShebangFromSource(source_code)
+
+
+def parseShebang(shebang):
+    """Given a concrete shebang value, it will extract the binary used.
+
+    Notes:
+        This function is less relevant on Windows, because it will not use
+        this method of determining the execution.
+
+        This handles that many times people use `env` binary to search the
+        PATH for an actual binary, e.g. `/usr/bin/env python3.7` where we
+        would care most about the `python3.7` part and want to see through
+        the `env` usage.
+    Args:
+        shebang: The shebang extracted with one of the methods to do so.
+    Returns:
+        The binary the kernel will use (Linux and compatible).
+    """
+
+    parts = shebang.split()
+
+    if os.path.basename(parts[0]) == "env":
+        # This attempts to handle env with arguments and options.
+        del parts[0]
+
+        while parts[0].startswith("-"):
+            del parts[0]
+
+        while "=" in parts[0]:
+            del parts[0]
+
+    return parts[0][2:].lstrip(), parts[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/utils/Signing.py

@@ -0,0 +1,144 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Signing of executables.
+
+"""
+
+from nuitka.Options import (
+    getMacOSSignedAppName,
+    getMacOSSigningIdentity,
+    shallUseSigningForNotarization,
+)
+from nuitka.Tracing import postprocessing_logger
+
+from .Execution import executeToolChecked
+from .FileOperations import withMadeWritableFileMode
+
+_macos_codesign_usage = (
+    "The 'codesign' is used to make signatures on macOS and required to be found."
+)
+
+
+def _filterCodesignErrorOutput(stderr):
+    stderr = b"\n".join(
+        line
+        for line in stderr.splitlines()
+        if line
+        if b"replacing existing signature" not in line
+    )
+
+    if b"errSecInternalComponent" in stderr:
+        postprocessing_logger.sysexit(
+            """\
+Access to the specified codesign certificate was not allowed. Please \
+'allow all items' or when compiling with GUI available, enable prompting \
+for the certificate in KeyChain Access application for this certificate."""
+        )
+
+    return None, stderr
+
+
+def detectMacIdentity():
+    output = executeToolChecked(
+        logger=postprocessing_logger,
+        command=["security", "find-identity"],
+        absence_message="The 'security' program is used to scan for signing identities",
+        decoding=str is not bytes,
+    )
+
+    signing_name = None
+    result = None
+
+    for line in output.splitlines():
+        line = line.strip()
+
+        if line.startswith("2)"):
+            postprocessing_logger.sysexit(
+                "More than one signing identity, auto mode cannot be used."
+            )
+
+        if line.startswith("1)"):
+            parts = line.split(" ", 2)
+
+            result = parts[1]
+            signing_name = parts[2]
+
+    if result is None:
+        postprocessing_logger.sysexit(
+            "Failed to detect any signing identity, auto mode cannot be used."
+        )
+    else:
+        postprocessing_logger.info(
+            "Using signing identity %s automatically." % signing_name
+        )
+
+    return result
+
+
+def addMacOSCodeSignature(filenames):
+    """Add the code signature to filenames.
+
+    Args:
+        filenames - The filenames to be signed.
+
+    Returns:
+        None
+
+    Notes:
+        This is macOS specific.
+    """
+
+    # Weak signing.
+    identity = getMacOSSigningIdentity()
+
+    if identity == "auto":
+        identity = detectMacIdentity()
+
+    command = [
+        # Need to avoid Anaconda codesign.
+        "/usr/bin/codesign",
+        "-s",
+        identity,
+        "--force",
+        "--deep",
+        "--preserve-metadata=entitlements",
+    ]
+
+    macos_signed_app_name = getMacOSSignedAppName()
+
+    if macos_signed_app_name is not None:
+        command += [
+            "-i",
+            macos_signed_app_name,
+        ]
+
+    if shallUseSigningForNotarization():
+        command.append("--options=runtime")
+
+    assert type(filenames) is not str
+    command.extend(filenames)
+
+    with withMadeWritableFileMode(filenames):
+        executeToolChecked(
+            logger=postprocessing_logger,
+            command=command,
+            absence_message=_macos_codesign_usage,
+            stderr_filter=_filterCodesignErrorOutput,
+        )
+
+
+#     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/SlotMetaClasses.py

@@ -0,0 +1,57 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Helper for portable metaclasses that do checks. """
+
+from abc import ABCMeta
+
+from nuitka.Errors import NuitkaNodeDesignError
+
+
+def getMetaClassBase(meta_class_prefix, require_slots):
+    """For Python2/3 compatible source, we create a base class that has the metaclass
+    used and doesn't require making a syntax choice.
+
+    Also this allows to enforce the proper usage of "__slots__" for all classes using
+    it optionally.
+    """
+
+    class MetaClass(ABCMeta):
+        def __new__(
+            mcs, name, bases, dictionary
+        ):  # pylint: disable=I0021,arguments-differ
+            if require_slots:
+                for base in bases:
+                    if base is not object and "__slots__" not in base.__dict__:
+                        raise NuitkaNodeDesignError(
+                            name, "All bases must set __slots__.", base
+                        )
+
+                if "__slots__" not in dictionary:
+                    raise NuitkaNodeDesignError(name, "Class must set __slots__.", name)
+
+            return ABCMeta.__new__(mcs, name, bases, dictionary)
+
+    MetaClassBase = MetaClass(
+        "%sMetaClassBase" % meta_class_prefix,
+        (object,),
+        {"__slots__": ()} if require_slots else {},
+    )
+
+    return MetaClassBase
+
+
+#     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/StaticLibraries.py

@@ -0,0 +1,260 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" This module deals with finding and information about static libraries.
+
+"""
+
+import os
+
+from nuitka.containers.OrderedSets import OrderedSet
+from nuitka.PythonFlavors import (
+    isAnacondaPython,
+    isDebianPackagePython,
+    isNuitkaPython,
+    isPyenvPython,
+    isPythonBuildStandalonePython,
+    isRyePython,
+    isSelfCompiledPythonUninstalled,
+)
+from nuitka.PythonVersions import (
+    getPythonABI,
+    getSystemPrefixPath,
+    python_version,
+    python_version_str,
+)
+from nuitka.Tracing import general
+
+from .Execution import executeToolChecked
+from .FileOperations import getFileContentByLine, getFileList
+from .Utils import (
+    getLinuxDistribution,
+    isDebianBasedLinux,
+    isMacOS,
+    isWin32Windows,
+)
+
+_ldconf_paths = None
+
+_static_lib_cache = {}
+
+
+def locateStaticLinkLibrary(dll_name):
+    if dll_name not in _static_lib_cache:
+        _static_lib_cache[dll_name] = _locateStaticLinkLibrary(dll_name)
+
+    return _static_lib_cache[dll_name]
+
+
+def _locateStaticLinkLibrary(dll_name):
+    # singleton, pylint: disable=global-statement
+
+    #
+    global _ldconf_paths
+
+    if _ldconf_paths is None:
+        _ldconf_paths = OrderedSet()
+
+        for conf_filename in getFileList("/etc/ld.so.conf.d", only_suffixes=".conf"):
+            for conf_line in getFileContentByLine(conf_filename):
+                conf_line = conf_line.split("#", 1)[0]
+                conf_line = conf_line.strip()
+
+                if os.path.exists(conf_line):
+                    _ldconf_paths.add(conf_line)
+
+    for ld_config_path in _ldconf_paths:
+        candidate = os.path.join(ld_config_path, "lib%s.a" % dll_name)
+
+        if os.path.exists(candidate):
+            return candidate
+
+    return None
+
+
+_static_lib_python_path = False
+
+
+def isDebianSuitableForStaticLinking():
+    dist_name, _base, dist_version = getLinuxDistribution()
+
+    if dist_name == "Debian":
+        if dist_version is None:
+            return True
+
+        try:
+            dist_version = tuple(int(x) for x in dist_version.split("."))
+        except ValueError:
+            # dist_version contains a non-numeric string such as "sid".
+            return True
+
+        return dist_version >= (10,)
+    else:
+        # TODO: Needs implementing potentially, Mint etc. are based
+        # on something that should be considered.
+        return True
+
+
+def _getSysConfigVarLIBPL():
+    # Return the LIBPL config variable, or None if it's not set or retrievable
+    try:
+        import sysconfig
+
+        return sysconfig.get_config_var("LIBPL")
+
+    except ImportError:
+        # Cannot detect this properly for Python 2.6, but we don't care much
+        # about that anyway.
+        return None
+
+
+def _getSystemStaticLibPythonPath():
+    # Return driven function with many cases, pylint: disable=too-many-branches,too-many-return-statements
+
+    sys_prefix = getSystemPrefixPath()
+    python_abi_version = python_version_str + getPythonABI()
+
+    if isNuitkaPython():
+        # Nuitka Python has this.
+        if isWin32Windows():
+            return os.path.join(
+                sys_prefix,
+                "libs",
+                "python" + python_abi_version.replace(".", "") + ".lib",
+            )
+        else:
+            return os.path.join(
+                sys_prefix,
+                "lib",
+                "libpython" + python_abi_version + ".a",
+            )
+
+    if isWin32Windows():
+        # The gcc used on Windows for Anaconda is far too old for winlibs gcc
+        # to use its library.
+        if isAnacondaPython():
+            return None
+
+        candidates = [
+            # Anaconda has this.
+            os.path.join(
+                sys_prefix,
+                "libs",
+                "libpython" + python_abi_version.replace(".", "") + ".dll.a",
+            ),
+            # MSYS2 mingw64 Python has this.
+            os.path.join(
+                sys_prefix,
+                "lib",
+                "libpython" + python_abi_version + ".dll.a",
+            ),
+        ]
+
+        for candidate in candidates:
+            if os.path.exists(candidate):
+                return candidate
+
+        return None
+
+    if isMacOS() and isRyePython():
+        return None
+
+    if isMacOS() and isPyenvPython():
+        return None
+
+    if isPythonBuildStandalonePython():
+        return None
+
+    if isSelfCompiledPythonUninstalled():
+        candidate = os.path.join(sys_prefix, "libpython" + python_abi_version + ".a")
+
+        if os.path.exists(candidate):
+            return candidate
+
+    candidate = os.path.join(sys_prefix, "lib", "libpython" + python_abi_version + ".a")
+
+    if os.path.exists(candidate):
+        return candidate
+
+    # For Python2 this works. TODO: Figure out Debian and Python3.
+    if (
+        python_version < 0x300
+        and isDebianPackagePython()
+        and isDebianSuitableForStaticLinking()
+    ):
+        candidate = locateStaticLinkLibrary("python" + python_abi_version)
+    else:
+        candidate = None
+
+    if candidate is not None and os.path.exists(candidate):
+        # Also check libz, can be missing
+        if not locateStaticLinkLibrary("z"):
+            general.warning(
+                "Error, missing 'libz-dev' installation needed for static lib-python."
+            )
+
+        return candidate
+
+    # This is not necessarily only for Python3 on Debian, but maybe others as well,
+    # but that's what's been tested. spell-checker: ignore libpl
+    if python_version >= 0x300 and isDebianPackagePython() and isDebianBasedLinux():
+        candidate = os.path.join(
+            _getSysConfigVarLIBPL(),
+            "libpython" + python_abi_version + "-pic.a",
+        )
+
+        if os.path.exists(candidate):
+            return candidate
+
+    libpl = _getSysConfigVarLIBPL()
+    if libpl is not None:
+        candidate = os.path.join(
+            libpl,
+            "libpython" + python_abi_version + ".a",
+        )
+
+        if os.path.exists(candidate):
+            return candidate
+
+    return None
+
+
+def getSystemStaticLibPythonPath():
+    global _static_lib_python_path  # singleton, pylint: disable=global-statement
+
+    if _static_lib_python_path is False:
+        _static_lib_python_path = _getSystemStaticLibPythonPath()
+
+    return _static_lib_python_path
+
+
+_nm_usage = "nm is used to detect symbols of static link libraries"
+
+
+def getStaticLinkLibrarySymbols(logger, static_library_path):
+    """Get the list of symbols exported by a static link library."""
+
+    output = executeToolChecked(
+        logger=logger,
+        command=("nm", "-U", "-g", "-j", static_library_path),
+        absence_message=_nm_usage,
+        decoding=str is not bytes,
+    )
+
+    return output.splitlines()
+
+
+#     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/ThreadedExecutor.py

@@ -0,0 +1,87 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Threaded pool execution.
+
+This can use Python3 native, or even Python2.7 backport, or has a Python2.6
+stub that does not thread at all.
+"""
+
+from threading import RLock, current_thread
+
+# Set this to false, to enable actual use of threads. This was found no longer
+# useful with dependency walker, but might be true in other cases.
+_use_threaded_executor = False
+
+
+class NonThreadedPoolExecutor(object):
+    def __init__(self, max_workers=None):
+        # This stub ignores max_workers, pylint: disable=unused-argument
+
+        self.results = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        return False
+
+    def submit(self, function, *args):
+        # Submitted jobs are simply done immediately.
+        self.results.append(function(*args))
+
+        return self
+
+
+def waitWorkers(workers):
+    if workers:
+        return iter(workers[0].results)
+
+
+ThreadPoolExecutor = NonThreadedPoolExecutor
+
+
+if _use_threaded_executor:
+    try:
+        from concurrent.futures import (  # pylint: disable=I0021,import-error,no-name-in-module,unused-import
+            FIRST_EXCEPTION,
+            ThreadPoolExecutor,
+            as_completed,
+            wait,
+        )
+
+        # We overwrite this if wanted, pylint: disable=function-redefined
+        def waitWorkers(workers):
+            wait(workers, return_when=FIRST_EXCEPTION)
+
+            for future in as_completed(workers):
+                yield future.result()
+
+    except ImportError:
+        # No backport installed, use stub for at least Python 2.6, and potentially
+        # also Python 2.7, we might want to tell the user about it though, that
+        # we think it should be installed.
+        pass
+
+
+def getThreadIdent():
+    return current_thread()
+
+
+assert RLock
+assert ThreadPoolExecutor
+
+#     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.