Nuitka-winsvc 2.1.5__cp311-cp311-win_amd64.whl → 2.2.1__cp311-cp311-win_amd64.whl

nuitka/nodes/StatementBasesGenerated.py

@@ -2,18 +2,33 @@
 
 
 # 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 statement 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 buffering capitalize casefold
+spell-checker: ignore center chars clear closefd copy count decode default delete dist
+spell-checker: ignore distribution_name encode encoding end endswith errors exit_code
+spell-checker: ignore expandtabs experimental_attributes experimental_autograph_options
+spell-checker: ignore experimental_compile experimental_follow_type_hints
+spell-checker: ignore experimental_implements experimental_relax_shapes extend file
+spell-checker: ignore fillchar find format format_map formatmap fromkeys func get group
+spell-checker: ignore handle has_key haskey index input_signature insert isalnum isalpha
+spell-checker: ignore isascii isdecimal isdigit isidentifier islower isnumeric isprintable
+spell-checker: ignore isspace istitle isupper item items iterable iteritems iterkeys
+spell-checker: ignore itervalues jit_compile join keepends key keys kwargs ljust lower
+spell-checker: ignore lstrip maketrans maxsplit mode name new newline old opener 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
 """
 
 
@@ -197,12 +212,16 @@ class StatementChildrenHavingConditionYesBranchOptionalStatementsOrNoneNoBranchO
 
         values = {
             "condition": self.subnode_condition.makeClone(),
-            "yes_branch": self.subnode_yes_branch.makeClone()
-            if self.subnode_yes_branch is not None
-            else None,
-            "no_branch": self.subnode_no_branch.makeClone()
-            if self.subnode_no_branch is not None
-            else None,
+            "yes_branch": (
+                self.subnode_yes_branch.makeClone()
+                if self.subnode_yes_branch is not None
+                else None
+            ),
+            "no_branch": (
+                self.subnode_no_branch.makeClone()
+                if self.subnode_no_branch is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -291,9 +310,9 @@ class StatementChildHavingDestOptionalOperationMixin(StatementBase):
         """
 
         values = {
-            "dest": self.subnode_dest.makeClone()
-            if self.subnode_dest is not None
-            else None,
+            "dest": (
+                self.subnode_dest.makeClone() if self.subnode_dest is not None else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -408,9 +427,9 @@ class StatementChildrenHavingDestOptionalValueOperationMixin(StatementBase):
         """
 
         values = {
-            "dest": self.subnode_dest.makeClone()
-            if self.subnode_dest is not None
-            else None,
+            "dest": (
+                self.subnode_dest.makeClone() if self.subnode_dest is not None else None
+            ),
             "value": self.subnode_value.makeClone(),
         }
 
@@ -789,15 +808,21 @@ class StatementChildrenHavingExceptionTypeExceptionValueOptionalExceptionTraceOp
 
         values = {
             "exception_type": self.subnode_exception_type.makeClone(),
-            "exception_value": self.subnode_exception_value.makeClone()
-            if self.subnode_exception_value is not None
-            else None,
-            "exception_trace": self.subnode_exception_trace.makeClone()
-            if self.subnode_exception_trace is not None
-            else None,
-            "exception_cause": self.subnode_exception_cause.makeClone()
-            if self.subnode_exception_cause is not None
-            else None,
+            "exception_value": (
+                self.subnode_exception_value.makeClone()
+                if self.subnode_exception_value is not None
+                else None
+            ),
+            "exception_trace": (
+                self.subnode_exception_trace.makeClone()
+                if self.subnode_exception_trace is not None
+                else None
+            ),
+            "exception_cause": (
+                self.subnode_exception_cause.makeClone()
+                if self.subnode_exception_cause is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -1107,12 +1132,16 @@ class StatementChildrenHavingExpressionLowerOptionalUpperOptionalMixin(Statement
 
         values = {
             "expression": self.subnode_expression.makeClone(),
-            "lower": self.subnode_lower.makeClone()
-            if self.subnode_lower is not None
-            else None,
-            "upper": self.subnode_upper.makeClone()
-            if self.subnode_upper is not None
-            else None,
+            "lower": (
+                self.subnode_lower.makeClone()
+                if self.subnode_lower is not None
+                else None
+            ),
+            "upper": (
+                self.subnode_upper.makeClone()
+                if self.subnode_upper is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -1599,9 +1628,11 @@ class StatementChildHavingLoopBodyOptionalStatementsOrNonePostInitMixin(Statemen
         """
 
         values = {
-            "loop_body": self.subnode_loop_body.makeClone()
-            if self.subnode_loop_body is not None
-            else None,
+            "loop_body": (
+                self.subnode_loop_body.makeClone()
+                if self.subnode_loop_body is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -2452,12 +2483,16 @@ class StatementChildrenHavingSourceExpressionLowerOptionalUpperOptionalMixin(
         values = {
             "source": self.subnode_source.makeClone(),
             "expression": self.subnode_expression.makeClone(),
-            "lower": self.subnode_lower.makeClone()
-            if self.subnode_lower is not None
-            else None,
-            "upper": self.subnode_upper.makeClone()
-            if self.subnode_upper is not None
-            else None,
+            "lower": (
+                self.subnode_lower.makeClone()
+                if self.subnode_lower is not None
+                else None
+            ),
+            "upper": (
+                self.subnode_upper.makeClone()
+                if self.subnode_upper is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -2719,12 +2754,16 @@ class StatementChildrenHavingSourceCodeGlobalsArgAutoNoneLocalsArgAutoNoneOperat
 
         values = {
             "source_code": self.subnode_source_code.makeClone(),
-            "globals_arg": self.subnode_globals_arg.makeClone()
-            if self.subnode_globals_arg is not None
-            else None,
-            "locals_arg": self.subnode_locals_arg.makeClone()
-            if self.subnode_locals_arg is not None
-            else None,
+            "globals_arg": (
+                self.subnode_globals_arg.makeClone()
+                if self.subnode_globals_arg is not None
+                else None
+            ),
+            "locals_arg": (
+                self.subnode_locals_arg.makeClone()
+                if self.subnode_locals_arg is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -3171,18 +3210,26 @@ class StatementChildrenHavingTriedStatementsExceptHandlerOptionalStatementsOrNon
 
         values = {
             "tried": self.subnode_tried.makeClone(),
-            "except_handler": self.subnode_except_handler.makeClone()
-            if self.subnode_except_handler is not None
-            else None,
-            "break_handler": self.subnode_break_handler.makeClone()
-            if self.subnode_break_handler is not None
-            else None,
-            "continue_handler": self.subnode_continue_handler.makeClone()
-            if self.subnode_continue_handler is not None
-            else None,
-            "return_handler": self.subnode_return_handler.makeClone()
-            if self.subnode_return_handler is not None
-            else None,
+            "except_handler": (
+                self.subnode_except_handler.makeClone()
+                if self.subnode_except_handler is not None
+                else None
+            ),
+            "break_handler": (
+                self.subnode_break_handler.makeClone()
+                if self.subnode_break_handler is not None
+                else None
+            ),
+            "continue_handler": (
+                self.subnode_continue_handler.makeClone()
+                if self.subnode_continue_handler is not None
+                else None
+            ),
+            "return_handler": (
+                self.subnode_return_handler.makeClone()
+                if self.subnode_return_handler is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())

nuitka/nodes/StringConcatenationNodes.py

@@ -8,6 +8,7 @@ code alternative to actually looking up that method from the empty string
 object, so it got a dedicated node, also to perform optimizations specific
 to this.
 """
+
 from .ChildrenHavingMixins import ChildHavingValuesTupleMixin
 from .ConstantRefNodes import makeConstantRefNode
 from .ExpressionBases import ExpressionBase

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/TypeNodes.py

@@ -23,6 +23,7 @@ from .ChildrenHavingMixins import (
     ChildrenExpressionBuiltinSuper0Mixin,
     ChildrenExpressionBuiltinSuper1Mixin,
     ChildrenExpressionBuiltinSuper2Mixin,
+    ChildrenExpressionTypeAliasMixin,
     ChildrenHavingInstanceClassesMixin,
 )
 from .ExpressionBases import ExpressionBase, ExpressionBuiltinSingleArgBase
@@ -326,6 +327,26 @@ class ExpressionSubtypeCheck(
         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.
 #

nuitka/nodes/VariableRefNodes.py

@@ -180,6 +180,7 @@ class ExpressionVariableRefBase(ExpressionBase):
         # Any code could be run, note that.
         trace_collection.onControlFlowEscape(in_node)
 
+        # TODO: Add "set" shape here as well.
         if self.variable_trace.hasShapeDictionaryExact():
             tags = "new_expression"
             message = """\

nuitka/nodes/shapes/BuiltinTypeShapes.py

@@ -2240,9 +2240,11 @@ mod_shapes_bool.update(
         tshape_int_or_long: operation_result_zerodiv_intorlong,
         tshape_bool: operation_result_zerodiv_int,
         tshape_float: operation_result_zerodiv_float,
-        tshape_complex: operation_result_zerodiv_complex
-        if python_version < 0x300
-        else operation_result_unsupported_mod,
+        tshape_complex: (
+            operation_result_zerodiv_complex
+            if python_version < 0x300
+            else operation_result_unsupported_mod
+        ),
         # Unsupported:
         tshape_str: operation_result_unsupported_mod,
         tshape_bytes: operation_result_unsupported_mod,
@@ -2577,9 +2579,11 @@ mod_shapes_int.update(
         tshape_int_or_long: operation_result_zerodiv_intorlong,
         tshape_bool: operation_result_zerodiv_int,
         tshape_float: operation_result_zerodiv_float,
-        tshape_complex: operation_result_zerodiv_complex
-        if python_version < 0x300
-        else operation_result_unsupported_mod,
+        tshape_complex: (
+            operation_result_zerodiv_complex
+            if python_version < 0x300
+            else operation_result_unsupported_mod
+        ),
         # Unsupported:
         tshape_str: operation_result_unsupported_mod,
         tshape_bytes: operation_result_unsupported_mod,
@@ -2881,9 +2885,11 @@ mod_shapes_long.update(
         tshape_int_or_long: operation_result_zerodiv_long,
         tshape_bool: operation_result_zerodiv_long,
         tshape_float: operation_result_zerodiv_float,
-        tshape_complex: operation_result_zerodiv_complex
-        if python_version < 0x300
-        else operation_result_unsupported_mod,
+        tshape_complex: (
+            operation_result_zerodiv_complex
+            if python_version < 0x300
+            else operation_result_unsupported_mod
+        ),
         # Unsupported:
         tshape_str: operation_result_unsupported_mod,
         tshape_bytes: operation_result_unsupported_mod,
@@ -3771,9 +3777,11 @@ add_shapes_str.update(
         # Sequence repeat is not allowed
         tshape_str: operation_result_str_noescape,
         tshape_bytes: operation_result_unsupported_add,
-        tshape_bytearray: operation_result_bytearray_noescape
-        if python_version < 0x300
-        else operation_result_unsupported_add,
+        tshape_bytearray: (
+            operation_result_bytearray_noescape
+            if python_version < 0x300
+            else operation_result_unsupported_add
+        ),
         tshape_unicode: operation_result_unicode_noescape,
         tshape_tuple: operation_result_unsupported_add,
         tshape_list: operation_result_unsupported_add,
@@ -3961,9 +3969,11 @@ add_shapes_bytearray.update(
         tshape_bool: operation_result_unsupported_add,
         tshape_float: operation_result_unsupported_add,
         # Sequence repeat is not allowed
-        tshape_str: operation_result_bytearray_noescape
-        if python_version < 0x300
-        else operation_result_unsupported_add,
+        tshape_str: (
+            operation_result_bytearray_noescape
+            if python_version < 0x300
+            else operation_result_unsupported_add
+        ),
         tshape_bytes: operation_result_bytearray_noescape,
         tshape_bytearray: operation_result_bytearray_noescape,
         tshape_unicode: operation_result_unsupported_add,

nuitka/optimizations/Optimization.py

@@ -8,7 +8,6 @@ optimization is possible. Every successful optimization to anything might
 make others possible.
 """
 
-
 import inspect
 
 from nuitka import ModuleRegistry, Options, Variables
@@ -213,11 +212,13 @@ after that.""".format(
         reportMemoryUsage(
             "optimization/%d/%s" % (pass_count, current_module.getFullName()),
             (
-                "Total memory usage before optimizing module '%s'"
-                % current_module.getFullName()
-            )
-            if Options.isShowProgress() or Options.isShowMemory()
-            else None,
+                (
+                    "Total memory usage before optimizing module '%s'"
+                    % current_module.getFullName()
+                )
+                if Options.isShowProgress() or Options.isShowMemory()
+                else None
+            ),
         )
 
 

nuitka/optimizations/OptimizeBuiltinCalls.py

@@ -1092,9 +1092,9 @@ def open_extractor(node):
 
     return BuiltinParameterSpecs.extractBuiltinArgs(
         node=node,
-        builtin_class=ExpressionBuiltinOpenP3
-        if str is not bytes
-        else ExpressionBuiltinOpenP2,
+        builtin_class=(
+            ExpressionBuiltinOpenP3 if str is not bytes else ExpressionBuiltinOpenP2
+        ),
         builtin_spec=BuiltinParameterSpecs.builtin_open_spec,
         empty_special_class=makeOpen0,
     )
@@ -1132,9 +1132,9 @@ def super_extractor(node):
             ):
                 return makeRaiseExceptionReplacementExpression(
                     expression=node,
-                    exception_type="SystemError"
-                    if python_version < 0x331
-                    else "RuntimeError",
+                    exception_type=(
+                        "SystemError" if python_version < 0x331 else "RuntimeError"
+                    ),
                     exception_value="super(): __class__ cell not found",
                 )
 
@@ -1172,9 +1172,11 @@ def super_extractor(node):
                     if not object_arg.getVariable().isParameterVariable():
                         return makeRaiseExceptionReplacementExpression(
                             expression=node,
-                            exception_type="SystemError"
-                            if python_version < 0x300
-                            else "RuntimeError",
+                            exception_type=(
+                                "SystemError"
+                                if python_version < 0x300
+                                else "RuntimeError"
+                            ),
                             exception_value="super(): __class__ cell not found",
                         )
 

nuitka/optimizations/Tags.py

@@ -9,7 +9,6 @@ tags to execute other steps.
 
 """
 
-
 allowed_tags = (
     # New code means new statements.
     # Could be an inlined exec statement.

nuitka/optimizations/TraceCollections.py

@@ -17,8 +17,6 @@ from nuitka import Variables
 from nuitka.__past__ import iterItems  # Python3 compatibility.
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.containers.OrderedSets import OrderedSet
-from nuitka.importing.Importing import locateModule, makeModuleUsageAttempt
-from nuitka.importing.Recursion import decideRecursion
 from nuitka.ModuleRegistry import addUsedModule
 from nuitka.nodes.NodeMakingHelpers import getComputationResult
 from nuitka.nodes.shapes.StandardShapes import tshape_uninitialized
@@ -949,6 +947,9 @@ class TraceCollectionBase(object):
     def onUsedFunction(self, function_body):
         return self.parent.onUsedFunction(function_body)
 
+    def onModuleUsageAttempts(self, module_usage_attempts):
+        self.parent.onModuleUsageAttempts(module_usage_attempts)
+
     def onModuleUsageAttempt(self, module_usage_attempt):
         self.parent.onModuleUsageAttempt(module_usage_attempt)
 
@@ -1133,60 +1134,10 @@ class TraceCollectionModule(CollectionStartPointMixin, TraceCollectionBase):
     def getModuleUsageAttempts(self):
         return self.module_usage_attempts
 
-    def onModuleUsageAttempt(self, module_usage_attempt):
-        if module_usage_attempt.finding != "not-found":
-            decision, _reason = decideRecursion(
-                using_module_name=self.owner.getFullName(),
-                module_name=module_usage_attempt.module_name,
-                module_filename=module_usage_attempt.filename,
-                module_kind=module_usage_attempt.module_kind,
-            )
-
-            # When sub-package module import is rejected for whatever reason,
-            # still this implies an attempt of the parent, because nothing else
-            # will do it otherwise, it of course may also be rejected, but if it
-            # is not, otherwise it will be missing.
-            #
-            # A common case of this happening are extension modules in
-            # accelerated mode, for standalone this will of course be rare.
-            if decision is False:
-                parent_package_name = module_usage_attempt.module_name.getPackageName()
-
-                if parent_package_name is not None:
-                    (
-                        package_module_name,
-                        module_filename,
-                        module_kind,
-                        finding,
-                    ) = locateModule(
-                        module_name=parent_package_name,
-                        parent_package=None,
-                        level=0,
-                    )
-
-                    # Should not be possible to happen.
-                    assert finding != "not-found", package_module_name
-
-                    decision, _reason = decideRecursion(
-                        using_module_name=self.owner.getFullName(),
-                        module_name=package_module_name,
-                        module_filename=module_filename,
-                        module_kind=module_kind,
-                    )
-
-                    if decision is True:
-                        self.onModuleUsageAttempt(
-                            makeModuleUsageAttempt(
-                                module_name=package_module_name,
-                                filename=module_filename,
-                                finding=finding,
-                                module_kind=module_kind,
-                                level=0,
-                                source_ref=module_usage_attempt.source_ref,
-                                reason="parent import",
-                            )
-                        )
+    def onModuleUsageAttempts(self, module_usage_attempts):
+        self.module_usage_attempts.update(module_usage_attempts)
 
+    def onModuleUsageAttempt(self, module_usage_attempt):
         self.module_usage_attempts.add(module_usage_attempt)
 
     def getUsedDistributions(self):

nuitka/optimizations/ValueTraces.py

@@ -18,7 +18,15 @@ Values can be seen as:
 * LoopComplete (complete knowledge of loop types)
 """
 
-from nuitka.nodes.shapes.BuiltinTypeShapes import tshape_dict, tshape_tuple
+from nuitka.nodes.shapes.BuiltinTypeShapes import (
+    tshape_bool,
+    tshape_bytes,
+    tshape_dict,
+    tshape_list,
+    tshape_str,
+    tshape_tuple,
+    tshape_unicode,
+)
 from nuitka.nodes.shapes.ControlFlowDescriptions import (
     ControlFlowDescriptionElementBasedEscape,
     ControlFlowDescriptionFullEscape,
@@ -847,6 +855,46 @@ class ValueTraceLoopBase(ValueTraceMergeBase):
         self.recursion = False
         return True
 
+    def hasShapeListExact(self):
+        return self.type_shapes == _only_list_shape
+
+    def hasShapeDictionaryExact(self):
+        return self.type_shapes == _only_dict_shape
+
+    def hasShapeStrExact(self):
+        return self.type_shapes == _only_str_shape
+
+    def hasShapeUnicodeExact(self):
+        return self.type_shapes == _only_unicode_shape
+
+    if str is bytes:
+
+        def hasShapeStrOrUnicodeExact(self):
+            return (
+                self.hasShapeStrExact()
+                or self.hasShapeUnicodeExact()
+                or self.type_shapes == _str_plus_unicode_shape
+            )
+
+    else:
+
+        hasShapeStrOrUnicodeExact = hasShapeUnicodeExact
+
+    def hasShapeBytesExact(self):
+        return self.type_shapes == _only_bytes_shape
+
+    def hasShapeBoolExact(self):
+        return self.type_shapes == _only_bool_shape
+
+
+_only_list_shape = frozenset((tshape_list,))
+_only_dict_shape = frozenset((tshape_dict,))
+_only_str_shape = frozenset((tshape_str,))
+_only_unicode_shape = frozenset((tshape_unicode,))
+_str_plus_unicode_shape = frozenset((tshape_unicode, tshape_str))
+_only_bytes_shape = frozenset((tshape_bytes,))
+_only_bool_shape = frozenset((tshape_bool,))
+
 
 class ValueTraceLoopComplete(ValueTraceLoopBase):
     __slots__ = ()