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

nuitka/nodes/TensorflowNodes.py

@@ -0,0 +1,38 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes that represent tensorflow functions
+
+"""
+
+from nuitka.HardImportRegistry import addModuleDynamicHard
+
+from .HardImportNodesGenerated import ExpressionTensorflowFunctionCallBase
+
+addModuleDynamicHard(module_name="tensorflow")
+
+
+class ExpressionTensorflowFunctionCall(ExpressionTensorflowFunctionCallBase):
+    kind = "EXPRESSION_TENSORFLOW_FUNCTION_CALL"
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        # TODO: The node generation should allow for this to not be necessary
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, 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/nodes/TryNodes.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
+
+
 """ Nodes for try/except/finally handling.
 
 This is the unified low level solution to trying a block, and executing code
@@ -515,3 +501,19 @@ class StatementTry(StatementTryBase):
     @staticmethod
     def getStatementNiceName():
         return "tried block statement"
+
+
+#     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/nodes/TypeMatchNodes.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
+
+
 """Dedicated nodes used for the 3.10 matching
 
 Not usable with older Python as it depends on type flags not present.
@@ -61,3 +47,19 @@ class ExpressionMatchTypeCheckMapping(ExpressionMatchTypeCheckBase):
         # shape, this could evaluate to statically True/False and then will allow
         # optimization into match branches.
         return self, None, 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/nodes/TypeNodes.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
+
+
 """ The type nodes.
 
 These ones deal with types and they are great for optimization. We need to know
@@ -37,6 +23,7 @@ from .ChildrenHavingMixins import (
     ChildrenExpressionBuiltinSuper0Mixin,
     ChildrenExpressionBuiltinSuper1Mixin,
     ChildrenExpressionBuiltinSuper2Mixin,
+    ChildrenExpressionTypeAliasMixin,
     ChildrenHavingInstanceClassesMixin,
 )
 from .ExpressionBases import ExpressionBase, ExpressionBuiltinSingleArgBase
@@ -338,3 +325,39 @@ class ExpressionSubtypeCheck(
         # TODO: This needs to check the MRO and can assume the type nature, since it's only coming
         # from re-formulations that guarantee that.
         return self, None, None
+
+
+class ExpressionTypeAlias(ChildrenExpressionTypeAliasMixin, ExpressionBase):
+    kind = "EXPRESSION_TYPE_ALIAS"
+
+    named_children = ("type_params|tuple", "compute_value")
+
+    def __init__(self, type_params, compute_value, source_ref):
+        ChildrenExpressionTypeAliasMixin.__init__(
+            self, type_params=type_params, compute_value=compute_value
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        return self, None, None
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
+#     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/nodes/VariableAssignNodes.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
+
+
 """ Assignment related nodes.
 
 The most simple assignment statement ``a = b`` is what we have here. All others
@@ -179,19 +165,7 @@ class StatementAssignmentVariableMixin(object):
         # is such a code for the type shape.
         return True
 
-    def _transferState(self, result):
-        self.variable_trace.assign_node = result
-        result.variable_trace = self.variable_trace
-        self.variable_trace = None
-
-    def _considerSpecialization(self, old_source):
-        # Specialize if possible, might have become that way only recently.
-        # return driven, pylint: disable=too-many-return-statements
-        source = self.subnode_source
-
-        if source is old_source:
-            return self, None, None
-
+    def _considerSpecialization(self, old_source, source):
         if source.isCompileTimeConstant():
             result = makeStatementAssignmentVariableConstant(
                 source=source,
@@ -201,8 +175,6 @@ class StatementAssignmentVariableMixin(object):
                 source_ref=self.source_ref,
             )
 
-            self._transferState(result)
-
             return (
                 result,
                 "new_statements",
@@ -218,8 +190,6 @@ class StatementAssignmentVariableMixin(object):
                 source_ref=self.source_ref,
             )
 
-            self._transferState(result)
-
             return (
                 result,
                 "new_statements",
@@ -234,8 +204,6 @@ class StatementAssignmentVariableMixin(object):
                 source_ref=self.source_ref,
             )
 
-            self._transferState(result)
-
             return (
                 result,
                 "new_statements",
@@ -250,8 +218,6 @@ class StatementAssignmentVariableMixin(object):
                 source_ref=self.source_ref,
             )
 
-            self._transferState(result)
-
             return (
                 result,
                 "new_statements",
@@ -266,8 +232,6 @@ class StatementAssignmentVariableMixin(object):
                 source_ref=self.source_ref,
             )
 
-            self._transferState(result)
-
             return (
                 result,
                 "new_statements",
@@ -284,6 +248,10 @@ class StatementAssignmentVariableMixin(object):
     def hasVeryTrustedValue(self):
         """Does this assignment node have a very trusted value."""
 
+    @abstractmethod
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
+        """Set the value trace for the assignment form."""
+
 
 class StatementAssignmentVariableGeneric(
     StatementAssignmentVariableMixin, StatementAssignmentVariableGenericBase
@@ -403,17 +371,26 @@ Removed assignment of %s from itself which is known to be defined."""
                     % variable.getDescription(),
                 )
 
+        if source is old_source:
+            result = self, None, None
+        else:
+            result = self._considerSpecialization(old_source, source)
+            result[0].parent = self.parent
+
+        result[0].computeStatementAssignmentTraceUpdate(trace_collection, source)
+
+        return result
+
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
         # Set-up the trace to the trace collection, so future references will
         # find this assignment.
         self.variable_trace = trace_collection.onVariableSet(
-            variable=variable, version=self.variable_version, assign_node=self
+            variable=self.variable, version=self.variable_version, assign_node=self
         )
 
         # TODO: Determine from future use of assigned variable, if this is needed at all.
         trace_collection.removeKnowledge(source)
 
-        return self._considerSpecialization(old_source)
-
     def hasVeryTrustedValue(self):
         """Does this assignment node have a very trusted value."""
         return self.subnode_source.hasVeryTrustedValue()
@@ -486,7 +463,7 @@ class StatementAssignmentVariableIterator(
         self.temp_scope = provider.allocateTempScope("iterator_access")
 
         self.tmp_iterated_variable = provider.allocateTempVariable(
-            temp_scope=self.temp_scope, name="iterated_value"
+            temp_scope=self.temp_scope, name="iterated_value", temp_type="object"
         )
 
         reference_iterated = ExpressionTempVariableRef(
@@ -499,18 +476,16 @@ class StatementAssignmentVariableIterator(
         assign_iterated = makeStatementAssignmentVariable(
             source=iterated_value,
             variable=self.tmp_iterated_variable,
-            variable_version=None,
             source_ref=iterated_value.source_ref,
         )
 
         self.tmp_iteration_count_variable = provider.allocateTempVariable(
-            temp_scope=self.temp_scope, name="iteration_count"
+            temp_scope=self.temp_scope, name="iteration_count", temp_type="object"
         )
 
         assign_iteration_count = makeStatementAssignmentVariable(
             source=makeConstantRefNode(constant=0, source_ref=self.source_ref),
             variable=self.tmp_iteration_count_variable,
-            variable_version=None,
             source_ref=iterated_value.source_ref,
         )
 
@@ -530,7 +505,7 @@ class StatementAssignmentVariableIterator(
 
         # For use when the "next" is replaced.
         self.tmp_iteration_next_variable = provider.allocateTempVariable(
-            temp_scope=self.temp_scope, name="next_value"
+            temp_scope=self.temp_scope, name="next_value", temp_type="object"
         )
 
         result = makeStatementsSequenceReplacementNode(
@@ -595,12 +570,18 @@ Assignment raises exception in assigned value, removed assignment.""",
 
         # Set-up the trace to the trace collection, so future references will
         # find this assignment.
+        # Note: Keep this aligned with computeStatementAssignmentTraceUpdate
         self.variable_trace = trace_collection.onVariableSet(
             variable=variable, version=self.variable_version, assign_node=self
         )
 
         return self, None, None
 
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
+        self.variable_trace = trace_collection.onVariableSet(
+            variable=self.variable, version=self.variable_version, assign_node=self
+        )
+
     @staticmethod
     def hasVeryTrustedValue():
         """Does this assignment node have a very trusted value."""
@@ -643,6 +624,7 @@ class StatementAssignmentVariableConstantMutable(
 
         # Set-up the trace to the trace collection, so future references will
         # find this assignment.
+        # Note: Keep this aligned with computeStatementAssignmentTraceUpdate
         self.variable_trace = trace_collection.onVariableSet(
             variable=variable, version=self.variable_version, assign_node=self
         )
@@ -683,6 +665,11 @@ class StatementAssignmentVariableConstantMutable(
 
         return self, None, None
 
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
+        self.variable_trace = trace_collection.onVariableSet(
+            variable=self.variable, version=self.variable_version, assign_node=self
+        )
+
     @staticmethod
     def hasVeryTrustedValue():
         """Does this assignment node have a very trusted value."""
@@ -786,12 +773,18 @@ class StatementAssignmentVariableConstantImmutable(
                         % self.getVariableName(),
                     )
 
+        # Note: Keep this aligned with computeStatementAssignmentTraceUpdate
         self.variable_trace = trace_collection.onVariableSetToUnescapableValue(
             variable=variable, version=self.variable_version, assign_node=self
         )
 
         return self, None, None
 
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
+        self.variable_trace = trace_collection.onVariableSetToUnescapableValue(
+            variable=self.variable, version=self.variable_version, assign_node=self
+        )
+
     @staticmethod
     def hasVeryTrustedValue():
         """Does this assignment node have a very trusted value."""
@@ -805,7 +798,7 @@ class StatementAssignmentVariableConstantMutableTrusted(
 
     @staticmethod
     def hasVeryTrustedValue():
-        return True
+        return False
 
 
 class StatementAssignmentVariableConstantImmutableTrusted(
@@ -869,12 +862,18 @@ class StatementAssignmentVariableHardValue(
 Assignment raises exception in assigned value, removed assignment.""",
             )
 
+        # Note: Keep this aligned with computeStatementAssignmentTraceUpdate
         self.variable_trace = trace_collection.onVariableSetToVeryTrustedValue(
             variable=variable, version=self.variable_version, assign_node=self
         )
 
         return self, None, None
 
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
+        self.variable_trace = trace_collection.onVariableSetToVeryTrustedValue(
+            variable=self.variable, version=self.variable_version, assign_node=self
+        )
+
     @staticmethod
     def hasVeryTrustedValue():
         """Does this assignment node have a very trusted value."""
@@ -915,6 +914,11 @@ class StatementAssignmentVariableFromVariable(
         old_source = self.subnode_source
         variable = self.variable
 
+        # Assigning from and to the same variable, can be optimized away
+        # immediately, there is no point in doing it. Exceptions are of course
+        # module variables that collide with built-in names. TODO: In
+        # specialization this could be considered right away as its own node
+        # type, waiting for it to compute like this.
         if not variable.isModuleVariable() and old_source.getVariable() is variable:
             # A variable access that has a side effect, must be preserved,
             # so it can e.g. raise an exception, otherwise we can be fully
@@ -924,8 +928,10 @@ class StatementAssignmentVariableFromVariable(
                     expression=old_source, node=self
                 )
 
+                result = trace_collection.onStatement(result)
+
                 return (
-                    result.computeStatementsSequence(trace_collection),
+                    result,
                     "new_statements",
                     """\
 Lowered assignment of %s from itself to mere access of it."""
@@ -943,20 +949,47 @@ Removed assignment of %s from itself which is known to be defined."""
         # Let assignment source may re-compute first.
         source = trace_collection.onExpression(self.subnode_source)
 
-        # Assigning from and to the same variable, can be optimized away
-        # immediately, there is no point in doing it. Exceptions are of course
-        # module variables that collide with built-in names.
+        if source is old_source:
+            result = self, None, None
+        else:
+            if source.willRaiseAnyException():
+                result = makeStatementExpressionOnlyReplacementNode(
+                    expression=source, node=self
+                )
 
-        # Set-up the trace to the trace collection, so future references will
-        # find this assignment.
-        self.variable_trace = trace_collection.onVariableSet(
-            variable=variable, version=self.variable_version, assign_node=self
-        )
+                return (
+                    result,
+                    "new_raise",
+                    """\
+Assignment raises exception in assigned variable access, removed assignment.""",
+                )
 
-        # TODO: Determine from future use of assigned variable, if this is needed at all.
-        trace_collection.removeKnowledge(source)
+            result = self._considerSpecialization(old_source, source)
+            result[0].parent = self.parent
 
-        return self._considerSpecialization(old_source)
+        result[0].computeStatementAssignmentTraceUpdate(trace_collection, source)
+
+        return result
+
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
+        if source.isExpressionVariableRef():
+            self.variable_trace = trace_collection.onVariableSetAliasing(
+                variable=self.variable,
+                version=self.variable_version,
+                assign_node=self,
+                source=source,
+            )
+        else:
+            # Set-up the trace to the trace collection, so future references will
+            # find this assignment. TODO: We should for non-variables make sure we do
+            # always specialize, since this is no longer a variable once it was
+            # resolved.
+            self.variable_trace = trace_collection.onVariableSet(
+                variable=self.variable, version=self.variable_version, assign_node=self
+            )
+
+            # TODO: Determine from future use of assigned variable, if this is needed at all.
+            trace_collection.removeKnowledge(source)
 
     @staticmethod
     def hasVeryTrustedValue():
@@ -1013,17 +1046,26 @@ Removed assignment of %s from itself which is known to be defined."""
         # Let assignment source may re-compute first.
         source = trace_collection.onExpression(self.subnode_source)
 
+        if source is old_source:
+            result = self, None, None
+        else:
+            result = self._considerSpecialization(old_source, source)
+            result[0].parent = self.parent
+
+        result[0].computeStatementAssignmentTraceUpdate(trace_collection, source)
+
+        return result
+
+    def computeStatementAssignmentTraceUpdate(self, trace_collection, source):
         # Set-up the trace to the trace collection, so future references will
         # find this assignment.
         self.variable_trace = trace_collection.onVariableSet(
-            variable=variable, version=self.variable_version, assign_node=self
+            variable=self.variable, version=self.variable_version, assign_node=self
         )
 
         # TODO: Determine from future use of assigned variable, if this is needed at all.
         trace_collection.removeKnowledge(source)
 
-        return self._considerSpecialization(old_source)
-
     @staticmethod
     def hasVeryTrustedValue():
         """Does this assignment node have a very trusted value."""
@@ -1116,3 +1158,19 @@ def makeStatementAssignmentVariable(
             variable_version=variable_version,
             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/nodes/VariableDelNodes.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
+
+
 """ Nodes for variable deletion
 
 These refer to resolved variable objects.
@@ -316,3 +302,19 @@ def makeStatementDelVariable(variable, tolerant, source_ref, version=None):
         return StatementDelVariableIntolerant(
             variable=variable, version=version, 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/nodes/VariableNameNodes.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
+
+
 """ Nodes for named variable reference, assignment, and deletion
 
 x = ...
@@ -149,3 +135,19 @@ class ExpressionVariableLocalNameRef(ExpressionVariableNameRef):
     @staticmethod
     def needsFallback():
         return False
+
+
+#     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.