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