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

nuitka/nodes/ExpressionBasesGenerated.py

@@ -1,33 +1,34 @@
-#     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
+
+
 # We are not avoiding these in generated code at all
-# pylint: disable=I0021,too-many-lines
-# pylint: disable=I0021,line-too-long
-# pylint: disable=I0021,too-many-instance-attributes
-# pylint: disable=I0021,too-many-return-statements
+# pylint: disable=I0021,line-too-long,too-many-instance-attributes,too-many-lines
+# pylint: disable=I0021,too-many-arguments,too-many-return-statements,too-many-statements
 
 
 """Children having expression bases
 
 WARNING, this code is GENERATED. Modify the template ChildrenHavingMixin.py.j2 instead!
 
-spell-checker: ignore append capitalize casefold center clear copy count decode encode endswith expandtabs extend find format formatmap fromkeys get haskey index insert isalnum isalpha isascii isdecimal isdigit isidentifier islower isnumeric isprintable isspace istitle isupper items iteritems iterkeys itervalues join keys ljust lower lstrip maketrans partition pop popitem prepare remove replace reverse rfind rindex rjust rpartition rsplit rstrip setdefault sort split splitlines startswith strip swapcase title translate update upper values viewitems viewkeys viewvalues zfill
-spell-checker: ignore args chars count default delete encoding end errors fillchar index item iterable keepends key kwargs maxsplit new old pairs prefix sep start stop sub suffix table tabsize value width
+spell-checker: ignore __prepare__ append args autograph capitalize casefold center chars
+spell-checker: ignore clear copy count decode default delete dist distribution_name encode
+spell-checker: ignore encoding end endswith errors exit_code expandtabs
+spell-checker: ignore experimental_attributes experimental_autograph_options
+spell-checker: ignore experimental_compile experimental_follow_type_hints
+spell-checker: ignore experimental_implements experimental_relax_shapes extend fillchar
+spell-checker: ignore find format format_map formatmap fromkeys func get group handle
+spell-checker: ignore has_key haskey index input_signature insert isalnum isalpha isascii
+spell-checker: ignore isdecimal isdigit isidentifier islower isnumeric isprintable isspace
+spell-checker: ignore istitle isupper item items iterable iteritems iterkeys itervalues
+spell-checker: ignore jit_compile join keepends key keys kwargs ljust lower lstrip
+spell-checker: ignore maketrans maxsplit mode name new old p package
+spell-checker: ignore package_or_requirement pairs partition path pop popitem prefix
+spell-checker: ignore prepare reduce_retracing remove replace resource resource_name
+spell-checker: ignore reverse rfind rindex rjust rpartition rsplit rstrip s sep setdefault
+spell-checker: ignore sort split splitlines start startswith stop strip sub suffix
+spell-checker: ignore swapcase table tabsize title translate update upper use_errno
+spell-checker: ignore use_last_error value values viewitems viewkeys viewvalues width
+spell-checker: ignore winmode zfill
 """
 
 
@@ -79,6 +80,80 @@ ExpressionImportlibMetadataBackportEntryPointValueRefBase = (
 ExpressionImportlibMetadataEntryPointValueRefBase = NoChildHavingFinalNoRaiseMixin
 
 
+class NoChildHavingFinalNoRaiseNameMixin(ExpressionBase):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionTypeVariable
+
+    def __init__(self, name, source_ref):
+        self.name = name
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def getDetails(self):
+        return {
+            "name": self.name,
+        }
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return ()
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return ()
+
+    def replaceChild(self, old_node, new_node):
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {}
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        return self, None, None
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+    @staticmethod
+    def mayRaiseException(exception_type):
+        return False
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+
+# Assign the names that are easier to import with a stable name.
+ExpressionTypeVariableBase = NoChildHavingFinalNoRaiseNameMixin
+
+
 class ChildHavingArgsTupleFinalNoRaiseMixin(ExpressionBase):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
@@ -199,14 +274,218 @@ class ChildHavingArgsTupleFinalNoRaiseMixin(ExpressionBase):
 ExpressionBuiltinMakeExceptionBase = ChildHavingArgsTupleFinalNoRaiseMixin
 
 
-class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(ExpressionBase):
+class ChildrenHavingArgsTupleNameOptionalObjOptionalFinalNoRaiseForRaiseMixin(
+    ExpressionBase
+):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionBuiltinMakeExceptionAttributeError
+
+    def __init__(self, args, name, obj, for_raise, source_ref):
+        assert type(args) is tuple
+
+        for val in args:
+            val.parent = self
+
+        self.subnode_args = args
+
+        if name is not None:
+            name.parent = self
+
+        self.subnode_name = name
+
+        if obj is not None:
+            obj.parent = self
+
+        self.subnode_obj = obj
+
+        self.for_raise = for_raise
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def getDetails(self):
+        return {
+            "for_raise": self.for_raise,
+        }
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        result.extend(self.subnode_args)
+        value = self.subnode_name
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_obj
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("args", self.subnode_args),
+            ("name", self.subnode_name),
+            ("obj", self.subnode_obj),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_args
+        if old_node in value:
+            if new_node is not None:
+                new_node.parent = self
+
+                self.subnode_args = tuple(
+                    (val if val is not old_node else new_node) for val in value
+                )
+            else:
+                self.subnode_args = tuple(val for val in value if val is not old_node)
+
+            return
+
+        value = self.subnode_name
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_name = new_node
+
+            return
+
+        value = self.subnode_obj
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_obj = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "args": tuple(v.makeClone() for v in self.subnode_args),
+            "name": (
+                self.subnode_name.makeClone() if self.subnode_name is not None else None
+            ),
+            "obj": (
+                self.subnode_obj.makeClone() if self.subnode_obj is not None else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        for c in self.subnode_args:
+            c.finalize()
+        del self.subnode_args
+        if self.subnode_name is not None:
+            self.subnode_name.finalize()
+        del self.subnode_name
+        if self.subnode_obj is not None:
+            self.subnode_obj.finalize()
+        del self.subnode_obj
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        return self, None, None
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+    def mayRaiseException(self, exception_type):
+        return (
+            any(value.mayRaiseException(exception_type) for value in self.subnode_args)
+            or (
+                self.subnode_name is not None
+                and self.subnode_name.mayRaiseException(exception_type)
+            )
+            or (
+                self.subnode_obj is not None
+                and self.subnode_obj.mayRaiseException(exception_type)
+            )
+        )
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        for element in self.subnode_args:
+            element.collectVariableAccesses(emit_read, emit_write)
+        subnode_name = self.subnode_name
+
+        if subnode_name is not None:
+            self.subnode_name.collectVariableAccesses(emit_read, emit_write)
+        subnode_obj = self.subnode_obj
+
+        if subnode_obj is not None:
+            self.subnode_obj.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ExpressionBuiltinMakeExceptionAttributeErrorBase = (
+    ChildrenHavingArgsTupleNameOptionalObjOptionalFinalNoRaiseForRaiseMixin
+)
+
+
+class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseForRaiseMixin(
+    ExpressionBase
+):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
     # This is generated for use in
     #   ExpressionBuiltinMakeExceptionImportError
+    #   ExpressionBuiltinMakeExceptionModuleNotFoundError
 
-    def __init__(self, args, name, path, source_ref):
+    def __init__(self, args, name, path, for_raise, source_ref):
         assert type(args) is tuple
 
         for val in args:
@@ -224,8 +503,15 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
         self.subnode_path = path
 
+        self.for_raise = for_raise
+
         ExpressionBase.__init__(self, source_ref)
 
+    def getDetails(self):
+        return {
+            "for_raise": self.for_raise,
+        }
+
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
@@ -297,12 +583,12 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
         values = {
             "args": tuple(v.makeClone() for v in self.subnode_args),
-            "name": self.subnode_name.makeClone()
-            if self.subnode_name is not None
-            else None,
-            "path": self.subnode_path.makeClone()
-            if self.subnode_path is not None
-            else None,
+            "name": (
+                self.subnode_name.makeClone() if self.subnode_name is not None else None
+            ),
+            "path": (
+                self.subnode_path.makeClone() if self.subnode_path is not None else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -387,7 +673,10 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
 # Assign the names that are easier to import with a stable name.
 ExpressionBuiltinMakeExceptionImportErrorBase = (
-    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
+    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseForRaiseMixin
+)
+ExpressionBuiltinMakeExceptionModuleNotFoundErrorBase = (
+    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseForRaiseMixin
 )
 
 
@@ -1645,9 +1934,11 @@ class ChildHavingPromptOptionalFinalMixin(ExpressionBase):
         """
 
         values = {
-            "prompt": self.subnode_prompt.makeClone()
-            if self.subnode_prompt is not None
-            else None,
+            "prompt": (
+                self.subnode_prompt.makeClone()
+                if self.subnode_prompt is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -1795,3 +2086,18 @@ class ChildHavingValueFinalNoRaiseMixin(ExpressionBase):
 # Assign the names that are easier to import with a stable name.
 ExpressionBuiltinClassmethodBase = ChildHavingValueFinalNoRaiseMixin
 ExpressionBuiltinStaticmethodBase = ChildHavingValueFinalNoRaiseMixin
+
+#     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/ExpressionShapeMixins.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
+
+
 """Mixins for expressions that have specific shapes.
 
 Providing derived implementation, such that e.g. for a given shape, shortcuts
@@ -882,3 +868,19 @@ else:
         @staticmethod
         def getTypeShape():
             return tshape_str_or_unicode_derived
+
+
+#     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/FrameNodes.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
+
+
 """ Frame nodes.
 
 The frame attaches name and other frame properties to a scope, where it is
@@ -32,7 +18,8 @@ from nuitka.PythonVersions import python_version
 
 from .CodeObjectSpecs import CodeObjectSpec
 from .FutureSpecs import fromFlags
-from .StatementNodes import StatementsSequence
+from .StatementBasesGenerated import StatementsSequenceBase
+from .StatementNodes import StatementsSequenceMixin
 
 
 def checkFrameStatements(value):
@@ -47,30 +34,39 @@ def checkFrameStatements(value):
     return tuple(value)
 
 
-class StatementsFrameBase(StatementsSequence):
+class StatementsFrameBase(StatementsSequenceMixin, StatementsSequenceBase):
     checkers = {"statements": checkFrameStatements}
 
     __slots__ = ("code_object", "needs_frame_exception_preserve")
 
+    named_children = ("statements|tuple+setter",)
+
     def __init__(self, statements, code_object, source_ref):
-        StatementsSequence.__init__(self, statements=statements, source_ref=source_ref)
+        StatementsSequenceBase.__init__(
+            self, statements=statements, source_ref=source_ref
+        )
 
         self.code_object = code_object
 
         self.needs_frame_exception_preserve = False
 
-    def isStatementsFrame(self):
+    @staticmethod
+    def isStatementsFrame():
+        return True
+
+    @staticmethod
+    def isStatementsSequence():
         return True
 
     def getDetails(self):
         result = {"code_object": self.code_object}
 
-        result.update(StatementsSequence.getDetails(self))
+        result.update(StatementsSequenceBase.getDetails(self))
 
         return result
 
     def getDetailsForDisplay(self):
-        result = StatementsSequence.getDetails(self)
+        result = StatementsSequenceBase.getDetails(self)
         result.update()
 
         result.update(self.code_object.getDetails())
@@ -153,7 +149,7 @@ class StatementsFrameBase(StatementsSequence):
         self.code_object.setFlagIsOptimizedValue(is_optimized)
 
         new_locals = not provider.isCompiledPythonModule() and (
-            python_version < 0x340
+            python_version < 0x300
             or (
                 not provider.isExpressionClassBodyBase()
                 and not provider.isUnoptimized()
@@ -188,10 +184,7 @@ class StatementsFrameBase(StatementsSequence):
                 new_statement = trace_collection.onStatement(statement=statement)
 
             if new_statement is not None:
-                if (
-                    new_statement.isStatementsSequence()
-                    and not new_statement.isStatementsFrame()
-                ):
+                if new_statement.isStatementsSequenceButNotFrame():
                     new_statements.extend(new_statement.subnode_statements)
                 else:
                     new_statements.append(new_statement)
@@ -279,6 +272,10 @@ class StatementsFrameBase(StatementsSequence):
 
         return None
 
+    @staticmethod
+    def getStatementNiceName():
+        return "frame statements sequence"
+
 
 class StatementsFrameModule(StatementsFrameBase):
     kind = "STATEMENTS_FRAME_MODULE"
@@ -386,3 +383,19 @@ class StatementsFrameAsyncgen(StatementsFrameGeneratorBase):
     @staticmethod
     def getStructureMember():
         return "asyncgen"
+
+
+#     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/FunctionAttributeNodes.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
+
+
 """ Function attribute nodes
 
 The represent special values of the modules. The "__qualname__" value node
@@ -98,3 +84,19 @@ class ExpressionFunctionErrorStr(
     def computeExpression(self, trace_collection):
         # TODO: Could compile time compute these for concrete functions.
         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.