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

nuitka/finalizations/FinalizeMarkups.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
+
+
 """ Finalize the markups
 
 Set flags on functions and classes to indicate if a locals dict is really
@@ -31,19 +17,10 @@ are in another context.
 
 """
 
-
 from nuitka import Tracing
-from nuitka.__past__ import unicode
-from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.PythonVersions import python_version
 from nuitka.tree.Operations import VisitorNoopMixin
 
-imported_names = OrderedSet()
-
-
-def getImportedNames():
-    return imported_names
-
 
 class FinalizeMarkups(VisitorNoopMixin):
     def onEnterNode(self, node):
@@ -81,16 +58,6 @@ class FinalizeMarkups(VisitorNoopMixin):
                 else:
                     search.markAsNeedsGeneratorReturnHandling(1)
 
-        if node.isExpressionBuiltinImport() and node.follow_attempted:
-            module_name = node.subnode_name
-
-            if module_name.isCompileTimeConstant():
-                imported_module_name = module_name.getCompileTimeConstant()
-
-                if type(imported_module_name) in (str, unicode):
-                    if imported_module_name:
-                        imported_names.add(imported_module_name)
-
         if node.isExpressionFunctionCreation():
             if (
                 not node.getParent().isExpressionFunctionCall()
@@ -118,10 +85,7 @@ class FinalizeMarkups(VisitorNoopMixin):
             if assign_source.isExpressionOperationBinary():
                 left_arg = assign_source.subnode_left
 
-                if (
-                    left_arg.isExpressionVariableRef()
-                    or left_arg.isExpressionTempVariableRef()
-                ):
+                if left_arg.isExpressionVariableRefOrTempVariableRef():
                     if assign_source.subnode_left.getVariable() is target_var:
                         if assign_source.isInplaceSuspect():
                             node.markAsInplaceSuspect()
@@ -136,7 +100,7 @@ class FinalizeMarkups(VisitorNoopMixin):
             if (
                 node.isExpressionYield()
                 or node.isExpressionYieldFrom()
-                or node.isExpressionYieldFromWaitable()
+                or node.isExpressionYieldFromAwaitable()
             ):
                 search = node.getParent()
 
@@ -158,3 +122,19 @@ class FinalizeMarkups(VisitorNoopMixin):
                     ):
                         node.markAsExceptionPreserving()
                         break
+
+
+#     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/finalizations/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """

nuitka/freezer/DependsExe.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
+
+
 """ Interface to depends.exe on Windows.
 
 We use depends.exe to investigate needed DLLs of Python DLLs.
@@ -32,7 +18,9 @@ from nuitka.utils.FileOperations import (
     deleteFile,
     getExternalUsePath,
     getFileContentByLine,
+    getWindowsLongPathName,
     isFilenameBelowPath,
+    isFilesystemEncodable,
     putTextFileContents,
     withFileLock,
 )
@@ -52,9 +40,11 @@ def getDependsExePath():
         depends_url = "https://dependencywalker.com/depends22_x64.zip"
 
     return getCachedDownload(
+        name="dependency walker",
         url=depends_url,
         is_arch_specific=getArchitecture(),
         binary="depends.exe",
+        unzip=True,
         flatten=True,
         specificity="",  # Note: If there ever was an update, put version here.
         message="""\
@@ -135,20 +125,29 @@ def _parseDependsExeOutput2(lines):
             else:
                 continue
 
-        assert os.path.basename(dll_filename) != "kernel32.dll"
+        # The executable itself is of course exempted. We cannot check its path
+        # because depends.exe mistreats unicode paths.
+        if first:
+            first = False
+            continue
 
         dll_filename = os.path.abspath(dll_filename)
+        dll_filename = getWindowsLongPathName(dll_filename)
 
         dll_name = os.path.basename(dll_filename)
 
         # Ignore this runtime DLL of Python2, will be coming via manifest.
+        # spell-checker: ignore msvcr90
         if dll_name in ("msvcr90.dll",):
             continue
 
-        # The executable itself is of course exempted. We cannot check its path
-        # because depends.exe mistreats unicode paths.
-        if first:
-            first = False
+        # Ignore API DLLs, they can come in from PATH, but we do not want to
+        # include them.
+        if dll_name.startswith("api-ms-win-"):
+            continue
+
+        # Ignore UCRT runtime, this must come from OS, spell-checker: ignore ucrtbase
+        if dll_name == "ucrtbase.dll":
             continue
 
         assert os.path.isfile(dll_filename), (dll_filename, line)
@@ -163,10 +162,14 @@ def parseDependsExeOutput(filename):
 
 
 def detectDLLsWithDependencyWalker(binary_filename, source_dir, scan_dirs):
-    dwp_filename = os.path.join(source_dir, os.path.basename(binary_filename) + ".dwp")
-    output_filename = os.path.join(
-        source_dir, os.path.basename(binary_filename) + ".depends"
-    )
+    source_dir = getExternalUsePath(source_dir)
+    temp_base_name = os.path.basename(binary_filename)
+
+    if not isFilesystemEncodable(temp_base_name):
+        temp_base_name = "dependency_walker"
+
+    dwp_filename = os.path.join(source_dir, temp_base_name + ".dwp")
+    output_filename = os.path.join(source_dir, temp_base_name + ".depends")
 
     # User query should only happen once if at all.
     with withFileLock(
@@ -204,14 +207,15 @@ SxS
                 "-f1",
                 "-pa1",
                 "-ps1",
-                binary_filename,
+                getExternalUsePath(binary_filename),
             ),
             external_cwd=True,
         )
 
     if not os.path.exists(output_filename):
         inclusion_logger.sysexit(
-            "Error, 'depends.exe' failed to produce expected output."
+            "Error, 'depends.exe' failed to produce expected output for binary '%s'."
+            % binary_filename
         )
 
     # Opening the result under lock, so it is not getting locked by new processes.
@@ -224,3 +228,19 @@ SxS
     deleteFile(dwp_filename, must_exist=True)
 
     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/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,7 +53,7 @@ def _detectPythonRpaths():
         if os.path.isdir(candidate):
             result.append(candidate)
 
-    return tuple(result)
+    return tuple(set(result))
 
 
 def detectBinaryPathDLLsMacOS(
@@ -103,8 +96,8 @@ def 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,
             )
 
             merged_result.update(sub_result)
@@ -118,17 +111,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 +123,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
+
+    # 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) :],
+            )
 
-    return paths
+            for filename in _getNonVersionedDllFilenames2(dll_filename):
+                yield filename
 
 
 def _resolveBinaryPathDLLsMacOS(
@@ -159,11 +184,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 +230,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 +304,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 +392,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 +404,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.