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

nuitka/freezer/IncludedEntryPoints.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
+
+
 """ Included entry points for standalone mode.
 
 This keeps track of entry points for standalone. These should be extension
@@ -31,13 +17,14 @@ from nuitka.Options import getShallNotIncludeDllFilePatterns, isShowInclusion
 from nuitka.Tracing import general, inclusion_logger
 from nuitka.utils.FileOperations import (
     areSamePaths,
+    getNormalizedPath,
     getReportPath,
     hasFilenameExtension,
     haveSameFileContents,
     isRelativePath,
 )
 from nuitka.utils.Importing import getSharedLibrarySuffix
-from nuitka.utils.ModuleNames import ModuleName
+from nuitka.utils.ModuleNames import ModuleName, checkModuleName
 from nuitka.utils.SharedLibraries import getDLLVersion
 
 IncludedEntryPoint = collections.namedtuple(
@@ -47,6 +34,7 @@ IncludedEntryPoint = collections.namedtuple(
         "kind",
         "source_path",
         "dest_path",
+        "module_name",
         "package_name",
         "executable",
         "reason",
@@ -56,7 +44,7 @@ IncludedEntryPoint = collections.namedtuple(
 
 # Since inheritance is not a thing with namedtuple, have factory functions
 def _makeIncludedEntryPoint(
-    logger, kind, source_path, dest_path, package_name, reason, executable
+    logger, kind, source_path, dest_path, module_name, package_name, reason, executable
 ):
     if package_name is not None:
         package_name = ModuleName(package_name)
@@ -64,29 +52,36 @@ def _makeIncludedEntryPoint(
     assert type(executable) is bool, executable
 
     # Make sure outside code uses sane paths only.
-    assert source_path == os.path.normpath(source_path), source_path
+    assert source_path == getNormalizedPath(source_path), source_path
 
     # Avoid obvious mistakes, these files won't be binaries or DLL ever, right?
     assert not hasFilenameExtension(path=source_path, extensions=(".qml", ".json"))
 
     return IncludedEntryPoint(
-        logger,
-        kind,
-        source_path,
-        os.path.normpath(dest_path),
-        package_name,
-        executable,
-        reason,
+        logger=logger,
+        kind=kind,
+        source_path=source_path,
+        dest_path=getNormalizedPath(dest_path),
+        module_name=module_name,
+        package_name=package_name,
+        executable=executable,
+        reason=reason,
     )
 
 
 def _makeDllOrExeEntryPoint(
-    logger, kind, source_path, dest_path, package_name, reason, executable
+    logger, kind, source_path, dest_path, module_name, package_name, reason, executable
 ):
     assert type(dest_path) not in (tuple, list)
     assert type(source_path) not in (tuple, list)
     assert isRelativePath(dest_path), dest_path
     assert ".dist" not in dest_path, dest_path
+    if module_name is not None:
+        assert checkModuleName(module_name), module_name
+        module_name = ModuleName(module_name)
+    if package_name is not None:
+        assert checkModuleName(package_name), package_name
+        package_name = ModuleName(package_name)
 
     if not os.path.isfile(source_path):
         logger.sysexit(
@@ -99,42 +94,52 @@ def _makeDllOrExeEntryPoint(
         kind=kind,
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=executable,
     )
 
 
-def makeExtensionModuleEntryPoint(logger, source_path, dest_path, package_name, reason):
+def makeExtensionModuleEntryPoint(
+    logger, source_path, dest_path, module_name, package_name, reason
+):
     return _makeDllOrExeEntryPoint(
         logger=logger,
         kind="extension",
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=False,
     )
 
 
-def makeDllEntryPoint(logger, source_path, dest_path, package_name, reason):
+def makeDllEntryPoint(
+    logger, source_path, dest_path, module_name, package_name, reason
+):
     return _makeDllOrExeEntryPoint(
         logger=logger,
         kind="dll",
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=False,
     )
 
 
-def makeExeEntryPoint(logger, source_path, dest_path, package_name, reason):
+def makeExeEntryPoint(
+    logger, source_path, dest_path, module_name, package_name, reason
+):
     return _makeDllOrExeEntryPoint(
         logger=logger,
         kind="exe",
         source_path=source_path,
         dest_path=dest_path,
+        module_name=module_name,
         package_name=package_name,
         reason=reason,
         executable=True,
@@ -147,6 +152,7 @@ def makeMainExecutableEntryPoint(dest_path):
         kind="executable",
         source_path=dest_path,
         dest_path=os.path.basename(dest_path),
+        module_name=None,
         package_name=None,
         reason="main binary",
         executable=True,
@@ -159,6 +165,7 @@ def _makeIgnoredEntryPoint(entry_point):
         kind=entry_point.kind + "_ignored",
         source_path=entry_point.source_path,
         dest_path=entry_point.dest_path,
+        module_name=entry_point.module_name,
         package_name=entry_point.package_name,
         reason=entry_point.reason,
         executable=entry_point.executable,
@@ -176,7 +183,7 @@ def _getTopLevelPackageName(package_name):
 
 
 def _warnNonIdenticalEntryPoints(entry_point1, entry_point2):
-    # Well know case, where they duplicate all the DLLs, seems to work well
+    # Well know cases, where they duplicate all the DLLs, seems to work well
     # enough to not report this. TODO: When we are adding to the report, it
     # ought to be still added. spell-checker: ignore scipy
     if frozenset(
@@ -187,10 +194,27 @@ def _warnNonIdenticalEntryPoints(entry_point1, entry_point2):
     ) == frozenset(("numpy", "scipy")):
         return
 
+    if frozenset(
+        (
+            _getTopLevelPackageName(entry_point1.package_name),
+            _getTopLevelPackageName(entry_point2.package_name),
+        )
+    ) == frozenset(("av", "cv2")):
+        return
+
+    def _describe(entry_point):
+        if entry_point.package_name:
+            return "'%s' of package '%s'" % (
+                entry_point.source_path,
+                entry_point.package_name,
+            )
+        else:
+            return "'%s'" % entry_point.source_path
+
     inclusion_logger.warning(
         """\
-Ignoring non-identical DLLs for '%s', '%s' different from '%s'. Using first one and hoping for the best."""
-        % (entry_point1.dest_path, entry_point1.source_path, entry_point2.source_path)
+Ignoring non-identical DLLs for %s, %s different from %s. Using first one and hoping for the best."""
+        % (entry_point1.dest_path, _describe(entry_point1), _describe(entry_point2))
     )
 
 
@@ -206,6 +230,13 @@ def addIncludedEntryPoint(entry_point):
             if areSamePaths(
                 entry_point.source_path, standalone_entry_point.source_path
             ):
+                if (
+                    standalone_entry_point.kind == "extension"
+                    and entry_point.kind == "dll"
+                ):
+                    entry_point = _makeIgnoredEntryPoint(entry_point)
+                    break
+
                 return
 
             if isShowInclusion():
@@ -285,19 +316,53 @@ def setMainEntryPoint(binary_filename):
 
 
 def addExtensionModuleEntryPoint(module):
+    dest_path = module.getFullName().asPath()
+
+    if module.isExtensionModulePackage():
+        dest_path = os.path.join(dest_path, "__init__")
+
+    dest_path += getSharedLibrarySuffix(preferred=False)
+
     standalone_entry_points.append(
         makeExtensionModuleEntryPoint(
             logger=general,
             source_path=module.getFilename(),
-            dest_path=module.getFullName().asPath()
-            + getSharedLibrarySuffix(preferred=False),
+            dest_path=dest_path,
+            module_name=module.getFullName(),
             package_name=module.getFullName().getPackageName(),
-            reason="required extension module for CPython library startup"
-            if module.isTechnical()
-            else "used extension module",
+            reason=(
+                "required extension module for CPython library startup"
+                if module.isTechnical()
+                else "used extension module"
+            ),
         )
     )
 
 
+def getIncludedExtensionModule(source_path):
+    for standalone_entry_point in standalone_entry_points:
+        if standalone_entry_point.kind == "extension":
+            if areSamePaths(source_path, standalone_entry_point.source_path):
+                return standalone_entry_point
+
+    return None
+
+
 def getStandaloneEntryPoints():
     return tuple(standalone_entry_points)
+
+
+#     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/freezer/Onefile.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
+
+
 """ Pack distribution folders into a single file.
 
 """
@@ -27,7 +13,6 @@ from nuitka import Options, OutputDirectories
 from nuitka.build.SconsInterface import (
     asBoolStr,
     cleanSconsDirectory,
-    getSconsDataPath,
     runScons,
     setCommonSconsOptions,
 )
@@ -69,19 +54,17 @@ def packDistFolderToOnefile(dist_dir):
     Plugins.onOnefileFinished(onefile_output_filename)
 
 
-def _runOnefileScons(onefile_compression):
+def _runOnefileScons(onefile_compression, onefile_archive):
     source_dir = OutputDirectories.getSourceDirectoryPath(onefile=True)
 
     # Let plugins do their thing for onefile mode too.
     Plugins.writeExtraCodeFiles(onefile=True)
 
     options = {
-        "result_name": OutputDirectories.getResultBasePath(onefile=True),
         "result_exe": OutputDirectories.getResultFullpath(onefile=True),
         "source_dir": source_dir,
         "debug_mode": asBoolStr(Options.is_debug),
         "trace_mode": asBoolStr(Options.shallTraceExecution()),
-        "nuitka_src": getSconsDataPath(),
         "onefile_splash_screen": asBoolStr(
             Options.getWindowsSplashScreen() is not None
         ),
@@ -93,6 +76,7 @@ def _runOnefileScons(onefile_compression):
     env_values["_NUITKA_ONEFILE_TEMP_BOOL"] = "1" if isOnefileTempDirMode() else "0"
     env_values["_NUITKA_ONEFILE_COMPRESSION_BOOL"] = "1" if onefile_compression else "0"
     env_values["_NUITKA_ONEFILE_BUILD_BOOL"] = "1" if onefile_compression else "0"
+    env_values["_NUITKA_ONEFILE_ARCHIVE_BOOL"] = "1" if onefile_archive else "0"
 
     # Allow plugins to build definitions.
     env_values.update(Plugins.getBuildDefinitions())
@@ -173,6 +157,8 @@ def runOnefileCompressor(
             onefile_output_filename=onefile_output_filename,
             start_binary=start_binary,
             expect_compression=compressor_python is not None,
+            as_archive=Options.shallOnefileAsArchive(),
+            use_compression_cache=not Options.shallDisableCompressionCacheUsage(),
             file_checksums=file_checksums,
             win_path_sep=win_path_sep,
             low_memory=Options.isLowMemory(),
@@ -206,6 +192,8 @@ def runOnefileCompressor(
                     str(file_checksums),
                     str(win_path_sep),
                     str(Options.isLowMemory()),
+                    str(Options.shallOnefileAsArchive()),
+                    str(not Options.shallDisableCompressionCacheUsage()),
                 ],
                 shell=False,
             )
@@ -243,6 +231,7 @@ def packDistFolderToOnefileBootstrap(onefile_output_filename, dist_dir):
     # Create the bootstrap binary for unpacking.
     _runOnefileScons(
         onefile_compression=compressor_python is not None,
+        onefile_archive=Options.shallOnefileAsArchive(),
     )
 
     if isWin32Windows():
@@ -281,7 +270,28 @@ def packDistFolderToOnefileBootstrap(onefile_output_filename, dist_dir):
     if Options.isRemoveBuildDir():
         onefile_logger.info("Removing onefile build directory '%s'." % source_dir)
 
-        removeDirectory(path=source_dir, ignore_errors=False)
+        removeDirectory(
+            path=source_dir,
+            logger=onefile_logger,
+            ignore_errors=False,
+            extra_recommendation=None,
+        )
         assert not os.path.exists(source_dir)
     else:
         onefile_logger.info("Keeping onefile build directory '%s'." % source_dir)
+
+
+#     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.