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

nuitka/build/SconsInterface.py

@@ -42,6 +42,7 @@ from nuitka.PythonVersions import (
     getSystemPrefixPath,
     getTargetPythonDLLPath,
     python_version,
+    python_version_str,
 )
 from nuitka.utils.Execution import (
     getExecutablePath,
@@ -334,6 +335,7 @@ def asBoolStr(value):
 def cleanSconsDirectory(source_dir):
     """Clean scons build directory."""
 
+    # spell-checker: ignore gcda
     extensions = (
         ".bin",
         ".c",
@@ -380,6 +382,9 @@ def setCommonSconsOptions(options):
     # Scons gets transported many details, that we express as variables, and
     # have checks for them, leading to many branches and statements,
     # pylint: disable=too-many-branches,too-many-statements
+    options["nuitka_src"] = getSconsDataPath()
+
+    options["python_version"] = python_version_str
 
     options["python_prefix"] = getDirectoryRealPath(getSystemPrefixPath())
 

nuitka/build/SconsSpawn.py

@@ -128,6 +128,12 @@ surely happen again."""
     )
 
 
+def _getNoSuchCommandErrorMessage():
+    import ctypes
+
+    return ctypes.WinError(3).args[1]
+
+
 # To work around Windows not supporting command lines of greater than 10K by
 # default:
 def _getWindowsSpawnFunction(env, module_mode, source_files):
@@ -202,7 +208,14 @@ def _getWindowsSpawnFunction(env, module_mode, source_files):
                 err = decodeData(err)
 
             err = "\r\n".join(
-                line for line in err.split("\r\n") if not isIgnoredError(line)
+                line
+                for line in err.split("\r\n")
+                if not isIgnoredError(line)
+                if not (
+                    env.mingw_mode
+                    and env.lto_mode
+                    and line == _getNoSuchCommandErrorMessage()
+                )
             )
 
             if err:
@@ -402,8 +415,8 @@ it or using '--clang' option."""
     return spawnCommand
 
 
-def enableSpawnMonitoring(env, win_target, module_mode, source_files):
-    if win_target:
+def enableSpawnMonitoring(env, module_mode, source_files):
+    if os.name == "nt":
         env["SPAWN"] = _getWindowsSpawnFunction(
             env=env, module_mode=module_mode, source_files=source_files
         )

nuitka/build/SconsUtils.py

@@ -160,7 +160,7 @@ def prepareEnvironment(mingw_mode):
             if os.path.isdir(cc_dirname):
                 addToPATH(None, cc_dirname, prefix=True)
 
-        if win_target and isGccName(os.path.basename(os.environ["CC"])):
+        if os.name == "nt" and isGccName(os.path.basename(os.environ["CC"])):
             scons_details_logger.info(
                 "Environment CC seems to be a gcc, enabling mingw_mode."
             )
@@ -286,11 +286,6 @@ def decodeData(data):
             return data.decode("utf8", "backslashreplace")
 
 
-# Windows target mode: Compile for Windows. Used to be an option, but we
-# no longer cross compile this way.
-win_target = os.name == "nt"
-
-
 def getExecutablePath(filename, env):
     """Find an execute in either normal PATH, or Scons detected PATH."""
 
@@ -303,7 +298,7 @@ def getExecutablePath(filename, env):
         filename = env[filename[1:]]
 
     # Append ".exe" suffix  on Windows if not already present.
-    if win_target and not filename.lower().endswith(".exe"):
+    if os.name == "nt" and not filename.lower().endswith(".exe"):
         filename += ".exe"
 
     # Either look at the initial "PATH" as given from the outside or look at the
@@ -491,7 +486,7 @@ def cheapCopyFile(src, dst):
     if not os.path.exists(dirname):
         os.makedirs(dirname)
 
-    if win_target:
+    if os.name == "nt":
         # Windows has symlinks these days, but they do not integrate well
         # with Python2 at least. So make a copy in any case.
         if os.path.exists(dst):
@@ -524,9 +519,11 @@ def cheapCopyFile(src, dst):
             shutil.copy(src, dst)
 
 
-def provideStaticSourceFile(sub_path, nuitka_src, source_dir, c11_mode):
-    source_filename = os.path.join(nuitka_src, "static_src", sub_path)
-    target_filename = os.path.join(source_dir, "static_src", os.path.basename(sub_path))
+def provideStaticSourceFile(env, sub_path, c11_mode):
+    source_filename = os.path.join(env.nuitka_src, "static_src", sub_path)
+    target_filename = os.path.join(
+        env.source_dir, "static_src", os.path.basename(sub_path)
+    )
 
     if target_filename.endswith(".c") and not c11_mode:
         target_filename += "pp"  # .cpp suffix then.
@@ -592,6 +589,8 @@ def createDefinitionsFile(source_dir, filename, definitions):
                 continue
 
             if type(value) is int or key.endswith(("_BOOL", "_INT")):
+                if type(value) is bool:
+                    value = int(value)
                 f.write("#define %s %s\n" % (key, value))
             elif type(value) in (str, unicode) and key.endswith("_WIDE_STRING"):
                 f.write("#define %s L%s\n" % (key, makeCLiteral(value)))
@@ -665,7 +664,7 @@ def getLinkerArch(target_arch, mingw_mode):
     global _linker_arch_determined, _linker_arch
 
     if not _linker_arch_determined:
-        if win_target:
+        if os.name == "nt":
             if target_arch == "x86_64":
                 _linker_arch = "pei-x86-64"
             elif target_arch == "arm64":

nuitka/build/include/nuitka/checksum_tools.h

@@ -24,10 +24,6 @@
 #include "nuitka/prelude.h"
 #endif
 
-extern uint32_t initCRC32(void);
-extern uint32_t updateCRC32(uint32_t crc, unsigned char const *message, uint32_t size);
-extern uint32_t finalizeCRC32(uint32_t crc);
-
 extern uint32_t calcCRC32(unsigned char const *message, uint32_t size);
 
 #endif

nuitka/build/include/nuitka/compiled_asyncgen.h

@@ -42,7 +42,7 @@ struct Nuitka_AsyncgenObject {
     PyObject *m_module;
 
     PyObject *m_qualname;
-    PyObject *m_yieldfrom;
+    PyObject *m_yield_from;
 
     // Weak references are supported for asyncgen objects in CPython.
     PyObject *m_weakrefs;

nuitka/build/include/nuitka/compiled_coroutine.h

@@ -42,7 +42,7 @@ struct Nuitka_CoroutineObject {
     PyObject *m_module;
 
     PyObject *m_qualname;
-    PyObject *m_yieldfrom;
+    PyObject *m_yield_from;
 
     // Weak references are supported for coroutine objects in CPython.
     PyObject *m_weakrefs;

nuitka/build/include/nuitka/compiled_frame.h

@@ -93,10 +93,13 @@ extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyO
 NUITKA_MAY_BE_UNUSED static inline bool isFakeCodeObject(PyCodeObject *code) {
 #if PYTHON_VERSION < 0x300
     return code->co_code == const_str_empty;
-#elif PYTHON_VERSION < 0x3B0
+#elif PYTHON_VERSION < 0x3b0
     return code->co_code == const_str_empty;
-#else
+#elif PYTHON_VERSION < 0x3c0
     return _PyCode_CODE(code)[0] == 0;
+#else
+    _Py_CODEUNIT *code_unit = _PyCode_CODE(code);
+    return code_unit->op.code == 0;
 #endif
 }
 
@@ -195,7 +198,7 @@ inline static void assertFrameObject(struct Nuitka_FrameObject *frame_object) {
 }
 
 inline static void assertThreadFrameObject(Nuitka_ThreadStateFrameType *frame) {
-#if PYTHON_VERSION < 0x3B0
+#if PYTHON_VERSION < 0x3b0
     assertPythonFrameObject(frame);
 #else
     // For uncompiled frames of Python 3.11 these often do not exist. TODO: Figure
@@ -267,7 +270,7 @@ static inline bool Nuitka_Frame_IsExecuting(struct Nuitka_FrameObject *frame) {
 }
 #endif
 
-#if PYTHON_VERSION >= 0x3B0
+#if PYTHON_VERSION >= 0x3b0
 NUITKA_MAY_BE_UNUSED inline static void pushFrameStackInterpreterFrame(PyThreadState *tstate,
                                                                        _PyInterpreterFrame *interpreter_frame) {
     _PyInterpreterFrame *old = tstate->cframe->current_frame;

nuitka/build/include/nuitka/compiled_function.h

@@ -19,8 +19,8 @@
 #define __NUITKA_COMPILED_FUNCTION_H__
 
 #ifdef __IDE_ONLY__
-#include "Python.h"
-#include "frameobject.h"
+#include <Python.h>
+#include <frameobject.h>
 #endif
 
 // Compiled function type.
@@ -108,7 +108,7 @@ extern struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_co
 #else
 extern struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyObject *name, PyObject *qualname,
                                                          PyCodeObject *code_object, PyObject *defaults,
-                                                         PyObject *kwdefaults, PyObject *annotations, PyObject *module,
+                                                         PyObject *kw_defaults, PyObject *annotations, PyObject *module,
                                                          PyObject *doc, struct Nuitka_CellObject **closure,
                                                          Py_ssize_t closure_given);
 #endif
@@ -119,6 +119,16 @@ extern void Nuitka_Function_EnableConstReturnFalse(struct Nuitka_FunctionObject
 
 extern void Nuitka_Function_EnableConstReturnGeneric(struct Nuitka_FunctionObject *function, PyObject *value);
 
+#ifdef _NUITKA_PLUGIN_DILL_ENABLED
+extern int Nuitka_Function_GetFunctionCodeIndex(struct Nuitka_FunctionObject *function,
+                                                function_impl_code const *function_table);
+extern struct Nuitka_FunctionObject *
+Nuitka_Function_CreateFunctionViaCodeIndex(PyObject *module, PyObject *function_qualname, PyObject *function_index,
+                                           PyObject *code_object_desc, PyObject *constant_return_value,
+                                           PyObject *defaults, PyObject *kw_defaults, PyObject *doc,
+                                           function_impl_code const *function_table, int function_table_size);
+#endif
+
 static inline bool Nuitka_Function_Check(PyObject *object) { return Py_TYPE(object) == &Nuitka_Function_Type; }
 
 static inline PyObject *Nuitka_Function_GetName(PyObject *object) {

nuitka/build/include/nuitka/compiled_generator.h

@@ -67,7 +67,7 @@ struct Nuitka_GeneratorObject {
 #endif
 #if PYTHON_VERSION >= 0x300
     // The value currently yielded from.
-    PyObject *m_yieldfrom;
+    PyObject *m_yield_from;
 #endif
 
     // Weak references are supported for generator objects in CPython.

nuitka/build/include/nuitka/constants.h

@@ -160,6 +160,8 @@ extern PyObject **global_constants;
 #define const_str_plain___newobj__ global_constants[44]
 // '.'
 #define const_str_dot global_constants[45]
+// '_'
+#define const_str_underscore global_constants[45]
 // '__getattr__'
 #define const_str_plain___getattr__ global_constants[46]
 // '__setattr__'

nuitka/build/include/nuitka/environment_variables.h

@@ -0,0 +1,45 @@
+//     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.
+//
+#ifndef __NUITKA_ENVIRONMENT_VARIABLES_H__
+#define __NUITKA_ENVIRONMENT_VARIABLES_H__
+
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+// Helpers for working with environment variables in a portable way. This mainly
+// abstracts the string type differences between Win32 and non-Win32 environment
+// variables.
+#if defined(_WIN32)
+#define environment_char_t wchar_t
+#define compareEnvironmentString(a, b) wcscmp(a, b)
+#define makeEnvironmentLiteral(x) L##x
+#else
+#define environment_char_t char
+#define compareEnvironmentString(a, b) strcmp(a, b)
+#define makeEnvironmentLiteral(x) x
+#endif
+
+extern environment_char_t const *getEnvironmentVariable(char const *name);
+extern void setEnvironmentVariable(char const *name, environment_char_t const *value);
+extern void unsetEnvironmentVariable(char const *name);
+
+extern void undoEnvironmentVariable(PyThreadState *tstate, char const *variable_name,
+                                    environment_char_t const *old_value);
+
+#endif

nuitka/build/include/nuitka/exceptions.h

@@ -376,9 +376,9 @@ NUITKA_MAY_BE_UNUSED inline static void SET_CURRENT_EXCEPTION_TYPE0(PyThreadStat
 }
 
 // Same as "PyErr_SetObject" CPython API, use this instead.
-#if PYTHON_VERSION < 0x3c0
 NUITKA_MAY_BE_UNUSED inline static void
 SET_CURRENT_EXCEPTION_TYPE0_VALUE0(PyThreadState *tstate, PyObject *exception_type, PyObject *exception_value) {
+#if PYTHON_VERSION < 0x3c0
     PyObject *old_exception_type = tstate->curexc_type;
     PyObject *old_exception_value = tstate->curexc_value;
     PyObject *old_exception_traceback = tstate->curexc_traceback;
@@ -397,10 +397,24 @@ SET_CURRENT_EXCEPTION_TYPE0_VALUE0(PyThreadState *tstate, PyObject *exception_ty
     Py_XDECREF(old_exception_type);
     Py_XDECREF(old_exception_value);
     Py_XDECREF(old_exception_traceback);
+#else
+    PyObject *old_exception = tstate->current_exception;
+
+    tstate->current_exception = exception_value;
+    Py_INCREF(exception_value);
+
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("SET_CURRENT_EXCEPTION_TYPE_0VALUE0:\n");
+    PRINT_CURRENT_EXCEPTION();
+#endif
+
+    Py_XDECREF(old_exception);
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED inline static void
 SET_CURRENT_EXCEPTION_TYPE0_VALUE1(PyThreadState *tstate, PyObject *exception_type, PyObject *exception_value) {
+#if PYTHON_VERSION < 0x3c0
     PyObject *old_exception_type = tstate->curexc_type;
     PyObject *old_exception_value = tstate->curexc_value;
     PyObject *old_exception_traceback = tstate->curexc_traceback;
@@ -418,10 +432,20 @@ SET_CURRENT_EXCEPTION_TYPE0_VALUE1(PyThreadState *tstate, PyObject *exception_ty
     Py_XDECREF(old_exception_type);
     Py_XDECREF(old_exception_value);
     Py_XDECREF(old_exception_traceback);
-}
+#else
+    PyObject *old_exception = tstate->current_exception;
+
+    tstate->current_exception = exception_value;
 
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("SET_CURRENT_EXCEPTION_TYPE0_VALUE1:\n");
+    PRINT_CURRENT_EXCEPTION();
 #endif
 
+    Py_XDECREF(old_exception);
+#endif
+}
+
 // Helper that sets the current thread exception, and has no reference passed.
 // Same as CPython API PyErr_SetString
 
@@ -889,10 +913,14 @@ extern void FORMAT_UNBOUND_CLOSURE_ERROR(PyObject **exception_type, PyObject **e
 #endif
 
 #if PYTHON_VERSION >= 0x3c0
-static PyObject *_MAKE_EXCEPTION_FROM_TYPE_ARG0(PyTypeObject *type, PyObject *arg) {
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE1(PyObject *element1);
+
+static PyObject *_MAKE_EXCEPTION_FROM_TYPE_ARG0(PyObject *type, PyObject *arg) {
     PyBaseExceptionObject *self;
 
-    self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
+    PyTypeObject *type_object = (PyTypeObject *)type;
+
+    self = (PyBaseExceptionObject *)(type_object->tp_alloc(type_object, 0));
 
     self->dict = NULL;
     self->notes = NULL;

nuitka/build/include/nuitka/filesystem_paths.h

@@ -18,6 +18,8 @@
 #ifndef __NUITKA_FILESYSTEM_PATH_OPS_H__
 #define __NUITKA_FILESYSTEM_PATH_OPS_H__
 
+#include "nuitka/safe_string_ops.h"
+
 // Have a type for filename type different on Linux and Win32.
 #if defined(_WIN32)
 #define filename_char_t wchar_t
@@ -33,6 +35,7 @@
 #define strlenFilename wcslen
 #define strcmpFilename wcscmp
 #define strdupFilename wcsdup
+#define scanFilename swscanf
 #else
 #define filename_char_t char
 #define FILENAME_EMPTY_STR ""
@@ -47,6 +50,7 @@
 #define strlenFilename strlen
 #define strcmpFilename strcmp
 #define strdupFilename strdup
+#define scanFilename sscanf
 #endif
 
 #if defined(_WIN32)
@@ -79,8 +83,9 @@ extern FILE_HANDLE openFileForReading(filename_char_t const *filename);
 extern FILE_HANDLE createFileForWriting(filename_char_t const *filename);
 extern int64_t getFileSize(FILE_HANDLE file_handle);
 extern bool readFileChunk(FILE_HANDLE file_handle, void *buffer, size_t size);
-extern bool writeFileChunk(FILE_HANDLE file_handle, void *buffer, size_t size);
+extern bool writeFileChunk(FILE_HANDLE file_handle, void const *buffer, size_t size);
 extern bool closeFile(FILE_HANDLE target_file);
+extern error_code_t getLastErrorCode(void);
 
 extern int getFileMode(filename_char_t const *filename);
 extern bool copyFile(filename_char_t const *source, filename_char_t const *dest, int mode);

nuitka/build/include/nuitka/freelists.h

@@ -19,6 +19,16 @@
 #ifndef __NUITKA_FREELISTS_H__
 #define __NUITKA_FREELISTS_H__
 
+#ifndef __cplusplus
+#include "stdbool.h"
+#endif
+
+#ifdef _NUITKA_EXPERIMENTAL_DISABLE_FREELIST_ALL
+static const bool use_freelists = false;
+#else
+static const bool use_freelists = true;
+#endif
+
 #define allocateFromFreeList(free_list, object_type, type_type, size)                                                  \
     if (free_list != NULL) {                                                                                           \
         result = free_list;                                                                                            \
@@ -51,7 +61,7 @@
     CHECK_OBJECT(result);
 
 #define releaseToFreeList(free_list, object, max_free_list_count)                                                      \
-    if (free_list != NULL || max_free_list_count == 0) {                                                               \
+    if (free_list != NULL || max_free_list_count == 0 || use_freelists == false) {                                     \
         if (free_list##_count >= max_free_list_count) {                                                                \
             PyObject_GC_Del(object);                                                                                   \
         } else {                                                                                                       \

nuitka/build/include/nuitka/helper/dictionaries.h

@@ -214,7 +214,7 @@ static Nuitka_DictEntryHandle GET_STRING_DICT_ENTRY(PyDictObject *dict, Nuitka_S
 #else
     // Will be written by Nuitka_PyDictLookupStr in all cases.
     PyObject **value;
-    Py_ssize_t found = Nuitka_PyDictLookupStr(dict, (PyObject *)key, hash, &value);
+    NUITKA_MAY_BE_UNUSED Py_ssize_t found = Nuitka_PyDictLookupStr(dict, (PyObject *)key, hash, &value);
     assert(found != DKIX_ERROR);
 
     return value;

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

@@ -38,6 +38,9 @@ extern PyObject *IMPORT_HARD__FROZEN_IMPORTLIB_EXTERNAL(void);
 /* C helper for hard import of module "_io" import. */
 extern PyObject *IMPORT_HARD__IO(void);
 
+/* C helper for hard import of module "builtins" import. */
+extern PyObject *IMPORT_HARD_BUILTINS(void);
+
 /* C helper for hard import of module "ctypes" import. */
 extern PyObject *IMPORT_HARD_CTYPES(void);
 

nuitka/build/include/nuitka/helpers.h

@@ -63,12 +63,14 @@
 // From CPython, to allow us quick access to the dictionary of an module, the
 // structure is normally private, but we need it for quick access to the module
 // dictionary.
+#if PYTHON_VERSION < 0x3c0
 typedef struct {
     /* Python object folklore: */
     PyObject_HEAD
 
         PyObject *md_dict;
 } PyModuleObject;
+#endif
 
 // Generated code helpers, used in static helper codes:
 extern PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyObject *const *args);

nuitka/build/include/nuitka/importing.h

@@ -37,6 +37,9 @@ extern PyObject *IMPORT_MODULE_KW(PyThreadState *tstate, PyObject *module_name,
 
 extern bool IMPORT_MODULE_STAR(PyThreadState *tstate, PyObject *target, bool is_module, PyObject *module);
 
+// Fixed import name to be imported and used by value name.
+extern PyObject *IMPORT_MODULE_FIXED(PyThreadState *tstate, PyObject *module_name, PyObject *value_name);
+
 // Import an embedded module directly.
 extern PyObject *IMPORT_EMBEDDED_MODULE(PyThreadState *tstate, char const *name);
 

nuitka/build/include/nuitka/prelude.h

@@ -55,12 +55,12 @@
 #endif
 
 /* Include the relevant Python C-API header files. */
-#include "Python.h"
-#include "frameobject.h"
-#include "marshal.h"
-#include "methodobject.h"
-#include "osdefs.h"
-#include "structseq.h"
+#include <Python.h>
+#include <frameobject.h>
+#include <marshal.h>
+#include <methodobject.h>
+#include <osdefs.h>
+#include <structseq.h>
 
 #if PYTHON_VERSION < 0x3a0
 #include "pydebug.h"
@@ -126,6 +126,7 @@ extern _PyRuntimeState _PyRuntime;
 #endif
 
 #if PYTHON_VERSION >= 0x3b0
+#include <internal/pycore_dict.h>
 #include <internal/pycore_frame.h>
 #include <internal/pycore_gc.h>
 #endif
@@ -137,6 +138,10 @@ extern _PyRuntimeState _PyRuntime;
 #undef CALL_FUNCTION
 #endif
 
+#if PYTHON_VERSION >= 0x3c0
+#include <cpython/code.h>
+#endif
+
 #if !defined(PY_NOGIL) && PYTHON_VERSION < 0x3c0
 #undef PyThreadState_GET
 #define _PyThreadState_Current _PyRuntime.gilstate.tstate_current
@@ -485,6 +490,12 @@ extern PyObject *Nuitka_dunder_compiled_value;
 #define NUITKA_INIT_PROGRAM_LATE(module_name)
 #endif
 
+#if _NUITKA_EXPERIMENTAL_EXIT_PROGRAM
+#include "nuitka_exit_program.h"
+#else
+#define NUITKA_FINALIZE_PROGRAM(tstate)
+#endif
+
 // Only Python3.9+ has a more precise check, while making the old one slow.
 #ifndef PyCFunction_CheckExact
 #define PyCFunction_CheckExact PyCFunction_Check

nuitka/build/include/nuitka/unfreezing.h

@@ -37,7 +37,7 @@ typedef PyObject *(*module_initfunc)(PyThreadState *tstate, PyObject *module,
                                      struct Nuitka_MetaPathBasedLoaderEntry const *loader_entry);
 
 #if PYTHON_VERSION >= 0x370 && defined(_NUITKA_EXE) && !defined(_NUITKA_STANDALONE) &&                                 \
-    defined(NUITKA_FILE_REFERENCE_ORIGINAL_MODE)
+    defined(_NUITKA_FILE_REFERENCE_ORIGINAL_MODE)
 #define _NUITKA_FREEZER_HAS_FILE_PATH
 #endif
 

nuitka/build/inline_copy/bin/scons.py

@@ -9,6 +9,7 @@ to add another one.
 """
 
 if __name__ == "__main__":
+    import hashlib
     import os
     import sys
 
@@ -37,6 +38,19 @@ if __name__ == "__main__":
     # On Windows this Scons variable must be set by us.
     os.environ["SCONS_LIB_DIR"] = sys.path[0]
 
+    # Workaround for FIPS enabled systems.
+    try:
+        hashlib.md5()
+    except ValueError:
+        # On FIPS compliant systems, checks might be enabled that require this
+        # parameter to be set.
+        _md5 = hashlib.md5
+
+        def md5(value=b""):
+            return _md5(value, usedforsecurity=False)
+
+        hashlib.md5 = md5
+
     import SCons.Script  # pylint: disable=import-error
 
     # this does all the work, and calls sys.exit

nuitka/build/inline_copy/tqdm/tqdm/__init__.py

@@ -1,7 +1,7 @@
 from ._monitor import TMonitor, TqdmSynchronisationWarning
 from ._tqdm_pandas import tqdm_pandas
-from .gui import tqdm as tqdm_gui  # TODO: remove in v5.0.0
-from .gui import trange as tgrange  # TODO: remove in v5.0.0
+# from .gui import tqdm as tqdm_gui  # TODO: remove in v5.0.0
+# from .gui import trange as tgrange  # TODO: remove in v5.0.0
 from .std import (
     TqdmDeprecationWarning, TqdmExperimentalWarning, TqdmKeyError, TqdmMonitorWarning,
     TqdmTypeError, TqdmWarning, tqdm, trange)

nuitka/build/inline_copy/tqdm/tqdm/utils.py

@@ -5,7 +5,7 @@ import os
 import re
 import sys
 from functools import wraps
-from warnings import warn
+import warnings
 
 # py2/3 compat
 try:
@@ -236,9 +236,12 @@ def _screen_shape_wrapper():  # pragma: no cover
 
 def _screen_shape_windows(fp):  # pragma: no cover
     try:
-        import struct
-        from ctypes import create_string_buffer, windll
-        from sys import stdin, stdout
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+
+            import struct
+            from ctypes import create_string_buffer, windll
+            from sys import stdin, stdout
 
         io_handle = -12  # assume stderr
         if fp == stdin:
@@ -273,9 +276,12 @@ def _screen_shape_tput(*_):  # pragma: no cover
 def _screen_shape_linux(fp):  # pragma: no cover
 
     try:
-        from array import array
-        from fcntl import ioctl
-        from termios import TIOCGWINSZ
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+
+            from array import array
+            from fcntl import ioctl
+            from termios import TIOCGWINSZ
     except ImportError:
         return None
     else:
@@ -294,7 +300,7 @@ def _environ_cols_wrapper():  # pragma: no cover
     Return a function which returns console width.
     Supported: linux, osx, windows, cygwin.
     """
-    warn("Use `_screen_shape_wrapper()(file)[0]` instead of"
+    warnings.warn("Use `_screen_shape_wrapper()(file)[0]` instead of"
          " `_environ_cols_wrapper()(file)`", DeprecationWarning, stacklevel=2)
     shape = _screen_shape_wrapper()
     if not shape:

nuitka/build/inline_copy/zlib/LICENSE

@@ -0,0 +1,22 @@
+Copyright notice:
+
+ (C) 1995-2022 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu