"""Return NSIS executable"""

localdir = osp.join(sys.prefix, os.pardir, os.pardir)

for drive in get_drives():

for dirname in (r'C:\Program Files', r'C:\Program Files (x86)',

drive+r'PortableApps\NSISPortableANSI',

drive+r'PortableApps\NSISPortable',

osp.join(localdir, 'NSISPortableANSI'),

osp.join(localdir, 'NSISPortable'),

):

for subdirname in ('.', 'App'):

exe = osp.join(dirname, subdirname, 'NSIS', 'makensis.exe')

include = osp.join(dirname, subdirname, 'NSIS', 'include')

if osp.isfile(exe):

return exe

else:

"""Replace text in line starting with *start*, from this position:

fd = open(fname, 'U')

lines = fd.readlines()

fd.close()

for idx, line in enumerate(lines):

for start, text in data:

if start not in ('Icon', 'OutFile') and not start.startswith('!'):

start = '!define ' + start

if line.startswith(start + ' '):

lines[idx] = line[:len(start)+1] + ('"%s"' % text) + '\n'

fd = open(fname, 'w')

fd.writelines(lines)

print('nsis for ', fname, 'is', lines)

"""Build NSIS script"""

portable_dir = osp.join(osp.dirname(osp.abspath(__file__)), 'portable')

shutil.copy(osp.join(portable_dir, srcname), dstname)

data = [('!addincludedir', osp.join(portable_dir, 'include'))

] + list(data)

replace_in_nsis_file(dstname, data)

try:

retcode = subprocess.call('"%s" -V2 "%s"' % (NSIS_EXE, dstname),

shell=True, stdout=sys.stderr)

if retcode < 0:

print("Child was terminated by signal", -retcode, file=sys.stderr)

except OSError as e:

print("Execution failed:", e, file=sys.stderr)

"""WinPython distribution"""

MINGW32_PATH = r'\t\mingw32\bin'

R_PATH = r'\t\R\bin'

JULIA_PATH = r'\t\Julia\bin'

NODEJS_PATH = r'\t\n'

def __init__(self, build_number, release_level, target, wheeldir,

toolsdirs=None, verbose=False, simulation=False,

basedir=None, install_options=None, flavor='', docsdirs=None):

assert isinstance(build_number, int)

assert isinstance(release_level, str)

self.build_number = build_number

self.release_level = release_level

self.target = target

self.wheeldir = wheeldir

if toolsdirs is None:

toolsdirs = []

self._toolsdirs = toolsdirs

if docsdirs is None:

docsdirs = []

self._docsdirs = docsdirs

self.verbose = verbose

self.winpydir = None

self.python_fname = None

self.python_name = None

self.python_version = None

self.python_fullversion = None

self.distribution = None

self.installed_packages = []

self.simulation = simulation

self.basedir = basedir # added to build from winpython

self.install_options = install_options

self.flavor = flavor

@property

def package_index_wiki(self):

"""Return Package Index page in Wiki format"""

installed_tools = []

def get_tool_path(relpath, checkfunc):

if self.simulation:

for dirname in self.toolsdirs:

path = dirname + relpath.replace(r'\t', '')

if checkfunc(path):

return path

else:

path = self.winpydir + relpath

if checkfunc(path):

return path

if get_tool_path (r'\t\SciTE.exe', osp.isfile):

installed_tools += [('SciTE', '3.3.7')]

rpath = get_tool_path(self.R_PATH, osp.isdir)

if rpath is not None:

rver = utils.get_r_version(rpath)

installed_tools += [('R', rver)]

juliapath = get_tool_path(self.JULIA_PATH, osp.isdir)

if juliapath is not None:

juliaver = utils.get_julia_version(juliapath)

installed_tools += [('Julia', juliaver)]

nodepath = get_tool_path(self.NODEJS_PATH, osp.isdir)

if nodepath is not None:

nodever = utils.get_nodejs_version(nodepath)

installed_tools += [('Nodejs', nodever)]

npmver = utils.get_npmjs_version(nodepath)

installed_tools += [('npmjs', npmver)]

pandocexe = get_tool_path (r'\t\pandoc.exe', osp.isfile)

if pandocexe is not None:

pandocver = utils.get_pandoc_version(osp.dirname(pandocexe))

installed_tools += [('Pandoc', pandocver)]

ffmpegexe = get_tool_path (r'\t\ffmpeg.exe', osp.isfile)

if ffmpegexe is not None:

ffmpegver = utils.get_ffmpeg_version(osp.dirname(ffmpegexe))

installed_tools += [('ffmpeg', ffmpegver)]

tools = []

for name, ver in installed_tools:

metadata = wppm.get_package_metadata('tools.ini', name)

url, desc = metadata['url'], metadata['description']

tools += ['[%s](%s) | %s | %s' % (name, url, ver, desc)]

# get all packages installed in the changelog, whatever the method

self.installed_packages = []

self.installed_packages = self.distribution.get_installed_packages()

packages = ['[%s](%s) | %s | %s'

% (pack.name, pack.url, pack.version, pack.description)

for pack in sorted(self.installed_packages,

key=lambda p: p.name.lower())]

python_desc = 'Python programming language with standard library'

return """## WinPython %s

%s""" % (self.winpyver2+self.flavor, self.winpy_arch, self.winpyver2+self.flavor,

(' %s' % self.release_level), '\n'.join(tools),

self.python_fullversion, python_desc, '\n'.join(packages))

@property

def winpyver(self):

"""Return WinPython version (with flavor and release level!)"""

return '%s.%d%s%s' % (self.python_fullversion, self.build_number,

self.flavor,self.release_level)

@property

def python_dir(self):

"""Return Python dirname (full path) of the target distribution"""

return osp.join(self.winpydir, self.python_name)

@property

def winpy_arch(self):

"""Return WinPython architecture"""

return '%d' % self.distribution.architecture

@property

def pyqt_arch(self):

"""Return distribution architecture, in PyQt format: x32/x64"""

return 'x%d' % self.distribution.architecture

@property

def py_arch(self):

"""Return distribution architecture, in Python distutils format:

if self.distribution.architecture == 64:

return 'win-amd64'

else:

return 'win32'

@property

def prepath(self):

"""Return PATH contents to be prepend to the environment variable"""

path = [r"Lib\site-packages\PyQt5", r"Lib\site-packages\PyQt4",

r"Lib\site-packages\PySide2", "", # Python root directory

"DLLs", "Scripts", r"..\t", r"..\t\mingw32\bin"

]

if self.distribution.architecture == 32 \

and osp.isdir(self.winpydir + self.MINGW32_PATH):

path += [r".." + self.MINGW32_PATH]

if self.distribution.architecture == 32:

path += [r".." + self.R_PATH + r"\i386"]

if self.distribution.architecture == 64:

path += [r".." + self.R_PATH + r"\x64"]

path += [r".." + self.JULIA_PATH]

path += [r".." + self.NODEJS_PATH]

return path

@property

def postpath(self):

"""Return PATH contents to be append to the environment variable"""

path = []

# if osp.isfile(self.winpydir + self.THG_PATH):

# path += [r"..\t\TortoiseHg"]

return path

@property

def toolsdirs(self):

"""Return tools directory list"""

return [osp.join(osp.dirname(osp.abspath(__file__)), 't')] + self._toolsdirs

@property

def docsdirs(self):

"""Return docs directory list"""

if osp.isdir(osp.join(osp.dirname(osp.abspath(__file__)), 'docs')):

return [osp.join(osp.dirname(osp.abspath(__file__)), 'docs')] + self._docsdirs

else:

return self._docsdirs

def get_package_fname(self, pattern):

"""Get package matching pattern in wheeldir"""

path = self.wheeldir

for fname in os.listdir(path):

match = re.match(pattern, fname)

if match is not None or pattern == fname:

return osp.abspath(osp.join(path, fname))

else:

raise RuntimeError(

'Could not find required package matching %s' % pattern)

def install_package(self, pattern, install_options=None):

"""Install package matching pattern"""

fname = self.get_package_fname(pattern)

if fname not in [p.fname for p in self.installed_packages]:

pack = wppm.Package(fname)

if self.simulation:

self.distribution._print(pack, "Installing")

self.distribution._print_done()

else:

if install_options:

self.distribution.install(pack, install_options)

else:

self.distribution.install(pack,

install_options=self.install_options)

self.installed_packages.append(pack)

def create_batch_script(self, name, contents):

"""Create batch script %WINPYDIR%/name"""

scriptdir = osp.join(self.winpydir, 'scripts')

if not osp.isdir(scriptdir):

os.mkdir(scriptdir)

fd = open(osp.join(scriptdir, name), 'w')

fd.write(contents)

fd.close()

def create_launcher(self, name, icon, command=None,

args=None, workdir=r'$EXEDIR\scripts',

launcher='launcher_basic.nsi'):

"""Create exe launcher with NSIS"""

assert name.endswith('.exe')

portable_dir = osp.join(osp.dirname(osp.abspath(__file__)), 'portable')

icon_fname = osp.join(portable_dir, 'icons', icon)

assert osp.isfile(icon_fname)

# Customizing NSIS script

if command is None:

if args is not None and '.pyw' in args:

command = '${WINPYDIR}\pythonw.exe'

else:

command = '${WINPYDIR}\python.exe'

if args is None:

args = ''

if workdir is None:

workdir = ''

fname = osp.join(self.winpydir, osp.splitext(name)[0]+'.nsi')

data = [('WINPYDIR', '$EXEDIR\%s' % self.python_name),

('WINPYVER', self.winpyver),

('COMMAND', command),

('PARAMETERS', args),

('WORKDIR', workdir),

('Icon', icon_fname),

('OutFile', name)]

build_nsis(launcher, fname, data)

def create_python_batch(self, name, script_name,

workdir=None, options=None, command=None):

"""Create batch file to run a Python script"""

if options is None:

options = ''

else:

options = ' ' + options

if command is None:

if script_name.endswith('.pyw'):

command = 'start "%WINPYDIR%\pythonw.exe"'

else:

command = '"%WINPYDIR%\python.exe"'

changedir = ''

if workdir is not None:

workdir = (workdir)

changedir = r"""cd/D %s

""" % workdir

if script_name:

script_name = ' ' + script_name

self.create_batch_script(name, r"""@echo off

""" + changedir + command + script_name + options + " %*")

def create_installer(self):

"""Create installer with NSIS"""

self._print("Creating WinPython installer")

portable_dir = osp.join(osp.dirname(osp.abspath(__file__)), 'portable')

fname = osp.join(portable_dir, 'installer-tmp.nsi')

data = (('DISTDIR', self.winpydir),

('ARCH', self.winpy_arch),

('VERSION', '%s.%d%s' % (self.python_fullversion,

self.build_number, self.flavor)),

('VERSION_INSTALL', '%s%d' % (self.python_fullversion.replace(

'.' , ''), self.build_number)),

('RELEASELEVEL', self.release_level),)

build_nsis('installer.nsi', fname, data)

self._print_done()

def _print(self, text):

"""Print action text indicating progress"""

if self.verbose:

utils.print_box(text)

else:

print(text + '...', end=" ")

def _print_done(self):

"""Print OK at the end of a process"""

if not self.verbose:

print("OK")

def _extract_python(self):

"""Extracting Python installer, creating distribution object"""

self._print("Extracting Python installer")

os.mkdir(self.python_dir)

if self.python_fname[-3:] == 'zip': # Python3.5

utils.extract_archive(self.python_fname, targetdir=self.python_dir+r'\..')

if self.winpyver < "3.6":

# new Python 3.5 trick (https://bugs.python.org/issue23955)

pyvenv_file = osp.join(self.python_dir, 'pyvenv.cfg')

open(pyvenv_file, 'w').write('applocal=True\n')

else:

# new Python 3.6 trick (https://docs.python.org/3.6/using/windows.html#finding-modules)

# (on hold since 2017-02-16, http://bugs.python.org/issue29578)

pypath_file = osp.join(self.python_dir, 'python_onHold._pth')

open(pypath_file, 'w').write('python36.zip\nDLLs\nLib\n.\nimport site\n')

else:

utils.extract_msi(self.python_fname, targetdir=self.python_dir)

os.remove(osp.join(self.python_dir, osp.basename(self.python_fname)))

if not os.path.exists(osp.join(self.python_dir, 'Scripts')):

os.mkdir(osp.join(self.python_dir, 'Scripts'))

self._print_done()

def _add_msvc_files(self):

"""Adding Microsoft Visual C++ DLLs"""

print("Adding Microsoft Visual C++ DLLs""")

msvc_version = dh.get_msvc_version(self.distribution.version)

for fname in dh.get_msvc_dlls(msvc_version,

architecture=self.distribution.architecture):

shutil.copy(fname, self.python_dir)

def _check_packages(self):

"""Check packages for duplicates or unsupported packages"""

print("Checking packages")

packages = []

my_plist = []

my_plist += os.listdir(self.wheeldir)

for fname0 in my_plist:

fname = self.get_package_fname(fname0)

if fname == self.python_fname:

continue

try:

pack = wppm.Package(fname)

except NotImplementedError:

print("WARNING: package %s is not supported"

% osp.basename(fname), file=sys.stderr)

continue

packages.append(pack)

all_duplicates = []

for pack in packages:

if pack.name in all_duplicates:

continue

all_duplicates.append(pack.name)

duplicates = [p for p in packages if p.name == pack.name]

if len(duplicates) > 1:

print("WARNING: duplicate packages %s (%s)" %

(pack.name, ", ".join([p.version for p in duplicates])),

file=sys.stderr)

def _install_all_other_packages(self):

"""Try to install all other packages in wheeldir"""

print("Installing other packages")

my_list = []

my_list += os.listdir(self.wheeldir)

for fname in my_list:

if osp.basename(fname) != osp.basename(self.python_fname):

try:

self.install_package(fname)

except NotImplementedError:

print("WARNING: unable to install package %s"

% osp.basename(fname), file=sys.stderr)

def _copy_dev_tools(self):

"""Copy dev tools"""

self._print("Copying tools")

toolsdir = osp.join(self.winpydir, 't')

os.mkdir(toolsdir)

for dirname in self.toolsdirs: # the ones in the make.py script environment

for name in os.listdir(dirname):

path = osp.join(dirname, name)

copy = shutil.copytree if osp.isdir(path) else shutil.copyfile

if self.verbose:

print(path + ' --> ' + osp.join(toolsdir, name))

copy(path, osp.join(toolsdir, name))

self._print_done()

def _copy_dev_docs(self):

"""Copy dev docs"""

self._print("Copying Noteebook docs")

docsdir = osp.join(self.winpydir, 'notebooks')

if not osp.isdir(docsdir):

os.mkdir(docsdir)

docsdir = osp.join(self.winpydir, 'notebooks', 'docs')

if not osp.isdir(docsdir):

os.mkdir(docsdir)

for dirname in self.docsdirs:

for name in os.listdir(dirname):

path = osp.join(dirname, name)

copy = shutil.copytree if osp.isdir(path) else shutil.copyfile

copy(path, osp.join(docsdir, name))

if self.verbose:

print(path + ' --> ' + osp.join(docsdir, name))

self._print_done()

def _create_launchers(self):

"""Create launchers"""

self._print("Creating launchers")

self.create_launcher('WinPython Command Prompt.exe', 'cmd.ico',

command='$SYSDIR\cmd.exe',

args=r'/k cmd.bat')

self.create_launcher('WinPython Powershell Prompt.exe', 'powershell.ico',

command='$SYSDIR\cmd.exe',

args=r'/k cmd_ps.bat')

self.create_launcher('WinPython Interpreter.exe', 'python.ico',

command='$SYSDIR\cmd.exe',

args= r'/k winpython.bat')

self.create_launcher('IDLEX.exe', 'python.ico',

command='wscript.exe',

args= r'Noshell.vbs winidlex.bat')

self.create_launcher('IDLE (Python GUI).exe', 'python.ico',

command='wscript.exe',

args= r'Noshell.vbs winidle.bat')

self.create_launcher('Spyder.exe', 'spyder.ico',

command='wscript.exe',

args=r'Noshell.vbs winspyder.bat')

self.create_launcher('Spyder reset.exe', 'spyder_reset.ico',

command='wscript.exe',

args=r'Noshell.vbs spyder_reset.bat')

self.create_launcher('WinPython Control Panel.exe', 'winpython.ico',

command='wscript.exe',

args=r'Noshell.vbs wpcp.bat')

# Multi-Qt launchers

self.create_launcher('Qt Designer.exe', 'qtdesigner.ico',

command='wscript.exe',

args=r'Noshell.vbs qtdesigner.bat')

self.create_launcher('Qt Linguist.exe', 'qtlinguist.ico',

command='wscript.exe',

args=r'Noshell.vbs qtlinguist.bat')

# Jupyter launchers

self.create_launcher('IPython Qt Console.exe', 'ipython.ico',

command='wscript.exe',

args=r'Noshell.vbs winqtconsole.bat')

# this one needs a shell to kill fantom processes

self.create_launcher('Jupyter Notebook.exe', 'jupyter.ico',

command='$SYSDIR\cmd.exe',

args=r'/k winipython_notebook.bat')

self.create_launcher('Jupyter Lab.exe', 'jupyter.ico',

command='$SYSDIR\cmd.exe',

args=r'/k winjupyter_lab.bat')

self.create_launcher('Pyzo.exe', 'pyzologo.ico',

command='wscript.exe',

args=r'Noshell.vbs winpyzo.bat')

self._print_done()

def _create_batch_scripts_initial(self):

"""Create batch scripts"""

self._print("Creating batch scripts initial")

conv = lambda path: ";".join(['%WINPYDIR%\\'+pth for pth in path])

path = conv(self.prepath) + ";%PATH%;" + conv(self.postpath)

convps = lambda path: ";".join(["$env:WINPYDIR\\"+pth for pth in path])

pathps = convps(self.prepath) + ";$env:path;" + convps(self.postpath)

self.create_batch_script('env.bat', r"""@echo off

set WINPYDIR=%WINPYDIRBASE%"""+"\\" + self.python_name + r"""

set WINPYVER=""" + self.winpyver + r"""

if %ERRORLEVEL% NEQ 0 set PATH=""" + path + r"""

""")

self.create_batch_script('WinPython_PS_Prompt.ps1', r"""

if (-not ($env:WINPYDIR -eq [System.IO.Path]::GetFullPath( $env:WINPYDIRBASE+"""+'"\\' + self.python_name + '"' + r""")) ) {

$env:WINPYDIR = $env:WINPYDIRBASE+"""+ '"' + '\\' + self.python_name + '"' + r"""

$env:WINPYVER = '""" + self.winpyver + r"""'

$env:PATH = """ + '"' + pathps + '"' + r""" }

""")

self.create_batch_script('cmd_ps.bat', r"""@echo off

""")

self.create_batch_script('WinPython_Interpreter_PS.bat', r"""@echo off

""")

self.create_batch_script('env_for_icons.bat', r"""@echo off

""")

self.create_batch_script('Noshell.vbs',

r"""

""")

self.create_batch_script('WinPythonIni.vbs',

r"""

""")

def _create_batch_scripts(self):

"""Create batch scripts"""

self._print("Creating batch scripts")

self.create_batch_script('readme.txt',

The environment variables are set-up in 'env_.bat' and 'env_for_icons.bat'.""")

conv = lambda path: ";".join(['%WINPYDIR%\\'+pth for pth in path])

path = conv(self.prepath) + ";%PATH%;" + conv(self.postpath)

self.create_batch_script('make_cython_use_mingw.bat', r"""@echo off

""")

self.create_batch_script('make_cython_use_vc.bat', r"""@echo off