"""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'\tools\mingw32\bin'

R_PATH = r'\tools\R\bin'

JULIA_PATH = r'\tools\Julia\bin'

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'\tools', '')

if checkfunc(path):

return path

else:

path = self.winpydir + relpath

if checkfunc(path):

return path

if get_tool_path (r'\tools\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)]

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

if pandocexe is not None:

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

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

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.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 '%dbit' % 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",

"", # Python root directory (python.exe)

"DLLs", "Scripts", r"..\tools", r"..\tools\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]

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"..\tools\TortoiseHg"]

return path

@property

def toolsdirs(self):

"""Return tools directory list"""

return [osp.join(osp.dirname(osp.abspath(__file__)), 'tools')] + 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)),

('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'\..')

# 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:

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, 'tools')

os.mkdir(toolsdir)

for dirname in self.toolsdirs:

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(toolsdir, name))

if self.verbose:

print(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 Interpreter.exe', 'python.ico',

command='$SYSDIR\cmd.exe',

args= r'/k python.bat')

#self.create_launcher('IDLEX (students).exe', 'python.ico',

# command='$SYSDIR\cmd.exe',

# args= r'/k IDLEX_for_student.bat %*',

# workdir='$EXEDIR\scripts')

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

command='wscript.exe',

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

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

command='wscript.exe',

args=r'Noshell.vbs spyder.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 (Qt5 has priority if found)

self.create_launcher('Qt Demo.exe', 'qt.ico',

command='wscript.exe',

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

self.create_launcher('Qt Assistant.exe', 'qtassistant.ico',

command='wscript.exe',

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

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 qtconsole.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 ipython_notebook.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)

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

set WINPYDIR=%~dp0.."""+"\\" + self.python_name + r"""

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

set PATH=""" + path + r"""

""")

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

""")

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

""")

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

""")

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

""")

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

""")

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

cmd.exe /k""")

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

""")

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

""")

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

""")

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

""")

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

""")

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

""")

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

""")

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

""")

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

""")

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

""")

self.create_python_batch('register_python.bat', 'register_python',

workdir=r'"%WINPYDIR%\Scripts"')

self.create_batch_script('register_python_for_all.bat',

r"""@echo off

call %~dp0register_python.bat --all""")

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

""")

#self.create_python_batch('wpcp.bat', '-m winpython.controlpanel',

# workdir=r'"%WINPYDIR%\Scripts"')

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

""")

# pre-run mingw batch

print('now pre-running extra mingw')

filepath = osp.join(self.winpydir, 'scripts', 'make_cython_use_mingw.bat')

p = subprocess.Popen(filepath, shell=True, stdout=subprocess.PIPE)

stdout, stderr = p.communicate()

self._print_done()

def _run_complement_batch_scripts(self, this_batch="run_complement.bat"):

""" tools\..\run_complement.bat for final complements"""

print('now %s in tooldirs\..' % this_batch)

for post_complement in list(set([osp.dirname(s)

for s in self._toolsdirs])):

filepath = osp.join(post_complement, this_batch)

if osp.isfile(filepath):

print('launch "%s" for "%s"' % (filepath, self.winpydir))

try:

retcode = subprocess.call('"%s" "%s"' % (filepath, self.winpydir),

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)

self._print_done()

def make(self, remove_existing=True, requirements=None, my_winpydir=None): #, find_links=None):

"""Make WinPython distribution in target directory from the installers

if self.simulation:

print("WARNING: this is just a simulation!", file=sys.stderr)

self.python_fname = self.get_package_fname(

r'python-([0-9\.rc]*)((\.|\-)amd64)?\.(msi|zip)')

self.python_name = osp.basename(self.python_fname)[:-4]

distname = 'win%s' % self.python_name

vlst = re.match(r'winpython-([0-9\.]*)', distname

).groups()[0].split('.')

self.python_version = '.'.join(vlst[:2])

self.python_fullversion = '.'.join(vlst[:3])

print(self.python_fname,self.python_name , distname, self.python_version, self.python_fullversion)

# Create the WinPython base directory

self._print("Creating WinPython %s base directory"

% self.python_version)

if my_winpydir is None:

self.winpydir = osp.join(self.target, distname)

else:

self.winpydir = osp.join(self.target, my_winpydir)

if osp.isdir(self.winpydir) and remove_existing \

and not self.simulation:

shutil.rmtree(self.winpydir, onerror=utils.onerror)

if not osp.isdir(self.winpydir):

os.mkdir(self.winpydir)

if remove_existing and not self.simulation:

# Create settings directory

# (only necessary if user is starting an application with a batch

# scripts before using an executable launcher, because the latter

# is creating the directory automatically)

os.mkdir(osp.join(self.winpydir, 'settings'))

self._print_done()

if remove_existing and not self.simulation:

self._extract_python()

self.distribution = wppm.Distribution(self.python_dir,

verbose=self.verbose,

indent=True)

self._check_packages()

if remove_existing:

if not self.simulation:

self._add_msvc_files()

if not self.simulation:

self._create_batch_scripts_initial()

self._create_batch_scripts() # which set mingwpy as compiler

self._run_complement_batch_scripts("run_required_first.bat")

# launchers at the beginning

self._create_launchers()

# pre-patch current pip (until default python has pip 8.0.3)

self.distribution.patch_standard_packages('pip')

# force update of pip (FIRST) and setuptools here

for req in ('pip', 'setuptools'):

actions = ["install","--upgrade", "--force-reinstall", req]

if self.install_options is not None:

actions += self.install_options

print("piping %s" % ' '.join(actions))

self._print("piping %s" % ' '.join(actions))

self.distribution.do_pip_action(actions)

self.distribution.patch_standard_packages(req)

# install packages in source_dirs (not using requirements.txt)

self._install_all_other_packages()

if not self.simulation:

self._copy_dev_tools()

self._copy_dev_docs()

if not self.simulation:

if requirements:

if not list(requirements)==requirements:

requirements = requirements.split()

for req in requirements:

actions = ["install","-r", req]

if self.install_options is not None:

actions += self.install_options

print("piping %s" % ' '.join(actions))

self._print("piping %s" % ' '.join(actions))

self.distribution.do_pip_action(actions)

#actions=["install","-r", req, "--no-index",

# "--trusted-host=None"]+ links,

# install_options=None)

self._run_complement_batch_scripts() # run_complement.bat

self.distribution.patch_standard_packages()

if remove_existing and not self.simulation: