LeoVasanko
734b7993a2
Files extracted from a downloaded ZIP carry a Zone.Identifier stream and the .NET Framework CLR refuses to load such assemblies, so pythonnet failed with 'Failed to resolve Python.Runtime.Loader.Initialize'. MSI-installed files have no MOTW; the winmain strip fixes the ZIP distribution.
391 lines
12 KiB
Python
Executable File
391 lines
12 KiB
Python
Executable File
#!/usr/bin/env -S uv run
|
|
"""Build the desktop GUI application and package it as a versioned ZIP/DMG.
|
|
|
|
Usage:
|
|
uv run scripts/winbuild.py
|
|
|
|
This runs in the project environment where dependencies
|
|
are available via pyproject.toml.
|
|
|
|
This script:
|
|
1. Reads the version from pyproject.toml
|
|
2. Runs `uv build` to produce the wheel/sdist
|
|
3. On Windows, downloads the latest ffmpeg.exe for bundling
|
|
4. On macOS arm64, downloads a prebuilt ffmpeg binary for bundling
|
|
4. Builds MediaHive using PyInstaller
|
|
5. Creates a versioned ZIP (Windows/Linux) or DMG (macOS) artifact
|
|
"""
|
|
|
|
import io
|
|
import platform
|
|
import re
|
|
import shutil
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import urllib.request
|
|
import zipfile
|
|
from pathlib import Path
|
|
|
|
import setuptools_scm
|
|
|
|
# BtbN automated builds always publish a 'latest' tag with this asset.
|
|
_FFMPEG_URL = (
|
|
"https://github.com/BtbN/ffmpeg-builds/releases/download/latest"
|
|
"/ffmpeg-master-latest-win64-gpl.zip"
|
|
)
|
|
_MACOS_ARM64_TOOL_URLS = {
|
|
"ffmpeg": "https://www.osxexperts.net/ffmpeg81arm.zip",
|
|
}
|
|
_FFMPEG_STAGING = Path(__file__).parent.parent / "build" / "ffmpeg"
|
|
_REPO_ROOT = Path(__file__).parent.parent
|
|
_ASSETS_DIR = _REPO_ROOT / "mediahive" / "assets"
|
|
|
|
# WiX 3.11 standalone binaries (candle/light/heat run on .NET Framework 4.x,
|
|
# no .NET SDK needed, unlike WiX v4 which is a dotnet tool).
|
|
_WIX_URL = (
|
|
"https://github.com/wixtoolset/wix3/releases/download/wix3112rtm"
|
|
"/wix311-binaries.zip"
|
|
)
|
|
_WIX_STAGING = _REPO_ROOT / "build" / "wix311"
|
|
_WIX_WXS = _REPO_ROOT / "scripts" / "installer" / "MediaHive.wxs"
|
|
|
|
|
|
def _platform_zip_suffix() -> str:
|
|
machine = platform.machine().lower()
|
|
arch = {
|
|
"x86_64": "x64",
|
|
"amd64": "x64",
|
|
"arm64": "arm64",
|
|
"aarch64": "arm64",
|
|
}.get(machine, machine or "unknown")
|
|
|
|
if sys.platform == "win32":
|
|
return "win64"
|
|
if sys.platform == "darwin":
|
|
return f"macos-{arch}"
|
|
return f"linux-{arch}"
|
|
|
|
|
|
def fetch_ffmpeg() -> Path:
|
|
"""Download latest ffmpeg.exe from BtbN builds into build/ffmpeg/."""
|
|
dest = _FFMPEG_STAGING / "ffmpeg.exe"
|
|
if dest.exists():
|
|
print(f"ffmpeg already staged at {dest}, skipping download.")
|
|
return dest
|
|
|
|
_FFMPEG_STAGING.mkdir(parents=True, exist_ok=True)
|
|
print(f"Downloading ffmpeg from {_FFMPEG_URL} ...")
|
|
with urllib.request.urlopen(_FFMPEG_URL) as resp:
|
|
data = resp.read()
|
|
|
|
print("Extracting ffmpeg.exe ...")
|
|
with zipfile.ZipFile(io.BytesIO(data)) as zf:
|
|
# The zip contains a top-level folder; ffmpeg.exe is under .../bin/
|
|
ffmpeg_entry = next(
|
|
name for name in zf.namelist() if name.endswith("/bin/ffmpeg.exe")
|
|
)
|
|
with zf.open(ffmpeg_entry) as src:
|
|
Path(dest).write_bytes(src.read())
|
|
|
|
print(f"ffmpeg staged at {dest} ({dest.stat().st_size // 1024 // 1024} MB)")
|
|
return dest
|
|
|
|
|
|
def fetch_macos_arm64_binaries() -> dict[str, Path]:
|
|
"""Download prebuilt macOS arm64 ffmpeg binary into build/ffmpeg/."""
|
|
if sys.platform != "darwin" or platform.machine().lower() not in {
|
|
"arm64",
|
|
"aarch64",
|
|
}:
|
|
raise RuntimeError("macOS bundling is only supported for arm64 builds")
|
|
|
|
_FFMPEG_STAGING.mkdir(parents=True, exist_ok=True)
|
|
staged: dict[str, Path] = {}
|
|
|
|
for tool_name, url in _MACOS_ARM64_TOOL_URLS.items():
|
|
dest = _FFMPEG_STAGING / tool_name
|
|
if dest.exists():
|
|
print(f"{tool_name} already staged at {dest}, skipping download.")
|
|
staged[tool_name] = dest
|
|
continue
|
|
|
|
print(f"Downloading {tool_name} from {url} ...")
|
|
with urllib.request.urlopen(url) as resp:
|
|
data = resp.read()
|
|
|
|
with zipfile.ZipFile(io.BytesIO(data)) as zf:
|
|
entry_name = next(
|
|
name
|
|
for name in zf.namelist()
|
|
if Path(name).name == tool_name and not name.endswith("/")
|
|
)
|
|
with zf.open(entry_name) as src:
|
|
Path(dest).write_bytes(src.read())
|
|
|
|
dest.chmod(dest.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
|
|
|
|
# Make the bundled binary runnable when copied out of the zip/app on macOS.
|
|
subprocess.run(["xattr", "-cr", str(dest)], check=False)
|
|
subprocess.run(["codesign", "-f", "-s", "-", str(dest)], check=True)
|
|
|
|
staged[tool_name] = dest
|
|
print(
|
|
f"{tool_name} staged at {dest} ({dest.stat().st_size // 1024 // 1024} MB)"
|
|
)
|
|
|
|
return staged
|
|
|
|
|
|
def ensure_macos_icon() -> Path:
|
|
"""Create mediahive.icns from mediahive.ico when building on macOS."""
|
|
icon_icns = _ASSETS_DIR / "mediahive.icns"
|
|
if icon_icns.exists():
|
|
return icon_icns
|
|
|
|
icon_ico = _ASSETS_DIR / "mediahive.ico"
|
|
if not icon_ico.exists():
|
|
raise FileNotFoundError(f"Missing source icon: {icon_ico}")
|
|
|
|
iconset_dir = _REPO_ROOT / "build" / "mediahive.iconset"
|
|
iconset_dir.mkdir(parents=True, exist_ok=True)
|
|
base_png = _REPO_ROOT / "build" / "mediahive-icon-1024.png"
|
|
|
|
subprocess.run(
|
|
["sips", "-s", "format", "png", str(icon_ico), "--out", str(base_png)],
|
|
check=True,
|
|
)
|
|
|
|
size_entries = [
|
|
(16, "icon_16x16.png"),
|
|
(32, "icon_16x16@2x.png"),
|
|
(32, "icon_32x32.png"),
|
|
(64, "icon_32x32@2x.png"),
|
|
(128, "icon_128x128.png"),
|
|
(256, "icon_128x128@2x.png"),
|
|
(256, "icon_256x256.png"),
|
|
(512, "icon_256x256@2x.png"),
|
|
(512, "icon_512x512.png"),
|
|
(1024, "icon_512x512@2x.png"),
|
|
]
|
|
for pixels, name in size_entries:
|
|
subprocess.run(
|
|
[
|
|
"sips",
|
|
"-z",
|
|
str(pixels),
|
|
str(pixels),
|
|
str(base_png),
|
|
"--out",
|
|
str(iconset_dir / name),
|
|
],
|
|
check=True,
|
|
)
|
|
|
|
subprocess.run(
|
|
["iconutil", "-c", "icns", str(iconset_dir), "-o", str(icon_icns)],
|
|
check=True,
|
|
)
|
|
print(f"macOS app icon generated: {icon_icns}")
|
|
return icon_icns
|
|
|
|
|
|
def fetch_wix() -> Path:
|
|
"""Download WiX 3.11 standalone binaries into build/wix311/ (cached)."""
|
|
candle = _WIX_STAGING / "candle.exe"
|
|
if candle.exists():
|
|
print(f"WiX already staged at {_WIX_STAGING}, skipping download.")
|
|
return _WIX_STAGING
|
|
|
|
_WIX_STAGING.mkdir(parents=True, exist_ok=True)
|
|
print(f"Downloading WiX from {_WIX_URL} ...")
|
|
with urllib.request.urlopen(_WIX_URL) as resp:
|
|
data = resp.read()
|
|
|
|
with zipfile.ZipFile(io.BytesIO(data)) as zf:
|
|
zf.extractall(_WIX_STAGING)
|
|
|
|
print(f"WiX staged at {_WIX_STAGING}")
|
|
return _WIX_STAGING
|
|
|
|
|
|
def build_msi(version: str) -> Path:
|
|
"""Build a per-user MSI installer from the PyInstaller output folder.
|
|
|
|
MSI-installed files carry no Mark-of-the-Web, so the .NET CLR loads
|
|
pythonnet/pywebview assemblies that it refuses from a downloaded ZIP.
|
|
"""
|
|
dist_folder = _REPO_ROOT / "build" / "MediaHive"
|
|
if not dist_folder.exists():
|
|
raise FileNotFoundError(f"Distribution folder not found: {dist_folder}")
|
|
|
|
# MSI versions must be numeric x.y.z[.w]; strip any local/pre-release part.
|
|
msi_version = re.match(r"\d+(?:\.\d+){0,3}", version)
|
|
if not msi_version:
|
|
raise ValueError(f"Cannot derive MSI version from {version!r}")
|
|
|
|
wix = fetch_wix()
|
|
obj_dir = _REPO_ROOT / "build" / "wix-obj"
|
|
obj_dir.mkdir(parents=True, exist_ok=True)
|
|
files_wxs = _REPO_ROOT / "build" / "wix-files.wxs"
|
|
msi_path = _REPO_ROOT / "build" / f"MediaHive-{version}-{_platform_zip_suffix()}.msi"
|
|
|
|
def run(tool: str, args: list[str]) -> None:
|
|
cmd = [str(wix / tool), *args]
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, cwd=_REPO_ROOT)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"{tool} failed with exit code {result.returncode}")
|
|
|
|
run("heat.exe", [
|
|
"dir", str(dist_folder),
|
|
"-cg", "MediaHiveFiles",
|
|
"-dr", "INSTALLFOLDER",
|
|
"-gg", "-g1",
|
|
"-sfrag", "-sreg", "-srd",
|
|
"-var", "var.MediaHiveSourceDir",
|
|
"-out", str(files_wxs),
|
|
])
|
|
run("candle.exe", [
|
|
f"-dMediaHiveVersion={msi_version.group(0)}",
|
|
f"-dMediaHiveSourceDir={dist_folder}",
|
|
"-arch", "x64",
|
|
str(_WIX_WXS),
|
|
str(files_wxs),
|
|
"-out", f"{obj_dir}\\",
|
|
])
|
|
run("light.exe", [
|
|
"-ext", "WixUIExtension",
|
|
"-sice:ICE38", "-sice:ICE61", "-sice:ICE64", "-sice:ICE91",
|
|
str(obj_dir / "MediaHive.wixobj"),
|
|
str(obj_dir / "wix-files.wixobj"),
|
|
"-out", str(msi_path),
|
|
])
|
|
return msi_path
|
|
|
|
|
|
def read_version() -> str:
|
|
"""Read version via setuptools_scm (same logic as hatch-vcs)."""
|
|
return setuptools_scm.get_version(root=str(_REPO_ROOT))
|
|
|
|
|
|
def build_wheel() -> None:
|
|
"""Run uv build to produce the wheel and sdist."""
|
|
repo_root = _REPO_ROOT
|
|
cmd = ["uv", "build"]
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, cwd=repo_root)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"uv build failed with exit code {result.returncode}")
|
|
|
|
|
|
def build_executable() -> None:
|
|
"""Run PyInstaller to build the desktop GUI app."""
|
|
repo_root = _REPO_ROOT
|
|
spec_file = Path(__file__).parent / "MediaHive.spec"
|
|
cmd = [
|
|
sys.executable,
|
|
"-m",
|
|
"PyInstaller",
|
|
"--noconfirm",
|
|
"--clean",
|
|
"--distpath",
|
|
str(repo_root / "build"),
|
|
"--workpath",
|
|
str(repo_root / "build" / ".pyinstaller-work"),
|
|
str(spec_file),
|
|
]
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, cwd=repo_root)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"PyInstaller failed with exit code {result.returncode}")
|
|
|
|
|
|
def create_zip(version: str) -> Path:
|
|
"""Create a version-numbered ZIP file of the build/MediaHive folder."""
|
|
repo_root = _REPO_ROOT
|
|
dist_folder = repo_root / "build" / "MediaHive"
|
|
|
|
if not dist_folder.exists():
|
|
raise FileNotFoundError(f"Distribution folder not found: {dist_folder}")
|
|
|
|
zip_name = f"MediaHive-{version}-{_platform_zip_suffix()}.zip"
|
|
zip_path = repo_root / "build" / zip_name
|
|
zip_path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
print(f"Creating {zip_path}...")
|
|
shutil.make_archive(
|
|
str(zip_path.with_suffix("")), # removes .zip so make_archive can add it
|
|
"zip",
|
|
root_dir=str(dist_folder), # zip contents of MediaHive/, not the folder itself
|
|
)
|
|
return zip_path
|
|
|
|
|
|
def create_dmg(version: str) -> Path:
|
|
"""Create a version-numbered DMG containing MediaHive.app (macOS only)."""
|
|
repo_root = _REPO_ROOT
|
|
app_bundle = repo_root / "build" / "MediaHive.app"
|
|
|
|
if not app_bundle.exists():
|
|
raise FileNotFoundError(f"App bundle not found: {app_bundle}")
|
|
|
|
dmg_path = repo_root / "build" / f"MediaHive-{version}-{_platform_zip_suffix()}.dmg"
|
|
dmg_path.parent.mkdir(parents=True, exist_ok=True)
|
|
dmg_path.unlink(missing_ok=True)
|
|
|
|
cmd = [
|
|
"hdiutil", "create",
|
|
"-volname", "MediaHive",
|
|
"-srcfolder", str(app_bundle),
|
|
"-ov",
|
|
"-format", "UDZO",
|
|
str(dmg_path),
|
|
]
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, cwd=repo_root)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"hdiutil failed with exit code {result.returncode}")
|
|
return dmg_path
|
|
|
|
|
|
def main() -> None:
|
|
# Windows consoles default to cp1252, which can't encode ✓/✗
|
|
sys.stdout.reconfigure(errors="replace")
|
|
sys.stderr.reconfigure(errors="replace")
|
|
try:
|
|
version = read_version()
|
|
print(f"MediaHive version: {version}")
|
|
|
|
if sys.platform == "win32":
|
|
fetch_ffmpeg()
|
|
elif sys.platform == "darwin":
|
|
fetch_macos_arm64_binaries()
|
|
ensure_macos_icon()
|
|
else:
|
|
print(
|
|
"Skipping ffmpeg bundling on this platform "
|
|
"(uses system ffmpeg if available)."
|
|
)
|
|
build_wheel()
|
|
build_executable()
|
|
if sys.platform == "darwin":
|
|
artifact_path = create_dmg(version)
|
|
else:
|
|
artifact_path = create_zip(version)
|
|
|
|
print(f"✓ Built successfully: {artifact_path}")
|
|
print(f" Size: {artifact_path.stat().st_size / (1024 * 1024):.1f} MB")
|
|
|
|
if sys.platform == "win32":
|
|
msi_path = build_msi(version)
|
|
print(f"✓ Built successfully: {msi_path}")
|
|
print(f" Size: {msi_path.stat().st_size / (1024 * 1024):.1f} MB")
|
|
except (FileNotFoundError, OSError, RuntimeError, ValueError) as e:
|
|
print(f"✗ Build failed: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|