Nuitka-winsvc 2.2.2__cp311-cp311-win_amd64.whl → 2.3__cp311-cp311-win_amd64.whl

nuitka/Bytecodes.py

@@ -7,6 +7,7 @@ import ast
 
 from nuitka.Options import hasPythonFlagNoAsserts, hasPythonFlagNoDocStrings
 from nuitka.tree.TreeHelpers import getKind
+from nuitka.utils.Utils import withNoSyntaxWarning
 
 doc_having = tuple(
     getattr(ast, candidate)
@@ -26,8 +27,9 @@ def _removeDocFromBody(node):
 def compileSourceToBytecode(source_code, filename):
     """Compile given source code into bytecode."""
 
-    # Prepare compile call with AST tree.
-    tree = ast.parse(source_code, filename)
+    with withNoSyntaxWarning():
+        # Prepare compile call with AST tree.
+        tree = ast.parse(source_code, filename)
 
     # Do we need to remove doc strings.
     remove_doc_strings_from_tree = hasPythonFlagNoDocStrings()

nuitka/HardImportRegistry.py

@@ -211,6 +211,7 @@ module_os_path_trust = {
     "basename": trust_node,
     "dirname": trust_node,
     "abspath": trust_node,
+    "normpath": trust_node,
 }
 
 

nuitka/MainControl.py

@@ -87,7 +87,10 @@ from nuitka.utils.FileOperations import (
     removeDirectory,
     resetDirectory,
 )
-from nuitka.utils.Importing import getSharedLibrarySuffix
+from nuitka.utils.Importing import (
+    getPackageDirFilename,
+    getSharedLibrarySuffix,
+)
 from nuitka.utils.MemoryUsage import reportMemoryUsage, showMemoryTrace
 from nuitka.utils.ModuleNames import ModuleName
 from nuitka.utils.ReExecute import callExecProcess, reExecuteNuitka
@@ -569,7 +572,6 @@ def runSconsBackend():
     # pylint: disable=too-many-branches,too-many-statements
 
     options = {
-        "result_name": OutputDirectories.getResultBasePath(onefile=False),
         "source_dir": OutputDirectories.getSourceDirectoryPath(),
         "nuitka_python": asBoolStr(isNuitkaPython()),
         "debug_mode": asBoolStr(Options.is_debug),
@@ -692,7 +694,9 @@ def runSconsBackend():
         options["abiflags"] = abiflags
 
     if Options.shallMakeModule():
-        options["module_suffix"] = getSharedLibrarySuffix(preferred=True)
+        options["result_exe"] = OutputDirectories.getResultBasePath(
+            onefile=False
+        ) + getSharedLibrarySuffix(preferred=True)
 
     link_module_libs = getModuleLinkerLibs()
     if link_module_libs:
@@ -759,7 +763,7 @@ def runSconsBackend():
     return result
 
 
-def callExecPython(args, add_path):
+def callExecPython(args, add_path, uac):
     if add_path:
         if "PYTHONPATH" in os.environ:
             os.environ["PYTHONPATH"] += ":" + Options.getOutputDir()
@@ -769,7 +773,7 @@ def callExecPython(args, add_path):
     # Add the main arguments, previous separated.
     args += Options.getPositionalArgs()[1:] + Options.getMainArgs()
 
-    callExecProcess(args)
+    callExecProcess(args, uac=uac)
 
 
 def _executeMain(binary_filename):
@@ -779,7 +783,11 @@ def _executeMain(binary_filename):
     else:
         args = (binary_filename, binary_filename)
 
-    callExecPython(add_path=False, args=args)
+    callExecPython(
+        args=args,
+        add_path=False,
+        uac=isWin32Windows() and Options.shallAskForWindowsAdminRights(),
+    )
 
 
 def _executeModule(tree):
@@ -824,7 +832,7 @@ import sys; sys.path.insert(0, %(output_dir)r)
     else:
         args = (sys.executable, "python", "-c", python_command)
 
-    callExecPython(add_path=True, args=args)
+    callExecPython(args=args, add_path=True, uac=False)
 
 
 def compileTree():
@@ -1085,9 +1093,7 @@ def _main():
     if Options.shallMakeModule():
         base_path = OutputDirectories.getResultBasePath(onefile=False)
 
-        if os.path.isdir(base_path) and os.path.isfile(
-            os.path.join(base_path, "__init__.py")
-        ):
+        if os.path.isdir(base_path) and getPackageDirFilename(base_path):
             general.warning(
                 """\
 The compilation result is hidden by package directory '%s'. Importing will \

nuitka/ModuleRegistry.py

@@ -295,6 +295,21 @@ def getModuleOptimizationTimingInfos(module_name):
     return module_timing_infos.get(module_name, ())
 
 
+def getImportedModuleNames():
+    result = OrderedSet()
+
+    for module in getDoneModules():
+        for used_module in module.getUsedModules():
+            module_name = used_module.module_name
+
+            if hasDoneModule(module_name):
+                continue
+
+            result.add(module_name)
+
+    return result
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/OptionParsing.py

@@ -287,8 +287,8 @@ follow_group.add_option(
     default=[],
     help="""\
 Do not follow to that module name even if used, or if a package name, to the
-whole package in any case, overrides all other options. Can be given multiple
-times. Default empty.""",
+whole package in any case, overrides all other options. This can also contain
+patterns, e.g. "*.tests". Can be given multiple times. Default empty.""",
 )
 
 follow_group.add_option(
@@ -454,6 +454,18 @@ data_group.add_option(
 Output the data files found for a given package name. Default not done.""",
 )
 
+data_group.add_option(
+    "--include-raw-dir",
+    action="append",
+    dest="raw_dirs",
+    metavar="DIRECTORY",
+    default=[],
+    help="""\
+Include raw directories completely in the distribution. This is
+recursive. Check '--include-data-dir' to use the sane option.
+Default empty.""",
+)
+
 
 del data_group
 
@@ -1288,9 +1300,7 @@ os_group.add_option(
     action="store_true",
     dest="disable_console",
     default=None,
-    help="""\
-When compiling for Windows or macOS, disable the console window and create a GUI
-application. Defaults to off.""",
+    help=SUPPRESS_HELP,
 )
 
 os_group.add_option(
@@ -1298,10 +1308,22 @@ os_group.add_option(
     action="store_false",
     dest="disable_console",
     default=None,
+    help=SUPPRESS_HELP,
+)
+
+os_group.add_option(
+    "--windows-console-mode",
+    action="store",
+    dest="console_mode",
+    choices=("force", "disable", "attach"),
+    metavar="CONSOLE_MODE",
+    default=None,
     help="""\
-When compiling for Windows or macOS, enable the console window and create a console
-application. This disables hints from certain modules, e.g. "PySide" that suggest
-to disable it. Defaults to true.""",
+Select console mode to use. Default mode is 'force' and creates a
+console window if not available, i.e. the program was started from one. With
+'disable' it doesn't create or use a console. With 'attach' an existing console
+will be used for outputs. Default is 'force'.
+""",
 )
 
 os_group.add_option(

nuitka/Options.py

@@ -325,6 +325,28 @@ when '--onefile' is not specified."""
         )
 
 
+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
 
@@ -628,11 +650,6 @@ 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 = getFileVersionTuple()
     # Catch all the things, don't want any interface, pylint: disable=broad-except
@@ -751,24 +768,10 @@ 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."
-            )
-
-        src, dst = data_dir.split("=", 1)
-
-        if os.path.isabs(dst):
-            Tracing.options_logger.sysexit(
-                "Error, must specify relative target path for data dir, not '%s' as in '%s'."
-                % (dst, data_dir)
-            )
+        _checkDataDirOptionValue(data_dir=data_dir, option_name="--include-data-dir")
 
-        if not os.path.isdir(src):
-            Tracing.options_logger.sysexit(
-                "Error, must specify existing source data directory, not '%s' as in '%s'."
-                % (dst, data_dir)
-            )
+    for data_dir in options.raw_dirs:
+        _checkDataDirOptionValue(data_dir=data_dir, option_name="--include-raw-dir")
 
     for pattern in getShallFollowExtraFilePatterns():
         if os.path.isdir(pattern):
@@ -820,11 +823,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(
@@ -895,8 +901,27 @@ version '%s' instead or newer Nuitka."""
                 )
             )
 
+    if sys.version_info.releaselevel != "final":
+        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 \
@@ -1112,15 +1137,10 @@ and not with the non-debug version.
 """
         )
 
-    if (
-        isMacOS()
-        and shallCreateAppBundle()
-        and shallDisableConsoleWindow()
-        and not getMacOSIconPaths()
-    ):
+    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."""
         )
 
@@ -1139,7 +1159,7 @@ to work."""
     if (
         isWin32Windows()
         and 0x340 <= python_version < 0x380
-        and not shallDisableConsoleWindow()
+        and getWindowsConsoleMode() != "disable"
     ):
         Tracing.general.warning(
             """\
@@ -1152,6 +1172,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-module=%s"
+                    % ("force" if options.disable_console else "disable"),
+                )
+            )
+        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``"""
@@ -1658,16 +1721,13 @@ def shallDisableCompressionCacheUsage():
     return shallDisableCacheUsage("compression")
 
 
-def shallDisableConsoleWindow():
-    """:returns: None (not given), False, or True derived from ``--disable-console or ``--enable-console``"""
-    return options.disable_console
-
-
-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():

nuitka/PostProcessing.py

@@ -11,7 +11,7 @@ import sys
 
 from nuitka import Options, OutputDirectories
 from nuitka.build.DataComposerInterface import getConstantBlobFilename
-from nuitka.finalizations.FinalizeMarkups import getImportedNames
+from nuitka.ModuleRegistry import getImportedModuleNames
 from nuitka.PythonVersions import (
     getPythonABI,
     getTargetPythonDLLPath,
@@ -25,6 +25,7 @@ from nuitka.utils.FileOperations import (
     getFileContents,
     getFileSize,
     hasFilenameExtension,
+    isFilesystemEncodable,
     makePath,
     putTextFileContents,
     removeFileExecutablePermission,
@@ -285,11 +286,6 @@ def executePostProcessing():
 
     result_filename = OutputDirectories.getResultFullpath(onefile=False)
 
-    if not os.path.exists(result_filename):
-        postprocessing_logger.sysexit(
-            "Error, scons failed to create the expected file %r. " % result_filename
-        )
-
     if isWin32Windows():
         if not Options.shallMakeModule():
             if python_version < 0x300:
@@ -387,7 +383,11 @@ set NUITKA_PYTHONPATH=%(python_path)s
             "dll_directory": dll_directory,
             "python_home": sys.prefix,
             "python_path": ";".join(sys.path),
-            "exe_filename": os.path.basename(result_filename),
+            "exe_filename": os.path.basename(
+                result_filename
+                if isFilesystemEncodable(result_filename)
+                else getExternalUsePath(result_filename)
+            ),
         }
 
         putTextFileContents(cmd_filename, cmd_contents)
@@ -420,7 +420,8 @@ __name__ = ...
 """
             % {
                 "imports": "\n".join(
-                    "import %s" % module_name for module_name in getImportedNames()
+                    "import %s" % module_name
+                    for module_name in getImportedModuleNames()
                 )
             },
             encoding="utf-8",

nuitka/PythonVersions.py

@@ -31,6 +31,7 @@ def getSupportedPythonVersions():
         "3.9",
         "3.10",
         "3.11",
+        "3.12",
     )
 
 
@@ -42,7 +43,7 @@ def getNotYetSupportedPythonVersions():
 def getPartiallySupportedPythonVersions():
     """Partially supported Python versions for Nuitka."""
 
-    return ("3.12",)
+    return ()
 
 
 def getZstandardSupportingVersions():

nuitka/Serialization.py

@@ -163,7 +163,9 @@ class ConstantStreamReader(object):
         return self.pickle.load()
 
 
-class ConstantAccessor(object):
+class GlobalConstantAccessor(object):
+    __slots__ = ("constants", "constants_writer", "top_level_name")
+
     def __init__(self, data_filename, top_level_name):
         self.constants = OrderedSet()
 
@@ -171,52 +173,54 @@ class ConstantAccessor(object):
         self.top_level_name = top_level_name
 
     def getConstantCode(self, constant):
-        # Use in user code, or for constants building code itself, many
-        # constant types get special code immediately.
-        # pylint: disable=too-many-branches,too-many-statements
+        # Use in user code, or for constants building code itself, many constant
+        # types get special code immediately, and it's return driven.
+        # pylint: disable=too-many-branches,too-many-return-statements
         if constant is None:
-            key = "Py_None"
+            return "Py_None"
         elif constant is True:
-            key = "Py_True"
+            return "Py_True"
         elif constant is False:
-            key = "Py_False"
+            return "Py_False"
         elif constant is Ellipsis:
-            key = "Py_Ellipsis"
+            return "Py_Ellipsis"
         elif constant is NotImplemented:
-            key = "Py_NotImplemented"
+            return "Py_NotImplemented"
         elif constant is sys.version_info:
-            key = "Py_SysVersionInfo"
+            return "Py_SysVersionInfo"
         elif type(constant) is type:
             # TODO: Maybe make this a mapping in nuitka.Builtins
 
             if constant is None:
-                key = "(PyObject *)Py_TYPE(Py_None)"
+                return "(PyObject *)Py_TYPE(Py_None)"
             elif constant is object:
-                key = "(PyObject *)&PyBaseObject_Type"
+                return "(PyObject *)&PyBaseObject_Type"
             elif constant is staticmethod:
-                key = "(PyObject *)&PyStaticMethod_Type"
+                return "(PyObject *)&PyStaticMethod_Type"
             elif constant is classmethod:
-                key = "(PyObject *)&PyClassMethod_Type"
+                return "(PyObject *)&PyClassMethod_Type"
             elif constant is bytearray:
-                key = "(PyObject *)&PyByteArray_Type"
+                return "(PyObject *)&PyByteArray_Type"
             elif constant is enumerate:
-                key = "(PyObject *)&PyEnum_Type"
+                return "(PyObject *)&PyEnum_Type"
             elif constant is frozenset:
-                key = "(PyObject *)&PyFrozenSet_Type"
+                return "(PyObject *)&PyFrozenSet_Type"
             elif python_version >= 0x270 and constant is memoryview:
-                key = "(PyObject *)&PyMemoryView_Type"
+                return "(PyObject *)&PyMemoryView_Type"
             elif python_version < 0x300 and constant is basestring:
-                key = "(PyObject *)&PyBaseString_Type"
+                return "(PyObject *)&PyBaseString_Type"
             elif python_version < 0x300 and constant is xrange:
-                key = "(PyObject *)&PyRange_Type"
+                return "(PyObject *)&PyRange_Type"
             elif constant in builtin_anon_values:
-                key = "(PyObject *)" + builtin_anon_codes[builtin_anon_values[constant]]
+                return (
+                    "(PyObject *)" + builtin_anon_codes[builtin_anon_values[constant]]
+                )
             elif constant in builtin_exception_values_list:
-                key = "(PyObject *)PyExc_%s" % constant.__name__
+                return "(PyObject *)PyExc_%s" % constant.__name__
             elif constant is ExceptionGroup:
-                key = "(PyObject *)_PyInterpreterState_GET()->exc_state.PyExc_ExceptionGroup"
+                return "(PyObject *)_PyInterpreterState_GET()->exc_state.PyExc_ExceptionGroup"
             elif constant is BaseExceptionGroup:
-                key = "(PyObject *)PyExc_BaseExceptionGroup"
+                return "(PyObject *)PyExc_BaseExceptionGroup"
             else:
                 type_name = constant.__name__
 
@@ -225,15 +229,18 @@ class ConstantAccessor(object):
                 elif constant is str:
                     type_name = "string" if python_version < 0x300 else "unicode"
 
-                key = "(PyObject *)&Py%s_Type" % type_name.capitalize()
+                return "(PyObject *)&Py%s_Type" % type_name.capitalize()
         else:
-            key = "const_" + namifyConstant(constant)
+            return self._getConstantCode(constant)
 
-            if key not in self.constants:
-                self.constants.add(key)
-                self.constants_writer.addConstantValue(constant)
+    def _getConstantCode(self, constant):
+        key = "const_" + namifyConstant(constant)
 
-            key = "%s[%d]" % (self.top_level_name, self.constants.index(key))
+        if key not in self.constants:
+            self.constants.add(key)
+            self.constants_writer.addConstantValue(constant)
+
+        key = "%s[%d]" % (self.top_level_name, self.constants.index(key))
 
         # TODO: Make it returning, more clear.
         return key
@@ -256,6 +263,16 @@ class ConstantAccessor(object):
         return len(self.constants)
 
 
+class ConstantAccessor(GlobalConstantAccessor):
+    def _getConstantCode(self, constant):
+        constant_type = type(constant)
+
+        if constant_type is tuple and not constant:
+            return "const_tuple_empty"
+
+        return GlobalConstantAccessor._getConstantCode(self, constant)
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/Version.py

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