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

nuitka/nodes/shapes/BuiltinTypeShapes.py

@@ -360,6 +360,8 @@ def _getComparisonEqShapeGeneric(self, right_shape):
 
 
 class ShapeTypeNoneType(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = None
 
     @staticmethod
@@ -440,6 +442,8 @@ tshape_none = ShapeTypeNoneType()
 
 
 class ShapeTypeBool(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = True
 
     @staticmethod
@@ -493,6 +497,8 @@ tshape_bool = ShapeTypeBool()
 
 
 class ShapeTypeInt(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = 7
 
     @staticmethod
@@ -550,6 +556,8 @@ if python_version < 0x300:
     _the_typical_long_value = long(7)  # pylint: disable=I0021,undefined-variable
 
     class ShapeTypeLong(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
+        __slots__ = ()
+
         typical_value = _the_typical_long_value
 
         @staticmethod
@@ -599,6 +607,8 @@ if python_version < 0x300:
     tshape_long = ShapeTypeLong()
 
     class ShapeTypeLongDerived(ShapeTypeUnknown):
+        __slots__ = ()
+
         @staticmethod
         def getTypeName():
             return None
@@ -606,6 +616,8 @@ if python_version < 0x300:
     tshape_long_derived = ShapeTypeLongDerived()
 
     class ShapeTypeIntOrLong(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
+        __slots__ = ()
+
         if isExperimental("nuitka_ilong"):
 
             @staticmethod
@@ -668,13 +680,15 @@ else:
 
 # TODO: Make this Python2 only, and use ShapeTypeIntDerived for Python3
 class ShapeTypeIntOrLongDerived(ShapeTypeUnknown):
-    pass
+    __slots__ = ()
 
 
 tshape_int_or_long_derived = ShapeTypeIntOrLongDerived()
 
 
 class ShapeTypeFloat(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = 0.1
 
     @staticmethod
@@ -722,13 +736,15 @@ tshape_float = ShapeTypeFloat()
 
 
 class ShapeTypeFloatDerived(ShapeTypeUnknown):
-    pass
+    __slots__ = ()
 
 
 tshape_float_derived = ShapeTypeFloatDerived()
 
 
 class ShapeTypeComplex(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = 0j
 
     @staticmethod
@@ -756,6 +772,8 @@ tshape_complex = ShapeTypeComplex()
 
 
 class ShapeTypeTuple(ShapeContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = ()
 
     @staticmethod
@@ -797,6 +815,8 @@ tshape_tuple = ShapeTypeTuple()
 
 
 class ShapeTypeNamedTuple(ShapeContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     @staticmethod
     def getTypeName():
         return "namedtuple"
@@ -837,6 +857,8 @@ tshape_namedtuple = ShapeTypeNamedTuple()
 
 
 class ShapeTypeTupleIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_tuple.typical_value)
 
     @staticmethod
@@ -852,6 +874,8 @@ tshape_tuple_iterator = ShapeTypeTupleIterator()
 
 
 class ShapeTypeList(ShapeContainerMutableMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = []
 
     @staticmethod
@@ -909,6 +933,8 @@ tshape_list = ShapeTypeList()
 
 
 class ShapeTypeListIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_list.typical_value)
 
     @staticmethod
@@ -924,6 +950,8 @@ tshape_list_iterator = ShapeTypeListIterator()
 
 
 class ShapeTypeSet(ShapeContainerMutableMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = set()
 
     @staticmethod
@@ -963,6 +991,8 @@ tshape_set = ShapeTypeSet()
 
 
 class ShapeTypeSetIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_set.typical_value)
 
     @staticmethod
@@ -978,6 +1008,8 @@ tshape_set_iterator = ShapeTypeSetIterator()
 
 
 class ShapeTypeFrozenset(ShapeContainerImmutableMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = frozenset()
 
     @staticmethod
@@ -1015,6 +1047,8 @@ _the_empty_dict = {}
 
 
 class ShapeTypeDict(ShapeContainerMutableMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = _the_empty_dict
 
     @staticmethod
@@ -1063,6 +1097,8 @@ tshape_dict = ShapeTypeDict()
 
 
 class ShapeTypeDictIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_dict.typical_value)
 
     @staticmethod
@@ -1080,6 +1116,8 @@ tshape_dict_iterator = ShapeTypeDictIterator()
 
 
 class ShapeTypeStr(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = "a"
 
     @staticmethod
@@ -1177,13 +1215,15 @@ tshape_str = ShapeTypeStr()
 
 
 class TypeShapeStrDerived(ShapeTypeUnknown):
-    pass
+    __slots__ = ()
 
 
 tshape_str_derived = TypeShapeStrDerived()
 
 
 class ShapeTypeStrIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_str.typical_value)
 
     @staticmethod
@@ -1201,6 +1241,8 @@ tshape_str_iterator = ShapeTypeStrIterator()
 if python_version < 0x300:
 
     class ShapeTypeUnicode(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+        __slots__ = ()
+
         typical_value = the_empty_unicode
 
         @staticmethod
@@ -1290,11 +1332,13 @@ if python_version < 0x300:
     tshape_unicode = ShapeTypeUnicode()
 
     class ShapeTypeUnicodeDerived(ShapeTypeUnknown):
-        pass
+        __slots__ = ()
 
     tshape_unicode_derived = ShapeTypeUnicodeDerived()
 
     class ShapeTypeUnicodeIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+        __slots__ = ()
+
         typical_value = iter(tshape_unicode.typical_value)
 
         @staticmethod
@@ -1315,6 +1359,8 @@ else:
 if python_version < 0x300:
 
     class ShapeTypeStrOrUnicode(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+        __slots__ = ()
+
         @staticmethod
         def emitAlternatives(emit):
             emit(tshape_str)
@@ -1380,7 +1426,7 @@ if python_version < 0x300:
     tshape_str_or_unicode = ShapeTypeStrOrUnicode()
 
     class ShapeTypeStrOrUnicodeDerived(ShapeTypeUnknown):
-        pass
+        __slots__ = ()
 
     tshape_str_or_unicode_derived = ShapeTypeStrOrUnicodeDerived()
 
@@ -1391,6 +1437,8 @@ else:
 if python_version >= 0x300:
 
     class ShapeTypeBytes(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+        __slots__ = ()
+
         typical_value = b"b"
 
         @staticmethod
@@ -1476,11 +1524,12 @@ if python_version >= 0x300:
     tshape_bytes = ShapeTypeBytes()
 
     class TypeShapeBytesDerived(ShapeTypeUnknown):
-        pass
+        __slots__ = ()
 
     tshape_bytes_derived = TypeShapeBytesDerived()
 
     class TypeShapeBytesIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+        __slots__ = ()
         typical_value = iter(tshape_bytes.typical_value)
 
         @staticmethod
@@ -1500,6 +1549,8 @@ _the_typical_bytearray_value = bytearray(b"b")
 
 
 class ShapeTypeBytearray(ShapeContainerMutableMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = _the_typical_bytearray_value
 
     @staticmethod
@@ -1555,6 +1606,8 @@ tshape_bytearray = ShapeTypeBytearray()
 
 
 class ShapeTypeBytearrayIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_bytearray.typical_value)
 
     @staticmethod
@@ -1570,6 +1623,8 @@ tshape_bytearray_iterator = ShapeTypeBytearrayIterator()
 
 
 class ShapeTypeEllipsis(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = Ellipsis
 
     @staticmethod
@@ -1595,6 +1650,8 @@ _the_typical_slice_value = slice(7)
 
 
 class ShapeTypeSlice(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = _the_typical_slice_value
 
     @staticmethod
@@ -1624,6 +1681,8 @@ _the_typical_xrange_value = (
 
 
 class ShapeTypeXrange(ShapeContainerImmutableMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = _the_typical_xrange_value
 
     @staticmethod
@@ -1668,6 +1727,8 @@ tshape_xrange = ShapeTypeXrange()
 
 
 class ShapeTypeXrangeIterator(ShapeIteratorMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = iter(tshape_xrange.typical_value)
 
     @staticmethod
@@ -1683,6 +1744,8 @@ tshape_xrange_iterator = ShapeTypeXrangeIterator()
 
 
 class ShapeTypeType(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = int
 
     @staticmethod
@@ -1711,6 +1774,8 @@ tshape_type = ShapeTypeType()
 
 
 class ShapeTypeModule(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     typical_value = __import__("sys")
 
     @staticmethod
@@ -1730,6 +1795,7 @@ tshape_module = ShapeTypeModule()
 
 
 class ShapeTypeFunction(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
     # TODO: Add typical value.
 
     @staticmethod
@@ -1745,6 +1811,8 @@ tshape_function = ShapeTypeFunction()
 
 
 class ShapeTypeBuiltinModule(ShapeTypeModule):
+    __slots__ = ()
+
     typical_value = __import__("_ctypes")
 
 
@@ -1752,6 +1820,7 @@ tshape_module_builtin = ShapeTypeBuiltinModule()
 
 
 class ShapeTypeFile(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
     # TODO: That need not really be a file, find something better.
     typical_value = __import__("sys").stdout
 
@@ -1781,6 +1850,8 @@ tshape_file = ShapeTypeFile()
 
 
 class ShapeTypeStaticmethod(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
+
     # TODO: Add typical value.
 
     @staticmethod
@@ -1794,6 +1865,7 @@ tshape_staticmethod = ShapeTypeStaticmethod()
 
 
 class ShapeTypeClassmethod(ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase):
+    __slots__ = ()
     # TODO: Add typical value.
 
     @staticmethod
@@ -4161,6 +4233,9 @@ if python_version >= 0x390:
 class ShapeTypeBuiltinExceptionClass(
     ShapeNotContainerMixin, ShapeNotNumberMixin, ShapeBase
 ):
+    __slots__ = ()
+
+    # TODO: Add a typical value, that should be easy.
     typical_value = None
 
 

nuitka/nodes/shapes/ShapeMixins.py

@@ -28,6 +28,9 @@ from .ControlFlowDescriptions import (
 class ShapeContainerMixin(object):
     """Mixin that defines the common container shape functions."""
 
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def hasShapeSlotBool():
         return True
@@ -62,18 +65,27 @@ class ShapeContainerMixin(object):
 
 
 class ShapeContainerMutableMixin(ShapeContainerMixin):
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def hasShapeSlotHash():
         return False
 
 
 class ShapeContainerImmutableMixin(ShapeContainerMixin):
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def hasShapeSlotHash():
         return True
 
 
 class ShapeNotContainerMixin(object):
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def hasShapeSlotBool():
         return True
@@ -106,6 +118,9 @@ class ShapeNotContainerMixin(object):
 class ShapeNotNumberMixin(object):
     """Mixin that defines the number slots to be set."""
 
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def hasShapeSlotBool():
         return True
@@ -138,6 +153,9 @@ class ShapeNotNumberMixin(object):
 class ShapeNumberMixin(object):
     """Mixin that defines the number slots to be set."""
 
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def hasShapeSlotBool():
         return True
@@ -180,6 +198,9 @@ class ShapeNumberMixin(object):
 
 
 class ShapeIteratorMixin(ShapeNotContainerMixin):
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def isShapeIterator():
         return True

nuitka/nodes/shapes/StandardShapes.py

@@ -19,17 +19,19 @@
 
 from abc import abstractmethod
 
-from nuitka.__past__ import getMetaClassBase
 from nuitka.code_generation.c_types.CTypePyObjectPointers import (
     CTypePyObjectPtr,
 )
 from nuitka.code_generation.Reports import onMissingOperation
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 from .ControlFlowDescriptions import ControlFlowDescriptionFullEscape
 from .ShapeMixins import ShapeIteratorMixin
 
 
-class ShapeBase(getMetaClassBase("Shape")):
+class ShapeBase(getMetaClassBase("Shape", require_slots=True)):
+    __slots__ = ()
+
     def __repr__(self):
         return "<%s %s %s>" % (
             self.__class__.__name__,
@@ -493,6 +495,8 @@ class ShapeBase(getMetaClassBase("Shape")):
 
 
 class ShapeTypeUnknown(ShapeBase):
+    __slots__ = ()
+
     @staticmethod
     def getOperationBinaryAddShape(right_shape):
         return operation_result_unknown
@@ -566,7 +570,7 @@ tshape_unknown = ShapeTypeUnknown()
 
 
 class ShapeTypeUninitialized(ShapeTypeUnknown):
-    pass
+    __slots__ = ()
 
 
 tshape_uninitialized = ShapeTypeUninitialized()
@@ -626,6 +630,8 @@ class ShapeLargeConstantValuePredictable(ShapeLargeConstantValue):
 class ShapeIterator(ShapeBase, ShapeIteratorMixin):
     """Iterator created by iter with 2 arguments, TODO: could be way more specific."""
 
+    __slots__ = ()
+
     @staticmethod
     def isShapeIterator():
         return None

nuitka/optimizations/OptimizeBuiltinCalls.py

@@ -882,7 +882,7 @@ def eval_extractor(node):
         )
 
         source_variable = outline_body.allocateTempVariable(
-            temp_scope=None, name="source"
+            temp_scope=None, name="source", temp_type="object"
         )
 
         final.setChildStatements(

nuitka/optimizations/TraceCollections.py

@@ -31,6 +31,8 @@ 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
@@ -526,6 +528,26 @@ class TraceCollectionBase(object):
 
         return variable_trace
 
+    def onVariableSetAliasing(self, variable, version, assign_node, source):
+        other_variable_trace = source.variable_trace
+
+        if other_variable_trace.__class__ is ValueTraceAssignUnescapable:
+            return self.onVariableSetToUnescapableValue(
+                variable=variable, version=version, assign_node=assign_node
+            )
+        elif other_variable_trace.__class__ is ValueTraceAssignVeryTrusted:
+            return self.onVariableSetToVeryTrustedValue(
+                variable=variable, version=version, assign_node=assign_node
+            )
+        else:
+            result = self.onVariableSet(
+                variable=variable, version=version, assign_node=assign_node
+            )
+
+            self.removeKnowledge(source)
+
+            return result
+
     def onVariableSetToUnescapableValue(self, variable, version, assign_node):
         variable_trace = ValueTraceAssignUnescapable(
             owner=self.owner,
@@ -1126,6 +1148,59 @@ class TraceCollectionModule(CollectionStartPointMixin, TraceCollectionBase):
         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",
+                            )
+                        )
+
         self.module_usage_attempts.add(module_usage_attempt)
 
     def getUsedDistributions(self):

nuitka/pgo/PGO.py

@@ -44,6 +44,14 @@ def _readStringValue(input_file):
     return _pgo_strings[_readCIntValue(input_file)]
 
 
+def _readModuleIdentifierValue(input_file):
+    module_identifier = _readStringValue(input_file)
+    if str is not bytes:
+        module_identifier = module_identifier.decode("utf8")
+
+    return module_identifier
+
+
 def readPGOInputFile(input_filename):
     """Read PGO information produced by a PGO run."""
 
@@ -84,21 +92,21 @@ def readPGOInputFile(input_filename):
             # Which probe is it.
             probe_name = _readStringValue(input_file)
 
-            if probe_name == "ModuleEnter":
-                module_name = _readStringValue(input_file)
+            if probe_name == b"ModuleEnter":
+                module_name = _readModuleIdentifierValue(input_file)
                 arg = _readCIntValue(input_file)
 
                 _module_entries[module_name] = arg
-            elif probe_name == "ModuleExit":
-                module_name = _readStringValue(input_file)
+            elif probe_name == b"ModuleExit":
+                module_name = _readModuleIdentifierValue(input_file)
                 had_error = _readCIntValue(input_file) != 0
 
                 _module_exits[module_name] = had_error
-            elif probe_name == "END":
+            elif probe_name == b"END":
                 break
             else:
                 pgo_logger.sysexit(
-                    "Error, unknown problem '%s' encountered." % probe_name
+                    "Error, unknown probe '%s' encountered." % probe_name
                 )
 
     _pgo_active = True