Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/reports/Reports.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Collection of information for reports and their writing.
 
 These reports are in XML form, and with Jinja2 templates in any form you like.
@@ -29,10 +15,13 @@ import traceback
 from nuitka import TreeXML
 from nuitka.__past__ import unicode
 from nuitka.build.DataComposerInterface import getDataComposerReportValues
+from nuitka.build.SconsUtils import readSconsErrorReport
+from nuitka.code_generation.ConstantCodes import getDistributionMetadataValues
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.freezer.IncludedDataFiles import getIncludedDataFiles
 from nuitka.freezer.IncludedEntryPoints import getStandaloneEntryPoints
 from nuitka.importing.Importing import getPackageSearchPath
+from nuitka.importing.Recursion import getRecursionDecisions
 from nuitka.ModuleRegistry import (
     getDoneModules,
     getModuleInclusionInfoByName,
@@ -43,17 +32,46 @@ from nuitka.Options import (
     getCompilationReportFilename,
     getCompilationReportTemplates,
     getCompilationReportUserData,
+    isOnefileMode,
     shallCreateDiffableCompilationReport,
 )
+from nuitka.OutputDirectories import (
+    getResultRunFilename,
+    getSourceDirectoryPath,
+    hasMainModule,
+)
 from nuitka.plugins.Plugins import getActivePlugins
 from nuitka.PythonFlavors import getPythonFlavorName
-from nuitka.PythonVersions import getSystemPrefixPath, python_version_full_str
+from nuitka.PythonVersions import (
+    getLaunchingSystemPrefixPath,
+    getSystemPrefixPath,
+    python_version_full_str,
+)
 from nuitka.Tracing import ReportingSystemExit, reports_logger
-from nuitka.utils.Distributions import getDistributionsFromModuleName
-from nuitka.utils.FileOperations import getReportPath, putTextFileContents
+from nuitka.utils.Distributions import (
+    getDistributionInstallerName,
+    getDistributionLicense,
+    getDistributionName,
+    getDistributionsFromModuleName,
+    getDistributionVersion,
+)
+from nuitka.utils.FileOperations import (
+    getReportPath,
+    putBinaryFileContents,
+    putTextFileContents,
+)
 from nuitka.utils.Jinja2 import getTemplate
 from nuitka.utils.MemoryUsage import getMemoryInfos
-from nuitka.utils.Utils import getArchitecture, getOS
+from nuitka.utils.Utils import (
+    getArchitecture,
+    getLinuxDistribution,
+    getMacOSRelease,
+    getOS,
+    getWindowsRelease,
+    isLinux,
+    isMacOS,
+    isWin32OrPosixWindows,
+)
 from nuitka.Version import getCommercialVersion, getNuitkaVersion
 
 
@@ -61,7 +79,8 @@ def _getReportInputData(aborted):
     """Collect all information for reporting into a dictionary."""
 
     # used with locals for laziness and these are to populate a dictionary with
-    # many entries, pylint: disable=possibly-unused-variable,too-many-locals
+    # many entries,
+    # pylint: disable=possibly-unused-variable,too-many-branches,too-many-locals,too-many-statements
 
     module_names = tuple(module.getFullName() for module in getDoneModules())
 
@@ -88,8 +107,14 @@ def _getReportInputData(aborted):
         for module in getDoneModules()
     )
 
+    module_usages = dict(
+        (module.getFullName(), tuple(module.getUsedModules()))
+        for module in getDoneModules()
+    )
+
     module_distributions = {}
     distribution_modules = {}
+
     for module in getDoneModules():
         module_distributions[module.getFullName()] = getDistributionsFromModuleName(
             module.getFullName()
@@ -100,9 +125,19 @@ def _getReportInputData(aborted):
 
             distribution_modules[_distribution].add(module.getFullName())
 
-    module_usages = dict(
-        (module.getFullName(), module.getUsedModules()) for module in getDoneModules()
-    )
+    module_distribution_usages = {}
+    for module in getDoneModules():
+        module_distribution_usages[module.getFullName()] = OrderedSet()
+
+        for _module_usage in module_usages[module.getFullName()]:
+            if _module_usage.module_name not in module_usages:
+                continue
+
+            module_distribution_usages[module.getFullName()].update(
+                dist
+                for dist in module_distributions[_module_usage.module_name]
+                if dist not in module_distributions[module.getFullName()]
+            )
 
     module_distribution_names = dict(
         (module.getFullName(), module.getUsedDistributions())
@@ -112,10 +147,55 @@ def _getReportInputData(aborted):
     all_distributions = tuple(
         sorted(
             set(sum(module_distributions.values(), ())),
-            key=lambda dist: dist.metadata["Name"],
+            key=getDistributionName,
         )
     )
 
+    module_distribution_installers = dict(
+        (
+            getDistributionName(dist),
+            getDistributionInstallerName(getDistributionName(dist)),
+        )
+        for dist in all_distributions
+    )
+
+    module_exclusions = dict((module.getFullName(), {}) for module in getDoneModules())
+
+    # TODO: The module filename, and other things can be None. Once we change to
+    # namedtuples, we need to adapt the type check.
+    def _replaceNoneWithString(value):
+        if type(value) is tuple:
+            return tuple(_replaceNoneWithString(element) for element in value)
+
+        return value if value is not None else ""
+
+    for (
+        _using_module_name,
+        _module_filename,
+        _module_name,
+        _module_kind,
+        _extra_recursion,
+    ), (_decision, _reason) in sorted(
+        getRecursionDecisions().items(), key=_replaceNoneWithString
+    ):
+        if _decision is not False:
+            continue
+
+        if _using_module_name is None:
+            continue
+
+        # We might be interrupted, and have this information, but never actually
+        # finished the module.
+        if _using_module_name not in module_exclusions:
+            continue
+
+        module_exclusions[_using_module_name][_module_name] = _reason
+
+    included_metadata = dict(
+        (distribution_name, meta_data_value.reasons)
+        for distribution_name, meta_data_value in getDistributionMetadataValues()
+    )
+
     memory_infos = getMemoryInfos()
 
     python_exe = sys.executable
@@ -125,6 +205,18 @@ def _getReportInputData(aborted):
     os_name = getOS()
     arch_name = getArchitecture()
 
+    # Record system encoding, spell-checker: ignore getfilesystemencoding
+    filesystem_encoding = sys.getfilesystemencoding()
+
+    if isWin32OrPosixWindows():
+        os_release = str(getWindowsRelease())
+    elif isLinux():
+        os_release = "-".join(x for x in getLinuxDistribution() if x)
+    elif isMacOS():
+        os_release = getMacOSRelease()
+    else:
+        os_release = "unknown"
+
     nuitka_version = getNuitkaVersion()
     nuitka_commercial_version = getCommercialVersion() or "not installed"
 
@@ -136,6 +228,17 @@ def _getReportInputData(aborted):
 
     data_composer = getDataComposerReportValues()
 
+    if hasMainModule():
+        output_run_filename = os.path.abspath(
+            getResultRunFilename(onefile=isOnefileMode())
+        )
+        scons_error_report_data = readSconsErrorReport(
+            source_dir=getSourceDirectoryPath()
+        )
+    else:
+        scons_error_report_data = {}
+        output_run_filename = "failed too early"
+
     return dict(
         (var_name, var_value)
         for var_name, var_value in locals().items()
@@ -154,7 +257,7 @@ def _getReportPathPrefixes():
     if _report_prefixes is None:
         _report_prefixes = []
 
-        sys_prefix = os.environ.get("NUITKA_SYS_PREFIX", sys.prefix)
+        sys_prefix = getLaunchingSystemPrefixPath() or sys.prefix
         real_sys_prefix = getSystemPrefixPath()
 
         if real_sys_prefix != sys_prefix:
@@ -171,7 +274,8 @@ def _getCompilationReportPath(path):
 
 
 def _addModulesToReport(root, report_input_data, diffable):
-    # Many details to work with, pylint: disable=too-many-locals
+    # Many details to work with,
+    # pylint: disable=too-many-branches,too-many-locals,too-many-statements
 
     for module_name in report_input_data["module_names"]:
         active_module_info = report_input_data["module_inclusion_infos"][module_name]
@@ -188,6 +292,13 @@ def _addModulesToReport(root, report_input_data, diffable):
             ),
         )
 
+        distributions = report_input_data["module_distributions"][module_name]
+
+        if distributions:
+            module_xml_node.attrib["distribution"] = ",".join(
+                getDistributionName(dist) for dist in distributions
+            )
+
         for plugin_name, influence, detail in report_input_data[
             "module_plugin_influences"
         ][module_name]:
@@ -199,8 +310,34 @@ def _addModulesToReport(root, report_input_data, diffable):
                 condition, condition_tags_used, condition_result = detail
 
                 influence_xml_node.attrib["condition"] = condition
-                influence_xml_node.attrib["tags_used"] = ",".join(condition_tags_used)
+                if condition_tags_used:
+                    influence_xml_node.attrib["tags_used"] = ",".join(
+                        condition_tags_used
+                    )
                 influence_xml_node.attrib["result"] = str(condition_result).lower()
+            elif influence == "variable-used":
+                variable_name, condition_tags_used, variable_value = detail
+
+                influence_xml_node.attrib["variable"] = variable_name
+                if condition_tags_used:
+                    influence_xml_node.attrib["tags_used"] = ",".join(
+                        condition_tags_used
+                    )
+                influence_xml_node.attrib["value"] = variable_value
+            elif influence == "parameter-used":
+                parameter_name, condition_tags_used, parameter_value = detail
+
+                influence_xml_node.attrib["parameter"] = parameter_name
+                if condition_tags_used:
+                    influence_xml_node.attrib["tags_used"] = ",".join(
+                        condition_tags_used
+                    )
+                influence_xml_node.attrib["value"] = repr(parameter_value)
+            elif influence == "detection":
+                detection_name, detection_value = detail
+
+                influence_xml_node.attrib["detection"] = detection_name
+                influence_xml_node.attrib["value"] = repr(detection_value)
             else:
                 assert False, influence
 
@@ -217,21 +354,35 @@ def _addModulesToReport(root, report_input_data, diffable):
                 "volatile" if diffable else "%.2f" % timing_info.time_used
             )
 
+            if timing_info.micro_passes:
+                timing_xml_node.attrib["micro_passes"] = str(timing_info.micro_passes)
+
+            if timing_info.merge_counts:
+                merged_total = 0
+
+                for branch_count, merge_count in timing_info.merge_counts.items():
+                    merged_total += branch_count * merge_count
+
+                max_merge_size = max(timing_info.merge_counts)
+
+                timing_xml_node.attrib["max_branch_merge"] = str(max_merge_size)
+                timing_xml_node.attrib["merged_total"] = str(merged_total)
+
             module_xml_node.append(timing_xml_node)
 
-        distributions = report_input_data["module_distributions"][module_name]
+        distributions = report_input_data["module_distribution_usages"][module_name]
 
         if distributions:
             distributions_xml_node = TreeXML.appendTreeElement(
                 module_xml_node,
-                "distributions",
+                "distribution-usages",
             )
 
             for distribution in distributions:
                 TreeXML.appendTreeElement(
                     distributions_xml_node,
-                    "distribution-used",
-                    name=distribution.metadata["Name"],
+                    "distribution-usage",
+                    name=getDistributionName(distribution),
                 )
 
         module_distribution_names = report_input_data["module_distribution_names"][
@@ -247,7 +398,7 @@ def _addModulesToReport(root, report_input_data, diffable):
             for distribution_name, found in module_distribution_names.items():
                 TreeXML.appendTreeElement(
                     module_distribution_names_xml_node,
-                    "distribution",
+                    "distribution-lookup",
                     name=distribution_name,
                     found="yes" if found else "no",
                 )
@@ -257,15 +408,48 @@ def _addModulesToReport(root, report_input_data, diffable):
             "module_usages",
         )
 
-        for used_module in report_input_data["module_usages"][module_name]:
-            TreeXML.appendTreeElement(
+        for count, used_module in enumerate(
+            report_input_data["module_usages"][module_name]
+        ):
+            # We don't want to see those parent imports, unless they have
+            # an effect.
+            if used_module.reason == "import path parent":
+                while True:
+                    count += 1
+                    next_used_module = report_input_data["module_usages"][module_name][
+                        count
+                    ]
+
+                    if next_used_module.reason != "import path parent":
+                        break
+
+                exclusion_reason = report_input_data["module_exclusions"][
+                    module_name
+                ].get(next_used_module.module_name)
+
+                if exclusion_reason is None or next_used_module.finding != "not-found":
+                    continue
+
+            module_usage_node = TreeXML.appendTreeElement(
                 used_modules_xml_node,
                 "module_usage",
                 name=used_module.module_name.asString(),
                 finding=used_module.finding,
                 line=str(used_module.source_ref.getLineNumber()),
+                # TODO: Add reason in a hotfix.
+                # reason=used_module.reason,
+            )
+
+            exclusion_reason = report_input_data["module_exclusions"][module_name].get(
+                used_module.module_name
             )
 
+            # Include reason why a module was excluded unless it is obvious like
+            # with built-in modules.
+            if exclusion_reason is not None and used_module.module_kind != "built-in":
+                module_usage_node.attrib["finding"] = "excluded"
+                module_usage_node.attrib["exclusion_reason"] = exclusion_reason
+
 
 def _addMemoryInfosToReport(performance_xml_node, memory_infos, diffable):
     for key, value in memory_infos.items():
@@ -340,6 +524,45 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
 
         exception_xml_node.text = "\n" + traceback.format_exc()
 
+    if report_input_data["scons_error_report_data"]:
+        scons_error_reports_node = TreeXML.appendTreeElement(
+            root, "scons_error_reports"
+        )
+
+        for cmd, (stdout, stderr) in report_input_data[
+            "scons_error_report_data"
+        ].items():
+            scons_error_report_node = TreeXML.appendTreeElement(
+                scons_error_reports_node, "scons_error_report"
+            )
+
+            TreeXML.appendTreeElement(
+                scons_error_report_node,
+                "command",
+            ).text = cmd
+
+            if stdout:
+                if not stdout.startswith("\n"):
+                    stdout = "\n" + stdout
+
+                stdout = stdout.rstrip("\n") + "\n"
+
+                TreeXML.appendTreeElement(
+                    scons_error_report_node,
+                    "stdout",
+                ).text = stdout
+
+            if stderr:
+                if not stderr.startswith("\n"):
+                    stderr = "\n" + stderr
+
+                stderr = stderr.rstrip("\n") + "\n"
+
+                TreeXML.appendTreeElement(
+                    scons_error_report_node,
+                    "stderr",
+                ).text = stderr
+
     _addModulesToReport(
         root=root, report_input_data=report_input_data, diffable=diffable
     )
@@ -377,6 +600,22 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
                 tags=",".join(included_datafile.tags),
             )
 
+    if report_input_data["included_metadata"]:
+        metadata_node = TreeXML.appendTreeElement(
+            root,
+            "metadata",
+        )
+
+        for distribution_name, reasons in sorted(
+            report_input_data["included_metadata"].items()
+        ):
+            TreeXML.appendTreeElement(
+                metadata_node,
+                "included_metadata",
+                name=distribution_name,
+                reason=". ".join(reasons),
+            )
+
     for standalone_entry_point in getStandaloneEntryPoints():
         if standalone_entry_point.kind == "executable":
             continue
@@ -397,7 +636,7 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
             source_path=_getCompilationReportPath(standalone_entry_point.source_path),
             package=standalone_entry_point.package_name or "",
             ignored="yes" if ignored else "no",
-            reason=standalone_entry_point.reason
+            reason=standalone_entry_point.reason,
             # TODO: No reason yet.
         )
 
@@ -460,8 +699,11 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
         TreeXML.appendTreeElement(
             distributions_xml_node,
             "distribution",
-            name=distribution.metadata["Name"],
-            version=distribution.metadata["Version"],
+            name=getDistributionName(distribution),
+            version=getDistributionVersion(distribution),
+            installer=report_input_data["module_distribution_installers"][
+                getDistributionName(distribution)
+            ],
         )
 
     python_xml_node = TreeXML.appendTreeElement(
@@ -471,25 +713,43 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
         python_flavor=report_input_data["python_flavor"],
         python_version=report_input_data["python_version"],
         os_name=report_input_data["os_name"],
+        os_release=report_input_data["os_release"],
         arch_name=report_input_data["arch_name"],
+        filesystem_encoding=report_input_data["filesystem_encoding"],
     )
 
-    search_path_xml_node = TreeXML.appendTreeElement(
-        python_xml_node,
-        "search_path",
-    )
+    search_path = getPackageSearchPath(None)
 
-    for search_path in getPackageSearchPath(None):
-        TreeXML.appendTreeElement(
-            search_path_xml_node,
-            "path",
-            value=_getCompilationReportPath(search_path),
+    if search_path is not None:
+        search_path_xml_node = TreeXML.appendTreeElement(
+            python_xml_node,
+            "search_path",
         )
 
+        for search_path in getPackageSearchPath(None):
+            TreeXML.appendTreeElement(
+                search_path_xml_node,
+                "path",
+                value=_getCompilationReportPath(search_path),
+            )
+
     _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"]
+        ),
+    )
+
+    contents = TreeXML.toString(root)
+
+    if type(contents) is not bytes:
+        contents = contents.encode("utf8")
+
     try:
-        putTextFileContents(filename=report_filename, contents=TreeXML.toString(root))
+        putBinaryFileContents(filename=report_filename, contents=contents)
     except OSError as e:
         reports_logger.warning(
             "Compilation report write to file '%s' failed due to: %s."
@@ -499,9 +759,10 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
         if _crash_report_filename == report_filename:
             _crash_report_filename = None
     else:
-        reports_logger.info(
-            "Compilation report written to file '%s'." % report_filename
-        )
+        if _crash_report_filename != report_filename:
+            reports_logger.info(
+                "Compilation report written to file '%s'." % report_filename
+            )
 
 
 def writeCompilationReportFromTemplate(
@@ -514,25 +775,6 @@ def writeCompilationReportFromTemplate(
         extensions=("jinja2.ext.do",),
     )
 
-    def get_distribution_license(distribution):
-        license_name = distribution.metadata["License"]
-
-        if license_name == "UNKNOWN":
-            for classifier in (
-                value
-                for (key, value) in distribution.metadata.items()
-                if "Classifier" in key
-            ):
-                parts = [part.strip() for part in classifier.split("::")]
-                if not parts:
-                    continue
-
-                if parts[0] == "License":
-                    license_name = parts[-1]
-                    break
-
-        return license_name
-
     def quoted(value):
         if isinstance(value, str):
             return "'%s'" % value
@@ -541,7 +783,11 @@ def writeCompilationReportFromTemplate(
 
     report_text = template.render(
         # Get the license text.
-        get_distribution_license=get_distribution_license,
+        get_distribution_license=getDistributionLicense,
+        # get the distribution_name
+        get_distribution_name=getDistributionName,
+        # get the distribution version
+        get_distribution_version=getDistributionVersion,
         # Quote a list of strings.
         quoted=quoted,
         # For checking length of lists.
@@ -563,15 +809,20 @@ def writeCompilationReportFromTemplate(
 
 
 _crash_report_filename = "nuitka-crash-report.xml"
+_crash_report_bug_message = True
 
 
 def _informAboutCrashReport():
     if _crash_report_filename is not None:
+        message = (
+            "Compilation crash report written to file '%s'." % _crash_report_filename
+        )
+
+        if _crash_report_bug_message:
+            message += " Please include it in your bug report."
+
         reports_logger.info(
-            """\
-Compilation crash report written to file '%s'. Please include it in \
-your bug report."""
-            % _crash_report_filename,
+            message,
             style="red",
         )
 
@@ -588,6 +839,15 @@ def writeCompilationReports(aborted):
     ):
         report_filename = _crash_report_filename
 
+        # Inform user about bug reporting of a bug only, if this is not some sort
+        # of reporting exit, these do not constitute definitive bugs of Nuitka but
+        # are often usage errors only.
+
+        # Using global here, as this is really a singleton
+        # pylint: disable=global-statement
+        global _crash_report_bug_message
+        _crash_report_bug_message = sys.exc_info()[0] is not ReportingSystemExit
+
         atexit.register(_informAboutCrashReport)
 
     if report_filename or template_specs:
@@ -625,3 +885,19 @@ def writeCompilationReports(aborted):
                 report_filename=report_filename,
                 report_input_data=report_input_data,
             )
+
+
+#     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.

nuitka/reports/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """