lucy-python-script-2030 0.1.0__py3-none-any.whl

pypi/Scripts/pywin32_postinstall.py

@@ -0,0 +1,729 @@
+# postinstall script for pywin32
+#
+# copies pywintypesXX.dll and pythoncomXX.dll into the system directory,
+# and creates a pth file
+import argparse
+import glob
+import os
+import shutil
+import sys
+import sysconfig
+import tempfile
+import winreg
+
+tee_f = open(
+    os.path.join(
+        tempfile.gettempdir(),  # Send output somewhere so it can be found if necessary...
+        "pywin32_postinstall.log",
+    ),
+    "w",
+)
+
+
+class Tee:
+    def __init__(self, file):
+        self.f = file
+
+    def write(self, what):
+        if self.f is not None:
+            try:
+                self.f.write(what.replace("\n", "\r\n"))
+            except OSError:
+                pass
+        tee_f.write(what)
+
+    def flush(self):
+        if self.f is not None:
+            try:
+                self.f.flush()
+            except OSError:
+                pass
+        tee_f.flush()
+
+
+sys.stderr = Tee(sys.stderr)
+sys.stdout = Tee(sys.stdout)
+
+com_modules = [
+    # module_name,                      class_names
+    ("win32com.servers.interp", "Interpreter"),
+    ("win32com.servers.dictionary", "DictionaryPolicy"),
+    ("win32com.axscript.client.pyscript", "PyScript"),
+]
+
+# Is this a 'silent' install - ie, avoid all dialogs.
+# Different than 'verbose'
+silent = 0
+
+# Verbosity of output messages.
+verbose = 1
+
+root_key_name = "Software\\Python\\PythonCore\\" + sys.winver
+
+
+def get_root_hkey():
+    try:
+        winreg.OpenKey(
+            winreg.HKEY_LOCAL_MACHINE, root_key_name, 0, winreg.KEY_CREATE_SUB_KEY
+        )
+        return winreg.HKEY_LOCAL_MACHINE
+    except OSError:
+        # Either not exist, or no permissions to create subkey means
+        # must be HKCU
+        return winreg.HKEY_CURRENT_USER
+
+
+# Create a function with the same signature as create_shortcut
+# previously provided by bdist_wininst
+def create_shortcut(
+    path, description, filename, arguments="", workdir="", iconpath="", iconindex=0
+):
+    import pythoncom
+    from win32com.shell import shell
+
+    ilink = pythoncom.CoCreateInstance(
+        shell.CLSID_ShellLink,
+        None,
+        pythoncom.CLSCTX_INPROC_SERVER,
+        shell.IID_IShellLink,
+    )
+    ilink.SetPath(path)
+    ilink.SetDescription(description)
+    if arguments:
+        ilink.SetArguments(arguments)
+    if workdir:
+        ilink.SetWorkingDirectory(workdir)
+    if iconpath or iconindex:
+        ilink.SetIconLocation(iconpath, iconindex)
+    # now save it.
+    ipf = ilink.QueryInterface(pythoncom.IID_IPersistFile)
+    ipf.Save(filename, 0)
+
+
+# Support the same list of "path names" as bdist_wininst used to
+def get_special_folder_path(path_name):
+    from win32com.shell import shell, shellcon
+
+    for maybe in """
+        CSIDL_COMMON_STARTMENU CSIDL_STARTMENU CSIDL_COMMON_APPDATA
+        CSIDL_LOCAL_APPDATA CSIDL_APPDATA CSIDL_COMMON_DESKTOPDIRECTORY
+        CSIDL_DESKTOPDIRECTORY CSIDL_COMMON_STARTUP CSIDL_STARTUP
+        CSIDL_COMMON_PROGRAMS CSIDL_PROGRAMS CSIDL_PROGRAM_FILES_COMMON
+        CSIDL_PROGRAM_FILES CSIDL_FONTS""".split():
+        if maybe == path_name:
+            csidl = getattr(shellcon, maybe)
+            return shell.SHGetSpecialFolderPath(0, csidl, False)
+    raise ValueError(f"{path_name} is an unknown path ID")
+
+
+def CopyTo(desc, src, dest):
+    import win32api
+    import win32con
+
+    while 1:
+        try:
+            win32api.CopyFile(src, dest, 0)
+            return
+        except win32api.error as details:
+            if details.winerror == 5:  # access denied - user not admin.
+                raise
+            if silent:
+                # Running silent mode - just re-raise the error.
+                raise
+            full_desc = (
+                f"Error {desc}\n\n"
+                "If you have any Python applications running, "
+                f"please close them now\nand select 'Retry'\n\n{details.strerror}"
+            )
+            rc = win32api.MessageBox(
+                0, full_desc, "Installation Error", win32con.MB_ABORTRETRYIGNORE
+            )
+            if rc == win32con.IDABORT:
+                raise
+            elif rc == win32con.IDIGNORE:
+                return
+            # else retry - around we go again.
+
+
+# We need to import win32api to determine the Windows system directory,
+# so we can copy our system files there - but importing win32api will
+# load the pywintypes.dll already in the system directory preventing us
+# from updating them!
+# So, we pull the same trick pywintypes.py does, but it loads from
+# our pywintypes_system32 directory.
+def LoadSystemModule(lib_dir, modname):
+    # See if this is a debug build.
+    import importlib.machinery
+    import importlib.util
+
+    suffix = "_d" if "_d.pyd" in importlib.machinery.EXTENSION_SUFFIXES else ""
+    filename = "%s%d%d%s.dll" % (
+        modname,
+        sys.version_info.major,
+        sys.version_info.minor,
+        suffix,
+    )
+    filename = os.path.join(lib_dir, "pywin32_system32", filename)
+    loader = importlib.machinery.ExtensionFileLoader(modname, filename)
+    spec = importlib.machinery.ModuleSpec(name=modname, loader=loader, origin=filename)
+    mod = importlib.util.module_from_spec(spec)
+    loader.exec_module(mod)
+
+
+def SetPyKeyVal(key_name, value_name, value):
+    root_hkey = get_root_hkey()
+    root_key = winreg.OpenKey(root_hkey, root_key_name)
+    try:
+        my_key = winreg.CreateKey(root_key, key_name)
+        try:
+            winreg.SetValueEx(my_key, value_name, 0, winreg.REG_SZ, value)
+            if verbose:
+                print(f"-> {root_key_name}\\{key_name}[{value_name}]={value!r}")
+        finally:
+            my_key.Close()
+    finally:
+        root_key.Close()
+
+
+def UnsetPyKeyVal(key_name, value_name, delete_key=False):
+    root_hkey = get_root_hkey()
+    root_key = winreg.OpenKey(root_hkey, root_key_name)
+    try:
+        my_key = winreg.OpenKey(root_key, key_name, 0, winreg.KEY_SET_VALUE)
+        try:
+            winreg.DeleteValue(my_key, value_name)
+            if verbose:
+                print(f"-> DELETE {root_key_name}\\{key_name}[{value_name}]")
+        finally:
+            my_key.Close()
+        if delete_key:
+            winreg.DeleteKey(root_key, key_name)
+            if verbose:
+                print(f"-> DELETE {root_key_name}\\{key_name}")
+    except OSError as why:
+        winerror = getattr(why, "winerror", why.errno)
+        if winerror != 2:  # file not found
+            raise
+    finally:
+        root_key.Close()
+
+
+def RegisterCOMObjects(register=True):
+    import win32com.server.register
+
+    if register:
+        func = win32com.server.register.RegisterClasses
+    else:
+        func = win32com.server.register.UnregisterClasses
+    flags = {}
+    if not verbose:
+        flags["quiet"] = 1
+    for module, klass_name in com_modules:
+        __import__(module)
+        mod = sys.modules[module]
+        flags["finalize_register"] = getattr(mod, "DllRegisterServer", None)
+        flags["finalize_unregister"] = getattr(mod, "DllUnregisterServer", None)
+        klass = getattr(mod, klass_name)
+        func(klass, **flags)
+
+
+def RegisterHelpFile(register=True, lib_dir=None):
+    if lib_dir is None:
+        lib_dir = sysconfig.get_paths()["platlib"]
+    if register:
+        # Register the .chm help file.
+        chm_file = os.path.join(lib_dir, "PyWin32.chm")
+        if os.path.isfile(chm_file):
+            # This isn't recursive, so if 'Help' doesn't exist, we croak
+            SetPyKeyVal("Help", None, None)
+            SetPyKeyVal("Help\\Pythonwin Reference", None, chm_file)
+            return chm_file
+        else:
+            print("NOTE: PyWin32.chm can not be located, so has not been registered")
+    else:
+        UnsetPyKeyVal("Help\\Pythonwin Reference", None, delete_key=True)
+    return None
+
+
+def RegisterPythonwin(register=True, lib_dir=None):
+    """Add (or remove) Pythonwin to context menu for python scripts.
+    ??? Should probably also add Edit command for pys files also.
+    Also need to remove these keys on uninstall, but there's no function
+    to add registry entries to uninstall log ???
+    """
+    import os
+
+    if lib_dir is None:
+        lib_dir = sysconfig.get_paths()["platlib"]
+    classes_root = get_root_hkey()
+    ## Installer executable doesn't seem to pass anything to postinstall script indicating if it's a debug build
+    pythonwin_exe = os.path.join(lib_dir, "Pythonwin", "Pythonwin.exe")
+    pythonwin_edit_command = pythonwin_exe + ' -edit "%1"'
+
+    keys_vals = [
+        (
+            "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Pythonwin.exe",
+            "",
+            pythonwin_exe,
+        ),
+        (
+            "Software\\Classes\\Python.File\\shell\\Edit with Pythonwin",
+            "command",
+            pythonwin_edit_command,
+        ),
+        (
+            "Software\\Classes\\Python.NoConFile\\shell\\Edit with Pythonwin",
+            "command",
+            pythonwin_edit_command,
+        ),
+    ]
+
+    try:
+        if register:
+            for key, sub_key, val in keys_vals:
+                ## Since winreg only uses the character Api functions, this can fail if Python
+                ##  is installed to a path containing non-ascii characters
+                hkey = winreg.CreateKey(classes_root, key)
+                if sub_key:
+                    hkey = winreg.CreateKey(hkey, sub_key)
+                winreg.SetValueEx(hkey, None, 0, winreg.REG_SZ, val)
+                hkey.Close()
+        else:
+            for key, sub_key, val in keys_vals:
+                try:
+                    if sub_key:
+                        hkey = winreg.OpenKey(classes_root, key)
+                        winreg.DeleteKey(hkey, sub_key)
+                        hkey.Close()
+                    winreg.DeleteKey(classes_root, key)
+                except OSError as why:
+                    winerror = getattr(why, "winerror", why.errno)
+                    if winerror != 2:  # file not found
+                        raise
+    finally:
+        # tell windows about the change
+        from win32com.shell import shell, shellcon
+
+        shell.SHChangeNotify(
+            shellcon.SHCNE_ASSOCCHANGED, shellcon.SHCNF_IDLIST, None, None
+        )
+
+
+def get_shortcuts_folder():
+    if get_root_hkey() == winreg.HKEY_LOCAL_MACHINE:
+        fldr = get_special_folder_path("CSIDL_COMMON_PROGRAMS")
+    else:
+        # non-admin install - always goes in this user's start menu.
+        fldr = get_special_folder_path("CSIDL_PROGRAMS")
+
+    try:
+        install_group = winreg.QueryValue(
+            get_root_hkey(), root_key_name + "\\InstallPath\\InstallGroup"
+        )
+    except OSError:
+        install_group = "Python %d.%d" % (
+            sys.version_info.major,
+            sys.version_info.minor,
+        )
+    return os.path.join(fldr, install_group)
+
+
+# Get the system directory, which may be the Wow64 directory if we are a 32bit
+# python on a 64bit OS.
+def get_system_dir():
+    import win32api  # we assume this exists.
+
+    try:
+        import pythoncom
+        import win32process
+        from win32com.shell import shell, shellcon
+
+        try:
+            if win32process.IsWow64Process():
+                return shell.SHGetSpecialFolderPath(0, shellcon.CSIDL_SYSTEMX86)
+            return shell.SHGetSpecialFolderPath(0, shellcon.CSIDL_SYSTEM)
+        except (pythoncom.com_error, win32process.error):
+            return win32api.GetSystemDirectory()
+    except ImportError:
+        return win32api.GetSystemDirectory()
+
+
+def fixup_dbi():
+    # We used to have a dbi.pyd with our .pyd files, but now have a .py file.
+    # If the user didn't uninstall, they will find the .pyd which will cause
+    # problems - so handle that.
+    import win32api
+    import win32con
+
+    pyd_name = os.path.join(os.path.dirname(win32api.__file__), "dbi.pyd")
+    pyd_d_name = os.path.join(os.path.dirname(win32api.__file__), "dbi_d.pyd")
+    py_name = os.path.join(os.path.dirname(win32con.__file__), "dbi.py")
+    for this_pyd in (pyd_name, pyd_d_name):
+        this_dest = this_pyd + ".old"
+        if os.path.isfile(this_pyd) and os.path.isfile(py_name):
+            try:
+                if os.path.isfile(this_dest):
+                    print(
+                        f"Old dbi '{this_dest}' already exists - deleting '{this_pyd}'"
+                    )
+                    os.remove(this_pyd)
+                else:
+                    os.rename(this_pyd, this_dest)
+                    print(f"renamed '{this_pyd}'->'{this_pyd}.old'")
+            except OSError as exc:
+                print(f"FAILED to rename '{this_pyd}': {exc}")
+
+
+def install(lib_dir):
+    import traceback
+
+    # The .pth file is now installed as a regular file.
+    # Create the .pth file in the site-packages dir, and use only relative paths
+    # We used to write a .pth directly to sys.prefix - clobber it.
+    if os.path.isfile(os.path.join(sys.prefix, "pywin32.pth")):
+        os.unlink(os.path.join(sys.prefix, "pywin32.pth"))
+    # The .pth may be new and therefore not loaded in this session.
+    # Setup the paths just in case.
+    for name in "win32 win32\\lib Pythonwin".split():
+        sys.path.append(os.path.join(lib_dir, name))
+    # It is possible people with old versions installed with still have
+    # pywintypes and pythoncom registered.  We no longer need this, and stale
+    # entries hurt us.
+    for name in "pythoncom pywintypes".split():
+        keyname = "Software\\Python\\PythonCore\\" + sys.winver + "\\Modules\\" + name
+        for root in winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER:
+            try:
+                winreg.DeleteKey(root, keyname + "\\Debug")
+            except OSError:
+                pass
+            try:
+                winreg.DeleteKey(root, keyname)
+            except OSError:
+                pass
+    LoadSystemModule(lib_dir, "pywintypes")
+    LoadSystemModule(lib_dir, "pythoncom")
+    import win32api
+
+    # and now we can get the system directory:
+    files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*"))
+    if not files:
+        raise RuntimeError("No system files to copy!!")
+    # Try the system32 directory first - if that fails due to "access denied",
+    # it implies a non-admin user, and we use sys.prefix
+    for dest_dir in [get_system_dir(), sys.prefix]:
+        # and copy some files over there
+        worked = 0
+        try:
+            for fname in files:
+                base = os.path.basename(fname)
+                dst = os.path.join(dest_dir, base)
+                CopyTo("installing %s" % base, fname, dst)
+                if verbose:
+                    print(f"Copied {base} to {dst}")
+                worked = 1
+                # Nuke any other versions that may exist - having
+                # duplicates causes major headaches.
+                bad_dest_dirs = [
+                    os.path.join(sys.prefix, "Library\\bin"),
+                    os.path.join(sys.prefix, "Lib\\site-packages\\win32"),
+                ]
+                if dest_dir != sys.prefix:
+                    bad_dest_dirs.append(sys.prefix)
+                for bad_dest_dir in bad_dest_dirs:
+                    bad_fname = os.path.join(bad_dest_dir, base)
+                    if os.path.exists(bad_fname):
+                        # let exceptions go here - delete must succeed
+                        os.unlink(bad_fname)
+            if worked:
+                break
+        except win32api.error as details:
+            if details.winerror == 5:
+                # access denied - user not admin - try sys.prefix dir,
+                # but first check that a version doesn't already exist
+                # in that place - otherwise that one will still get used!
+                if os.path.exists(dst):
+                    msg = (
+                        "The file '%s' exists, but can not be replaced "
+                        "due to insufficient permissions.  You must "
+                        "reinstall this software as an Administrator" % dst
+                    )
+                    print(msg)
+                    raise RuntimeError(msg)
+                continue
+            raise
+    else:
+        raise RuntimeError(
+            "You don't have enough permissions to install the system files"
+        )
+
+    # Register our demo COM objects.
+    try:
+        try:
+            RegisterCOMObjects()
+        except win32api.error as details:
+            if details.winerror != 5:  # ERROR_ACCESS_DENIED
+                raise
+            print("You do not have the permissions to install COM objects.")
+            print("The sample COM objects were not registered.")
+    except Exception:
+        print("FAILED to register the Python COM objects")
+        traceback.print_exc()
+
+    # There may be no main Python key in HKCU if, eg, an admin installed
+    # python itself.
+    winreg.CreateKey(get_root_hkey(), root_key_name)
+
+    chm_file = None
+    try:
+        chm_file = RegisterHelpFile(True, lib_dir)
+    except Exception:
+        print("Failed to register help file")
+        traceback.print_exc()
+    else:
+        if verbose:
+            print("Registered help file")
+
+    # misc other fixups.
+    fixup_dbi()
+
+    # Register Pythonwin in context menu
+    try:
+        RegisterPythonwin(True, lib_dir)
+    except Exception:
+        print("Failed to register pythonwin as editor")
+        traceback.print_exc()
+    else:
+        if verbose:
+            print("Pythonwin has been registered in context menu")
+
+    # Create the win32com\gen_py directory.
+    make_dir = os.path.join(lib_dir, "win32com", "gen_py")
+    if not os.path.isdir(make_dir):
+        if verbose:
+            print(f"Creating directory {make_dir}")
+        os.mkdir(make_dir)
+
+    try:
+        # create shortcuts
+        # CSIDL_COMMON_PROGRAMS only available works on NT/2000/XP, and
+        # will fail there if the user has no admin rights.
+        fldr = get_shortcuts_folder()
+        # If the group doesn't exist, then we don't make shortcuts - its
+        # possible that this isn't a "normal" install.
+        if os.path.isdir(fldr):
+            dst = os.path.join(fldr, "PythonWin.lnk")
+            create_shortcut(
+                os.path.join(lib_dir, "pythonwin", "Pythonwin.exe"),
+                "The Pythonwin IDE",
+                dst,
+                "",
+                sys.prefix,
+            )
+            if verbose:
+                print("Shortcut for Pythonwin created")
+            # And the docs.
+            if chm_file:
+                dst = os.path.join(fldr, "Python for Windows Documentation.lnk")
+                doc = "Documentation for the PyWin32 extensions"
+                create_shortcut(chm_file, doc, dst)
+                if verbose:
+                    print("Shortcut to documentation created")
+        else:
+            if verbose:
+                print(f"Can't install shortcuts - {fldr!r} is not a folder")
+    except Exception as details:
+        print(details)
+
+    # importing win32com.client ensures the gen_py dir created - not strictly
+    # necessary to do now, but this makes the installation "complete"
+    try:
+        import win32com.client  # noqa
+    except ImportError:
+        # Don't let this error sound fatal
+        pass
+    print("The pywin32 extensions were successfully installed.")
+
+
+def uninstall(lib_dir):
+    # First ensure our system modules are loaded from pywin32_system, so
+    # we can remove the ones we copied...
+    LoadSystemModule(lib_dir, "pywintypes")
+    LoadSystemModule(lib_dir, "pythoncom")
+
+    try:
+        RegisterCOMObjects(False)
+    except Exception as why:
+        print(f"Failed to unregister COM objects: {why}")
+
+    try:
+        RegisterHelpFile(False, lib_dir)
+    except Exception as why:
+        print(f"Failed to unregister help file: {why}")
+    else:
+        if verbose:
+            print("Unregistered help file")
+
+    try:
+        RegisterPythonwin(False, lib_dir)
+    except Exception as why:
+        print(f"Failed to unregister Pythonwin: {why}")
+    else:
+        if verbose:
+            print("Unregistered Pythonwin")
+
+    try:
+        # remove gen_py directory.
+        gen_dir = os.path.join(lib_dir, "win32com", "gen_py")
+        if os.path.isdir(gen_dir):
+            shutil.rmtree(gen_dir)
+            if verbose:
+                print(f"Removed directory {gen_dir}")
+
+        # Remove pythonwin compiled "config" files.
+        pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin")
+        for fname in glob.glob(os.path.join(pywin_dir, "*.cfc")):
+            os.remove(fname)
+
+        # The dbi.pyd.old files we may have created.
+        try:
+            os.remove(os.path.join(lib_dir, "win32", "dbi.pyd.old"))
+        except OSError:
+            pass
+        try:
+            os.remove(os.path.join(lib_dir, "win32", "dbi_d.pyd.old"))
+        except OSError:
+            pass
+
+    except Exception as why:
+        print(f"Failed to remove misc files: {why}")
+
+    try:
+        fldr = get_shortcuts_folder()
+        for link in ("PythonWin.lnk", "Python for Windows Documentation.lnk"):
+            fqlink = os.path.join(fldr, link)
+            if os.path.isfile(fqlink):
+                os.remove(fqlink)
+                if verbose:
+                    print(f"Removed {link}")
+    except Exception as why:
+        print(f"Failed to remove shortcuts: {why}")
+    # Now remove the system32 files.
+    files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*"))
+    # Try the system32 directory first - if that fails due to "access denied",
+    # it implies a non-admin user, and we use sys.prefix
+    try:
+        for dest_dir in [get_system_dir(), sys.prefix]:
+            # and copy some files over there
+            worked = 0
+            for fname in files:
+                base = os.path.basename(fname)
+                dst = os.path.join(dest_dir, base)
+                if os.path.isfile(dst):
+                    try:
+                        os.remove(dst)
+                        worked = 1
+                        if verbose:
+                            print("Removed file %s" % (dst))
+                    except Exception:
+                        print(f"FAILED to remove {dst}")
+            if worked:
+                break
+    except Exception as why:
+        print(f"FAILED to remove system files: {why}")
+
+
+# NOTE: This used to be run from inside the bdist_wininst created binary un/installer.
+# From inside the binary installer this script HAD to NOT
+# call sys.exit() or raise SystemExit, otherwise the installer would also terminate!
+# Out of principle, we're still not using system exits.
+
+
+def verify_destination(location: str) -> str:
+    location = os.path.abspath(location)
+    if not os.path.isdir(location):
+        raise argparse.ArgumentTypeError(
+            f'Path "{location}" is not an existing directory!'
+        )
+    return location
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="""A post-install script for the pywin32 extensions.
+
+    * Typical usage:
+
+    > python -m pywin32_postinstall -install
+
+    * or (shorter but you don't have control over which python environment is used)
+
+    > pywin32_postinstall -install
+
+    You need to execute this script, with a '-install' parameter,
+    to ensure the environment is setup correctly to install COM objects, services, etc.
+    """,
+    )
+    parser.add_argument(
+        "-install",
+        default=False,
+        action="store_true",
+        help="Configure the Python environment correctly for pywin32.",
+    )
+    parser.add_argument(
+        "-remove",
+        default=False,
+        action="store_true",
+        help="Try and remove everything that was installed or copied.",
+    )
+    parser.add_argument(
+        "-wait",
+        type=int,
+        help="Wait for the specified process to terminate before starting.",
+    )
+    parser.add_argument(
+        "-silent",
+        default=False,
+        action="store_true",
+        help='Don\'t display the "Abort/Retry/Ignore" dialog for files in use.',
+    )
+    parser.add_argument(
+        "-quiet",
+        default=False,
+        action="store_true",
+        help="Don't display progress messages.",
+    )
+    parser.add_argument(
+        "-destination",
+        default=sysconfig.get_paths()["platlib"],
+        type=verify_destination,
+        help="Location of the PyWin32 installation",
+    )
+
+    args = parser.parse_args()
+
+    if not args.quiet:
+        print(f"Parsed arguments are: {args}")
+
+    if not args.install ^ args.remove:
+        parser.error("You need to either choose to -install or -remove!")
+
+    if args.wait is not None:
+        try:
+            os.waitpid(args.wait, 0)
+        except OSError:
+            # child already dead
+            pass
+
+    silent = args.silent
+    verbose = not args.quiet
+
+    if args.install:
+        install(args.destination)
+
+    if args.remove:
+        uninstall(args.destination)
+
+
+if __name__ == "__main__":
+    main()