Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__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
@@ -37,7 +23,7 @@ from nuitka.utils.FileOperations import (
     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 +33,7 @@ IncludedEntryPoint = collections.namedtuple(
         "kind",
         "source_path",
         "dest_path",
+        "module_name",
         "package_name",
         "executable",
         "reason",
@@ -56,7 +43,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)
@@ -70,23 +57,30 @@ def _makeIncludedEntryPoint(
     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=os.path.normpath(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 +93,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 +151,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 +164,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 +182,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 +193,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 +229,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 +315,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.

nuitka/freezer/Standalone.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 and copy files for standalone mode.
 
 This is expected to work for macOS, Windows, and Linux. Other things like
@@ -26,7 +12,11 @@ import os
 
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.Errors import NuitkaForbiddenDLLEncounter
-from nuitka.importing.Importing import getPythonUnpackedSearchPath
+from nuitka.importing.Importing import (
+    getPythonUnpackedSearchPath,
+    locateModule,
+)
+from nuitka.importing.StandardLibrary import isStandardLibraryPath
 from nuitka.Options import (
     isShowProgress,
     shallNotStoreDependsExeCachedResults,
@@ -38,6 +28,12 @@ from nuitka.Progress import (
     reportProgressBar,
     setupProgressBar,
 )
+from nuitka.PythonFlavors import (
+    getHomebrewInstallPath,
+    isAnacondaPython,
+    isHomebrewPython,
+)
+from nuitka.PythonVersions import getSystemPrefixPath
 from nuitka.Tracing import general, inclusion_logger
 from nuitka.utils.FileOperations import areInSamePaths, isFilenameBelowPath
 from nuitka.utils.SharedLibraries import copyDllFile, setSharedLibraryRPATH
@@ -56,8 +52,12 @@ from .DllDependenciesMacOS import (
     fixupBinaryDLLPathsMacOS,
 )
 from .DllDependenciesPosix import detectBinaryPathDLLsPosix
-from .DllDependenciesWin32 import detectBinaryPathDLLsWindowsDependencyWalker
-from .IncludedEntryPoints import addIncludedEntryPoint, makeDllEntryPoint
+from .DllDependenciesWin32 import detectBinaryPathDLLsWin32
+from .IncludedEntryPoints import (
+    addIncludedEntryPoint,
+    getIncludedExtensionModule,
+    makeDllEntryPoint,
+)
 
 
 def checkFreezingModuleSet():
@@ -135,7 +135,7 @@ def _detectBinaryDLLs(
             message="Running 'depends.exe' for %s took %%.2f seconds" % binary_filename,
             decider=isShowProgress,
         ):
-            return detectBinaryPathDLLsWindowsDependencyWalker(
+            return detectBinaryPathDLLsWin32(
                 is_main_executable=is_main_executable,
                 source_dir=source_dir,
                 original_dir=os.path.dirname(original_filename),
@@ -227,10 +227,32 @@ def copyDllsUsed(dist_dir, standalone_entry_points):
     )
 
 
+def _reduceToPythonPath(used_dlls):
+    inside_paths = getPythonUnpackedSearchPath()
+
+    if isAnacondaPython():
+        inside_paths.insert(0, getSystemPrefixPath())
+
+    if isHomebrewPython():
+        inside_paths.insert(0, getHomebrewInstallPath())
+
+    def decideInside(dll_filename):
+        return any(
+            isFilenameBelowPath(path=inside_path, filename=dll_filename)
+            for inside_path in inside_paths
+        )
+
+    used_dlls = set(
+        dll_filename for dll_filename in used_dlls if decideInside(dll_filename)
+    )
+
+    return used_dlls
+
+
 def _detectUsedDLLs(standalone_entry_point, source_dir):
     binary_filename = standalone_entry_point.source_path
     try:
-        used_dlls = _detectBinaryDLLs(
+        used_dll_paths = _detectBinaryDLLs(
             is_main_executable=standalone_entry_point.kind == "executable",
             source_dir=source_dir,
             original_filename=standalone_entry_point.source_path,
@@ -240,57 +262,74 @@ def _detectUsedDLLs(standalone_entry_point, source_dir):
             update_cache=not shallNotStoreDependsExeCachedResults(),
         )
     except NuitkaForbiddenDLLEncounter:
-        inclusion_logger.info("Not including forbidden DLL '%s'." % binary_filename)
+        inclusion_logger.info(
+            "Not including due to forbidden DLL '%s'." % binary_filename
+        )
     else:
         # Plugins generally decide if they allow dependencies from the outside
         # based on the package name.
-        allow_outside_dependencies = Plugins.decideAllowOutsideDependencies(
-            standalone_entry_point.package_name
-        )
 
-        # TODO: Command line option maybe
-        if allow_outside_dependencies is None:
-            allow_outside_dependencies = True
+        if standalone_entry_point.module_name is not None and used_dll_paths:
+            module_name, module_filename, _kind, finding = locateModule(
+                standalone_entry_point.module_name, parent_package=None, level=0
+            )
 
-        if not allow_outside_dependencies:
-            inside_paths = getPythonUnpackedSearchPath()
+            # Make sure we are not surprised here.
+            assert (
+                module_name == standalone_entry_point.module_name
+            ), standalone_entry_point.module_name
+            assert finding == "absolute", standalone_entry_point.module_name
 
-            def decideInside(dll_filename):
-                return any(
-                    isFilenameBelowPath(path=inside_path, filename=dll_filename)
-                    for inside_path in inside_paths
+            if isStandardLibraryPath(module_filename):
+                allow_outside_dependencies = True
+            else:
+                allow_outside_dependencies = Plugins.decideAllowOutsideDependencies(
+                    standalone_entry_point.module_name
                 )
 
-            used_dlls = set(
-                dll_filename for dll_filename in used_dlls if decideInside(dll_filename)
-            )
+            if allow_outside_dependencies is False:
+                used_dll_paths = _reduceToPythonPath(used_dll_paths)
 
         # Allow plugins can prevent inclusion, this may discard things from used_dlls.
         removed_dlls = Plugins.removeDllDependencies(
-            dll_filename=binary_filename, dll_filenames=used_dlls
+            dll_filename=binary_filename, dll_filenames=used_dll_paths
         )
-        used_dlls = tuple(OrderedSet(used_dlls) - OrderedSet(removed_dlls))
-
-        for used_dll in used_dlls:
-            # TODO: If used by a DLL from the same folder, put it there,
-            # otherwise top level, but for now this is limited to the case where
-            # it is required that way only, because it broke other things.
-            if standalone_entry_point.package_name == "openvino" and areInSamePaths(
-                standalone_entry_point.source_path, used_dll
+        used_dll_paths = tuple(OrderedSet(used_dll_paths) - OrderedSet(removed_dlls))
+
+        for used_dll_path in used_dll_paths:
+            extension_standalone_entry_point = getIncludedExtensionModule(used_dll_path)
+            if extension_standalone_entry_point is not None:
+                # Sometimes an extension module is used like a DLL, make sure to
+                # remove it as a DLL then, there is no value in keeping those. Need
+                # to keep it's destination path from that extension module then.
+                dest_path = extension_standalone_entry_point.dest_path
+            elif (
+                standalone_entry_point.package_name is not None
+                and standalone_entry_point.package_name.hasOneOfNamespaces(
+                    "openvino",
+                    "av",
+                )
+                and areInSamePaths(standalone_entry_point.source_path, used_dll_path)
             ):
+                # TODO: If used by a DLL from the same folder, put it there,
+                # otherwise top level, but for now this is limited to a few cases
+                # where required that way (openvino) or known to be good only (av),
+                # because it broke other things. spell-checker: ignore openvino
+
                 dest_path = os.path.normpath(
                     os.path.join(
                         os.path.dirname(standalone_entry_point.dest_path),
-                        os.path.basename(used_dll),
+                        os.path.basename(used_dll_path),
                     )
                 )
             else:
-                dest_path = os.path.basename(used_dll)
+                dest_path = os.path.basename(used_dll_path)
 
             dll_entry_point = makeDllEntryPoint(
                 logger=inclusion_logger,
-                source_path=used_dll,
+                source_path=used_dll_path,
                 dest_path=dest_path,
+                module_name=standalone_entry_point.module_name,
                 package_name=standalone_entry_point.package_name,
                 reason="Used by '%s'" % standalone_entry_point.dest_path,
             )
@@ -313,3 +352,19 @@ def detectUsedDLLs(standalone_entry_points, source_dir):
         )
 
     closeProgressBar()
+
+
+#     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/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """

nuitka/importing/IgnoreListing.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
+
+
 """ Ignore listing of modules that are not found, but probably that's acceptable.
 
 """
@@ -445,3 +431,19 @@ please report this as a bug."""
         )
 
     return module_name.hasOneOfNamespaces(getModuleIgnoreList())
+
+
+#     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.