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

nuitka/OutputDirectories.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
+
+
 """ Directories and paths to for output of Nuitka.
 
 There are two major outputs, the build directory *.build and for
@@ -27,7 +13,12 @@ this.
 import os
 
 from nuitka import Options
-from nuitka.utils.FileOperations import hasFilenameExtension, makePath
+from nuitka.utils.FileOperations import (
+    addFilenameExtension,
+    getNormalizedPath,
+    makePath,
+    putTextFileContents,
+)
 from nuitka.utils.Importing import getSharedLibrarySuffix
 from nuitka.utils.Utils import isWin32OrPosixWindows, isWin32Windows
 
@@ -44,10 +35,19 @@ def setMainModule(main_module):
     _main_module = main_module
 
 
+def hasMainModule():
+    """For reporting to check if there is anything to talk about."""
+    return _main_module is not None
+
+
+def getMainModule():
+    return _main_module
+
+
 def getSourceDirectoryPath(onefile=False):
     """Return path inside the build directory."""
 
-    # Distinct build folders for oneline mode.
+    # Distinct build folders for onefile mode.
     if onefile:
         suffix = ".onefile-build"
     else:
@@ -59,6 +59,11 @@ def getSourceDirectoryPath(onefile=False):
 
     makePath(result)
 
+    git_ignore_filename = os.path.join(result, ".gitignore")
+
+    if not os.path.exists(git_ignore_filename):
+        putTextFileContents(filename=git_ignore_filename, contents="*")
+
     return result
 
 
@@ -131,12 +136,15 @@ def getResultFullpath(onefile):
         elif output_filename is not None:
             result = output_filename
         elif not isWin32OrPosixWindows() and not Options.shallCreateAppBundle():
-            result += ".bin"
+            result = addFilenameExtension(result, ".bin")
 
-        if isWin32OrPosixWindows() and not hasFilenameExtension(result, ".exe"):
-            result += ".exe"
+        if isWin32OrPosixWindows():
+            result = addFilenameExtension(result, ".exe")
 
-    return result
+        if not isWin32OrPosixWindows() and Options.isOnefileMode() and not onefile:
+            result = addFilenameExtension(result, ".bin")
+
+    return getNormalizedPath(result)
 
 
 def getResultRunFilename(onefile):
@@ -158,3 +166,19 @@ def getPgoRunExecutable():
 
 def getPgoRunInputFilename():
     return getPgoRunExecutable() + ".nuitka-pgo"
+
+
+#     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.

nuitka/PostProcessing.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
+
+
 """ Postprocessing tasks for create binaries or modules.
 
 """
@@ -25,27 +11,27 @@ import sys
 
 from nuitka import Options, OutputDirectories
 from nuitka.build.DataComposerInterface import getConstantBlobFilename
-from nuitka.finalizations.FinalizeMarkups import getImportedNames
-from nuitka.PythonVersions import (
-    getPythonABI,
-    getTargetPythonDLLPath,
-    python_version,
-    python_version_str,
-)
+from nuitka.ModuleRegistry import getImportedModuleNames
+from nuitka.PythonVersions import getTargetPythonDLLPath, python_version
 from nuitka.Tracing import postprocessing_logger
 from nuitka.utils.Execution import wrapCommandForDebuggerForExec
 from nuitka.utils.FileOperations import (
-    getExternalUsePath,
     getFileContents,
+    getFileSize,
+    hasFilenameExtension,
+    makeFilesystemEncodable,
     makePath,
     putTextFileContents,
     removeFileExecutablePermission,
 )
 from nuitka.utils.Images import convertImageToIconFormat
+from nuitka.utils.Importing import importFromInlineCopy
 from nuitka.utils.MacOSApp import createPlistInfoFile
 from nuitka.utils.SharedLibraries import (
     callInstallNameTool,
     cleanupHeaderForAndroid,
+    getOtoolDependencyOutput,
+    parseOtoolListingOutput,
 )
 from nuitka.utils.Utils import isAndroidBasedLinux, isMacOS, isWin32Windows
 from nuitka.utils.WindowsResources import (
@@ -116,7 +102,7 @@ def _addWindowsIconFromIcons(onefile):
 
     result_filename = OutputDirectories.getResultFullpath(onefile=onefile)
 
-    for icon_spec in Options.getIconPaths():
+    for icon_spec in Options.getWindowsIconPaths():
         if "#" in icon_spec:
             icon_path, icon_index = icon_spec.rsplit("#", 1)
             icon_index = int(icon_index)
@@ -124,9 +110,7 @@ def _addWindowsIconFromIcons(onefile):
             icon_path = icon_spec
             icon_index = None
 
-        icon_path = os.path.normcase(icon_path)
-
-        if not icon_path.endswith(".ico"):
+        if not hasFilenameExtension(icon_path, ".ico"):
             postprocessing_logger.info(
                 "File '%s' is not in Windows icon format, converting to it." % icon_path
             )
@@ -241,13 +225,13 @@ def executePostProcessingResources(manifest, onefile):
 
     if (
         Options.getWindowsVersionInfoStrings()
-        or Options.getProductVersion()
-        or Options.getFileVersion()
+        or Options.getProductVersionTuple()
+        or Options.getFileVersionTuple()
     ):
         addVersionInfoResource(
             string_values=Options.getWindowsVersionInfoStrings(),
-            product_version=Options.getProductVersion(),
-            file_version=Options.getFileVersion(),
+            product_version=Options.getProductVersionTuple(),
+            file_version=Options.getFileVersionTuple(),
             file_date=(0, 0),
             is_exe=not Options.shallMakeModule(),
             result_filename=result_filename,
@@ -295,15 +279,11 @@ def executePostProcessing():
     These are in part required steps, not usable after failure.
     """
 
-    # Lots of cases to deal with, pylint: disable=too-many-branches
+    # Lots of cases to deal with,
+    # pylint: disable=too-many-branches,too-many-locals,too-many-statements
 
     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:
@@ -335,10 +315,26 @@ def executePostProcessing():
         and not Options.shallMakeModule()
         and not Options.shallUseStaticLibPython()
     ):
-        python_abi_version = python_version_str + getPythonABI()
-        python_dll_filename = "libpython" + python_abi_version + ".dylib"
-        python_lib_path = os.path.join(sys.prefix, "lib")
-        python_dll_path = os.path.join(python_lib_path, python_dll_filename)
+        for dependency in parseOtoolListingOutput(
+            getOtoolDependencyOutput(result_filename, [])
+        ):
+            if os.path.basename(dependency).lower().startswith(("python", "libpython")):
+                python_dll_filename = dependency
+                break
+        else:
+            postprocessing_logger.sysexit(
+                """
+Error, expected 'libpython dependency not found. Please report the bug."""
+            )
+
+        python_lib_path = os.path.dirname(python_dll_filename)
+        python_dll_path = python_dll_filename
+
+        if not os.path.exists(python_lib_path):
+            python_lib_path = os.path.join(sys.prefix, "lib")
+            python_dll_path = os.path.join(
+                python_lib_path, os.path.basename(python_dll_filename)
+            )
 
         # Note: For CPython, and potentially others, the rpath for the Python
         # library needs to be set, so it will be detected as a dependency
@@ -350,10 +346,6 @@ def executePostProcessing():
                     python_dll_filename,
                     python_dll_path,
                 ),
-                (
-                    "@rpath/Python3.framework/Versions/%s/Python3" % python_version_str,
-                    python_dll_path,
-                ),
             ),
             id_path=None,
             rpath=python_lib_path,
@@ -381,8 +373,6 @@ def executePostProcessing():
 
     # Might have to create a CMD file, potentially with debugger run.
     if Options.shallCreateCmdFileForExecution():
-        dll_directory = getExternalUsePath(os.path.dirname(getTargetPythonDLLPath()))
-
         cmd_filename = OutputDirectories.getResultRunFilename(onefile=False)
 
         cmd_contents = """
@@ -390,48 +380,112 @@ def executePostProcessing():
 rem This script was created by Nuitka to execute '%(exe_filename)s' with Python DLL being found.
 set PATH=%(dll_directory)s;%%PATH%%
 set PYTHONHOME=%(python_home)s
+set NUITKA_PYTHONPATH=%(python_path)s
 %(debugger_call)s"%%~dp0%(exe_filename)s" %%*
 """ % {
-            "debugger_call": (" ".join(wrapCommandForDebuggerForExec()) + " ")
-            if Options.shallRunInDebugger()
-            else "",
-            "dll_directory": dll_directory,
-            "python_home": sys.prefix,
-            "exe_filename": os.path.basename(result_filename),
+            "debugger_call": (
+                (" ".join(wrapCommandForDebuggerForExec()) + " ")
+                if Options.shallRunInDebugger()
+                else ""
+            ),
+            "dll_directory": makeFilesystemEncodable(
+                os.path.dirname(getTargetPythonDLLPath())
+            ),
+            "python_home": makeFilesystemEncodable(sys.prefix),
+            "python_path": ";".join(makeFilesystemEncodable(e) for e in sys.path),
+            "exe_filename": os.path.basename(makeFilesystemEncodable(result_filename)),
         }
 
         putTextFileContents(cmd_filename, cmd_contents)
 
     # Create a ".pyi" file for created modules
     if Options.shallMakeModule() and Options.shallCreatePyiFile():
-        pyi_filename = OutputDirectories.getResultBasePath() + ".pyi"
-
-        putTextFileContents(
-            filename=pyi_filename,
-            contents="""\
-# This file was generated by Nuitka and describes the types of the
-# created shared library.
+        if Options.shallCreatePyiFileContainStubs():
+            if python_version >= 0x300:
+                stubgen = importFromInlineCopy("stubgen", must_exist=False)
+                stubgen_reason = "Stubs included by default"
+            else:
+                stubgen = None
+                stubgen_reason = "Python2 is not supported for stubs"
+        else:
+            stubgen = None
+            stubgen_reason = "Stubs were disabled"
 
-# At this time it lists only the imports made and can be used by the
-# tools that bundle libraries, including Nuitka itself. For instance
-# standalone mode usage of the created library will need it.
+        imported_module_names = getImportedModuleNames()
 
-# In the future, this will also contain type information for values
-# in the module, so IDEs will use this. Therefore please include it
-# when you make software releases of the extension module that it
-# describes.
+        contents = """\
+# This file was generated by Nuitka
+"""
 
-%(imports)s
+        if stubgen is not None:
+            try:
+                stubs = stubgen.generate_stub_from_source(
+                    source_code=OutputDirectories.getMainModule().getSourceCode(),
+                    output_file_path=None,
+                    text_only=True,
+                )
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                postprocessing_logger.warning(
+                    "Stub generation with stubgen failed due to: '%s'. Please report the module code in an issue report."
+                    % (str(e))
+                )
 
-# This is not Python source even if it looks so. Make it clear for
-# now. This was decided by PEP 484 designers.
-__name__ = ...
+                if Options.is_debug:
+                    raise
 
-"""
-            % {
-                "imports": "\n".join(
-                    "import %s" % module_name for module_name in getImportedNames()
+                stubs = None
+                stubgen_reason = (
+                    "Stub generation failed due to error, please report the issue."
                 )
-            },
-            encoding="utf-8",
+        else:
+            stubs = None
+
+        stubs = "# %s\n%s" % (stubgen_reason, "" if stubs is None else stubs)
+
+        contents += "\n" + stubs + "\n"
+
+        contents += "__name__ = ..."
+
+        imported_module_names = getImportedModuleNames()
+
+        # Meaningless, TODO: Potentially others could be listed here too.
+        if "__future__" in imported_module_names:
+            imported_module_names.remove("__future__")
+
+        contents += "\n" * 4
+
+        if imported_module_names:
+            contents += "# Modules used internally, to allow implicit dependencies to be seen:\n"
+            contents += "\n".join(
+                "import %s" % module_name for module_name in getImportedModuleNames()
+            )
+        else:
+            contents += (
+                "# No other modules used internally, no implicit dependencies.\n"
+            )
+
+        pyi_filename = OutputDirectories.getResultBasePath() + ".pyi"
+        putTextFileContents(pyi_filename, contents, encoding="utf-8")
+
+    if isWin32Windows() and getFileSize(result_filename) > 2**30 * 1.8:
+        postprocessing_logger.warning(
+            """\
+The created compiled binary is larger than 1.8GB and therefore may not be
+executable by Windows due to its limitations."""
         )
+
+
+#     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.

nuitka/Progress.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
+
+
 """ Progress bars in Nuitka.
 
 This is responsible for wrapping the rendering of progress bar and emitting tracing
@@ -25,16 +11,29 @@ to the user while it's being displayed.
 from contextlib import contextmanager
 
 from nuitka import Tracing
+from nuitka.PythonVersions import isPythonWithGil
 from nuitka.Tracing import general
 from nuitka.utils.Importing import importFromInlineCopy
 from nuitka.utils.ThreadedExecutor import RLock
 from nuitka.utils.Utils import isWin32Windows
 
-# spell-checker: ignore tqdm
+# spell-checker: ignore tqdm,ncols
 
 # Late import and optional to be there.
 use_progress_bar = False
 tqdm = None
+colorama = None
+
+_uses_threading = False
+
+
+def enableThreading():
+    """Inform about threading being used."""
+
+    # Singleton, pylint: disable=global-statement
+    global _uses_threading
+
+    _uses_threading = True
 
 
 class NuitkaProgressBar(object):
@@ -54,12 +53,13 @@ class NuitkaProgressBar(object):
         self.tqdm = tqdm(
             iterable=iterable,
             initial=self.progress,
-            total=max(self.total, self.min_total)
-            if self.min_total is not None
-            else None,
+            total=(
+                max(self.total, self.min_total) if self.min_total is not None else None
+            ),
             unit=unit,
             disable=None,
             leave=False,
+            dynamic_ncols=True,
             bar_format="{desc}{percentage:3.1f}%|{bar:25}| {n_fmt}/{total_fmt}{postfix}",
         )
 
@@ -95,7 +95,10 @@ class NuitkaProgressBar(object):
 
     @contextmanager
     def withExternalWritingPause(self):
-        with self.tqdm.external_write_mode():
+        # spell-checker: ignore nolock
+        with self.tqdm.external_write_mode(
+            nolock=not _uses_threading or isPythonWithGil()
+        ):
             yield
 
 
@@ -107,7 +110,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:
@@ -134,12 +137,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()
 
 
@@ -201,3 +209,44 @@ 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:
+                    # False alarm when tqdm is not installed, pylint: disable=I0021,attribute-defined-outside-init
+                    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
+
+
+#     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.