Nuitka-winsvc 2.3.11__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/Options.py

@@ -43,14 +43,17 @@ from nuitka.PythonFlavors import (
     isUninstalledPython,
 )
 from nuitka.PythonVersions import (
+    getLaunchingSystemPrefixPath,
     getNotYetSupportedPythonVersions,
     getSupportedPythonVersions,
     isDebugPython,
+    isPythonWithGil,
     python_version,
     python_version_str,
 )
 from nuitka.utils.Execution import getExecutablePath
 from nuitka.utils.FileOperations import (
+    isLegalPath,
     isPathExecutable,
     openTextFile,
     resolveShellPatternToFilenames,
@@ -60,6 +63,7 @@ from nuitka.utils.StaticLibraries import getSystemStaticLibPythonPath
 from nuitka.utils.Utils import (
     getArchitecture,
     getCPUCoreCount,
+    getLaunchingNuitkaProcessEnvironmentValue,
     getLinuxDistribution,
     getMacOSRelease,
     getOS,
@@ -116,6 +120,9 @@ def checkPathSpec(value, arg_name, allow_disable):
             % (arg_name, old, value)
         )
 
+    # This changes the '/' to '\' on Windows at least.
+    value = os.path.normpath(value)
+
     if "\n" in value or "\r" in value:
         Tracing.options_logger.sysexit(
             "Using a new line in value '%s=%r' value is not allowed."
@@ -221,6 +228,22 @@ start of '%s=%s', using that alone is not allowed."""
                 % (candidate, arg_name, value)
             )
 
+        if value.startswith(candidate):
+            if value[len(candidate)] != os.path.sep:
+                Tracing.options_logger.sysexit(
+                    """Cannot use general system folder %s, without a path \
+separator '%s=%s', just appending to these is not allowed, needs to be \
+below them."""
+                    % (candidate, arg_name, value)
+                )
+
+    is_legal, reason = isLegalPath(value)
+    if not is_legal:
+        Tracing.options_logger.sysexit(
+            """Cannot use illegal paths '%s=%s', due to %s."""
+            % (arg_name, value, reason)
+        )
+
     return value
 
 
@@ -273,6 +296,8 @@ def _getVersionInformationValues():
     yield "Commercial: %s" % getCommercialVersion()
     yield "Python: %s" % sys.version.split("\n", 1)[0]
     yield "Flavor: %s" % getPythonFlavorName()
+    if python_version >= 0x3D0:
+        yield "GIL: %s" % ("yes" if isPythonWithGil() else "no")
     yield "Executable: %s" % sys.executable
     yield "OS: %s" % getOS()
     yield "Arch: %s" % getArchitecture()
@@ -414,11 +439,17 @@ Error, the Python from Windows app store is not supported.""",
             % " ".join(_quoteArg(arg) for arg in sys.argv[1:])
         )
 
-    if os.getenv("NUITKA_REEXECUTION") and not isAllowedToReexecute():
+    if (
+        getLaunchingNuitkaProcessEnvironmentValue("NUITKA_RE_EXECUTION")
+        and not isAllowedToReexecute()
+    ):
         Tracing.general.sysexit(
             "Error, not allowed to re-execute, but that has happened."
         )
 
+    # Force to persist this one early.
+    getLaunchingSystemPrefixPath()
+
     if options.progress_bar:
         Progress.enableProgressBar()
 
@@ -934,6 +965,13 @@ release will add it. In the mean time use '%s' instead."""
                 )
             )
 
+    if not isPythonWithGil():
+        Tracing.general.warning(
+            """\
+The Python without GIL is only experimentally supported by \
+and recommended only for use in Nuitka development and testing."""
+        )
+
     default_reference_mode = (
         "runtime" if shallMakeModule() or isStandaloneMode() else "original"
     )
@@ -1003,7 +1041,7 @@ release will add it. In the mean time use '%s' instead."""
         getJobLimit()
     except ValueError:
         Tracing.options_logger.sysexit(
-            "For --jobs value, use positive integer values only, not, but not '%s'."
+            "For '--jobs' value, use integer values only, not, but not '%s'."
             % options.jobs
         )
 
@@ -1052,7 +1090,8 @@ to work. You need to instead selectively add them with \
             )
 
     if (
-        not standalone_mode
+        not shallCreatePythonPgoInput()
+        and not standalone_mode
         and options.follow_all is None
         and not options.follow_modules
         and not options.follow_stdlib
@@ -1080,7 +1119,7 @@ make sure that is intended."""
         options.static_libpython = "no"
 
     if (
-        not isPgoMode()
+        not isCPgoMode()
         and not isPythonPgoMode()
         and (getPgoArgs() or getPgoExecutable())
     ):
@@ -1088,15 +1127,19 @@ make sure that is intended."""
             "Providing PGO arguments without enabling PGO mode has no effect."
         )
 
-    if isPgoMode():
+    if isCPgoMode():
         if isStandaloneMode():
             Tracing.optimization_logger.warning(
-                "Using PGO with standalone/onefile mode is not currently working. Expect errors."
+                """\
+Using C level PGO with standalone/onefile mode is not \
+currently working. Expect errors."""
             )
 
         if shallMakeModule():
             Tracing.optimization_logger.warning(
-                "Using PGO with module mode is not currently working. Expect errors."
+                """\
+Using C level PGO with module mode is not currently \
+working. Expect errors."""
             )
 
     if (
@@ -1300,6 +1343,9 @@ def shallFollowNoImports():
 
 def shallFollowAllImports():
     """:returns: bool derived from ``--follow-imports``"""
+    if shallCreatePythonPgoInput() and options.is_standalone:
+        return True
+
     return options.is_standalone or options.follow_all is True
 
 
@@ -1512,6 +1558,10 @@ def getMainEntryPointFilenames():
     return tuple(os.path.normpath(r).rstrip(os.path.sep) for r in result)
 
 
+def isMultidistMode():
+    return options is not None and options.mains and len(options.mains) > 1
+
+
 def shallOptimizeStringExec():
     """Inactive yet"""
     return False
@@ -1554,7 +1604,7 @@ def _shallUseStaticLibPython():
 
         # For Anaconda default to trying static lib python library, which
         # normally is just not available or if it is even unusable.
-        if isAnacondaPython() and not isMacOS() and not isWin32Windows():
+        if isAnacondaPython() and not isWin32Windows():
             return (
                 True,
                 "Nuitka on Anaconda needs package for static libpython installed. Execute 'conda install libpython-static'.",
@@ -1643,22 +1693,25 @@ def isShowScons():
 
 def getJobLimit():
     """*int*, value of ``--jobs`` / "-j" or number of CPU kernels"""
-    if options.jobs is None:
-        if isLowMemory():
-            return 1
-        else:
-            return getCPUCoreCount()
+    jobs = options.jobs
 
-    result = int(options.jobs)
+    # Low memory has a default of 1.
+    if jobs is None and isLowMemory():
+        return 1
+
+    if jobs is None:
+        result = getCPUCoreCount()
+    else:
+        result = int(jobs)
 
-    if result <= 0:
-        raise ValueError(result)
+        if result <= 0:
+            result = max(1, getCPUCoreCount() + jobs)
 
     return result
 
 
 def getLtoMode():
-    """:returns: bool derived from ``--lto`` or ``--pgo``"""
+    """:returns: bool derived from ``--lto``"""
     return options.lto
 
 
@@ -1797,6 +1850,23 @@ def getExperimentalIndications():
         return ()
 
 
+def getDebugModeIndications():
+    result = []
+
+    for debug_option_value_name in ("debug_immortal",):
+        if debug_option_value_name == "debug_immortal" and python_version < 0x3C0:
+            continue
+
+        if _isDebug():
+            if getattr(options, debug_option_value_name) is not False:
+                result.append(debug_option_value_name)
+        else:
+            if getattr(options, debug_option_value_name) is True:
+                result.append(debug_option_value_name)
+
+    return result
+
+
 def shallExplainImports():
     """:returns: bool derived from ``--explain-imports``"""
     return options is not None and options.explain_imports
@@ -1804,12 +1874,18 @@ def shallExplainImports():
 
 def isStandaloneMode():
     """:returns: bool derived from ``--standalone``"""
-    return options.is_standalone
+    if shallCreatePythonPgoInput():
+        return False
+
+    return bool(options.is_standalone or options.list_package_dlls)
 
 
 def isOnefileMode():
     """:returns: bool derived from ``--onefile``"""
-    return options.is_onefile
+    if shallCreatePythonPgoInput():
+        return False
+
+    return bool(options.is_onefile)
 
 
 def isAcceleratedMode():
@@ -1824,6 +1900,9 @@ def isOnefileTempDirMode():
         Using cached onefile execution when the spec doesn't contain
         volatile things.
     """
+    if shallCreatePythonPgoInput():
+        return False
+
     spec = getOnefileTempDirSpec()
 
     for candidate in (
@@ -1838,8 +1917,11 @@ def isOnefileTempDirMode():
     return False
 
 
-def isPgoMode():
-    """:returns: bool derived from ``--pgo``"""
+def isCPgoMode():
+    """:returns: bool derived from ``--pgo-c``"""
+    if shallCreatePythonPgoInput():
+        return False
+
     return options.is_c_pgo
 
 
@@ -1853,7 +1935,7 @@ def getPythonPgoInput():
     return options.python_pgo_input
 
 
-def shallCreatePgoInput():
+def shallCreatePythonPgoInput():
     return isPythonPgoMode() and getPythonPgoInput() is None
 
 
@@ -1883,8 +1965,7 @@ def getOnefileTempDirSpec():
         options.onefile_tempdir_spec or "{TEMP}" + os.path.sep + "onefile_{PID}_{TIME}"
     )
 
-    # This changes the '/' to '\' on Windows at least.
-    return os.path.normpath(result)
+    return result
 
 
 def getOnefileChildGraceTime():
@@ -2073,6 +2154,16 @@ def getFileVersionTuple():
     return _parseVersionNumber(options.file_version)
 
 
+def getProductFileVersion():
+    if options.product_version:
+        if options.file_version:
+            return "%s-%s" % (options.product_version, options.file_version)
+        else:
+            return options.product_version
+    else:
+        return options.file_version
+
+
 def getWindowsSplashScreen():
     """:returns: bool derived from ``--onefile-windows-splash-screen-image``"""
     return options.splash_screen_image
@@ -2100,6 +2191,9 @@ def getMacOSTargetArch():
 
 def shallCreateAppBundle():
     """*bool* shall create an application bundle, derived from ``--macos-create-app-bundle`` value"""
+    if shallCreatePythonPgoInput():
+        return False
+
     return options.macos_create_bundle and isMacOS()
 
 
@@ -2370,22 +2464,18 @@ def shallUseProgressBar():
 
 def getForcedStdoutPath():
     """*str* force program stdout output into that filename"""
-    result = options.force_stdout_spec
-
-    if result is not None:
-        result = os.path.normpath(result)
+    if shallCreatePythonPgoInput():
+        return False
 
-    return result
+    return options.force_stdout_spec
 
 
 def getForcedStderrPath():
     """*str* force program stderr output into that filename"""
-    result = options.force_stderr_spec
-
-    if result is not None:
-        result = os.path.normpath(result)
+    if shallCreatePythonPgoInput():
+        return False
 
-    return result
+    return options.force_stderr_spec
 
 
 def shallShowSourceModifications(module_name):
@@ -2479,6 +2569,17 @@ def shallShowExecutedCommands():
     return isExperimental("show-commands")
 
 
+def getTargetPythonDescription():
+    """:returns: tuple(python_version,OS/arch) string derived from ``--target``"""
+    if options.target_spec is not None:
+        # TODO: Only one we are working on right now.
+        assert options.target_spec == "wasi"
+
+        return python_version, "wasi"
+
+    return None
+
+
 def getFcfProtectionMode():
     """:returns: string derived from ``--fcf-protection``"""
     return options.cf_protection
@@ -2486,7 +2587,13 @@ def getFcfProtectionMode():
 
 def getModuleParameter(module_name, parameter_name):
     """:returns: string derived from ``--module-parameter``"""
-    option_name = module_name.asString() + "-" + parameter_name
+
+    module_name_prefix = module_name.getTopLevelPackageName().asString()
+
+    if parameter_name.startswith(module_name_prefix + "-"):
+        option_name = parameter_name
+    else:
+        option_name = module_name_prefix + "-" + parameter_name
 
     for module_option in options.module_parameters:
         module_option_name, module_option_value = module_option.split("=", 1)

nuitka/OutputDirectories.py

@@ -34,6 +34,11 @@ def setMainModule(main_module):
     _main_module = main_module
 
 
+def hasMainModule():
+    """For reporting to check if there is anything to talk about."""
+    return _main_module is not None
+
+
 def getSourceDirectoryPath(onefile=False):
     """Return path inside the build directory."""
 

nuitka/PostProcessing.py

@@ -12,12 +12,7 @@ import sys
 from nuitka import Options, OutputDirectories
 from nuitka.build.DataComposerInterface import getConstantBlobFilename
 from nuitka.ModuleRegistry import getImportedModuleNames
-from nuitka.PythonVersions import (
-    getPythonABI,
-    getTargetPythonDLLPath,
-    python_version,
-    python_version_str,
-)
+from nuitka.PythonVersions import getTargetPythonDLLPath, python_version
 from nuitka.Tracing import postprocessing_logger
 from nuitka.utils.Execution import wrapCommandForDebuggerForExec
 from nuitka.utils.FileOperations import (
@@ -35,6 +30,8 @@ from nuitka.utils.MacOSApp import createPlistInfoFile
 from nuitka.utils.SharedLibraries import (
     callInstallNameTool,
     cleanupHeaderForAndroid,
+    getOtoolDependencyOutput,
+    parseOtoolListingOutput,
 )
 from nuitka.utils.Utils import isAndroidBasedLinux, isMacOS, isWin32Windows
 from nuitka.utils.WindowsResources import (
@@ -317,10 +314,26 @@ def executePostProcessing():
         and not Options.shallMakeModule()
         and not Options.shallUseStaticLibPython()
     ):
-        python_abi_version = python_version_str + getPythonABI()
-        python_dll_filename = "libpython" + python_abi_version + ".dylib"
-        python_lib_path = os.path.join(sys.prefix, "lib")
-        python_dll_path = os.path.join(python_lib_path, python_dll_filename)
+        for dependency in parseOtoolListingOutput(
+            getOtoolDependencyOutput(result_filename, [])
+        ):
+            if os.path.basename(dependency).lower().startswith(("python", "libpython")):
+                python_dll_filename = dependency
+                break
+        else:
+            postprocessing_logger.sysexit(
+                """
+Error, expected 'libpython dependency not found. Please report the bug."""
+            )
+
+        python_lib_path = os.path.dirname(python_dll_filename)
+        python_dll_path = python_dll_filename
+
+        if not os.path.exists(python_lib_path):
+            python_lib_path = os.path.join(sys.prefix, "lib")
+            python_dll_path = os.path.join(
+                python_lib_path, os.path.basename(python_dll_filename)
+            )
 
         # Note: For CPython, and potentially others, the rpath for the Python
         # library needs to be set, so it will be detected as a dependency
@@ -332,10 +345,6 @@ def executePostProcessing():
                     python_dll_filename,
                     python_dll_path,
                 ),
-                (
-                    "@rpath/Python3.framework/Versions/%s/Python3" % python_version_str,
-                    python_dll_path,
-                ),
             ),
             id_path=None,
             rpath=python_lib_path,

nuitka/PythonFlavors.py

@@ -113,6 +113,20 @@ def isHomebrewPython():
     return False
 
 
+def getHomebrewInstallPath():
+    assert isHomebrewPython()
+
+    candidate = getSystemPrefixPath()
+
+    while candidate != "/":
+        if os.path.isdir(os.path.join(candidate, "Cellar")):
+            return candidate
+
+        candidate = os.path.dirname(candidate)
+
+    sys.exit("Error, failed to locate homebrew installation path.")
+
+
 def isRyePython():
     if isMacOS():
         import sysconfig
@@ -271,10 +285,14 @@ def isCPythonOfficialPackage():
     sys_prefix = getSystemPrefixPath()
 
     # For macOS however, it's very knowable.
-    if isMacOS() and isFilenameBelowPath(
-        path="/Library/Frameworks/Python.framework/Versions/", filename=sys_prefix
-    ):
-        return True
+    if isMacOS():
+        for candidate in (
+            "/Library/Frameworks/Python.framework/Versions/",
+            "/Library/Frameworks/PythonT.framework/Versions/",
+        ):
+
+            if isFilenameBelowPath(path=candidate, filename=sys_prefix):
+                return True
 
     # For Windows, we check registry.
     if isWin32Windows():

nuitka/PythonVersions.py

@@ -104,6 +104,7 @@ python_version_full_str = ".".join(str(s) for s in sys.version_info[0:3])
 python_version_str = ".".join(str(s) for s in sys.version_info[0:2])
 
 
+# TODO: Move error construction helpers to separate node making helpers module.
 def getErrorMessageExecWithNestedFunction():
     """Error message of the concrete Python in case an exec occurs in a
     function that takes a closure variable.
@@ -161,6 +162,13 @@ def getUnboundLocalErrorErrorTemplate():
     return getUnboundLocalErrorErrorTemplate.result
 
 
+def getDictFromkeysNoArgErrorMessage():
+    try:
+        dict.fromkeys()
+    except TypeError as e:
+        return e.args[0]
+
+
 _needs_set_literal_reverse_insertion = None
 
 
@@ -253,6 +261,12 @@ def getPythonABI():
     return abiflags
 
 
+def getLaunchingSystemPrefixPath():
+    from nuitka.utils.Utils import getLaunchingNuitkaProcessEnvironmentValue
+
+    return getLaunchingNuitkaProcessEnvironmentValue("NUITKA_SYS_PREFIX")
+
+
 _the_sys_prefix = None
 
 
@@ -472,6 +486,10 @@ def getModuleLinkerLibs():
         return result
 
 
+def isPythonWithGil():
+    return python_version < 0x3D0 or sys.flags.gil
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/TreeXML.py

@@ -7,7 +7,7 @@ Means to create XML elements from Nuitka tree nodes and to convert the
 XML tree to ASCII or output it.
 """
 
-from nuitka.__past__ import StringIO
+from nuitka.__past__ import BytesIO, StringIO
 
 
 def _indent(elem, level=0, more_sibs=False):
@@ -93,8 +93,11 @@ def toString(tree):
     return result
 
 
-def fromString(text):
-    return fromFile(StringIO(text))
+def fromString(text, use_lxml=False):
+    if type(text) is str:
+        return fromFile(StringIO(text), use_lxml=use_lxml)
+    else:
+        return fromFile(BytesIO(text), use_lxml=use_lxml)
 
 
 def fromFile(file_handle, use_lxml=False):

nuitka/Version.py

@@ -20,7 +20,7 @@
 """
 
 version_string = """\
-Nuitka V2.3.11
+Nuitka V2.4.1
 Copyright (C) 2024 Kay Hayen."""
 
 

nuitka/__main__.py

@@ -14,6 +14,36 @@ or package, that can contain all used modules too.
 import os
 import sys
 
+_cached_process_environments = {}
+
+
+def getLaunchingNuitkaProcessEnvironmentValue(environment_variable_name):
+    if environment_variable_name not in _cached_process_environments:
+        _cached_process_environments[environment_variable_name] = os.getenv(
+            environment_variable_name
+        )
+        if _cached_process_environments[environment_variable_name] is not None:
+            del os.environ[environment_variable_name]
+
+    value = _cached_process_environments[environment_variable_name]
+
+    if value is not None and ":" not in value:
+        value = None
+
+    if value is not None:
+        pid, value = value.split(":", 1)
+
+        try:
+            pid = int(pid)
+        except ValueError:
+            value = None
+        else:
+            if os.name != "nt":
+                if pid != os.getpid():
+                    value = None
+
+    return value
+
 
 def main():
     # PyLint for Python3 thinks we import from ourselves if we really
@@ -35,21 +65,25 @@ def main():
         )
         sys.exit(1)
 
-    if "NUITKA_BINARY_NAME" in os.environ:
-        sys.argv[0] = os.environ["NUITKA_BINARY_NAME"]
+    nuitka_binary_name = getLaunchingNuitkaProcessEnvironmentValue("NUITKA_BINARY_NAME")
+    if nuitka_binary_name is not None:
+        sys.argv[0] = nuitka_binary_name
+
+    nuitka_pythonpath_ast = getLaunchingNuitkaProcessEnvironmentValue(
+        "NUITKA_PYTHONPATH_AST"
+    )
 
-    if "NUITKA_PYTHONPATH_AST" in os.environ:
+    if nuitka_pythonpath_ast is not None:
         # Restore the PYTHONPATH gained from the site module, that we chose not
         # to have imported during compilation. For loading "ast" module, we need
         # one element, that is not necessarily in our current path, but we use
         # that to evaluate the current path.
-        sys.path = [os.environ["NUITKA_PYTHONPATH_AST"]]
+        sys.path = [nuitka_pythonpath_ast]
         import ast
 
-        del os.environ["NUITKA_PYTHONPATH_AST"]
-
-        sys.path = ast.literal_eval(os.environ["NUITKA_PYTHONPATH"])
-        del os.environ["NUITKA_PYTHONPATH"]
+        sys.path = ast.literal_eval(
+            getLaunchingNuitkaProcessEnvironmentValue("NUITKA_PYTHONPATH")
+        )
     else:
         # Remove path element added for being called via "__main__.py", this can
         # only lead to trouble, having e.g. a "distutils" in sys.path that comes
@@ -103,6 +137,13 @@ def main():
 
     warnings.simplefilter("ignore", DeprecationWarning)
 
+    # Hack, we need this to bootstrap and it's actually living in __main__
+    # module of nuitka package and renamed to where we can get at easily for
+    # other uses.
+    __import__("nuitka").getLaunchingNuitkaProcessEnvironmentValue = (
+        getLaunchingNuitkaProcessEnvironmentValue
+    )
+
     from nuitka import Options  # isort:skip
 
     Options.parseArgs()
@@ -151,11 +192,15 @@ def main():
 
 
 if __name__ == "__main__":
-    if "NUITKA_PACKAGE_HOME" in os.environ:
-        sys.path.insert(0, os.environ["NUITKA_PACKAGE_HOME"])
+    _nuitka_package_home = getLaunchingNuitkaProcessEnvironmentValue(
+        "NUITKA_PACKAGE_HOME"
+    )
+    if _nuitka_package_home is not None:
+        sys.path.insert(0, _nuitka_package_home)
 
         import nuitka  # just to have it loaded from there, pylint: disable=unused-import
 
+        assert sys.path[0] is _nuitka_package_home
         del sys.path[0]
 
     main()