Nuitka-winsvc 1.6.6__cp310-cp310-win_amd64.whl → 1.7.5__cp310-cp310-win_amd64.whl

nuitka/Serialization.py

@@ -25,7 +25,13 @@ import sys
 
 from nuitka import OutputDirectories
 from nuitka.__past__ import ExceptionGroup  # pylint: disable=I0021,redefined-builtin
-from nuitka.__past__ import UnionType, basestring, to_byte, xrange
+from nuitka.__past__ import (
+    GenericAlias,
+    UnionType,
+    basestring,
+    to_byte,
+    xrange,
+)
 from nuitka.Builtins import (
     builtin_anon_codes,
     builtin_anon_values,
@@ -54,7 +60,17 @@ class BuiltinAnonValue(object):
         return to_byte(self.anon_values.index(self.anon_name))
 
 
+class BuiltinGenericAliasValue(object):
+    """For transporting GenericAlias values through pickler."""
+
+    def __init__(self, origin, args):
+        self.origin = origin
+        self.args = args
+
+
 class BuiltinUnionTypeValue(object):
+    """For transporting UnionType values through pickler."""
+
     def __init__(self, args):
         self.args = args
 
@@ -68,7 +84,7 @@ class BuiltinSpecialValue(object):
     def getStreamValueByte(self):
         """Return byte value, encoding the special built-in value."""
 
-        # Currently the only one.
+        # Currently the only ones.
         if self.value == "Ellipsis":
             return to_byte(0)
         elif self.value == "NotImplemented":
@@ -108,8 +124,12 @@ def _pickleAnonValues(pickler, value):
         pickler.save_global(value)
 
 
-def _pickeUnionType(picker, value):
-    picker.save(BuiltinUnionTypeValue(value.__args__))
+def _pickleGenericAlias(pickler, value):
+    pickler.save(BuiltinGenericAliasValue(origin=value.__origin__, args=value.__args__))
+
+
+def _pickleUnionType(pickler, value):
+    pickler.save(BuiltinUnionTypeValue(args=value.__args__))
 
 
 class ConstantStreamWriter(object):
@@ -135,8 +155,11 @@ class ConstantStreamWriter(object):
             self.pickle.dispatch[type(sys.version_info)] = _pickleAnonValues
 
         # Standard pickling doesn't work with our necessary wrappers.
+        if python_version >= 0x390:
+            self.pickle.dispatch[GenericAlias] = _pickleGenericAlias
+
         if python_version >= 0x3A0:
-            self.pickle.dispatch[UnionType] = _pickeUnionType
+            self.pickle.dispatch[UnionType] = _pickleUnionType
 
     def addConstantValue(self, constant_value):
         self.pickle.dump(constant_value)

nuitka/Version.py

@@ -1,4 +1,4 @@
-#     Copyright 2022, Kay Hayen, mailto:kay.hayen@gmail.com
+#     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.
@@ -20,7 +20,7 @@
 """
 
 version_string = """\
-Nuitka V1.6.6
+Nuitka V1.7.5
 Copyright (C) 2023 Kay Hayen."""
 
 

nuitka/build/Backend.scons

@@ -263,6 +263,10 @@ python_sysflag_no_randomization = getArgumentBool(
 # python_sysflag_unbuffered
 python_sysflag_unbuffered = getArgumentBool("python_sysflag_unbuffered", False)
 
+# python_sysflag_isolated
+python_sysflag_isolated = getArgumentBool("python_sysflag_isolated", False)
+
+
 # Preprocessor defines from plugins
 cpp_defines = getArgumentList("cpp_defines", "")
 cpp_include_dirs = getArgumentList("cpp_include_dirs", "")
@@ -337,7 +341,7 @@ env.the_compiler = env["CC"]
 env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.standalone_mode = standalone_mode
 env.debug_mode = debug_mode
-env.unstripped_mode = debug_mode or unstripped_mode
+env.unstripped_mode = unstripped_mode
 env.disable_console = disable_console
 env.source_dir = source_dir
 env.low_memory = low_memory
@@ -795,8 +799,15 @@ if module_mode:
         assert False, env.the_cc_name
 else:
     if env.msvc_mode:
-        env.Append(CCFLAGS=["/MT"])  # Multithreaded, static version of C run time.
-
+        # For complete outputs, we have to match the C runtime of the Python DLL, if any,
+        # for Nuitka-Python there is of course none.
+        if not env.nuitka_python and (
+            forced_stdout_path not in ("%NONE%", "%NULL%", None)
+            or forced_stderr_path not in ("%NONE%", "%NULL%", None)
+        ):
+            env.Append(CCFLAGS=["/MD"])  # Multithreaded, dynamic version of C run time.
+        else:
+            env.Append(CCFLAGS=["/MT"])  # Multithreaded, static version of C run time.
 
 if module_mode:
     env.Append(CPPDEFINES=["_NUITKA_MODULE"])
@@ -923,6 +934,8 @@ def createBuildDefinitionsFile():
 
     build_definitions["SYSFLAG_UNBUFFERED"] = 1 if python_sysflag_unbuffered else 0
 
+    build_definitions["SYSFLAG_ISOLATED"] = 1 if python_sysflag_isolated else 0
+
     if forced_stdout_path:
         if forced_stdout_path == "%NONE%":
             build_definitions["NUITKA_FORCED_STDOUT_NONE_BOOL"] = 1

nuitka/build/CCompilerVersion.scons

@@ -218,7 +218,7 @@ env = checkWindowsCompilerFound(
 env.the_compiler = env["CC"] or env["CXX"]
 env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.debug_mode = debug_mode
-env.unstripped_mode = debug_mode or unstripped_mode
+env.unstripped_mode = unstripped_mode
 env.disable_console = disable_console
 env.low_memory = False
 env.macos_min_version = macos_min_version

nuitka/build/DataComposerInterface.py

@@ -23,6 +23,7 @@ import subprocess
 import sys
 
 from nuitka.Options import isExperimental
+from nuitka.Tracing import data_composer_logger
 from nuitka.utils.Execution import withEnvironmentVarsOverridden
 
 
@@ -51,15 +52,20 @@ def _runDataComposer(source_dir):
     blob_filename = getConstantBlobFilename(source_dir)
 
     with withEnvironmentVarsOverridden(mapping):
-        subprocess.check_call(
-            [
-                sys.executable,
-                data_composer_path,
-                source_dir,
-                blob_filename,
-            ],
-            shell=False,
-        )
+        try:
+            subprocess.check_call(
+                [
+                    sys.executable,
+                    data_composer_path,
+                    source_dir,
+                    blob_filename,
+                ],
+                shell=False,
+            )
+        except subprocess.CalledProcessError:
+            data_composer_logger.sysexit(
+                "Error executing data composer, please report the above exception."
+            )
 
     return blob_filename
 

nuitka/build/Onefile.scons

@@ -272,7 +272,7 @@ env.the_compiler = env["CC"] or env["CXX"]
 env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.standalone_mode = True  # We are only used in this case.
 env.debug_mode = debug_mode
-env.unstripped_mode = debug_mode or unstripped_mode
+env.unstripped_mode = unstripped_mode
 env.disable_console = disable_console
 env.source_dir = source_dir
 env.low_memory = False  # Never a concern in this case.

nuitka/build/SconsCompilerSettings.py

@@ -238,6 +238,7 @@ version for lto mode (>= 4.6). Disabled."""
         )
 
     env.lto_mode = lto_mode
+    env.orig_lto_mode = orig_lto_mode
 
     # PGO configuration
     _enablePgoSettings(env, pgo_mode)

nuitka/build/SconsProgress.py

@@ -73,11 +73,20 @@ def closeSconsProgressBar():
     closeProgressBar()
 
 
-def reportSlowCompilation(cmd, delta_time):
+def reportSlowCompilation(env, cmd, delta_time):
     # TODO: for linking, we ought to apply a different timer maybe and attempt to extra
     # the source file that is causing the issues: pylint: disable=unused-argument
     if _current != _total:
         scons_logger.info(
-            "Slow C compilation detected, used %.0fs so far, scalability problem."
+            """\
+Slow C compilation detected, used %.0fs so far, scalability problem."""
             % delta_time
         )
+    else:
+        if env.orig_lto_mode == "auto" and env.lto_mode:
+            scons_logger.info(
+                """\
+Slow C linking detected, used %.0fs so far, consider using '--lto=no' \
+for faster linking, or '--lto=yes"' to disable this message. """
+                % delta_time
+            )

nuitka/build/SconsSpawn.py

@@ -54,7 +54,7 @@ class SubprocessThread(threading.Thread):
         self.timer_report = TimerReport(
             message="Running %s took %%.2f seconds"
             % repr(self.cmdline).replace("%", "%%"),
-            min_report_time=60,
+            min_report_time=360,
             logger=scons_logger,
         )
 
@@ -73,15 +73,15 @@ class SubprocessThread(threading.Thread):
         return self.data, self.err, self.exit_code, self.exception
 
 
-def runProcessMonitored(cmdline, env):
-    thread = SubprocessThread(cmdline, env)
+def _runProcessMonitored(env, cmdline, os_env):
+    thread = SubprocessThread(cmdline, os_env)
     thread.start()
 
-    # Allow 5 minutes before warning for long compile time.
+    # Allow 6 minutes before warning for long compile time.
     thread.join(360)
 
     if thread.is_alive():
-        reportSlowCompilation(cmdline, thread.timer_report.getTimer().getDelta())
+        reportSlowCompilation(env, cmdline, thread.timer_report.getTimer().getDelta())
 
     thread.join()
 
@@ -160,7 +160,7 @@ def _getWindowsSpawnFunction(env, module_mode, source_files):
         if cmd == "<clcache>":
             data, err, rv = runClCache(args, os_env)
         else:
-            data, err, rv, exception = runProcessMonitored(cmdline, os_env)
+            data, err, rv, exception = _runProcessMonitored(env, cmdline, os_env)
 
             if exception:
                 closeSconsProgressBar()
@@ -323,7 +323,7 @@ class SpawnThread(threading.Thread):
         self.timer_report = TimerReport(
             message="Running %s took %%.2f seconds"
             % (" ".join(_unescape(arg) for arg in self.args[2]).replace("%", "%%"),),
-            min_report_time=60,
+            min_report_time=360,
             logger=scons_logger,
         )
 
@@ -342,15 +342,15 @@ class SpawnThread(threading.Thread):
         return self.result, self.exception
 
 
-def runSpawnMonitored(sh, cmd, args, env):
-    thread = SpawnThread(sh, cmd, args, env)
+def _runSpawnMonitored(env, sh, cmd, args, os_env):
+    thread = SpawnThread(sh, cmd, args, os_env)
     thread.start()
 
-    # Allow 5 minutes before warning for long compile time.
+    # Allow 6 minutes before warning for long compile time.
     thread.join(360)
 
     if thread.is_alive():
-        reportSlowCompilation(cmd, thread.timer_report.getTimer().getDelta())
+        reportSlowCompilation(env, cmd, thread.timer_report.getTimer().getDelta())
 
     thread.join()
 
@@ -360,16 +360,16 @@ def runSpawnMonitored(sh, cmd, args, env):
 
 
 def _getWrappedSpawnFunction(env):
-    def spawnCommand(sh, escape, cmd, args, _env):
+    def spawnCommand(sh, escape, cmd, args, os_env):
         # signature needed towards Scons core, pylint: disable=unused-argument
 
         # Avoid using ccache on binary constants blob, not useful and not working
         # with old ccache.
         if '"__constants_data.o"' in args or '"__constants_data.os"' in args:
-            _env = dict(_env)
-            _env["CCACHE_DISABLE"] = "1"
+            os_env = dict(os_env)
+            os_env["CCACHE_DISABLE"] = "1"
 
-        result, exception = runSpawnMonitored(sh, cmd, args, _env)
+        result, exception = _runSpawnMonitored(env, sh, cmd, args, os_env)
 
         if exception:
             closeSconsProgressBar()

nuitka/build/include/nuitka/builtins.h

@@ -41,6 +41,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_BUILTIN(PyObject *name) {
     return result;
 }
 
+// Returns a reference.
 NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_BUILTIN_STR(char const *name) {
     CHECK_OBJECT(dict_builtin);
 
@@ -54,6 +55,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_BUILTIN_STR(char const *name) {
 
     CHECK_OBJECT(result);
 
+    Py_INCREF(result);
     return result;
 }
 

nuitka/build/include/nuitka/filesystem_paths.h

@@ -89,4 +89,8 @@ extern bool renameFile(filename_char_t const *source, filename_char_t const *des
 
 extern uint32_t getFileCRC32(filename_char_t const *filename);
 
+// Expand symbolic paths, containing %TEMP%, %PID% without overflowing.
+extern bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_size);
+extern bool expandTemplatePath(char *target, char const *source, size_t buffer_size);
+
 #endif

nuitka/build/include/nuitka/helper/attributes.h

@@ -33,6 +33,9 @@ extern int BUILTIN_HASATTR_BOOL(PyObject *source, PyObject *attr_name);
 // Check for an attribute, cannot raise an exception.
 extern bool HAS_ATTR_BOOL(PyObject *source, PyObject *attr_name);
 
+// Check for an attribute, can raise an exception.
+extern int HAS_ATTR_BOOL2(PyObject *source, PyObject *attr_name);
+
 // Set an attribute except for attribute slots below.
 extern bool SET_ATTRIBUTE(PyObject *target, PyObject *attr_name, PyObject *value);
 

nuitka/build/include/nuitka/helper/import_hard.h

@@ -99,3 +99,9 @@ extern PyObject *IMPORT_HARD_TYPES(void);
 #if PYTHON_VERSION >= 0x350
 extern PyObject *IMPORT_HARD_TYPING(void);
 #endif
+
+/* C helper for hard import of module "unittest" import. */
+extern PyObject *IMPORT_HARD_UNITTEST(void);
+
+/* C helper for hard import of module "unittest.mock" import. */
+extern PyObject *IMPORT_HARD_UNITTEST__MOCK(void);

nuitka/build/include/nuitka/helpers.h

@@ -361,7 +361,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *MODULE_NAME0(PyObject *module) {
     return DICT_GET_ITEM0(module_dict, const_str_plain___name__);
 }
 
-// Get the binary directory was wide characters.
+// Get the binary directory as wide characters.
 extern wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks);
 
 // Get the binary directory, translated to ANSI/native path

nuitka/build/include/nuitka/safe_string_ops.h

@@ -18,6 +18,7 @@
 #ifndef __NUITKA_SAFE_STRING_OPS_H__
 #define __NUITKA_SAFE_STRING_OPS_H__
 
+#include <errno.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -36,8 +37,14 @@ extern void appendCharSafeW(wchar_t *target, char c, size_t buffer_size);
 extern void appendStringSafeW(wchar_t *target, char const *source, size_t buffer_size);
 extern void appendWStringSafeW(wchar_t *target, wchar_t const *source, size_t buffer_size);
 
-/* Expand symbolic paths, containing %TEMP%, %PID% without overflowing. */
-extern bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_size);
-extern bool expandTemplatePath(char *target, char const *source, size_t buffer_size);
+/* Get OS error code and print it to stderr. */
+#ifdef _WIN32
+typedef DWORD error_code_t;
+static inline error_code_t getCurrentErrorCode(void) { return GetLastError(); }
+#else
+typedef int error_code_t;
+static inline error_code_t getCurrentErrorCode(void) { return errno; }
+#endif
+extern void printOSErrorMessage(char const *message, error_code_t error_code);
 
 #endif

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -1530,17 +1530,6 @@ int Nuitka_BuiltinModule_SetAttr(PyModuleObject *module, PyObject *name, PyObjec
     return PyObject_GenericSetAttr((PyObject *)module, name, value);
 }
 
-#if defined(_WIN32)
-#include <Shlwapi.h>
-#elif defined(__APPLE__)
-#include <dlfcn.h>
-#include <libgen.h>
-#include <mach-o/dyld.h>
-#else
-#include <dlfcn.h>
-#include <libgen.h>
-#endif
-
 #if defined(__FreeBSD__) || defined(__OpenBSD__)
 #include <sys/sysctl.h>
 #endif
@@ -1594,195 +1583,6 @@ NUITKA_MAY_BE_UNUSED static void stripFilenameW(wchar_t *path) {
 
 #if defined(_NUITKA_EXE)
 
-#ifdef _WIN32
-static void resolveFileSymbolicLink(wchar_t *resolved_filename, wchar_t const *filename, DWORD resolved_filename_size,
-                                    bool resolve_symlinks) {
-    // Resolve any symbolic links in the filename.
-    // Copies the resolved path over the top of the parameter.
-
-    // There are no symlinks before Windows Vista. TODO: This effectively disables this code
-    // for MinGW64.
-#if _WIN32_WINNT >= 0x0600
-    if (resolve_symlinks) {
-        // Open the file in the most non-exclusive way possible
-        HANDLE file_handle = CreateFileW(filename, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
-                                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
-        if (unlikely(file_handle == INVALID_HANDLE_VALUE)) {
-            abort();
-        }
-
-        // Resolve the path, get the result with a drive letter
-        DWORD len = GetFinalPathNameByHandleW(file_handle, resolved_filename, resolved_filename_size,
-                                              FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
-
-        CloseHandle(file_handle);
-
-        if (unlikely(len >= resolved_filename_size)) {
-            abort();
-        }
-
-        // Avoid network filenames added by just the resolution, revert it if
-        // they are pointing to local drive.
-        if (wcsncmp(resolved_filename, L"\\\\?\\", 4) == 0) {
-            if (wcscmp(resolved_filename + 4, filename) == 0) {
-                copyStringSafeW(resolved_filename, filename, resolved_filename_size);
-            } else if (resolved_filename[5] == L':') {
-                copyStringSafeW(resolved_filename, resolved_filename + 4, resolved_filename_size);
-            }
-        }
-    } else
-#endif
-    {
-        copyStringSafeW(resolved_filename, filename, resolved_filename_size);
-    }
-}
-
-#else
-
-static void resolveFileSymbolicLink(char *resolved_filename, char const *filename, size_t resolved_filename_size,
-                                    bool resolve_symlinks) {
-    if (resolve_symlinks) {
-        // At least on macOS, realpath cannot allocate a buffer, itself, so lets
-        // use a local one, only on Linux we could use NULL argument and have a
-        // malloc of the resulting value.
-        char buffer[PATH_MAX];
-
-        char *result = realpath(filename, buffer);
-
-        if (unlikely(result == NULL)) {
-            abort();
-        }
-
-        copyStringSafe(resolved_filename, buffer, resolved_filename_size);
-    } else {
-        copyStringSafe(resolved_filename, filename, resolved_filename_size);
-    }
-}
-#endif
-
-#ifdef _WIN32
-extern wchar_t const *getBinaryFilenameWideChars(bool resolve_symlinks);
-
-char const *getBinaryFilenameHostEncoded(bool resolve_symlinks) {
-    static char *binary_filename = NULL;
-    static char *binary_filename_resolved = NULL;
-
-    char *binary_filename_target;
-
-    if (resolve_symlinks) {
-        binary_filename_target = binary_filename_resolved;
-    } else {
-        binary_filename_target = binary_filename;
-    }
-
-    if (binary_filename_target != NULL) {
-        return binary_filename_target;
-    }
-    wchar_t const *w = getBinaryFilenameWideChars(resolve_symlinks);
-
-    DWORD bufsize = WideCharToMultiByte(CP_ACP, 0, w, -1, NULL, 0, NULL, NULL);
-    assert(bufsize != 0);
-
-    binary_filename_target = (char *)malloc(bufsize + 1);
-    assert(binary_filename_target);
-
-    DWORD res2 = WideCharToMultiByte(CP_ACP, 0, w, -1, binary_filename_target, bufsize, NULL, NULL);
-    assert(res2 != 0);
-
-    if (unlikely(res2 > bufsize)) {
-        abort();
-    }
-
-    return (char const *)binary_filename_target;
-}
-
-#else
-char const *getBinaryFilenameHostEncoded(bool resolve_symlinks) {
-    const int buffer_size = MAXPATHLEN + 1;
-
-    static char binary_filename[MAXPATHLEN + 1] = {0};
-    static char binary_filename_resolved[MAXPATHLEN + 1] = {0};
-
-    char *binary_filename_target;
-
-    if (resolve_symlinks) {
-        binary_filename_target = binary_filename_resolved;
-    } else {
-        binary_filename_target = binary_filename;
-    }
-
-    if (*binary_filename_target != 0) {
-        return binary_filename_target;
-    }
-
-#if defined(__APPLE__)
-    uint32_t bufsize = buffer_size;
-    int res = _NSGetExecutablePath(binary_filename_target, &bufsize);
-
-    if (unlikely(res != 0)) {
-        abort();
-    }
-
-    // Resolve any symlinks we were invoked via
-    resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
-
-#elif defined(__FreeBSD__) || defined(__OpenBSD__)
-    /* Not all of FreeBSD has /proc file system, so use the appropriate
-     * "sysctl" instead.
-     */
-    int mib[4];
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_PATHNAME;
-    mib[3] = -1;
-    size_t cb = buffer_size;
-    int res = sysctl(mib, 4, binary_filename_target, &cb, NULL, 0);
-
-    if (unlikely(res != 0)) {
-        abort();
-    }
-
-    // Resolve any symlinks we were invoked via
-    resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
-#else
-    /* The remaining platforms, mostly Linux or compatible. */
-
-    /* The "readlink" call does not terminate result, so fill zeros there, then
-     * it is a proper C string right away. */
-    memset(binary_filename_target, 0, buffer_size);
-    ssize_t res = readlink("/proc/self/exe", binary_filename_target, buffer_size - 1);
-
-    if (unlikely(res == -1)) {
-        abort();
-    }
-
-    // Resolve any symlinks we were invoked via
-    resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
-#endif
-
-    return binary_filename_target;
-}
-#endif
-
-#ifdef _WIN32
-wchar_t const *getBinaryFilenameWideChars(bool resolve_symlinks) {
-    static wchar_t binary_filename[MAXPATHLEN + 1];
-    static bool init_done = false;
-
-    if (init_done == false) {
-        DWORD res = GetModuleFileNameW(NULL, binary_filename, sizeof(binary_filename) / sizeof(wchar_t));
-        assert(res != 0);
-
-        // Resolve any symlinks we were invoked via
-        resolveFileSymbolicLink(binary_filename, binary_filename, sizeof(binary_filename) / sizeof(wchar_t),
-                                resolve_symlinks);
-    }
-
-    return binary_filename;
-}
-#endif
-
 wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
     static wchar_t binary_directory[MAXPATHLEN + 1];
     static bool init_done = false;