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

nuitka/tree/ReformulationClasses3.py

@@ -38,7 +38,6 @@ from nuitka.nodes.DictionaryNodes import (
     ExpressionDictOperationGet2,
     ExpressionDictOperationIn,
     StatementDictOperationRemove,
-    StatementDictOperationUpdate,
 )
 from nuitka.nodes.ExceptionNodes import (
     ExpressionBuiltinMakeException,
@@ -88,12 +87,12 @@ from .InternalModule import (
     makeInternalHelperFunctionBody,
     once_decorator,
 )
+from .ReformulationDictionaryCreation import buildDictionaryUnpacking
 from .ReformulationSequenceCreation import buildTupleUnpacking
 from .ReformulationTryExceptStatements import makeTryExceptSingleHandlerNode
 from .ReformulationTryFinallyStatements import makeTryFinallyStatement
 from .TreeHelpers import (
     buildFrameNode,
-    buildNode,
     buildNodeTuple,
     extractDocFromBody,
     getKind,
@@ -373,11 +372,6 @@ def buildClassNode3(provider, node, source_ref):
             source_ref=decorator.getSourceReference(),
         )
 
-    if node.keywords and node.keywords[-1].arg is None:
-        keywords = node.keywords[:-1]
-    else:
-        keywords = node.keywords
-
     statements = []
 
     if node.bases:
@@ -417,32 +411,35 @@ def buildClassNode3(provider, node, source_ref):
                 )
             )
 
+    # TODO: It's not really clear, since when those in the middle keywords are accepted
+    # and not a SyntaxError, and if then we might have to raise it.
+    keyword_keys = tuple(keyword.arg for keyword in node.keywords)
+    keyword_values = tuple(keyword.value for keyword in node.keywords)
+
+    if None in keyword_keys:
+        assert python_version >= 0x350
+
+        make_keywords_dict = buildDictionaryUnpacking(
+            provider,
+            keys=keyword_keys,
+            values=keyword_values,
+            source_ref=source_ref,
+        )
+    else:
+        make_keywords_dict = makeDictCreationOrConstant2(
+            keys=keyword_keys,
+            values=buildNodeTuple(provider, keyword_values, source_ref),
+            source_ref=source_ref,
+        )
+
     statements.append(
         makeStatementAssignmentVariable(
             variable=tmp_class_decl_dict,
-            source=makeDictCreationOrConstant2(
-                keys=[keyword.arg for keyword in keywords],
-                values=[
-                    buildNode(provider, keyword.value, source_ref)
-                    for keyword in keywords
-                ],
-                source_ref=source_ref,
-            ),
+            source=make_keywords_dict,
             source_ref=source_ref,
         )
     )
 
-    if node.keywords and node.keywords[-1].arg is None:
-        statements.append(
-            StatementDictOperationUpdate(
-                dict_arg=ExpressionVariableRef(
-                    variable=tmp_class_decl_dict, source_ref=source_ref
-                ),
-                value=buildNode(provider, node.keywords[-1].value, source_ref),
-                source_ref=source_ref,
-            )
-        )
-
     # Check if there are bases, and if there are, go with the type of the
     # first base class as a metaclass unless it was specified in the class
     # decl dict of course.

nuitka/tree/ReformulationContractionExpressions.py

@@ -204,9 +204,11 @@ def buildDictContractionNode(provider, node, source_ref):
         provider=provider,
         node=node,
         name="<dictcontraction>",
-        emit_class=StatementDictOperationSet
-        if python_version < 0x380
-        else StatementDictOperationSetKeyValue,
+        emit_class=(
+            StatementDictOperationSet
+            if python_version < 0x380
+            else StatementDictOperationSetKeyValue
+        ),
         start_value={},
         source_ref=source_ref,
     )

nuitka/tree/ReformulationDictionaryCreation.py

@@ -71,7 +71,10 @@ def buildDictionaryNode(provider, node, source_ref):
         for key in node.keys:
             if key is None:
                 return buildDictionaryUnpacking(
-                    provider=provider, node=node, source_ref=source_ref
+                    provider=provider,
+                    keys=node.keys,
+                    values=node.values,
+                    source_ref=source_ref,
                 )
 
     return makeExpressionMakeDictOrConstant(
@@ -266,10 +269,8 @@ def buildDictionaryUnpackingArgs(provider, keys, values, source_ref):
     return tuple(result)
 
 
-def buildDictionaryUnpacking(provider, node, source_ref):
-    helper_args = buildDictionaryUnpackingArgs(
-        provider, node.keys, node.values, source_ref
-    )
+def buildDictionaryUnpacking(provider, keys, values, source_ref):
+    helper_args = buildDictionaryUnpackingArgs(provider, keys, values, source_ref)
 
     result = makeExpressionFunctionCall(
         function=makeExpressionFunctionCreation(

nuitka/tree/ReformulationExecStatements.py

@@ -142,15 +142,17 @@ def wrapEvalGlobalsAndLocals(
     return (
         ExpressionTempVariableRef(
             variable=globals_keeper_variable,
-            source_ref=source_ref
-            if globals_node is None
-            else globals_node.getSourceReference(),
+            source_ref=(
+                source_ref
+                if globals_node is None
+                else globals_node.getSourceReference()
+            ),
         ),
         ExpressionTempVariableRef(
             variable=locals_keeper_variable,
-            source_ref=source_ref
-            if locals_node is None
-            else locals_node.getSourceReference(),
+            source_ref=(
+                source_ref if locals_node is None else locals_node.getSourceReference()
+            ),
         ),
         makeStatementsSequence(pre_statements, False, source_ref),
         makeStatementsSequence(post_statements, False, source_ref),

nuitka/tree/ReformulationFunctionStatements.py

@@ -826,12 +826,16 @@ def buildFunctionWithParsing(
     parameters = ParameterSpec(
         ps_name=name,
         ps_normal_args=extractNormalArgs(node.args.args),
-        ps_pos_only_args=[extractArg(arg) for arg in node.args.posonlyargs]
-        if python_version >= 0x380
-        else (),
-        ps_kw_only_args=[extractArg(arg) for arg in node.args.kwonlyargs]
-        if python_version >= 0x300
-        else (),
+        ps_pos_only_args=(
+            [extractArg(arg) for arg in node.args.posonlyargs]
+            if python_version >= 0x380
+            else ()
+        ),
+        ps_kw_only_args=(
+            [extractArg(arg) for arg in node.args.kwonlyargs]
+            if python_version >= 0x300
+            else ()
+        ),
         ps_list_star_arg=extractArg(node.args.vararg),
         ps_dict_star_arg=extractArg(node.args.kwarg),
         ps_default_count=len(node.args.defaults),

nuitka/tree/SourceHandling.py

@@ -285,6 +285,7 @@ That will make use the correct Python version for Nuitka.
 
 
 def readSourceLine(source_ref):
+    """Read a single source line, mainly for use in error reporting only."""
     import linecache
 
     return linecache.getline(
@@ -292,6 +293,13 @@ def readSourceLine(source_ref):
     )
 
 
+def readSourceLines(source_ref):
+    """Read a source lines with linecache, for use with cached function source finding."""
+    import linecache
+
+    return linecache.getlines(source_ref.filename)
+
+
 def writeSourceCode(filename, source_code):
     # Prevent accidental overwriting. When this happens the collision detection
     # or something else has failed.

nuitka/tree/TreeHelpers.py

@@ -128,7 +128,7 @@ def detectFunctionBodyKind(nodes, start_value=None):
             for name, field in ast.iter_fields(node):
                 if name in ("name", "body"):
                     pass
-                elif name in ("bases", "decorator_list", "keywords"):
+                elif name in ("bases", "decorator_list", "keywords", "type_params"):
                     for child in field:
                         _check(child)
                 elif name == "starargs":
@@ -145,7 +145,7 @@ def detectFunctionBodyKind(nodes, start_value=None):
             for name, field in ast.iter_fields(node):
                 if name in ("name", "body"):
                     pass
-                elif name in ("bases", "decorator_list"):
+                elif name in ("bases", "decorator_list", "type_params"):
                     for child in field:
                         _check(child)
                 elif name == "args":
@@ -197,7 +197,10 @@ def detectFunctionBodyKind(nodes, start_value=None):
                 if name in ("name", "body", "comparators"):
                     pass
                 elif name == "generators":
-                    _check(field[0].iter)
+                    if python_version < 0x3B0:
+                        _check(field[0].iter)
+                    else:
+                        _check(field[0])
                 elif name in ("body", "elt"):
                     _check(field)
                 else:

nuitka/utils/AppDirs.py

@@ -71,10 +71,14 @@ please consider making a PR for a general solution that adds support for it, or
     return _cache_dir
 
 
-def getCacheDir(cache_basename):
+def getCacheDirEnvironmentVariableName(cache_basename):
     env_name = cache_basename.replace("-", "_").upper()
 
-    cache_dir = os.getenv("NUITKA_CACHE_DIR_" + env_name)
+    return "NUITKA_CACHE_DIR_" + env_name
+
+
+def getCacheDir(cache_basename):
+    cache_dir = os.getenv(getCacheDirEnvironmentVariableName(cache_basename))
     if cache_dir is None:
         cache_dir = os.path.join(_getCacheDir(), cache_basename)
 

nuitka/utils/CStrings.py

@@ -142,7 +142,7 @@ def encodePythonIdentifierToC(value):
         else:
             return "$$%d$" % ord(c)
 
-    return "".join(re.sub("[^a-zA-Z0-9_]", r, c) for c in value)
+    return re.sub("[^a-zA-Z0-9_]", r, value)
 
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/utils/CommandLineOptions.py

@@ -3,7 +3,6 @@
 
 """ Tools for command line options."""
 
-
 import sys
 from optparse import (
     AmbiguousOptionError,

nuitka/utils/Distributions.py

@@ -358,9 +358,9 @@ def getDistributionInstallerName(distribution_name):
             )
 
             if installer_name:
-                _distribution_to_installer[
-                    distribution_name
-                ] = installer_name.strip().lower()
+                _distribution_to_installer[distribution_name] = (
+                    installer_name.strip().lower()
+                )
             elif isAnacondaPython():
                 _distribution_to_installer[distribution_name] = "conda"
             elif isPdmPackageInstallation(distribution):

nuitka/utils/Download.py

@@ -40,8 +40,12 @@ def getDownload(name, url, download_path):
             raise
 
 
+def getDownloadCacheName():
+    return "downloads"
+
+
 def getDownloadCacheDir():
-    return getCacheDir("downloads")
+    return getCacheDir(getDownloadCacheName())
 
 
 def getCachedDownload(

nuitka/utils/Execution.py

@@ -7,7 +7,6 @@ Basically a layer for os, subprocess, shutil to come together. It can find
 binaries (needed for exec) and run them capturing outputs.
 """
 
-
 import os
 from contextlib import contextmanager
 
@@ -107,6 +106,10 @@ def check_output(*popenargs, **kwargs):
     Note: We use same name as in Python stdlib, violating our rules to
     make it more recognizable what this does.
     """
+    logger = kwargs.pop("logger", None)
+
+    if logger is not None:
+        logger.info("Executing command '%s'." % popenargs[0], keep_format=True)
 
     if "stdout" in kwargs:
         raise ValueError("stdout argument not allowed, it will be overridden.")
@@ -141,7 +144,7 @@ def check_call(*popenargs, **kwargs):
     logger = kwargs.pop("logger", None)
 
     if logger is not None:
-        logger.info("Executing command '%s'." % popenargs[0])
+        logger.info("Executing command '%s'." % popenargs[0], keep_format=True)
 
     try:
         subprocess.check_call(*popenargs, **kwargs)
@@ -156,7 +159,7 @@ def callProcess(*popenargs, **kwargs):
     logger = kwargs.pop("logger", None)
 
     if logger is not None:
-        logger.info("Executing command '%s'." % popenargs[0])
+        logger.info("Executing command '%s'." % popenargs[0], keep_format=True)
 
     return subprocess.call(*popenargs, **kwargs)
 

nuitka/utils/FileOperations.py

@@ -97,6 +97,9 @@ def areSamePaths(path1, path2):
         even short paths, it then becomes a mere string compare after that.
     """
 
+    if path1 == path2:
+        return True
+
     path1 = os.path.abspath(os.path.normpath(path1))
     path2 = os.path.abspath(os.path.normpath(path2))
 
@@ -186,7 +189,11 @@ def makePath(path):
 
     with withFileLock("creating directory %s" % path):
         if not os.path.isdir(path):
-            os.makedirs(path)
+            try:
+                os.makedirs(path)
+            except OSError:
+                if not os.path.exists(path):
+                    raise
 
 
 def makeContainingPath(filename):
@@ -236,9 +243,14 @@ def _getRealPathWindows(path):
             if str is not bytes:
                 result = result.decode("utf8")
 
-            _real_path_windows_cache[path] = os.path.join(
-                os.path.dirname(path), result.rstrip("\r\n")
-            )
+            if result.startswith("UNC\\"):
+                # Avoid network mounts being converted to UNC shared paths by newer
+                # Python versions, many tools won't work with those.
+                _real_path_windows_cache[path] = path
+            else:
+                _real_path_windows_cache[path] = os.path.join(
+                    os.path.dirname(path), result.rstrip("\r\n")
+                )
         else:
             _real_path_windows_cache[path] = path
 
@@ -270,37 +282,16 @@ def getDirectoryRealPath(path):
     return path
 
 
-def getFilenameRealPath(path):
-    """Get os.path.realpath with Python2 and Windows symlink workaround applied.
-
-    Args:
-        path: path to get realpath of
-
-    Returns:
-        path with symlinks resolved
-
-    Notes:
-        Workaround for Windows symlinks are applied, this works recursive and
-        assumes that the path given itself is a file and not a directory, and
-        doesn't handle file symlinks at the end on older Python currently, but
-        we shouldn't deal with those.
-    """
-    orig_path = path
-    path = os.path.realpath(path)
-
-    # Avoid network mounts being converted to UNC shared paths ny newer
-    # Python versions, many tools won't work with those.
-    if os.name == "nt" and path.startswith("\\\\"):
+def _restoreWindowsPath(orig_path, path):
+    if path.startswith("\\\\"):
         drive, _remaining_path = os.path.splitdrive(orig_path)
 
-        if drive:
+        if drive and not drive.startswith("\\\\"):
             drive_real_path = os.path.realpath(drive + "\\")
             assert path.startswith(drive_real_path)
 
             path = drive + path[len(drive_real_path) :]
-
-    # Attempt to resolve Windows symlinks older Python
-    if os.name == "nt":
+    else:
         path = path.strip(os.path.sep)
 
         if os.path.sep in path:
@@ -321,6 +312,32 @@ def getFilenameRealPath(path):
     return path
 
 
+def getFilenameRealPath(path):
+    """Get os.path.realpath with Python2 and Windows symlink workaround applied.
+
+    Args:
+        path: path to get realpath of
+
+    Returns:
+        path with symlinks resolved
+
+    Notes:
+        Workaround for Windows symlinks are applied, this works recursive and
+        assumes that the path given itself is a file and not a directory, and
+        doesn't handle file symlinks at the end on older Python currently, but
+        we shouldn't deal with those.
+    """
+    orig_path = path
+    path = os.path.realpath(path)
+
+    # Avoid network mounts being converted to UNC shared paths by newer
+    # Python versions, many tools won't work with those.
+    if os.name == "nt":
+        path = _restoreWindowsPath(orig_path=orig_path, path=path)
+
+    return path
+
+
 def listDir(path):
     """Give a sorted listing of a path.
 
@@ -478,9 +495,9 @@ def getDllBasename(path):
         if compare_path.endswith(suffix):
             return path[: -len(suffix)]
 
-    # Linux us not case sensitive, but lets still do it properly,
-    # sometimes, it is done on non-Linux too. So we split on the
-    # normcase, but only to find out what is going on there.
+    # Linux is not case sensitive, but lets still do it properly, sometimes, it
+    # is done macOS too. So we split on the normcase, but only to find out what
+    # is going on there.
     if ".so." in compare_path:
         return path[: len(compare_path.split(".so.")[0])]
 
@@ -694,6 +711,13 @@ def hasFilenameExtension(path, extensions):
         return extension in extensions
 
 
+def addFilenameExtension(path, extension):
+    if not hasFilenameExtension(path, extension):
+        path += extension
+
+    return path
+
+
 def removeDirectory(path, ignore_errors):
     """Remove a directory recursively.
 
@@ -933,10 +957,13 @@ def copyTree(source_path, dest_path):
     if python_version >= 0x380:
         # Python 3.8+ has dirs_exist_ok
         return shutil.copytree(source_path, dest_path, dirs_exist_ok=True)
+    else:
 
-    from distutils.dir_util import copy_tree
+        from distutils.dir_util import (  # Older Python only, pylint: disable=I0021,import-error
+            copy_tree,
+        )
 
-    return copy_tree(source_path, dest_path)
+        return copy_tree(source_path, dest_path)
 
 
 def copyFileWithPermissions(source_path, dest_path, dist_dir):

nuitka/utils/Importing.py

@@ -40,7 +40,7 @@ def _importFilePy3OldWay(filename):
 
 def importFilePy2(filename):
     """Import a file for Python version 2."""
-    import imp
+    import imp  # Python2 only, pylint: disable=I0021,import-error
 
     basename = os.path.splitext(os.path.basename(filename))[0]
     return imp.load_source(basename, filename)
@@ -76,7 +76,7 @@ def getSharedLibrarySuffixes():
 
     if _shared_library_suffixes is None:
         if python_version < 0x300:
-            import imp
+            import imp  # Python2 only, pylint: disable=I0021,import-error
 
             _shared_library_suffixes = []
 
@@ -223,7 +223,7 @@ def importFromCompileTime(module_name, must_exist):
 
 def isBuiltinModuleName(module_name):
     if python_version < 0x300:
-        import imp as _imp
+        import imp as _imp  # Python2 only, pylint: disable=I0021,import-error
     else:
         import _imp
 
@@ -255,7 +255,7 @@ builtin_module_names = set(
 
 def getModuleFilenameSuffixes():
     if python_version < 0x3C0:
-        import imp
+        import imp  # Older Python only, pylint: disable=I0021,import-error
 
         for suffix, _mode, module_type in imp.get_suffixes():
             if module_type == imp.C_EXTENSION:

nuitka/utils/InstanceCounters.py

@@ -10,6 +10,7 @@ class.
 This is going to expanded with time.
 
 """
+
 from nuitka.Options import isShowMemory
 from nuitka.Tracing import printIndented, printLine
 

nuitka/utils/MacOSApp.py

@@ -4,6 +4,7 @@
 """ For macOS application bundle creation
 
 """
+
 import os
 
 from nuitka import Options, OutputDirectories

nuitka/utils/Shebang.py

@@ -4,6 +4,7 @@
 """ Utils to work with shebang lines.
 
 """
+
 import os
 import re
 

nuitka/utils/Utils.py

@@ -128,9 +128,47 @@ def getWindowsRelease():
     if not isWin32OrPosixWindows():
         return None
 
+    class OsVersionInfoEx(ctypes.Structure):
+        _fields_ = [
+            ("dwOSVersionInfoSize", ctypes.c_ulong),
+            ("dwMajorVersion", ctypes.c_ulong),
+            ("dwMinorVersion", ctypes.c_ulong),
+            ("dwBuildNumber", ctypes.c_ulong),
+            ("dwPlatformId", ctypes.c_ulong),
+            ("szCSDVersion", ctypes.c_wchar * 128),
+            ("wServicePackMajor", ctypes.c_ushort),
+            ("wServicePackMinor", ctypes.c_ushort),
+            ("wSuiteMask", ctypes.c_ushort),
+            ("wProductType", ctypes.c_byte),
+            ("wReserved", ctypes.c_byte),
+        ]
+
+        def __init__(self):
+            self.dwOSVersionInfoSize = ctypes.sizeof(  # pylint: disable=invalid-name
+                self
+            )
+
+    os_version_value = OsVersionInfoEx()
+
+    result = ctypes.windll.ntdll.RtlGetVersion(ctypes.byref(os_version_value))
+    if result != 0:
+        raiseWindowsError("Failed to get OS version")
+
+    version = os_version_value.dwMajorVersion
+
+    if os_version_value.dwBuildNumber >= 21996 and version == 10:
+        version = 11
+
+    return version
+
+
+def getMacOSRelease():
+    if not isMacOS():
+        return None
+
     import platform
 
-    return platform.release()
+    return platform.mac_ver()[0]
 
 
 def isDebianBasedLinux():

nuitka/utils/WindowsFileUsage.py

@@ -16,7 +16,7 @@ STATUS_INVALID_HANDLE = 0xC0000008
 STATUS_BUFFER_TOO_SMALL = 0xC0000023
 
 
-def getWindowsAllProcessandles():
+def getWindowsAllProcessHandles():
     """Return all process system handles."""
 
     i = 2048
@@ -184,13 +184,14 @@ def getWindowsAllProcessFileHandles():
 
     ObjectTypeInformation = 2
 
-    psapi = ctypes.WinDLL("Psapi.dll")
+    # spell-checker: ignore psapi
+    psapi = ctypes.WinDLL("psapi.dll")
     psapi.GetProcessImageFileNameW.restype = ctypes.wintypes.DWORD
 
     this_process = ctypes.windll.kernel32.GetCurrentProcess()
     this_process_id = ctypes.windll.kernel32.GetCurrentProcessId()
 
-    for process, handles in getWindowsAllProcessandles().items():
+    for process, handles in getWindowsAllProcessHandles().items():
         # Ignore ourselves, we do not matter normally.
 
         if this_process_id == process: