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

nuitka/importing/Recursion.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
+
+
 """ Recursion into other modules.
 
 """
@@ -28,7 +14,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 +24,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 +90,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 +133,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]
 
 
@@ -122,13 +154,23 @@ def _decideRecursion(
     if module_name == "__main__":
         return False, "Main program is not followed to a second time."
 
+    if using_module_name == "__main__" and Options.isMultidistMode():
+        return True, "Main program multidist entry points."
+
     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."
 
-    if module_name in detectStdlibAutoInclusionModules():
+    is_stdlib = module_filename is not None and StandardLibrary.isStandardLibraryPath(
+        module_filename
+    )
+
+    if is_stdlib and module_name in detectStdlibAutoInclusionModules():
         return True, "Including as part of the non-excluded parts of standard library."
 
     # In '-m' mode, when including the package, do not duplicate main program.
@@ -164,7 +206,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 +219,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
@@ -193,7 +235,6 @@ def _decideRecursion(
 
     # PGO decisions are not overruling plugins, but all command line options, they are
     # supposed to be applied already.
-    is_stdlib = StandardLibrary.isStandardLibraryPath(module_filename)
 
     if not is_stdlib or Options.shallFollowStandardLibrary():
         # TODO: Bad placement of this function or should PGO also know about
@@ -201,7 +242,12 @@ def _decideRecursion(
         from nuitka.tree.Building import decideCompilationMode
 
         if (
-            decideCompilationMode(is_top=False, module_name=module_name, for_pgo=True)
+            decideCompilationMode(
+                is_top=False,
+                module_name=module_name,
+                module_filename=module_filename,
+                for_pgo=True,
+            )
             == "compiled"
         ):
             pgo_decision = decideInclusionFromPGO(
@@ -247,8 +293,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 +328,34 @@ 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_filename.endswith(".py"):
+                    checkPluginSinglePath(
+                        sub_path,
+                        module_package=module.getFullName(),
+                        package_only=False,
+                    )
+                else:
+                    for suffix in getSharedLibrarySuffixes():
+                        if (
+                            sub_filename.endswith(suffix)
+                            and "." not in sub_filename[: -len(suffix)]
+                        ):
+                            checkPluginSinglePath(
+                                sub_path,
+                                module_package=module.getFullName(),
+                                package_only=False,
+                            )
 
     elif module.isCompiledPythonModule() or module.isUncompiledPythonModule():
         ModuleRegistry.addRootModule(module)
@@ -301,7 +366,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 +376,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 +410,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 +430,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 +480,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 +509,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,
@@ -485,3 +564,19 @@ def considerUsedModules(module, pass_count):
             "Error, forbidden import of '%s' (intending to avoid '%s') done implicitly by module '%s'."
             % (e.args[0], e.args[1], module.getFullName())
         )
+
+
+#     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/importing/StandardLibrary.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
+
+
 """ Access to standard library distinction.
 
 For code to be in the standard library means that it's not written by the
@@ -28,11 +14,11 @@ 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
 from nuitka.utils.Utils import (
+    isMacOS,
     isNetBSD,
     isPosixWindows,
     isWin32OrPosixWindows,
@@ -104,10 +90,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
+
+            if not shallUseStaticLibPython():
+                import _ctypes
 
-            stdlib_paths.add(os.path.dirname(_ctypes.__file__))
+                stdlib_paths.add(os.path.dirname(_ctypes.__file__))
 
         getStandardLibraryPaths.result = [
             os.path.normcase(os.path.normpath(stdlib_path))
@@ -117,11 +106,7 @@ def getStandardLibraryPaths():
     return getStandardLibraryPaths.result
 
 
-def isStandardLibraryPath(filename):
-    """Check if a path is in the standard library."""
-
-    filename = os.path.normcase(os.path.normpath(filename))
-
+def _isStandardLibraryPath(filename):
     # In virtualenv, the "site.py" lives in a place that suggests it is not in
     # standard library, although it is.
     if os.path.basename(filename) == "site.py":
@@ -142,50 +127,69 @@ def isStandardLibraryPath(filename):
     return False
 
 
-# Some modules we want to exclude entirely.
-_excluded_stdlib_modules = ["__main__.py", "__init__.py", "antigravity.py"]
+_is_standard_library_path_cache = {}
 
-if not isWin32Windows():
-    # On posix systems, and posix Python variants on Windows, this won't
-    # work.
-    _excluded_stdlib_modules.append("wintypes.py")
-    _excluded_stdlib_modules.append("cp65001.py")
+
+def isStandardLibraryPath(filename):
+    """Check if a path is in the standard library."""
+
+    filename = os.path.normcase(os.path.normpath(filename))
+
+    if filename not in _is_standard_library_path_cache:
+        _is_standard_library_path_cache[filename] = _isStandardLibraryPath(filename)
+
+    return _is_standard_library_path_cache[filename]
 
 
 def scanStandardLibraryPath(stdlib_dir):
     # There is a lot of filtering here, done in branches, so there is many of
-    # them, but that's acceptable, pylint: disable=too-many-branches,too-many-statements
+    # them, but that's acceptable, pylint: disable=too-many-branches
 
     for root, dirs, filenames in os.walk(stdlib_dir):
         import_path = root[len(stdlib_dir) :].strip("/\\")
         import_path = import_path.replace("\\", ".").replace("/", ".")
 
+        def _removeFilenamesIfPresent(*remove_filenames):
+            # pylint: intended for loop usage, pylint: disable=cell-var-from-loop
+            for remove_filename in remove_filenames:
+                if remove_filename in filenames:
+                    filenames.remove(remove_filename)
+
+        def _removeDirsIfPresent(*remove_dirs):
+            # pylint: intended for loop usage, pylint: disable=cell-var-from-loop
+            for remove_dir in remove_dirs:
+                if remove_dir in dirs:
+                    dirs.remove(remove_dir)
+
+        _removeDirsIfPresent("__pycache__")
+
+        # Ignore ".idea", ".git" and similar folders, they are not modules
+        dirs[:] = [dirname for dirname in dirs if not dirname.startswith(".")]
+
         if import_path == "":
-            if "site-packages" in dirs:
-                dirs.remove("site-packages")
-            if "dist-packages" in dirs:
-                dirs.remove("dist-packages")
-            if "vendor-packages" in dirs:
-                dirs.remove("vendor-packages")
-            if "test" in dirs:
-                dirs.remove("test")
-            if "turtledemo" in dirs:
-                dirs.remove("turtledemo")
-
-            if "ensurepip" in filenames:
-                filenames.remove("ensurepip")
-            if "ensurepip" in dirs:
-                dirs.remove("ensurepip")
-
-            # Ignore "lib-dynload" and "lib-tk" and alike.
+            # Ignore "lib-dynload" and "lib-tk" and alike, spell-checker: ignore dynload
             dirs[:] = [
                 dirname
                 for dirname in dirs
                 if not dirname.startswith("lib-")
-                if dirname != "Tools"
                 if not dirname.startswith("plat-")
             ]
 
+            _removeDirsIfPresent(
+                "site-packages",
+                "dist-packages",
+                "vendor-packages",
+                "test",
+                "ensurepip",
+                "turtledemo",
+                "Tools",
+            )
+            _removeFilenamesIfPresent("ensurepip")
+
+            if not isMacOS():
+                _removeFilenamesIfPresent("_ios_support.py")
+
+        # Ignore tests from selected packages, spell-checker: ignore bsddb
         if import_path in (
             "tkinter",
             "Tkinter",
@@ -197,38 +201,40 @@ def scanStandardLibraryPath(stdlib_dir):
             "email",
             "bsddb",
         ):
-            if "test" in dirs:
-                dirs.remove("test")
+            _removeDirsIfPresent("test")
+
+        if import_path in ("lib2to3", "json", "distutils"):
+            _removeDirsIfPresent("tests")
 
         if import_path == "distutils.command":
             # Misbehaving and crashing while importing the world.
-            if "bdist_conda.py" in filenames:
-                filenames.remove("bdist_conda.py")
-
-        if import_path in ("lib2to3", "json", "distutils"):
-            if "tests" in dirs:
-                dirs.remove("tests")
+            _removeFilenamesIfPresent("bdist_conda.py")
 
         if import_path == "asyncio":
-            if "test_utils.py" in filenames:
-                filenames.remove("test_utils.py")
+            _removeFilenamesIfPresent("test_utils.py")
 
-        if python_version >= 0x340 and isWin32Windows():
+        if python_version >= 0x300 and isPosixWindows():
             if import_path == "multiprocessing":
-                filenames.remove("popen_fork.py")
-                filenames.remove("popen_forkserver.py")
-                filenames.remove("popen_spawn_posix.py")
+                _removeFilenamesIfPresent(
+                    "popen_fork.py", "popen_forkserver.py", "popen_spawn_posix.py"
+                )
 
-        if python_version >= 0x300 and isPosixWindows():
             if import_path == "curses":
-                filenames.remove("has_key.py")
+                _removeFilenamesIfPresent("has_key.py")
 
         if isNetBSD():
             if import_path == "xml.sax":
-                filenames.remove("expatreader.py")
+                _removeFilenamesIfPresent("expatreader.py")
+
+        _removeFilenamesIfPresent("__main__.py", "__init__.py", "antigravity.py")
+
+        if not isWin32Windows():
+            # On POSIX systems, and on POSIX Python variants on Windows, this
+            # won't work.
+            _removeFilenamesIfPresent("wintypes.py", "cp65001.py")
 
         for filename in filenames:
-            if filename.endswith(".py") and filename not in _excluded_stdlib_modules:
+            if filename.endswith(".py"):
                 module_name = filename[:-3]
 
                 if import_path == "":
@@ -236,13 +242,6 @@ def scanStandardLibraryPath(stdlib_dir):
                 else:
                     yield ModuleName(import_path + "." + module_name)
 
-        if python_version >= 0x300:
-            if "__pycache__" in dirs:
-                dirs.remove("__pycache__")
-
-        # Ignore ".idea", ".git" and similar folders, they are not modules
-        dirs = [dirname for dirname in dirs if not dirname.startswith(".")]
-
         for dirname in dirs:
             if import_path == "":
                 yield ModuleName(dirname)
@@ -253,6 +252,7 @@ def scanStandardLibraryPath(stdlib_dir):
 _stdlib_no_auto_inclusion_list = (
     # Avoid this to be included, implicit usages will be rare, but it triggers
     # the Nuitka plugin "multiprocessing" that is always enabled.
+    # spell-checker: ignore _pydecimal,_posixsubprocess,pyexpat,sitecustomize
     "multiprocessing",
     "_multiprocessing",
     # Implicit usages of these will be rare, but it can have that costly extension module
@@ -338,7 +338,6 @@ _stdlib_no_auto_inclusion_list = (
     # Packages that will be imported rarely by extension modules
     "email",
     "mailbox",
-    "calendar",
     "argparse",
     "telnetlib",
     "smtplib",
@@ -359,6 +358,7 @@ _stdlib_no_auto_inclusion_list = (
     "tty",
     "termios",
     "this",
+    "textwrap",
     # Distribution and bytecode related stuff
     "plistlib",
     "distutils",
@@ -367,13 +367,13 @@ _stdlib_no_auto_inclusion_list = (
     "py_compile",
     "msilib",
     "_opcode",
-    # tzdata is not always needed
+    # time zone data is not always needed
     "zoneinfo",
     # tkinter under all its names
     "Tkinter",
     "tkinter",
     "_tkinter",
-    # lib-tk from Python2
+    # lib-tk from Python2, spell-checker: ignore Tkdnd,Tkconstants
     "Tix",
     "FixTk",
     "ScrolledText",
@@ -411,3 +411,19 @@ if not isWin32Windows():
 
 def isStandardLibraryNoAutoInclusionModule(module_name):
     return module_name.hasOneOfNamespaces(*_stdlib_no_auto_inclusion_list)
+
+
+#     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/importing/__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. """