je-editor 0.0.57__py3-none-any.whl → 0.0.59__py3-none-any.whl

venv/Lib/site-packages/PyInstaller/utils/win32/winmanifest.py

@@ -1,1083 +0,0 @@
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013-2022, PyInstaller Development Team.
-#
-# Distributed under the terms of the GNU General Public License (version 2
-# or later) with exception for distributing the bootloader.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#
-# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
-#-----------------------------------------------------------------------------
-
-# Development notes kept for documentation purposes.
-#
-# Currently not implemented in the Manifest class:
-# * Validation (only very basic sanity checks are currently in place)
-# * comClass, typelib, comInterfaceProxyStub and windowClass child elements of the file element
-# * comInterfaceExternalProxyStub and windowClass child elements of the assembly element
-# * Application Configuration File and Multilanguage User Interface (MUI) support when searching for assembly files
-#
-# Isolated Applications and Side-by-side Assemblies:
-# http://msdn.microsoft.com/en-us/library/dd408052%28VS.85%29.aspx
-#
-# Changelog:
-# 2009-12-17  fix: small glitch in toxml / toprettyxml methods (xml declaration wasn't replaced when a different
-#                  encoding than UTF-8 was used)
-#             chg: catch xml.parsers.expat.ExpatError and re-raise as ManifestXMLParseError
-#             chg: support initialize option in parse method also
-#
-# 2009-12-13  fix: fixed os import
-#             fix: skip invalid / empty dependent assemblies
-#
-# 2009-08-21  fix: Corrected assembly searching sequence for localized assemblies
-#             fix: Allow assemblies with no dependent files
-#
-# 2009-07-31  chg: Find private assemblies even if unversioned
-#             add: Manifest.same_id method to check if two manifests have the same assemblyIdentity
-#
-# 2009-07-30  fix: Potential failure in File.calc_hash method if hash algorithm not supported
-#             add: Publisher configuration (policy) support when searching for assembly files
-#             fix: Private assemblies are now actually found if present (and no shared assembly exists)
-#             add: Python 2.3 compatibility (oldest version supported by pyinstaller)
-#
-# 2009-07-28  chg: Code cleanup, removed a bit of redundancy
-#             add: silent mode (set silent attribute on module)
-#             chg: Do not print messages in silent mode
-#
-# 2009-06-18  chg: Use glob instead of regular expression in Manifest.find_files
-#
-# 2009-05-04  fix: Don't fail if manifest has empty description
-#             fix: Manifests created by the toxml, toprettyxml, writexml or writeprettyxml methods are now correctly
-#                  recognized by Windows, which expects the XML declaration to be ordered version-encoding-standalone
-#                  (standalone being optional)
-#             add: 'encoding' keyword argument in toxml, toprettyxml, writexml and writeprettyxml methods
-#             chg: UpdateManifestResourcesFromXML and UpdateManifestResourcesFromXMLFile: set resource name depending on
-#                  file type ie. exe or dll
-#             fix: typo in __main__: UpdateManifestResourcesFromDataFile
-#                  should have been UpdateManifestResourcesFromXMLFile
-#
-# 2009-03-21  First version
-"""
-Create, parse and write MS Windows Manifest files. Find files which are part of an assembly, by searching shared and
-private assemblies. Update or add manifest resources in Win32 PE files.
-
-Commandline usage:
-winmanifest.py <dstpath> <xmlpath>
-Updates or adds manifest <xmlpath> as resource in Win32 PE file <dstpath>.
-"""
-
-import hashlib
-import os
-import sys
-import xml
-from glob import glob
-from xml.dom import Node, minidom
-from xml.dom.minidom import Document, Element
-
-from PyInstaller import compat
-from PyInstaller import log as logging
-from PyInstaller.utils.win32 import winresource
-
-logger = logging.getLogger(__name__)
-
-LANGUAGE_NEUTRAL_NT5 = "x-ww"
-LANGUAGE_NEUTRAL_NT6 = "none"
-RT_MANIFEST = 24
-
-Document.aChild = Document.appendChild
-Document.cE = Document.createElement
-Document.cT = Document.createTextNode
-Document.getEByTN = Document.getElementsByTagName
-Element.aChild = Element.appendChild
-Element.getA = Element.getAttribute
-Element.getEByTN = Element.getElementsByTagName
-Element.remA = Element.removeAttribute
-Element.setA = Element.setAttribute
-
-
-def getChildElementsByTagName(self, tagName):
-    """
-    Return child elements of type tagName if found, else [].
-    """
-    result = []
-    for child in self.childNodes:
-        if isinstance(child, Element):
-            if child.tagName == tagName:
-                result.append(child)
-    return result
-
-
-def getFirstChildElementByTagName(self, tagName):
-    """
-    Return the first element of type tagName if found, else None.
-    """
-    for child in self.childNodes:
-        if isinstance(child, Element):
-            if child.tagName == tagName:
-                return child
-    return None
-
-
-Document.getCEByTN = getChildElementsByTagName
-Document.getFCEByTN = getFirstChildElementByTagName
-Element.getCEByTN = getChildElementsByTagName
-Element.getFCEByTN = getFirstChildElementByTagName
-
-
-class _Dummy:
-    pass
-
-
-if winresource:
-    _File = winresource.File
-else:
-    _File = _Dummy
-
-
-class File(_File):
-    """
-    A file referenced by an assembly inside a manifest.
-    """
-    def __init__(
-        self,
-        filename="",
-        hashalg=None,
-        hash=None,
-        comClasses=None,
-        typelibs=None,
-        comInterfaceProxyStubs=None,
-        windowClasses=None
-    ):
-        if winresource:
-            winresource.File.__init__(self, filename)
-        else:
-            self.filename = filename
-        self.name = os.path.basename(filename)
-        if hashalg:
-            self.hashalg = hashalg.upper()
-        else:
-            self.hashalg = None
-        if os.path.isfile(filename) and hashalg and hashlib and hasattr(hashlib, hashalg.lower()):
-            self.calc_hash()
-        else:
-            self.hash = hash
-        self.comClasses = comClasses or []  # TODO: implement
-        self.typelibs = typelibs or []  # TODO: implement
-        self.comInterfaceProxyStubs = comInterfaceProxyStubs or []  # TODO: implement
-        self.windowClasses = windowClasses or []  # TODO: implement
-
-    def calc_hash(self, hashalg=None):
-        """
-        Calculate the hash of the file.
-
-        Will be called automatically from the constructor if the file exists and hashalg is given (and supported),
-        but may also be called manually e.g. to update the hash if the file has changed.
-        """
-        with open(self.filename, "rb") as fd:
-            buf = fd.read()
-        if hashalg:
-            self.hashalg = hashalg.upper()
-        self.hash = getattr(hashlib, self.hashalg.lower())(buf).hexdigest()
-
-    def find(self, searchpath):
-        logger.info("Searching for file %s", self.name)
-        fn = os.path.join(searchpath, self.name)
-        if os.path.isfile(fn):
-            logger.info("Found file %s", fn)
-            return fn
-        else:
-            logger.warning("No such file %s", fn)
-            return None
-
-
-class InvalidManifestError(Exception):
-    pass
-
-
-class ManifestXMLParseError(InvalidManifestError):
-    pass
-
-
-class Manifest:
-    # Manifests:
-    # http://msdn.microsoft.com/en-us/library/aa375365%28VS.85%29.aspx
-    """
-    Manifest constructor.
-
-    To build a basic manifest for your application:
-      mf = Manifest(type='win32', name='YourAppName', language='*', processorArchitecture='x86', version=[1, 0, 0, 0])
-
-    To write the XML to a manifest file:
-      mf.writexml("YourAppName.exe.manifest")
-    or
-      mf.writeprettyxml("YourAppName.exe.manifest")
-    """
-    def __init__(
-        self,
-        manifestType="assembly",
-        manifestVersion=None,
-        noInheritable=False,
-        noInherit=False,
-        type_=None,
-        name=None,
-        language=None,
-        processorArchitecture=None,
-        version=None,
-        publicKeyToken=None,
-        description=None,
-        requestedExecutionLevel=None,
-        uiAccess=None,
-        dependentAssemblies=None,
-        files=None,
-        comInterfaceExternalProxyStubs=None
-    ):
-        self.filename = None
-        self.optional = None
-        self.manifestType = manifestType
-        self.manifestVersion = manifestVersion or [1, 0]
-        self.noInheritable = noInheritable
-        self.noInherit = noInherit
-        self.type = type_
-        self.name = name
-        self.language = language
-        self.processorArchitecture = processorArchitecture
-        self.version = version
-        self.publicKeyToken = publicKeyToken
-        # publicKeyToken: a 16-character hexadecimal string that represents the last 8 bytes of the SHA-1 hash of the
-        # public key under which the assembly is signed. The public key used to sign the catalog must be 2048 bits or
-        # greater. Required for all shared side-by-side assemblies.
-        # http://msdn.microsoft.com/en-us/library/aa375692(VS.85).aspx
-        self.applyPublisherPolicy = None
-        self.description = None
-        self.requestedExecutionLevel = requestedExecutionLevel
-        self.uiAccess = uiAccess
-        self.dependentAssemblies = dependentAssemblies or []
-        self.bindingRedirects = []
-        self.files = files or []
-        self.comInterfaceExternalProxyStubs = comInterfaceExternalProxyStubs or []  # TODO: implement
-
-    def __eq__(self, other):
-        if isinstance(other, Manifest):
-            return self.toxml() == other.toxml()
-        if isinstance(other, str):
-            return self.toxml() == other
-        return False
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __repr__(self):
-        return repr(self.toxml())
-
-    def add_dependent_assembly(
-        self,
-        manifestVersion=None,
-        noInheritable=False,
-        noInherit=False,
-        type_=None,
-        name=None,
-        language=None,
-        processorArchitecture=None,
-        version=None,
-        publicKeyToken=None,
-        description=None,
-        requestedExecutionLevel=None,
-        uiAccess=None,
-        dependentAssemblies=None,
-        files=None,
-        comInterfaceExternalProxyStubs=None
-    ):
-        """
-        Shortcut for self.dependentAssemblies.append(Manifest(*args, **kwargs))
-        """
-        self.dependentAssemblies.append(
-            Manifest(
-                manifestVersion,
-                noInheritable,
-                noInherit,
-                type_,
-                name,
-                language,
-                processorArchitecture,
-                version,
-                publicKeyToken,
-                description,
-                requestedExecutionLevel,
-                uiAccess,
-                dependentAssemblies,
-                files,
-                comInterfaceExternalProxyStubs,
-            )
-        )
-        if self.filename:
-            # Enable search for private assembly by assigning bogus filename (only the directory has to be correct).
-            self.dependentAssemblies[-1].filename = ":".join((self.filename, name))
-
-    def add_file(
-        self,
-        name="",
-        hashalg="",
-        hash="",
-        comClasses=None,
-        typelibs=None,
-        comInterfaceProxyStubs=None,
-        windowClasses=None
-    ):
-        """
-        Shortcut for manifest.files.append
-        """
-        self.files.append(File(name, hashalg, hash, comClasses, typelibs, comInterfaceProxyStubs, windowClasses))
-
-    @classmethod
-    def get_winsxs_dir(cls):
-        return os.path.join(compat.getenv("SystemRoot"), "WinSxS")
-
-    @classmethod
-    def get_manifest_dir(cls):
-        winsxs = cls.get_winsxs_dir()
-        if not os.path.isdir(winsxs):
-            logger.warning("No such dir %s", winsxs)
-        manifests = os.path.join(winsxs, "Manifests")
-        if not os.path.isdir(manifests):
-            logger.warning("No such dir %s", manifests)
-        return manifests
-
-    @classmethod
-    def get_policy_dir(cls):
-        winsxs = os.path.join(compat.getenv("SystemRoot"), "WinSxS")
-        if sys.getwindowsversion() < (6,):
-            # Windows XP
-            pcfiles = os.path.join(winsxs, "Policies")
-            if not os.path.isdir(pcfiles):
-                logger.warning("No such dir %s", pcfiles)
-        else:
-            # Vista or later
-            pcfiles = cls.get_manifest_dir()
-        return pcfiles
-
-    def get_policy_redirect(self, language=None, version=None):
-        # Publisher Configuration (aka policy)
-        # A publisher configuration file globally redirects applications and assemblies having a dependence on one
-        # version of a side-by-side assembly to use another version of the same assembly. This enables applications and
-        # assemblies to use the updated assembly without having to rebuild all of the affected applications.
-        # http://msdn.microsoft.com/en-us/library/aa375680%28VS.85%29.aspx
-        #
-        # Under Windows XP and 2003, policies are stored as
-        # <version>.policy files inside
-        # %SystemRoot%\WinSxS\Policies\<name>
-        # Under Vista and later, policies are stored as
-        # <name>.manifest files inside %SystemRoot%\winsxs\Manifests
-        redirected = False
-        pcfiles = self.get_policy_dir()
-        if version is None:
-            version = self.version
-        if language is None:
-            language = self.language
-
-        if os.path.isdir(pcfiles):
-            logger.debug("Searching for publisher configuration %s ...", self.getpolicyid(True, language=language))
-            if sys.getwindowsversion() < (6,):
-                # Windows XP
-                policies = os.path.join(pcfiles, self.getpolicyid(True, language=language) + ".policy")
-            else:
-                # Vista or later
-                policies = os.path.join(pcfiles, self.getpolicyid(True, language=language) + ".manifest")
-            for manifestpth in glob(policies):
-                if not os.path.isfile(manifestpth):
-                    logger.warning("Not a file %s", manifestpth)
-                    continue
-                logger.info("Found %s", manifestpth)
-                try:
-                    policy = ManifestFromXMLFile(manifestpth)
-                except Exception:
-                    logger.error("Could not parse file %s", manifestpth, exc_info=1)
-                else:
-                    logger.debug("Checking publisher policy for binding redirects")
-                    for assembly in policy.dependentAssemblies:
-                        if not assembly.same_id(self, True) or assembly.optional:
-                            continue
-                        for redirect in assembly.bindingRedirects:
-                            old = "-".join([".".join([str(i) for i in part]) for part in redirect[0]])
-                            new = ".".join([str(i) for i in redirect[1]])
-                            logger.debug("Found redirect for version(s) %s -> %s", old, new)
-                            if redirect[0][0] <= version <= redirect[0][-1] and version != redirect[1]:
-                                logger.debug("Applying redirect %s -> %s", ".".join([str(i) for i in version]), new)
-                                version = redirect[1]
-                                redirected = True
-            if not redirected:
-                logger.debug("Publisher configuration not used")
-
-        return version
-
-    def find_files(self, ignore_policies=True):
-        """
-        Search shared and private assemblies and return a list of files.
-
-        If any files are not found, return an empty list.
-
-        IMPORTANT NOTE: On some Windows systems, the dependency listed in the manifest will not actually be present,
-        and finding its files will fail. This is because a newer version of the dependency is installed,
-        and the manifest's dependency is being redirected to a newer version. To properly bundle the newer version of
-        the assembly, you need to find the newer version by setting ignore_policies=False, and then either create a
-        .config file for each bundled assembly, or modify each bundled assembly to point to the newer version.
-
-        This is important because Python 2.7's app manifest depends on version 21022 of the VC90 assembly,
-        but the Python 2.7.9 installer will install version 30729 of the assembly along with a policy file that
-        enacts the version redirect.
-        """
-
-        # Shared Assemblies:
-        # http://msdn.microsoft.com/en-us/library/aa375996%28VS.85%29.aspx
-        #
-        # Private Assemblies:
-        # http://msdn.microsoft.com/en-us/library/aa375674%28VS.85%29.aspx
-        #
-        # Assembly Searching Sequence:
-        # http://msdn.microsoft.com/en-us/library/aa374224%28VS.85%29.aspx
-        #
-        # NOTE:
-        # Multilanguage User Interface (MUI) support not yet implemented
-
-        files = []
-
-        languages = []
-        if self.language not in (None, "", "*", "neutral"):
-            languages.append(self.getlanguage())
-            if "-" in self.language:
-                # language-culture syntax, e.g., en-us
-                # Add only the language part
-                languages.append(self.language.split("-")[0])
-            if self.language not in ("en-us", "en"):
-                languages.append("en-us")
-            if self.language != "en":
-                languages.append("en")
-        languages.append(self.getlanguage("*"))
-
-        manifests = self.get_manifest_dir()
-        winsxs = self.get_winsxs_dir()
-
-        for language in languages:
-            version = self.version
-
-            # Search for publisher configuration
-            if not ignore_policies and version:
-                version = self.get_policy_redirect(language, version)
-
-            # Search for assemblies according to assembly searching sequence
-            paths = []
-            if os.path.isdir(manifests):
-                # Add winsxs search paths
-                # Search for manifests in Windows\WinSxS\Manifests
-                paths.extend(
-                    glob(os.path.join(manifests,
-                                      self.getid(language=language, version=version) + "_*.manifest"))
-                )
-            if self.filename:
-                # Add private assembly search paths
-                # Search for manifests inside assembly folders that are in the same folder as the depending manifest.
-                dirnm = os.path.dirname(self.filename)
-                if language in (LANGUAGE_NEUTRAL_NT5, LANGUAGE_NEUTRAL_NT6):
-                    for ext in (".dll", ".manifest"):
-                        paths.extend(glob(os.path.join(dirnm, self.name + ext)))
-                        paths.extend(glob(os.path.join(dirnm, self.name, self.name + ext)))
-                else:
-                    for ext in (".dll", ".manifest"):
-                        paths.extend(glob(os.path.join(dirnm, language, self.name + ext)))
-                    for ext in (".dll", ".manifest"):
-                        paths.extend(glob(os.path.join(dirnm, language, self.name, self.name + ext)))
-            logger.info("Searching for assembly %s ...", self.getid(language=language, version=version))
-            for manifestpth in paths:
-                if not os.path.isfile(manifestpth):
-                    logger.warning("Not a file %s", manifestpth)
-                    continue
-                assemblynm = os.path.basename(os.path.splitext(manifestpth)[0])
-                try:
-                    if manifestpth.endswith(".dll"):
-                        logger.info("Found manifest in %s", manifestpth)
-                        manifest = ManifestFromResFile(manifestpth, [1])
-                    else:
-                        logger.info("Found manifest %s", manifestpth)
-                        manifest = ManifestFromXMLFile(manifestpth)
-                except Exception:
-                    logger.error("Could not parse manifest %s", manifestpth, exc_info=1)
-                else:
-                    if manifestpth.startswith(winsxs):
-                        # Manifest is in Windows\WinSxS\Manifests, so assembly dir is in Windows\WinSxS
-                        assemblydir = os.path.join(winsxs, assemblynm)
-                        if not os.path.isdir(assemblydir):
-                            logger.warning("No such dir %s", assemblydir)
-                            logger.warning("Assembly incomplete")
-                            return []
-                    else:
-                        # Manifest is inside assembly dir.
-                        assemblydir = os.path.dirname(manifestpth)
-                    files.append(manifestpth)
-                    for file_ in self.files or manifest.files:
-                        fn = file_.find(assemblydir)
-                        if fn:
-                            files.append(fn)
-                        else:
-                            # If any of our files does not exist, the assembly is incomplete.
-                            logger.warning("Assembly incomplete")
-                            return []
-                return files
-
-        logger.warning("Assembly not found")
-        return []
-
-    def getid(self, language=None, version=None):
-        """
-        Return an identification string which uniquely names a manifest.
-
-        This string is a combination of the manifest's processorArchitecture, name, publicKeyToken, version and
-        language.
-
-        Arguments:
-        version (tuple or list of integers) - If version is given, use it instead of the manifest's version.
-        """
-        if not self.name:
-            logger.warning("Assembly metadata incomplete")
-            return ""
-        id = []
-        if self.processorArchitecture:
-            id.append(self.processorArchitecture)
-        id.append(self.name)
-        if self.publicKeyToken:
-            id.append(self.publicKeyToken)
-        if version or self.version:
-            id.append(".".join([str(i) for i in version or self.version]))
-        if not language:
-            language = self.getlanguage()
-        if language:
-            id.append(language)
-        return "_".join(id)
-
-    def getlanguage(self, language=None, windowsversion=None):
-        """
-        Get and return the manifest's language as string.
-
-        Can be either language-culture e.g. 'en-us' or a string indicating language neutrality, e.g. 'x-ww' on
-        Windows XP or 'none' on Vista and later.
-        """
-        if not language:
-            language = self.language
-        if language in (None, "", "*", "neutral"):
-            return (LANGUAGE_NEUTRAL_NT5, LANGUAGE_NEUTRAL_NT6)[(windowsversion or sys.getwindowsversion()) >= (6,)]
-        return language
-
-    def getpolicyid(self, fuzzy=True, language=None, windowsversion=None):
-        """
-        Return an identification string which can be used to find a policy.
-
-        This string is a combination of the manifest's processorArchitecture, major and minor version, name,
-        publicKeyToken and language.
-
-        Arguments:
-            fuzzy (boolean):
-                 If False, insert the full version in the id string. Default is True (omit).
-            windowsversion (tuple or list of integers or None):
-                If not specified (or None), default to sys.getwindowsversion().
-        """
-        if not self.name:
-            logger.warning("Assembly metadata incomplete")
-            return ""
-        id = []
-        if self.processorArchitecture:
-            id.append(self.processorArchitecture)
-        name = []
-        name.append("policy")
-        if self.version:
-            name.append(str(self.version[0]))
-            name.append(str(self.version[1]))
-        name.append(self.name)
-        id.append(".".join(name))
-        if self.publicKeyToken:
-            id.append(self.publicKeyToken)
-        if self.version and (windowsversion or sys.getwindowsversion()) >= (6,):
-            # Vista and later
-            if fuzzy:
-                id.append("*")
-            else:
-                id.append(".".join([str(i) for i in self.version]))
-        if not language:
-            language = self.getlanguage(windowsversion=windowsversion)
-        if language:
-            id.append(language)
-        id.append("*")
-        id = "_".join(id)
-        if self.version and (windowsversion or sys.getwindowsversion()) < (6,):
-            # Windows XP
-            if fuzzy:
-                id = os.path.join(id, "*")
-            else:
-                id = os.path.join(id, ".".join([str(i) for i in self.version]))
-        return id
-
-    def load_dom(self, domtree, initialize=True):
-        """
-        Load manifest from DOM tree.
-
-        If initialize is True (default), reset existing attributes first.
-        """
-        if domtree.nodeType == Node.DOCUMENT_NODE:
-            rootElement = domtree.documentElement
-        elif domtree.nodeType == Node.ELEMENT_NODE:
-            rootElement = domtree
-        else:
-            raise InvalidManifestError(
-                "Invalid root element node type %s - has to be one of (DOCUMENT_NODE, ELEMENT_NODE)" %
-                rootElement.nodeType
-            )
-        allowed_names = ("assembly", "assemblyBinding", "configuration", "dependentAssembly")
-        if rootElement.tagName not in allowed_names:
-            raise InvalidManifestError(
-                "Invalid root element <%s> - has to be one of <%s>" % (rootElement.tagName, ">, <".join(allowed_names))
-            )
-        # logger.info("loading manifest metadata from element <%s>", rootElement.tagName)
-        if rootElement.tagName == "configuration":
-            for windows in rootElement.getCEByTN("windows"):
-                for assemblyBinding in windows.getCEByTN("assemblyBinding"):
-                    self.load_dom(assemblyBinding, initialize)
-        else:
-            if initialize:
-                self.__init__()
-            self.manifestType = rootElement.tagName
-            self.manifestVersion = [int(i) for i in (rootElement.getA("manifestVersion") or "1.0").split(".")]
-            self.noInheritable = bool(rootElement.getFCEByTN("noInheritable"))
-            self.noInherit = bool(rootElement.getFCEByTN("noInherit"))
-            for assemblyIdentity in rootElement.getCEByTN("assemblyIdentity"):
-                self.type = assemblyIdentity.getA("type") or None
-                self.name = assemblyIdentity.getA("name") or None
-                self.language = assemblyIdentity.getA("language") or None
-                self.processorArchitecture = assemblyIdentity.getA("processorArchitecture") or None
-                version = assemblyIdentity.getA("version")
-                if version:
-                    self.version = tuple(int(i) for i in version.split("."))
-                self.publicKeyToken = assemblyIdentity.getA("publicKeyToken") or None
-            for publisherPolicy in rootElement.getCEByTN("publisherPolicy"):
-                self.applyPublisherPolicy = (publisherPolicy.getA("apply") or "").lower() == "yes"
-            for description in rootElement.getCEByTN("description"):
-                if description.firstChild:
-                    self.description = description.firstChild.wholeText
-            for trustInfo in rootElement.getCEByTN("trustInfo"):
-                for security in trustInfo.getCEByTN("security"):
-                    for reqPriv in security.getCEByTN("requestedPrivileges"):
-                        for reqExeLev in reqPriv.getCEByTN("requestedExecutionLevel"):
-                            self.requestedExecutionLevel = reqExeLev.getA("level")
-                            self.uiAccess = (reqExeLev.getA("uiAccess") or "").lower() == "true"
-            if rootElement.tagName == "assemblyBinding":
-                dependencies = [rootElement]
-            else:
-                dependencies = rootElement.getCEByTN("dependency")
-            for dependency in dependencies:
-                for dependentAssembly in dependency.getCEByTN("dependentAssembly"):
-                    manifest = ManifestFromDOM(dependentAssembly)
-                    if not manifest.name:
-                        # invalid, skip
-                        continue
-                    manifest.optional = (dependency.getA("optional") or "").lower() == "yes"
-                    self.dependentAssemblies.append(manifest)
-                    if self.filename:
-                        # Enable search for private assembly by assigning bogus filename
-                        # (only the directory has to be correct).
-                        self.dependentAssemblies[-1].filename = ":".join((self.filename, manifest.name))
-            for bindingRedirect in rootElement.getCEByTN("bindingRedirect"):
-                oldVersion = tuple(
-                    tuple(int(i) for i in part.split(".")) for part in bindingRedirect.getA("oldVersion").split("-")
-                )
-                newVersion = tuple(int(i) for i in bindingRedirect.getA("newVersion").split("."))
-                self.bindingRedirects.append((oldVersion, newVersion))
-            for file_ in rootElement.getCEByTN("file"):
-                self.add_file(name=file_.getA("name"), hashalg=file_.getA("hashalg"), hash=file_.getA("hash"))
-
-    def parse(self, filename_or_file, initialize=True):
-        """
-        Load manifest from file or file object.
-        """
-        if isinstance(filename_or_file, str):
-            filename = filename_or_file
-        else:
-            filename = filename_or_file.name
-        try:
-            domtree = minidom.parse(filename_or_file)
-        except xml.parsers.expat.ExpatError as e:
-            args = ['\n  File "%r"\n   ' % filename, str(e.args[0])]
-            raise ManifestXMLParseError(" ".join(args)) from e
-        if initialize:
-            self.__init__()
-        self.filename = filename
-        self.load_dom(domtree, False)
-
-    def parse_string(self, xmlstr, initialize=True):
-        """
-        Load manifest from XML string.
-        """
-        try:
-            domtree = minidom.parseString(xmlstr)
-        except xml.parsers.expat.ExpatError as e:
-            raise ManifestXMLParseError(e) from e
-        self.load_dom(domtree, initialize)
-
-    def same_id(self, manifest, skip_version_check=False):
-        """
-        Return a bool indicating if another manifest has the same identitiy.
-
-        This is done by comparing language, name, processorArchitecture, publicKeyToken, type and version.
-        """
-        if skip_version_check:
-            version_check = True
-        else:
-            version_check = self.version == manifest.version
-        return (
-            self.language == manifest.language and self.name == manifest.name
-            and self.processorArchitecture == manifest.processorArchitecture
-            and self.publicKeyToken == manifest.publicKeyToken and self.type == manifest.type and version_check
-        )
-
-    def todom(self):
-        """
-        Return the manifest as DOM tree.
-        """
-        doc = Document()
-        docE = doc.cE(self.manifestType)
-        if self.manifestType == "assemblyBinding":
-            cfg = doc.cE("configuration")
-            win = doc.cE("windows")
-            win.aChild(docE)
-            cfg.aChild(win)
-            doc.aChild(cfg)
-        else:
-            doc.aChild(docE)
-        if self.manifestType != "dependentAssembly":
-            docE.setA("xmlns", "urn:schemas-microsoft-com:asm.v1")
-            if self.manifestType != "assemblyBinding":
-                docE.setA("manifestVersion", ".".join([str(i) for i in self.manifestVersion]))
-        if self.noInheritable:
-            docE.aChild(doc.cE("noInheritable"))
-        if self.noInherit:
-            docE.aChild(doc.cE("noInherit"))
-        aId = doc.cE("assemblyIdentity")
-        if self.type:
-            aId.setAttribute("type", self.type)
-        if self.name:
-            aId.setAttribute("name", self.name)
-        if self.language:
-            aId.setAttribute("language", self.language)
-        if self.processorArchitecture:
-            aId.setAttribute("processorArchitecture", self.processorArchitecture)
-        if self.version:
-            aId.setAttribute("version", ".".join([str(i) for i in self.version]))
-        if self.publicKeyToken:
-            aId.setAttribute("publicKeyToken", self.publicKeyToken)
-        if aId.hasAttributes():
-            docE.aChild(aId)
-        else:
-            aId.unlink()
-        if self.applyPublisherPolicy is not None:
-            ppE = doc.cE("publisherPolicy")
-            if self.applyPublisherPolicy:
-                ppE.setA("apply", "yes")
-            else:
-                ppE.setA("apply", "no")
-            docE.aChild(ppE)
-        if self.description:
-            descE = doc.cE("description")
-            descE.aChild(doc.cT(self.description))
-            docE.aChild(descE)
-        if self.requestedExecutionLevel in ("asInvoker", "highestAvailable", "requireAdministrator"):
-            tE = doc.cE("trustInfo")
-            tE.setA("xmlns", "urn:schemas-microsoft-com:asm.v3")
-            sE = doc.cE("security")
-            rpE = doc.cE("requestedPrivileges")
-            relE = doc.cE("requestedExecutionLevel")
-            relE.setA("level", self.requestedExecutionLevel)
-            if self.uiAccess:
-                relE.setA("uiAccess", "true")
-            else:
-                relE.setA("uiAccess", "false")
-            rpE.aChild(relE)
-            sE.aChild(rpE)
-            tE.aChild(sE)
-            docE.aChild(tE)
-        if self.dependentAssemblies:
-            for assembly in self.dependentAssemblies:
-                if self.manifestType != "assemblyBinding":
-                    dE = doc.cE("dependency")
-                    if assembly.optional:
-                        dE.setAttribute("optional", "yes")
-                daE = doc.cE("dependentAssembly")
-                adom = assembly.todom()
-                for child in adom.documentElement.childNodes:
-                    daE.aChild(child.cloneNode(False))
-                adom.unlink()
-                if self.manifestType != "assemblyBinding":
-                    dE.aChild(daE)
-                    docE.aChild(dE)
-                else:
-                    docE.aChild(daE)
-        if self.bindingRedirects:
-            for bindingRedirect in self.bindingRedirects:
-                brE = doc.cE("bindingRedirect")
-                brE.setAttribute(
-                    "oldVersion", "-".join([".".join([str(i) for i in part]) for part in bindingRedirect[0]])
-                )
-                brE.setAttribute("newVersion", ".".join([str(i) for i in bindingRedirect[1]]))
-                docE.aChild(brE)
-        if self.files:
-            for file_ in self.files:
-                fE = doc.cE("file")
-                for attr in ("name", "hashalg", "hash"):
-                    val = getattr(file_, attr)
-                    if val:
-                        fE.setA(attr, val)
-                docE.aChild(fE)
-
-        # Add compatibility section: http://stackoverflow.com/a/10158920
-        if self.manifestType == "assembly":
-            cE = doc.cE("compatibility")
-            cE.setAttribute("xmlns", "urn:schemas-microsoft-com:compatibility.v1")
-            caE = doc.cE("application")
-            supportedOS_guids = {
-                "Vista": "{e2011457-1546-43c5-a5fe-008deee3d3f0}",
-                "7": "{35138b9a-5d96-4fbd-8e2d-a2440225f93a}",
-                "8": "{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}",
-                "8.1": "{1f676c76-80e1-4239-95bb-83d0f6d0da78}",
-                "10": "{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"
-            }
-            for guid in supportedOS_guids.values():
-                sosE = doc.cE("supportedOS")
-                sosE.setAttribute("Id", guid)
-                caE.aChild(sosE)
-            cE.aChild(caE)
-            docE.aChild(cE)
-
-        # Add application.windowsSettings section to enable longPathAware
-        # option (issue #5423).
-        if self.manifestType == "assembly":
-            aE = doc.cE("application")
-            aE.setAttribute("xmlns", "urn:schemas-microsoft-com:asm.v3")
-            wsE = doc.cE("windowsSettings")
-            lpaE = doc.cE("longPathAware")
-            lpaE.setAttribute("xmlns", "http://schemas.microsoft.com/SMI/2016/WindowsSettings")
-            lpaT = doc.cT("true")
-            lpaE.aChild(lpaT)
-            wsE.aChild(lpaE)
-            aE.aChild(wsE)
-            docE.aChild(aE)
-
-        return doc
-
-    def toprettyxml(self, indent="  ", newl=os.linesep, encoding="UTF-8"):
-        """
-        Return the manifest as pretty-printed XML.
-        """
-        domtree = self.todom()
-        # WARNING: The XML declaration has to follow the order version-encoding-standalone (standalone being optional),
-        # otherwise if it is embedded in an exe the exe will fail to launch! ('application configuration incorrect')
-        xmlstr = domtree.toprettyxml(indent, newl, encoding)
-        xmlstr = xmlstr.decode(encoding).strip(os.linesep).replace(
-            '<?xml version="1.0" encoding="%s"?>' % encoding,
-            '<?xml version="1.0" encoding="%s" standalone="yes"?>' % encoding
-        )
-        domtree.unlink()
-        return xmlstr
-
-    def toxml(self, encoding="UTF-8"):
-        """
-        Return the manifest as XML.
-        """
-        domtree = self.todom()
-        # WARNING: The XML declaration has to follow the order version-encoding-standalone (standalone being optional),
-        # otherwise if it is embedded in an exe the exe will fail to launch! ('application configuration incorrect')
-        xmlstr = domtree.toxml(encoding).decode().replace(
-            '<?xml version="1.0" encoding="%s"?>' % encoding,
-            '<?xml version="1.0" encoding="%s" standalone="yes"?>' % encoding
-        )
-        domtree.unlink()
-        return xmlstr
-
-    def update_resources(self, dstpath, names=None, languages=None):
-        """
-        Update or add manifest resource in dll/exe file dstpath.
-        """
-        UpdateManifestResourcesFromXML(dstpath, self.toprettyxml().encode("UTF-8"), names, languages)
-
-    def writeprettyxml(self, filename_or_file=None, indent="  ", newl=os.linesep, encoding="UTF-8"):
-        """
-        Write the manifest as XML to a file or file object.
-        """
-        if not filename_or_file:
-            filename_or_file = self.filename
-        if isinstance(filename_or_file, str):
-            filename_or_file = open(filename_or_file, "wb")
-        xmlstr = self.toprettyxml(indent, newl, encoding)
-        with filename_or_file:
-            filename_or_file.write(xmlstr.encode())
-
-    def writexml(self, filename_or_file=None, indent="  ", newl=os.linesep, encoding="UTF-8"):
-        """
-        Write the manifest as XML to a file or file object.
-        """
-        if not filename_or_file:
-            filename_or_file = self.filename
-        if isinstance(filename_or_file, str):
-            filename_or_file = open(filename_or_file, "wb")
-        xmlstr = self.toxml(encoding)
-        with filename_or_file:
-            filename_or_file.write(xmlstr.encode())
-
-
-def ManifestFromResFile(filename, names=None, languages=None):
-    """
-    Create and return manifest instance from resource in dll/exe file.
-    """
-    res = GetManifestResources(filename, names, languages)
-    pth = []
-    if res and res[RT_MANIFEST]:
-        while isinstance(res, dict) and res.keys():
-            key, res = next(iter(res.items()))
-            pth.append(str(key))
-    if isinstance(res, dict):
-        raise InvalidManifestError("No matching manifest resource found in '%s'" % filename)
-    manifest = Manifest()
-    manifest.filename = ":".join([filename] + pth)
-    manifest.parse_string(res, False)
-    return manifest
-
-
-def ManifestFromDOM(domtree):
-    """
-    Create and return manifest instance from DOM tree.
-    """
-    manifest = Manifest()
-    manifest.load_dom(domtree)
-    return manifest
-
-
-def ManifestFromXML(xmlstr):
-    """
-    Create and return manifest instance from XML.
-    """
-    manifest = Manifest()
-    manifest.parse_string(xmlstr)
-    return manifest
-
-
-def ManifestFromXMLFile(filename_or_file):
-    """
-    Create and return manifest instance from file.
-    """
-    manifest = Manifest()
-    manifest.parse(filename_or_file)
-    return manifest
-
-
-def GetManifestResources(filename, names=None, languages=None):
-    """
-    Get manifest resources from file.
-    """
-    return winresource.GetResources(filename, [RT_MANIFEST], names, languages)
-
-
-def UpdateManifestResourcesFromXML(dstpath, xmlstr, names=None, languages=None):
-    """
-    Update or add manifest XML as resource in dstpath.
-    """
-    logger.info("Updating manifest in %s", dstpath)
-    if dstpath.lower().endswith(".exe"):
-        name = 1
-    else:
-        name = 2
-    winresource.UpdateResources(dstpath, xmlstr, RT_MANIFEST, names or [name], languages or [0, "*"])
-
-
-def UpdateManifestResourcesFromXMLFile(dstpath, srcpath, names=None, languages=None):
-    """
-    Update or add manifest XML from srcpath as resource in dstpath.
-    """
-    logger.info("Updating manifest from %s in %s", srcpath, dstpath)
-    if dstpath.lower().endswith(".exe"):
-        name = 1
-    else:
-        name = 2
-    winresource.UpdateResourcesFromDataFile(dstpath, srcpath, RT_MANIFEST, names or [name], languages or [0, "*"])
-
-
-def create_manifest(filename, manifest, console, uac_admin=False, uac_uiaccess=False):
-    """
-    Create assembly manifest.
-    """
-    if not manifest:
-        manifest = ManifestFromXMLFile(filename)
-        # /path/NAME.exe.manifest - split extension twice to get NAME.
-        name = os.path.basename(filename)
-        manifest.name = os.path.splitext(os.path.splitext(name)[0])[0]
-    elif isinstance(manifest, str) and "<" in manifest:
-        # Assume XML string
-        manifest = ManifestFromXML(manifest)
-    elif not isinstance(manifest, Manifest):
-        # Assume filename
-        manifest = ManifestFromXMLFile(manifest)
-    dep_names = set([dep.name for dep in manifest.dependentAssemblies])
-    if manifest.filename != filename:
-        # Update dependent assemblies.
-        depmanifest = ManifestFromXMLFile(filename)
-        for assembly in depmanifest.dependentAssemblies:
-            if assembly.name not in dep_names:
-                manifest.dependentAssemblies.append(assembly)
-                dep_names.add(assembly.name)
-    if "Microsoft.Windows.Common-Controls" not in dep_names:
-        # Add Microsoft.Windows.Common-Controls to dependent assemblies.
-        manifest.dependentAssemblies.append(
-            Manifest(
-                manifestType='dependentAssembly',
-                type_="win32",
-                name="Microsoft.Windows.Common-Controls",
-                language="*",
-                processorArchitecture=processor_architecture(),
-                version=(6, 0, 0, 0),
-                publicKeyToken="6595b64144ccf1df",
-            )
-        )
-    if uac_admin:
-        manifest.requestedExecutionLevel = 'requireAdministrator'
-    else:
-        manifest.requestedExecutionLevel = 'asInvoker'
-    if uac_uiaccess:
-        manifest.uiAccess = True
-
-    # Only write a new manifest if it is different from the old.
-    need_new = not os.path.exists(filename)
-    if not need_new:
-        old_xml = ManifestFromXMLFile(filename).toprettyxml().replace('\r', '')
-        new_xml = manifest.toprettyxml().replace('\r', '')
-
-        # This only works if PYTHONHASHSEED is set in environment.
-        need_new = (old_xml != new_xml)
-    if need_new:
-        manifest.writeprettyxml(filename)
-
-    return manifest
-
-
-def processor_architecture():
-    """
-    Detect processor architecture for assembly manifest.
-
-    According to:
-    http://msdn.microsoft.com/en-us/library/windows/desktop/aa374219(v=vs.85).aspx
-    item processorArchitecture in assembly manifest is
-
-    'x86' - 32bit Windows
-    'amd64' - 64bit Windows
-    """
-    if compat.architecture == '32bit':
-        return 'x86'
-    else:
-        return 'amd64'
-
-
-if __name__ == "__main__":
-    dstpath = sys.argv[1]
-    srcpath = sys.argv[2]
-    UpdateManifestResourcesFromXMLFile(dstpath, srcpath)