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

nuitka/tree/ReformulationMatchStatements.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
+
+
 """ Reformulation of Python3.10 match statements.
 
 Consult the Developer Manual for information. TODO: Add ability to sync
@@ -24,20 +10,23 @@ source code comments with Developer Manual sections.
 
 import ast
 
-from nuitka.nodes.AttributeNodes import (
-    ExpressionAttributeCheck,
-    makeExpressionAttributeLookup,
-)
+from nuitka.nodes.AttributeNodes import ExpressionAttributeCheck
+from nuitka.nodes.BuiltinDictNodes import ExpressionBuiltinDict
 from nuitka.nodes.BuiltinLenNodes import ExpressionBuiltinLen
 from nuitka.nodes.BuiltinTypeNodes import ExpressionBuiltinList
-from nuitka.nodes.ComparisonNodes import makeComparisonExpression
+from nuitka.nodes.ComparisonNodes import (
+    ExpressionComparisonIs,
+    makeComparisonExpression,
+)
 from nuitka.nodes.ConditionalNodes import makeStatementConditional
 from nuitka.nodes.ConstantRefNodes import makeConstantRefNode
+from nuitka.nodes.DictionaryNodes import StatementDictOperationRemove
 from nuitka.nodes.MatchNodes import ExpressionMatchArgs
+from nuitka.nodes.OperatorNodes import ExpressionOperationBinarySub
 from nuitka.nodes.OutlineNodes import ExpressionOutlineBody
 from nuitka.nodes.ReturnNodes import makeStatementReturnConstant
 from nuitka.nodes.SubscriptNodes import (
-    ExpressionSubscriptCheck,
+    ExpressionMatchSubscriptCheck,
     ExpressionSubscriptLookup,
 )
 from nuitka.nodes.TypeMatchNodes import (
@@ -46,12 +35,15 @@ from nuitka.nodes.TypeMatchNodes import (
 )
 from nuitka.nodes.TypeNodes import ExpressionBuiltinIsinstance
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
-from nuitka.nodes.VariableNameNodes import StatementAssignmentVariableName
+from nuitka.nodes.VariableNameNodes import (
+    ExpressionVariableNameRef,
+    StatementAssignmentVariableName,
+)
 from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
 from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 
 from .ReformulationBooleanExpressions import makeAndNode, makeOrNode
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .TreeHelpers import (
     buildNode,
     buildStatementsNode,
@@ -170,30 +162,38 @@ def _buildMatchSequence(provider, pattern, make_against, source_ref):
     # Could special case ">=1" or "==0" with truth checks potentially, but that
     # is for generic optimization to recognize, we don't know much about the
     # matched value at this point yet.
-    conditions.append(
-        makeComparisonExpression(
-            left=ExpressionBuiltinLen(
-                value=make_against(),
+    if min_length > 0 or exact:
+        conditions.append(
+            makeComparisonExpression(
+                left=ExpressionBuiltinLen(
+                    value=make_against(),
+                    source_ref=source_ref,
+                ),
+                right=makeConstantRefNode(constant=min_length, source_ref=source_ref),
+                comparator="Eq" if exact else "GtE",
                 source_ref=source_ref,
-            ),
-            right=makeConstantRefNode(constant=min_length, source_ref=source_ref),
-            comparator="Eq" if exact else "GtE",
-            source_ref=source_ref,
+            )
         )
-    )
 
     star_pos = None
 
-    count = seq_pattern = None
-
-    for count, seq_pattern in enumerate(pattern.patterns):
-        # offset from the start.
+    def makeOffsetNode(count):
         if star_pos is None:
-            offset = count
+            return makeConstantRefNode(constant=count, source_ref=source_ref)
         else:
-            # offset from the end.
-            offset = -(len(pattern.patterns) - count)
+            return ExpressionOperationBinarySub(
+                ExpressionBuiltinLen(
+                    value=make_against(),
+                    source_ref=source_ref,
+                ),
+                makeConstantRefNode(
+                    constant=len(pattern.patterns) - count,
+                    source_ref=source_ref,
+                ),
+                source_ref=source_ref,
+            )
 
+    for count, seq_pattern in enumerate(pattern.patterns):
         if seq_pattern.__class__ is ast.MatchStar:
             star_pos = count
 
@@ -204,8 +204,8 @@ def _buildMatchSequence(provider, pattern, make_against, source_ref):
                 assert "!" not in variable_name, variable_name
 
                 # Last one
-                if star_pos == len(pattern.patterns):
-                    slice_value = slice(count)
+                if star_pos == len(pattern.patterns) - 1:
+                    slice_value = slice(star_pos, None)
                 else:
                     slice_value = slice(count, -(len(pattern.patterns) - (count + 1)))
 
@@ -233,9 +233,7 @@ def _buildMatchSequence(provider, pattern, make_against, source_ref):
                 # It's called before return, pylint: disable=cell-var-from-loop
                 make_against=lambda: ExpressionSubscriptLookup(
                     expression=make_against(),
-                    subscript=makeConstantRefNode(
-                        constant=offset, source_ref=source_ref
-                    ),
+                    subscript=makeOffsetNode(count),
                     source_ref=source_ref,
                 ),
                 source_ref=source_ref,
@@ -266,7 +264,7 @@ def _buildMatchMapping(provider, pattern, make_against, source_ref):
 
     for key, kwd_pattern in zip(pattern.keys, pattern.patterns):
         conditions.append(
-            ExpressionSubscriptCheck(
+            ExpressionMatchSubscriptCheck(
                 expression=make_against(),
                 subscript=buildNode(provider, key, source_ref),
                 source_ref=source_ref,
@@ -291,45 +289,80 @@ def _buildMatchMapping(provider, pattern, make_against, source_ref):
         if item_assignments:
             assignments.extend(item_assignments)
 
+    if pattern.rest:
+        assert type(pattern.rest) is str, pattern.rest
+
+        assignments.append(
+            StatementAssignmentVariableName(
+                provider=provider,
+                variable_name=pattern.rest,
+                source=ExpressionBuiltinDict(
+                    pos_arg=make_against(),
+                    pairs=(),
+                    source_ref=source_ref,
+                ),
+                source_ref=source_ref,
+            )
+        )
+
+        for key in pattern.keys:
+            assert type(key) is ast.Constant, key
+
+            assignments.append(
+                StatementDictOperationRemove(
+                    dict_arg=ExpressionVariableNameRef(
+                        provider=provider,
+                        variable_name=pattern.rest,
+                        source_ref=source_ref,
+                    ),
+                    key=buildNode(provider, key, source_ref),
+                    source_ref=source_ref,
+                )
+            )
+
     return conditions, assignments
 
 
 def _buildMatchClass(provider, pattern, make_against, source_ref):
-    cls_node = buildNode(provider, pattern.cls, source_ref)
-
-    assignments = []
+    # Slightly complicated, due to using an outline body and there is also
+    # keyword and positional arguments to deal with, pylint: disable=too-many-locals
 
-    conditions = [
-        ExpressionBuiltinIsinstance(
-            instance=make_against(),
-            classes=cls_node,
-            source_ref=source_ref,
-        )
-    ]
+    cls_node = buildNode(provider, pattern.cls, source_ref)
 
-    assert not (pattern.patterns and pattern.kwd_patterns), (
-        source_ref,
-        ast.dump(pattern),
-    )
     assert len(pattern.kwd_attrs) == len(pattern.kwd_patterns), (
         source_ref,
         ast.dump(pattern),
     )
 
-    for count, pos_pattern in enumerate(pattern.patterns):
-        # TODO: Not reusing Match args, is very wasteful for performance, but
-        # temporary variable handling is a bit of a problem in this so far,
-        # we should create an outline function for it, but match value args
-        # ought to be global probably, so they can be shared.
+    if len(pattern.kwd_attrs) + len(pattern.patterns) == 0:
+        conditions = [
+            ExpressionBuiltinIsinstance(
+                instance=make_against(),
+                classes=cls_node,
+                source_ref=source_ref,
+            )
+        ]
+        assignments = None
+
+        return conditions, assignments
 
+    class_conditions_list = []
+    class_assignments_list = []
+
+    outline_body = ExpressionOutlineBody(
+        provider=provider, name="match_class", source_ref=source_ref
+    )
+    tmp_match_args = outline_body.allocateTempVariable(
+        temp_scope=None, name="match_args", temp_type="PyObject *"
+    )
+
+    for count, pos_pattern in enumerate(pattern.patterns):
         # It's called before return, pylint: disable=cell-var-from-loop
         item_conditions, item_assignments = _buildMatch(
             provider=provider,
             make_against=lambda: ExpressionSubscriptLookup(
-                expression=ExpressionMatchArgs(
-                    expression=make_against(),
-                    max_allowed=len(pattern.patterns),
-                    source_ref=source_ref,
+                expression=ExpressionTempVariableRef(
+                    variable=tmp_match_args, source_ref=source_ref
                 ),
                 subscript=makeConstantRefNode(constant=count, source_ref=source_ref),
                 source_ref=source_ref,
@@ -338,38 +371,138 @@ def _buildMatchClass(provider, pattern, make_against, source_ref):
             source_ref=source_ref,
         )
 
-        if item_conditions:
-            conditions.extend(item_conditions)
+        class_conditions_list.append(item_conditions)
+        class_assignments_list.append(item_assignments)
 
-        if item_assignments:
-            assignments.extend(item_assignments)
+    for count, (key, kwd_pattern) in enumerate(
+        zip(pattern.kwd_attrs, pattern.kwd_patterns)
+    ):
+        # It's called before return, pylint: disable=cell-var-from-loop
+        item_conditions, item_assignments = _buildMatch(
+            provider=provider,
+            make_against=lambda: ExpressionSubscriptLookup(
+                expression=ExpressionTempVariableRef(
+                    variable=tmp_match_args, source_ref=source_ref
+                ),
+                subscript=makeConstantRefNode(
+                    constant=count + len(pattern.patterns), source_ref=source_ref
+                ),
+                source_ref=source_ref,
+            ),
+            pattern=kwd_pattern,
+            source_ref=source_ref,
+        )
 
-    for key, kwd_pattern in zip(pattern.kwd_attrs, pattern.kwd_patterns):
-        conditions.append(
+        item_conditions = list(item_conditions or ())
+
+        item_conditions.insert(
+            0,
             ExpressionAttributeCheck(
                 expression=make_against(),
                 attribute_name=key,
                 source_ref=source_ref,
+            ),
+        )
+
+        item_conditions = tuple(item_conditions)
+
+        class_conditions_list.append(item_conditions)
+        class_assignments_list.append(item_assignments)
+
+    statements = []
+
+    for count, (class_conditions, class_assignments) in enumerate(
+        zip(class_conditions_list, class_assignments_list)
+    ):
+        class_assignments = class_assignments or ()
+
+        if class_conditions:
+            class_conditions = makeAndNode(
+                values=class_conditions, source_ref=source_ref
+            )
+        else:
+            class_conditions = makeConstantRefNode(constant=True, source_ref=source_ref)
+
+        if count == len(class_assignments_list) - 1:
+            class_assignments = list(class_assignments or ())
+            class_assignments.append(
+                makeStatementReturnConstant(constant=True, source_ref=source_ref)
+            )
+
+        statements.append(
+            makeStatementConditional(
+                condition=class_conditions,
+                yes_branch=makeStatementsSequence(
+                    statements=class_assignments,
+                    allow_none=False,
+                    source_ref=source_ref,
+                ),
+                no_branch=makeStatementReturnConstant(
+                    constant=False, source_ref=source_ref
+                ),
+                source_ref=source_ref,
             )
         )
 
-        # It's called before return, pylint: disable=cell-var-from-loop
-        item_conditions, item_assignments = _buildMatch(
-            provider=provider,
-            make_against=lambda: makeExpressionAttributeLookup(
+    assert statements
+
+    statements = [
+        makeStatementAssignmentVariable(
+            variable=tmp_match_args,
+            source=ExpressionMatchArgs(
                 expression=make_against(),
-                attribute_name=key,
+                # TODO: Maybe use a temp variable instead for caching.
+                match_type=cls_node.makeClone(),
+                max_allowed=len(pattern.patterns),
+                keywords=pattern.kwd_attrs,
                 source_ref=source_ref,
             ),
-            pattern=kwd_pattern,
             source_ref=source_ref,
-        )
+        ),
+        makeStatementConditional(
+            condition=ExpressionComparisonIs(
+                ExpressionTempVariableRef(
+                    variable=tmp_match_args, source_ref=source_ref
+                ),
+                makeConstantRefNode(constant=None, source_ref=source_ref),
+                source_ref=source_ref,
+            ),
+            yes_branch=makeStatementsSequence(
+                statements=(
+                    makeStatementReleaseVariable(
+                        variable=tmp_match_args, source_ref=source_ref
+                    ),
+                    makeStatementReturnConstant(constant=False, source_ref=source_ref),
+                ),
+                allow_none=False,
+                source_ref=source_ref,
+            ),
+            no_branch=None,
+            source_ref=source_ref,
+        ),
+        makeTryFinallyReleaseStatement(
+            provider=provider,
+            tried=statements,
+            variables=(tmp_match_args,),
+            source_ref=source_ref,
+        ),
+    ]
 
-        if item_conditions:
-            conditions.extend(item_conditions)
+    body = makeStatementsSequence(
+        statements=statements, allow_none=False, source_ref=source_ref
+    )
 
-        if item_assignments:
-            assignments.extend(item_assignments)
+    outline_body.setChildBody(body)
+
+    conditions = [
+        ExpressionBuiltinIsinstance(
+            instance=make_against(),
+            classes=cls_node,
+            source_ref=source_ref,
+        ),
+        outline_body,
+    ]
+    assignments = None
 
     return conditions, assignments
 
@@ -533,7 +666,9 @@ def buildMatchNode(provider, node, source_ref):
     temp_scope = provider.allocateTempScope("match_statement")
 
     # The value matched against, must be released in the end.
-    tmp_subject = provider.allocateTempVariable(temp_scope, "subject")
+    tmp_subject = provider.allocateTempVariable(
+        temp_scope, "subject", temp_type="object"
+    )
 
     # Indicator variable, will end up with C bool type, and need not be released.
     tmp_indicator_variable = provider.allocateTempVariable(
@@ -624,20 +759,39 @@ def buildMatchNode(provider, node, source_ref):
 
     return makeStatementsSequence(
         statements=(
+            makeStatementAssignmentVariable(
+                variable=tmp_indicator_variable,
+                source=makeConstantRefNode(constant=False, source_ref=source_ref),
+                source_ref=source_ref,
+            ),
             makeStatementAssignmentVariable(
                 variable=tmp_subject,
                 source=subject_node,
                 source_ref=subject_node.getSourceReference(),
             ),
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=provider,
                 tried=case_statements,
-                final=makeStatementReleaseVariable(
-                    variable=tmp_indicator_variable, source_ref=source_ref
-                ),
+                variables=(tmp_indicator_variable,),
                 source_ref=source_ref,
             ),
         ),
         allow_none=False,
         source_ref=source_ref,
     )
+
+
+#     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/tree/ReformulationMultidist.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
+
+
 """ Multidist re-formulation. """
 
 import os
@@ -32,7 +18,9 @@ def _stripPythonSuffix(filename):
         return filename
 
 
-def createMultidistMainSourceCode(main_filenames):
+def createMultidistMainSourceCode():
+    main_filenames = getMainEntryPointFilenames()
+
     main_basenames = [
         _stripPythonSuffix(os.path.basename(main_filename))
         for main_filename in main_filenames
@@ -74,3 +62,19 @@ def locateMultidistModule(module_name):
         "py",
         "absolute",
     )
+
+
+#     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/tree/ReformulationNamespacePackages.py

@@ -1,28 +1,13 @@
-#     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
+
+
 """
-Namespace packages of Python3.3 or higher
+Namespace packages of Python3
 
 """
 
 import os
 
-from nuitka import Options
 from nuitka.nodes.AttributeNodes import makeExpressionAttributeLookup
 from nuitka.nodes.CallNodes import ExpressionCallNoKeywords
 from nuitka.nodes.ConstantRefNodes import makeConstantRefNode
@@ -38,8 +23,9 @@ from nuitka.nodes.ImportNodes import (
     makeExpressionImportModuleNameHard,
 )
 from nuitka.nodes.ModuleAttributeNodes import ExpressionModuleAttributeFileRef
-from nuitka.nodes.ModuleNodes import CompiledPythonPackage
+from nuitka.nodes.ModuleNodes import CompiledPythonNamespacePackage
 from nuitka.nodes.VariableNameNodes import StatementAssignmentVariableName
+from nuitka.Options import getFileReferenceMode
 from nuitka.PythonVersions import python_version
 
 from .TreeHelpers import makeStatementsSequenceFromStatement
@@ -68,7 +54,7 @@ def _makeCall(module_name, import_name, attribute_name, source_ref, *args):
 def getNameSpacePathExpression(package, source_ref):
     """Create the __path__ expression for a package."""
 
-    reference_mode = Options.getFileReferenceMode()
+    reference_mode = getFileReferenceMode()
 
     if reference_mode == "original":
         return makeConstantRefNode(
@@ -81,30 +67,33 @@ def getNameSpacePathExpression(package, source_ref):
             source_ref=source_ref,
         )
     else:
-        elements = [
-            ExpressionCallNoKeywords(
-                called=makeExpressionAttributeLookup(
-                    expression=makeExpressionImportModuleNameHard(
-                        module_name="os",
-                        import_name="path",
-                        module_guaranteed=True,
-                        source_ref=source_ref,
-                    ),
-                    attribute_name="dirname",
-                    source_ref=source_ref,
-                ),
-                args=makeExpressionMakeTuple(
-                    elements=(
-                        ExpressionModuleAttributeFileRef(
-                            variable=package.getVariableForReference("__file__"),
+        file_ref_node = ExpressionModuleAttributeFileRef(
+            variable=package.getVariableForReference("__file__"),
+            source_ref=source_ref,
+        )
+
+        if package.isCompiledPythonNamespacePackage():
+            elements = [file_ref_node]
+        else:
+            elements = [
+                ExpressionCallNoKeywords(
+                    called=makeExpressionAttributeLookup(
+                        expression=makeExpressionImportModuleNameHard(
+                            module_name="os",
+                            import_name="path",
+                            module_guaranteed=True,
                             source_ref=source_ref,
                         ),
+                        attribute_name="dirname",
+                        source_ref=source_ref,
+                    ),
+                    args=makeExpressionMakeTuple(
+                        elements=(file_ref_node,),
+                        source_ref=source_ref,
                     ),
                     source_ref=source_ref,
-                ),
-                source_ref=source_ref,
-            )
-        ]
+                )
+            ]
 
         if package.canHaveExternalImports():
             parts = package.getFullName().asString().split(".")
@@ -152,15 +141,19 @@ def createPathAssignment(package, source_ref):
 
 
 def createPython3NamespacePath(package, source_ref):
+    module_name = (
+        "_frozen_importlib" if python_version < 0x350 else "_frozen_importlib_external"
+    )
+
     return StatementAssignmentVariableName(
         provider=package,
         variable_name="__path__",
         source=ExpressionCallNoKeywords(
             called=ExpressionImportName(
                 module=makeExpressionImportModuleFixed(
-                    module_name="_frozen_importlib"
-                    if python_version < 0x350
-                    else "_frozen_importlib_external",
+                    using_module_name=package.getFullName(),
+                    module_name=module_name,
+                    value_name=module_name,
                     source_ref=source_ref,
                 ),
                 import_name="_NamespacePath",
@@ -187,12 +180,12 @@ def createPython3NamespacePath(package, source_ref):
 
 
 def createNamespacePackage(module_name, reason, is_top, source_ref):
-    package = CompiledPythonPackage(
+    package = CompiledPythonNamespacePackage(
         module_name=module_name,
         reason=reason,
         is_top=is_top,
         mode="compiled",
-        future_spec=FutureSpec(),
+        future_spec=FutureSpec(use_annotations=False),
         source_ref=source_ref,
     )
 
@@ -206,3 +199,19 @@ def createNamespacePackage(module_name, reason, is_top, source_ref):
     completeVariableClosures(package)
 
     return package
+
+
+#     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.