You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
621 lines
24 KiB
621 lines
24 KiB
# postinstall script for pywin32
|
|
#
|
|
# copies PyWinTypesxx.dll and PythonCOMxx.dll into the system directory,
|
|
# and creates a pth file
|
|
import os, sys, glob, shutil, time
|
|
import winreg as winreg
|
|
|
|
# Send output somewhere so it can be found if necessary...
|
|
import tempfile
|
|
tee_f = open(os.path.join(tempfile.gettempdir(), '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 IOError:
|
|
pass
|
|
tee_f.write(what)
|
|
def flush(self):
|
|
if self.f is not None:
|
|
try:
|
|
self.f.flush()
|
|
except IOError:
|
|
pass
|
|
tee_f.flush()
|
|
|
|
# For some unknown reason, when running under bdist_wininst we will start up
|
|
# with sys.stdout as None but stderr is hooked up. This work-around allows
|
|
# bdist_wininst to see the output we write and display it at the end of
|
|
# the install.
|
|
if sys.stdout is None:
|
|
sys.stdout = sys.stderr
|
|
|
|
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
|
|
|
|
ver_string = "%d.%d" % (sys.version_info[0], sys.version_info[1])
|
|
root_key_name = "Software\\Python\\PythonCore\\" + ver_string
|
|
|
|
try:
|
|
# When this script is run from inside the bdist_wininst installer,
|
|
# file_created() and directory_created() are additional builtin
|
|
# functions which write lines to Python23\pywin32-install.log. This is
|
|
# a list of actions for the uninstaller, the format is inspired by what
|
|
# the Wise installer also creates.
|
|
file_created
|
|
is_bdist_wininst = True
|
|
except NameError:
|
|
is_bdist_wininst = False # we know what it is not - but not what it is :)
|
|
def file_created(file):
|
|
pass
|
|
def directory_created(directory):
|
|
pass
|
|
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 as details:
|
|
# Either not exist, or no permissions to create subkey means
|
|
# must be HKCU
|
|
return winreg.HKEY_CURRENT_USER
|
|
|
|
try:
|
|
create_shortcut
|
|
except NameError:
|
|
# Create a function with the same signature as create_shortcut provided
|
|
# by bdist_wininst
|
|
def create_shortcut(path, description, filename,
|
|
arguments="", workdir="", iconpath="", iconindex=0):
|
|
import pythoncom
|
|
from win32com.shell import shell, shellcon
|
|
|
|
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.
|
|
def get_special_folder_path(path_name):
|
|
import pythoncom
|
|
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("%s is an unknown path ID" % (path_name,))
|
|
|
|
def CopyTo(desc, src, dest):
|
|
import win32api, 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
|
|
tb = None
|
|
full_desc = "Error %s\n\n" \
|
|
"If you have any Python applications running, " \
|
|
"please close them now\nand select 'Retry'\n\n%s" \
|
|
% (desc, 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 imp
|
|
for suffix_item in imp.get_suffixes():
|
|
if suffix_item[0]=='_d.pyd':
|
|
suffix = '_d'
|
|
break
|
|
else:
|
|
suffix = ""
|
|
filename = "%s%d%d%s.dll" % \
|
|
(modname, sys.version_info[0], sys.version_info[1], suffix)
|
|
filename = os.path.join(lib_dir, "pywin32_system32", filename)
|
|
mod = imp.load_dynamic(modname, filename)
|
|
|
|
|
|
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)
|
|
finally:
|
|
my_key.Close()
|
|
finally:
|
|
root_key.Close()
|
|
if verbose:
|
|
print("-> %s\\%s[%s]=%r" % (root_key_name, key_name, value_name, value))
|
|
|
|
def RegisterCOMObjects(register = 1):
|
|
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 RegisterPythonwin(register=True):
|
|
""" 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
|
|
like file_created to add registry entries to uninstall log ???
|
|
"""
|
|
import os, distutils.sysconfig
|
|
|
|
lib_dir = distutils.sysconfig.get_python_lib(plat_specific=1)
|
|
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:
|
|
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:
|
|
try:
|
|
fldr = get_special_folder_path("CSIDL_COMMON_PROGRAMS")
|
|
except OSError:
|
|
# No CSIDL_COMMON_PROGRAMS on this platform
|
|
fldr = get_special_folder_path("CSIDL_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:
|
|
vi = sys.version_info
|
|
install_group = "Python %d.%d" % (vi[0], vi[1])
|
|
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, 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("Old dbi '%s' already exists - deleting '%s'" % (this_dest, this_pyd))
|
|
os.remove(this_pyd)
|
|
else:
|
|
os.rename(this_pyd, this_dest)
|
|
print("renamed '%s'->'%s.old'" % (this_pyd, this_pyd))
|
|
file_created(this_pyd+".old")
|
|
except os.error as exc:
|
|
print("FAILED to rename '%s': %s" % (this_pyd, exc))
|
|
|
|
def install():
|
|
import distutils.sysconfig
|
|
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
|
|
lib_dir = distutils.sysconfig.get_python_lib(plat_specific=1)
|
|
# 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 WindowsError:
|
|
pass
|
|
try:
|
|
winreg.DeleteKey(root, keyname)
|
|
except WindowsError:
|
|
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("Copied %s to %s" % (base, dst))
|
|
# Register the files with the uninstaller
|
|
file_created(dst)
|
|
worked = 1
|
|
# If this isn't sys.prefix (ie, System32), then nuke
|
|
# any versions that may exist in sys.prefix - having
|
|
# duplicates causes major headaches.
|
|
if dest_dir != sys.prefix:
|
|
bad_fname = os.path.join(sys.prefix, 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")
|
|
|
|
# Pythonwin 'compiles' config files - record them for uninstall.
|
|
pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin")
|
|
for fname in glob.glob(os.path.join(pywin_dir, "*.cfg")):
|
|
file_created(fname[:-1] + "c") # .cfg->.cfc
|
|
|
|
# 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:
|
|
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)
|
|
|
|
# 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)
|
|
else:
|
|
print("NOTE: PyWin32.chm can not be located, so has not " \
|
|
"been registered")
|
|
|
|
# misc other fixups.
|
|
fixup_dbi()
|
|
|
|
# Register Pythonwin in context menu
|
|
try:
|
|
RegisterPythonwin()
|
|
except:
|
|
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("Creating directory", make_dir)
|
|
directory_created(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)
|
|
file_created(dst)
|
|
if verbose:
|
|
print("Shortcut for Pythonwin created")
|
|
# And the docs.
|
|
dst = os.path.join(fldr, "Python for Windows Documentation.lnk")
|
|
doc = "Documentation for the PyWin32 extensions"
|
|
create_shortcut(chm_file, doc, dst)
|
|
file_created(dst)
|
|
if verbose:
|
|
print("Shortcut to documentation created")
|
|
else:
|
|
if verbose:
|
|
print("Can't install shortcuts - %r is not a folder" % (fldr,))
|
|
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
|
|
except ImportError:
|
|
# Don't let this error sound fatal
|
|
pass
|
|
print("The pywin32 extensions were successfully installed.")
|
|
|
|
def uninstall():
|
|
import distutils.sysconfig
|
|
lib_dir = distutils.sysconfig.get_python_lib(plat_specific=1)
|
|
# 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("Failed to unregister COM objects:", why)
|
|
|
|
try:
|
|
RegisterPythonwin(False)
|
|
except Exception as why:
|
|
print("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("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 os.error:
|
|
pass
|
|
try:
|
|
os.remove(os.path.join(lib_dir, "win32", "dbi_d.pyd.old"))
|
|
except os.error:
|
|
pass
|
|
|
|
except Exception as why:
|
|
print("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("Removed", link)
|
|
except Exception as why:
|
|
print("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("FAILED to remove", dst)
|
|
if worked:
|
|
break
|
|
except Exception as why:
|
|
print("FAILED to remove system files:", why)
|
|
|
|
def usage():
|
|
msg = \
|
|
"""%s: A post-install script for the pywin32 extensions.
|
|
|
|
Typical usage:
|
|
|
|
> python pywin32_postinstall.py -install
|
|
|
|
If you installed pywin32 via a .exe installer, this should be run
|
|
automatically after installation, but if it fails you can run it again.
|
|
|
|
If you installed pywin32 via PIP, you almost certainly need to run this to
|
|
setup the environment correctly.
|
|
|
|
Execute with script with a '-install' parameter, to ensure the environment
|
|
is setup correctly.
|
|
|
|
Options:
|
|
-install : Configure the Python environment correctly for pywin32.
|
|
-remove : Try and remove everything that was installed or copied.
|
|
-wait pid : Wait for the specified process to terminate before starting.
|
|
-silent : Don't display the "Abort/Retry/Ignore" dialog for files in use.
|
|
-quiet : Don't display progress messages.
|
|
"""
|
|
print(msg.strip() % os.path.basename(sys.argv[0]))
|
|
|
|
# NOTE: If this script is run from inside the bdist_wininst created
|
|
# binary installer or uninstaller, the command line args are either
|
|
# '-install' or '-remove'.
|
|
|
|
# Important: From inside the binary installer this script MUST NOT
|
|
# call sys.exit() or raise SystemExit, otherwise not only this script
|
|
# but also the installer will terminate! (Is there a way to prevent
|
|
# this from the bdist_wininst C code?)
|
|
|
|
if __name__=='__main__':
|
|
if len(sys.argv)==1:
|
|
usage()
|
|
sys.exit(1)
|
|
|
|
arg_index = 1
|
|
while arg_index < len(sys.argv):
|
|
arg = sys.argv[arg_index]
|
|
# Hack for installing while we are in use. Just a simple wait so the
|
|
# parent process can terminate.
|
|
if arg == "-wait":
|
|
arg_index += 1
|
|
pid = int(sys.argv[arg_index])
|
|
try:
|
|
os.waitpid(pid, 0)
|
|
except AttributeError:
|
|
# Python 2.2 - no waitpid - just sleep.
|
|
time.sleep(3)
|
|
except os.error:
|
|
# child already dead
|
|
pass
|
|
elif arg == "-install":
|
|
install()
|
|
elif arg == "-silent":
|
|
silent = 1
|
|
elif arg == "-quiet":
|
|
verbose = 0
|
|
elif arg == "-remove":
|
|
# bdist_msi calls us before uninstall, so we can undo what we
|
|
# previously did. Sadly, bdist_wininst calls us *after*, so
|
|
# we can't do much at all.
|
|
if not is_bdist_wininst:
|
|
uninstall()
|
|
else:
|
|
print("Unknown option:", arg)
|
|
usage()
|
|
sys.exit(0)
|
|
arg_index += 1
|