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

nuitka/Options.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
+
+
 """ Options module
 
 This exposes the choices made by the user. Defaults will be applied here, and
@@ -35,12 +21,21 @@ import sys
 from nuitka import Progress, Tracing
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.containers.OrderedSets import OrderedSet
-from nuitka.OptionParsing import parseOptions
+from nuitka.importing.StandardLibrary import isStandardLibraryPath
+from nuitka.OptionParsing import (
+    parseOptions,
+    run_time_variable_names,
+    runSpecialCommandsFromOptions,
+)
 from nuitka.PythonFlavors import (
     getPythonFlavorName,
     isAnacondaPython,
     isApplePython,
+    isArchPackagePython,
+    isCPythonOfficialPackage,
     isDebianPackagePython,
+    isHomebrewPython,
+    isManyLinuxPython,
     isMSYS2MingwPython,
     isNuitkaPython,
     isPyenvPython,
@@ -48,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,
@@ -65,7 +63,9 @@ from nuitka.utils.StaticLibraries import getSystemStaticLibPythonPath
 from nuitka.utils.Utils import (
     getArchitecture,
     getCPUCoreCount,
+    getLaunchingNuitkaProcessEnvironmentValue,
     getLinuxDistribution,
+    getMacOSRelease,
     getOS,
     getWindowsRelease,
     hasOnefileSupportedOS,
@@ -92,71 +92,132 @@ is_report_missing = None
 is_verbose = None
 
 
+def _convertOldStylePathSpecQuotes(value):
+    quote = None
+
+    result = ""
+    for c in value:
+        if c == "%":
+            if quote is None:
+                quote = "{"
+                result += quote
+            elif quote == "{":
+                result += "}"
+                quote = None
+        else:
+            result += c
+
+    return result
+
+
 def checkPathSpec(value, arg_name, allow_disable):
     # There are never enough checks here, pylint: disable=too-many-branches
+    old = value
+    value = _convertOldStylePathSpecQuotes(value)
+    if old != value:
+        Tracing.options_logger.warning(
+            "Adapted '%s' option value from legacy quoting style to '%s' -> '%s'"
+            % (arg_name, old, value)
+        )
 
-    if "%NONE%" in 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."
+            % (arg_name, value)
+        )
+
+    if "{NONE}" in value:
         if not allow_disable:
             Tracing.options_logger.sysexit(
-                "Using value '%%NONE%%' in '%s=%s' value is not allowed."
+                "Using value '{NONE}' in '%s=%s' value is not allowed."
                 % (arg_name, value)
             )
 
-        if value != "%NONE%":
+        if value != "{NONE}":
             Tracing.options_logger.sysexit(
-                "Using value '%%NONE%%' in '%s=%s' value does not allow anything else used too."
+                "Using value '{NONE}' in '%s=%s' value does not allow anything else used too."
                 % (arg_name, value)
             )
 
-    if "%NULL%" in value:
+    if "{NULL}" in value:
         if not allow_disable:
             Tracing.options_logger.sysexit(
-                "Using value '%%NULL%%' in '%s=%s' value is not allowed."
+                "Using value '{NULL}' in '%s=%s' value is not allowed."
                 % (arg_name, value)
             )
 
-        if value != "%NULL%":
+        if value != "{NULL}":
             Tracing.options_logger.sysexit(
-                "Using value '%%NULL%%' in '%s=%s' value does not allow anything else used too."
+                "Using value '{NULL}' in '%s=%s' value does not allow anything else used too."
                 % (arg_name, value)
             )
 
-    if "%COMPANY%" in value and not getCompanyName():
+    if "{COMPANY}" in value and not getCompanyName():
         Tracing.options_logger.sysexit(
-            "Using value '%%COMPANY%%' in '%s=%s' value without being specified."
+            "Using value '{COMPANY}' in '%s=%s' value without being specified."
             % (arg_name, value)
         )
 
-    if "%PRODUCT%" in value and not getProductName():
+    if "{PRODUCT}" in value and not getProductName():
         Tracing.options_logger.sysexit(
-            "Using value '%%PRODUCT%%' in '%s=%s' value without being specified."
+            "Using value '{PRODUCT}' in '%s=%s' value without being specified."
             % (arg_name, value)
         )
 
-    if "%VERSION%" in value and not (getFileVersion() or getProductVersion()):
+    if "{VERSION}" in value and not (getFileVersionTuple() or getProductVersionTuple()):
         Tracing.options_logger.sysexit(
-            "Using value '%%VERSION%%' in '%s=%s' value without being specified."
+            "Using value '{VERSION}' in '%s=%s' value without being specified."
             % (arg_name, value)
         )
 
-    if value.count("%") % 2 != 0:
-        Tracing.options_logger.warning(
-            """Unmatched '%%' is suspicious for '%s=%s' and may \
-not do what you want it to do."""
+    if value.count("{") != value.count("}"):
+        Tracing.options_logger.sysexit(
+            """Unmatched '{}' is wrong for '%s=%s' and may \
+definitely not do what you want it to do."""
             % (arg_name, value)
         )
 
+    # Catch nested or illegal variable names.
+    var_name = None
+    for c in value:
+        if c in "{":
+            if var_name is not None:
+                Tracing.options_logger.sysexit(
+                    """Nested '{' is wrong for '%s=%s'.""" % (arg_name, value)
+                )
+            var_name = ""
+        elif c == "}":
+            if var_name is None:
+                Tracing.options_logger.sysexit(
+                    """Stray '}' is wrong for '%s=%s'.""" % (arg_name, value)
+                )
+
+            if var_name not in run_time_variable_names:
+                Tracing.onefile_logger.sysexit(
+                    "Found unknown variable name '%s' in for '%s=%s'."
+                    "" % (var_name, arg_name, value)
+                )
+
+            var_name = None
+        else:
+            if var_name is not None:
+                var_name += c
+
     for candidate in (
-        "%PROGRAM%",
-        "%PROGRAM_BASE%",
-        "%CACHE_DIR%",
-        "%HOME%",
-        "%TEMP%",
+        "{PROGRAM}",
+        "{PROGRAM_BASE}",
+        "{CACHE_DIR}",
+        "{HOME}",
+        "{TEMP}",
     ):
         if candidate in value[1:]:
             Tracing.options_logger.sysexit(
-                """Absolute run time path of '%s' can only be at the \
-start of '%s=%s', using it in the middle is not allowed."""
+                """\
+Absolute run time paths of '%s' can only be at the start of \
+'%s=%s', using it in the middle of it is not allowed."""
                 % (candidate, arg_name, value)
             )
 
@@ -167,9 +228,27 @@ 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
+
 
 def _checkOnefileTargetSpec():
-    checkPathSpec(
+    options.onefile_tempdir_spec = checkPathSpec(
         options.onefile_tempdir_spec,
         arg_name="--onefile-tempdir-spec",
         allow_disable=False,
@@ -183,7 +262,7 @@ you cannot unpack the onefile payload into the same directory as the binary,
 as that would overwrite it and cause locking issues as well."""
         )
 
-    if options.onefile_tempdir_spec.count("%") == 0:
+    if options.onefile_tempdir_spec.count("{") == 0:
         Tracing.options_logger.warning(
             """Not using any variables for '--onefile-tempdir-spec' should only be \
 done if your program absolutely needs to be in the same path always: '%s'"""
@@ -192,16 +271,20 @@ done if your program absolutely needs to be in the same path always: '%s'"""
 
     if os.path.isabs(options.onefile_tempdir_spec):
         Tracing.options_logger.warning(
-            """Using an absolute path should be avoided unless you are targeting a \
-very well known environment: anchor with e.g. %%TEMP%%, %%CACHE_DIR%% is recommended: '%s'"""
+            """\
+Using an absolute path should be avoided unless you are targeting a \
+very well known environment: anchoring it with e.g. '{TEMP}', \
+'{CACHE_DIR}' is recommended: You seemingly gave the value '%s'"""
             % options.onefile_tempdir_spec
         )
     elif not options.onefile_tempdir_spec.startswith(
-        ("%TEMP%", "%HOME%", "%CACHE_DIR%")
+        ("{TEMP}", "{HOME}", "{CACHE_DIR}")
     ):
         Tracing.options_logger.warning(
-            """Using an relative to the executable should be avoided unless you are targeting a \
-very well known environment, anchor with e.g. %%TEMP%%, %%CACHE_DIR%% is recommended: '%s'"""
+            """\
+Using a relative to the onefile executable should be avoided \
+unless you are targeting a very well known environment, anchoring \
+it with e.g. '{TEMP}', '{CACHE_DIR}' is recommended: '%s'"""
             % options.onefile_tempdir_spec
         )
 
@@ -213,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()
@@ -232,6 +317,9 @@ def _getVersionInformationValues():
     if isWin32OrPosixWindows():
         yield "WindowsRelease: %s" % getWindowsRelease()
 
+    if isMacOS():
+        yield "macOSRelease: %s" % getMacOSRelease()
+
 
 def printVersionInformation():
     print("\n".join(_getVersionInformationValues()))
@@ -252,6 +340,38 @@ def printVersionInformation():
     )
 
 
+def _warnOnefileOnlyOption(option_name):
+    if not options.is_onefile:
+        Tracing.options_logger.warning(
+            """\
+Using onefile specific option '%s' has no effect \
+when '--onefile' is not specified."""
+            % option_name
+        )
+
+
+def _checkDataDirOptionValue(data_dir, option_name):
+    if "=" not in data_dir:
+        Tracing.options_logger.sysexit(
+            "Error, malformed '%s' value '%s' description, must specify a relative target path with '=' separating it."
+            % (option_name, data_dir)
+        )
+
+    src, dst = data_dir.split("=", 1)
+
+    if os.path.isabs(dst):
+        Tracing.options_logger.sysexit(
+            "Error, malformed '%s' value, must specify relative target path for data dir, not '%s' as in '%s'."
+            % (option_name, dst, data_dir)
+        )
+
+    if not os.path.isdir(src):
+        Tracing.options_logger.sysexit(
+            "Error, malformed '%s' value, must specify existing source data directory, not '%s' as in '%s'."
+            % (option_name, dst, data_dir)
+        )
+
+
 def parseArgs():
     """Parse the command line arguments
 
@@ -271,7 +391,7 @@ def parseArgs():
             Tracing.general.sysexit(
                 """\
 Error, the Python from Windows app store is not supported.""",
-                mnemonic="unsupported-python",
+                mnemonic="unsupported-windows-app-store-python",
             )
 
     is_nuitka_run, options, positional_args, extra_args = parseOptions(
@@ -296,7 +416,7 @@ Error, the Python from Windows app store is not supported.""",
     # TODO: Have dedicated option for it.
     is_report_missing = is_debug
 
-    if options.quiet or int(os.environ.get("NUITKA_QUIET", "0")):
+    if options.quiet or int(os.getenv("NUITKA_QUIET", "0")):
         Tracing.setQuiet()
 
     def _quoteArg(arg):
@@ -310,17 +430,26 @@ Error, the Python from Windows app store is not supported.""",
         else:
             return arg
 
+    # This will not return if a non-compiling command is given.
+    runSpecialCommandsFromOptions(options)
+
     if not options.version:
         Tracing.options_logger.info(
             "Used command line options: %s"
             % " ".join(_quoteArg(arg) for arg in sys.argv[1:])
         )
 
-    if os.environ.get("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()
 
@@ -362,7 +491,35 @@ Error, the Python from Windows app store is not supported.""",
     if options.is_onefile:
         options.is_standalone = True
 
-    # Standalone implies no_site build
+    # macOS bundle implies standalone build.
+    if shallCreateAppBundle():
+        options.is_standalone = True
+
+    if isMacOS():
+        macos_target_arch = getMacOSTargetArch()
+
+        if macos_target_arch == "universal":
+            Tracing.options_logger.sysexit(
+                "Cannot create universal macOS binaries (yet), please pick an arch and create two binaries."
+            )
+
+        if (options.macos_target_arch or "native") != "native":
+            from nuitka.utils.SharedLibraries import (
+                hasUniversalOrMatchingMacOSArchitecture,
+            )
+
+            if not hasUniversalOrMatchingMacOSArchitecture(
+                os.path.realpath(sys.executable)
+            ):
+                Tracing.options_logger.sysexit(
+                    """\
+Cannot cross compile to other arch, using non-universal Python binaries \
+for macOS. Please install the "universal" Python package as offered on \
+the Python download page."""
+                )
+
+    # Standalone implies no_site build unless overridden, therefore put it
+    # at start of flags, so "site" can override it.
     if options.is_standalone:
         options.python_flags.insert(0, "no_site")
 
@@ -370,12 +527,7 @@ Error, the Python from Windows app store is not supported.""",
     if options.onefile_tempdir_spec:
         _checkOnefileTargetSpec()
 
-        if not options.is_onefile:
-            Tracing.options_logger.warning(
-                """\
-Using onefile specific option '--onefile-windows-splash-screen-image' has no effect \
-when '--onefile' is not specified."""
-            )
+        _warnOnefileOnlyOption("--onefile-tempdir-spec")
 
     # Check onefile splash image
     if options.splash_screen_image:
@@ -385,34 +537,27 @@ when '--onefile' is not specified."""
                 % options.splash_screen_image
             )
 
-        if not options.is_onefile:
-            Tracing.options_logger.warning(
-                """\
-Using onefile specific option '--onefile-windows-splash-screen-image' has no effect \
-when '--onefile' is not specified."""
-            )
+        _warnOnefileOnlyOption("--onefile-windows-splash-screen-image")
 
     if options.onefile_child_grace_time is not None:
         if not options.onefile_child_grace_time.isdigit():
             Tracing.options_logger.sysexit(
                 """\
-Error, value given for '--onefile-child-grace-time' must be integer."""
+Error, the value given for '--onefile-child-grace-time' must be integer."""
             )
 
-        if not options.is_onefile:
-            Tracing.options_logger.warning(
-                """\
-Using onefile specific option '--onefile-windows-splash-screen-image' has no effect \
-when '--onefile-child-grace-time' is not specified."""
-            )
+        _warnOnefileOnlyOption("--onefile-child-grace-time")
+
+    if getShallIncludeExternallyDataFilePatterns():
+        _warnOnefileOnlyOption("--include-onefile-external-data")
 
     if options.force_stdout_spec:
-        checkPathSpec(
+        options.force_stdout_spec = checkPathSpec(
             options.force_stdout_spec, "--force-stdout-spec", allow_disable=True
         )
 
     if options.force_stderr_spec:
-        checkPathSpec(
+        options.force_stderr_spec = checkPathSpec(
             options.force_stderr_spec, "--force-stderr-spec", allow_disable=True
         )
 
@@ -504,18 +649,18 @@ it before using it: '%s' (from --output-filename='%s')."""
             )
 
     if isLinux():
-        if len(getIconPaths()) > 1:
+        if len(getLinuxIconPaths()) > 1:
             Tracing.options_logger.sysexit(
                 "Error, can only use one icon file on Linux."
             )
 
     if isMacOS():
-        if len(getIconPaths()) > 1:
+        if len(getMacOSIconPaths()) > 1:
             Tracing.options_logger.sysexit(
                 "Error, can only use one icon file on macOS."
             )
 
-    for icon_path in getIconPaths():
+    for icon_path in getWindowsIconPaths():
         if "#" in icon_path and isWin32Windows():
             icon_path, icon_index = icon_path.rsplit("#", 1)
 
@@ -525,13 +670,6 @@ it before using it: '%s' (from --output-filename='%s')."""
                     % (icon_path + "#" + icon_index)
                 )
 
-        if not os.path.exists(icon_path):
-            Tracing.options_logger.sysexit(
-                "Error, icon path '%s' does not exist." % icon_path
-            )
-
-        checkIconUsage(logger=Tracing.options_logger, icon_path=icon_path)
-
         if getWindowsIconExecutablePath():
             Tracing.options_logger.sysexit(
                 "Error, can only use icons from template executable or from icon files, but not both."
@@ -543,13 +681,8 @@ it before using it: '%s' (from --output-filename='%s')."""
             "Error, icon path executable '%s' does not exist." % icon_exe_path
         )
 
-    if isMacOS() and not shallCreateAppBundle() and shallDisableConsoleWindow():
-        Tracing.options_logger.sysexit(
-            "Error, cannot disable console unless also using '--macos-create-app-bundle'."
-        )
-
     try:
-        file_version = getFileVersion()
+        file_version = getFileVersionTuple()
     # Catch all the things, don't want any interface, pylint: disable=broad-except
     except Exception:
         Tracing.options_logger.sysexit(
@@ -557,7 +690,7 @@ it before using it: '%s' (from --output-filename='%s')."""
         )
 
     try:
-        product_version = getProductVersion()
+        product_version = getProductVersionTuple()
     # Catch all the things, don't want any interface, pylint: disable=broad-except
     except Exception:
         Tracing.options_logger.sysexit(
@@ -639,18 +772,20 @@ it before using it: '%s' (from --output-filename='%s')."""
 
         if data_file_desc.count("=") == 1:
             src, dst = data_file_desc.split("=", 1)
-
-            filenames = resolveShellPatternToFilenames(src)
-
-            if len(filenames) > 1 and not dst.endswith(("/", os.path.sep)):
-                Tracing.options_logger.sysexit(
-                    "Error, pattern '%s' matches more than one file, but target has no trailing slash, not a directory."
-                    % src
-                )
+            src = os.path.expanduser(src)
+            src_pattern = src
         else:
             src, dst, pattern = data_file_desc.split("=", 2)
+            src = os.path.expanduser(src)
+            src_pattern = os.path.join(src, pattern)
 
-            filenames = resolveShellPatternToFilenames(os.path.join(src, pattern))
+        filenames = resolveShellPatternToFilenames(src_pattern)
+
+        if len(filenames) > 1 and not dst.endswith(("/", os.path.sep)):
+            Tracing.options_logger.sysexit(
+                "Error, pattern '%s' matches more than one file, but target has no trailing slash, not a directory."
+                % src
+            )
 
         if not filenames:
             Tracing.options_logger.sysexit(
@@ -664,29 +799,31 @@ it before using it: '%s' (from --output-filename='%s')."""
             )
 
     for data_dir in options.data_dirs:
-        if "=" not in data_dir:
-            Tracing.options_logger.sysexit(
-                "Error, malformed data dir description, must specify relative target path with '=' separating it."
-            )
+        _checkDataDirOptionValue(data_dir=data_dir, option_name="--include-data-dir")
 
-        src, dst = data_dir.split("=", 1)
+    for data_dir in options.raw_dirs:
+        _checkDataDirOptionValue(data_dir=data_dir, option_name="--include-raw-dir")
 
-        if os.path.isabs(dst):
+    for pattern in getShallFollowExtraFilePatterns():
+        if os.path.isdir(pattern):
             Tracing.options_logger.sysexit(
-                "Error, must specify relative target path for data dir, not '%s' as in '%s'."
-                % (dst, data_dir)
+                "Error, pattern '%s' given to '--include-plugin-files' cannot be a directory name."
+                % pattern
             )
 
-        if not os.path.isdir(src):
+    for directory_name in getShallFollowExtra():
+        if not os.path.isdir(directory_name):
             Tracing.options_logger.sysexit(
-                "Error, must specify existing source data directory, not '%s' as in '%s'."
-                % (dst, data_dir)
+                "Error, value '%s' given to '--include-plugin-directory' must be a directory name."
+                % directory_name
             )
 
-    for pattern in getShallFollowExtraFilePatterns():
-        if os.path.isdir(pattern):
+        if isStandardLibraryPath(directory_name):
             Tracing.options_logger.sysexit(
-                "Error, pattern '%s' given to '--include-plugin-files' cannot be a directory name."
+                """\
+Error, directory '%s' given to '--include-plugin-directory' must not be a \
+standard library path. Use '--include-module' or '--include-package' \
+options instead."""
                 % pattern
             )
 
@@ -717,11 +854,14 @@ download. With that, your program will work on macOS 10.9 or higher."""
                 "Error, Apple Python 2.7 from macOS is not usable as per Apple decision, use e.g. CPython 2.7 instead."
             )
 
-    if isStandaloneMode() and isLinux() and getExecutablePath("patchelf") is None:
-        Tracing.options_logger.sysexit(
-            "Error, standalone mode on Linux requires 'patchelf' to be installed. Use 'apt/dnf/yum install patchelf' first."
+    if isStandaloneMode() and isLinux():
+        # Cyclic dependency
+        from nuitka.utils.SharedLibraries import (
+            checkPatchElfPresenceAndUsability,
         )
 
+        checkPatchElfPresenceAndUsability(Tracing.options_logger)
+
     pgo_executable = getPgoExecutable()
     if pgo_executable and not isPathExecutable(pgo_executable):
         Tracing.options_logger.sysexit(
@@ -740,6 +880,14 @@ Error, onefile mode on Termux requires 'termux-elf-cleaner' to be installed, \
 use 'pkg install termux-elf-cleaner' to use it."""
         )
 
+    for user_yaml_filename in getUserProvidedYamlFiles():
+        if not os.path.exists(user_yaml_filename):
+            Tracing.options_logger.sysexit(
+                """\
+Error, cannot find user provider yaml file '%s'."""
+                % user_yaml_filename
+            )
+
     # This triggers checks inside that code
     getCompilationReportUserData()
 
@@ -752,6 +900,20 @@ def commentArgs():
     """
     # A ton of cases to consider, pylint: disable=too-many-branches,too-many-statements
 
+    # Check files to exist or be suitable first before giving other warnings.
+    for filename in getMainEntryPointFilenames():
+        if not os.path.exists(filename):
+            Tracing.general.sysexit("Error, file '%s' is not found." % filename)
+
+        if (
+            shallMakeModule()
+            and os.path.normcase(os.path.basename(filename)) == "__init__.py"
+        ):
+            Tracing.general.sysexit(
+                """\
+Error, to compile a package, specify its directory but, not the '__init__.py'."""
+            )
+
     # Inform the user about potential issues with the running version. e.g. unsupported
     # version.
     if python_version_str not in getSupportedPythonVersions():
@@ -770,8 +932,28 @@ version '%s' instead or newer Nuitka."""
                 )
             )
 
+    # spell-checker: ignore releaselevel
+    if sys.version_info.releaselevel not in ("final", "candidate"):
+        if python_version_str not in getNotYetSupportedPythonVersions():
+            Tracing.general.sysexit(
+                """\
+Non-final versions '%s' '%s' are not supported by Nuitka, use the \
+final version instead."""
+                % (python_version_str, sys.version_info.releaselevel)
+            )
+
     if python_version_str in getNotYetSupportedPythonVersions():
-        if not isExperimental("python" + python_version_str):
+        if sys.version_info.releaselevel != "final" and not isExperimental(
+            "python" + python_version_str
+        ):
+            Tracing.general.warning(
+                """\
+The Python version '%s' '%s' is only experimentally supported by \
+and recommended only for use in Nuitka development and testing."""
+                % (python_version_str, sys.version_info.releaselevel)
+            )
+
+        elif not isExperimental("python" + python_version_str):
             Tracing.general.sysexit(
                 """\
 The Python version '%s' is not supported by Nuitka '%s', but an upcoming \
@@ -783,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"
     )
@@ -848,6 +1037,14 @@ release will add it. In the mean time use '%s' instead."""
                 % getMsvcVersion()
             )
 
+    try:
+        getJobLimit()
+    except ValueError:
+        Tracing.options_logger.sysexit(
+            "For '--jobs' value, use integer values only, not, but not '%s'."
+            % options.jobs
+        )
+
     if isOnefileMode():
         standalone_mode = "onefile"
     elif isStandaloneMode():
@@ -893,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
@@ -921,7 +1119,7 @@ make sure that is intended."""
         options.static_libpython = "no"
 
     if (
-        not isPgoMode()
+        not isCPgoMode()
         and not isPythonPgoMode()
         and (getPgoArgs() or getPgoExecutable())
     ):
@@ -929,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 (
@@ -945,6 +1147,7 @@ make sure that is intended."""
         and not shallMakeModule()
         and not shallUseStaticLibPython()
         and getSystemStaticLibPythonPath() is not None
+        and not shallUsePythonDebug()
     ):
         Tracing.options_logger.info(
             """Detected static libpython to exist, consider '--static-libpython=yes' for better performance, \
@@ -957,11 +1160,6 @@ but errors may happen."""
                 "The '--debugger' option has no effect outside of '--debug' without '--run' option."
             )
 
-        if not shallClearPythonPathEnvironment():
-            Tracing.options_logger.warning(
-                "The '--execute-with-pythonpath' option has no effect without '--run' option."
-            )
-
     # Check if the fallback is used, except for Python2 on Windows, where we cannot
     # have it.
     if hasattr(OrderedSet, "is_fallback") and not (
@@ -983,15 +1181,10 @@ and not with the non-debug version.
 """
         )
 
-    if (
-        isMacOS()
-        and shallCreateAppBundle()
-        and shallDisableConsoleWindow()
-        and not getIconPaths()
-    ):
+    if isMacOS() and shallCreateAppBundle() and not getMacOSIconPaths():
         Tracing.general.warning(
             """\
-For GUI applications, you ought to specify an icon with '--macos-app-icon'.", \
+For application bundles, you ought to specify an icon with '--macos-app-icon'.", \
 otherwise a dock icon may not be present."""
         )
 
@@ -1007,23 +1200,10 @@ notarization capable signature, the default identify 'ad-hoc' is not going \
 to work."""
         )
 
-    for filename in getMainEntryPointFilenames():
-        if not os.path.exists(filename):
-            Tracing.general.sysexit("Error, file '%s' is not found." % filename)
-
-        if (
-            shallMakeModule()
-            and os.path.normcase(os.path.basename(filename)) == "__init__.py"
-        ):
-            Tracing.general.sysexit(
-                """\
-Error, to compile a package, specify its directory but, not the '__init__.py'."""
-            )
-
     if (
         isWin32Windows()
         and 0x340 <= python_version < 0x380
-        and not shallDisableConsoleWindow()
+        and getWindowsConsoleMode() != "disable"
     ):
         Tracing.general.warning(
             """\
@@ -1036,6 +1216,49 @@ console window for deployment.
             mnemonic="old-python-windows-console",
         )
 
+    if shallMakeModule() and (getForcedStderrPath() or getForcedStdoutPath()):
+        Tracing.general.warning(
+            """\
+Extension modules do not control process outputs, therefore the \
+options '--force-stdout-spec' and '--force-stderr-spec' have no \
+impact and should not be specified."""
+        )
+
+    if shallMakeModule() and options.console_mode is not None:
+        Tracing.general.warning(
+            """\
+Extension modules are not binaries, and therefore the option \
+'--windows-console-mode' does not have an impact and should \
+not be specified."""
+        )
+
+    if options.disable_console in (True, False):
+        if isWin32Windows():
+            Tracing.general.warning(
+                """\
+The old console option '%s' should not be given anymore, use '%s' \
+instead. It also has the extra mode 'attach' to consider."""
+                % (
+                    (
+                        "--disable-console"
+                        if options.disable_console
+                        else "--enable-console"
+                    ),
+                    "--windows-console-mode=%s"
+                    % ("disable" if options.disable_console else "force"),
+                )
+            )
+        else:
+            Tracing.general.warning(
+                """The old console option '%s' should not be given anymore, and doesn't
+have any effect anymore on non-Windows."""
+                % (
+                    "--disable-console"
+                    if options.disable_console
+                    else "--enable-console"
+                )
+            )
+
 
 def isVerbose():
     """:returns: bool derived from ``--verbose``"""
@@ -1049,7 +1272,7 @@ def shallTraceExecution():
 
 def shallExecuteImmediately():
     """:returns: bool derived from ``--run``"""
-    return options.immediate_execution
+    return options is not None and options.immediate_execution
 
 
 def shallRunInDebugger():
@@ -1120,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
 
 
@@ -1133,7 +1359,7 @@ def getShallFollowInNoCase():
 
 
 def getShallFollowModules():
-    """*list*, items of ``--follow-import-to=``"""
+    """*list*, items of ``--follow-import-to=`` amended with what ``--include-module`` and ``--include-package`` got"""
     return sum(
         [
             _splitShellPattern(x)
@@ -1198,11 +1424,15 @@ def getShallIncludeDataFiles():
             src, dest = data_file_desc.split("=", 1)
 
             for pattern in _splitShellPattern(src):
+                pattern = os.path.expanduser(pattern)
+
                 yield pattern, None, dest, data_file_desc
         else:
             src, dest, pattern = data_file_desc.split("=", 2)
 
             for pattern in _splitShellPattern(pattern):
+                pattern = os.path.expanduser(pattern)
+
                 yield os.path.join(src, pattern), src, dest, data_file_desc
 
 
@@ -1220,6 +1450,12 @@ def getShallNotIncludeDataFilePatterns():
     return options.data_files_inhibited
 
 
+def getShallIncludeExternallyDataFilePatterns():
+    """*list*, items of ``--include-onefile-external-data=``"""
+
+    return options.data_files_external
+
+
 def getShallNotIncludeDllFilePatterns():
     """*list*, items of ``--noinclude-dlls=``"""
 
@@ -1315,9 +1551,15 @@ def getMainEntryPointFilenames():
         if len(options.mains) == 1:
             assert not positional_args
 
-        return tuple(options.mains)
+        result = tuple(options.mains)
     else:
-        return [positional_args[0]]
+        result = (positional_args[0],)
+
+    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():
@@ -1325,11 +1567,6 @@ def shallOptimizeStringExec():
     return False
 
 
-def shallClearPythonPathEnvironment():
-    """*bool* = **not** ``--execute-with-pythonpath``"""
-    return not options.keep_pythonpath
-
-
 _shall_use_static_lib_python = None
 
 
@@ -1342,7 +1579,10 @@ def _shallUseStaticLibPython():
     if options.static_libpython == "auto":
         # Nuitka-Python is good to to static linking.
         if isNuitkaPython():
-            return True, "Nuitka-Python is broken."
+            return True, "Nuitka-Python is unexpectedly broken."
+
+        if isHomebrewPython():
+            return True, "Homebrew Python is unexpectedly broken."
 
         # Debian packages with are usable if the OS is new enough
         from nuitka.utils.StaticLibraries import (
@@ -1364,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'.",
@@ -1373,6 +1613,21 @@ def _shallUseStaticLibPython():
         if isPyenvPython():
             return True, "Nuitka on pyenv should not use '--enable-shared'."
 
+        if isManyLinuxPython():
+            return (
+                True,
+                """\
+Nuitka on 'manylinux' has no shared libraries. Use container with \
+the command 'RUN cd /opt/_internal && tar xf static-libs-for-embedding-only.tar.xz' \
+added to provide the static link library.""",
+            )
+
+        if isMacOS() and isCPythonOfficialPackage():
+            return True, None
+
+        if isArchPackagePython():
+            return True, None
+
     return options.static_libpython == "yes", None
 
 
@@ -1438,17 +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
+
+    # 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:
+            result = max(1, getCPUCoreCount() + result)
 
-    return int(options.jobs)
+    return result
 
 
 def getLtoMode():
-    """:returns: bool derived from ``--lto`` or ``--pgo``"""
+    """:returns: bool derived from ``--lto``"""
     return options.lto
 
 
@@ -1507,16 +1770,18 @@ def shallDisableBytecodeCacheUsage():
     return shallDisableCacheUsage("bytecode")
 
 
-def shallDisableConsoleWindow():
-    """:returns: None (not given), False, or True derived from ``--disable-console or ``--enable-console``"""
-    return options.disable_console
-
+def shallDisableCompressionCacheUsage():
+    """:returns: bool derived from ``--disable-cache=compression``"""
+    return shallDisableCacheUsage("compression")
 
-def mayDisableConsoleWindow():
-    """:returns: bool derived from platform support of disabling the console,"""
 
-    # TODO: What about MSYS2?
-    return isWin32Windows() or isMacOS()
+def getWindowsConsoleMode():
+    """:returns: str from ``--windows-console-mode``"""
+    if options.disable_console is True:
+        return "disable"
+    if options.disable_console is False:
+        return "force"
+    return options.console_mode or "force"
 
 
 def _isFullCompat():
@@ -1577,10 +1842,6 @@ def enableExperimental(indication):
     _experimental.add(indication)
 
 
-def disableExperimental(indication):
-    _experimental.remove(indication)
-
-
 def getExperimentalIndications():
     """*tuple*, items of ``--experimental=``"""
     if hasattr(options, "experimental"):
@@ -1589,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
@@ -1596,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():
@@ -1616,13 +1900,16 @@ def isOnefileTempDirMode():
         Using cached onefile execution when the spec doesn't contain
         volatile things.
     """
+    if shallCreatePythonPgoInput():
+        return False
+
     spec = getOnefileTempDirSpec()
 
     for candidate in (
-        "%PID",
-        "%TIME%",
-        "%PROGRAM%",
-        "%PROGRAM_BASE%",
+        "{PID}",
+        "{TIME}",
+        "{PROGRAM}",
+        "{PROGRAM_BASE}",
     ):
         if candidate in spec:
             return True
@@ -1630,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
 
 
@@ -1645,7 +1935,7 @@ def getPythonPgoInput():
     return options.python_pgo_input
 
 
-def shallCreatePgoInput():
+def shallCreatePythonPgoInput():
     return isPythonPgoMode() and getPythonPgoInput() is None
 
 
@@ -1659,9 +1949,7 @@ def getPgoExecutable():
 
     if options.pgo_executable and os.path.exists(options.pgo_executable):
         if not os.path.isabs(options.pgo_executable):
-            options.pgo_executable = os.path.normcase(
-                os.path.join(".", options.pgo_executable)
-            )
+            options.pgo_executable = os.path.join(".", options.pgo_executable)
 
     return options.pgo_executable
 
@@ -1674,11 +1962,10 @@ def getPythonPgoUnseenModulePolicy():
 def getOnefileTempDirSpec():
     """*str* = ``--onefile-tempdir-spec``"""
     result = (
-        options.onefile_tempdir_spec or "%TEMP%" + os.path.sep + "onefile_%PID%_%TIME%"
+        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():
@@ -1695,10 +1982,31 @@ def shallNotCompressOnefile():
     return options.onefile_no_compression
 
 
-def getIconPaths():
-    """*list of str*, values of ``--windows-icon-from-ico`` and ``--linux-onefile-icon``"""
+def shallOnefileAsArchive():
+    """*bool* = ``--onefile-as-archive``"""
+    return options.onefile_as_archive
+
+
+def _checkIconPaths(icon_paths):
+    for icon_path in icon_paths:
+        if not os.path.exists(icon_path):
+            Tracing.options_logger.sysexit(
+                "Error, icon path '%s' does not exist." % icon_path
+            )
+
+        checkIconUsage(logger=Tracing.options_logger, icon_path=icon_path)
+
+    return icon_paths
 
-    result = options.icon_path
+
+def getWindowsIconPaths():
+    """*list of str*, values of ``--windows-icon-from-ico``"""
+    return _checkIconPaths(options.windows_icon_path)
+
+
+def getLinuxIconPaths():
+    """*list of str*, values of ``--linux-icon``"""
+    result = options.linux_icon_path
 
     # Check if Linux icon requirement is met.
     if isLinux() and not result and isOnefileMode():
@@ -1714,7 +2022,12 @@ def getIconPaths():
                 result.append(icon)
                 break
 
-    return result
+    return _checkIconPaths(result)
+
+
+def getMacOSIconPaths():
+    """*list of str*, values of ``--macos-app-icon``"""
+    return _checkIconPaths(options.macos_icon_path)
 
 
 def getWindowsIconExecutablePath():
@@ -1732,6 +2045,28 @@ def shallAskForWindowsUIAccessRights():
     return options.windows_uac_uiaccess
 
 
+def getLegalCopyright():
+    """*str* name of the product to use derived from ``--copyright``"""
+    return options.legal_copyright
+
+
+def getLegalTrademarks():
+    """*str* name of the product to use derived from ``--trademarks``"""
+    return options.legal_trademarks
+
+
+def getLegalInformation():
+    result = options.legal_copyright
+
+    if options.legal_trademarks:
+        if result is not None:
+            result += "\nTrademark information:" + options.legal_trademarks
+        else:
+            result = options.legal_trademarks
+
+    return result
+
+
 def isWindowsServiceMode():
     """*bool*, value of ``--windows-service``"""
     return options.windows_service
@@ -1800,27 +2135,47 @@ def _parseVersionNumber(value):
 
 
 def getProductVersion():
+    """:returns: str, derived from ``--product-version``"""
+    return options.product_version
+
+
+def getProductVersionTuple():
     """:returns: tuple of 4 ints or None, derived from ``--product-version``"""
     return _parseVersionNumber(options.product_version)
 
 
 def getFileVersion():
+    """:returns str, derived from ``--file-version``"""
+    return options.file_version
+
+
+def getFileVersionTuple():
     """:returns tuple of 4 ints or None, derived from ``--file-version``"""
     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
 
 
 def getCompanyName():
-    """*str* name of the company to use"""
+    """*str* name of the company to use derived from ``--company-name``"""
     return options.company_name
 
 
 def getProductName():
-    """*str* name of the product to use"""
+    """*str* name of the product to use derived from ``--product-name``"""
     return options.product_name
 
 
@@ -1836,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()
 
 
@@ -2106,27 +2464,28 @@ def shallUseProgressBar():
 
 def getForcedStdoutPath():
     """*str* force program stdout output into that filename"""
-    result = options.force_stdout_spec
+    if shallCreatePythonPgoInput():
+        return False
 
-    if result is not None:
-        result = os.path.normpath(result)
-
-    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():
+def shallShowSourceModifications(module_name):
     """*bool* display plugin source changes derived from --show-source-changes"""
-    return options is not None and options.show_source_changes
+    if options is None:
+        return False
+
+    result, _reason = module_name.matchesToShellPatterns(options.show_source_changes)
+
+    return result
 
 
 def isLowMemory():
@@ -2208,3 +2567,63 @@ def shallDisplayWarningMnemonic(mnemonic):
 
 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
+
+
+def getModuleParameter(module_name, parameter_name):
+    """:returns: string derived from ``--module-parameter``"""
+
+    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)
+
+        if option_name == module_option_name:
+            return module_option_value
+
+    return None
+
+
+def getForcedRuntimeEnvironmentVariableValues():
+    """:returns: iterable (string, string) derived from ``----force-runtime-environment-variable``"""
+
+    for forced_runtime_env_variables_spec in options.forced_runtime_env_variables:
+        name, value = forced_runtime_env_variables_spec.split("=", 1)
+
+        yield (name, value)
+
+
+#     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.