# -*- coding: utf-8 -*-

#

# Copyright © 2012 Pierre Raybaut

# Licensed under the terms of the MIT License

# (see winpython/__init__.py for details)

"""

WinPython build script

Created on Sun Aug 12 11:17:50 2012

"""

from __future__ import print_function

import os

import os.path as osp

import re

import subprocess

import shutil

import sys

# Local imports

from winpython import wppm, utils

import diff

CHANGELOGS_DIR = osp.join(

osp.dirname(__file__), 'changelogs'

)

assert osp.isdir(CHANGELOGS_DIR)

def get_drives():

"""Return all active drives"""

import win32api

return win32api.GetLogicalDriveStrings().split('\000')[

:-1

]

def get_nsis_exe():

"""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',

)

if osp.isfile(exe):

return exe

else:

raise RuntimeError(

"NSIS is not installed on this computer."

)

NSIS_EXE = get_nsis_exe() # NSIS Compiler

def get_iscc_exe():

"""Return ISCC 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, 'Inno Setup 5'),

):

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

exe = osp.join(

dirname,

subdirname,

'Inno Setup 5',

'iscc.exe',

)

if osp.isfile(exe):

return exe

else:

raise RuntimeError(

"Inno Setup 5 is not installed on this computer."

)

ISCC_EXE = get_iscc_exe() # Inno Setup Compiler (iscc.exe)

def get_7zip_exe():

"""Return 7zip 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)',

osp.join(localdir, '7-Zip'),

):

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

exe = osp.join(

dirname, subdirname, '7-Zip', '7z.exe'

)

# include = osp.join(dirname, subdirname, '7-Zip', 'include')

if osp.isfile(exe):

return exe

else:

raise RuntimeError(

"7-Zip is not installed on this computer."

)

SEVENZIP_EXE = (

get_7zip_exe()

) # Inno Setup Compiler (iscc.exe)

def replace_in_nsis_file(fname, data):

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

data is a list of (start, text) tuples"""

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('iss for ', fname, 'is', lines)

fd.close()

def replace_in_iss_file(fname, data):

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

data is a list of (start, text) tuples"""

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('Inno Setup for ', fname, 'is', lines)

fd.close()

def replace_in_7zip_file(fname, data):

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

data is a list of (start, text) tuples"""

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 = 'set ' + start

if line.startswith(start + '='):

lines[idx] = (

line[: len(start) + 1]

+ ('%s' % text)

+ '\n'

)

fd = open(fname, 'w')

fd.writelines(lines)

print('7-zip for ', fname, 'is', lines)

fd.close()

def build_nsis(srcname, dstname, data):

"""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)

os.remove(dstname)

def build_iss(srcname, dstname, data):

"""Build Inno Setup Script"""

portable_dir = osp.join(

osp.dirname(osp.abspath(__file__)), 'portable'

)

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

data = [('PORTABLE_DIR', portable_dir)] + list(data)

replace_in_iss_file(dstname, data)

try:

retcode = subprocess.call(

'"%s" "%s"' % (ISCC_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)

# os.remove(dstname)

def build_7zip(srcname, dstname, data):

"""7-Zip Setup Script"""

portable_dir = osp.join(

osp.dirname(osp.abspath(__file__)), 'portable'

)

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

data = [

('PORTABLE_DIR', portable_dir),

('SEVENZIP_EXE', SEVENZIP_EXE),

] + list(data)

replace_in_7zip_file(dstname, data)

try:

# insted of a 7zip command line, we launch a script that does it

# retcode = subprocess.call('"%s" "%s"' % (SEVENZIP_EXE, dstname),

retcode = subprocess.call(

'"%s" ' % (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)

# os.remove(dstname)

class WinPythonDistribution(object):

"""WinPython distribution"""

MINGW32_PATH = r'\t\mingw32\bin'

R_PATH = r'\t\R\bin'

JULIA_PATH = r'\t\Julia\bin'

NODEJS_PATH = r'\n' # 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.distribution = None

self.installed_packages = []

self.simulation = simulation

self.basedir = (

basedir

) # added to build from winpython

self.install_options = install_options

self.flavor = flavor

self.python_fname = self.get_package_fname(

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

)

self.python_name = osp.basename(self.python_fname)[

:-4

]

self.distname = 'win%s' % self.python_name

vlst = (

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

.groups()[0]

.split('.')

)

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

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

@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)]

vscodeexe = get_tool_path(r'\t\VSCode\Code.exe', osp.isfile)

if vscodeexe is not None:

installed_tools += [('VSCode',

utils.getFileProperties(vscodeexe)['FileVersion'])]

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.distribution.get_installed_packages(update=True)

)

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

The following packages are included in WinPython-%sbit v%s%s.

### Tools

Name | Version | Description

-----|---------|------------

%s

### Python packages

Name | Version | Description

-----|---------|------------

[Python](http://www.python.org/) | %s | %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 makes self.winpyver becomes a call to self.winpyver()

@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 py_arch(self):

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

win-amd64 or win32"""

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\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 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

call "%~dp0env_for_icons.bat"

"""

+ 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 create_installer_inno(self):

"""Create installer with INNO"""

self._print("Creating WinPython installer INNO")

portable_dir = osp.join(

osp.dirname(osp.abspath(__file__)), 'portable'

)

fname = osp.join(

portable_dir, 'installer_INNO-tmp.iss'

)

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_iss('installer_INNO.iss', fname, data)

self._print_done()

def create_installer_7zip(self, installer_option=''):

"""Create installer with 7-ZIP"""

self._print("Creating WinPython installer 7-ZIP")

portable_dir = osp.join(

osp.dirname(osp.abspath(__file__)), 'portable'

)

fname = osp.join(

portable_dir, 'installer_7zip-tmp.bat'

)

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

)

data += (('INSTALLER_OPTION', installer_option),)

build_7zip('installer_7zip.bat', 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 .zip version")

utils.extract_archive(

self.python_fname,

targetdir=self.python_dir + r'\..',

)

self._print_done()

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()

# move node higher

nodejs_current = osp.join(toolsdir, 'n')

nodejs_target = self.winpydir + self.NODEJS_PATH

if nodejs_current != nodejs_target and osp.isdir(

nodejs_current

):

shutil.move(nodejs_current, nodejs_target)

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

)

self.create_launcher(

'Qt Assistant.exe',

'qtassistant.ico',

command='wscript.exe',

args=r'Noshell.vbs qtassistant.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 winjupyter_nbclassic.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',

)

# VSCode launcher

self.create_launcher(

'VS Code.exe',

'code.ico',

command='wscript.exe',

args=r'Noshell.vbs winvscode.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 WINPYDIRBASE=%~dp0..

rem get a normalize path

set WINPYDIRBASETMP=%~dp0..

pushd %WINPYDIRBASETMP%

set WINPYDIRBASE=%CD%

set WINPYDIRBASETMP=

popd

set WINPYDIR=%WINPYDIRBASE%"""

+ "\\"