Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/Options.py

@@ -35,7 +35,8 @@ 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, runSpecialCommandsFromOptions
 from nuitka.PythonFlavors import (
     getPythonFlavorName,
     isAnacondaPython,
@@ -271,7 +272,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(
@@ -310,6 +311,9 @@ 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"
@@ -690,6 +694,22 @@ it before using it: '%s' (from --output-filename='%s')."""
                 % pattern
             )
 
+    for directory_name in getShallFollowExtra():
+        if not os.path.isdir(directory_name):
+            Tracing.options_logger.sysexit(
+                "Error, value '%s' given to '--include-plugin-directory' must be a directory name."
+                % directory_name
+            )
+
+        if isStandardLibraryPath(directory_name):
+            Tracing.options_logger.sysexit(
+                """\
+Error, directory '%s' given to '--include-plugin-directory' must not be a \
+standard library path. Use '--include-module' or '--include-package' \
+options instead."""
+                % pattern
+            )
+
     if options.static_libpython == "yes" and getSystemStaticLibPythonPath() is None:
         Tracing.options_logger.sysexit(
             "Error, static libpython is not found or not supported for this Python installation."
@@ -752,6 +772,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():
@@ -1007,19 +1041,6 @@ 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
@@ -1133,7 +1154,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)
@@ -1507,6 +1528,11 @@ def shallDisableBytecodeCacheUsage():
     return shallDisableCacheUsage("bytecode")
 
 
+def shallDisableCompressionCacheUsage():
+    """:returns: bool derived from ``--disable-cache=compression``"""
+    return shallDisableCacheUsage("compression")
+
+
 def shallDisableConsoleWindow():
     """:returns: None (not given), False, or True derived from ``--disable-console or ``--enable-console``"""
     return options.disable_console
@@ -1695,6 +1721,11 @@ def shallNotCompressOnefile():
     return options.onefile_no_compression
 
 
+def shallOnefileAsArchive():
+    """*bool* = ``--onefile-as-archive``"""
+    return options.onefile_as_archive
+
+
 def getIconPaths():
     """*list of str*, values of ``--windows-icon-from-ico`` and ``--linux-onefile-icon``"""
 

nuitka/Progress.py

@@ -35,6 +35,7 @@ from nuitka.utils.Utils import isWin32Windows
 # Late import and optional to be there.
 use_progress_bar = False
 tqdm = None
+colorama = None
 
 
 class NuitkaProgressBar(object):
@@ -108,7 +109,7 @@ def _getTqdmModule():
     elif tqdm is False:
         return None
     else:
-        tqdm = importFromInlineCopy("tqdm", must_exist=False)
+        tqdm = importFromInlineCopy("tqdm", must_exist=False, delete_module=True)
 
         if tqdm is None:
             try:
@@ -135,12 +136,17 @@ def _getTqdmModule():
 
 def enableProgressBar():
     global use_progress_bar  # singleton, pylint: disable=global-statement
+    global colorama  # singleton, pylint: disable=global-statement
 
     if _getTqdmModule() is not None:
         use_progress_bar = True
 
         if isWin32Windows():
-            colorama = importFromInlineCopy("colorama", must_exist=True)
+            if colorama is None:
+                colorama = importFromInlineCopy(
+                    "colorama", must_exist=True, delete_module=True
+                )
+
             colorama.init()
 
 
@@ -202,3 +208,27 @@ def wrapWithProgressBar(iterable, stage, unit):
         Tracing.progress = result
 
         return result
+
+
+@contextmanager
+def withNuitkaDownloadProgressBar(*args, **kwargs):
+    if not use_progress_bar or _getTqdmModule() is None:
+        yield
+    else:
+
+        class NuitkaDownloadProgressBar(tqdm):
+            # spell-checker: ignore bsize, tsize
+            def onProgress(self, b=1, bsize=1, tsize=None):
+                if tsize is not None:
+                    self.total = tsize
+                self.update(b * bsize - self.n)
+
+        kwargs.update(
+            disable=None,
+            leave=False,
+            dynamic_ncols=True,
+            bar_format="{desc} {percentage:3.1f}%|{bar:25}| {n_fmt}/{total_fmt}{postfix}",
+        )
+
+        with NuitkaDownloadProgressBar(*args, **kwargs) as progress_bar:
+            yield progress_bar.onProgress

nuitka/PythonFlavors.py

@@ -32,7 +32,6 @@ from nuitka.utils.FileOperations import (
     isFilenameBelowPath,
     isFilenameSameAsOrBelowPath,
 )
-from nuitka.utils.InstalledPythons import getInstalledPythonRegistryPaths
 from nuitka.utils.Utils import (
     isAndroidBasedLinux,
     isFedoraBasedLinux,
@@ -44,6 +43,7 @@ from nuitka.utils.Utils import (
 )
 
 from .PythonVersions import (
+    getInstalledPythonRegistryPaths,
     getRunningPythonDLLPath,
     getSystemPrefixPath,
     isStaticallyLinkedPython,

nuitka/PythonVersions.py

@@ -417,3 +417,64 @@ def isPythonValidCLongValue(value):
 
 def isPythonValidCLongLongValue(value):
     return _min_signed_longlong <= value <= _max_signed_longlong
+
+
+def getInstalledPythonRegistryPaths(version):
+    """Yield all Pythons as found in the Windows registry."""
+    # Windows only code,
+    # pylint: disable=I0021,import-error,redefined-builtin
+    from nuitka.__past__ import WindowsError
+
+    if str is bytes:
+        import _winreg as winreg  # pylint: disable=I0021,import-error,no-name-in-module
+    else:
+        import winreg  # pylint: disable=I0021,import-error,no-name-in-module
+
+    for hkey_branch in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER):
+        for arch_key in (0, winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY):
+            for suffix in "", "-32", "-arm64":
+                try:
+                    key = winreg.OpenKey(
+                        hkey_branch,
+                        r"SOFTWARE\Python\PythonCore\%s%s\InstallPath"
+                        % (version, suffix),
+                        0,
+                        winreg.KEY_READ | arch_key,
+                    )
+
+                    install_dir = os.path.normpath(winreg.QueryValue(key, ""))
+                except WindowsError:
+                    pass
+                else:
+                    candidate = os.path.normpath(
+                        os.path.join(install_dir, "python.exe")
+                    )
+
+                    if os.path.exists(candidate):
+                        yield candidate
+
+
+def getTkInterVersion():
+    """Get the tk-inter version or None if not installed."""
+    try:
+        if str is bytes:
+            return str(__import__("TkInter").TkVersion)
+        else:
+            return str(__import__("tkinter").TkVersion)
+    except ImportError:
+        # This should lead to no action taken ideally.
+        return None
+
+
+def getModuleLinkerLibs():
+    """Get static link libraries needed."""
+    try:
+        import sysconfig
+    except ImportError:
+        return []
+    else:
+        # static link libraries might be there, spell-checker: ignore modlibs
+        result = sysconfig.get_config_var("MODLIBS") or ""
+        result = [entry[2:] for entry in result.split() if entry.startswith("-l:")]
+
+        return result

nuitka/Tracing.py

@@ -271,6 +271,21 @@ class OurLogger(object):
         # For overload, pylint: disable=no-self-use
         my_print(message, **kwargs)
 
+    @staticmethod
+    def _warnMnemonic(mnemonic, style, output_function):
+        if mnemonic.startswith("http"):
+            url = mnemonic
+            extra_prefix = ""
+        else:
+            url = "https://nuitka.net/info/%s.html" % mnemonic
+            extra_prefix = "Complex topic! "
+
+        output_function(
+            """    %sMore information can be found at %s%s"""
+            % (extra_prefix, _getEnableStyleCode("link"), url),
+            style=style,
+        )
+
     def warning(self, message, style="red", mnemonic=None):
         if mnemonic is not None:
             from .Options import shallDisplayWarningMnemonic
@@ -303,11 +318,7 @@ class OurLogger(object):
         self.my_print(formatted_message, style=style, file=sys.stderr)
 
         if mnemonic is not None:
-            self.warning(
-                """    Complex topic! More information can be found at %shttps://nuitka.net/info/%s.html"""
-                % (_getEnableStyleCode("link"), mnemonic),
-                style=style,
-            )
+            self._warnMnemonic(mnemonic, style=style, output_function=self.warning)
 
     def sysexit(
         self, message="", style=None, mnemonic=None, exit_code=1, reporting=False
@@ -334,11 +345,7 @@ class OurLogger(object):
                 )
 
         if mnemonic is not None:
-            self.warning(
-                """    Complex topic! More information can be found at %shttps://nuitka.net/info/%s.html"""
-                % (_getEnableStyleCode("link"), mnemonic),
-                style=style,
-            )
+            self._warnMnemonic(mnemonic, style=style, output_function=self.warning)
 
         if reporting:
             raise ReportingSystemExit(exit_code=exit_code, exit_message=message)
@@ -354,7 +361,7 @@ class OurLogger(object):
     def isQuiet(self):
         return is_quiet or self.is_quiet
 
-    def info(self, message, style=None):
+    def info(self, message, style=None, mnemonic=None):
         if not self.isQuiet():
             if self.name:
                 message = "%s:INFO: %s" % (self.name, message)
@@ -362,6 +369,9 @@ class OurLogger(object):
             style = style or self.base_style
             self.my_print(message, style=style)
 
+            if mnemonic is not None:
+                self._warnMnemonic(mnemonic, style=style, output_function=self.info)
+
 
 class FileLogger(OurLogger):
     def __init__(self, name, quiet=False, base_style=None, file_handle=None):
@@ -382,13 +392,16 @@ class FileLogger(OurLogger):
     def isFileOutput(self):
         return self.file_handle is not None
 
-    def info(self, message, style=None):
+    def info(self, message, style=None, mnemonic=None):
         if not self.isQuiet() or self.file_handle:
             message = "%s:INFO: %s" % (self.name, message)
 
             style = style or self.base_style
             self.my_print(message, style=style)
 
+            if mnemonic is not None:
+                self._warnMnemonic(mnemonic, style=style, output_function=self.my_print)
+
     def debug(self, message, style=None):
         if self.file_handle:
             message = "%s:DEBUG: %s" % (self.name, message)

nuitka/TreeXML.py

@@ -71,13 +71,13 @@ try:
 
     Element = xml.etree.ElementTree.Element
 
-    def xml_tostring(tree, indent=True):
+    def xml_tostring(tree, indent=True, encoding=None):
         if indent:
             _indent(tree)
         elif not indent:
             _dedent(tree)
 
-        return xml_module.tostring(tree)
+        return xml_module.tostring(tree, encoding=encoding)
 
 except ImportError:
     xml_module = None
@@ -94,12 +94,12 @@ except ImportError:
 #     xml_writer = None
 
 
-def toBytes(tree, indent=True):
-    return xml_tostring(tree, indent=indent)
+def toBytes(tree, indent=True, encoding=None):
+    return xml_tostring(tree, indent=indent, encoding=encoding)
 
 
 def toString(tree):
-    result = toBytes(tree)
+    result = toBytes(tree, encoding="utf8")
 
     if str is not bytes:
         result = result.decode("utf8")

nuitka/Variables.py

@@ -25,7 +25,7 @@ module variable references.
 
 from abc import abstractmethod
 
-from nuitka.__past__ import getMetaClassBase, iterItems
+from nuitka.__past__ import iterItems
 from nuitka.nodes.shapes.BuiltinTypeShapes import tshape_dict
 from nuitka.nodes.shapes.StandardShapes import tshape_unknown
 from nuitka.utils import Utils
@@ -34,11 +34,12 @@ from nuitka.utils.InstanceCounters import (
     counted_init,
     isCountingInstances,
 )
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 complete = False
 
 
-class Variable(getMetaClassBase("Variable")):
+class Variable(getMetaClassBase("Variable", require_slots=True)):
     # We will need all of these attributes, since we track the global
     # state and cache some decisions as attributes. TODO: But in some
     # cases, part of the these might be moved to the outside.
@@ -390,21 +391,26 @@ class ModuleVariable(Variable):
 
 
 class TempVariable(Variable):
-    __slots__ = ()
+    __slots__ = ("variable_type",)
 
-    def __init__(self, owner, variable_name):
+    def __init__(self, owner, variable_name, variable_type):
         Variable.__init__(self, owner=owner, variable_name=variable_name)
 
-    def getDescription(self):
-        return "temp variable '%s'" % self.variable_name
+        # TODO: Push this later down to Variable itself.
+        self.variable_type = variable_type
 
     @staticmethod
     def isTempVariable():
         return True
 
-    @staticmethod
-    def getVariableType():
-        return "object"
+    def getVariableType(self):
+        return self.variable_type
+
+    def isTempVariableBool(self):
+        return self.variable_type == "bool"
+
+    def getDescription(self):
+        return "temp variable '%s'" % self.variable_name
 
     def initVariable(self, trace_collection):
         """Initialize variable in trace collection state."""
@@ -417,21 +423,6 @@ class TempVariable(Variable):
         # lost to outside star imports or exec/eval uses.
 
 
-class TempVariableBool(TempVariable):
-    __slots__ = ()
-
-    def getDescription(self):
-        return "temp bool variable '%s'" % self.variable_name
-
-    @staticmethod
-    def isTempVariableBool():
-        return True
-
-    @staticmethod
-    def getVariableType():
-        return "bool"
-
-
 class LocalsDictVariable(Variable):
     __slots__ = ()
 

nuitka/Version.py

@@ -20,7 +20,7 @@
 """
 
 version_string = """\
-Nuitka V1.8.6
+Nuitka V1.9.3
 Copyright (C) 2023 Kay Hayen."""
 
 
@@ -32,14 +32,13 @@ def getNuitkaVersion():
     return version_string.split()[1][1:]
 
 
-def getNuitkaVersionTuple():
-    """Return Nuitka version as a string.
+def parseNuitkaVersionToTuple(version):
+    """Return Nuitka version as a tuple.
 
-    This can also not be used for precise comparisons, last one might contain "rc"
+    This can also not be used for precise comparisons, even with rc versions,
+    but it's not actually a version.
     """
 
-    version = getNuitkaVersion()
-
     if "rc" in version:
         rc_number = int(version[version.find("rc") + 2 :] or "0")
         version = version[: version.find("rc")]
@@ -58,6 +57,17 @@ def getNuitkaVersionTuple():
     return tuple(result)
 
 
+def getNuitkaVersionTuple():
+    """Return Nuitka version as a tuple.
+
+    This can also not be used for precise comparisons, even with rc versions,
+    but it's not actually a version. The format is used what is used for
+    "__compiled__" values.
+    """
+
+    return parseNuitkaVersionToTuple(version=getNuitkaVersion())
+
+
 def getNuitkaVersionYear():
     """The year of Nuitka copyright for use in generations."""
 

nuitka/__main__.py

@@ -86,6 +86,14 @@ def main():
     if os.environ.get("PYTHONHASHSEED", "-1") != "0":
         needs_re_execution = True
 
+    # The frozen stdlib modules of Python 3.11 are less compatible than the ones
+    # of Nuitka, so prefer those.
+    if sys.version_info >= (3, 11):
+        from _imp import _frozen_module_names
+
+        if "os" in _frozen_module_names():
+            needs_re_execution = True
+
     # Avoid doing it when running in Visual Code.
     if needs_re_execution and "debugpy" in sys.modules:
         needs_re_execution = False
@@ -135,6 +143,13 @@ def main():
         setPthImportedPackages(ast.literal_eval(os.environ["NUITKA_PTH_IMPORTED"]))
         del os.environ["NUITKA_PTH_IMPORTED"]
 
+    if "NUITKA_USER_SITE" in os.environ:
+        from nuitka.utils.Distributions import setUserSiteDirectory
+
+        setUserSiteDirectory(ast.literal_eval(os.environ["NUITKA_USER_SITE"]))
+
+        del os.environ["NUITKA_USER_SITE"]
+
     # Now the real main program of Nuitka can take over.
     from nuitka import MainControl  # isort:skip
 

nuitka/__past__.py

@@ -27,7 +27,7 @@ be a "in (str, unicode)" rather than making useless version checks.
 
 import pkgutil
 import sys
-from abc import ABCMeta
+from hashlib import md5 as _md5
 
 # pylint: disable=invalid-name,self-assigning-variable
 
@@ -118,7 +118,7 @@ if str is bytes:
 else:
 
     def to_byte(value):
-        assert type(value) is int and 0 <= value < 256
+        assert type(value) is int and 0 <= value < 256, value
         return bytes((value,))
 
     def from_byte(value):
@@ -137,19 +137,6 @@ except ImportError:
     UnionType = None
 
 
-def getMetaClassBase(meta_class_prefix):
-    """For Python2/3 compatible source, we create a base class that has the metaclass
-    used and doesn't require making a choice.
-    """
-
-    class MetaClass(ABCMeta):
-        pass
-
-    MetaClassBase = MetaClass("%sMetaClassBase" % meta_class_prefix, (object,), {})
-
-    return MetaClassBase
-
-
 if str is bytes:
     try:
         import subprocess32 as subprocess
@@ -181,15 +168,26 @@ else:
 
 
 try:
-    ExceptionGroup = ExceptionGroup
+    ExceptionGroup = ExceptionGroup  # pylint: disable=I0021,redefined-builtin
 except NameError:
     ExceptionGroup = None
 
 try:
-    BaseExceptionGroup = BaseExceptionGroup
+    BaseExceptionGroup = BaseExceptionGroup  # pylint: disable=I0021,redefined-builtin
 except NameError:
     BaseExceptionGroup = None
 
+try:
+    _md5()
+except ValueError:
+    # On FIPS compliant systems, checks might be enabled that require
+    # this parameter to be set.
+    def md5(value=b""):
+        return _md5(value, usedforsecurity=False)
+
+else:
+    md5 = _md5
+
 # For PyLint to be happy.
 assert long
 assert unicode