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

nuitka/nodes/shapes/ShapeMixins.py

@@ -1,33 +1,24 @@
-#     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
+
+
 """ Mixins to use for composing type shapes.
 
 """
 
 from .ControlFlowDescriptions import (
+    ControlFlowDescriptionAddUnsupported,
     ControlFlowDescriptionElementBasedEscape,
     ControlFlowDescriptionNoEscape,
+    ControlFlowDescriptionSubUnsupported,
 )
 
 
 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 +53,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 +106,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
@@ -130,14 +133,26 @@ class ShapeNotNumberMixin(object):
     def hasShapeSlotComplex():
         return False
 
+    # TODO: Seems misplaced
     @staticmethod
     def hasShapeModule():
         return False
 
+    @staticmethod
+    def getOperationUnaryAddShape():
+        return None, ControlFlowDescriptionAddUnsupported
+
+    @staticmethod
+    def getOperationUnarySubShape():
+        return None, ControlFlowDescriptionSubUnsupported
+
 
 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
@@ -178,8 +193,17 @@ class ShapeNumberMixin(object):
     def getOperationUnaryReprEscape():
         return ControlFlowDescriptionNoEscape
 
+    def getOperationUnaryAddShape(self):
+        return self, ControlFlowDescriptionNoEscape
+
+    def getOperationUnarySubShape(self):
+        return self, ControlFlowDescriptionNoEscape
+
 
 class ShapeIteratorMixin(ShapeNotContainerMixin):
+    # Mixins are required to define empty slots
+    __slots__ = ()
+
     @staticmethod
     def isShapeIterator():
         return True
@@ -212,3 +236,19 @@ class ShapeIteratorMixin(ShapeNotContainerMixin):
     @staticmethod
     def hasShapeSlotHash():
         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/nodes/shapes/StandardShapes.py

@@ -1,35 +1,26 @@
-#     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
+
+
 """ Standard shapes that commonly appear. """
 
 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.code_generation.Reports import (
+    onMissingOperation,
+    onMissingUnaryOperation,
+)
+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__,
@@ -458,6 +449,16 @@ class ShapeBase(getMetaClassBase("Shape")):
 
             return operation_result_unknown
 
+    def getOperationUnaryAddShape(self):
+        onMissingUnaryOperation("+", self)
+
+        return operation_result_unknown
+
+    def getOperationUnarySubShape(self):
+        onMissingUnaryOperation("-", self)
+
+        return operation_result_unknown
+
     def getComparisonLtShape(self, right_shape):
         onMissingOperation("Lt", self, right_shape)
 
@@ -493,6 +494,8 @@ class ShapeBase(getMetaClassBase("Shape")):
 
 
 class ShapeTypeUnknown(ShapeBase):
+    __slots__ = ()
+
     @staticmethod
     def getOperationBinaryAddShape(right_shape):
         return operation_result_unknown
@@ -553,6 +556,12 @@ class ShapeTypeUnknown(ShapeBase):
     def getOperationBinaryMatMultShape(right_shape):
         return operation_result_unknown
 
+    def getOperationUnaryAddShape(self):
+        return operation_result_unknown
+
+    def getOperationUnarySubShape(self):
+        return operation_result_unknown
+
     @staticmethod
     def getComparisonLtShape(right_shape):
         return operation_result_unknown
@@ -566,7 +575,7 @@ tshape_unknown = ShapeTypeUnknown()
 
 
 class ShapeTypeUninitialized(ShapeTypeUnknown):
-    pass
+    __slots__ = ()
 
 
 tshape_uninitialized = ShapeTypeUninitialized()
@@ -626,6 +635,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
@@ -658,6 +669,13 @@ class ShapeIterator(ShapeBase, ShapeIteratorMixin):
     def getOperationUnaryReprEscape():
         return ControlFlowDescriptionFullEscape
 
+    def getOperationUnaryAddShape(self):
+        # TODO: Move prepared values to separate module
+        return tshape_unknown, ControlFlowDescriptionFullEscape
+
+    def getOperationUnarySubShape(self):
+        return tshape_unknown, ControlFlowDescriptionFullEscape
+
 
 tshape_iterator = ShapeIterator()
 
@@ -906,6 +924,22 @@ class ShapeLoopInitialAlternative(ShapeBase):
                 ControlFlowDescriptionFullEscape,
             )
 
+    def getOperationUnaryAddShape(self):
+        return (
+            self._collectInitialShape(
+                operation=lambda left_shape: left_shape.getOperationUnaryAddShape()
+            ),
+            ControlFlowDescriptionFullEscape,
+        )
+
+    def getOperationUnarySubShape(self):
+        return (
+            self._collectInitialShape(
+                operation=lambda left_shape: left_shape.getOperationUnarySubShape()
+            ),
+            ControlFlowDescriptionFullEscape,
+        )
+
     def getComparisonLtShape(self, right_shape):
         if right_shape is tshape_unknown:
             return operation_result_unknown
@@ -1170,6 +1204,16 @@ class ShapeLoopCompleteAlternative(ShapeBase):
             )
         )
 
+    def getOperationUnaryAddShape(self):
+        return self._collectShapeOperation(
+            operation=lambda left_shape: left_shape.getOperationUnaryAddShape()
+        )
+
+    def getOperationUnarySubShape(self):
+        return self._collectShapeOperation(
+            operation=lambda left_shape: left_shape.getOperationUnarySubShape()
+        )
+
     # Special method to be called by other shapes encountering this type on
     # the right side.
     def getOperationBinaryAddLShape(self, left_shape):
@@ -1372,3 +1416,18 @@ class ShapeLoopCompleteAlternative(ShapeBase):
 tshape_unknown_loop = ShapeLoopCompleteAlternative(shapes=(tshape_unknown,))
 
 operation_result_unknown = tshape_unknown, ControlFlowDescriptionFullEscape
+
+#     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/shapes/__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/optimizations/BytecodeDemotion.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
+
+
 """ Demotion of compiled modules to bytecode modules.
 
 """
@@ -37,6 +23,7 @@ from nuitka.plugins.Plugins import (
     replaceTriggerModule,
 )
 from nuitka.Tracing import inclusion_logger
+from nuitka.utils.FileOperations import getNormalizedPath
 
 
 def demoteSourceCodeToBytecode(module_name, source_code, filename):
@@ -73,7 +60,7 @@ def demoteCompiledModuleToBytecode(module):
     uncompiled_module = makeUncompiledPythonModule(
         module_name=full_name,
         reason=module.reason,
-        filename=filename,
+        filename=getNormalizedPath(filename),
         bytecode=bytecode,
         is_package=module.isCompiledPythonPackage(),
         technical=full_name in detectEarlyImports(),
@@ -100,3 +87,19 @@ def demoteCompiledModuleToBytecode(module):
         used_modules=used_modules,
         distribution_names=distribution_names,
     )
+
+
+#     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/FunctionInlining.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
+
+
 """ In-lining of functions.
 
 Done by assigning the argument values to variables, and producing an outline
@@ -23,10 +9,9 @@ from the in-lined function.
 
 from nuitka.nodes.OutlineNodes import ExpressionOutlineBody
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
-from nuitka.nodes.VariableReleaseNodes import makeStatementsReleaseVariables
 from nuitka.tree.Operations import VisitorNoopMixin, visitTree
 from nuitka.tree.ReformulationTryFinallyStatements import (
-    makeTryFinallyStatement,
+    makeTryFinallyReleaseStatement,
 )
 from nuitka.tree.TreeHelpers import makeStatementsSequence
 
@@ -97,15 +82,29 @@ def convertFunctionCallToOutline(provider, function_body, values, call_source_re
 
     # TODO: Not possible to auto release with outline bodies too?
     if auto_releases:
-        body = makeTryFinallyStatement(
+        body = makeTryFinallyReleaseStatement(
             provider=outline_body,
             tried=body,
-            final=makeStatementsReleaseVariables(
-                variables=auto_releases, source_ref=function_source_ref
-            ),
+            variables=auto_releases,
             source_ref=function_source_ref,
         )
 
     outline_body.setChildBody(body)
 
     return outline_body
+
+
+#     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/Graphs.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
+
+
 """ Graph optimization states.
 
 These are not the graphs you might be thinking of. This is for rending the
@@ -66,3 +52,19 @@ def endGraph(output_filename):
             _addModuleGraph(module, "final")
 
         graph.draw(output_filename + ".dot", prog="dot")
+
+
+#     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/Optimization.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
+
+
 """ Control the flow of optimizations applied to node tree.
 
 Applies abstract execution on all so far known modules until no more
@@ -22,7 +8,6 @@ optimization is possible. Every successful optimization to anything might
 make others possible.
 """
 
-
 import inspect
 
 from nuitka import ModuleRegistry, Options, Variables
@@ -41,7 +26,7 @@ from nuitka.utils.Timing import TimerReport
 from . import Graphs
 from .BytecodeDemotion import demoteCompiledModuleToBytecode
 from .Tags import TagSet
-from .TraceCollections import withChangeIndicationsTo
+from .TraceCollections import fetchMergeCounts, withChangeIndicationsTo
 
 tag_set = None
 
@@ -83,7 +68,12 @@ def optimizeCompiledPythonModule(module):
     # allow to continue the loop even without changes one more time.
     unchanged_count = 0
 
+    # Count the micro passes, so we can see how often we looped
+    micro_pass = 0
+
     while True:
+        micro_pass += 1
+
         tag_set.clear()
 
         try:
@@ -135,7 +125,7 @@ def optimizeCompiledPythonModule(module):
 
     considerUsedModules(module=module, pass_count=pass_count)
 
-    return touched
+    return touched, micro_pass
 
 
 def optimizeUncompiledPythonModule(module):
@@ -171,14 +161,12 @@ def optimizeModule(module):
 
     if module.isPythonExtensionModule():
         optimizeExtensionModule(module)
-        changed = False
+        return False, 0
     elif module.isCompiledPythonModule():
-        changed = optimizeCompiledPythonModule(module)
+        return optimizeCompiledPythonModule(module)
     else:
         optimizeUncompiledPythonModule(module)
-        changed = False
-
-    return changed
+        return False, 0
 
 
 pass_count = 0
@@ -227,11 +215,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
+            ),
         )
 
 
@@ -263,8 +253,6 @@ def restoreFromXML(text):
 def makeOptimizationPass():
     """Make a single pass for optimization, indication potential completion."""
 
-    # Controls complex optimization
-
     finished = True
 
     ModuleRegistry.startTraversal()
@@ -297,14 +285,14 @@ def makeOptimizationPass():
         with TimerReport(
             message="Optimizing %s" % module_name, decider=False
         ) as module_timer:
-            changed = optimizeModule(current_module)
-
-            # module_timer=module_time_report.getTimer()
+            changed, micro_passes = optimizeModule(current_module)
 
         ModuleRegistry.addModuleOptimizationTimeInformation(
             module_name=module_name,
             pass_number=pass_count,
             time_used=module_timer.getDelta(),
+            micro_passes=micro_passes,
+            merge_counts=fetchMergeCounts(),
         )
 
         _traceProgressModuleEnd(current_module)
@@ -357,3 +345,19 @@ def optimizeModules(output_filename):
         finished = makeOptimizationPass()
 
     Graphs.endGraph(output_filename)
+
+
+#     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.