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

nuitka/PythonFlavors.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
+
+
 """ Python flavors specifics.
 
 This abstracts the Python variants from different people. There is not just
@@ -32,9 +18,10 @@ from nuitka.utils.FileOperations import (
     isFilenameBelowPath,
     isFilenameSameAsOrBelowPath,
 )
-from nuitka.utils.InstalledPythons import getInstalledPythonRegistryPaths
 from nuitka.utils.Utils import (
+    isAlpineLinux,
     isAndroidBasedLinux,
+    isArchBasedLinux,
     isFedoraBasedLinux,
     isLinux,
     isMacOS,
@@ -44,6 +31,7 @@ from nuitka.utils.Utils import (
 )
 
 from .PythonVersions import (
+    getInstalledPythonRegistryPaths,
     getRunningPythonDLLPath,
     getSystemPrefixPath,
     isStaticallyLinkedPython,
@@ -125,12 +113,39 @@ def isHomebrewPython():
     return False
 
 
+def getHomebrewInstallPath():
+    assert isHomebrewPython()
+
+    candidate = getSystemPrefixPath()
+
+    while candidate != "/":
+        if os.path.isdir(os.path.join(candidate, "Cellar")):
+            return candidate
+
+        candidate = os.path.dirname(candidate)
+
+    sys.exit("Error, failed to locate homebrew installation path.")
+
+
+def isRyePython():
+    if isMacOS():
+        import sysconfig
+
+        # We didn't find a better one, since they do not leave much of any trace
+        # otherwise than an unusable "libpython.a"
+        # spell-checker: ignore isysroot,flto,ldflags
+        value = sysconfig.get_config_var("_OSX_SUPPORT_INITIAL_PY_CORE_LDFLAGS")
+        return value is not None and "-flto=thin" in value and "-isysroot" in value
+
+    return False
+
+
 def isPyenvPython():
     if isWin32Windows():
         return False
 
-    return os.environ.get("PYENV_ROOT") and isFilenameSameAsOrBelowPath(
-        path=os.environ["PYENV_ROOT"], filename=getSystemPrefixPath()
+    return os.getenv("PYENV_ROOT") and isFilenameSameAsOrBelowPath(
+        path=os.getenv("PYENV_ROOT"), filename=getSystemPrefixPath()
     )
 
 
@@ -141,7 +156,7 @@ def isMSYS2MingwPython():
 
     import sysconfig
 
-    if python_version < 0x3B0:
+    if python_version >= 0x3B0:
         return "-mingw_" in sysconfig.get_config_var("EXT_SUFFIX")
     else:
         return "-mingw_" in sysconfig.get_config_var("SO")
@@ -178,8 +193,10 @@ def isUninstalledPython():
         res = GetSystemDirectory(buf, MAX_PATH)
         assert res != 0
 
-        system_path = os.path.normcase(buf.value)
-        return not getRunningPythonDLLPath().startswith(system_path)
+        system_path = buf.value
+        return not isFilenameBelowPath(
+            path=system_path, filename=getRunningPythonDLLPath()
+        )
 
     return isAnacondaPython() or "WinPython" in sys.version
 
@@ -198,7 +215,7 @@ def isWinPython():
     if _is_win_python is None:
         for element in sys.path:
             if os.path.basename(element) == "site-packages":
-                if os.path.exists(os.path.join(element, "winpython")):
+                if os.path.exists(os.path.join(element, "WinPython")):
                     _is_win_python = True
                     break
         else:
@@ -217,7 +234,7 @@ def isDebianPackagePython():
 
     if python_version < 0x300:
         return hasattr(sys, "_multiarch")
-    else:
+    elif python_version < 0x3C0:
         with withNoDeprecationWarning():
             try:
                 from distutils.dir_util import _multiarch
@@ -225,6 +242,11 @@ def isDebianPackagePython():
                 return False
             else:
                 return True
+    else:
+        import sysconfig
+
+        # Need to check there for Debian patch, pylint: disable=protected-access
+        return "deb_system" in sysconfig._INSTALL_SCHEMES
 
 
 def isFedoraPackagePython():
@@ -237,16 +259,40 @@ def isFedoraPackagePython():
     return system_prefix_path == "/usr"
 
 
+def isAlpinePackagePython():
+    """Is the Python from a Alpine package."""
+    if not isAlpineLinux():
+        return False
+
+    system_prefix_path = getSystemPrefixPath()
+
+    return system_prefix_path == "/usr"
+
+
+def isArchPackagePython():
+    """Is the Python from a Fedora package."""
+    if not isArchBasedLinux():
+        return False
+
+    system_prefix_path = getSystemPrefixPath()
+
+    return system_prefix_path == "/usr"
+
+
 def isCPythonOfficialPackage():
     """Official CPython download, kind of hard to detect since self-compiled doesn't change much."""
 
     sys_prefix = getSystemPrefixPath()
 
     # For macOS however, it's very knowable.
-    if isMacOS() and isFilenameBelowPath(
-        path="/Library/Frameworks/Python.framework/Versions/", filename=sys_prefix
-    ):
-        return True
+    if isMacOS():
+        for candidate in (
+            "/Library/Frameworks/Python.framework/Versions/",
+            "/Library/Frameworks/PythonT.framework/Versions/",
+        ):
+
+            if isFilenameBelowPath(path=candidate, filename=sys_prefix):
+                return True
 
     # For Windows, we check registry.
     if isWin32Windows():
@@ -257,10 +303,47 @@ def isCPythonOfficialPackage():
     return False
 
 
+_is_self_compiled_python = None
+
+
+def isSelfCompiledPythonUninstalled():
+    # singleton, pylint: disable=global-statement
+    global _is_self_compiled_python
+
+    if _is_self_compiled_python is None:
+        sys_prefix = getSystemPrefixPath()
+
+        _is_self_compiled_python = os.path.isdir(os.path.join(sys_prefix, "PCbuild"))
+
+    return _is_self_compiled_python
+
+
+_is_manylinux_python = None
+
+
+def isManyLinuxPython():
+    if not isLinux():
+        return False
+
+    # singleton, pylint: disable=global-statement
+    global _is_manylinux_python
+
+    sys_prefix = getSystemPrefixPath()
+
+    if _is_manylinux_python is None:
+        _is_manylinux_python = os.path.isfile(
+            os.path.join(sys_prefix, "..", "static-libs-for-embedding-only.tar.xz")
+        )
+
+    return _is_manylinux_python
+
+
 def isGithubActionsPython():
-    return os.environ.get(
-        "GITHUB_ACTIONS", ""
-    ) == "true" and getSystemPrefixPath().startswith("/opt/hostedtoolcache/Python")
+    # spell-checker: ignore hostedtoolcache
+
+    return os.getenv("GITHUB_ACTIONS") == "true" and getSystemPrefixPath().startswith(
+        "/opt/hostedtoolcache/Python"
+    )
 
 
 def getPythonFlavorName():
@@ -277,8 +360,14 @@ def getPythonFlavorName():
         return "Debian Python"
     elif isFedoraPackagePython():
         return "Fedora Python"
+    elif isArchPackagePython():
+        return "Arch Python"
+    elif isAlpinePackagePython():
+        return "Alpine Python"
     elif isHomebrewPython():
         return "Homebrew Python"
+    elif isRyePython():
+        return "Rye Python"
     elif isApplePython():
         return "Apple Python"
     elif isPyenvPython():
@@ -291,7 +380,27 @@ def getPythonFlavorName():
         return "Android Termux"
     elif isCPythonOfficialPackage():
         return "CPython Official"
+    elif isSelfCompiledPythonUninstalled():
+        return "Self Compiled Uninstalled"
     elif isGithubActionsPython():
         return "GitHub Actions Python"
+    elif isManyLinuxPython():
+        return "Manylinux Python"
     else:
         return "Unknown"
+
+
+#     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/PythonOperators.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
+
+
 """ Python operator tables
 
 These are mostly used to resolve the operator in the module operator and to know the list
@@ -143,3 +129,18 @@ def matchException(left, right):
 
 
 all_comparison_functions["exception_match"] = matchException
+
+#     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/PythonVersions.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
+
+
 """ Python version specifics.
 
 This abstracts the Python version decisions. This makes decisions based on
@@ -37,7 +23,6 @@ def getSupportedPythonVersions():
     return (
         "2.6",
         "2.7",
-        "3.3",
         "3.4",
         "3.5",
         "3.6",
@@ -46,12 +31,14 @@ def getSupportedPythonVersions():
         "3.9",
         "3.10",
         "3.11",
+        "3.12",
+        "3.13",
     )
 
 
 def getNotYetSupportedPythonVersions():
     """Versions known to not work at all (yet)."""
-    return ()
+    return ("3.14",)
 
 
 def getPartiallySupportedPythonVersions():
@@ -118,6 +105,7 @@ python_version_full_str = ".".join(str(s) for s in sys.version_info[0:3])
 python_version_str = ".".join(str(s) for s in sys.version_info[0:2])
 
 
+# TODO: Move error construction helpers to separate node making helpers module.
 def getErrorMessageExecWithNestedFunction():
     """Error message of the concrete Python in case an exec occurs in a
     function that takes a closure variable.
@@ -175,6 +163,13 @@ def getUnboundLocalErrorErrorTemplate():
     return getUnboundLocalErrorErrorTemplate.result
 
 
+def getDictFromkeysNoArgErrorMessage():
+    try:
+        dict.fromkeys()
+    except TypeError as e:
+        return e.args[0]
+
+
 _needs_set_literal_reverse_insertion = None
 
 
@@ -267,6 +262,12 @@ def getPythonABI():
     return abiflags
 
 
+def getLaunchingSystemPrefixPath():
+    from nuitka.utils.Utils import getLaunchingNuitkaProcessEnvironmentValue
+
+    return getLaunchingNuitkaProcessEnvironmentValue("NUITKA_SYS_PREFIX")
+
+
 _the_sys_prefix = None
 
 
@@ -332,6 +333,12 @@ def getSystemPrefixPath():
 
             sys_prefix = getDirectoryRealPath(sys_prefix)
 
+        # Self-compiled Python version in source tree
+        if os.path.isdir(
+            os.path.join(os.path.dirname(os.path.realpath(sys.executable)), "PCbuild")
+        ):
+            sys_prefix = os.path.dirname(os.path.realpath(sys.executable))
+
         _the_sys_prefix = sys_prefix
 
     return _the_sys_prefix
@@ -417,3 +424,84 @@ def isPythonValidCLongValue(value):
 
 def isPythonValidCLongLongValue(value):
     return _min_signed_longlong <= value <= _max_signed_longlong
+
+
+def getInstalledPythonRegistryPaths(version):
+    """Yield all Pythons as found in the Windows registry."""
+    # Windows only code,
+    # pylint: disable=I0021,import-error,redefined-builtin
+    from nuitka.__past__ import WindowsError
+
+    if str is bytes:
+        import _winreg as winreg  # pylint: disable=I0021,import-error,no-name-in-module
+    else:
+        import winreg  # pylint: disable=I0021,import-error,no-name-in-module
+
+    for hkey_branch in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER):
+        for arch_key in (0, winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY):
+            for suffix in "", "-32", "-arm64":
+                try:
+                    key = winreg.OpenKey(
+                        hkey_branch,
+                        r"SOFTWARE\Python\PythonCore\%s%s\InstallPath"
+                        % (version, suffix),
+                        0,
+                        winreg.KEY_READ | arch_key,
+                    )
+
+                    install_dir = os.path.normpath(winreg.QueryValue(key, ""))
+                except WindowsError:
+                    pass
+                else:
+                    candidate = os.path.normpath(
+                        os.path.join(install_dir, "python.exe")
+                    )
+
+                    if os.path.exists(candidate):
+                        yield candidate
+
+
+def getTkInterVersion():
+    """Get the tk-inter version or None if not installed."""
+    try:
+        if str is bytes:
+            return str(__import__("TkInter").TkVersion)
+        else:
+            return str(__import__("tkinter").TkVersion)
+    except ImportError:
+        # This should lead to no action taken ideally.
+        return None
+
+
+def getModuleLinkerLibs():
+    """Get static link libraries needed."""
+    try:
+        import sysconfig
+    except ImportError:
+        return []
+    else:
+        # static link libraries might be there, spell-checker: ignore modlibs
+        result = sysconfig.get_config_var("MODLIBS") or ""
+        result = [entry[2:] for entry in result.split() if entry.startswith("-l:")]
+
+        return result
+
+
+def isPythonWithGil():
+    return python_version < 0x3D0 or sys.flags.gil
+
+
+#     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/Serialization.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
+
+
 """ Write and read constants data files and provide identifiers.
 
 """
@@ -43,7 +29,7 @@ from nuitka.Builtins import (
 from nuitka.code_generation.Namify import namifyConstant
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.PythonVersions import python_version
-from nuitka.utils.FileOperations import openTextFile
+from nuitka.utils.FileOperations import openPickleFile
 
 
 class BuiltinAnonValue(object):
@@ -140,13 +126,7 @@ class ConstantStreamWriter(object):
         self.count = 0
 
         filename = os.path.join(OutputDirectories.getSourceDirectoryPath(), filename)
-        self.file = openTextFile(filename, "wb")
-        if python_version < 0x300:
-            self.pickle = pickle.Pickler(self.file, -1)
-        else:
-            self.pickle = pickle._Pickler(  # pylint: disable=I0021,protected-access
-                self.file, -1
-            )
+        self.file, self.pickle = openPickleFile(filename, "wb")
 
         self.pickle.dispatch[type] = _pickleAnonValues
         self.pickle.dispatch[type(Ellipsis)] = _pickleAnonValues
@@ -183,7 +163,9 @@ class ConstantStreamReader(object):
         return self.pickle.load()
 
 
-class ConstantAccessor(object):
+class GlobalConstantAccessor(object):
+    __slots__ = ("constants", "constants_writer", "top_level_name")
+
     def __init__(self, data_filename, top_level_name):
         self.constants = OrderedSet()
 
@@ -191,52 +173,54 @@ class ConstantAccessor(object):
         self.top_level_name = top_level_name
 
     def getConstantCode(self, constant):
-        # Use in user code, or for constants building code itself, many
-        # constant types get special code immediately.
-        # pylint: disable=too-many-branches,too-many-statements
+        # Use in user code, or for constants building code itself, many constant
+        # types get special code immediately, and it's return driven.
+        # pylint: disable=too-many-branches,too-many-return-statements
         if constant is None:
-            key = "Py_None"
+            return "Py_None"
         elif constant is True:
-            key = "Py_True"
+            return "Py_True"
         elif constant is False:
-            key = "Py_False"
+            return "Py_False"
         elif constant is Ellipsis:
-            key = "Py_Ellipsis"
+            return "Py_Ellipsis"
         elif constant is NotImplemented:
-            key = "Py_NotImplemented"
+            return "Py_NotImplemented"
         elif constant is sys.version_info:
-            key = "Py_SysVersionInfo"
+            return "Py_SysVersionInfo"
         elif type(constant) is type:
             # TODO: Maybe make this a mapping in nuitka.Builtins
 
             if constant is None:
-                key = "(PyObject *)Py_TYPE(Py_None)"
+                return "(PyObject *)Py_TYPE(Py_None)"
             elif constant is object:
-                key = "(PyObject *)&PyBaseObject_Type"
+                return "(PyObject *)&PyBaseObject_Type"
             elif constant is staticmethod:
-                key = "(PyObject *)&PyStaticMethod_Type"
+                return "(PyObject *)&PyStaticMethod_Type"
             elif constant is classmethod:
-                key = "(PyObject *)&PyClassMethod_Type"
+                return "(PyObject *)&PyClassMethod_Type"
             elif constant is bytearray:
-                key = "(PyObject *)&PyByteArray_Type"
+                return "(PyObject *)&PyByteArray_Type"
             elif constant is enumerate:
-                key = "(PyObject *)&PyEnum_Type"
+                return "(PyObject *)&PyEnum_Type"
             elif constant is frozenset:
-                key = "(PyObject *)&PyFrozenSet_Type"
+                return "(PyObject *)&PyFrozenSet_Type"
             elif python_version >= 0x270 and constant is memoryview:
-                key = "(PyObject *)&PyMemoryView_Type"
+                return "(PyObject *)&PyMemoryView_Type"
             elif python_version < 0x300 and constant is basestring:
-                key = "(PyObject *)&PyBaseString_Type"
+                return "(PyObject *)&PyBaseString_Type"
             elif python_version < 0x300 and constant is xrange:
-                key = "(PyObject *)&PyRange_Type"
+                return "(PyObject *)&PyRange_Type"
             elif constant in builtin_anon_values:
-                key = "(PyObject *)" + builtin_anon_codes[builtin_anon_values[constant]]
+                return (
+                    "(PyObject *)" + builtin_anon_codes[builtin_anon_values[constant]]
+                )
             elif constant in builtin_exception_values_list:
-                key = "(PyObject *)PyExc_%s" % constant.__name__
+                return "(PyObject *)PyExc_%s" % constant.__name__
             elif constant is ExceptionGroup:
-                key = "(PyObject *)_PyInterpreterState_GET()->exc_state.PyExc_ExceptionGroup"
+                return "(PyObject *)_PyInterpreterState_GET()->exc_state.PyExc_ExceptionGroup"
             elif constant is BaseExceptionGroup:
-                key = "(PyObject *)PyExc_BaseExceptionGroup"
+                return "(PyObject *)PyExc_BaseExceptionGroup"
             else:
                 type_name = constant.__name__
 
@@ -245,15 +229,18 @@ class ConstantAccessor(object):
                 elif constant is str:
                     type_name = "string" if python_version < 0x300 else "unicode"
 
-                key = "(PyObject *)&Py%s_Type" % type_name.capitalize()
+                return "(PyObject *)&Py%s_Type" % type_name.capitalize()
         else:
-            key = "const_" + namifyConstant(constant)
+            return self._getConstantCode(constant)
 
-            if key not in self.constants:
-                self.constants.add(key)
-                self.constants_writer.addConstantValue(constant)
+    def _getConstantCode(self, constant):
+        key = "const_" + namifyConstant(constant)
+
+        if key not in self.constants:
+            self.constants.add(key)
+            self.constants_writer.addConstantValue(constant)
 
-            key = "%s[%d]" % (self.top_level_name, self.constants.index(key))
+        key = "%s[%d]" % (self.top_level_name, self.constants.index(key))
 
         # TODO: Make it returning, more clear.
         return key
@@ -274,3 +261,31 @@ class ConstantAccessor(object):
         self.constants_writer.close()
 
         return len(self.constants)
+
+
+class ConstantAccessor(GlobalConstantAccessor):
+    def _getConstantCode(self, constant):
+        constant_type = type(constant)
+
+        if constant_type is tuple and not constant:
+            return "const_tuple_empty"
+        elif constant_type is int and constant in (-1, 0, 1):
+            return "const_" + namifyConstant(constant)
+        else:
+            return GlobalConstantAccessor._getConstantCode(self, constant)
+
+
+#     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.