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

"""

import os

from pathlib import Path

import re

import subprocess

import shutil

import sys

# Local imports

from winpython import wppm, utils

import diff

CHANGELOGS_DIR = str(Path(__file__).parent / "changelogs")

assert Path(CHANGELOGS_DIR).is_dir()

def get_drives():

"""Return all active drives"""

import win32api

return win32api.GetLogicalDriveStrings().split("\000")[:-1]

def get_nsis_exe():

"""Return NSIS executable"""

localdir = str(Path(sys.prefix).parent.parent)

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

str(Path(localdir) / "NSISPortableANSI"),

str(Path(localdir) / "NSISPortable"),

):

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

exe = str(Path(dirname) / subdirname / "NSIS" / "makensis.exe")

if Path(exe).is_file():

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 = str(Path(sys.prefix).parent.parent)

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

str(Path(localdir) / "Inno Setup 5"),

):

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

exe = str(Path(dirname) / subdirname / "Inno Setup 5" / "iscc.exe")

if Path(exe).is_file():

return exe

else:

# raise RuntimeError(

print("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 = str(Path(sys.prefix).parent.parent)

for drive in get_drives():

for dirname in (

r"C:\Program Files",

r"C:\Program Files (x86)",

str(Path(localdir) / "7-Zip"),

):

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

exe = str(Path(dirname) / subdirname / "7-Zip" / "7z.exe")

if Path(exe).is_file():

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] + f'"{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] + f'"{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] + f"{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 = str(Path(__file__).resolve().parent / "portable")

shutil.copy(str(Path(portable_dir) / srcname), dstname)

data = [

(

"!addincludedir",

str(Path(portable_dir) / "include"),

)

] + list(data)

replace_in_nsis_file(dstname, data)

try:

retcode = subprocess.call(

f'"{NSIS_EXE}" -V2 "{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 = str(Path(__file__).resolve().parent / "portable")

shutil.copy(str(Path(portable_dir) / srcname), dstname)

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

replace_in_iss_file(dstname, data)

try:

retcode = subprocess.call(

f'"{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 = str(Path(__file__).resolve().parent / "portable")

shutil.copy(str(Path(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(f'"{SEVENZIP_EXE}" "{dstname}"'),

retcode = subprocess.call(

f'"{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 # new WinPython BaseDirectory

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

# python_fname = the .zip of the python interpreter PyPy !

# impot re

# re.match(r'(pypy3*-v|python-)([0-9\.rcba]*)((\.|\-)(amd64|win64)?\.zip')

try: # PyPy

self.python_fname = self.get_package_fname(

r"(pypy3|python-)([0-9]|[a-zA-Z]|.)*.zip"

)

except: # normal Python

self.python_fname = self.get_package_fname(

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

)

# osp.join(self.winpydir, self.python_name) = Directory of Python exec

# self.pythondir =osp.join(self.winpydir, self.python_name)

self.python_name = Path(self.python_fname).name[:-4]

self.distname = "winUNKNOWN" # f'win{self.python_name}' # PyPy ?

# vlst = (

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

# .groups()[0]

# .split('.')

# )

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

@property

def package_index_wiki(self):

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

installed_tools = []

def get_tool_path_file(relpath):

if self.simulation:

for dirname in self.toolsdirs:

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

if Path(path).is_file():

return path

else:

path = self.winpydir + relpath

if Path(path).is_file():

return path

def get_tool_path_dir(relpath):

if self.simulation:

for dirname in self.toolsdirs:

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

if Path(path).is_dir():

return path

else:

path = self.winpydir + relpath

if Path(path).is_dir():

return path

if get_tool_path_file(r"\t\SciTE.exe"):

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

rpath = get_tool_path_dir(self.R_PATH)

if rpath is not None:

rver = utils.get_r_version(rpath)

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

juliapath = get_tool_path_dir(self.JULIA_PATH)

if juliapath is not None:

juliaver = utils.get_julia_version(juliapath)

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

nodepath = get_tool_path_dir(self.NODEJS_PATH)

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_file(r"\t\pandoc.exe")

if pandocexe is not None:

pandocver = utils.get_pandoc_version(str(Path(pandocexe).parent))

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

vscodeexe = get_tool_path_file(r"\t\VSCode\Code.exe")

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 += [f"[{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 = [

f"[{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"

tools_f = "\n".join(tools)

packages_f = "\n".join(packages)

return (

f"""## WinPython {self.winpyver2 + self.flavor}

The following packages are included in WinPython-{self.winpy_arch}bit v{self.winpyver2+self.flavor} {self.release_level}.

<details>

### Tools

Name | Version | Description

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

{tools_f}

### Python packages

Name | Version | Description

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

[Python](http://www.python.org/) | {self.python_fullversion} | {python_desc}

{packages_f}"""

+ "\n\n</details>\n"

)

# @property makes self.winpyver becomes a call to self.winpyver()

@property

def winpyver(self):

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

return f"{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 str(Path(self.winpydir) / self.python_name) # python.exe path

@property

def winpy_arch(self):

"""Return WinPython architecture"""

return f"{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"""

# formerly was joining prepared tool dir + the one of building env..

return [

# osp.join(

# osp.dirname(osp.abspath(__file__)), 't'

# )

] + self._toolsdirs

@property

def docsdirs(self):

"""Return docs directory list"""

if (Path(__file__).resolve().parent / "docs").is_dir():

return [str(Path(__file__).resolve().parent / "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 str((Path(path) / fname).resolve())

else:

raise RuntimeError(f"Could not find required package matching {pattern}")

def create_batch_script(self, name, contents, do_changes=None):

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

scriptdir = str(Path(self.winpydir) / "scripts")

if not Path(scriptdir).is_dir():

os.mkdir(scriptdir)

print("dochanges for %s %", name, do_changes)

# live patch pypy3

contents_final = contents

if do_changes != None:

for i in do_changes:

contents_final = contents_final.replace(i[0], i[1])

fd = open(str(Path(scriptdir) / name), "w")

fd.write(contents_final)

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 = str(Path(__file__).resolve().parent / "portable")

icon_fname = str(Path(portable_dir) / "icons" / icon)

assert Path(icon_fname).is_file()

# 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 = str(Path(self.winpydir) / (Path(name).stem + ".nsi"))

data = [

("WINPYDIR", f"$EXEDIR\{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 = str(Path(__file__).resolve().parent / "portable")

fname = str(Path(portable_dir) / "installer-tmp.nsi")

data = (

("DISTDIR", self.winpydir),

("ARCH", self.winpy_arch),

(

"VERSION",

f"{self.python_fullversion}.{self.build_number}{self.flavor}",

),

(

"VERSION_INSTALL",

f'{self.python_fullversion.replace(".", "")}' + f"{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 = str(Path(__file__).resolve().parent / "portable")

fname = str(Path(portable_dir) / "installer_INNO-tmp.iss")

data = (

("DISTDIR", self.winpydir),

("ARCH", self.winpy_arch),

(

"VERSION",

f"{self.python_fullversion}.{self.build_number}{self.flavor}",

),

(

"VERSION_INSTALL",

f'{self.python_fullversion.replace(".", "")}' + f"{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 = str(Path(__file__).resolve().parent / "portable")

fname = str(Path(portable_dir) / "installer_7zip-tmp.bat")

data = (

("DISTDIR", self.winpydir),

("ARCH", self.winpy_arch),

(

"VERSION",

f"{self.python_fullversion}.{self.build_number}{self.flavor}",

),

(

"VERSION_INSTALL",

f'{self.python_fullversion.replace(".", "")}' + f"{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(f"Copying tools from {self.toolsdirs} to {self.winpydir}/t")

toolsdir = str(Path(self.winpydir) / "t")

os.mkdir(toolsdir)

for dirname in [

ok_dir for ok_dir in self.toolsdirs if Path(ok_dir).is_dir()

]: # the ones in the make.py script environment

for name in os.listdir(dirname):

path = str(Path(dirname) / name)

copy = shutil.copytree if Path(path).is_dir() else shutil.copyfile

if self.verbose:

print(path + " --> " + str(Path(toolsdir) / name))

copy(path, str(Path(toolsdir) / name))

self._print_done()

# move node higher

nodejs_current = str(Path(toolsdir) / "n")

nodejs_target = self.winpydir + self.NODEJS_PATH

if nodejs_current != nodejs_target and Path(nodejs_current).is_dir():

shutil.move(nodejs_current, nodejs_target)

def _copy_dev_docs(self):

"""Copy dev docs"""

docsdir = str(Path(self.winpydir) / "notebooks")

self._print(f"Copying Noteebook docs from {self.docsdirs} to {docsdir}")

if not Path(docsdir).is_dir():

os.mkdir(docsdir)

docsdir = str(Path(self.winpydir) / "notebooks" / "docs")

if not Path(docsdir).is_dir():

os.mkdir(docsdir)

for dirname in self.docsdirs:

for name in os.listdir(dirname):

path = str(Path(dirname) / name)

copy = shutil.copytree if Path(path).is_dir() else shutil.copyfile

copy(path, str(Path(docsdir) / name))

if self.verbose:

print(path + " --> " + str(Path(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",

)

# removed to reduce number of icons

#self.create_launcher(

# "WinPython Powershell Prompt.exe",

# "powershell.ico",

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

# args=r"/k cmd_ps.bat",

#)

self.create_launcher(

"WinPython Terminal.exe",

"terminal.ico",

command="wscript.exe",

args=r"Noshell.vbs WinPython_Terminal.bat",

)

self.create_launcher(

"WinPython Interpreter.exe",

"python.ico",

command="$SYSDIR\cmd.exe",

args=r"/k winpython.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",

command="$SYSDIR\cmd.exe",

args=r"/k 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 winipython_notebook.bat", # like VSCode + Rise way

# args=r'/k winjupyter_nbclassic.bat', # Jupyterlab in classic look

)

self.create_launcher(

"Jupyter Lab.exe",

"jupyter.ico",

command="$SYSDIR\cmd.exe",

args=r"/k winjupyter_lab.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)

# PyPy3

shorty = self.distribution.short_exe

changes = (

(r"DIR%\python.exe", r"DIR%" + "\\" + shorty),

(r"DIR%\PYTHON.EXE", r"DIR%" + "\\" + shorty),

)

if (Path(self.distribution.target) / r"lib-python\3\idlelib").is_dir():

changes += ((r"\Lib\idlelib", r"\lib-python\3\idlelib"),)

self.create_batch_script(

"env.bat",

r"""@echo off

set WINPYDIRBASE=%~dp0..

rem set PYTHONUTF8=1 would create issues in "movable" patching

rem get a normalize path

set WINPYDIRBASETMP=%~dp0..

pushd %WINPYDIRBASETMP%

set WINPYDIRBASE=%__CD__%

if "%WINPYDIRBASE:~-1%"=="\" set WINPYDIRBASE=%WINPYDIRBASE:~0,-1%

set WINPYDIRBASETMP=

popd

set WINPYDIR=%WINPYDIRBASE%"""

+ "\\"

+ self.python_name

+ r"""

rem 2019-08-25 pyjulia needs absolutely a variable PYTHON=%WINPYDIR%python.exe

set PYTHON=%WINPYDIR%\python.exe

set PYTHONPATHz=%WINPYDIR%;%WINPYDIR%\Lib;%WINPYDIR%\DLLs

set WINPYVER="""

+ self.winpyver

+ r"""

rem 2023-02-12 try utf-8 on console

rem see https://github.com/pypa/pip/issues/11798#issuecomment-1427069681

set PYTHONIOENCODING=utf-8

set HOME=%WINPYDIRBASE%\settings

rem read https://github.com/winpython/winpython/issues/839

rem set USERPROFILE=%HOME%

rem set WINPYDIRBASE=

set JUPYTER_DATA_DIR=%HOME%

set JUPYTER_CONFIG_DIR=%WINPYDIR%\etc\jupyter

set JUPYTER_CONFIG_PATH=%WINPYDIR%\etc\jupyter

set WINPYARCH=WIN32

if "%WINPYDIR:~-5%"=="amd64" set WINPYARCH=WIN-AMD64

set FINDDIR=%WINDIR%\system32

echo ";%PATH%;" | %FINDDIR%\find.exe /C /I ";%WINPYDIR%\;" >nul

if %ERRORLEVEL% NEQ 0 (

set "PATH="""

+ path

+ r""""

cd .

)

rem force default pyqt5 kit for Spyder if PyQt5 module is there

if exist "%WINPYDIR%\Lib\site-packages\PyQt5\__init__.py" set QT_API=pyqt5

rem ******************

rem handle R if included

rem ******************

if not exist "%WINPYDIRBASE%\t\R\bin" goto r_bad

set R_HOME=%WINPYDIRBASE%\t\R

if "%WINPYARCH%"=="WIN32" set R_HOMEbin=%R_HOME%\bin\i386

if not "%WINPYARCH%"=="WIN32" set R_HOMEbin=%R_HOME%\bin\x64

:r_bad

rem ******************

rem handle Julia if included

rem ******************

if not exist "%WINPYDIRBASE%\t\Julia\bin" goto julia_bad

set JULIA_HOME=%WINPYDIRBASE%\t\Julia\bin\

set JULIA_EXE=julia.exe

set JULIA=%JULIA_HOME%%JULIA_EXE%

set JULIA_PKGDIR=%WINPYDIRBASE%\settings\.julia

:julia_bad

rem ******************

rem handle PySide2 if included

rem ******************

set tmp_pyz=%WINPYDIR%\Lib\site-packages\PySide2

if not exist "%tmp_pyz%" goto pyside2_conf_exist

set tmp_pyz=%tmp_pyz%\qt.conf

if not exist "%tmp_pyz%" (

echo [Paths]

echo Prefix = .

echo Binaries = .

)>> "%tmp_pyz%"

:pyside2_conf_exist

rem ******************

rem handle PyQt5 if included

rem ******************

set tmp_pyz=%WINPYDIR%\Lib\site-packages\PyQt5

if not exist "%tmp_pyz%" goto pyqt5_conf_exist

set tmp_pyz=%tmp_pyz%\qt.conf

if not exist "%tmp_pyz%" (

echo [Paths]

echo Prefix = .

echo Binaries = .

)>> "%tmp_pyz%"

:pyqt5_conf_exist

rem ******************

rem handle pyqt5_tools if included

rem ******************

set tmp_pyz=%WINPYDIR%\Lib\site-packages\pyqt5_tools

if not exist "%tmp_pyz%" goto end_pyqt5_tools_conf

set QT_PLUGIN_PATH=%WINPYDIR%\Lib\site-packages\pyqt5_tools\Qt\plugins

:end_pyqt5_tools_conf

rem ******************

rem handle Pyzo configuration part

rem ******************

if not exist "%HOME%\.pyzo" mkdir %HOME%\.pyzo

if exist "%HOME%\.pyzo\config.ssdf" goto after_pyzo_conf

set tmp_pyz="%HOME%\.pyzo\config.ssdf"

(

echo shellConfigs2 = list:

echo dict:

echo name = 'Python'

echo exe = '.\\python.exe'

echo ipython = 'no'

echo gui = 'none'

)>> "%tmp_pyz%"

:after_pyzo_conf

rem ******************

rem WinPython.ini part (removed from nsis)

rem ******************

if not exist "%WINPYDIRBASE%\settings" mkdir "%WINPYDIRBASE%\settings"

if not exist "%WINPYDIRBASE%\settings\AppData" mkdir "%WINPYDIRBASE%\settings\AppData"

if not exist "%WINPYDIRBASE%\settings\AppData\Roaming" mkdir "%WINPYDIRBASE%\settings\AppData\Roaming"

set winpython_ini=%WINPYDIRBASE%\settings\winpython.ini

if not exist "%winpython_ini%" (

echo [debug]

echo state = disabled

echo [environment]

echo ## <?> Uncomment lines to override environment variables

echo #HOME = %%HOMEDRIVE%%%%HOMEPATH%%\Documents\WinPython%%WINPYVER%%

echo #USERPROFILE = %%HOME%%

echo #JUPYTER_DATA_DIR = %%HOME%%

echo #JUPYTERLAB_SETTINGS_DIR = %%HOME%%\.jupyter\lab

echo #JUPYTERLAB_WORKSPACES_DIR = %%HOME%%\.jupyter\lab\workspaces

echo #WINPYWORKDIR = %%HOMEDRIVE%%%%HOMEPATH%%\Documents\WinPython%%WINPYVER%%\Notebooks

)>> "%winpython_ini%"

""",

do_changes=changes,

)

self.create_batch_script(

"WinPython_PS_Prompt.ps1",

r"""

###############################

### WinPython_PS_Prompt.ps1 ###

###############################

$0 = $myInvocation.MyCommand.Definition

$dp0 = [System.IO.Path]::GetDirectoryName($0)

# $env:PYTHONUTF8 = 1 would create issues in "movable" patching