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

nuitka/utils/Hashing.py

@@ -1,30 +1,15 @@
-#     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
+
+
 """ Module for working with hashes in Nuitka.
 
 Offers support for hashing incrementally and files esp. without having
 to read their contents.
 """
 
-import hashlib
 from binascii import crc32
 
-from nuitka.__past__ import unicode
+from nuitka.__past__ import md5, unicode
 
 from .FileOperations import openTextFile
 
@@ -44,27 +29,42 @@ class HashBase(object):
                 self.updateFromBytes(value)
             elif type(value) is bytes:
                 self.updateFromBytes(value)
+            elif type(value) is dict:
+                self.updateFromBytes(b"dict")
+                self.updateFromValues(*list(value.items()))
+            elif type(value) is tuple:
+                self.updateFromBytes(b"tuple")
+                self.updateFromValues(*value)
+            elif type(value) is list:
+                self.updateFromBytes(b"list")
+                self.updateFromValues(*value)
             else:
                 assert False, type(value)
 
-    def updateFromFile(self, filename):
-        # TODO: Read in chunks
+    def updateFromFile(self, filename, line_filter=None):
         with openTextFile(filename, "rb") as input_file:
-            self.updateFromFileHandle(input_file)
+            self.updateFromFileHandle(input_file, line_filter=line_filter)
+
+    def updateFromFileHandle(self, file_handle, line_filter=None):
+        if line_filter is None:
+            while 1:
+                chunk = file_handle.read(1024 * 1024)
 
-    def updateFromFileHandle(self, file_handle):
-        while 1:
-            chunk = file_handle.read(1024 * 64)
+                if not chunk:
+                    break
 
-            if not chunk:
-                break
+                self.updateFromBytes(chunk)
+        else:
+            for line in file_handle:
+                line = line_filter(line)
 
-            self.updateFromBytes(chunk)
+                if line is not None:
+                    self.updateFromBytes(line)
 
 
 class Hash(HashBase):
     def __init__(self):
-        self.hash = hashlib.md5()
+        self.hash = md5()
 
     def updateFromBytes(self, value):
         self.hash.update(value)
@@ -76,9 +76,9 @@ class Hash(HashBase):
         return self.hash.hexdigest()
 
 
-def getFileContentsHash(filename, as_string=True):
+def getFileContentsHash(filename, as_string=True, line_filter=None):
     result = Hash()
-    result.updateFromFile(filename=filename)
+    result.updateFromFile(filename=filename, line_filter=line_filter)
 
     if as_string:
         return result.asHexDigest()
@@ -86,11 +86,14 @@ def getFileContentsHash(filename, as_string=True):
         return result.asDigest()
 
 
-def getStringHash(value):
+def getStringHash(value, as_string=True):
     result = Hash()
     result.updateFromValues(value)
 
-    return result.asHexDigest()
+    if as_string:
+        return result.asHexDigest()
+    else:
+        return result.asDigest()
 
 
 def getHashFromValues(*values):
@@ -109,3 +112,22 @@ class HashCRC32(HashBase):
 
     def asDigest(self):
         return self.hash
+
+    def asHexDigest(self):
+        return hex(self.hash)[2:]
+
+
+#     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/utils/Images.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
+
+
 """ Handling of images, esp. format conversions for icons.
 
 """
@@ -36,10 +22,15 @@ def checkIconUsage(logger, icon_path):
     if needs_conversion:
         try:
             import imageio  # pylint: disable=I0021,import-error,unused-import
-        except ImportError:
+        except ImportError as e:
+            from nuitka import Options
+
+            if Options.is_debug:
+                logger.info("Exception importing 'imageio' is %s" % repr(e))
+
             logger.sysexit(
                 """\
-Need to install 'imageio' to let automatically convert the non native \
+Need to install 'imageio' to automatically convert the non native \
 icon image (%s) in file in '%s'."""
                 % (icon_format[1:].upper(), icon_path)
             )
@@ -64,3 +55,19 @@ def convertImageToIconFormat(logger, image_filename, converted_icon_filename):
         )
 
     imageio.imwrite(converted_icon_filename, image)
+
+
+#     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/utils/Importing.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
+
+
 """ Helper to import a file as a module.
 
 Used for Nuitka plugins and for test code.
@@ -26,6 +12,8 @@ import sys
 from nuitka.PythonVersions import python_version
 from nuitka.Tracing import general
 
+from .InlineCopies import getInlineCopyFolder
+from .ModuleNames import ModuleName
 from .Utils import withNoDeprecationWarning
 
 
@@ -53,7 +41,7 @@ def _importFilePy3OldWay(filename):
 
 def importFilePy2(filename):
     """Import a file for Python version 2."""
-    import imp
+    import imp  # Python2 only, pylint: disable=I0021,import-error
 
     basename = os.path.splitext(os.path.basename(filename))[0]
     return imp.load_source(basename, filename)
@@ -89,7 +77,7 @@ def getSharedLibrarySuffixes():
 
     if _shared_library_suffixes is None:
         if python_version < 0x300:
-            import imp
+            import imp  # Python2 only, pylint: disable=I0021,import-error
 
             _shared_library_suffixes = []
 
@@ -163,25 +151,15 @@ def _importFromFolder(logger, module_name, path, must_exist, message):
         del sys.path[0]
 
 
-def importFromInlineCopy(module_name, must_exist):
-    """Import a module from the inline copy stage."""
+_deleted_modules = {}
 
-    folder_name = os.path.normpath(
-        os.path.join(
-            os.path.dirname(__file__), "..", "build", "inline_copy", module_name
-        )
-    )
 
-    candidate_27 = folder_name + "_27"
-    candidate_35 = folder_name + "_35"
+def importFromInlineCopy(module_name, must_exist, delete_module=False):
+    """Import a module from the inline copy stage."""
 
-    # Use specific versions if needed.
-    if python_version < 0x300 and os.path.exists(candidate_27):
-        folder_name = candidate_27
-    elif python_version < 0x360 and os.path.exists(candidate_35):
-        folder_name = candidate_35
+    folder_name = getInlineCopyFolder(module_name)
 
-    return _importFromFolder(
+    module = _importFromFolder(
         module_name=module_name,
         path=folder_name,
         must_exist=must_exist,
@@ -189,6 +167,19 @@ def importFromInlineCopy(module_name, must_exist):
         logger=general,
     )
 
+    if delete_module and module_name in sys.modules:
+        delete_module_names = set([module_name])
+
+        for m in sys.modules:
+            if m.startswith(module_name + "."):
+                delete_module_names.add(m)
+
+        for delete_module_name in delete_module_names:
+            _deleted_modules[delete_module_name] = sys.modules[delete_module_name]
+            del sys.modules[delete_module_name]
+
+    return module
+
 
 _compile_time_modules = {}
 
@@ -220,16 +211,39 @@ def importFromCompileTime(module_name, must_exist):
 
 def isBuiltinModuleName(module_name):
     if python_version < 0x300:
-        import imp as _imp
+        import imp as _imp  # Python2 only, pylint: disable=I0021,import-error
     else:
         import _imp
 
-    return _imp.is_builtin(module_name)
+    result = _imp.is_builtin(module_name) or _imp.is_frozen(module_name)
+
+    # Some frozen modules are not actually in that list, e.g.
+    # "importlib._bootstrap_external" on Python3.10 doesn't report to
+    # "_imp.is_frozen()" above, so we check if it's already loaded and from the
+    # "FrozenImporter" by name.
+    if result is False and module_name in sys.modules:
+        module = sys.modules[module_name]
+
+        if hasattr(module, "__loader__"):
+            loader = module.__loader__
+
+            try:
+                result = loader.__name__ == "FrozenImporter"
+            except AttributeError:
+                pass
+
+    return result
+
+
+# Have a set for quicker lookups, and we cannot have "__main__" in there.
+builtin_module_names = set(
+    module_name for module_name in sys.builtin_module_names if module_name != "__main__"
+)
 
 
 def getModuleFilenameSuffixes():
     if python_version < 0x3C0:
-        import imp
+        import imp  # Older Python only, pylint: disable=I0021,import-error
 
         for suffix, _mode, module_type in imp.get_suffixes():
             if module_type == imp.C_EXTENSION:
@@ -251,3 +265,71 @@ def getModuleFilenameSuffixes():
             yield suffix, "PY_SOURCE"
         for suffix in importlib.machinery.BYTECODE_SUFFIXES:
             yield suffix, "PY_COMPILED"
+
+
+def getModuleNameAndKindFromFilenameSuffix(module_filename):
+    """Given a filename, decide the module name and kind.
+
+    Args:
+        module_name - file path of the module
+    Returns:
+        Tuple with the name of the module basename, and the kind of the
+        module derived from the file suffix. Can be None, None if is is not a
+        known file suffix.
+    Notes:
+        This doesn't handle packages at all.
+    """
+    if module_filename.endswith(".py"):
+        return ModuleName(os.path.basename(module_filename)[:-3]), "py"
+
+    if module_filename.endswith(".pyc"):
+        return ModuleName(os.path.basename(module_filename)[:-4]), "pyc"
+
+    for suffix in getSharedLibrarySuffixes():
+        if module_filename.endswith(suffix):
+            return (
+                ModuleName(os.path.basename(module_filename)[: -len(suffix)]),
+                "extension",
+            )
+
+    return None, None
+
+
+def hasPackageDirFilename(path):
+    path = os.path.basename(path)
+
+    for suffix in (".py",) + getSharedLibrarySuffixes():
+        candidate = "__init__" + suffix
+
+        if candidate == path:
+            return True
+
+    return False
+
+
+def getPackageDirFilename(path):
+    assert os.path.isdir(path)
+
+    for suffix in getSharedLibrarySuffixes() + (".py",):
+        candidate = os.path.join(path, "__init__" + suffix)
+
+        if os.path.isfile(candidate):
+            return candidate
+
+    return None
+
+
+#     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/utils/InlineCopies.py

@@ -0,0 +1,52 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Policies for locating inline copies."""
+
+import os
+
+from nuitka.PythonVersions import python_version
+
+
+def _getInlineCopyBaseFolder():
+    """Base folder for inline copies."""
+    return os.path.normpath(
+        os.path.join(os.path.dirname(__file__), "..", "build", "inline_copy")
+    )
+
+
+def getInlineCopyFolder(module_name):
+    """Get the inline copy folder for a given name."""
+    folder_name = os.path.join(_getInlineCopyBaseFolder(), module_name)
+
+    candidate_27 = folder_name + "_27"
+    candidate_35 = folder_name + "_35"
+
+    # Use specific versions if needed.
+    if python_version < 0x300 and os.path.exists(candidate_27):
+        folder_name = candidate_27
+    elif python_version < 0x360 and os.path.exists(candidate_35):
+        folder_name = candidate_35
+
+    return folder_name
+
+
+def getDownloadCopyFolder():
+    """Get the inline copy folder for a given name."""
+    return os.path.join(_getInlineCopyBaseFolder(), "downloads", "pip")
+
+
+#     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/utils/InstalledPythons.py

@@ -1,28 +1,17 @@
-#     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
+
+
 """ Provide installed Pythons with module availability checks. """
 
 import os
 import sys
 
-from nuitka.__past__ import WindowsError  # pylint: disable=I0021,redefined-builtin
 from nuitka.containers.OrderedSets import OrderedSet
-from nuitka.PythonVersions import python_version_str
+from nuitka.PythonFlavors import isAnacondaPython, isMSYS2MingwPython
+from nuitka.PythonVersions import (
+    getInstalledPythonRegistryPaths,
+    python_version_str,
+)
 
 from .Execution import (
     NuitkaCalledProcessError,
@@ -55,11 +44,34 @@ class InstalledPython(object):
         return int(major) * 256 + int(minor) * 16
 
     def isAnacondaPython(self):
-        # TODO: This may not yet going to work really
+        if self.python_exe == sys.executable:
+            return isAnacondaPython()
+
+        # TODO: May not yet work really.
         return os.path.exists(
             os.path.join(os.path.dirname(self.python_exe), "..", "conda-meta")
         )
 
+    def isMSYS2MingwPython(self):
+        if self.python_exe == sys.executable:
+            return isMSYS2MingwPython()
+
+        # TODO: May not yet work really.
+        return (
+            os.path.exists(
+                os.path.join(os.path.dirname(self.python_exe), "..", "..", "msys2.ini")
+            )
+            and os.path.basename(os.path.dirname(self.python_exe)) == "mingw64"
+        )
+
+    def getPreferredPackageType(self):
+        if self.isAnacondaPython():
+            return "conda"
+        elif self.isMSYS2MingwPython():
+            return "pacman"
+        else:
+            return "pip"
+
     # Necessary for Python 2.7, otherwise SyntaxError is given on exec.
     @staticmethod
     def _exec(code, context):
@@ -124,38 +136,6 @@ class InstalledPython(object):
 _installed_pythons = {}
 
 
-def getInstalledPythonRegistryPaths(python_version):
-    """Yield all Pythons as found in the Windows registry."""
-    # Windows only code, pylint: disable=I0021,import-error,undefined-variable
-    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"
-                        % (python_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 _getPythonInstallPathsWindows(python_version):
     """Find Python installation on Windows.
 
@@ -181,37 +161,51 @@ def _getPythonInstallPathsWindows(python_version):
 
         seen.add(candidate)
 
-    for candidate in getInstalledPythonRegistryPaths(python_version=python_version):
+    for candidate in getInstalledPythonRegistryPaths(python_version):
         if candidate not in seen:
             seen.add(candidate)
             yield candidate
 
 
-def findPythons(python_version):
+def findPythons(python_version, module_name=None, module_version=None):
     """Find all Python installations for a specific version."""
 
-    if python_version in _installed_pythons:
-        return _installed_pythons[python_version]
-
-    result = OrderedSet()
-
-    if python_version == python_version_str:
-        result.add(
-            InstalledPython(python_exe=sys.executable, python_version=python_version)
-        )
-
-    if isWin32Windows():
-        result.update(
-            InstalledPython(python_exe=python_exe, python_version=python_version)
-            for python_exe in _getPythonInstallPathsWindows(python_version)
+    if python_version not in _installed_pythons:
+        result = OrderedSet()
+
+        if python_version == python_version_str:
+            result.add(
+                InstalledPython(
+                    python_exe=sys.executable, python_version=python_version
+                )
+            )
+
+        if isWin32Windows():
+            result.update(
+                InstalledPython(python_exe=python_exe, python_version=python_version)
+                for python_exe in _getPythonInstallPathsWindows(python_version)
+            )
+
+        candidate = getExecutablePath("python" + python_version)
+        if candidate is not None:
+            result.add(
+                InstalledPython(python_exe=candidate, python_version=python_version)
+            )
+
+        _installed_pythons[python_version] = result
+
+    return tuple(
+        sorted(
+            (
+                candidate
+                for candidate in _installed_pythons[python_version]
+                if candidate.checkUsability(
+                    module_name=module_name, module_version=module_version
+                )
+            ),
+            key=lambda c: c.getPythonExe(),
         )
-
-    candidate = getExecutablePath("python" + python_version)
-    if candidate is not None:
-        result.add(InstalledPython(python_exe=candidate, python_version=python_version))
-
-    _installed_pythons[python_version] = result
-    return result
+    )
 
 
 def findInstalledPython(python_versions, module_name, module_version):
@@ -242,3 +236,19 @@ def findInstalledPython(python_versions, module_name, module_version):
                     return candidate
 
     return None
+
+
+#     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.