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

nuitka/optimizations/TraceCollections.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
+
+
 """ Trace collection (also often still referred to as constraint collection).
 
 At the core of value propagation there is the collection of constraints that
@@ -65,6 +51,16 @@ from .ValueTraces import (
     ValueTraceUnknown,
 )
 
+# Keeping trace of how often branches are merged between calls
+_merge_counts = defaultdict(int)
+
+
+def fetchMergeCounts():
+    result = dict(_merge_counts)
+    _merge_counts.clear()
+    return result
+
+
 signalChange = None
 
 
@@ -203,10 +199,10 @@ class CollectionStartPointMixin(CollectionUpdateMixin):
 
         # TODO: We might want to track per exception, pylint: disable=unused-argument
 
-        if collection is None:
-            collection = self
-
         if self.exception_collections is not None:
+            if collection is None:
+                collection = self
+
             self.exception_collections.append(
                 TraceCollectionBranch(parent=collection, name="exception")
             )
@@ -526,6 +522,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,
@@ -748,6 +764,8 @@ class TraceCollectionBase(object):
             collection1 = collection_yes
             collection2 = collection_no
 
+        _merge_counts[2] += 1
+
         variable_versions = {}
 
         for variable, version in iterItems(collection1.variable_actives):
@@ -780,7 +798,7 @@ class TraceCollectionBase(object):
 
                 if trace1.isEscapeTrace() and trace1.previous is trace2:
                     version = versions[0]
-                elif trace2 is trace1.isEscapeTrace() and trace2.previous is trace1:
+                elif trace2.isEscapeTrace() and trace2.previous is trace1:
                     version = versions[1]
                 else:
                     version = self.addVariableMergeMultipleTrace(
@@ -810,10 +828,11 @@ class TraceCollectionBase(object):
         elif merge_size == 2:
             return self.mergeBranches(*collections)
 
-        # print("Enter mergeMultipleBranches", len(collections))
+        _merge_counts[len(collections)] += 1
+
         with TimerReport(
             message="Running merge for %s took %%.2f seconds" % collections,
-            decider=lambda: 0,
+            decider=False,
         ):
             variable_versions = defaultdict(OrderedSet)
 
@@ -868,6 +887,8 @@ class TraceCollectionBase(object):
         self.variable_actives.update(collection_replace.variable_actives)
         collection_replace.variable_actives = None
 
+        _merge_counts[1] += 1
+
     def onLoopBreak(self, collection=None):
         if collection is None:
             collection = self
@@ -941,6 +962,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)
 
@@ -1051,7 +1075,7 @@ class TraceCollectionFunction(CollectionStartPointMixin, TraceCollectionBase):
         if trusted_node is None:
             return CollectionStartPointMixin.initVariableModule(self, variable)
 
-        assign_trace = ValueTraceAssign(
+        assign_trace = ValueTraceAssignVeryTrusted(
             self.owner, assign_node=trusted_node.getParent(), previous=None
         )
 
@@ -1125,6 +1149,9 @@ class TraceCollectionModule(CollectionStartPointMixin, TraceCollectionBase):
     def getModuleUsageAttempts(self):
         return self.module_usage_attempts
 
+    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)
 
@@ -1212,3 +1239,19 @@ def areReadOnlyTraces(variable_traces):
             assert False, variable_trace
 
     return True
+
+
+#     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/optimizations/ValueTraces.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
+
+
 """ Value trace objects.
 
 Value traces indicate the flow of values and merges their versions for
@@ -32,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,
@@ -89,9 +83,15 @@ class ValueTraceBase(object):
     def __repr__(self):
         return "<%s of %s>" % (self.__class__.__name__, self.owner.getCodeName())
 
-    def dump(self, indent):
+    def dump(self, indent="  "):
         my_print("%s%s %s:" % (indent, self.__class__.__name__, id(self)))
 
+        if type(self.previous) is tuple:
+            for trace in self.previous:
+                trace.dump(indent + "  ")
+        elif self.previous is not None:
+            self.previous.dump(indent + "  ")
+
     def getOwner(self):
         return self.owner
 
@@ -152,6 +152,10 @@ class ValueTraceBase(object):
     def isUnknownTrace():
         return False
 
+    @staticmethod
+    def isAssignTraceVeryTrusted():
+        return False
+
     @staticmethod
     def isUnknownOrVeryTrustedTrace():
         return False
@@ -446,6 +450,12 @@ class ValueTraceUnknown(ValueTraceBase):
 class ValueTraceEscaped(ValueTraceUnknown):
     __slots__ = ()
 
+    def __init__(self, owner, previous):
+        if previous.isMergeTrace():
+            assert self not in previous.previous
+
+        ValueTraceUnknown.__init__(self, owner=owner, previous=previous)
+
     def addUsage(self):
         self.usage_count += 1
 
@@ -462,6 +472,9 @@ class ValueTraceEscaped(ValueTraceUnknown):
         if self.merge_usage_count <= 2:
             self.previous.addMergeUsage()
 
+    def getTypeShape(self):
+        return self.previous.getTypeShape()
+
     def mustHaveValue(self):
         return self.previous.mustHaveValue()
 
@@ -603,6 +616,10 @@ class ValueTraceAssignUnescapable(ValueTraceAssign):
 
 
 class ValueTraceAssignVeryTrusted(ValueTraceAssignUnescapable):
+    @staticmethod
+    def isAssignTraceVeryTrusted():
+        return True
+
     @staticmethod
     def isUnknownOrVeryTrustedTrace():
         return True
@@ -649,12 +666,6 @@ class ValueTraceMergeBase(ValueTraceBase):
         self.addUsage()
         self.merge_usage_count += 1
 
-    def dump(self, indent):
-        ValueTraceBase.dump(self, indent)
-
-        for trace in self.previous:
-            trace.dump(indent + "  ")
-
 
 class ValueTraceMerge(ValueTraceMergeBase):
     """Merge of two or more traces.
@@ -844,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__ = ()
@@ -911,3 +962,19 @@ class ValueTraceLoopIncomplete(ValueTraceLoopBase):
     @staticmethod
     def getComparisonValue():
         return False, 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/optimizations/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """

nuitka/pgo/PGO.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
+
+
 """Python level PGO handling in Nuitka."""
 
 import os
@@ -44,6 +30,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 +78,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
@@ -148,3 +142,19 @@ def decideCompilationFromPGO(module_name):
         return "bytecode"
     else:
         return 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/pgo/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """