pyappdist 0.1.0__tar.gz

pyappdist-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atsuo Ishimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyappdist-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: pyappdist
+Version: 0.1.0
+Summary: Turn a Python app into a Windows installer(msi)
+Keywords: windows,installer,msi,packaging,distribution,wheel,wix
+Author: Atsuo Ishimoto
+Author-email: Atsuo Ishimoto <atsuoishimoto@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: System :: Software Distribution
+Requires-Dist: packaging>=23
+Requires-Dist: pip>=26.1.1
+Requires-Dist: tomlkit>=0.15.0
+Requires-Dist: wheel>=0.47.0
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/atsuoishimoto/pyappdist
+Project-URL: Documentation, https://pyappdist.readthedocs.io/
+Project-URL: Repository, https://github.com/atsuoishimoto/pyappdist
+Project-URL: Issues, https://github.com/atsuoishimoto/pyappdist/issues
+Description-Content-Type: text/markdown
+
+# pyappdist
+
+**Turn a Python app into a Windows installer — and it just works.**
+
+> ⚠️ **Alpha.** pyappdist is under active development. It works end-to-end today, but the
+> config schema, CLI, and output layout may still change without notice.
+
+pyappdist does **not** freeze your code. Instead of bundling Python and your app into a
+single executable (and fighting hidden imports, data files, and plugins along the way),
+it installs your app into a real, dedicated Python runtime — exactly the way `pip` would —
+and ships that.
+
+Because the runtime is a normal Python environment, **most apps run as-is**: no hooks, no
+`--hidden-import`, no `--add-data`, no per-library workarounds. If it runs under `uv run`,
+it almost certainly runs after `pyappdist build`. C extensions, `abi3` wheels, Qt plugins,
+and tkinter-based GUIs work unmodified because the install layout is real.
+
+## Quick start
+
+Add a `[tool.pyappdist]` section to your app's `pyproject.toml`:
+
+```toml
+[tool.pyappdist]
+name = "My App"
+python = "3.12"
+target = "windows-x86_64"
+
+[[tool.pyappdist.launchers]]
+name = "myapp"              # produces myapp.exe
+entry = "myapp:main"        # module:callable
+
+[tool.pyappdist.wix]
+manufacturer = "Example Inc."
+```
+
+Then add pyappdist and build:
+
+```bash
+uv add --dev pyappdist
+uv run pyappdist build .    # wheels -> runtime -> image -> launcher -> wix -> MSI
+```
+
+The result lands under `appdist/dist/`: a portable `.zip` and an `.msi` installer.
+
+## Documentation
+
+Full documentation lives in the [`docs/`](docs/) directory (Sphinx / Read the Docs):
+
+- [Installation & requirements](docs/installation.rst)
+- [Quick start](docs/quickstart.rst)
+- [How it works](docs/how-it-works.rst)
+- [Configuration reference](docs/configuration.rst)
+- [CLI reference](docs/cli.rst)
+- [Dependency resolution](docs/dependencies.rst)
+- [Code signing](docs/signing.rst)
+- [Samples](docs/samples.rst)
+
+## Status
+
+**Alpha** — the pipeline works end-to-end, but expect breaking changes to the config
+schema, CLI, and output layout as it matures.
+
+Windows x64 is the current target. macOS/Linux packaging, auto-update, and code-signing
+certificates are out of scope for now. Distributed apps are not obfuscated, and unsigned
+installers will trigger a SmartScreen warning.

pyappdist-0.1.0/README.md

@@ -0,0 +1,65 @@
+# pyappdist
+
+**Turn a Python app into a Windows installer — and it just works.**
+
+> ⚠️ **Alpha.** pyappdist is under active development. It works end-to-end today, but the
+> config schema, CLI, and output layout may still change without notice.
+
+pyappdist does **not** freeze your code. Instead of bundling Python and your app into a
+single executable (and fighting hidden imports, data files, and plugins along the way),
+it installs your app into a real, dedicated Python runtime — exactly the way `pip` would —
+and ships that.
+
+Because the runtime is a normal Python environment, **most apps run as-is**: no hooks, no
+`--hidden-import`, no `--add-data`, no per-library workarounds. If it runs under `uv run`,
+it almost certainly runs after `pyappdist build`. C extensions, `abi3` wheels, Qt plugins,
+and tkinter-based GUIs work unmodified because the install layout is real.
+
+## Quick start
+
+Add a `[tool.pyappdist]` section to your app's `pyproject.toml`:
+
+```toml
+[tool.pyappdist]
+name = "My App"
+python = "3.12"
+target = "windows-x86_64"
+
+[[tool.pyappdist.launchers]]
+name = "myapp"              # produces myapp.exe
+entry = "myapp:main"        # module:callable
+
+[tool.pyappdist.wix]
+manufacturer = "Example Inc."
+```
+
+Then add pyappdist and build:
+
+```bash
+uv add --dev pyappdist
+uv run pyappdist build .    # wheels -> runtime -> image -> launcher -> wix -> MSI
+```
+
+The result lands under `appdist/dist/`: a portable `.zip` and an `.msi` installer.
+
+## Documentation
+
+Full documentation lives in the [`docs/`](docs/) directory (Sphinx / Read the Docs):
+
+- [Installation & requirements](docs/installation.rst)
+- [Quick start](docs/quickstart.rst)
+- [How it works](docs/how-it-works.rst)
+- [Configuration reference](docs/configuration.rst)
+- [CLI reference](docs/cli.rst)
+- [Dependency resolution](docs/dependencies.rst)
+- [Code signing](docs/signing.rst)
+- [Samples](docs/samples.rst)
+
+## Status
+
+**Alpha** — the pipeline works end-to-end, but expect breaking changes to the config
+schema, CLI, and output layout as it matures.
+
+Windows x64 is the current target. macOS/Linux packaging, auto-update, and code-signing
+certificates are out of scope for now. Distributed apps are not obfuscated, and unsigned
+installers will trigger a SmartScreen warning.

pyappdist-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "pyappdist"
+version = "0.1.0"
+description = "Turn a Python app into a Windows installer(msi)"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Atsuo Ishimoto", email = "atsuoishimoto@gmail.com" },
+]
+keywords = ["windows", "installer", "msi", "packaging", "distribution", "wheel", "wix"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Environment :: Win32 (MS Windows)",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Installation/Setup",
+    "Topic :: System :: Software Distribution",
+]
+dependencies = [
+    "packaging>=23",
+    "pip>=26.1.1",
+    "tomlkit>=0.15.0",
+    "wheel>=0.47.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/atsuoishimoto/pyappdist"
+Documentation = "https://pyappdist.readthedocs.io/"
+Repository = "https://github.com/atsuoishimoto/pyappdist"
+Issues = "https://github.com/atsuoishimoto/pyappdist/issues"
+
+[project.scripts]
+pyappdist = "pyappdist.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["uv_build>=0.11.6,<0.12.0"]
+build-backend = "uv_build"

pyappdist-0.1.0/src/pyappdist/_hostexec.py

@@ -0,0 +1,30 @@
+"""Execution helpers that absorb host/target differences.
+
+When handling a Windows target from WSL (a Linux host), Windows tools (uv.exe)
+must be invoked and paths converted to Windows form (wslpath -w).
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from .targets import Target
+
+
+def is_cross_windows(target: Target) -> bool:
+    """Handling a Windows target from a Linux host (requires the .exe bridge)."""
+    return target.os == "windows" and sys.platform != "win32"
+
+
+def target_path(target: Target, path: Path | str) -> str:
+    """Path string to pass to a target tool."""
+    p = Path(path)
+    if is_cross_windows(target):
+        out = subprocess.run(
+            ["wslpath", "-w", str(p)], capture_output=True, text=True,
+            errors="replace", check=True,
+        )
+        return out.stdout.strip()
+    return str(p)

pyappdist-0.1.0/src/pyappdist/cli.py

@@ -0,0 +1,199 @@
+"""pyappdist CLI.
+
+Subcommands:
+  build-wheels   app + dependency wheels into appdist/wheelhouse
+  fetch-runtime  python-build-standalone runtime into appdist/runtime
+  build-image    runtime + install + compileall + launcher + portable zip into appdist/image
+  build-launchers build launcher.exe inside the image (Windows, MSVC)
+  gen-wix        scan the image and generate WiX XML (.wxs)
+  build          run wheels->runtime->image->launcher->wix->MSI in one go
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import sys
+from pathlib import Path
+
+from . import image as image_mod
+from .config import ensure_upgrade_code, load_config
+from .context import BuildContext
+from .errors import BuildError, PyappdistError
+from .launcher import build_launchers
+from .runtime import fetch_runtime
+from .sign import sign_artifact
+from .wheels import build_wheelhouse
+from .wix import build_msi, generate_wxs, scan_image
+
+
+def _build_context(args: argparse.Namespace) -> BuildContext:
+    project_dir = Path(args.project).resolve()
+    config = load_config(project_dir, target_override=args.target)
+    out_dir = Path(args.out_dir).resolve() if args.out_dir else project_dir / "appdist"
+    return BuildContext(config=config, out_dir=out_dir)
+
+
+def _do_fetch_runtime(ctx: BuildContext, args: argparse.Namespace):
+    return fetch_runtime(
+        ctx.config.target,
+        ctx.config.python,
+        ctx.runtime_dir,
+        runtime_source=Path(args.runtime_source) if args.runtime_source else None,
+        runtime_release=args.runtime_release,
+    )
+
+
+def cmd_build_wheels(args: argparse.Namespace) -> int:
+    ctx = _build_context(args)
+    # Dependencies are resolved with the target runtime's python, so prepare the runtime first.
+    info = _do_fetch_runtime(ctx, args)
+    wheels = build_wheelhouse(ctx.config, info, ctx.wheelhouse)
+    print(f"OK: {len(wheels)} wheel -> {ctx.wheelhouse}")
+    return 0
+
+
+def cmd_fetch_runtime(args: argparse.Namespace) -> int:
+    ctx = _build_context(args)
+    info = _do_fetch_runtime(ctx, args)
+    print(f"OK: runtime {info.version} -> {ctx.runtime_dir}")
+    return 0
+
+
+def cmd_build_image(args: argparse.Namespace) -> int:
+    ctx = _build_context(args)
+    info = _do_fetch_runtime(ctx, args)
+    build_wheelhouse(ctx.config, info, ctx.wheelhouse)
+    layout = image_mod.build_image(ctx, info, compile_pyc=not args.no_compile)
+    exes = build_launchers(ctx.config, layout, ctx.out_dir / "_launcher_build")
+    # The zip includes launcher.exe, so do it after the launcher build.
+    if not args.no_zip:
+        image_mod.make_portable_zip(ctx)
+    print(f"OK: image -> {layout.image_dir} ({len(exes)} launcher)")
+    return 0
+
+
+def cmd_build_launchers(args: argparse.Namespace) -> int:
+    ctx = _build_context(args)
+    if not ctx.image_dir.is_dir():
+        raise BuildError(
+            f"image is missing: {ctx.image_dir} (run build-image first)"
+        )
+    layout = image_mod.ImageLayout(
+        image_dir=ctx.image_dir,
+        target=ctx.config.target,
+        minor=ctx.config.python_minor,
+    )
+    exes = build_launchers(ctx.config, layout, ctx.out_dir / "_launcher_build")
+    print(f"OK: {len(exes)} launcher -> {layout.image_dir}")
+    return 0
+
+
+def _write_wxs(ctx: BuildContext) -> Path:
+    # Ensure a stable upgrade_code exists (generated and persisted to pyproject.toml if unset).
+    upgrade_code = ensure_upgrade_code(ctx.config.project_dir)
+    config = ctx.config
+    if config.wix.upgrade_code != upgrade_code:
+        config = dataclasses.replace(
+            config, wix=dataclasses.replace(config.wix, upgrade_code=upgrade_code)
+        )
+    tree = scan_image(ctx.image_dir)
+    xml = generate_wxs(config, tree)
+    wxs = ctx.out_dir / f"{ctx.config.dist_name}.wxs"
+    wxs.write_text(xml, encoding="utf-8")
+    return wxs
+
+
+def cmd_gen_wix(args: argparse.Namespace) -> int:
+    ctx = _build_context(args)
+    if not ctx.image_dir.is_dir():
+        raise BuildError(f"image is missing: {ctx.image_dir} (run build-image first)")
+    wxs = _write_wxs(ctx)
+    print(f"OK: wxs -> {wxs}")
+    return 0
+
+
+def cmd_build(args: argparse.Namespace) -> int:
+    """Run wheelhouse -> runtime -> image -> launcher -> wix -> MSI in one go (Phase 5)."""
+    ctx = _build_context(args)
+    info = _do_fetch_runtime(ctx, args)
+    build_wheelhouse(ctx.config, info, ctx.wheelhouse)
+    layout = image_mod.build_image(ctx, info, compile_pyc=not args.no_compile)
+    exes = build_launchers(ctx.config, layout, ctx.out_dir / "_launcher_build")
+    for exe in exes:
+        sign_artifact(exe)
+    if not args.no_zip:
+        image_mod.make_portable_zip(ctx)
+
+    wxs = _write_wxs(ctx)
+    msi_name = f"{ctx.config.dist_name}-{ctx.config.version}.msi"
+    msi = build_msi(ctx.config, ctx.image_dir, wxs, ctx.dist_dir / msi_name)
+    if msi is not None:
+        sign_artifact(msi)
+        print(f"OK: msi -> {msi} ({len(exes)} launcher)")
+    else:
+        print(f"OK: image -> {layout.image_dir} (msi skipped on non-Windows)")
+    return 0
+
+
+def _add_common(p: argparse.ArgumentParser) -> None:
+    p.add_argument("project", nargs="?", default=".", help="the app's project directory")
+    p.add_argument("--target", help="distribution target (e.g. windows-x86_64 / linux-x86_64)")
+    p.add_argument("--out-dir", help="output directory (default: <project>/appdist)")
+
+
+def _add_runtime_opts(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--runtime-release", help="pin the python-build-standalone release tag")
+    p.add_argument("--runtime-source", help="local runtime tar.gz (offline)")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="pyappdist", description="Create a Windows distribution of a Python app")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("build-wheels", help="wheels into appdist/wheelhouse")
+    _add_common(p)
+    _add_runtime_opts(p)
+    p.set_defaults(func=cmd_build_wheels)
+
+    p = sub.add_parser("fetch-runtime", help="runtime into appdist/runtime")
+    _add_common(p)
+    _add_runtime_opts(p)
+    p.set_defaults(func=cmd_fetch_runtime)
+
+    p = sub.add_parser("build-image", help="image into appdist/image")
+    _add_common(p)
+    _add_runtime_opts(p)
+    p.add_argument("--no-compile", action="store_true", help="skip compileall")
+    p.add_argument("--no-zip", action="store_true", help="do not create a portable zip")
+    p.set_defaults(func=cmd_build_image)
+
+    p = sub.add_parser("build-launchers", help="build launcher.exe into the image (Windows)")
+    _add_common(p)
+    p.set_defaults(func=cmd_build_launchers)
+
+    p = sub.add_parser("gen-wix", help="generate WiX XML (.wxs) from the image")
+    _add_common(p)
+    p.set_defaults(func=cmd_gen_wix)
+
+    p = sub.add_parser("build", help="run wheels->runtime->image->launcher->wix->MSI in one go")
+    _add_common(p)
+    _add_runtime_opts(p)
+    p.add_argument("--no-compile", action="store_true")
+    p.add_argument("--no-zip", action="store_true")
+    p.set_defaults(func=cmd_build)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except PyappdistError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyappdist-0.1.0/src/pyappdist/config.py

@@ -0,0 +1,176 @@
+"""Loading and validation of ``[tool.pyappdist]``.
+
+Treats pyproject.toml as the single source of truth and normalizes it into a
+typed dataclass.
+"""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+from .errors import ConfigError
+from .targets import Target, get_target
+
+_PYTHON_RE = re.compile(r"^\d+\.\d+(\.\d+)?$")
+
+_MANAGERS = ("uv", "poetry", "pipenv", "pdm", "requirements.txt")
+
+
+@dataclass(frozen=True)
+class LauncherConfig:
+    name: str           # output exe name (without extension)
+    entry: str          # "module:callable"
+    gui: bool = False
+    icon: str | None = None
+    args: str = ""      # fixed arguments (single string)
+
+
+@dataclass(frozen=True)
+class WixConfig:
+    manufacturer: str | None = None
+    upgrade_code: str | None = None
+
+
+@dataclass(frozen=True)
+class Config:
+    project_dir: Path
+    name: str           # display name
+    dist_name: str      # distribution package name ([project].name)
+    version: str
+    python: str         # "X.Y" or "X.Y.Z"
+    target: Target
+    identifier: str | None
+    launchers: tuple[LauncherConfig, ...]
+    wix: WixConfig
+    manager: str | None  # manager used for dependency resolution (uv/poetry/pipenv/pdm/requirements.txt). None=auto-detect
+
+    @property
+    def python_minor(self) -> str:
+        parts = self.python.split(".")
+        return f"{parts[0]}.{parts[1]}"
+
+
+def load_config(project_dir: Path, *, target_override: str | None = None) -> Config:
+    project_dir = Path(project_dir).resolve()
+    pyproject = project_dir / "pyproject.toml"
+    if not pyproject.is_file():
+        raise ConfigError(f"pyproject.toml not found: {pyproject}")
+
+    data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+    project = data.get("project", {})
+    tool = data.get("tool", {}).get("pyappdist")
+    if tool is None:
+        raise ConfigError(f"[tool.pyappdist] is missing: {pyproject}")
+
+    dist_name = project.get("name")
+    if not dist_name:
+        raise ConfigError("[project].name is required")
+    name = tool.get("name") or dist_name
+
+    version = tool.get("version") or project.get("version") or "0.0.0"
+
+    python = tool.get("python")
+    if not python:
+        raise ConfigError("[tool.pyappdist].python is required (e.g. \"3.12\")")
+    if not _PYTHON_RE.match(str(python)):
+        raise ConfigError(f"python must be in X.Y or X.Y.Z format: {python!r}")
+
+    target_name = target_override or tool.get("target") or "windows-x86_64"
+    target = get_target(target_name)
+
+    launchers = _parse_launchers(tool.get("launchers"))
+    wix = _parse_wix(tool.get("wix"))
+
+    manager = tool.get("manager")
+    if manager is not None and manager not in _MANAGERS:
+        raise ConfigError(
+            f"[tool.pyappdist].manager must be one of {_MANAGERS}: {manager!r}"
+        )
+
+    return Config(
+        project_dir=project_dir,
+        name=str(name),
+        dist_name=str(dist_name),
+        version=str(version),
+        python=str(python),
+        target=target,
+        identifier=tool.get("identifier"),
+        launchers=launchers,
+        wix=wix,
+        manager=manager,
+    )
+
+
+def _parse_launchers(raw: object) -> tuple[LauncherConfig, ...]:
+    if raw is None:
+        return ()
+    if not isinstance(raw, list):
+        raise ConfigError("[tool.pyappdist].launchers must be an array")
+    out: list[LauncherConfig] = []
+    for i, item in enumerate(raw):
+        if not isinstance(item, dict):
+            raise ConfigError(f"launchers[{i}] must be a table")
+        name = item.get("name")
+        entry = item.get("entry")
+        if not name:
+            raise ConfigError(f"launchers[{i}].name is required")
+        if not entry or ":" not in str(entry):
+            raise ConfigError(
+                f"launchers[{i}].entry must be in \"module:callable\" format: {entry!r}"
+            )
+        out.append(
+            LauncherConfig(
+                name=str(name),
+                entry=str(entry),
+                gui=bool(item.get("gui", False)),
+                icon=item.get("icon"),
+                args=str(item.get("args", "")),
+            )
+        )
+    return tuple(out)
+
+
+def ensure_upgrade_code(project_dir: Path, *, log=print) -> str:
+    """Return the WiX upgrade_code, generating and persisting one if unset.
+
+    The upgrade code identifies the product across versions for MSI MajorUpgrade,
+    so it must stay stable across builds. When it is missing from pyproject.toml we
+    generate a UUID and write it back into [tool.pyappdist.wix], editing with
+    tomlkit so existing formatting and comments are preserved.
+    """
+    import uuid
+
+    import tomlkit
+
+    from .wix.guid import is_guid
+
+    pyproject = Path(project_dir).resolve() / "pyproject.toml"
+    doc = tomlkit.parse(pyproject.read_text(encoding="utf-8"))
+
+    wix = doc.get("tool", {}).get("pyappdist", {}).get("wix")
+    existing = wix.get("upgrade_code") if wix is not None else None
+    if existing and is_guid(str(existing)):
+        return str(existing)
+
+    code = str(uuid.uuid4()).upper()
+    tool = doc.setdefault("tool", tomlkit.table())
+    pyappdist = tool.setdefault("pyappdist", tomlkit.table())
+    wix_tbl = pyappdist.setdefault("wix", tomlkit.table())
+    wix_tbl["upgrade_code"] = code
+    pyproject.write_text(tomlkit.dumps(doc), encoding="utf-8")
+    log(f"wix: generated upgrade_code {code} -> {pyproject}")
+    return code
+
+
+def _parse_wix(raw: object) -> WixConfig:
+    if raw is None:
+        return WixConfig()
+    if not isinstance(raw, dict):
+        raise ConfigError("[tool.pyappdist.wix] must be a table")
+    return WixConfig(
+        manufacturer=raw.get("manufacturer"),
+        upgrade_code=raw.get("upgrade_code"),
+    )

pyappdist-0.1.0/src/pyappdist/context.py

@@ -0,0 +1,30 @@
+"""Container for paths and settings shared across the whole build."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .config import Config
+
+
+@dataclass(frozen=True)
+class BuildContext:
+    config: Config
+    out_dir: Path  # appdist/
+
+    @property
+    def wheelhouse(self) -> Path:
+        return self.out_dir / "wheelhouse"
+
+    @property
+    def runtime_dir(self) -> Path:
+        return self.out_dir / "runtime"
+
+    @property
+    def image_dir(self) -> Path:
+        return self.out_dir / "image"
+
+    @property
+    def dist_dir(self) -> Path:
+        return self.out_dir / "dist"