Nuitka-winsvc 2.5.6__cp311-cp311-win_amd64.whl → 2.6.5__cp311-cp311-win_amd64.whl

{Nuitka_winsvc-2.5.6.dist-info → Nuitka_winsvc-2.6.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64
 

nuitka/Builtins.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Built-ins module. Information about built-ins of the running Python.

nuitka/BytecodeCaching.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Caching of compiled code.
@@ -12,6 +12,7 @@ import sys
 
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.importing.Importing import locateModule, makeModuleUsageAttempt
+from nuitka.ModuleRegistry import getModuleOptimizationTimingInfos
 from nuitka.plugins.Plugins import Plugins
 from nuitka.utils.AppDirs import getCacheDir
 from nuitka.utils.FileOperations import makePath
@@ -50,7 +51,7 @@ def hasCachedImportedModuleUsageAttempts(module_name, source_code, source_ref):
 
 
 # Bump this is format is changed or enhanced implementation might different ones.
-_cache_format_version = 6
+_cache_format_version = 7
 
 
 def getCachedImportedModuleUsageAttempts(module_name, source_code, source_ref):
@@ -118,11 +119,20 @@ def getCachedImportedModuleUsageAttempts(module_name, source_code, source_ref):
         # something changed there.
         pass
 
-    return result
+    # The Json doesn't store integer keys.
+    for pass_timing_info in data["timing_infos"]:
+        pass_timing_info[3] = dict(
+            (int(key), value) for (key, value) in pass_timing_info[3].items()
+        )
+
+    return result, data["timing_infos"]
 
 
 def writeImportedModulesNamesToCache(
-    module_name, source_code, used_modules, distribution_names
+    module_name,
+    source_code,
+    used_modules,
+    distribution_names,
 ):
     cache_name = makeCacheName(module_name, source_code)
     cache_filename = _getCacheFilename(cache_name, "json")
@@ -138,6 +148,7 @@ def writeImportedModulesNamesToCache(
         # We use a tuple, so preserve the order.
         "modules_used": used_modules,
         "distribution_names": distribution_names,
+        "timing_infos": getModuleOptimizationTimingInfos(module_name),
     }
 
     makePath(os.path.dirname(cache_filename))

nuitka/Bytecodes.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Handle bytecode and compile source code to bytecode. """

nuitka/CacheCleanup.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Cleanup of caches for Nuitka.

nuitka/Constants.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Module for constants in Nuitka.

nuitka/Errors.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ For enhanced bug reporting, these exceptions should be used.

nuitka/HardImportRegistry.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ Registry for hard import data.

nuitka/MainControl.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ This is the main actions of Nuitka.
@@ -35,7 +35,13 @@ from nuitka.freezer.IncludedEntryPoints import (
     getStandaloneEntryPoints,
     setMainEntryPoint,
 )
-from nuitka.importing import Importing, Recursion
+from nuitka.importing.Importing import locateModule, setupImportingFromOptions
+from nuitka.importing.Recursion import (
+    scanIncludedPackage,
+    scanPluginFilenamePattern,
+    scanPluginPath,
+    scanPluginSinglePath,
+)
 from nuitka.Options import (
     getPythonPgoInput,
     hasPythonFlagIsolated,
@@ -55,6 +61,7 @@ from nuitka.Progress import (
     setupProgressBar,
 )
 from nuitka.PythonFlavors import (
+    getPythonFlavorName,
     isApplePython,
     isArchPackagePython,
     isDebianPackagePython,
@@ -84,6 +91,7 @@ from nuitka.utils.FileOperations import (
     changeFilenameExtension,
     deleteFile,
     getExternalUsePath,
+    getReportPath,
     openTextFile,
     removeDirectory,
     resetDirectory,
@@ -103,8 +111,9 @@ from . import ModuleRegistry, Options, OutputDirectories
 from .build.SconsInterface import (
     asBoolStr,
     cleanSconsDirectory,
+    getCommonSconsOptions,
     runScons,
-    setCommonSconsOptions,
+    setPythonTargetOptions,
 )
 from .code_generation import CodeGeneration, LoaderCodes, Reports
 from .finalizations import Finalization
@@ -205,31 +214,20 @@ def _createMainModule():
 
     # Second, do it for the directories given.
     for plugin_filename in Options.getShallFollowExtra():
-        Recursion.checkPluginPath(plugin_filename=plugin_filename, module_package=None)
+        scanPluginPath(plugin_filename=plugin_filename, module_package=None)
 
     for pattern in Options.getShallFollowExtraFilePatterns():
-        Recursion.checkPluginFilenamePattern(pattern=pattern)
+        scanPluginFilenamePattern(pattern=pattern)
 
-    for package_name in Options.getMustIncludePackages():
-        package_name, package_directory, _module_kind, finding = Importing.locateModule(
-            module_name=ModuleName(package_name),
-            parent_package=None,
-            level=0,
-        )
+    # For packages, include the full suite.
+    if Options.shallMakePackage():
+        scanIncludedPackage(main_module.getFullName())
 
-        if finding != "absolute":
-            inclusion_logger.sysexit(
-                "Error, failed to locate package '%s' you asked to include."
-                % package_name
-            )
-
-        Recursion.checkPluginPath(
-            plugin_filename=package_directory,
-            module_package=package_name.getPackageName(),
-        )
+    for package_name in Options.getMustIncludePackages():
+        scanIncludedPackage(package_name)
 
     for module_name in Options.getMustIncludeModules():
-        module_name, module_filename, _module_kind, finding = Importing.locateModule(
+        module_name, module_filename, _module_kind, finding = locateModule(
             module_name=ModuleName(module_name),
             parent_package=None,
             level=0,
@@ -241,7 +239,7 @@ def _createMainModule():
                 % module_name.asString()
             )
 
-        Recursion.checkPluginSinglePath(
+        scanPluginSinglePath(
             plugin_filename=module_filename,
             module_package=module_name.getPackageName(),
             package_only=True,
@@ -585,166 +583,164 @@ def runSconsBackend():
     # 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 = {
-        "source_dir": OutputDirectories.getSourceDirectoryPath(),
-        "nuitka_python": asBoolStr(isNuitkaPython()),
-        "debug_mode": asBoolStr(Options.is_debug),
-        "debugger_mode": asBoolStr(Options.shallRunInDebugger()),
-        "python_debug": asBoolStr(Options.shallUsePythonDebug()),
-        "module_mode": asBoolStr(Options.shallMakeModule()),
-        "full_compat": asBoolStr(Options.is_full_compat),
-        "experimental": ",".join(Options.getExperimentalIndications()),
-        "trace_mode": asBoolStr(Options.shallTraceExecution()),
-        "file_reference_mode": Options.getFileReferenceMode(),
-        "module_count": "%d" % len(ModuleRegistry.getDoneModules()),
-        "gil_mode": asBoolStr(Options.isPythonWithGil()),
-    }
+    scons_options, env_values = getCommonSconsOptions()
+
+    setPythonTargetOptions(scons_options)
+
+    scons_options["source_dir"] = OutputDirectories.getSourceDirectoryPath()
+    scons_options["nuitka_python"] = asBoolStr(isNuitkaPython())
+    scons_options["debug_mode"] = asBoolStr(Options.is_debug)
+    scons_options["debugger_mode"] = asBoolStr(Options.shallRunInDebugger())
+    scons_options["python_debug"] = asBoolStr(Options.shallUsePythonDebug())
+    scons_options["module_mode"] = asBoolStr(Options.shallMakeModule())
+    scons_options["full_compat"] = asBoolStr(Options.is_full_compat)
+    scons_options["experimental"] = ",".join(Options.getExperimentalIndications())
+    scons_options["trace_mode"] = asBoolStr(Options.shallTraceExecution())
+    scons_options["file_reference_mode"] = Options.getFileReferenceMode()
+    scons_options["module_count"] = "%d" % len(ModuleRegistry.getDoneModules())
 
     if Options.isLowMemory():
-        options["low_memory"] = asBoolStr(True)
+        scons_options["low_memory"] = asBoolStr(True)
 
     if not Options.shallMakeModule():
-        options["result_exe"] = OutputDirectories.getResultFullpath(onefile=False)
+        scons_options["result_exe"] = OutputDirectories.getResultFullpath(onefile=False)
 
         main_module = ModuleRegistry.getRootTopModule()
         assert main_module.isMainModule()
 
         main_module_name = main_module.getFullName()
         if main_module_name != "__main__":
-            options["main_module_name"] = main_module_name
+            scons_options["main_module_name"] = main_module_name
 
     if Options.shallUseStaticLibPython():
-        options["static_libpython"] = getSystemStaticLibPythonPath()
+        scons_options["static_libpython"] = getSystemStaticLibPythonPath()
 
     if isDebianPackagePython():
-        options["debian_python"] = asBoolStr(True)
+        scons_options["debian_python"] = asBoolStr(True)
     if isFedoraPackagePython():
-        options["fedora_python"] = asBoolStr(True)
+        scons_options["fedora_python"] = asBoolStr(True)
     if isArchPackagePython():
-        options["arch_python"] = asBoolStr(True)
+        scons_options["arch_python"] = asBoolStr(True)
     if isApplePython():
-        options["apple_python"] = asBoolStr(True)
+        scons_options["apple_python"] = asBoolStr(True)
     if isPyenvPython():
-        options["pyenv_python"] = asBoolStr(True)
+        scons_options["pyenv_python"] = asBoolStr(True)
 
     if Options.isStandaloneMode():
-        options["standalone_mode"] = asBoolStr(True)
+        scons_options["standalone_mode"] = asBoolStr(True)
 
     if Options.isOnefileMode():
-        options["onefile_mode"] = asBoolStr(True)
+        scons_options["onefile_mode"] = asBoolStr(True)
 
         if Options.isOnefileTempDirMode():
-            options["onefile_temp_mode"] = asBoolStr(True)
+            scons_options["onefile_temp_mode"] = asBoolStr(True)
 
     # TODO: Some things are going to hate that, we might need to bundle
     # for accelerated mode still.
     if Options.shallCreateAppBundle():
-        options["macos_bundle_mode"] = asBoolStr(True)
+        scons_options["macos_bundle_mode"] = asBoolStr(True)
 
     if Options.getForcedStdoutPath():
-        options["forced_stdout_path"] = Options.getForcedStdoutPath()
+        scons_options["forced_stdout_path"] = Options.getForcedStdoutPath()
 
     if Options.getForcedStderrPath():
-        options["forced_stderr_path"] = Options.getForcedStderrPath()
+        scons_options["forced_stderr_path"] = Options.getForcedStderrPath()
 
     if Options.isProfile():
-        options["profile_mode"] = asBoolStr(True)
+        scons_options["profile_mode"] = asBoolStr(True)
 
     if Options.shallTreatUninstalledPython():
-        options["uninstalled_python"] = asBoolStr(True)
+        scons_options["uninstalled_python"] = asBoolStr(True)
 
     if ModuleRegistry.getUncompiledTechnicalModules():
-        options["frozen_modules"] = str(
+        scons_options["frozen_modules"] = str(
             len(ModuleRegistry.getUncompiledTechnicalModules())
         )
 
     if hasPythonFlagNoWarnings():
-        options["no_python_warnings"] = asBoolStr(True)
+        scons_options["no_python_warnings"] = asBoolStr(True)
 
     if hasPythonFlagNoAsserts():
-        options["python_sysflag_optimize"] = str(
+        scons_options["python_sysflag_optimize"] = str(
             2 if hasPythonFlagNoDocStrings() else 1
         )
 
-        options["python_flag_no_asserts"] = asBoolStr(True)
+        scons_options["python_flag_no_asserts"] = asBoolStr(True)
 
     if hasPythonFlagNoDocStrings():
-        options["python_flag_no_docstrings"] = asBoolStr(True)
+        scons_options["python_flag_no_docstrings"] = asBoolStr(True)
 
     if hasPythonFlagNoAnnotations():
-        options["python_flag_no_annotations"] = asBoolStr(True)
+        scons_options["python_flag_no_annotations"] = asBoolStr(True)
 
     if python_version < 0x300 and sys.flags.py3k_warning:
-        options["python_sysflag_py3k_warning"] = asBoolStr(True)
+        scons_options["python_sysflag_py3k_warning"] = asBoolStr(True)
 
     if python_version < 0x300 and (
         sys.flags.division_warning or sys.flags.py3k_warning
     ):
-        options["python_sysflag_division_warning"] = asBoolStr(True)
+        scons_options["python_sysflag_division_warning"] = asBoolStr(True)
 
     if sys.flags.bytes_warning:
-        options["python_sysflag_bytes_warning"] = asBoolStr(True)
+        scons_options["python_sysflag_bytes_warning"] = asBoolStr(True)
 
     if int(os.getenv("NUITKA_NOSITE_FLAG", Options.hasPythonFlagNoSite())):
-        options["python_sysflag_no_site"] = asBoolStr(True)
+        scons_options["python_sysflag_no_site"] = asBoolStr(True)
 
     if Options.hasPythonFlagTraceImports():
-        options["python_sysflag_verbose"] = asBoolStr(True)
+        scons_options["python_sysflag_verbose"] = asBoolStr(True)
 
     if Options.hasPythonFlagNoRandomization():
-        options["python_sysflag_no_randomization"] = asBoolStr(True)
+        scons_options["python_sysflag_no_randomization"] = asBoolStr(True)
 
     if python_version < 0x300 and sys.flags.unicode:
-        options["python_sysflag_unicode"] = asBoolStr(True)
+        scons_options["python_sysflag_unicode"] = asBoolStr(True)
 
     if python_version >= 0x370 and sys.flags.utf8_mode:
-        options["python_sysflag_utf8"] = asBoolStr(True)
+        scons_options["python_sysflag_utf8"] = asBoolStr(True)
 
     if hasPythonFlagNoBytecodeRuntimeCache():
-        options["python_sysflag_unbuffered"] = asBoolStr(True)
+        scons_options["python_sysflag_unbuffered"] = asBoolStr(True)
 
     if hasPythonFlagUnbuffered():
-        options["python_sysflag_unbuffered"] = asBoolStr(True)
+        scons_options["python_sysflag_unbuffered"] = asBoolStr(True)
 
     if hasPythonFlagIsolated():
-        options["python_sysflag_isolated"] = asBoolStr(True)
+        scons_options["python_sysflag_isolated"] = asBoolStr(True)
 
     abiflags = getPythonABI()
     if abiflags:
-        options["abiflags"] = abiflags
+        scons_options["abiflags"] = abiflags
 
     if Options.shallMakeModule():
-        options["result_exe"] = OutputDirectories.getResultBasePath(
+        scons_options["result_exe"] = OutputDirectories.getResultBasePath(
             onefile=False
         ) + getSharedLibrarySuffix(preferred=True)
 
     link_module_libs = getModuleLinkerLibs()
     if link_module_libs:
-        options["link_module_libs"] = ",".join(link_module_libs)
-
-    env_values = setCommonSconsOptions(options)
+        scons_options["link_module_libs"] = ",".join(link_module_libs)
 
     # Allow plugins to build definitions.
     env_values.update(Plugins.getBuildDefinitions())
 
     if Options.shallCreatePythonPgoInput():
-        options["pgo_mode"] = "python"
+        scons_options["pgo_mode"] = "python"
 
         result = runScons(
-            options=options,
+            scons_options=scons_options,
             env_values=env_values,
             scons_filename="Backend.scons",
         )
 
         if not result:
-            return result, options
+            return result, scons_options
 
         # Need to make it usable before executing it.
         executePostProcessing()
         _runPythonPgoBinary()
 
-        return True, options
+        return True, scons_options
 
         # Need to restart compilation from scratch here.
     if Options.isCPgoMode():
@@ -752,33 +748,33 @@ def runSconsBackend():
         # and standalone mode proper support, which might need data files to be
         # there, which currently are not yet there, so it won't run.
         if Options.isCPgoMode():
-            options["pgo_mode"] = "generate"
+            scons_options["pgo_mode"] = "generate"
 
             result = runScons(
-                options=options,
+                scons_options=scons_options,
                 env_values=env_values,
                 scons_filename="Backend.scons",
             )
 
             if not result:
-                return result, options
+                return result, scons_options
 
             # Need to make it usable before executing it.
             executePostProcessing()
             _runCPgoBinary()
-            options["pgo_mode"] = "use"
+            scons_options["pgo_mode"] = "use"
 
     result = (
         runScons(
-            options=options,
+            scons_options=scons_options,
             env_values=env_values,
             scons_filename="Backend.scons",
         ),
-        options,
+        scons_options,
     )
 
     # Delete PGO files if asked to do that.
-    if options.get("pgo_mode") == "use" and _wasMsvcMode():
+    if scons_options.get("pgo_mode") == "use" and _wasMsvcMode():
         _deleteMsvcPGOFiles(pgo_mode="use")
 
     return result
@@ -799,8 +795,8 @@ def callExecPython(args, add_path, uac):
 
 def _executeMain(binary_filename):
     # Wrap in debugger, unless the CMD file contains that call already.
-    if Options.shallRunInDebugger() and not Options.shallCreateCmdFileForExecution():
-        args = wrapCommandForDebuggerForExec(binary_filename)
+    if Options.shallRunInDebugger() and not Options.shallCreateScriptFileForExecution():
+        args = wrapCommandForDebuggerForExec(command=(binary_filename,))
     else:
         args = (binary_filename, binary_filename)
 
@@ -849,7 +845,9 @@ import sys; sys.path.insert(0, %(output_dir)r)
     }
 
     if Options.shallRunInDebugger():
-        args = wrapCommandForDebuggerForExec(sys.executable, "-c", python_command)
+        args = wrapCommandForDebuggerForExec(
+            command=(sys.executable, "-c", python_command)
+        )
     else:
         args = (sys.executable, "python", "-c", python_command)
 
@@ -970,9 +968,10 @@ def _main():
         readPGOInputFile(pgo_filename)
 
     general.info(
-        "Starting Python compilation with Nuitka %r on Python %r commercial grade %r."
+        "Starting Python compilation with Nuitka %r on Python (flavor %s), %r commercial grade %r."
         % (
             getNuitkaVersion(),
+            getPythonFlavorName(),
             python_version_str,
             getCommercialVersion() or "not installed",
         )
@@ -989,7 +988,7 @@ def _main():
 
     # Initialize the importing layer from options, main filenames, debugging
     # options, etc.
-    Importing.setupImportingFromOptions()
+    setupImportingFromOptions()
 
     addIncludedDataFilesFromFileOptions()
     addIncludedDataFilesFromPackageOptions()
@@ -1131,7 +1130,7 @@ not use compiled code while it exists."""
                 mnemonic="compiled-package-hidden-by-package",
             )
 
-    general.info("Successfully created '%s'." % final_filename)
+    general.info("Successfully created '%s'." % getReportPath(final_filename))
 
     writeCompilationReports(aborted=False)
 

nuitka/ModuleRegistry.py

@@ -1,4 +1,4 @@
-#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
 """ This to keep track of used modules.
@@ -14,6 +14,7 @@
 import collections
 import os
 
+from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.PythonVersions import python_version
 
@@ -234,7 +235,7 @@ def addModuleInfluencingCondition(
 
 
 def addModuleInfluencingVariable(
-    module_name, plugin_name, variable_name, control_tags, result
+    module_name, config_module_name, plugin_name, variable_name, control_tags, result
 ):
     if module_name not in module_influencing_plugins:
         module_influencing_plugins[module_name] = OrderedSet()
@@ -242,7 +243,7 @@ def addModuleInfluencingVariable(
         (
             plugin_name,
             "variable-used",
-            (variable_name, tuple(control_tags), repr(result)),
+            (variable_name, tuple(control_tags), repr(result), config_module_name),
         )
     )
 
@@ -278,7 +279,8 @@ def getModuleInfluences(module_name):
 # Information about how long the optimization took.
 module_timing_infos = {}
 
-ModuleOptimizationTimingInfo = collections.namedtuple(
+
+ModuleOptimizationTimingInfo = makeNamedtupleClass(
     "ModuleOptimizationTimingInfo",
     ("pass_number", "time_used", "micro_passes", "merge_counts"),
 )
@@ -288,6 +290,13 @@ def addModuleOptimizationTimeInformation(
     module_name, pass_number, time_used, micro_passes, merge_counts
 ):
     module_timing_info = list(module_timing_infos.get(module_name, []))
+
+    # Do not record cached bytecode loaded timing information, not useful
+    # and duplicate, we want the original values.
+    if pass_number == 1 and len(module_timing_info) == 1:
+        assert micro_passes == 0
+        return
+
     module_timing_info.append(
         ModuleOptimizationTimingInfo(
             pass_number=pass_number,
@@ -303,6 +312,12 @@ def getModuleOptimizationTimingInfos(module_name):
     return module_timing_infos.get(module_name, ())
 
 
+def setModuleOptimizationTimingInfos(module_name, timing_infos):
+    module_timing_infos[module_name] = [
+        ModuleOptimizationTimingInfo(*timing_info) for timing_info in timing_infos
+    ]
+
+
 def getImportedModuleNames():
     result = OrderedSet()