Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/freezer/DllDependenciesCommon.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """DLL dependency scan methods that are shared. """
 
 import os
@@ -22,6 +8,7 @@ import os
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.importing.Importing import locateModule
 from nuitka.plugins.Plugins import Plugins
+from nuitka.Tracing import inclusion_logger
 from nuitka.utils.FileOperations import getSubDirectoriesWithDlls
 from nuitka.utils.ModuleNames import ModuleName
 
@@ -36,7 +23,12 @@ def getLdLibraryPath(package_name, python_rpaths, original_dir):
         if python_rpaths:
             ld_library_path.update(python_rpaths)
 
-        ld_library_path.update(getPackageSpecificDLLDirectories(package_name))
+        ld_library_path.update(
+            getPackageSpecificDLLDirectories(
+                package_name=package_name,
+                consider_plugins=True,
+            )
+        )
         if original_dir is not None:
             ld_library_path.add(original_dir)
 
@@ -45,7 +37,9 @@ def getLdLibraryPath(package_name, python_rpaths, original_dir):
     return _ld_library_cache[key]
 
 
-def getPackageSpecificDLLDirectories(package_name, consider_plugins=True):
+def getPackageSpecificDLLDirectories(
+    package_name, consider_plugins, allow_not_found=False
+):
     scan_dirs = OrderedSet()
 
     if package_name is not None:
@@ -53,6 +47,17 @@ def getPackageSpecificDLLDirectories(package_name, consider_plugins=True):
             module_name=package_name, parent_package=None, level=0
         )[1]
 
+        if package_dir is None:
+            if allow_not_found:
+                return scan_dirs
+
+            inclusion_logger.sysexit(
+                """\
+Error, failed to locate package '%s' while trying to look up DLL dependencies, \
+that should not happen. Please report the issue."""
+                % package_name
+            )
+
         if os.path.isdir(package_dir):
             scan_dirs.add(package_dir)
             scan_dirs.update(getSubDirectoriesWithDlls(package_dir))
@@ -65,6 +70,28 @@ def getPackageSpecificDLLDirectories(package_name, consider_plugins=True):
 
     # TODO: Move this to plugins DLLs section.
     if package_name == "torchvision" and consider_plugins:
-        scan_dirs.update(getPackageSpecificDLLDirectories(ModuleName("torch")))
+        scan_dirs.update(
+            getPackageSpecificDLLDirectories(
+                package_name=ModuleName("torch"),
+                consider_plugins=True,
+                allow_not_found=True,
+            )
+        )
 
     return scan_dirs
+
+
+#     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/freezer/DllDependenciesMacOS.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """DLL dependency scan methods for macOS. """
 
 import os
@@ -28,14 +14,21 @@ from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonFlavors import isAnacondaPython, isNuitkaPython
 from nuitka.PythonVersions import python_version
 from nuitka.Tracing import inclusion_logger
-from nuitka.utils.FileOperations import areSamePaths, isFilenameBelowPath
+from nuitka.utils.FileOperations import (
+    areSamePaths,
+    changeFilenameExtension,
+    getReportPath,
+    isFilenameBelowPath,
+)
 from nuitka.utils.Importing import getSharedLibrarySuffixes
 from nuitka.utils.Json import loadJsonFromFilename
 from nuitka.utils.SharedLibraries import (
     callInstallNameTool,
     getOtoolDependencyOutput,
     getOtoolListing,
+    parseOtoolListingOutput,
 )
+from nuitka.utils.Utils import getArchitecture
 
 from .DllDependenciesCommon import getLdLibraryPath
 
@@ -60,11 +53,16 @@ def _detectPythonRpaths():
         if os.path.isdir(candidate):
             result.append(candidate)
 
-    return tuple(result)
+    return tuple(set(result))
 
 
 def detectBinaryPathDLLsMacOS(
-    original_dir, binary_filename, package_name, keep_unresolved, recursive
+    original_dir,
+    binary_filename,
+    package_name,
+    keep_unresolved,
+    recursive,
+    recursive_dlls=None,
 ):
     assert os.path.exists(binary_filename), binary_filename
 
@@ -98,13 +96,25 @@ def detectBinaryPathDLLsMacOS(
     if recursive:
         merged_result = OrderedDict(resolved_result)
 
+        # For recursive DLL detection, cycle may exist, so we keep track of what
+        # was seen so far.
+        if recursive_dlls is None:
+            recursive_dlls = set([binary_filename])
+        else:
+            recursive_dlls = set(recursive_dlls)
+            recursive_dlls.add(binary_filename)
+
         for sub_dll_filename in resolved_result:
+            if sub_dll_filename in recursive_dlls:
+                continue
+
             _, sub_result = detectBinaryPathDLLsMacOS(
                 original_dir=os.path.dirname(sub_dll_filename),
                 binary_filename=sub_dll_filename,
                 package_name=package_name,
-                recursive=True,
                 keep_unresolved=True,
+                recursive=True,
+                recursive_dlls=recursive_dlls,
             )
 
             merged_result.update(sub_result)
@@ -118,17 +128,9 @@ def detectBinaryPathDLLsMacOS(
 
 
 def _parseOtoolListingOutput(output):
-    paths = OrderedSet()
-
-    for line in output.split(b"\n")[1:]:
-        if str is not bytes:
-            line = line.decode("utf8")
-
-        if not line:
-            continue
-
-        filename = line.split(" (", 1)[0].strip()
+    result = OrderedSet()
 
+    for filename in parseOtoolListingOutput(output):
         # Ignore dependency from system paths.
         if not isFilenameBelowPath(
             path=(
@@ -138,9 +140,49 @@ def _parseOtoolListingOutput(output):
             ),
             filename=filename,
         ):
-            paths.add(filename)
+            result.add(filename)
+
+    return result
+
+
+def _getNonVersionedDllFilenames2(filename):
+    yield filename
+
+    if getArchitecture() == "arm64" and filename.endswith(".dylib"):
+        yield filename[:-6] + "_arm64.dylib"
+
+    match = re.match(r"^(.*?)(\.\d+)+\.dylib$", filename)
+
+    if match:
+        yield match.group(1) + ".dylib"
+
+        # TODO: The versioned filename, might do the same, and so could the
+        # "x86_64" specific DLL be a thing too, but we should have actual
+        # examples to be sure they are covered with tests.
+        if getArchitecture() == "arm64":
+            yield match.group(1) + "_arm64.dylib"
+
+    if filename.endswith(".so"):
+        yield changeFilenameExtension(filename, ".dylib")
+
+
+def _getNonVersionedDllFilenames(dll_filename, package_name):
+    for filename in _getNonVersionedDllFilenames2(dll_filename):
+        yield filename
 
-    return paths
+    # Some build systems, internally prefix DLLs with package names, attempt
+    # those removed as well.
+    if package_name is not None:
+        package_prefix = package_name.asString() + "."
+
+        if os.path.basename(dll_filename).startswith(package_prefix):
+            dll_filename = os.path.join(
+                os.path.dirname(dll_filename),
+                os.path.basename(dll_filename)[len(package_prefix) :],
+            )
+
+            for filename in _getNonVersionedDllFilenames2(dll_filename):
+                yield filename
 
 
 def _resolveBinaryPathDLLsMacOS(
@@ -159,11 +201,17 @@ def _resolveBinaryPathDLLsMacOS(
     for path in paths:
         if path.startswith("@rpath/"):
             # Resolve rpath to just the ones given, first match.
+            library_name = path[7:]
+
             for rpath in rpaths:
-                if os.path.exists(os.path.join(rpath, path[7:])):
+                if os.path.exists(os.path.join(rpath, library_name)):
                     resolved_path = os.path.normpath(os.path.join(rpath, path[7:]))
                     break
             else:
+                # These have become virtual in later macOS, spell-checker: ignore libz
+                if library_name in ("libc++.1.dylib", "libz.1.dylib"):
+                    continue
+
                 # This is only a guess, might be missing package specific directories.
                 resolved_path = os.path.normpath(os.path.join(original_dir, path[7:]))
         elif path.startswith("@loader_path/"):
@@ -199,38 +247,70 @@ def _resolveBinaryPathDLLsMacOS(
                 )
 
         # Some extension modules seem to reference themselves by a different
-        # extension module name, so use that if it exists.
-        if not os.path.exists(resolved_path) and python_version >= 0x300:
+        # extension module name, so use that if it exists, and some versioned
+        # DLL dependencies do not matter.
+        if python_version >= 0x300:
             so_suffixes = getSharedLibrarySuffixes()[:-1]
 
             specific_suffix = so_suffixes[0]
             abi_suffix = so_suffixes[1]
 
-            if resolved_path.endswith(specific_suffix):
-                candidate = resolved_path[: -len(specific_suffix)] + abi_suffix
-            elif resolved_path.endswith(abi_suffix):
-                candidate = resolved_path[: -len(specific_suffix)] + abi_suffix
-            else:
-                candidate = None
-
-            if candidate is not None and os.path.exists(candidate):
-                resolved_path = candidate
-
-        # Sometimes self-dependencies are on a numbered version, but deployed is
-        # one version without it. The macOS just ignores that, and so we do.
-        if not os.path.exists(resolved_path):
-            match = re.match(r"^(.*)\.\d+\.dylib$", resolved_path)
+            for resolved_path_candidate in _getNonVersionedDllFilenames(
+                dll_filename=resolved_path, package_name=package_name
+            ):
+                if os.path.exists(resolved_path_candidate):
+                    resolved_path = resolved_path_candidate
+                    break
 
-            if match:
-                candidate = match.group(1) + ".dylib"
+                if resolved_path_candidate.endswith(specific_suffix):
+                    candidate = (
+                        resolved_path_candidate[: -len(specific_suffix)] + abi_suffix
+                    )
+                elif resolved_path_candidate.endswith(abi_suffix):
+                    candidate = (
+                        resolved_path_candidate[: -len(specific_suffix)] + abi_suffix
+                    )
+                else:
+                    candidate = None
 
-                if os.path.exists(candidate):
+                if candidate is not None and os.path.exists(candidate):
                     resolved_path = candidate
-                else:
-                    candidate = os.path.join(original_dir, os.path.basename(candidate))
+                    break
 
-                    if os.path.exists(candidate):
-                        resolved_path = candidate
+        # Sometimes self-dependencies are on a numbered version, but deployed is
+        # one version without it. Also be tolerant about changing suffixes
+        # internally. The macOS just ignores that, and so we do.
+        if not os.path.exists(resolved_path):
+            if os.path.basename(resolved_path) == os.path.basename(binary_filename):
+                resolved_path = binary_filename
+            else:
+                for suffix1, suffix2 in (
+                    (".dylib", ".dylib"),
+                    (".so", ".so"),
+                    (".dylib", ".so"),
+                    (".so", ".dylib"),
+                ):
+                    pattern = r"^(.*?)(\.\d+)*%s$" % re.escape(suffix1)
+
+                    match = re.match(pattern, resolved_path)
+
+                    if match:
+                        candidate = match.group(1) + suffix2
+
+                        if os.path.exists(candidate):
+                            resolved_path = candidate
+                        else:
+                            candidate = os.path.join(
+                                original_dir, os.path.basename(candidate)
+                            )
+
+                            if os.path.exists(candidate):
+                                resolved_path = candidate
+                            elif os.path.basename(candidate) == os.path.basename(
+                                binary_filename
+                            ):
+                                # Versioned dependency on itself in non-existent path.
+                                resolved_path = binary_filename
 
         if not os.path.exists(resolved_path):
             acceptable, plugin_name = Plugins.isAcceptableMissingDLL(
@@ -241,6 +321,17 @@ def _resolveBinaryPathDLLsMacOS(
             # TODO: Missing DLLs that are accepted, are not really forbidden, we
             # should instead acknowledge them as missing, and treat that properly
             # in using code.
+            if acceptable is True:
+                raise NuitkaForbiddenDLLEncounter(binary_filename, plugin_name)
+
+            # We check both the user and the used DLL if they are listed. This
+            # might be a form of bug hiding, that the later is not sufficient,
+            # that we should address later.
+            acceptable, plugin_name = Plugins.isAcceptableMissingDLL(
+                package_name=package_name,
+                filename=resolved_path,
+            )
+
             if acceptable is True:
                 raise NuitkaForbiddenDLLEncounter(binary_filename, plugin_name)
 
@@ -318,7 +409,7 @@ def fixupBinaryDLLPathsMacOS(
                 inclusion_logger.sysexit(
                     """\
     Error, problem with dependency scan of '%s' with '%s' please report the bug."""
-                    % (original_location, rpath_filename)
+                    % (getReportPath(original_location), rpath_filename)
                 )
 
             mapping.append((rpath_filename, "@executable_path/" + dist_path))
@@ -330,3 +421,19 @@ def fixupBinaryDLLPathsMacOS(
                 id_path=os.path.basename(binary_filename) if had_self else None,
                 rpath=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/freezer/DllDependenciesPosix.py

@@ -1,25 +1,10 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """DLL dependency scan methods for POSIX (Linux, *BSD, MSYS2).
 
 """
 
-
 import os
 import sys
 
@@ -28,7 +13,11 @@ from nuitka.PythonFlavors import isAnacondaPython
 from nuitka.Tracing import inclusion_logger
 from nuitka.utils.Execution import executeProcess, withEnvironmentPathAdded
 from nuitka.utils.SharedLibraries import getSharedLibraryRPATH
-from nuitka.utils.Utils import isAlpineLinux, isPosixWindows
+from nuitka.utils.Utils import (
+    isAlpineLinux,
+    isAndroidBasedLinux,
+    isPosixWindows,
+)
 
 from .DllDependenciesCommon import getLdLibraryPath
 
@@ -204,6 +193,9 @@ _linux_dll_ignore_list = [
     # The DRM layer should also be taken from the OS in question and won't
     # allow loading native drivers otherwise.
     "libdrm.so",
+    # The zlib can be assumed to be everywhere, and outside dependencies
+    # may actually load it.
+    "libz.so",
 ]
 
 if isAnacondaPython() or isAlpineLinux():
@@ -211,3 +203,21 @@ if isAnacondaPython() or isAlpineLinux():
     # so they have to be included.
     # Alpine linux does not include `libstdc++.so` by default.
     _linux_dll_ignore_list.remove("libstdc++.so")
+
+if isAndroidBasedLinux():
+    _linux_dll_ignore_list.remove("libz.so")
+
+#     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/freezer/DllDependenciesWin32.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """DLL dependency scan methods for Win32 Windows.
 
 Note: MSYS2, aka POSIX Windows is dealt with in the "DllDependenciesPosix" module.
@@ -28,6 +14,7 @@ from nuitka.build.SconsUtils import readSconsReport
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.Options import isShowProgress
 from nuitka.plugins.Plugins import Plugins
+from nuitka.PythonVersions import getSystemPrefixPath
 from nuitka.Tracing import inclusion_logger
 from nuitka.utils.AppDirs import getCacheDir
 from nuitka.utils.FileOperations import (
@@ -50,12 +37,13 @@ from .DllDependenciesCommon import getPackageSpecificDLLDirectories
 _scan_dir_cache = {}
 
 
-def detectBinaryPathDLLsWindowsDependencyWalker(
+def detectBinaryPathDLLsWin32(
     is_main_executable,
     source_dir,
     original_dir,
     binary_filename,
     package_name,
+    use_path,
     use_cache,
     update_cache,
 ):
@@ -68,6 +56,7 @@ def detectBinaryPathDLLsWindowsDependencyWalker(
             original_dir=original_dir,
             binary_filename=binary_filename,
             package_name=package_name,
+            use_path=use_path,
         )
 
         if use_cache:
@@ -92,7 +81,9 @@ def detectBinaryPathDLLsWindowsDependencyWalker(
     if isShowProgress():
         inclusion_logger.info("Analyzing dependencies of '%s'." % binary_filename)
 
-    scan_dirs = _getScanDirectories(package_name, original_dir)
+    scan_dirs = _getScanDirectories(
+        package_name=package_name, original_dir=original_dir, use_path=use_path
+    )
 
     result = detectDLLsWithDependencyWalker(
         binary_filename=binary_filename, source_dir=source_dir, scan_dirs=scan_dirs
@@ -104,7 +95,7 @@ def detectBinaryPathDLLsWindowsDependencyWalker(
     return result
 
 
-def _getScanDirectories(package_name, original_dir):
+def _getScanDirectories(package_name, original_dir, use_path):
     # TODO: Move PyWin32 specific stuff to yaml dll section
     # pylint: disable=too-many-branches
 
@@ -113,10 +104,15 @@ def _getScanDirectories(package_name, original_dir):
     if cache_key in _scan_dir_cache:
         return _scan_dir_cache[cache_key]
 
-    scan_dirs = [sys.prefix]
+    scan_dirs = [os.path.dirname(sys.executable), getSystemPrefixPath()]
 
     if package_name is not None:
-        scan_dirs.extend(getPackageSpecificDLLDirectories(package_name))
+        scan_dirs.extend(
+            getPackageSpecificDLLDirectories(
+                package_name=package_name,
+                consider_plugins=False,
+            )
+        )
 
     if original_dir is not None:
         scan_dirs.append(original_dir)
@@ -128,18 +124,23 @@ def _getScanDirectories(package_name, original_dir):
         if py_win32_dir is not None:
             scan_dirs.append(py_win32_dir)
 
-    for path_dir in os.environ["PATH"].split(";"):
-        if not os.path.isdir(path_dir):
-            continue
+    if use_path:
+        for path_dir in os.environ["PATH"].split(";"):
+            if not os.path.isdir(path_dir):
+                continue
 
-        if areSamePaths(path_dir, os.path.join(os.environ["SYSTEMROOT"])):
-            continue
-        if areSamePaths(path_dir, os.path.join(os.environ["SYSTEMROOT"], "System32")):
-            continue
-        if areSamePaths(path_dir, os.path.join(os.environ["SYSTEMROOT"], "SysWOW64")):
-            continue
+            if areSamePaths(path_dir, os.path.join(os.environ["SYSTEMROOT"])):
+                continue
+            if areSamePaths(
+                path_dir, os.path.join(os.environ["SYSTEMROOT"], "System32")
+            ):
+                continue
+            if areSamePaths(
+                path_dir, os.path.join(os.environ["SYSTEMROOT"], "SysWOW64")
+            ):
+                continue
 
-        scan_dirs.append(path_dir)
+            scan_dirs.append(path_dir)
 
     result = []
 
@@ -169,6 +170,7 @@ def _getCacheFilename(
     original_dir,
     binary_filename,
     package_name,
+    use_path,
 ):
     original_filename = os.path.join(original_dir, os.path.basename(binary_filename))
     original_filename = os.path.normcase(original_filename)
@@ -200,7 +202,27 @@ def _getCacheFilename(
     # Take Nuitka version into account as well, ought to catch code changes.
     hash_value.updateFromValues(version_string)
 
-    cache_dir = os.path.join(getCacheDir(), "library_dependencies", dependency_tool)
+    # Using PATH or not, should also be considered different.
+    if use_path:
+        hash_value.updateFromValues(os.getenv("PATH"))
+
+    cache_dir = os.path.join(getCacheDir("library_dependencies"), dependency_tool)
     makePath(cache_dir)
 
     return os.path.join(cache_dir, hash_value.asHexDigest())
+
+
+#     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.