Repository navigation
Expand file tree
/
Copy pathbuild_winpython_meta.py
More file actions
157 lines (139 loc) · 6.63 KB
/
Copy pathbuild_winpython_meta.py
File metadata and controls
157 lines (139 loc) · 6.63 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
155
156
157
# 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")
# wheels only, unless a flavor still has a package with no wheel for its target
my_only_binary = "yes" if build.get("only_binary", True) else "no"
# 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,
"--only-binary", my_only_binary,
"--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()