Nuitka-winsvc 2.1.6__cp311-cp311-win_amd64.whl → 2.2.2__cp311-cp311-win_amd64.whl

nuitka/nodes/ImportHardNodes.py

@@ -3,7 +3,11 @@
 
 """ Nodes representing more trusted imports. """
 
-from nuitka.importing.Importing import locateModule, makeModuleUsageAttempt
+from nuitka.importing.Importing import (
+    locateModule,
+    makeModuleUsageAttempt,
+    makeParentModuleUsagesAttempts,
+)
 from nuitka.utils.ModuleNames import ModuleName
 
 from .ExpressionBases import ExpressionBase
@@ -12,7 +16,13 @@ from .ExpressionBases import ExpressionBase
 class ExpressionImportHardBase(ExpressionBase):
     # Base classes can be abstract, pylint: disable=abstract-method
     #
-    __slots__ = ("module_name", "finding", "module_kind", "module_filename")
+    __slots__ = (
+        "module_name",
+        "finding",
+        "module_kind",
+        "module_filename",
+        "module_usages",
+    )
 
     def __init__(self, module_name, source_ref):
         ExpressionBase.__init__(self, source_ref)
@@ -34,17 +44,21 @@ class ExpressionImportHardBase(ExpressionBase):
         assert self.finding != "not-found", self.module_name
         assert _module_name == self.module_name, (self.module_name, _module_name)
 
-    def getModuleUsageAttempt(self):
-        return makeModuleUsageAttempt(
-            module_name=self.module_name,
-            filename=self.module_filename,
-            module_kind=self.module_kind,
-            finding=self.finding,
-            level=0,
-            source_ref=self.source_ref,
-            reason="import",
+        self.module_usages = makeParentModuleUsagesAttempts(
+            makeModuleUsageAttempt(
+                module_name=self.module_name,
+                filename=self.module_filename,
+                module_kind=self.module_kind,
+                finding=self.finding,
+                level=0,
+                source_ref=self.source_ref,
+                reason="import",
+            )
         )
 
+    def getModuleUsageAttempts(self):
+        return self.module_usages
+
 
 class ExpressionImportModuleNameHardBase(ExpressionImportHardBase):
     """Hard import names base class."""
@@ -96,7 +110,7 @@ class ExpressionImportModuleNameHardMaybeExists(ExpressionImportModuleNameHardBa
         trace_collection.onExceptionRaiseExit(AttributeError)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         return self, None, None
 
@@ -122,7 +136,7 @@ class ExpressionImportModuleNameHardExists(ExpressionImportModuleNameHardBase):
             trace_collection.onExceptionRaiseExit(ImportError)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         # As good as it gets.
         return self, None, None

nuitka/nodes/ImportNodes.py

@@ -37,6 +37,7 @@ from nuitka.importing.Importing import (
     isPackageDir,
     locateModule,
     makeModuleUsageAttempt,
+    makeParentModuleUsagesAttempts,
 )
 from nuitka.importing.ImportResolving import resolveModuleName
 from nuitka.importing.Recursion import decideRecursion
@@ -47,6 +48,7 @@ from nuitka.Options import (
     shallMakeModule,
     shallWarnUnusualCode,
 )
+from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonVersions import python_version
 from nuitka.specs.BuiltinParameterSpecs import (
     BuiltinParameterSpec,
@@ -139,6 +141,7 @@ class ExpressionImportModuleFixed(ExpressionBase):
         "found_module_filename",
         "module_kind",
         "finding",
+        "module_usages",
     )
 
     def __init__(self, module_name, value_name, source_ref):
@@ -157,6 +160,18 @@ class ExpressionImportModuleFixed(ExpressionBase):
             self.finding,
         ) = self._attemptFollow()
 
+        self.module_usages = makeParentModuleUsagesAttempts(
+            makeModuleUsageAttempt(
+                module_name=self.found_module_name,
+                filename=self.found_module_filename,
+                finding=self.finding,
+                module_kind=self.module_kind,
+                level=0,
+                source_ref=self.source_ref,
+                reason="import",
+            )
+        )
+
     # TODO: This is called in constructor only, is it, then inline it.
     def _attemptFollow(self):
         found_module_name, found_module_filename, module_kind, finding = locateModule(
@@ -218,23 +233,15 @@ class ExpressionImportModuleFixed(ExpressionBase):
         else:
             return tshape_module
 
-    def getModuleUsageAttempt(self):
-        return makeModuleUsageAttempt(
-            module_name=self.found_module_name,
-            filename=self.found_module_filename,
-            finding=self.finding,
-            module_kind=self.module_kind,
-            level=0,
-            source_ref=self.source_ref,
-            reason="import",
-        )
+    def getModuleUsageAttempts(self):
+        return self.module_usages
 
     def computeExpressionRaw(self, trace_collection):
         if self.mayRaiseException(BaseException):
             trace_collection.onExceptionRaiseExit(BaseException)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         # Nothing to do about it.
         return self, None, None
@@ -263,6 +270,7 @@ class ExpressionImportModuleBuiltin(ExpressionBase):
         "value_name",
         "module_kind",
         "builtin_module",
+        "module_usages",
     )
 
     def __init__(self, module_name, value_name, source_ref):
@@ -284,6 +292,18 @@ class ExpressionImportModuleBuiltin(ExpressionBase):
         assert _finding == "built-in", _finding
         assert _module_kind is None, _module_kind
 
+        self.module_usages = makeParentModuleUsagesAttempts(
+            makeModuleUsageAttempt(
+                module_name=self.module_name,
+                filename=None,
+                finding="built-in",
+                module_kind=None,
+                level=0,
+                source_ref=self.source_ref,
+                reason="import",
+            )
+        )
+
     @staticmethod
     def getTypeShape():
         return tshape_module_builtin
@@ -310,23 +330,15 @@ class ExpressionImportModuleBuiltin(ExpressionBase):
     def mayRaiseException(self, exception_type):
         return isNonRaisingBuiltinModule(self.module_name) is not False
 
-    def getModuleUsageAttempt(self):
-        return makeModuleUsageAttempt(
-            module_name=self.module_name,
-            filename=None,
-            finding="built-in",
-            module_kind=None,
-            level=0,
-            source_ref=self.source_ref,
-            reason="import",
-        )
+    def getModuleUsageAttempts(self):
+        return self.module_usages
 
     def computeExpressionRaw(self, trace_collection):
         if self.mayRaiseException(BaseException):
             trace_collection.onExceptionRaiseExit(BaseException)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         # Nothing to do about it.
         return self, None, None
@@ -428,7 +440,7 @@ class ExpressionImportModuleHard(
             trace_collection.onExceptionRaiseExit(BaseException)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         return self, None, None
 
@@ -479,14 +491,16 @@ class ExpressionImportModuleHard(
     def _computeExpressionAttribute(
         self, lookup_node, attribute_name, trace_collection, is_import
     ):
-        # Return driven handling of many cases, pylint: disable=too-many-return-statements
+        # Return driven handling of many cases
+        # pylint: disable=too-many-branches,too-many-return-statements
 
-        if self.module is not None and self.allowed:
+        if self.allowed:
             full_name = self.value_name.getChildNamed(attribute_name)
-
             full_name = ModuleName(hard_modules_aliases.get(full_name, full_name))
 
             if isHardModule(full_name):
+                trace_collection.onExceptionRaiseExit(BaseException)
+
                 new_node = ExpressionImportModuleHard(
                     using_module_name=self.using_module_name,
                     module_name=full_name,
@@ -501,9 +515,12 @@ class ExpressionImportModuleHard(
                     % (self.value_name, attribute_name),
                 )
 
-            trust = hard_modules_trust[self.value_name].get(
-                attribute_name, trust_undefined
-            )
+            if self.value_name in hard_modules_trust:
+                trust = hard_modules_trust[self.value_name].get(
+                    attribute_name, trust_undefined
+                )
+            else:
+                trust = trust_undefined
 
             if trust is trust_importable:
                 # TODO: Change this is a hard module import itself, currently these are not all trusted
@@ -512,8 +529,10 @@ class ExpressionImportModuleHard(
                 trace_collection.onExceptionRaiseExit(BaseException)
             elif trust is trust_may_exist:
                 trace_collection.onExceptionRaiseExit(BaseException)
-            elif trust is not trust_undefined and not hasattr(
-                self.module, attribute_name
+            elif (
+                trust is not trust_undefined
+                and self.module is not None
+                and not hasattr(self.module, attribute_name)
             ):
                 # TODO: Unify with below branches.
                 trace_collection.onExceptionRaiseExit(ImportError)
@@ -573,7 +592,7 @@ class ExpressionImportModuleHard(
                         self.value_name,
                         attribute_name,
                     )
-                elif trust is trust_constant:
+                elif trust is trust_constant and self.module is not None:
                     # Make sure it's actually there, and not becoming the getattr default by accident.
                     assert hasattr(self.module, attribute_name), self
 
@@ -795,6 +814,30 @@ addModuleSingleAttributeNodeFactory(
 )
 
 
+def _makeParentImportModuleUsages(module_name, source_ref):
+    for parent_package_name in module_name.getParentPackageNames():
+        (
+            _parent_package_name,
+            parent_module_filename,
+            parent_module_kind,
+            parent_module_finding,
+        ) = locateModule(
+            module_name=parent_package_name,
+            parent_package=None,
+            level=0,
+        )
+
+        yield makeModuleUsageAttempt(
+            module_name=parent_package_name,
+            filename=parent_module_filename,
+            finding=parent_module_finding,
+            module_kind=parent_module_kind,
+            level=0,
+            source_ref=source_ref,
+            reason="import path parent",
+        )
+
+
 class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBase):
     __slots__ = (
         "follow_attempted",
@@ -850,7 +893,7 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
             return level_value
 
     def _attemptFollow(self, module_name):
-        # Complex stuff, pylint: disable=too-many-branches,too-many-locals
+        # Complex stuff, pylint: disable=too-many-branches
 
         # Without the level value, we don't know what it is.
         level_value = self._getLevelValue()
@@ -885,7 +928,15 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
             level=level_value,
         )
 
-        self.used_modules = [
+        # Allow for the import look ahead, to change what modules are
+        # considered hard imports.
+        Plugins.onModuleUsageLookAhead(
+            module_name=module_name_found,
+            module_filename=module_filename,
+            module_kind=module_kind,
+        )
+
+        self.used_modules = makeParentModuleUsagesAttempts(
             makeModuleUsageAttempt(
                 module_name=module_name_found,
                 filename=module_filename,
@@ -895,7 +946,7 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                 source_ref=self.source_ref,
                 reason="import",
             )
-        ]
+        )
 
         if self.finding != "not-found":
             module_name = module_name_found
@@ -929,6 +980,8 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                         level=1,  # Relative import
                     )
 
+                    self.used_modules = list(self.used_modules)
+
                     self.used_modules.append(
                         makeModuleUsageAttempt(
                             module_name=name_import_module_name,
@@ -937,44 +990,14 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                             finding=name_import_finding,
                             level=1,
                             source_ref=self.source_ref,
-                            reason="import",
+                            reason="import fromlist",
                         )
                     )
 
+                self.used_modules = tuple(self.used_modules)
+
             return module_filename
         else:
-            while True:
-                module_name = module_name.getPackageName()
-
-                if not module_name:
-                    break
-
-                (
-                    found_module_name,
-                    module_filename,
-                    module_kind,
-                    finding,
-                ) = locateModule(
-                    module_name=module_name,
-                    parent_package=parent_package,
-                    level=level_value,
-                )
-
-                self.used_modules.append(
-                    makeModuleUsageAttempt(
-                        module_name=found_module_name,
-                        filename=module_filename,
-                        module_kind=module_kind,
-                        finding=finding,
-                        level=level_value,
-                        source_ref=self.source_ref,
-                        reason="import",
-                    )
-                )
-
-                if finding != "not-found":
-                    break
-
             return None
 
     def _getImportedValueName(self, imported_module_name):
@@ -999,8 +1022,7 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                 trace_collection.onExceptionRaiseExit(RuntimeError)
 
             # Trace the module usage attempts.
-            for module_usage_attempt in self.used_modules:
-                trace_collection.onModuleUsageAttempt(module_usage_attempt)
+            trace_collection.onModuleUsageAttempts(self.used_modules)
 
             # We stay here.
             return self, None, None

nuitka/nodes/InjectCNodes.py

@@ -3,7 +3,6 @@
 
 """ Nodes to inject C code into generated code. """
 
-
 from .NodeBases import StatementBase
 
 

nuitka/nodes/ModuleNodes.py

@@ -131,7 +131,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):
@@ -450,7 +450,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):
@@ -540,9 +543,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

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/OperatorNodesUnary.py

@@ -5,6 +5,7 @@
 
 Some of these come from built-ins, e.g. abs, some from syntax, and repr from both.
 """
+
 from nuitka import PythonOperators
 
 from .ChildrenHavingMixins import ChildHavingOperandMixin

nuitka/nodes/OsSysNodes.py

@@ -3,7 +3,6 @@
 
 """ Nodes the represent ways to access os and sys functions. """
 
-
 import os
 
 from .BuiltinRefNodes import ExpressionBuiltinExceptionRef

nuitka/nodes/PackageMetadataNodes.py

@@ -5,7 +5,6 @@
 
 """
 
-
 from nuitka.Constants import isCompileTimeConstantValue
 from nuitka.Options import isStandaloneMode, shallMakeModule
 from nuitka.Tracing import inclusion_logger

nuitka/nodes/PackageResourceNodes.py

@@ -28,9 +28,11 @@ from .NodeBases import SideEffectsFromChildrenMixin
 
 
 class ExpressionPkgutilGetDataCall(
-    ExpressionBytesShapeExactMixin
-    if str is not bytes
-    else ExpressionStrShapeExactMixin,
+    (
+        ExpressionBytesShapeExactMixin
+        if str is not bytes
+        else ExpressionStrShapeExactMixin
+    ),
     SideEffectsFromChildrenMixin,
     ExpressionPkgutilGetDataCallBase,
 ):
@@ -45,9 +47,11 @@ class ExpressionPkgutilGetDataCall(
 
 
 class ExpressionPkgResourcesResourceStringCall(
-    ExpressionBytesShapeExactMixin
-    if str is not bytes
-    else ExpressionStrShapeExactMixin,
+    (
+        ExpressionBytesShapeExactMixin
+        if str is not bytes
+        else ExpressionStrShapeExactMixin
+    ),
     SideEffectsFromChildrenMixin,
     ExpressionPkgResourcesResourceStringCallBase,
 ):