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

nuitka/build/static_src/HelpersFilesystemPaths.c

@@ -749,7 +749,7 @@ bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_s
                     }
                 } else if (wcsicmp(var_name, L"PID") == 0) {
                     char pid_buffer[128];
-                    snprintf(pid_buffer, sizeof(pid_buffer), "%d", GetCurrentProcessId());
+                    snprintf(pid_buffer, sizeof(pid_buffer), "%ld", GetCurrentProcessId());
 
                     appendStringSafeW(target, pid_buffer, buffer_size);
                 } else if (wcsicmp(var_name, L"HOME") == 0) {

nuitka/build/static_src/HelpersSafeStrings.c

@@ -133,7 +133,7 @@ void printOSErrorMessage(char const *message, error_code_t error_code) {
     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
                   error_code, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), (LPTSTR)&err_buffer, 0, NULL);
 
-    fprintf(stderr, "%s ([Error %d] %s)\n", message, error_code, err_buffer);
+    fprintf(stderr, "%s ([Error " ERROR_CODE_FORMAT_STR "] %s)\n", message, error_code, err_buffer);
 #else
     fprintf(stderr, "%s: %s\n", message, strerror(error_code));
 #endif

nuitka/build/static_src/MainProgram.c

@@ -1524,7 +1524,6 @@ orig_argv = argv;
 
             CALL_FUNCTION_WITH_KEYARGS(tstate, main_function, kw_args);
         }
-        static int loky_joblib_parent_pid_arg = 0;
 
         int exit_code = HANDLE_PROGRAM_EXIT(tstate);
 

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -64,7 +64,7 @@ static inline bool isVerbose(void) { return false; }
 static struct Nuitka_MetaPathBasedLoaderEntry *loader_entries = NULL;
 
 static bool hasFrozenModule(char const *name) {
-    for (struct _frozen const *p = PyImport_FrozenModules;; p++) {
+    for (struct _frozen const *p = PyImport_FrozenModules; p != NULL; p++) {
         if (p->name == NULL) {
             return false;
         }

nuitka/build/static_src/MetaPathBasedLoaderResourceReaderFiles.c

@@ -221,6 +221,16 @@ static PyObject *Nuitka_ResourceReaderFiles_read_text(struct Nuitka_ResourceRead
     return result;
 }
 
+static PyObject *Nuitka_ResourceReaderFiles_exists(struct Nuitka_ResourceReaderFilesObject *files, PyObject *args,
+                                                   PyObject *kwds) {
+
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *file_name = _Nuitka_ResourceReaderFiles_GetPath(tstate, files);
+    PyObject *result = OS_PATH_FILE_EXISTS(tstate, file_name);
+    Py_DECREF(file_name);
+    return result;
+}
+
 //    @abc.abstractmethod
 //    def is_dir(self) -> bool:
 //        """
@@ -451,6 +461,7 @@ static PyMethodDef Nuitka_ResourceReaderFiles_methods[] = {
     {"iterdir", (PyCFunction)Nuitka_ResourceReaderFiles_iterdir, METH_NOARGS, NULL},
     {"read_bytes", (PyCFunction)Nuitka_ResourceReaderFiles_read_bytes, METH_NOARGS, NULL},
     {"read_text", (PyCFunction)Nuitka_ResourceReaderFiles_read_text, METH_VARARGS | METH_KEYWORDS, NULL},
+    {"exists", (PyCFunction)Nuitka_ResourceReaderFiles_exists, METH_NOARGS, NULL},
     {"is_dir", (PyCFunction)Nuitka_ResourceReaderFiles_is_dir, METH_NOARGS, NULL},
     {"is_file", (PyCFunction)Nuitka_ResourceReaderFiles_is_file, METH_NOARGS, NULL},
     {"joinpath", (PyCFunction)Nuitka_ResourceReaderFiles_joinpath, METH_VARARGS | METH_KEYWORDS, NULL},

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -308,12 +308,29 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
         init_done = true;
     }
 
+#if defined(_NUITKA_MODULE) && %(is_top)d
+    PyObject *pre_load = IMPORT_EMBEDDED_MODULE(tstate, %(module_name_cstr)s "-preLoad");
+    if (pre_load == NULL) {
+        return NULL;
+    }
+#endif
+
     // PRINT_STRING("in init%(module_identifier)s\n");
 
     moduledict_%(module_identifier)s = MODULE_DICT(module_%(module_identifier)s);
 
 #ifdef _NUITKA_PLUGIN_DILL_ENABLED
-    registerDillPluginTables(tstate, loader_entry->name, &_method_def_reduce_compiled_function, &_method_def_create_compiled_function);
+    {
+        char const *module_name_c;
+        if (loader_entry != NULL) {
+            module_name_c = loader_entry->name;
+        } else {
+            PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+            module_name_c = Nuitka_String_AsString(module_name);
+        }
+
+        registerDillPluginTables(tstate, module_name_c, &_method_def_reduce_compiled_function, &_method_def_create_compiled_function);
+    }
 #endif
 
     // Set "__compiled__" to what version information we have.

nuitka/code_generation/templates_c/HelperDictionaryCopy.c.j2

@@ -201,7 +201,7 @@ else
 {% endif %}
                 PyObject *key = *key_ptr;
 {% if per_key_code %}
-                if (is_unicode) {
+                if (is_unicode == false) {
                     {{ per_key_code }}
                 }
 {% endif %}

nuitka/code_generation/templates_c/HelperLongTools.c.j2

@@ -31,7 +31,7 @@
     }
 
     Py_ssize_t {{operand}}_digit_count = 0;
-    digit {{operand}}_digits[5]; // Could be more minimal and depend on sizeof(digit)
+    digit {{operand}}_digits[5] = {0}; // Could be more minimal and depend on sizeof(digit)
     {
         unsigned long t = {{operand}}_abs_ival;
 

nuitka/distutils/DistutilCommands.py

@@ -323,7 +323,9 @@ class build(distutils.command.build.build):
                 for option, value in toml_options.get("nuitka", {}).items():
                     command.extend(self._parseOptionsEntry(option, value))
 
-                for option, value in toml_options.get("tool.nuitka", {}).items():
+                for option, value in (
+                    toml_options.get("tool", {}).get("nuitka", {}).items()
+                ):
                     command.extend(self._parseOptionsEntry(option, value))
 
             # Process any extra options from setuptools

nuitka/nodes/PackageMetadataNodes.py

@@ -85,9 +85,8 @@ class ExpressionPkgResourcesRequireCall(ExpressionPkgResourcesRequireCallBase):
                 resources_module.extern.packaging.requirements.InvalidRequirement
             )
         except AttributeError:
-            InvalidRequirement = (
-                resources_module.packaging.requirements.InvalidRequirement
-            )
+            # Very old versions of pkg_resources do not have it
+            InvalidRequirement = TypeError
 
         args = tuple(
             element.getCompileTimeConstant() for element in self.subnode_requirements

nuitka/plugins/PluginBase.py

@@ -1087,8 +1087,11 @@ except ImportError:
         if shallShowExecutedCommands():
             self.info("Executing query command:\n%s" % cmd)
 
+        env = dict(os.environ)
+        env["PYTHONIOENCODING"] = "utf8"
+
         try:
-            feedback = check_output([sys.executable, "-c", cmd])
+            feedback = check_output([sys.executable, "-c", cmd], env=env)
         except NuitkaCalledProcessError as e:
             if e.returncode == 38:
                 return None
@@ -1211,18 +1214,13 @@ except ImportError:
                 "no_annotations": hasPythonFlagNoAnnotations(),
                 # Querying package properties
                 "has_builtin_module": isBuiltinModuleName,
+                # Architectures
+                "arch_x86": getArchitecture() == "x86",
+                "arch_amd64": getArchitecture() == "x86_64",
+                "arch_arm64": getArchitecture() == "arm64",
             }
         )
 
-        if isWin32Windows() or isMacOS():
-            context.update(
-                {
-                    "arch_x86": getArchitecture() == "x86",
-                    "arch_amd64": getArchitecture() == "x86_64",
-                    "arch_arm64": getArchitecture() == "arm64",
-                }
-            )
-
         versions = getTestExecutionPythonVersions()
 
         for version in versions:

nuitka/plugins/standard/DillPlugin/DillPlugin.c

@@ -0,0 +1,37 @@
+//     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.
+//
+// C code for use when the dill-plugin is active
+
+#include "nuitka/prelude.h"
+
+void registerDillPluginTables(PyThreadState *tstate, char const *module_name, PyMethodDef *reduce_compiled_function,
+                              PyMethodDef *create_compiled_function) {
+    PyObject *function_tables = PyObject_GetAttrString((PyObject *)builtin_module, "compiled_function_tables");
+
+    if (function_tables == NULL) {
+        CLEAR_ERROR_OCCURRED(tstate);
+
+        function_tables = MAKE_DICT_EMPTY();
+        PyObject_SetAttrString((PyObject *)builtin_module, "compiled_function_tables", function_tables);
+    }
+
+    PyObject *funcs =
+        MAKE_TUPLE2_0(PyCFunction_New(reduce_compiled_function, NULL), PyCFunction_New(create_compiled_function, NULL));
+
+    PyDict_SetItemString(function_tables, module_name, funcs);
+}

nuitka/plugins/standard/DillPlugin/dill-postLoad.py

@@ -0,0 +1,249 @@
+#     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.
+#
+# Plugin dill-compat has this as post load code for the "dill" package.
+# Not supposed to be good code,
+# pylint: disable=invalid-name,missing-module-docstring,protected-access,too-many-branches,too-many-statements
+from types import CodeType
+
+# spell-checker: ignore kwdefaults,globalvars
+# Nuitka will optimize this away, but VS code will warn about them otherwise.
+from typing import TYPE_CHECKING
+
+import dill._dill
+
+if str is bytes:
+    import __builtin__ as builtins  # Python2 code, pylint: disable=import-error
+else:
+    import builtins
+
+if TYPE_CHECKING:
+    compiled_function_tables = {}
+
+
+class ForCompiledTypeLookups:
+    def for_compiled_type(self):
+        pass
+
+
+compiled_function = type(ForCompiledTypeLookups.for_compiled_type)
+compiled_method = type(ForCompiledTypeLookups().for_compiled_type)
+assert "__compiled__" in globals()
+
+dill_version = tuple(int(d) for d in dill.__version__.split("."))
+
+
+# Compiled methods need to be created.
+@dill.register(compiled_method)
+def save_compiled_method(pickler, obj):
+    if str is not bytes:
+        pickler.save_reduce(compiled_method, (obj.__func__, obj.__self__), obj=obj)
+    else:
+        pickler.save_reduce(
+            compiled_method, (obj.im_func, obj.im_self, obj.im_class), obj=obj
+        )
+
+
+if str is bytes:
+
+    def _create_compiled_function2(module_name, func_values, func_dict, func_defaults):
+        if module_name not in compiled_function_tables:
+            __import__(module_name)
+
+        # This gets the "_create_compiled_function" of the module and calls it.
+        func = compiled_function_tables[module_name][1](*func_values)
+        if func_dict:
+            for key, value in func_dict.items():
+                func[key] = value
+
+        func.__defaults__ = func_defaults
+
+        return func
+
+
+if str is not bytes:
+
+    def _create_compiled_function3(
+        module_name, func_values, func_dict, func_defaults, func_kwdefaults
+    ):
+        if module_name not in compiled_function_tables:
+            __import__(module_name)
+
+        func = compiled_function_tables[module_name][1](*func_values)
+        if func_dict:
+            for key, value in func_dict.items():
+                func[key] = value
+
+        func.__defaults__ = func_defaults
+        func.__kwdefaults__ = func_kwdefaults
+
+        return func
+
+
+# Compiled methods might have to be created as well. This is very closely following
+# the code of "dill._dill.save_function" that is intended to do things for the
+# uncompiled function.
+@dill.register(compiled_function)
+def save_compiled_function(pickler, obj):
+    # Complex beast, pylint: disable=too-many-locals
+
+    if dill_version >= (0, 3):
+        if not dill._dill._locate_function(obj, pickler):
+            if type(obj.__code__) is not CodeType:
+                # Some PyPy builtin functions have no module name, and thus are not
+                # able to be located
+                module_name = getattr(obj, "__module__", None)
+                if module_name is None:
+                    module_name = builtins.__name__
+
+                _module = dill._dill._import_module(module_name, safe=True)
+
+            _recurse = getattr(pickler, "_recurse", None)
+            _postproc = getattr(pickler, "_postproc", None)
+            _main_modified = getattr(pickler, "_main_modified", None)
+            _original_main = getattr(pickler, "_original_main", builtins)
+
+            postproc_list = []
+            if _recurse:
+                # recurse to get all globals referred to by obj
+                from dill.detect import globalvars
+
+                globs_copy = globalvars(obj, recurse=True, builtin=True)
+
+                # Add the name of the module to the globs dictionary to prevent
+                # the duplication of the dictionary. Pickle the unpopulated
+                # globals dictionary and set the remaining items after the function
+                # is created to correctly handle recursion.
+                globs = {"__name__": obj.__module__}
+            else:
+                globs_copy = obj.__globals__
+
+                # If the globals is the __dict__ from the module being saved as a
+                # session, substitute it by the dictionary being actually saved.
+                if _main_modified and globs_copy is _original_main.__dict__:
+                    globs_copy = getattr(pickler, "_main", _original_main).__dict__
+                    globs = globs_copy
+                # If the globals is a module __dict__, do not save it in the pickle.
+                elif (
+                    globs_copy is not None
+                    and obj.__module__ is not None
+                    and getattr(
+                        dill._dill._import_module(obj.__module__, True),
+                        "__dict__",
+                        None,
+                    )
+                    is globs_copy
+                ):
+                    globs = globs_copy
+                else:
+                    globs = {"__name__": obj.__module__}
+
+            if globs_copy is not None and globs is not globs_copy:
+                # In the case that the globals are copied, we need to ensure that
+                # the globals dictionary is updated when all objects in the
+                # dictionary are already created.
+                glob_ids = {id(g) for g in globs_copy.values()}
+                for stack_element in _postproc:
+                    if stack_element in glob_ids:
+                        _postproc[stack_element].append(
+                            (dill._dill._setitems, (globs, globs_copy))
+                        )
+                        break
+                else:
+                    postproc_list.append((dill._dill._setitems, (globs, globs_copy)))
+
+            state_dict = {}
+            for fattrname in ("__doc__", "__kwdefaults__", "__annotations__"):
+                fattr = getattr(obj, fattrname, None)
+                if fattr is not None:
+                    state_dict[fattrname] = fattr
+            if obj.__qualname__ != obj.__name__:
+                state_dict["__qualname__"] = obj.__qualname__
+            if "__name__" not in globs or obj.__module__ != globs["__name__"]:
+                state_dict["__module__"] = obj.__module__
+
+            pickler.save_reduce(
+                _create_compiled_function3,
+                (
+                    obj.__module__,
+                    # This gets the "_reduce_compiled_function" of the module and calls it.
+                    compiled_function_tables[obj.__module__][0](obj),
+                    obj.__dict__,
+                    obj.__defaults__,
+                    obj.__kwdefaults__,
+                ),
+            )
+        else:
+            name = getattr(obj, "__qualname__", getattr(obj, "__name__", None))
+            dill._dill.StockPickler.save_global(pickler, obj, name=name)
+    else:
+        if not dill._dill._locate_function(obj):
+            stack = dill._dill.stack
+
+            _byref = getattr(pickler, "_byref", None)
+            _recurse = getattr(pickler, "_recurse", None)
+            _memo = (id(obj) in stack) and (_recurse is not None)
+            stack[id(obj)] = len(stack), obj
+
+            if str is not bytes:
+                # Python3
+                _super = ("super" in getattr(obj.__code__, "co_names", ())) and (
+                    _byref is not None
+                )
+                if _super:
+                    pickler._byref = True
+                if _memo:
+                    pickler._recurse = False
+
+                pickler.save_reduce(
+                    _create_compiled_function3,
+                    (
+                        obj.__module__,
+                        compiled_function_tables[obj.__module__][0](obj),
+                        obj.__dict__,
+                        obj.__defaults__,
+                        obj.__kwdefaults__,
+                    ),
+                )
+            else:
+                # Python2
+                _super = (
+                    ("super" in getattr(obj.__code__, "co_names", ()))
+                    and (_byref is not None)
+                    and getattr(pickler, "_recurse", False)
+                )
+                if _super:
+                    pickler._byref = True
+                if _memo:
+                    pickler._recurse = False
+
+                pickler.save_reduce(
+                    _create_compiled_function2,
+                    (
+                        obj.__module__,
+                        compiled_function_tables[obj.__module__][0](obj),
+                        obj.__dict__,
+                        obj.__defaults__,
+                    ),
+                )
+
+            if _super:
+                pickler._byref = _byref
+            if _memo:
+                pickler._recurse = _recurse
+        else:
+            dill._dill.StockPickler.save_global(pickler, obj)

nuitka/plugins/standard/DillPlugin.py

@@ -19,6 +19,7 @@
 
 """
 
+from nuitka.Options import shallMakeModule
 from nuitka.plugins.PluginBase import NuitkaPluginBase
 
 
@@ -36,7 +37,15 @@ class NuitkaPluginDillWorkarounds(NuitkaPluginBase):
     def createPostModuleLoadCode(self, module):
         full_name = module.getFullName()
 
-        if full_name == "dill":
+        if full_name == "dill" and not shallMakeModule():
+            return (
+                self.getPluginDataFileContents("dill-postLoad.py"),
+                """\
+Extending "dill" for compiled types to be pickle-able as well.""",
+            )
+
+    def createPreModuleLoadCode(self, module):
+        if shallMakeModule() and module.isTopModule():
             return (
                 self.getPluginDataFileContents("dill-postLoad.py"),
                 """\
@@ -48,25 +57,4 @@ Extending "dill" for compiled types to be pickle-able as well.""",
         return {"_NUITKA_PLUGIN_DILL_ENABLED": "1"}
 
     def getExtraCodeFiles(self):
-        return {"DillPlugin.c": extra_code}
-
-
-extra_code = r"""
-#include "nuitka/prelude.h"
-
-void registerDillPluginTables(PyThreadState *tstate, char const *module_name, PyMethodDef *reduce_compiled_function, PyMethodDef *create_compiled_function) {
-    PyObject *function_tables = PyObject_GetAttrString((PyObject *)builtin_module, "compiled_function_tables");
-
-    if (function_tables == NULL) {
-        CLEAR_ERROR_OCCURRED(tstate);
-
-        function_tables = MAKE_DICT_EMPTY();
-        PyObject_SetAttrString((PyObject *)builtin_module, "compiled_function_tables", function_tables);
-    }
-
-    PyObject *funcs = MAKE_TUPLE2_0(PyCFunction_New(reduce_compiled_function, NULL), PyCFunction_New(create_compiled_function, NULL));
-
-    PyDict_SetItemString(function_tables, module_name, funcs);
-}
-
-"""
+        return {"DillPlugin.c": self.getPluginDataFileContents("DillPlugin.c")}

nuitka/plugins/standard/ImplicitImports.py

@@ -597,6 +597,7 @@ __file__ = (__nuitka_binary_dir + '%ssite.py') if '__nuitka_binary_dir' in dict(
         "transformers.utils.dummy_pt_objects",  # Not performance relevant.
         "transformers.utils.dummy_flax_objects",  # Not performance relevant.
         "transformers.utils.dummy_tf_objects",  # Not performance relevant.
+        "rich",  #  # Not performance relevant and memory leaking due to empty compiled cell leaks
     )
 
     def decideCompilation(self, module_name):

nuitka/plugins/standard/OptionsNannyPlugin.py

@@ -103,7 +103,7 @@ Otherwise a terminal window will open"""
 
                 self.info(
                     """\
-Note, when using '%s', consider using '--disable-console' option. %s. However\
+Note, when using '%s', consider using '--disable-console' option. %s. However \
 for debugging, terminal output is the easiest way to see informative traceback \
 and error information, so delay this until your program working and remove \
 once you find it non-working, and use '--enable-console' to make it explicit \

nuitka/plugins/standard/standard.nuitka-package.config.yml

@@ -640,6 +640,10 @@
         'comtypes': 'ignore'
 
 - module-name: 'curl_cffi'
+  data-files:
+    patterns:
+      - 'cacert.pem'
+
   implicit-imports:
     - depends:
         - '_cffi_backend'
@@ -1622,6 +1626,12 @@
     patterns:
       - 'intervals.msgpack'
 
+- module-name: 'libusb_package'
+  dlls:
+    - from_filenames:
+        prefixes:
+          - 'libusb'
+
 - module-name: 'lightgbm.libpath'
   dlls:
     - from_filenames:
@@ -2863,6 +2873,14 @@
     - description: 'workaround __new__ decorator issue'
       append_plain: 'SharedRegistryObject.__new__ = staticmethod(SharedRegistryObject.__new__)'
 
+- module-name: 'pip._vendor.rich.jupyter'
+  # See rich.jupyter
+  anti-bloat:
+    - description: 'remove IPython reference'
+      change_function:
+        'display': 'un-callable'
+      when: 'not use_ipython'
+
 - module-name: 'pkg_resources'
   anti-bloat:
     - description: 'avoid using plistlib dependency on non-macOS'
@@ -3217,6 +3235,10 @@
         macos_bundle_as_onefile: 'yes'
         when: 'macos and use_pyqt5'
 
+  import-hacks:
+    - acceptable-missing-dlls:
+        - 'libqpdf'
+
 - module-name: 'PyQt6'
   options:
     checks:
@@ -3411,7 +3433,19 @@
           from PySide6 import QtCore
           orig_disconnect = QtCore.SignalInstance.disconnect
           QtCore.SignalInstance.disconnect = patched_disconnect
-      when: 'version("PySide6") < (6,6)'
+
+          def patched_connect(self, receiver, type=None):
+              type = type or QtCore.Qt.ConnectionType.AutoConnection
+              if hasattr(receiver, "im_func"):
+                  if hasattr(receiver.im_func, "__compiled__"):
+                      patched_connect._protected = getattr(patched_connect, "_protected", [])
+                      patched_connect._protected.append(receiver)
+
+              return orig_connect(self, receiver, type)
+
+          from PySide6 import QtCore
+          orig_connect = QtCore.SignalInstance.connect
+          QtCore.SignalInstance.connect = patched_connect
 
   options:
     checks:
@@ -4941,15 +4975,11 @@
     dirs:
       - 'static'
 
-- module-name: 'streamlit.delta_generator'
+- module-name: 'streamlit.runtime.caching.cache_utils'
   anti-bloat:
-    - description: 'remove IPython reference'
+    - description: 'remove warning for compiled functions'
       replacements_plain:
-        'from streamlit.elements.legacy_altair import LegacyAltairMixin': ''
-        'LegacyAltairMixin,': ''
-        'from streamlit.elements.arrow_altair import ArrowAltairMixin': ''
-        'ArrowAltairMixin,': ''
-      when: 'not use_ipython'
+        '_LOGGER.debug(': '('
 
 - module-name: 'sv_ttk'
   data-files:
@@ -5508,6 +5538,13 @@
     - depends:
         - '._*'
 
+- module-name: 'tf_keras.src.utils.vis_utils'
+  anti-bloat:
+    - description: 'remove IPython reference'
+      no-auto-follow:
+        'IPython': 'ignore'
+      when: 'not use_ipython'
+
 - module-name: 'thinc.backends.cblas'
   implicit-imports:
     - depends:

nuitka/reports/Reports.py

@@ -44,8 +44,10 @@ from nuitka.Options import (
     getCompilationReportFilename,
     getCompilationReportTemplates,
     getCompilationReportUserData,
+    isOnefileMode,
     shallCreateDiffableCompilationReport,
 )
+from nuitka.OutputDirectories import getResultRunFilename
 from nuitka.plugins.Plugins import getActivePlugins
 from nuitka.PythonFlavors import getPythonFlavorName
 from nuitka.PythonVersions import getSystemPrefixPath, python_version_full_str
@@ -194,6 +196,8 @@ def _getReportInputData(aborted):
 
     data_composer = getDataComposerReportValues()
 
+    output_run_filename = os.path.abspath(getResultRunFilename(onefile=isOnefileMode()))
+
     return dict(
         (var_name, var_value)
         for var_name, var_value in locals().items()
@@ -569,6 +573,14 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
 
     _addUserDataToReport(root=root, user_data=report_input_data["user_data"])
 
+    python_xml_node = TreeXML.appendTreeElement(
+        root,
+        "output",
+        run_filename=_getCompilationReportPath(
+            report_input_data["output_run_filename"]
+        ),
+    )
+
     try:
         putTextFileContents(
             filename=report_filename, contents=TreeXML.toString(root), encoding="utf8"