Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/nodes/BuiltinAllNodes.py

@@ -0,0 +1,115 @@
+#     Copyright 2025, Batakrishna Sahu, mailto:<Batakrishna.Sahu@suiit.ac.in> find license text at end of file
+
+
+""" Node for the calls to the 'all' built-in.
+
+"""
+
+from nuitka.specs import BuiltinParameterSpecs
+
+from .ExpressionBases import ExpressionBuiltinSingleArgBase
+from .ExpressionShapeMixins import ExpressionBoolShapeExactMixin
+from .NodeMakingHelpers import (
+    makeConstantReplacementNode,
+    makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue,
+    wrapExpressionWithNodeSideEffects,
+)
+from .shapes.BuiltinTypeShapes import tshape_str, tshape_unicode
+
+
+class ExpressionBuiltinAll(
+    ExpressionBoolShapeExactMixin, ExpressionBuiltinSingleArgBase
+):
+    """Builtin All Node class.
+
+    Args:
+        ExpressionBase: 'all - expression'
+
+    Returns:
+        Node that represents built-in 'all' call.
+
+    """
+
+    kind = "EXPRESSION_BUILTIN_ALL"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_all_spec
+
+    def computeExpression(self, trace_collection):
+        value = self.subnode_value
+        shape = value.getTypeShape()
+        if shape.hasShapeSlotIter() is False:
+            # An exception is raised.
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue(
+                template="'%s' object is not iterable",
+                operation="all",
+                original_node=value,
+                value_node=value,
+            )
+
+        if shape in (tshape_str, tshape_unicode):
+            return (
+                wrapExpressionWithNodeSideEffects(
+                    new_node=makeConstantReplacementNode(
+                        constant=True, node=self, user_provided=False
+                    ),
+                    old_node=value,
+                ),
+                "new_constant",
+                "Predicted truth value of built-in 'all' string type argument",
+            )
+
+        iteration_handle = value.getIterationHandle()
+
+        if iteration_handle is not None:
+            all_true = iteration_handle.getAllElementTruthValue()
+
+            if all_true is not None:
+                result = wrapExpressionWithNodeSideEffects(
+                    new_node=makeConstantReplacementNode(
+                        constant=all_true, node=self, user_provided=False
+                    ),
+                    old_node=value,
+                )
+
+                return (
+                    result,
+                    "new_constant",
+                    "Predicted truth value of built-in 'all' argument",
+                )
+
+        self.onContentEscapes(trace_collection)
+
+        # All code could be run, note that.
+        trace_collection.onControlFlowEscape(self)
+
+        # All exception may be raised.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        """returns boolean True if try/except/finally is needed else False"""
+        value = self.subnode_value
+
+        if value.mayRaiseException(exception_type):
+            return True
+
+        return not value.getTypeShape().hasShapeSlotIter()
+
+
+#     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/BuiltinAnyNodes.py

@@ -0,0 +1,124 @@
+#     Copyright 2025, Batakrishna Sahu, mailto:<Batakrishna.Sahu@suiit.ac.in> find license text at end of file
+
+
+""" Node for the calls to the 'any' built-in.
+
+"""
+
+from nuitka.specs import BuiltinParameterSpecs
+
+from .ExpressionBases import ExpressionBuiltinSingleArgBase
+from .ExpressionShapeMixins import ExpressionBoolShapeExactMixin
+from .NodeMakingHelpers import (
+    makeConstantReplacementNode,
+    makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue,
+    wrapExpressionWithNodeSideEffects,
+)
+
+
+class ExpressionBuiltinAny(
+    ExpressionBoolShapeExactMixin, ExpressionBuiltinSingleArgBase
+):
+    """Builtin Any Node class.
+
+    Node that represents built-in 'any' call.
+
+    """
+
+    kind = "EXPRESSION_BUILTIN_ANY"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_any_spec
+
+    def computeExpression(self, trace_collection):
+        value = self.subnode_value
+        shape = value.getTypeShape()
+        if shape.hasShapeSlotIter() is False:
+            # An exception is raised.
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue(
+                template="'%s' object is not iterable",
+                operation="any",
+                original_node=value,
+                value_node=value,
+            )
+
+        iteration_handle = value.getIterationHandle()
+
+        if iteration_handle is not None:
+            all_false = True
+            count = 0
+            while True:
+                truth_value = iteration_handle.getNextValueTruth()
+                if truth_value is StopIteration:
+                    break
+                if count > 256:
+                    all_false = False
+                    break
+
+                if truth_value is True:
+                    result = wrapExpressionWithNodeSideEffects(
+                        new_node=makeConstantReplacementNode(
+                            constant=True, node=self, user_provided=False
+                        ),
+                        old_node=value,
+                    )
+
+                    return (
+                        result,
+                        "new_constant",
+                        "Predicted truth value of built-in any argument",
+                    )
+                elif truth_value is None:
+                    all_false = False
+
+                count += 1
+
+            if all_false is True:
+                result = wrapExpressionWithNodeSideEffects(
+                    new_node=makeConstantReplacementNode(
+                        constant=False, node=self, user_provided=False
+                    ),
+                    old_node=value,
+                )
+
+                return (
+                    result,
+                    "new_constant",
+                    "Predicted truth value of built-in any argument",
+                )
+
+        self.onContentEscapes(trace_collection)
+
+        # Any code could be run, note that.
+        trace_collection.onControlFlowEscape(self)
+
+        # Any exception may be raised.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        """returns boolean True if exception is raised else False"""
+        value = self.subnode_value
+
+        if value.mayRaiseException(exception_type):
+            return True
+
+        return not value.getTypeShape().hasShapeSlotIter()
+
+
+#     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/BuiltinComplexNodes.py

@@ -0,0 +1,83 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Node for the calls to the 'complex' built-in.
+
+"""
+
+from nuitka.specs import BuiltinParameterSpecs
+
+from .ChildrenHavingMixins import (
+    ChildHavingValueMixin,
+    ChildrenHavingRealOptionalImagMixin,
+)
+from .ExpressionBases import (
+    ExpressionBase,
+    ExpressionSpecBasedComputationMixin,
+)
+from .ExpressionShapeMixins import ExpressionComplexShapeExactMixin
+
+
+class ExpressionBuiltinComplex1(
+    ExpressionComplexShapeExactMixin, ChildHavingValueMixin, ExpressionBase
+):
+    kind = "EXPRESSION_BUILTIN_COMPLEX1"
+
+    named_children = ("value",)
+
+    def __init__(self, value, source_ref):
+        ChildHavingValueMixin.__init__(self, value=value)
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        value = self.subnode_value
+
+        return value.computeExpressionComplex(
+            complex_node=self, trace_collection=trace_collection
+        )
+
+
+class ExpressionBuiltinComplex2(
+    ExpressionSpecBasedComputationMixin,
+    ExpressionComplexShapeExactMixin,
+    ChildrenHavingRealOptionalImagMixin,
+    ExpressionBase,
+):
+    kind = "EXPRESSION_BUILTIN_COMPLEX2"
+
+    named_children = ("real|optional", "imag")
+
+    builtin_spec = BuiltinParameterSpecs.builtin_complex_spec
+
+    def __init__(self, real, imag, source_ref):
+        ChildrenHavingRealOptionalImagMixin.__init__(
+            self,
+            real=real,
+            imag=imag,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        given_values = self.subnode_real, self.subnode_imag
+
+        return self.computeBuiltinSpec(
+            trace_collection=trace_collection, given_values=given_values
+        )
+
+
+#     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/BuiltinDecodingNodes.py

@@ -0,0 +1,52 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Built-in ord/chr nodes
+
+These are good for optimizations, as they give a very well known result. In the case of
+'chr', it's one of 256 strings, and in case of 'ord' it's one of 256 numbers, so these can
+answer quite a few questions at compile time.
+
+"""
+
+from nuitka.specs import BuiltinParameterSpecs
+
+from .ExpressionBases import ExpressionBuiltinSingleArgBase
+
+
+class ExpressionBuiltinOrd(ExpressionBuiltinSingleArgBase):
+    kind = "EXPRESSION_BUILTIN_ORD"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_ord_spec
+
+    @staticmethod
+    def isKnownToBeIterable(count):
+        return False
+
+
+class ExpressionBuiltinChr(ExpressionBuiltinSingleArgBase):
+    kind = "EXPRESSION_BUILTIN_CHR"
+
+    builtin_spec = BuiltinParameterSpecs.builtin_chr_spec
+
+    def isKnownToBeIterable(self, count):
+        if self.mayRaiseException(BaseException):
+            return None
+
+        return count is None or count == 1
+
+
+#     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/BuiltinDecoratorNodes.py

@@ -0,0 +1,85 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Built-in staticmethod/classmethod nodes
+
+These are good for optimizations, as they give a very well known result, changing
+only the way a class member is being called. Being able to avoid going through a
+C call to the built-ins resulting wrapper, will speed up things.
+"""
+
+from .ExpressionBasesGenerated import (
+    ExpressionBuiltinClassmethodBase,
+    ExpressionBuiltinStaticmethodBase,
+)
+from .shapes.BuiltinTypeShapes import tshape_classmethod, tshape_staticmethod
+
+
+class BuiltinStaticmethodClassmethodMixin(object):
+    __slots__ = ()
+
+    # There is nothing to compute for it as a value.
+    auto_compute_handling = "final,no_raise"
+
+    # TODO: Make it part of auto-compute through a the shape provided.
+    @staticmethod
+    def isKnownToBeIterable(count):
+        # pylint: disable=unused-argument
+        return False
+
+    @staticmethod
+    def isKnownToBeHashable():
+        return True
+
+    # TODO: should be automatic due to final
+    def mayRaiseException(self, exception_type):
+        return self.subnode_value.mayRaiseException(exception_type)
+
+    # TODO: should be a auto_compute property.
+    def mayHaveSideEffect(self):
+        return self.subnode_value.mayHaveSideEffect()
+
+    def extractSideEffects(self):
+        return self.subnode_value.extractSideEffects()
+
+
+class ExpressionBuiltinStaticmethod(
+    BuiltinStaticmethodClassmethodMixin, ExpressionBuiltinStaticmethodBase
+):
+    kind = "EXPRESSION_BUILTIN_STATICMETHOD"
+
+    # TODO: Allow these to be in class classes instead.
+    named_children = ("value",)
+
+    @staticmethod
+    def getTypeShape():
+        return tshape_staticmethod
+
+
+class ExpressionBuiltinClassmethod(
+    BuiltinStaticmethodClassmethodMixin, ExpressionBuiltinClassmethodBase
+):
+    kind = "EXPRESSION_BUILTIN_CLASSMETHOD"
+
+    # TODO: Allow these to be in mixin classes instead.
+    named_children = ("value",)
+
+    @staticmethod
+    def getTypeShape():
+        return tshape_classmethod
+
+
+#     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/BuiltinDictNodes.py

@@ -0,0 +1,140 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Node for the calls to the 'dict' built-in.
+
+"""
+
+from nuitka.specs.BuiltinParameterSpecs import builtin_dict_spec
+
+from .BuiltinIteratorNodes import ExpressionBuiltinIter1
+from .ChildrenHavingMixins import ChildrenHavingPosArgOptionalPairsTupleMixin
+from .DictionaryNodes import makeExpressionMakeDict
+from .ExpressionBases import ExpressionBase
+from .ExpressionShapeMixins import ExpressionDictShapeExactMixin
+from .NodeMakingHelpers import wrapExpressionWithNodeSideEffects
+
+
+class ExpressionBuiltinDict(
+    ExpressionDictShapeExactMixin,
+    ChildrenHavingPosArgOptionalPairsTupleMixin,
+    ExpressionBase,
+):
+    kind = "EXPRESSION_BUILTIN_DICT"
+
+    named_children = ("pos_arg|optional", "pairs|tuple")
+
+    def __init__(self, pos_arg, pairs, source_ref):
+        ChildrenHavingPosArgOptionalPairsTupleMixin.__init__(
+            self,
+            pos_arg=pos_arg,
+            pairs=pairs,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def hasOnlyConstantArguments(self):
+        pos_arg = self.subnode_pos_arg
+
+        if pos_arg is not None and not pos_arg.isCompileTimeConstant():
+            return False
+
+        for arg_pair in self.subnode_pairs:
+            if not arg_pair.isCompileTimeConstant():
+                return False
+
+        return True
+
+    def computeExpression(self, trace_collection):
+        pos_arg = self.subnode_pos_arg
+        pairs = self.subnode_pairs
+
+        if pos_arg is None:
+            new_node = makeExpressionMakeDict(
+                pairs=self.subnode_pairs, source_ref=self.source_ref
+            )
+
+            # This cannot raise anymore than its arguments, as the keys will
+            # be known as hashable, due to being Python parameters before.
+
+            return (
+                new_node,
+                "new_expression",
+                "Replace 'dict' built-in call dictionary creation from arguments.",
+            )
+
+        pos_iteration_length = pos_arg.getIterationLength()
+
+        if pos_iteration_length == 0:
+            new_node = makeExpressionMakeDict(
+                pairs=self.subnode_pairs, source_ref=self.source_ref
+            )
+
+            # Maintain potential side effects from the positional arguments.
+            new_node = wrapExpressionWithNodeSideEffects(
+                old_node=ExpressionBuiltinIter1(
+                    value=pos_arg, source_ref=self.source_ref
+                ),
+                new_node=new_node,
+            )
+
+            # Just in case, the iteration may do that.
+            if not pos_arg.hasShapeSlotIter():
+                trace_collection.onExceptionRaiseExit(BaseException)
+
+            return (
+                new_node,
+                "new_expression",
+                "Replace 'dict' built-in call dictionary creation from arguments.",
+            )
+
+        if (
+            pos_iteration_length is not None
+            and pos_iteration_length + len(pairs) < 256
+            and self.hasOnlyConstantArguments()
+        ):
+            if pos_arg is not None:
+                pos_args = (pos_arg,)
+            else:
+                pos_args = None
+
+            return trace_collection.getCompileTimeComputationResult(
+                node=self,
+                computation=lambda: builtin_dict_spec.simulateCall(
+                    (pos_args, self.subnode_pairs)
+                ),
+                description="Replace 'dict' call with constant arguments.",
+            )
+        else:
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        pos_arg = self.subnode_pos_arg
+
+        # TODO: Determining if it's sufficient is not easy but possible.
+        if pos_arg is not None:
+            return True
+
+        for arg_pair in self.subnode_pairs:
+            if arg_pair.mayRaiseException(exception_type):
+                return True
+
+        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.