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

nuitka/nodes/MatchNodes.py

@@ -1,42 +1,33 @@
-#     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
+
+
 """ Nodes for match statement for Python3.10+ """
 
-from .ChildrenHavingMixins import ChildHavingExpressionMixin
+from .ChildrenHavingMixins import ChildrenHavingExpressionMatchTypeMixin
 from .ExpressionBases import ExpressionBase
 from .ExpressionShapeMixins import ExpressionTupleShapeExactMixin
 
 
 class ExpressionMatchArgs(
-    ExpressionTupleShapeExactMixin, ChildHavingExpressionMixin, ExpressionBase
+    ExpressionTupleShapeExactMixin,
+    ChildrenHavingExpressionMatchTypeMixin,
+    ExpressionBase,
 ):
     kind = "EXPRESSION_MATCH_ARGS"
 
-    named_children = ("expression",)
+    named_children = ("expression", "match_type")
 
-    __slots__ = ("max_allowed",)
+    __slots__ = ("positional_count", "keywords")
 
-    def __init__(self, expression, max_allowed, source_ref):
-        ChildHavingExpressionMixin.__init__(self, expression=expression)
+    def __init__(self, expression, match_type, max_allowed, keywords, source_ref):
+        ChildrenHavingExpressionMatchTypeMixin.__init__(
+            self, expression=expression, match_type=match_type
+        )
 
         ExpressionBase.__init__(self, source_ref)
 
-        self.max_allowed = max_allowed
+        self.positional_count = max_allowed
+        self.keywords = tuple(keywords)
 
     def computeExpression(self, trace_collection):
         # TODO: May know that match args doesn't raise from the shape of
@@ -45,3 +36,25 @@ class ExpressionMatchArgs(
         trace_collection.onExceptionRaiseExit(BaseException)
 
         return self, None, None
+
+    def getPositionalArgsCount(self):
+        return self.positional_count
+
+    def getKeywordArgs(self):
+        return self.keywords
+
+
+#     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/ModuleAttributeNodes.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
+
+
 """ Module/Package attribute nodes
 
 The represent special values of the modules. The "__name__", "__package__",
@@ -30,7 +16,7 @@ quickly, in others they will present boundaries for optimization.
 from nuitka import Options
 
 from .ConstantRefNodes import makeConstantRefNode
-from .ExpressionBases import ExpressionBase, ExpressionNoSideEffectsMixin
+from .ExpressionBases import ExpressionBase
 
 
 class ExpressionModuleAttributeBase(ExpressionBase):
@@ -178,20 +164,17 @@ class ExpressionModuleAttributeSpecRef(ExpressionModuleAttributeBase):
         return self, None, None
 
 
-class ExpressionNuitkaLoaderCreation(ExpressionNoSideEffectsMixin, ExpressionBase):
-    __slots__ = ("provider",)
-
-    kind = "EXPRESSION_NUITKA_LOADER_CREATION"
-
-    def __init__(self, provider, source_ref):
-        ExpressionBase.__init__(self, source_ref)
-
-        self.provider = provider
-
-    def finalize(self):
-        del self.parent
-        del self.provider
-
-    def computeExpressionRaw(self, trace_collection):
-        # Nothing can be done here.
-        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/ModuleNodes.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
+
+
 """ Module/Package nodes
 
 The top of the tree. Packages are also modules. Modules are what hold a program
@@ -34,6 +20,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.SourceCodeReferences import fromFilename
 from nuitka.tree.SourceHandling import parsePyIFile, readSourceCodeFromFilename
 from nuitka.utils.CStrings import encodePythonIdentifierToC
+from nuitka.utils.Importing import getPackageDirFilename
 from nuitka.utils.ModuleNames import ModuleName
 
 from .ChildrenHavingMixins import (
@@ -57,6 +44,7 @@ class PythonModuleBase(NodeBase):
 
     def __init__(self, module_name, reason, source_ref):
         assert type(module_name) is ModuleName, module_name
+        assert module_name != "", source_ref
 
         NodeBase.__init__(self, source_ref=source_ref)
 
@@ -144,7 +132,7 @@ class PythonModuleBase(NodeBase):
             )
 
     def getCodeName(self):
-        # Abstract method, pylint: disable=no-self-use
+        # Virtual method, pylint: disable=no-self-use
         return None
 
     def getCompileTimeFilename(self):
@@ -194,7 +182,10 @@ class PythonModuleBase(NodeBase):
             current = filename
 
             levels = full_name.count(".")
-            if self.isCompiledPythonPackage():
+            if (
+                self.isCompiledPythonPackage()
+                and not self.isCompiledPythonNamespacePackage()
+            ):
                 levels += 1
 
             for _i in range(levels):
@@ -202,8 +193,19 @@ class PythonModuleBase(NodeBase):
 
                 result = os.path.join(os.path.basename(current), result)
 
+            # Avoid unnecessary unicode path values
+            if str is not bytes:
+                try:
+                    result = str(result)
+                except UnicodeDecodeError:
+                    pass
+
             return result
 
+    @staticmethod
+    def isExtensionModulePackage():
+        return False
+
 
 class CompiledPythonModule(
     ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin,
@@ -453,7 +455,10 @@ class CompiledPythonModule(
         # For code name of modules, we need to translate to C identifiers,
         # removing characters illegal for that.
 
-        return encodePythonIdentifierToC(self.getFullName())
+        if self.code_name is None:
+            self.code_name = encodePythonIdentifierToC(self.module_name)
+
+        return self.code_name
 
     @staticmethod
     def getChildQualname(function_name):
@@ -474,6 +479,11 @@ class CompiledPythonModule(
         self.used_modules = None
 
     def getUsedModules(self):
+        if self.trace_collection is None:
+            # Optimization is not yet done at all, but report writing for error
+            # exit may happen.
+            return ()
+
         return self.trace_collection.getModuleUsageAttempts()
 
     def getUsedDistributions(self):
@@ -538,9 +548,11 @@ class CompiledPythonModule(
 
         self.trace_collection = TraceCollectionModule(
             self,
-            very_trusted_module_variables=old_collection.getVeryTrustedModuleVariables()
-            if old_collection is not None
-            else {},
+            very_trusted_module_variables=(
+                old_collection.getVeryTrustedModuleVariables()
+                if old_collection is not None
+                else {}
+            ),
         )
 
         module_body = self.subnode_body
@@ -707,6 +719,10 @@ class CompiledPythonPackage(CompiledPythonModule):
             source_ref=source_ref,
         )
 
+    @staticmethod
+    def isCompiledPythonPackage():
+        return True
+
     def getOutputFilename(self):
         result = self.getFilename()
 
@@ -720,6 +736,14 @@ class CompiledPythonPackage(CompiledPythonModule):
         return not hasPythonFlagIsolated()
 
 
+class CompiledPythonNamespacePackage(CompiledPythonPackage):
+    kind = "COMPILED_PYTHON_NAMESPACE_PACKAGE"
+
+    @staticmethod
+    def isCompiledPythonNamespacePackage():
+        return True
+
+
 def makeUncompiledPythonModule(
     module_name, reason, filename, bytecode, is_package, technical
 ):
@@ -934,7 +958,7 @@ class PythonMainModule(CompiledPythonModule):
             )
 
             # Technically required, but not found must not happen
-            assert finding != "not-found"
+            assert finding != "not-found", early_module_name
 
             self.standard_library_modules.add(
                 makeModuleUsageAttempt(
@@ -952,13 +976,14 @@ class PythonMainModule(CompiledPythonModule):
 class PythonExtensionModule(PythonModuleBase):
     kind = "PYTHON_EXTENSION_MODULE"
 
-    __slots__ = ("used_modules", "technical")
+    __slots__ = ("used_modules", "module_filename", "technical", "is_package")
 
     avoid_duplicates = set()
 
     def __init__(
         self,
         module_name,
+        module_filename,
         reason,
         technical,
         source_ref,
@@ -986,11 +1011,22 @@ class PythonExtensionModule(PythonModuleBase):
 
         self.used_modules = None
 
+        if os.path.isdir(module_filename):
+            module_filename = getPackageDirFilename(module_filename)
+            self.is_package = True
+        else:
+            self.is_package = False
+
+        self.module_filename = module_filename
+
+    def isExtensionModulePackage(self):
+        return self.is_package
+
     def finalize(self):
         del self.used_modules
 
     def getFilename(self):
-        return self.source_ref.getFilename()
+        return self.module_filename
 
     @staticmethod
     def startTraversal():
@@ -1000,24 +1036,31 @@ class PythonExtensionModule(PythonModuleBase):
         """Must be present as it's used in CPython library initialization."""
         return self.technical
 
-    def getPyIFilename(self):
+    def _getPyIFilename(self):
         """Get Python type description filename."""
 
         path = self.getFilename()
         filename = os.path.basename(path)
         dirname = os.path.dirname(path)
 
-        return os.path.join(dirname, filename.split(".")[0]) + ".pyi"
+        for suffix in (".pyi", ".py"):
+            candidate = os.path.join(dirname, filename.split(".")[0]) + suffix
+
+            if os.path.exists(candidate):
+                return candidate
+
+        return None
 
     def _readPyIFile(self):
         """Read the .pyi file if present and scan for dependencies."""
 
         if self.used_modules is None:
-            pyi_filename = self.getPyIFilename()
+            pyi_filename = self._getPyIFilename()
 
-            if os.path.exists(pyi_filename):
+            if pyi_filename is not None:
                 pyi_deps = parsePyIFile(
-                    module_name=self.getFullName(), pyi_filename=pyi_filename
+                    module_name=self.getFullName(),
+                    pyi_filename=pyi_filename,
                 )
 
                 # These are not to be taken serious.
@@ -1057,3 +1100,19 @@ class PythonExtensionModule(PythonModuleBase):
 
     def getParentModule(self):
         return self
+
+
+#     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/NetworkxNodes.py

@@ -0,0 +1,45 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes that represent networkx functions
+
+"""
+
+from nuitka.HardImportRegistry import addModuleDynamicHard
+
+# TODO: Disabled for now, keyword only arguments and star list argument are
+# having ordering issues for call matching and code generation.
+
+if False:  # pylint: disable=using-constant-test
+    from .HardImportNodesGenerated import (  # pylint: disable=no-name-in-module
+        ExpressionNetworkxUtilsDecoratorsArgmapCallBase,
+    )
+
+    addModuleDynamicHard(module_name="networkx.utils.decorators")
+
+    class ExpressionNetworkxUtilsDecoratorsArgmapCall(
+        ExpressionNetworkxUtilsDecoratorsArgmapCallBase
+    ):
+        kind = "EXPRESSION_NETWORKX_UTILS_DECORATORS_ARGMAP_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/NodeBases.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
+
+
 """ Node base classes.
 
 These classes provide the generic base classes available for nodes,
@@ -28,7 +14,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 +24,7 @@ from nuitka.utils.InstanceCounters import (
     counted_init,
     isCountingInstances,
 )
+from nuitka.Variables import TempVariable
 
 from .FutureSpecs import fromFlags
 from .NodeMakingHelpers import makeStatementOnlyNodesFromExpressions
@@ -198,6 +185,19 @@ class NodeBase(NodeMetaClassBase):
 
         return parent
 
+    def getContainingLoopNode(self):
+        """Return the parent that is module."""
+        parent = self.parent
+
+        while parent is not None and not parent.isExpressionFunctionBodyBase():
+
+            if parent.isStatementLoop():
+                return parent
+
+            parent = parent.getParent()
+
+        return parent
+
     def isParentVariableProvider(self):
         # Check if it's a closure giver, in which cases it can provide variables,
         return isinstance(self, ClosureGiverNodeMixin)
@@ -327,13 +327,18 @@ class NodeBase(NodeMetaClassBase):
     def isStatementsFrame():
         return False
 
+    @staticmethod
+    def isStatementsSequenceButNotFrame():
+        return False
+
     @staticmethod
     def isCompiledPythonModule():
         # For overload by module nodes
         return False
 
-    def isExpressionBuiltin(self):
-        return self.kind.startswith("EXPRESSION_BUILTIN_")
+    @staticmethod
+    def isExpressionBuiltin():
+        return False
 
     @staticmethod
     def isStatementAssignmentVariable():
@@ -379,6 +384,10 @@ class NodeBase(NodeMetaClassBase):
     def isExpressionMakeSequence():
         return False
 
+    @staticmethod
+    def isExpressionVariableRefOrTempVariableRef():
+        return False
+
     @staticmethod
     def isNumberConstant():
         return False
@@ -399,10 +408,6 @@ class NodeBase(NodeMetaClassBase):
     def isExpressionClassBodyBase():
         return False
 
-    @staticmethod
-    def isExpressionImportModuleNameHard():
-        return False
-
     @staticmethod
     def isExpressionFunctionCreation():
         return False
@@ -417,6 +422,11 @@ class NodeBase(NodeMetaClassBase):
     def getVisitableNodes():
         return ()
 
+    def checkChildren(self):
+        for c in self.getVisitableNodes():
+            assert c.parent is self, (c, "parent", self, "!=", c.parent)
+            c.checkChildren()
+
     @staticmethod
     def getVisitableNodesNamed():
         """Named children dictionary.
@@ -470,7 +480,7 @@ class NodeBase(NodeMetaClassBase):
         return False
 
     def needsFrame(self):
-        """Unless we are tolder otherwise, this depends on exception raise."""
+        """Unless we are told otherwise, this depends on exception raise."""
 
         return self.mayRaiseException(BaseException)
 
@@ -508,17 +518,18 @@ class CodeNodeMixin(object):
             provider = self.getParentVariableProvider().getEntryPoint()
             parent_name = provider.getCodeName()
 
-            uid = "_%d" % provider.getChildUID(self)
-
-            assert isinstance(self, CodeNodeMixin)
-
-            if self.name:
-                name = uid + "_" + self.name.strip("<>")
+            if self.code_prefix == "helper_function":
+                name = self.name
             else:
-                name = uid
+                uid = "_%d" % provider.getChildUID(self)
+
+                if self.name:
+                    name = uid + "_" + self.name.strip("<>")
+                else:
+                    name = uid
 
-            if str is not bytes:
-                name = name.encode("ascii", "c_identifier").decode()
+                if str is not bytes:
+                    name = name.encode("ascii", "c_identifier").decode()
 
             self.code_name = "%s$$$%s_%s" % (parent_name, self.code_prefix, name)
 
@@ -567,7 +578,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 +602,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
 
@@ -721,6 +729,11 @@ class StatementBase(NodeBase):
             expression = trace_collection.onExpression(expression)
 
             if expression.willRaiseAnyException():
+                # They probably have changed.
+                expressions = self.getVisitableNodes()
+
+                child_name = expression.getChildNameNice()
+
                 wrapped_expression = makeStatementOnlyNodesFromExpressions(
                     expressions[: count + 1]
                 )
@@ -731,7 +744,7 @@ class StatementBase(NodeBase):
                     wrapped_expression,
                     "new_raise",
                     lambda: "For %s the child expression '%s' will raise."
-                    % (self.getStatementNiceName(), expression.getChildNameNice()),
+                    % (self.getStatementNiceName(), child_name),
                 )
 
         return self, None, None
@@ -858,3 +871,19 @@ def fromXML(provider, xml, source_ref=None):
     except (TypeError, AttributeError):
         Tracing.printLine(node_class, args, source_ref)
         raise
+
+
+#     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.