Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/nodes/IterationHandles.py

@@ -22,12 +22,15 @@
 import math
 from abc import abstractmethod
 
-from nuitka.__past__ import getMetaClassBase, xrange
+from nuitka.__past__ import xrange
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 
-class IterationHandleBase(getMetaClassBase("IterationHandle")):
+class IterationHandleBase(getMetaClassBase("IterationHandle", require_slots=True)):
     """Base class for Iteration Handles."""
 
+    __slots__ = ()
+
     @abstractmethod
     def getNextValueExpression(self):
         """Abstract method to get next iteration value."""
@@ -93,6 +96,11 @@ class ConstantIterationHandleBase(IterationHandleBase):
         Returns the boolean value of the next handle
     """
 
+    __slots__ = (
+        "constant_node",
+        "iter",
+    )
+
     def __init__(self, constant_node):
         assert constant_node.isIterableConstant()
 
@@ -142,8 +150,7 @@ class ConstantIndexableIterationHandle(ConstantIterationHandleBase):
         Sequential access of the constants
     """
 
-    def __init__(self, constant_node):
-        ConstantIterationHandleBase.__init__(self, constant_node)
+    __slots__ = ()
 
     def getIterationValueWithIndex(self, value_index):
         """Tries to return constant value at the given index.
@@ -165,50 +172,49 @@ class ConstantIndexableIterationHandle(ConstantIterationHandleBase):
 
 
 class ConstantTupleIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantListIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantStrIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantUnicodeIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantBytesIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantBytearrayIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantRangeIterationHandle(ConstantIndexableIterationHandle):
-    pass
+    __slots__ = ()
 
 
 class ConstantSetAndDictIterationHandleBase(ConstantIterationHandleBase):
     """Class for the set and dictionary constants."""
 
-    def __init__(self, constant_node):
-        ConstantIterationHandleBase.__init__(self, constant_node)
+    __slots__ = ()
 
 
 class ConstantSetIterationHandle(ConstantSetAndDictIterationHandleBase):
-    pass
+    __slots__ = ()
 
 
 class ConstantFrozensetIterationHandle(ConstantSetAndDictIterationHandleBase):
-    pass
+    __slots__ = ()
 
 
 class ConstantDictIterationHandle(ConstantSetAndDictIterationHandleBase):
-    pass
+    __slots__ = ()
 
 
 class ListAndTupleContainerMakingIterationHandle(IterationHandleBase):
@@ -232,6 +238,8 @@ class ListAndTupleContainerMakingIterationHandle(IterationHandleBase):
         Sequential access of the expression
     """
 
+    __slots__ = ("elements", "iter")
+
     def __init__(self, elements):
         self.elements = elements
         self.iter = iter(self.elements)
@@ -272,11 +280,13 @@ class RangeIterationHandleBase(IterationHandleBase):
     high : int
         Optional. An integer number specifying at which position to end.
     step : int
-        Optional. An integer number specifying the incrementation. Default is 1
+        Optional. An integer number specifying the increment. Default is 1
     """
 
     step = 1
 
+    __slots__ = ("low", "iter", "source_ref")
+
     def __init__(self, low_value, range_value, source_ref):
         self.low = low_value
         self.iter = iter(range_value)
@@ -332,6 +342,8 @@ class RangeIterationHandleBase(IterationHandleBase):
 class IterationHandleRange1(RangeIterationHandleBase):
     """Iteration handle for range(low,)"""
 
+    __slots__ = ()
+
     def __init__(self, low_value, source_ref):
         RangeIterationHandleBase.__init__(
             self, low_value, xrange(low_value), source_ref
@@ -348,6 +360,8 @@ class IterationHandleRange1(RangeIterationHandleBase):
 class IterationHandleRange2(RangeIterationHandleBase):
     """Iteration handle for ranges(low, high)"""
 
+    __slots__ = ("high",)
+
     def __init__(self, low_value, high_value, source_ref):
         RangeIterationHandleBase.__init__(
             self, low_value, xrange(low_value, high_value), source_ref
@@ -362,6 +376,11 @@ class IterationHandleRange2(RangeIterationHandleBase):
 class IterationHandleRange3(RangeIterationHandleBase):
     """Iteration handle for ranges(low, high, step)"""
 
+    __slots__ = (
+        "high",
+        "step",
+    )
+
     def __init__(self, low_value, high_value, step_value, source_ref):
         RangeIterationHandleBase.__init__(
             self, low_value, xrange(low_value, high_value, step_value), source_ref

nuitka/nodes/LocalsScopes.py

@@ -256,7 +256,9 @@ class LocalsDictHandleBase(object):
             provider = trace_collection.getOwner()
 
             self.propagation[variable_name] = provider.allocateTempVariable(
-                temp_scope=None, name=self.getCodeName() + "_key_" + variable_name
+                temp_scope=None,
+                name=self.getCodeName() + "_key_" + variable_name,
+                temp_type="object",
             )
 
         return self.propagation[variable_name]

nuitka/nodes/NodeBases.py

@@ -28,7 +28,7 @@ expression only stuff.
 import ast
 from abc import abstractmethod
 
-from nuitka import Options, Tracing, TreeXML, Variables
+from nuitka import Options, Tracing, TreeXML
 from nuitka.__past__ import iterItems
 from nuitka.Errors import NuitkaNodeError
 from nuitka.PythonVersions import python_version
@@ -38,6 +38,7 @@ from nuitka.utils.InstanceCounters import (
     counted_init,
     isCountingInstances,
 )
+from nuitka.Variables import TempVariable
 
 from .FutureSpecs import fromFlags
 from .NodeMakingHelpers import makeStatementOnlyNodesFromExpressions
@@ -399,10 +400,6 @@ class NodeBase(NodeMetaClassBase):
     def isExpressionClassBodyBase():
         return False
 
-    @staticmethod
-    def isExpressionImportModuleNameHard():
-        return False
-
     @staticmethod
     def isExpressionFunctionCreation():
         return False
@@ -567,7 +564,7 @@ class ClosureGiverNodeMixin(CodeNodeMixin):
 
         return "%s_%d" % (name, self.temp_scopes[name])
 
-    def allocateTempVariable(self, temp_scope, name, temp_type=None):
+    def allocateTempVariable(self, temp_scope, name, temp_type):
         if temp_scope is not None:
             full_name = "%s__%s" % (temp_scope, name)
         else:
@@ -591,14 +588,11 @@ class ClosureGiverNodeMixin(CodeNodeMixin):
         if temp_name in self.temp_variables:
             return self.temp_variables[temp_name]
 
-        if temp_type is None:
-            temp_class = Variables.TempVariable
-        elif temp_type == "bool":
-            temp_class = Variables.TempVariableBool
-        else:
-            assert False, temp_type
-
-        result = temp_class(owner=self, variable_name=temp_name)
+        result = TempVariable(
+            owner=self,
+            variable_name=temp_name,
+            variable_type=temp_type,
+        )
 
         self.temp_variables[temp_name] = result
 

nuitka/nodes/OperatorNodes.py

@@ -47,7 +47,7 @@ from .shapes.StandardShapes import (
 class ExpressionPropertiesFromTypeShapeMixin(object):
     """Given a self.type_shape, this can derive default properties from there."""
 
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     def isKnownToBeHashable(self):
@@ -627,7 +627,7 @@ if python_version >= 0x350:
             return left_shape.getOperationBinaryMatMultShape(right_shape)
 
 
-_operator2binary_operation_nodeclass = {
+_operator2binary_operation_node_class = {
     "Add": ExpressionOperationBinaryAdd,
     "Sub": ExpressionOperationBinarySub,
     "Mult": ExpressionOperationBinaryMult,
@@ -644,14 +644,14 @@ _operator2binary_operation_nodeclass = {
 }
 
 if python_version < 0x300:
-    _operator2binary_operation_nodeclass["OldDiv"] = ExpressionOperationBinaryOldDiv
+    _operator2binary_operation_node_class["OldDiv"] = ExpressionOperationBinaryOldDiv
 
 if python_version >= 0x350:
-    _operator2binary_operation_nodeclass["MatMult"] = ExpressionOperationBinaryMatMult
+    _operator2binary_operation_node_class["MatMult"] = ExpressionOperationBinaryMatMult
 
 
 def makeBinaryOperationNode(operator, left, right, source_ref):
-    node_class = _operator2binary_operation_nodeclass[operator]
+    node_class = _operator2binary_operation_node_class[operator]
 
     return node_class(left=left, right=right, source_ref=source_ref)
 
@@ -914,7 +914,7 @@ if python_version >= 0x350:
             return left_shape.getOperationBinaryMatMultShape(right_shape)
 
 
-_operator2binary_inplace_nodeclass = {
+_operator2binary_inplace_node_class = {
     "IAdd": ExpressionOperationInplaceAdd,
     "ISub": ExpressionOperationInplaceSub,
     "IMult": ExpressionOperationInplaceMult,
@@ -930,13 +930,13 @@ _operator2binary_inplace_nodeclass = {
 }
 
 if python_version < 0x300:
-    _operator2binary_inplace_nodeclass["IOldDiv"] = ExpressionOperationInplaceOldDiv
+    _operator2binary_inplace_node_class["IOldDiv"] = ExpressionOperationInplaceOldDiv
 
 if python_version >= 0x350:
-    _operator2binary_inplace_nodeclass["IMatMult"] = ExpressionOperationInplaceMatMult
+    _operator2binary_inplace_node_class["IMatMult"] = ExpressionOperationInplaceMatMult
 
 
 def makeExpressionOperationBinaryInplace(operator, left, right, source_ref):
-    node_class = _operator2binary_inplace_nodeclass[operator]
+    node_class = _operator2binary_inplace_node_class[operator]
 
     return node_class(left=left, right=right, source_ref=source_ref)

nuitka/nodes/OutlineNodes.py

@@ -79,7 +79,7 @@ class ExpressionOutlineBody(ChildHavingBodyOptionalMixin, ExpressionBase):
 
         return self.temp_scope
 
-    def allocateTempVariable(self, temp_scope, name, temp_type=None):
+    def allocateTempVariable(self, temp_scope, name, temp_type):
         if temp_scope is None:
             temp_scope = self.getOutlineTempScope()
 
@@ -311,12 +311,12 @@ class ExpressionOutlineFunctionBase(ExpressionFunctionBodyBase):
 
         return self.temp_scope
 
-    def allocateTempVariable(self, temp_scope, name, temp_type=None):
+    def allocateTempVariable(self, temp_scope, name, temp_type):
         if temp_scope is None:
             temp_scope = self.getOutlineTempScope()
 
         return self.provider.allocateTempVariable(
-            temp_scope=temp_scope, name=name, temp_type=None
+            temp_scope=temp_scope, name=name, temp_type=temp_type
         )
 
     def allocateTempScope(self, name):

nuitka/nodes/PackageMetadataNodes.py

@@ -75,11 +75,19 @@ class ExpressionPkgResourcesRequireCall(ExpressionPkgResourcesRequireCallBase):
     kind = "EXPRESSION_PKG_RESOURCES_REQUIRE_CALL"
 
     def replaceWithCompileTimeValue(self, trace_collection):
-        require = _getPkgResourcesModule().require
-        ResolutionError = _getPkgResourcesModule().ResolutionError
-        InvalidRequirement = (
-            _getPkgResourcesModule().extern.packaging.requirements.InvalidRequirement
-        )
+        resources_module = _getPkgResourcesModule()
+
+        require = resources_module.require
+        ResolutionError = resources_module.ResolutionError
+
+        try:
+            InvalidRequirement = (
+                resources_module.extern.packaging.requirements.InvalidRequirement
+            )
+        except AttributeError:
+            InvalidRequirement = (
+                resources_module.packaging.requirements.InvalidRequirement
+            )
 
         args = tuple(
             element.getCompileTimeConstant() for element in self.subnode_requirements
@@ -135,8 +143,9 @@ class ExpressionPkgResourcesGetDistributionCall(
     kind = "EXPRESSION_PKG_RESOURCES_GET_DISTRIBUTION_CALL"
 
     def replaceWithCompileTimeValue(self, trace_collection):
-        get_distribution = _getPkgResourcesModule().get_distribution
-        DistributionNotFound = _getPkgResourcesModule().DistributionNotFound
+        pkg_resources_module = _getPkgResourcesModule()
+        get_distribution = pkg_resources_module.get_distribution
+        DistributionNotFound = pkg_resources_module.DistributionNotFound
 
         arg = self.subnode_dist.getCompileTimeConstant()
 
@@ -363,8 +372,9 @@ class ExpressionPkgResourcesIterEntryPointsCall(
     kind = "EXPRESSION_PKG_RESOURCES_ITER_ENTRY_POINTS_CALL"
 
     def replaceWithCompileTimeValue(self, trace_collection):
-        iter_entry_points = _getPkgResourcesModule().iter_entry_points
-        DistributionNotFound = _getPkgResourcesModule().DistributionNotFound
+        pkg_resources_module = _getPkgResourcesModule()
+        iter_entry_points = pkg_resources_module.iter_entry_points
+        DistributionNotFound = pkg_resources_module.DistributionNotFound
 
         group = self.subnode_group.getCompileTimeConstant()
         if self.subnode_name is not None:

nuitka/nodes/SliceNodes.py

@@ -250,7 +250,7 @@ def makeExpressionBuiltinSlice(start, stop, step, source_ref):
 class ExpressionBuiltinSliceMixin(
     ExpressionSliceShapeExactMixin, SideEffectsFromChildrenMixin
 ):
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     builtin_spec = BuiltinParameterSpecs.builtin_slice_spec

nuitka/nodes/VariableAssignNodes.py

@@ -183,6 +183,7 @@ class StatementAssignmentVariableMixin(object):
         self.variable_trace.assign_node = result
         result.variable_trace = self.variable_trace
         self.variable_trace = None
+        result.parent = self.parent
 
     def _considerSpecialization(self, old_source):
         # Specialize if possible, might have become that way only recently.
@@ -486,7 +487,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(
@@ -504,7 +505,7 @@ class StatementAssignmentVariableIterator(
         )
 
         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(
@@ -530,7 +531,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(
@@ -915,6 +916,9 @@ 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.
         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,18 +949,22 @@ 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.
-
-        # 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
-        )
+        if source.isExpressionVariableRef():
+            self.variable_trace = trace_collection.onVariableSetAliasing(
+                variable=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.
+            self.variable_trace = trace_collection.onVariableSet(
+                variable=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)
+            # TODO: Determine from future use of assigned variable, if this is needed at all.
+            trace_collection.removeKnowledge(source)
 
         return self._considerSpecialization(old_source)
 

nuitka/nodes/VariableRefNodes.py

@@ -358,6 +358,12 @@ Subscript look-up to dictionary lowered to dictionary look-up.""",
         # Need to compute the replacement still.
         return replacement.computeExpressionRaw(trace_collection)
 
+    def getTruthValue(self):
+        return self.variable_trace.getTruthValue()
+
+    def getComparisonValue(self):
+        return self.variable_trace.getComparisonValue()
+
 
 _hard_names = ("dir", "eval", "exec", "execfile", "locals", "vars", "super")
 
@@ -630,18 +636,12 @@ Replaced read-only module attribute '__spec__' with module attribute reference."
             self.variable_trace is not None and self.variable_trace.hasShapeBoolExact()
         )
 
-    def getTruthValue(self):
-        return self.variable_trace.getTruthValue()
-
-    def getComparisonValue(self):
-        return self.variable_trace.getComparisonValue()
-
     @staticmethod
     def isKnownToBeIterable(count):
         return None
 
     def mayHaveSideEffects(self):
-        return not self.variable_trace.mustHaveValue()
+        return self.variable_trace is None or not self.variable_trace.mustHaveValue()
 
     def mayRaiseException(self, exception_type):
         return self.variable_trace is None or not self.variable_trace.mustHaveValue()

nuitka/nodes/YieldNodes.py

@@ -104,7 +104,7 @@ class ExpressionYieldFrom(ExpressionYieldBase):
     kind = "EXPRESSION_YIELD_FROM"
 
 
-class ExpressionYieldFromWaitable(ExpressionYieldBase):
+class ExpressionYieldFromAwaitable(ExpressionYieldBase):
     """Yielding from an expression.
 
     Typical code: await x, async for ..., async with (Python3.5)
@@ -116,4 +116,4 @@ class ExpressionYieldFromWaitable(ExpressionYieldBase):
     slots and have dedicated nodes.
     """
 
-    kind = "EXPRESSION_YIELD_FROM_WAITABLE"
+    kind = "EXPRESSION_YIELD_FROM_AWAITABLE"