Nuitka-winsvc 2.3.9__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/tree/ReformulationWithStatements.py

@@ -34,7 +34,6 @@ from nuitka.nodes.StatementNodes import (
 )
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
 from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 from nuitka.nodes.YieldNodes import ExpressionYieldFromAwaitable
 from nuitka.PythonVersions import python_version
 
@@ -42,7 +41,10 @@ from .ReformulationAssignmentStatements import buildAssignmentStatements
 from .ReformulationTryExceptStatements import (
     makeTryExceptSingleHandlerNodeWithPublish,
 )
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import (
+    makeTryFinallyReleaseStatement,
+    makeTryFinallyStatement,
+)
 from .TreeHelpers import (
     buildNode,
     buildStatementsNode,
@@ -285,19 +287,13 @@ def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref
         ),
     )
 
-    return makeTryFinallyStatement(
+    return makeTryFinallyReleaseStatement(
         provider=provider,
         tried=statements,
-        final=(
-            makeStatementReleaseVariable(
-                variable=tmp_source_variable, source_ref=with_exit_source_ref
-            ),
-            makeStatementReleaseVariable(
-                variable=tmp_enter_variable, source_ref=with_exit_source_ref
-            ),
-            makeStatementReleaseVariable(
-                variable=tmp_exit_variable, source_ref=with_exit_source_ref
-            ),
+        variables=(
+            tmp_source_variable,
+            tmp_enter_variable,
+            tmp_exit_variable,
         ),
         source_ref=source_ref,
     )
@@ -308,13 +304,13 @@ def buildWithNode(provider, node, source_ref):
     # manual. Catches exceptions, and provides them to "__exit__", while making
     # the "__enter__" value available under a given name.
 
-    # Before Python3.3, multiple context managers are not visible in the parse
+    # Before Python3, multiple context managers are not visible in the parse
     # tree, now we need to handle it ourselves.
     if hasattr(node, "items"):
         context_exprs = [item.context_expr for item in node.items]
         assign_targets = [item.optional_vars for item in node.items]
     else:
-        # Make it a list for before Python3.3
+        # Make it a list for before Python3
         context_exprs = [node.context_expr]
         assign_targets = [node.optional_vars]
 
@@ -344,7 +340,7 @@ def buildAsyncWithNode(provider, node, source_ref):
     # manual. Catches exceptions, and provides them to "__exit__", while making
     # the "__enter__" value available under a given name.
 
-    # Before Python3.3, multiple context managers are not visible in the parse
+    # Before Python3, multiple context managers are not visible in the parse
     # tree, now we need to handle it ourselves.
     context_exprs = [item.context_expr for item in node.items]
     assign_targets = [item.optional_vars for item in node.items]

nuitka/tree/SourceHandling.py

@@ -17,10 +17,7 @@ from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonVersions import python_version, python_version_str
 from nuitka.Tracing import general, my_print
-from nuitka.utils.FileOperations import (
-    getFileContentByLine,
-    putTextFileContents,
-)
+from nuitka.utils.FileOperations import putTextFileContents
 from nuitka.utils.Shebang import getShebangFromSource, parseShebang
 from nuitka.utils.Utils import isWin32OrPosixWindows
 
@@ -192,7 +189,8 @@ def readSourceCodeFromFilenameWithInformation(
         contributing_plugins = ()
 
     if (
-        Options.shallShowSourceModifications(module_name)
+        module_name is not None
+        and Options.shallShowSourceModifications(module_name)
         and source_code_modified != source_code
     ):
         source_diff = getSourceCodeDiff(source_code, source_code_modified)
@@ -324,7 +322,14 @@ def parsePyIFile(module_name, pyi_filename):
     in_import_part = ""
     in_quote = None
 
-    for line in getFileContentByLine(pyi_filename):
+    pyi_contents = readSourceCodeFromFilename(
+        # Do not pass module name, or else plugins modify it, which they
+        # should not.
+        module_name=None,
+        source_filename=pyi_filename,
+    )
+
+    for line in pyi_contents.splitlines():
         line = line.strip()
 
         if in_quote:
@@ -369,11 +374,11 @@ def parsePyIFile(module_name, pyi_filename):
                     if dot_count > 0:
                         if origin_name:
                             origin_name = module_name.getRelativePackageName(
-                                level=dot_count + 1
+                                level=dot_count
                             ).getChildNamed(origin_name)
                         else:
                             origin_name = module_name.getRelativePackageName(
-                                level=dot_count + 1
+                                level=dot_count - 1
                             )
 
                 if origin_name != module_name:

nuitka/tree/VariableClosure.py

@@ -28,7 +28,6 @@ from nuitka.nodes.VariableRefNodes import (
     ExpressionTempVariableRef,
     makeExpressionVariableRef,
 )
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 from nuitka.PythonVersions import (
     getErrorMessageExecWithNestedFunction,
     python_version,
@@ -37,7 +36,7 @@ from nuitka.Variables import isSharedAmongScopes, releaseSharedScopeInformation
 
 from .Operations import VisitorNoopMixin, visitTree
 from .ReformulationFunctionStatements import addFunctionVariableReleases
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .SyntaxErrors import raiseSyntaxError
 
 # Note: We do the variable scope assignment, as an extra step from tree
@@ -158,7 +157,7 @@ class VariableClosureLookupVisitorPhase1(VisitorNoopMixin):
                                 source=node.subnode_source.subnode_left,
                                 source_ref=node.source_ref,
                             ),
-                            makeTryFinallyStatement(
+                            makeTryFinallyReleaseStatement(
                                 provider=provider,
                                 tried=(
                                     makeStatementAssignmentVariable(
@@ -184,9 +183,7 @@ class VariableClosureLookupVisitorPhase1(VisitorNoopMixin):
                                         source_ref=node.source_ref,
                                     ),
                                 ),
-                                final=makeStatementReleaseVariable(
-                                    variable=tmp_variable, source_ref=node.source_ref
-                                ),
+                                variables=(tmp_variable,),
                                 source_ref=node.source_ref,
                             ),
                         )
@@ -294,32 +291,19 @@ class VariableClosureLookupVisitorPhase1(VisitorNoopMixin):
         elif node.isExpressionGeneratorObjectBody():
             if python_version >= 0x300:
                 self._handleNonLocal(node)
-
-            # Only Python3.4 or later allows for generators to have qualname.
-            if python_version >= 0x340:
                 self._handleQualnameSetup(node)
         elif node.isExpressionCoroutineObjectBody():
             self._handleNonLocal(node)
-
             self._handleQualnameSetup(node)
         elif node.isExpressionAsyncgenObjectBody():
             self._handleNonLocal(node)
-
             self._handleQualnameSetup(node)
-        elif node.isExpressionClassBodyP3():
+        elif node.isExpressionClassMappingBody():
             self._handleNonLocal(node)
-
-            # Python3.4 allows for class declarations to be made global, even
-            # after they were declared, so we need to fix this up.
-            if python_version >= 0x340:
-                self._handleQualnameSetup(node)
+            self._handleQualnameSetup(node)
         elif node.isExpressionFunctionBody():
             if python_version >= 0x300:
                 self._handleNonLocal(node)
-
-            # Python 3.4 allows for class declarations to be made global, even
-            # after they were declared, so we need to fix this up.
-            if python_version >= 0x340:
                 self._handleQualnameSetup(node)
         # Check if continue and break are properly in loops. If not, raise a
         # syntax error.

nuitka/utils/Distributions.py

@@ -9,6 +9,7 @@ from nuitka.__past__ import (  # pylint: disable=redefined-builtin
     FileNotFoundError,
     unicode,
 )
+from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.Options import isExperimental
 from nuitka.PythonFlavors import (
@@ -74,6 +75,15 @@ is typically caused by corruption of its installation."""
         return None
 
 
+def _getDistributionInstallerFileContents(distribution):
+    installer_name = _getDistributionMetadataFileContents(distribution, "INSTALLER")
+
+    if installer_name:
+        installer_name = installer_name.strip().lower()
+
+    return installer_name
+
+
 def getDistributionTopLevelPackageNames(distribution):
     """Returns the top level package names for a distribution."""
     top_level_txt = _getDistributionMetadataFileContents(distribution, "top_level.txt")
@@ -126,6 +136,16 @@ def getDistributionTopLevelPackageNames(distribution):
     return tuple(result)
 
 
+def _get_pkg_resources_module():
+    # pip and vendored pkg_resources are optional of course, but of course very
+    # omnipresent generally, so we don't handle failure here.
+
+    # pylint: disable=I0021,no-name-in-module
+    from pip._vendor import pkg_resources
+
+    return pkg_resources
+
+
 def _get_pkg_resource_distributions():
     """Small replacement of distributions() of importlib.metadata that uses pkg_resources"""
 
@@ -135,11 +155,7 @@ def _get_pkg_resource_distributions():
     if _user_site_directory is not None:
         site.USER_SITE = _user_site_directory
 
-    # pip and vendored pkg_resources are optional of course, but of course very
-    # omnipresent generally, so we don't handle failure here.
-
-    # pylint: disable=I0021,no-name-in-module
-    from pip._vendor import pkg_resources
+    pkg_resources = _get_pkg_resources_module()
 
     return lambda: pkg_resources.working_set
 
@@ -353,14 +369,10 @@ def getDistributionInstallerName(distribution_name):
             else:
                 _distribution_to_installer[distribution_name] = "not_found"
         else:
-            installer_name = _getDistributionMetadataFileContents(
-                distribution, "INSTALLER"
-            )
+            installer_name = _getDistributionInstallerFileContents(distribution)
 
             if installer_name:
-                _distribution_to_installer[distribution_name] = (
-                    installer_name.strip().lower()
-                )
+                _distribution_to_installer[distribution_name] = installer_name
             elif isAnacondaPython():
                 _distribution_to_installer[distribution_name] = "conda"
             elif isPdmPackageInstallation(distribution):
@@ -401,6 +413,20 @@ def getDistributionName(distribution):
 
     if hasattr(distribution, "metadata"):
         result = distribution.metadata["Name"]
+
+        if result is None:
+            installer_name = _getDistributionInstallerFileContents(distribution)
+
+            if installer_name == "debian":
+                distribution_path = _getDistributionPath(distribution)
+
+                if distribution_path is not None:
+                    dir_name = os.path.basename(distribution_path)
+
+                    if dir_name.endswith(".dist-info"):
+                        dir_name = dir_name[:-10]
+
+                        result = dir_name.rsplit("-", 1)[0]
     else:
         result = distribution.project_name
 
@@ -443,6 +469,49 @@ def getDistributionLicense(distribution):
     return license_name
 
 
+def _getEntryPointGroup(group_name):
+    try:
+        if isExperimental("force-pkg-resources-metadata"):
+            raise ImportError
+
+        try:
+            from importlib.metadata import entry_points
+        except ImportError:
+            from importlib_metadata import entry_points
+
+    except (ImportError, SyntaxError, RuntimeError):
+        pkg_resources = _get_pkg_resources_module()
+
+        entry_points = pkg_resources.entry_points
+
+    return entry_points(group=group_name)
+
+
+EntryPointDescription = makeNamedtupleClass(
+    "EntryPointDescription",
+    (
+        "distribution_name",
+        "distribution",
+        "module_name",
+    ),
+)
+
+
+def getEntryPointGroup(group_name):
+    result = OrderedSet()
+
+    for entry_point in _getEntryPointGroup(group_name):
+        result.add(
+            EntryPointDescription(
+                distribution_name=getDistributionName(entry_point.dist),
+                distribution=entry_point.dist,
+                module_name=ModuleName(entry_point.module),
+            )
+        )
+
+    return result
+
+
 # User site directory if any
 _user_site_directory = None
 

nuitka/utils/Download.py

@@ -52,6 +52,7 @@ def getCachedDownload(
     name,
     url,
     binary,
+    unzip,
     flatten,
     is_arch_specific,
     specificity,
@@ -114,44 +115,52 @@ Fully automatic, cached. Proceed and download"""
                     % (url, e, download_path)
                 )
 
-    if not os.path.isfile(exe_path) and os.path.isfile(download_path):
-        Tracing.general.info("Extracting to '%s'" % exe_path)
+    if unzip:
+        if not os.path.isfile(exe_path) and os.path.isfile(download_path):
+            Tracing.general.info("Extracting to '%s'" % exe_path)
 
-        import zipfile
+            import zipfile
 
-        try:
-            # Not all Python versions support using it as a context manager, pylint: disable=consider-using-with
-            zip_file = zipfile.ZipFile(download_path)
+            try:
+                # Not all Python versions support using it as a context manager, pylint: disable=consider-using-with
+                zip_file = zipfile.ZipFile(download_path)
 
-            for zip_info in zip_file.infolist():
-                if zip_info.filename[-1] == "/":
-                    continue
+                for zip_info in zip_file.infolist():
+                    if zip_info.filename[-1] == "/":
+                        continue
 
-                if flatten:
-                    zip_info.filename = os.path.basename(zip_info.filename)
+                    if flatten:
+                        zip_info.filename = os.path.basename(zip_info.filename)
 
-                zip_file.extract(zip_info, nuitka_download_dir)
+                    zip_file.extract(zip_info, nuitka_download_dir)
 
-        except Exception:  # Catching anything zip throws, pylint: disable=broad-except
-            Tracing.general.info("Problem with the downloaded zip file, deleting it.")
+            except (
+                # Catching anything zip throws, pylint: disable=broad-except
+                Exception
+            ):
+                Tracing.general.info(
+                    "Problem with the downloaded zip file, deleting it."
+                )
 
-            deleteFile(binary, must_exist=False)
-            deleteFile(download_path, must_exist=True)
+                deleteFile(binary, must_exist=False)
+                deleteFile(download_path, must_exist=True)
 
-            Tracing.general.sysexit(
-                "Error, need '%s' as extracted from '%s'." % (binary, url)
-            )
+                Tracing.general.sysexit(
+                    "Error, need '%s' as extracted from '%s'." % (binary, url)
+                )
 
-    # Check success here, and make sure it's executable.
-    if os.path.isfile(exe_path):
-        addFileExecutablePermission(exe_path)
-    else:
-        if reject:
-            Tracing.general.sysexit(reject)
+        # Check success here, and make sure it's executable.
+        if os.path.isfile(exe_path):
+            addFileExecutablePermission(exe_path)
+        else:
+            if reject:
+                Tracing.general.sysexit(reject)
 
-        exe_path = None
+            exe_path = None
 
-    return exe_path
+        return exe_path
+    else:
+        return download_path
 
 
 def getCachedDownloadedMinGW64(target_arch, assume_yes_for_downloads):
@@ -164,19 +173,17 @@ def getCachedDownloadedMinGW64(target_arch, assume_yes_for_downloads):
         url = "https://github.com/brechtsanders/winlibs_mingw/releases/download/13.2.0-16.0.6-11.0.1-msvcrt-r1/winlibs-i686-posix-dwarf-gcc-13.2.0-llvm-16.0.6-mingw-w64msvcrt-11.0.1-r1.zip"
         binary = r"mingw32\bin\gcc.exe"
     elif target_arch == "arm64":
-        url = None
+        return None
     else:
         assert False, target_arch
 
-    if url is None:
-        return None
-
     gcc_binary = getCachedDownload(
         name="mingw64",
         url=url,
         is_arch_specific=target_arch,
         specificity=url.rsplit("/", 2)[1],
         binary=binary,
+        unzip=True,
         flatten=False,
         message="Nuitka will use gcc from MinGW64 of winlibs to compile on Windows.",
         reject="Only this specific gcc is supported with Nuitka.",

nuitka/utils/Execution.py

@@ -20,7 +20,8 @@ from .Utils import getArchitecture, isWin32OrPosixWindows, isWin32Windows
 # Cache, so we avoid repeated command lookups.
 _executable_command_cache = {}
 
-# We emulate and use APIs of stdlib, spell-checker: ignore popenargs,creationflags,preexec_fn,setsid
+# We emulate and use APIs of stdlib,
+# spell-checker: ignore popenargs,creationflags,preexec_fn,setsid,debuginfod
 
 
 def _getExecutablePath(filename, search_path):
@@ -289,7 +290,17 @@ def wrapCommandForDebuggerForExec(*args):
             general.sysexit("Error, no 'gdb' or 'lldb' binary found in path.")
 
     if gdb_path is not None:
-        args = (gdb_path, "gdb", "-ex=run", "-ex=where", "-ex=quit", "--args") + args
+        args = (
+            gdb_path,
+            "gdb",
+            "-q",
+            "-ex=set pagination off",
+            "-ex=set debuginfod enabled off",
+            "-ex=run",
+            "-ex=where",
+            "-ex=quit",
+            "--args",
+        ) + args
     else:
         args = (lldb_path, "lldb", "-o", "run", "-o", "bt", "-o", "quit", "--") + args
 
@@ -352,13 +363,14 @@ def executeToolChecked(
     # Allow to avoid repeated scans in PATH for the tool.
     command[0] = getExecutablePath(tool)
 
-    process = subprocess.Popen(
-        command,
-        stdin=getNullInput(),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        shell=False,
-    )
+    with withEnvironmentVarOverridden("LC_ALL", "C"):
+        process = subprocess.Popen(
+            command,
+            stdin=getNullInput(),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=False,
+        )
 
     stdout, stderr = process.communicate()
     result = process.poll()

nuitka/utils/FileOperations.py

@@ -42,6 +42,7 @@ from nuitka.Tracing import (
 from .Importing import importFromInlineCopy
 from .ThreadedExecutor import RLock, getThreadIdent
 from .Utils import (
+    decoratorRetries,
     isLinux,
     isMacOS,
     isWin32OrPosixWindows,
@@ -718,7 +719,7 @@ def addFilenameExtension(path, extension):
     return path
 
 
-def removeDirectory(path, ignore_errors):
+def removeDirectory(path, logger, ignore_errors, extra_recommendation):
     """Remove a directory recursively.
 
     On Windows, it happens that operations fail, and succeed when retried,
@@ -729,36 +730,52 @@ def removeDirectory(path, ignore_errors):
     it hopefully only briefly.
     """
 
-    def onError(func, path, exc_info):
-        # Record what happened what happened, pylint: disable=unused-argument
-        last_error.append((func, path))
-
     with withFileLock("removing directory %s" % path):
         if os.path.exists(path):
-            previous_error = []
-
-            while True:
-                last_error = []
-                shutil.rmtree(path, ignore_errors=False, onerror=onError)
-
-                # onError as a side effect, modifies last_error
-                if previous_error == last_error:
-                    break
-
-                previous_error = list(last_error)
-                time.sleep(0.1)
-
-            # if it still exists, try one more time, this time not ignoring errors.
-            if os.path.exists(path):
-                try:
-                    shutil.rmtree(path, ignore_errors=ignore_errors)
-                except OSError:
-                    if not ignore_errors:
-                        raise
-
 
-def resetDirectory(path, ignore_errors):
-    removeDirectory(path=path, ignore_errors=ignore_errors)
+            @decoratorRetries(
+                logger=logger,
+                purpose="delete '%s'" % path,
+                consequence="the path is not fully removed",
+                extra_recommendation=extra_recommendation,
+            )
+            def _removeDirectory():
+                def onError(func, path, exc_info):
+                    # Record what happened what happened, pylint: disable=unused-argument
+                    last_error.append((func, path))
+
+                previous_error = []
+
+                # Try deleting while ignoring errors first.
+                while True:
+                    last_error = []
+                    shutil.rmtree(path, ignore_errors=False, onerror=onError)
+
+                    # onError as a side effect, modifies last_error
+                    if previous_error == last_error:
+                        break
+
+                    previous_error = list(last_error)
+                    time.sleep(0.2)
+
+                # If it still exists, try one more time, this time not ignoring errors.
+                if os.path.exists(path):
+                    try:
+                        shutil.rmtree(path, ignore_errors=ignore_errors)
+                    except OSError:
+                        if not ignore_errors:
+                            raise
+
+            _removeDirectory()
+
+
+def resetDirectory(path, logger, ignore_errors, extra_recommendation):
+    removeDirectory(
+        path=path,
+        logger=logger,
+        ignore_errors=ignore_errors,
+        extra_recommendation=extra_recommendation,
+    )
     makePath(path)
 
 
@@ -1490,6 +1507,16 @@ def isLegalPath(path):
         if path.endswith(illegal_suffix):
             return False, "contains illegal suffix %r" % illegal_suffix
 
+        for part in path.split(os.path.sep):
+            if part == ".":
+                continue
+
+            if part.endswith(illegal_suffix):
+                return False, "contains illegal suffix %r in path part %r" % (
+                    part,
+                    illegal_suffix,
+                )
+
     return True, None
 
 

nuitka/utils/Images.py

@@ -22,7 +22,12 @@ def checkIconUsage(logger, icon_path):
     if needs_conversion:
         try:
             import imageio  # pylint: disable=I0021,import-error,unused-import
-        except ImportError:
+        except ImportError as e:
+            from nuitka import Options
+
+            if Options.is_debug:
+                logger.info("Exception importing 'imageio' is %s" % repr(e))
+
             logger.sysexit(
                 """\
 Need to install 'imageio' to automatically convert the non native \

nuitka/utils/Importing.py

@@ -322,7 +322,7 @@ def hasPackageDirFilename(path):
 def getPackageDirFilename(path):
     assert os.path.isdir(path)
 
-    for suffix in (".py",) + getSharedLibrarySuffixes():
+    for suffix in getSharedLibrarySuffixes() + (".py",):
         candidate = os.path.join(path, "__init__" + suffix)
 
         if os.path.isfile(candidate):

nuitka/utils/ModuleNames.py

@@ -112,12 +112,18 @@ class ModuleName(str):
             yield parent_package
 
     def getRelativePackageName(self, level):
-        result = ".".join(self.asString().split(".")[: -level + 1])
+        assert level >= 0
 
-        if result == "":
-            return None
-        else:
-            return ModuleName(result)
+        parts = self.asString().split(".")
+
+        while level > 0:
+            if not parts:
+                return None
+
+            del parts[-1]
+            level -= 1
+
+        return ModuleName(".".join(parts))
 
     def getTopLevelPackageName(self):
         """Get the top level package name.