GeezerVison is showing github.com — winpython/build_winpython_meta.py at 17.12.20260522/WinPython · winpython/winpython

Expand file tree

build_winpython_meta.py

Copy path

More file actions

Latest commit

History

154 lines (136 loc) · 6.44 KB

build_winpython_meta.py

Copy path

File metadata and controls

154 lines (136 loc) · 6.44 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

# build_winpython_meta.py

# Local builds are made with Python 3.11 or later.

import os

import sys

import tomllib # stdlib since 3.11; we choose toml over yaml, more python standard

import subprocess

from pathlib import Path

# Flavor paths are names, not full paths: these say what they hang from.

UNDER_BASEDIR = ("requirements", "source_dirs", "wheelhousereq")

UNDER_ROOT = ("toolsdirs",)

def load_builds(config_file):

with open(config_file, "rb") as f:

config = tomllib.load(f)

python_versions = config.get("pythons", {})

# A file may still spell out one [[builds]] block per build; otherwise the

# builds are the (python, flavor) pairs [pythons] asks for.

builds = config["builds"] if "builds" in config else expand_builds(config)

return builds, python_versions

def expand_builds(config):

"""One build per flavor listed by each [pythons."3XX"], paths derived.

A flavor names its files relative to the build directory, so a new Python

minor is one [pythons] block. Where a Python needs its own file - a

requirements list under another name, say - [pythons."3XX".overrides.flavor]

replaces that flavor's entries for that Python alone.

"""

defaults = config.get("defaults", {})

flavors = config.get("flavors", {})

builds = []

for target, vinfo in config.get("pythons", {}).items():

root = Path(vinfo.get("root_dir_for_builds", defaults.get("root_dir_for_builds", "")))

basedir = root / f"bd{target}"

overrides = vinfo.get("overrides", {})

for flavor in vinfo.get("builds", []):

if flavor not in flavors:

raise KeyError(f"python {target} builds {flavor!r}, which has no [flavors.{flavor}]")

build = {**defaults, "name": flavor, "python_target": target, "flavor": flavor}

for key, value in {**flavors[flavor], **overrides.get(flavor, {})}.items():

if key in UNDER_BASEDIR:

value = str(basedir / value)

elif key in UNDER_ROOT:

value = str(root / value)

build[key] = value

builds.append(build)

return builds

def select_builds(builds, wanted):

"""Builds asked for on the command line: "315", "315:slim", ":slim"."""

if not wanted:

return builds

kept = []

for spec in wanted:

target, _, flavor = spec.partition(":")

matching = [b for b in builds

if (not target or b["python_target"] == target)

and (not flavor or b["flavor"] == flavor)]

if not matching:

raise SystemExit(f"no build matches {spec!r}")

kept += [b for b in matching if b not in kept]

return kept

def must_exist(path, build, key):

"""pip_install() skips a missing requirements file without failing, which

would drop those packages silently. Say so instead."""

if path and not Path(path).exists():

raise FileNotFoundError(f"build {build['name']!r} needs {key} = {path!r}, which does not exist")

return path

def declared_file(build, key, default):

"""Path named by the build for `key`, else `default`."""

declared = build.get(key)

return str(default) if declared is None else must_exist(str(declared), build, key)

def run_build(build, python_versions, dry_run=False):

print(f"\n=== Building WinPython: {build['python_target']} {build['name']} ===")

print(build)

root_dir_for_builds = build["root_dir_for_builds"]

my_python_target = build["python_target"]

my_flavor = build["flavor"]

my_arch = str(build["arch"])

my_create_installer = build.get("create_installer", "True")

my_requirements = must_exist(build.get("requirements", ""), build, "requirements")

my_source_dirs = build.get("source_dirs", "")

my_find_links = build.get("find_links", "")

my_toolsdirs = build.get("toolsdirs", "")

wheelhousereq = must_exist(build.get("wheelhousereq", ""), build, "wheelhousereq")

# "pip" (default, what ships) | "none" | "parallel" | "parallel-N"

my_bytecode = build.get("bytecode", "pip")

# Get Python release info from TOML [pythons]

py_target = my_python_target

vinfo = python_versions.get(py_target, {})

my_python_target_release = vinfo.get("python_target_release", "")

my_release = vinfo.get("release", "")

my_release_level = vinfo.get("my_release_level", "b0")

# A build may name its own file for a specific problem; otherwise the one

# shipped beside this script is used.

here = Path(__file__).parent

mandatory_requirements = declared_file(build, "mandatory_requirements", here / "mandatory_requirements.txt")

my_constraints = declared_file(build, "constraints", here / "constraints.txt")

# Build directory logic

my_basedir = f"{root_dir_for_builds}\\bd{my_python_target}"

my_WINPYDIRBASE = f"{my_basedir}\\bu{my_flavor}\\WPy{my_arch}-{my_python_target_release}{my_release}{my_release_level}"

# Build env paths (customize as needed) already defined per the launcher of that script...

my_python_exe = Path(sys.executable)

my_buildenvi = str(my_python_exe.parent)

my_archive_dir = os.path.join(os.getcwd(), "WinPython_build_logs")

os.makedirs(my_archive_dir, exist_ok=True)

# Build command

build_cmd = [

str(my_python_exe),

"-m", "winpython.build_winpython",

"--buildenv", my_buildenvi,

"--python-target", my_python_target,

"--release", my_release,

"--release-level", my_release_level,

"--winpydirbase", my_WINPYDIRBASE,

"--flavor", my_flavor,

"--source_dirs", my_source_dirs,

"--tools_dirs", my_toolsdirs,

"--log-dir", my_archive_dir,

"--mandatory-req", mandatory_requirements,

"--requirements", my_requirements,

"--constraints", my_constraints,

"--find-links", my_find_links,

"--wheelhousereq", wheelhousereq,

"--bytecode", my_bytecode,

"--create-installer", my_create_installer,

]

print("Dry run, build command:" if dry_run else "Running build command:")

print(" ".join(build_cmd))

if not dry_run:

subprocess.run(build_cmd, check=False)

def main():

args = [a for a in sys.argv[1:] if a != "--dry-run"]

dry_run = len(args) != len(sys.argv) - 1

config_file = args[0] if args else "winpython_builds.toml"

builds, python_versions = load_builds(config_file)

for build in select_builds(builds, args[1:]):

run_build(build, python_versions, dry_run)

if __name__ == "__main__":

main()