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

nuitka/importing/Recursion.py

@@ -28,7 +28,7 @@ from nuitka.freezer.ImportDetection import (
     detectEarlyImports,
     detectStdlibAutoInclusionModules,
 )
-from nuitka.importing import ImportCache, Importing, StandardLibrary
+from nuitka.importing import ImportCache, StandardLibrary
 from nuitka.ModuleRegistry import addUsedModule, getRootTopModule
 from nuitka.pgo.PGO import decideInclusionFromPGO
 from nuitka.plugins.Plugins import Plugins
@@ -38,6 +38,13 @@ from nuitka.utils.FileOperations import listDir
 from nuitka.utils.Importing import getSharedLibrarySuffixes
 from nuitka.utils.ModuleNames import ModuleName
 
+from .Importing import (
+    getModuleNameAndKindFromFilename,
+    isPackageDir,
+    locateModule,
+    warnAboutNotFoundImport,
+)
+
 
 def _recurseTo(module_name, module_filename, module_kind, reason):
     from nuitka.tree import Building
@@ -97,9 +104,38 @@ def recurseTo(
 _recursion_decision_cache = {}
 
 
+def getRecursionDecisions():
+    """Access to recursion decisions, intended only for reporting."""
+    return _recursion_decision_cache
+
+
 def decideRecursion(
     using_module_name, module_filename, module_name, module_kind, extra_recursion=False
 ):
+    package_part, _remainder = module_name.splitModuleBasename()
+
+    if package_part is not None:
+        (
+            _package_part,
+            package_filename,
+            package_module_kind,
+            package_finding,
+        ) = locateModule(module_name=package_part, parent_package=None, level=0)
+        assert _package_part == package_part
+
+        # For bad decisions, this may already not work.
+        if package_finding != "not-found":
+            package_decision, package_reason = decideRecursion(
+                using_module_name=using_module_name,
+                module_filename=package_filename,
+                module_name=package_part,
+                module_kind=package_module_kind,
+                extra_recursion=extra_recursion,
+            )
+
+            if package_decision is False:
+                return package_decision, package_reason
+
     key = using_module_name, module_filename, module_name, module_kind, extra_recursion
 
     if key not in _recursion_decision_cache:
@@ -111,6 +147,16 @@ def decideRecursion(
             extra_recursion,
         )
 
+        # If decided true, give the plugins a chance to e.g. add more hard
+        # module information, this indicates tentatively, that a module might
+        # get used, but it may also not happen at all.
+        if _recursion_decision_cache[key][0]:
+            Plugins.onModuleUsageLookAhead(
+                module_name=module_name,
+                module_filename=module_filename,
+                module_kind=module_kind,
+            )
+
     return _recursion_decision_cache[key]
 
 
@@ -125,6 +171,9 @@ def _decideRecursion(
     if module_kind == "extension" and not Options.isStandaloneMode():
         return False, "Extension modules cannot be inspected."
 
+    if module_kind == "built-in":
+        return False, "Built-in modules cannot be inspected."
+
     if module_name in detectEarlyImports():
         return True, "Technically required for CPython library startup."
 
@@ -164,7 +213,7 @@ def _decideRecursion(
         if plugin_decision and plugin_decision[0]:
             deciding_plugins[0].sysexit(
                 "Conflict between user and plugin decision for module '%s'."
-                % module_filename
+                % module_name
             )
 
         return False, "Module %s instructed by user to not follow to." % reason
@@ -177,7 +226,7 @@ def _decideRecursion(
         if plugin_decision and not plugin_decision[0] and deciding_plugins:
             deciding_plugins[0].sysexit(
                 "Conflict between user and plugin decision for module '%s'."
-                % module_filename
+                % module_name
             )
 
         return True, "Module %s instructed by user to follow to." % reason
@@ -247,8 +296,9 @@ def isSameModulePath(path1, path2):
     return os.path.abspath(path1) == os.path.abspath(path2)
 
 
-def _addIncludedModule(module):
-    # Many branches, for the decision is very complex, pylint: disable=too-many-branches
+def _addIncludedModule(module, package_only):
+    # Many branches, for the decision is very complex
+    # pylint: disable=too-many-branches
 
     if Options.isShowInclusion():
         recursion_logger.info(
@@ -281,16 +331,23 @@ def _addIncludedModule(module):
         if Options.isShowInclusion():
             recursion_logger.info("Package directory '%s'." % package_dir)
 
-        for sub_path, sub_filename in listDir(package_dir):
-            if sub_filename in ("__init__.py", "__pycache__"):
-                continue
-
-            if Importing.isPackageDir(sub_path) and not os.path.exists(
-                sub_path + ".py"
-            ):
-                checkPluginSinglePath(sub_path, module_package=module.getFullName())
-            elif sub_path.endswith(".py"):
-                checkPluginSinglePath(sub_path, module_package=module.getFullName())
+        if not package_only:
+            for sub_path, sub_filename in listDir(package_dir):
+                if sub_filename in ("__init__.py", "__pycache__"):
+                    continue
+
+                if isPackageDir(sub_path) and not os.path.exists(sub_path + ".py"):
+                    checkPluginSinglePath(
+                        sub_path,
+                        module_package=module.getFullName(),
+                        package_only=False,
+                    )
+                elif sub_path.endswith(".py"):
+                    checkPluginSinglePath(
+                        sub_path,
+                        module_package=module.getFullName(),
+                        package_only=False,
+                    )
 
     elif module.isCompiledPythonModule() or module.isUncompiledPythonModule():
         ModuleRegistry.addRootModule(module)
@@ -301,7 +358,7 @@ def _addIncludedModule(module):
         assert False, module
 
 
-def checkPluginSinglePath(plugin_filename, module_package):
+def checkPluginSinglePath(plugin_filename, module_package, package_only):
     # The importing wants these to be unique.
     plugin_filename = os.path.abspath(plugin_filename)
 
@@ -311,9 +368,7 @@ def checkPluginSinglePath(plugin_filename, module_package):
             % (plugin_filename, module_package)
         )
 
-    module_name, module_kind = Importing.getModuleNameAndKindFromFilename(
-        plugin_filename
-    )
+    module_name, module_kind = getModuleNameAndKindFromFilename(plugin_filename)
 
     module_name = ModuleName.makeModuleNameInPackage(module_name, module_package)
 
@@ -347,7 +402,7 @@ the compiled result, and therefore asking to include them makes no sense.
             )
 
             if module:
-                _addIncludedModule(module)
+                _addIncludedModule(module=module, package_only=package_only)
             else:
                 recursion_logger.warning(
                     "Failed to include module from '%s'." % plugin_filename
@@ -367,21 +422,33 @@ def checkPluginPath(plugin_filename, module_package):
         )
 
     # Files and package directories are handled here.
-    if os.path.isfile(plugin_filename) or Importing.isPackageDir(plugin_filename):
-        checkPluginSinglePath(plugin_filename, module_package=module_package)
+    if os.path.isfile(plugin_filename) or isPackageDir(plugin_filename):
+        checkPluginSinglePath(
+            plugin_filename,
+            module_package=module_package,
+            package_only=False,
+        )
     # This effectively only covers files known to not be packages due to name
     # or older Python version.
     elif os.path.isdir(plugin_filename):
         for sub_path, sub_filename in listDir(plugin_filename):
             assert sub_filename != "__init__.py"
 
-            if Importing.isPackageDir(sub_path) or sub_path.endswith(".py"):
-                checkPluginSinglePath(sub_path, module_package=None)
+            if isPackageDir(sub_path) or sub_path.endswith(".py"):
+                checkPluginSinglePath(
+                    sub_path,
+                    module_package=None,
+                    package_only=False,
+                )
                 continue
 
             for suffix in getSharedLibrarySuffixes():
                 if sub_path.endswith(suffix):
-                    checkPluginSinglePath(sub_path, module_package=None)
+                    checkPluginSinglePath(
+                        sub_path,
+                        module_package=None,
+                        package_only=False,
+                    )
 
     else:
         recursion_logger.warning(
@@ -405,7 +472,11 @@ def checkPluginFilenamePattern(pattern):
             continue
 
         found = True
-        checkPluginSinglePath(filename, module_package=None)
+        checkPluginSinglePath(
+            filename,
+            module_package=None,
+            package_only=False,
+        )
 
     if not found:
         recursion_logger.warning(
@@ -430,7 +501,7 @@ def considerUsedModules(module, pass_count):
                 continue
 
         if used_module.finding == "not-found":
-            Importing.warnAbout(
+            warnAboutNotFoundImport(
                 importing=module,
                 source_ref=used_module.source_ref,
                 module_name=used_module.module_name,

nuitka/importing/StandardLibrary.py

@@ -28,7 +28,6 @@ module.
 
 import os
 
-from nuitka.Options import shallUseStaticLibPython
 from nuitka.PythonVersions import python_version
 from nuitka.utils.FileOperations import getFileContents, isFilenameBelowPath
 from nuitka.utils.ModuleNames import ModuleName
@@ -104,10 +103,13 @@ def getStandardLibraryPaths():
             if os.path.isdir(candidate):
                 stdlib_paths.add(candidate)
 
-        if isWin32OrPosixWindows() and not shallUseStaticLibPython():
-            import _ctypes
+        if isWin32OrPosixWindows():
+            from nuitka.Options import shallUseStaticLibPython
 
-            stdlib_paths.add(os.path.dirname(_ctypes.__file__))
+            if not shallUseStaticLibPython():
+                import _ctypes
+
+                stdlib_paths.add(os.path.dirname(_ctypes.__file__))
 
         getStandardLibraryPaths.result = [
             os.path.normcase(os.path.normpath(stdlib_path))
@@ -358,6 +360,7 @@ _stdlib_no_auto_inclusion_list = (
     "tty",
     "termios",
     "this",
+    "textwrap",
     # Distribution and bytecode related stuff
     "plistlib",
     "distutils",

nuitka/nodes/BuiltinOpenNodes.py

@@ -30,7 +30,7 @@ from .shapes.BuiltinTypeShapes import tshape_file
 
 
 class ExpressionBuiltinOpenMixin(object):
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     @staticmethod
@@ -112,3 +112,30 @@ class ExpressionBuiltinOpenP3(
         )
 
         ExpressionBase.__init__(self, source_ref)
+
+
+def makeExpressionBuiltinsOpenCall(
+    filename,
+    mode,
+    buffering,
+    encoding,
+    errors,
+    newline,
+    closefd,
+    opener,
+    source_ref,
+):
+    """Function reference ctypes.CDLL"""
+
+    assert str is not bytes
+    return ExpressionBuiltinOpenP3(
+        filename=filename,
+        mode=mode,
+        buffering=buffering,
+        encoding=encoding,
+        errors=errors,
+        newline=newline,
+        closefd=closefd,
+        opener=opener,
+        source_ref=source_ref,
+    )

nuitka/nodes/BuiltinRangeNodes.py

@@ -47,7 +47,7 @@ from .shapes.BuiltinTypeShapes import tshape_xrange
 class ExpressionBuiltinRangeMixin(ExpressionListShapeExactMixin):
     """Mixin class for range nodes with 1/2/3 arguments."""
 
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     builtin_spec = BuiltinParameterSpecs.builtin_range_spec
@@ -403,7 +403,7 @@ class ExpressionBuiltinRange3(
 class ExpressionBuiltinXrangeMixin(object):
     """Mixin class for xrange nodes with 1/2/3 arguments."""
 
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     builtin_spec = BuiltinParameterSpecs.builtin_xrange_spec

nuitka/nodes/BuiltinSumNodes.py

@@ -32,7 +32,7 @@ from .ExpressionBases import ExpressionBase
 
 
 class ExpressionBuiltinSumMixin(object):
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     builtin_spec = BuiltinParameterSpecs.builtin_sum_spec

nuitka/nodes/ChildrenHavingMixins.py

@@ -6387,7 +6387,7 @@ class ChildHavingExpressionMixin(object):
     #   ExpressionMatchArgs
     #   ExpressionYield
     #   ExpressionYieldFrom
-    #   ExpressionYieldFromWaitable
+    #   ExpressionYieldFromAwaitable
 
     def __init__(
         self,
@@ -6660,7 +6660,7 @@ ChildrenExpressionAttributeLookupTypePrepareMixin = ChildHavingExpressionMixin
 ChildrenExpressionMatchArgsMixin = ChildHavingExpressionMixin
 ChildrenExpressionYieldMixin = ChildHavingExpressionMixin
 ChildrenExpressionYieldFromMixin = ChildHavingExpressionMixin
-ChildrenExpressionYieldFromWaitableMixin = ChildHavingExpressionMixin
+ChildrenExpressionYieldFromAwaitableMixin = ChildHavingExpressionMixin
 
 
 class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
@@ -7355,6 +7355,330 @@ ChildrenExpressionLocalsMappingVariableRefOrFallbackMixin = ChildHavingFallbackM
 ChildrenExpressionLocalsVariableRefOrFallbackMixin = ChildHavingFallbackMixin
 
 
+class ChildrenHavingFileModeOptionalBufferingOptionalEncodingOptionalErrorsOptionalNewlineOptionalClosefdOptionalOpenerOptionalMixin(
+    object
+):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionBuiltinsOpen
+
+    def __init__(
+        self,
+        file,
+        mode,
+        buffering,
+        encoding,
+        errors,
+        newline,
+        closefd,
+        opener,
+    ):
+        file.parent = self
+
+        self.subnode_file = file
+
+        if mode is not None:
+            mode.parent = self
+
+        self.subnode_mode = mode
+
+        if buffering is not None:
+            buffering.parent = self
+
+        self.subnode_buffering = buffering
+
+        if encoding is not None:
+            encoding.parent = self
+
+        self.subnode_encoding = encoding
+
+        if errors is not None:
+            errors.parent = self
+
+        self.subnode_errors = errors
+
+        if newline is not None:
+            newline.parent = self
+
+        self.subnode_newline = newline
+
+        if closefd is not None:
+            closefd.parent = self
+
+        self.subnode_closefd = closefd
+
+        if opener is not None:
+            opener.parent = self
+
+        self.subnode_opener = opener
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        result.append(self.subnode_file)
+        value = self.subnode_mode
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_buffering
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_encoding
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_errors
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_newline
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_closefd
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_opener
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("file", self.subnode_file),
+            ("mode", self.subnode_mode),
+            ("buffering", self.subnode_buffering),
+            ("encoding", self.subnode_encoding),
+            ("errors", self.subnode_errors),
+            ("newline", self.subnode_newline),
+            ("closefd", self.subnode_closefd),
+            ("opener", self.subnode_opener),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_file
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_file = new_node
+
+            return
+
+        value = self.subnode_mode
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_mode = new_node
+
+            return
+
+        value = self.subnode_buffering
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_buffering = new_node
+
+            return
+
+        value = self.subnode_encoding
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_encoding = new_node
+
+            return
+
+        value = self.subnode_errors
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_errors = new_node
+
+            return
+
+        value = self.subnode_newline
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_newline = new_node
+
+            return
+
+        value = self.subnode_closefd
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_closefd = new_node
+
+            return
+
+        value = self.subnode_opener
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_opener = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "file": self.subnode_file.makeClone(),
+            "mode": self.subnode_mode.makeClone()
+            if self.subnode_mode is not None
+            else None,
+            "buffering": self.subnode_buffering.makeClone()
+            if self.subnode_buffering is not None
+            else None,
+            "encoding": self.subnode_encoding.makeClone()
+            if self.subnode_encoding is not None
+            else None,
+            "errors": self.subnode_errors.makeClone()
+            if self.subnode_errors is not None
+            else None,
+            "newline": self.subnode_newline.makeClone()
+            if self.subnode_newline is not None
+            else None,
+            "closefd": self.subnode_closefd.makeClone()
+            if self.subnode_closefd is not None
+            else None,
+            "opener": self.subnode_opener.makeClone()
+            if self.subnode_opener is not None
+            else None,
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_file.finalize()
+        del self.subnode_file
+        if self.subnode_mode is not None:
+            self.subnode_mode.finalize()
+        del self.subnode_mode
+        if self.subnode_buffering is not None:
+            self.subnode_buffering.finalize()
+        del self.subnode_buffering
+        if self.subnode_encoding is not None:
+            self.subnode_encoding.finalize()
+        del self.subnode_encoding
+        if self.subnode_errors is not None:
+            self.subnode_errors.finalize()
+        del self.subnode_errors
+        if self.subnode_newline is not None:
+            self.subnode_newline.finalize()
+        del self.subnode_newline
+        if self.subnode_closefd is not None:
+            self.subnode_closefd.finalize()
+        del self.subnode_closefd
+        if self.subnode_opener is not None:
+            self.subnode_opener.finalize()
+        del self.subnode_opener
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        self.subnode_file.collectVariableAccesses(emit_read, emit_write)
+        subnode_mode = self.subnode_mode
+
+        if subnode_mode is not None:
+            self.subnode_mode.collectVariableAccesses(emit_read, emit_write)
+        subnode_buffering = self.subnode_buffering
+
+        if subnode_buffering is not None:
+            self.subnode_buffering.collectVariableAccesses(emit_read, emit_write)
+        subnode_encoding = self.subnode_encoding
+
+        if subnode_encoding is not None:
+            self.subnode_encoding.collectVariableAccesses(emit_read, emit_write)
+        subnode_errors = self.subnode_errors
+
+        if subnode_errors is not None:
+            self.subnode_errors.collectVariableAccesses(emit_read, emit_write)
+        subnode_newline = self.subnode_newline
+
+        if subnode_newline is not None:
+            self.subnode_newline.collectVariableAccesses(emit_read, emit_write)
+        subnode_closefd = self.subnode_closefd
+
+        if subnode_closefd is not None:
+            self.subnode_closefd.collectVariableAccesses(emit_read, emit_write)
+        subnode_opener = self.subnode_opener
+
+        if subnode_opener is not None:
+            self.subnode_opener.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionBuiltinsOpenMixin = ChildrenHavingFileModeOptionalBufferingOptionalEncodingOptionalErrorsOptionalNewlineOptionalClosefdOptionalOpenerOptionalMixin
+
+
 class ChildrenHavingFilenameModeOptionalBufferingOptionalMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()