xbuild 0.0.1__py3-none-any.whl

xbuild/__init__.py

@@ -0,0 +1,20 @@
+__all__ = [
+    "__version__",
+]
+
+try:
+    # Read version from SCM metadata
+    # This will only exist in a development environment
+    from setuptools_scm import get_version
+
+    # Excluded from coverage because a pure test environment (such as the one
+    # used by tox in CI) won't have setuptools_scm
+    __version__ = get_version("../..", relative_to=__file__)  # pragma: no cover
+except (ModuleNotFoundError, LookupError):  # pragma: no-cover-if-missing-setuptools_scm
+    # If setuptools_scm isn't in the environment, the call to import will fail.
+    # If it *is* in the environment, but the code isn't a git checkout (e.g.,
+    # it's been pip installed non-editable) the call to get_version() will fail.
+    # If either of these occurs, read version from the installer metadata.
+    from importlib.metadata import version
+
+    __version__ = version("xbuild")

xbuild/__main__.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Sequence
+from functools import partial
+
+from build import ProjectBuilder
+from build import env as _env
+from build.__main__ import (
+    _cprint,
+    _handle_build_error,
+    _max_terminal_width,
+    _natural_language_list,
+    _setup_cli,
+    _styles,
+)
+from build._types import ConfigSettings, Distribution, StrPath
+from build.env import DefaultIsolatedEnv
+
+import xbuild
+
+
+def _build_in_isolated_env(
+    srcdir: StrPath,
+    outdir: StrPath,
+    distribution: Distribution,
+    config_settings: ConfigSettings | None,
+    installer: _env.Installer,
+) -> str:
+    with DefaultIsolatedEnv(installer=installer) as env:
+        builder = ProjectBuilder.from_isolated_env(env, srcdir)
+        # first install the build dependencies
+        env.install(builder.build_system_requires)
+        # then get the extra required dependencies from the backend
+        # (which was installed in the call above :P)
+        env.install(builder.get_requires_for_build(distribution, config_settings or {}))
+        return builder.build(distribution, outdir, config_settings or {})
+
+
+def main_parser() -> argparse.ArgumentParser:
+    """Construct the main parser."""
+    formatter_class = partial(
+        argparse.RawDescriptionHelpFormatter, width=min(_max_terminal_width, 127)
+    )
+    # Workaround for 3.14.0 beta 1, can remove once beta 2 is out
+    if sys.version_info >= (3, 14):
+        formatter_class = partial(formatter_class, color=True)
+
+    make_parser = partial(
+        argparse.ArgumentParser,
+        description="A cross-platform build backend for Python",
+        # Prevent argparse from taking up the entire width of the terminal window
+        # which impedes readability. Also keep the description formatted.
+        formatter_class=formatter_class,
+    )
+    if sys.version_info >= (3, 14):
+        make_parser = partial(make_parser, suggest_on_error=True, color=True)
+
+    parser = make_parser()
+    parser.add_argument(
+        "srcdir",
+        type=str,
+        nargs="?",
+        default=os.getcwd(),
+        help="source directory (defaults to current directory)",
+    )
+    parser.add_argument(
+        "--version",
+        "-V",
+        action="version",
+        version=f"xbuild {xbuild.__version__} ({','.join(xbuild.__path__)})",
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        dest="verbosity",
+        action="count",
+        default=0,
+        help="increase verbosity",
+    )
+    # parser.add_argument(
+    #     "--sdist",
+    #     "-s",
+    #     dest="distributions",
+    #     action="append_const",
+    #     const="sdist",
+    #     help="build a source distribution (disables the default behavior)",
+    # )
+    # parser.add_argument(
+    #     "--wheel",
+    #     "-w",
+    #     dest="distributions",
+    #     action="append_const",
+    #     const="wheel",
+    #     help="build a wheel (disables the default behavior)",
+    # )
+    parser.add_argument(
+        "--outdir",
+        "-o",
+        type=str,
+        help=f"output directory (defaults to {{srcdir}}{os.sep}dist)",
+        metavar="PATH",
+    )
+    # parser.add_argument(
+    #     "--skip-dependency-check",
+    #     "-x",
+    #     action="store_true",
+    #     help="do not check that build dependencies are installed",
+    # )
+    # env_group = parser.add_mutually_exclusive_group()
+    # env_group.add_argument(
+    #     "--no-isolation",
+    #     "-n",
+    #     action="store_true",
+    #     help="disable building the project in an isolated virtual environment. "
+    #     "Build dependencies must be installed separately when this option is used",
+    # )
+    # env_group.add_argument(
+    #     "--installer",
+    #     choices=_env.INSTALLERS,
+    #     help="Python package installer to use (defaults to pip)",
+    # )
+    # config_group = parser.add_mutually_exclusive_group()
+    # config_group.add_argument(
+    #     "--config-setting",
+    #     "-C",
+    #     dest="config_settings",
+    #     action="append",
+    #     help=(
+    #         "settings to pass to the backend.  Multiple settings can be "
+    #         "provided. Settings beginning with a hyphen will erroneously "
+    #         "be interpreted as options to build if separated by a space "
+    #         "character; use ``--config-setting=--my-setting -C--my-other-setting``"
+    #     ),
+    #     metavar="KEY[=VALUE]",
+    # )
+    # config_group.add_argument(
+    #     "--config-json",
+    #     dest="config_json",
+    #     help=(
+    #         "settings to pass to the backend as a JSON object. This is an "
+    #         "alternative to --config-setting that allows complex nested "
+    #         "structures. Cannot be used together with --config-setting"
+    #     ),
+    #     metavar="JSON_STRING",
+    # )
+
+    return parser
+
+
+def main(cli_args: Sequence[str], prog: str | None = None) -> None:
+    """Parse the CLI arguments and invoke the build process.
+
+    :param cli_args: CLI arguments
+    :param prog: Program name to show in help text
+    """
+    parser = main_parser()
+    if prog:
+        parser.prog = prog
+    args = parser.parse_args(cli_args)
+
+    _setup_cli(verbosity=args.verbosity)
+
+    config_settings = {}
+
+    # # Handle --config-json
+    # if args.config_json:
+    #     try:
+    #         config_settings = json.loads(args.config_json)
+    #         if not isinstance(config_settings, dict):
+    #             _error(
+    #                 "--config-json must contain a JSON object (dict), "
+    #                 "not a list or primitive value"
+    #             )
+    #     except json.JSONDecodeError as e:
+    #         _error(f"Invalid JSON in --config-json: {e}")
+
+    # # Handle --config-setting (original logic)
+    # elif args.config_settings:
+    #     for arg in args.config_settings:
+    #         setting, _, value = arg.partition("=")
+    #         if setting not in config_settings:
+    #             config_settings[setting] = value
+    #         else:
+    #             if not isinstance(config_settings[setting], list):
+    #                 config_settings[setting] = [config_settings[setting]]
+
+    #             config_settings[setting].append(value)
+
+    # outdir is relative to srcdir only if omitted.
+    outdir = os.path.join(args.srcdir, "dist") if args.outdir is None else args.outdir
+
+    with _handle_build_error():
+        built = [
+            _build_in_isolated_env(
+                args.srcdir,
+                outdir,
+                "wheel",
+                config_settings,
+                "pip",
+            )
+        ]
+        artifact_list = _natural_language_list(
+            [
+                "{underline}{}{reset}{bold}{green}".format(artifact, **_styles.get())
+                for artifact in built
+            ]
+        )
+        _cprint("{bold}{green}Successfully built {}{reset}", artifact_list)
+
+
+def entrypoint() -> None:
+    main(sys.argv[1:])
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main(sys.argv[1:], "python -m build")
+
+__all__ = [
+    "main",
+    "main_parser",
+]

xbuild-0.0.1.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: xbuild
+Version: 0.0.1
+Summary: A PEP517 build frontend for cross-compiling wheels.
+Author-email: Russell Keith-Magee <russell@keith-magee.com>
+Maintainer-email: Russell Keith-Magee <russell@keith-magee.com>
+License-Expression: BSD-3-Clause
+Project-URL: Project, https://github.com/beeware/xbuild
+Project-URL: Funding, https://beeware.org/contributing/membership/
+Project-URL: Tracker, https://github.com/beeware/xbuild/issues
+Project-URL: Source, https://github.com/beeware/xbuild
+Keywords: pep517,build
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Software Distribution
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build==1.3.0
+Dynamic: license-file
+
+# xbuild
+
+[![Python Versions](https://img.shields.io/pypi/pyversions/xbuild.svg)](https://pypi.python.org/pypi/xbuild)
+[![PyPI Version](https://img.shields.io/pypi/v/xbuild.svg)](https://pypi.python.org/pypi/xbuild)
+[![Maturity](https://img.shields.io/pypi/status/xbuild.svg)](https://pypi.python.org/pypi/xbuild)
+[![BSD License](https://img.shields.io/pypi/l/xbuild.svg)](https://github.com/beeware/xbuild/blob/master/LICENSE)
+[![Discord server](https://img.shields.io/discord/836455665257021440?label=Discord%20Chat&logo=discord&style=plastic)](https://beeware.org/bee/chat/)
+
+`xbuild` is PEP517 build frontend that has additions and extensions to support cross-compiling wheels for platforms where compilation cannot be performed natively - most notably:
+
+* Android
+* Emscripten (WASM)
+* iOS
+
+## Usage
+
+### Creating a cross virtual environment
+
+To create a cross virtual environment, you will need a distribution of Python that has been compiled for Android, Emscripten or iOS. Create a virtual environment for your build platform (i.e., the platform where you will be compiling), then use the `xvenv` script to convert that virtual environment in to a cross environment.
+
+    $ python3 -m venv venv
+    $ source venv/bin/activate
+    (venv) $ pip install xbuild
+    (venv) $ python -m venv x-venv
+    (venv) $ xvenv --sysconfig path/to/_sysconfig_vars__...json x-venv
+
+You can then activate the cross virtual environment. For example, if `x-venv` was constructed using an iOS simulator sysconfig vars file (`_sysconfig_vars__ios_arm64-iphonesimulator.json`), you would see output like:
+
+    $ source x-venv/bin/activate
+    (x-venv) $ python -c "import sys; print(sys.platform)"
+    ios
+    (x-venv) $ python -c "import sys; print(sys.implementation._multiarch)"
+    arm64-iphonesimulator
+
+This should now print the platform identifier for the target platform, not your build platform.
+
+You can also configure xvenv with a `_sysconfigdata` Python file (e.g., `_sysconfigdata__ios_arm64-iphonesimulator.py`), instead of the `_sysconfig_var` JSON file. You'll have to use `_sysconfigdata` if you're on Python 3.13 (as the JSON format was only introduced in Python 3.14)
+
+If you are in the cross environment, and you need to temporarily convert it back to the build platform, you can do so with the `XBUILD_ENV` environment variable. For example, if `x-venv` is an iOS cross environment:
+
+    $ source x-venv/bin/activate
+    (x-venv) $ python -c "import sys; print(sys.platform)"
+    ios
+    (x-venv) $ XBUILD_ENV=off python -c "import sys; print(sys.platform)"
+    darwin
+
+## How this works
+
+The cross build environment does not run the target platform binaries on the build platform - it uses binaries for the build platform, but monkey-patches the Python interpreter at startup so that any question asking details about the platform returns details about the target platform. For example, if you create an iOS cross-platform environment on a macOS machine, you'll be using the macOS `python.exe`; but if you ask for `sys.platform`, the answer will be `ios`, not `darwin`.
+
+## Contributing
+
+To set up a development environment:
+
+    $ python3 -m venv venv
+    $ source venv/bin/activate
+    (venv) $ python -m pip install -U pip
+    (venv) $ python -m pip install -e . --group dev
+
+## Community
+
+`xbuild` is part of the [BeeWare suite](http://beeware.org). You can talk to the community through:
+
+- [@pybeeware on Twitter](https://twitter.com/pybeeware)
+- [Discord](https://beeware.org/bee/chat/)
+
+We foster a welcoming and respectful community as described in our [BeeWare Community Code of Conduct](http://beeware.org/community/behavior/).
+
+## Contributing
+
+If you experience problems with `xbuild`, [log them on GitHub](https://github.com/beeware/xbuild/issues). If you want to contribute code, please [fork the code](https://github.com/beeware/xbuild) and [submit a pull request](https://github.com/beeware/xbuild/pulls).

xbuild-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+xbuild/__init__.py,sha256=u3wDO6aPZzsZgXih4JqrDNHlgZ0SHvHDaYCy24P8wTg,869
+xbuild/__main__.py,sha256=PeaMnXoI4aOHXdkPcTh1WIvssuRSXt_62eXR25L6lM8,7083
+xbuild-0.0.1.dist-info/licenses/LICENSE,sha256=XYQSYHFcE30mh1LcQccvGSWMBfYnRdvEZoleqfnUios,1522
+xvenv/__init__.py,sha256=6jjRnZghwSf0mG6KbapDKm1WJUDWBwv7Ro7GukzSCnY,103
+xvenv/__main__.py,sha256=eppmUqYjKlVl80023Y849Wceq11WTec0Kr5XPhmDqvM,2094
+xvenv/_cross_target.py.tmpl,sha256=CHcZ3-P7j-VGZBaG2gFU8QJmFwY4ssKVk0UYOBZrOnE,3247
+xvenv/convert.py,sha256=UJDhOgfiqQ0z-Ddy_0GzgcYFSs4F_WXAg7shSwQyoXI,6698
+xvenv/platforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xvenv/platforms/android.py,sha256=cmjRo3oekxnImFiRiPvElT6AjKlWDzL7R-W7KJQHnmc,2282
+xvenv/platforms/emscripten.py,sha256=TJjUl5yiPhuqloiWuEM9b2py7N6JlQZ80CXbBJ8JB1E,526
+xvenv/platforms/ios.py,sha256=qcK9DD7QcJsI6xrLB59EqD9T6yUA_kGov6v33Hk025k,1205
+xbuild-0.0.1.dist-info/METADATA,sha256=FL0cDFumxqXsfqzxhxq0U3N-T1jwQ-CTDcjQUKwNVb8,5086
+xbuild-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xbuild-0.0.1.dist-info/entry_points.txt,sha256=GIHORBLMolwW-AkaAFdDP6-3rks6u6V8d_ZpTWy_K9Q,88
+xbuild-0.0.1.dist-info/top_level.txt,sha256=vI5VC2agCGAoVSufMhr23Z0E9DwwK--TDsxcyRh5IVc,13
+xbuild-0.0.1.dist-info/RECORD,,

xbuild-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xbuild-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+xbuild = xbuild.__main__:entrypoint
+xvenv = xvenv.__main__:entrypoint

xbuild-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2025 Russell Keith-Magee.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of xbuild nor the names of its
+       contributors may be used to endorse or promote products derived from this
+       software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

xbuild-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+xbuild
+xvenv

xvenv/__init__.py

@@ -0,0 +1,6 @@
+# xvenv version is the same as xbuild
+from xbuild import __version__
+
+__all__ = [
+    "__version__",
+]

xvenv/__main__.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import sys
+from argparse import ArgumentParser
+from collections.abc import Sequence
+from pathlib import Path
+
+from build.__main__ import (
+    _cprint,
+    _error,
+)
+
+import xvenv
+from xvenv.convert import convert_venv
+
+
+def main_parser():
+    parser = ArgumentParser(
+        "xvenv",
+        description=(
+            "Convert a native virtual environment into a cross-platform "
+            "virtual environment."
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        "-V",
+        action="version",
+        version=f"xvenv {xvenv.__version__}",
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        dest="verbosity",
+        action="count",
+        default=0,
+        help="increase verbosity",
+    )
+    parser.add_argument(
+        "-s",
+        "--sysconfig",
+        help="The path to a sysconfig_vars JSON file or sysconfigdata Python file",
+    )
+    parser.add_argument(
+        "venv",
+        help="The location of a native virtual environment",
+    )
+    return parser
+
+
+def main(cli_args: Sequence[str], prog: str | None = None) -> None:
+    """Parse the CLI arguments and convert the venv.
+
+    :param cli_args: CLI arguments
+    :param prog: Program name to show in help text
+    """
+    parser = main_parser()
+    if prog:
+        parser.prog = prog
+    args = parser.parse_args(cli_args)
+
+    venv_path = Path(args.venv).resolve()
+    sysconfig_path = Path(args.sysconfig).resolve()
+
+    if not venv_path.exists():
+        _error(f"Native virtual environment {venv_path} does not exist.")
+    else:
+        try:
+            description = convert_venv(venv_path, sysconfig_path)
+        except Exception as e:
+            _error(e)
+            sys.exit(1)
+        else:
+            _cprint(
+                "{bold}{green}{}{reset}",
+                f"{args.venv} is now an {description} cross venv.",
+            )
+
+
+def entrypoint() -> None:
+    main(sys.argv[1:])
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main(sys.argv[1:], "python -m build")
+
+__all__ = [
+    "main",
+    "main_parser",
+]

xvenv/_cross_target.py.tmpl

@@ -0,0 +1,95 @@
+# A site package that turns a virtual environment
+# into a {os} {multiarch} cross-platform virtual environment
+import functools
+import os
+import platform
+import subprocess
+import sys
+import sysconfig
+
+
+def monkeypatch(module):
+    """A decorator for patching a function in a module."""
+    def _dec(fn):
+        orig_fn = getattr(module, fn.__name__, None)
+        setattr(module, fn.__name__, fn)
+        functools.wraps(orig_fn)(fn)
+
+    return _dec
+
+
+def patch_cross_env():
+    ###########################################################################
+    # sys module patches
+    ###########################################################################
+    sys.cross_compiling = True
+    sys.platform = "{platform}"
+    sys.implementation._multiarch = "{multiarch}"
+    sys.abiflags = "{abiflags}"
+
+    if sys.version_info < (3, 14):
+        sys.base_prefix = sysconfig.get_config_var("prefix")
+        sys.base_exec_prefix = sysconfig.get_config_var("prefix")
+    else:
+        sys.base_prefix = sysconfig._get_sysconfigdata()["prefix"]
+        sys.base_exec_prefix = sysconfig._get_sysconfigdata()["prefix"]
+
+    ###########################################################################
+    # os module patches
+    ###########################################################################
+    @monkeypatch(os)
+    def uname():
+        return os.uname_result(
+            (
+                "{os_sysname}",
+                "{os_nodename}",
+                "{os_release}",
+                "{os_version}",
+                "{arch}",
+            )
+        )
+
+    ###########################################################################
+    # platform module patches
+    ###########################################################################
+    @monkeypatch(platform)
+    def uname():
+        return platform.uname_result(
+            system="{os}",
+            node="{os_nodename}",
+            release="{release}",
+            version="{os_version}",
+            machine="{arch}",
+        )
+
+    # -------------------------------------------------------------------------
+{platform_extra}
+    ###########################################################################
+    # subprocess module patches
+    ###########################################################################
+    subprocess._can_fork_exec = True
+
+    ###########################################################################
+    # sysconfig module patches
+    ###########################################################################
+
+    @monkeypatch(sysconfig)
+    def get_platform():
+        return "{platform}-{platform_version}-{machine}"
+
+    @monkeypatch(sysconfig)
+    def get_sysconfigdata_name():
+        return "_sysconfigdata__{platform}_{multiarch}"
+
+    # Ensure module-level values cached at time of import are updated.
+    sysconfig._BASE_PREFIX = sys.base_prefix
+    sysconfig._BASE_EXEC_PREFIX = sys.base_exec_prefix
+
+    # Force sysconfig data to be loaded (and cached).
+    sysconfig._init_config_vars()
+
+
+# if XBUILD_ENV=off is in the environment, don't apply any environment shims.
+# This reverts the environment to a native build environment.
+if os.environ.get("XBUILD_ENV", "on").lower() in {{"1", "on"}}:
+    patch_cross_env()

xvenv/convert.py

@@ -0,0 +1,174 @@
+import json
+import pprint
+import sys
+from importlib import import_module
+from importlib import util as importlib_util
+from pathlib import Path
+
+
+def localized_vars(orig_vars, slice_path):
+    """Update (where possible) any references to build-time variables with the best
+    guess of the installed location."""
+    # The host's sysconfigdata will include references to build-time variables.
+    # Update these to refer to the current known install location.
+    orig_prefix = orig_vars["prefix"]
+    localized_vars = {}
+    for key, value in orig_vars.items():
+        final = value
+        if isinstance(value, str):
+            # Replace any reference to the build installation prefix
+            final = final.replace(orig_prefix, str(slice_path))
+            # Replace any reference to the build-time Framework location
+            final = final.replace("-F .", f"-F {slice_path}")
+        localized_vars[key] = final
+
+    return localized_vars
+
+
+def localize_sysconfigdata(sysconfigdata_path, venv_site_packages):
+    """Localize a sysconfigdata python module.
+
+    :param support_path: The platform config that contains the sysconfigdata module to
+        localize.
+    :param venv_site_packages: The site packages folder where the localized
+        sysconfigdata module should be output.
+    """
+    # Import the sysconfigdata module
+    spec = importlib_util.spec_from_file_location(
+        sysconfigdata_path.stem, sysconfigdata_path
+    )
+    if spec is None:
+        msg = f"Unable to load spec for {sysconfigdata_path}"
+        raise ValueError(msg)
+    if spec.loader is None:
+        msg = f"Spec for {sysconfigdata_path} does not define a loader"
+        raise ValueError(msg)
+    sysconfigdata = importlib_util.module_from_spec(spec)
+    spec.loader.exec_module(sysconfigdata)
+
+    # Write the updated sysconfigdata module into the cross-platform site.
+    slice_path = sysconfigdata_path.parent.parent.parent
+    with (venv_site_packages / sysconfigdata_path.name).open("w") as f:
+        f.write(f"# Generated from {sysconfigdata_path}\n")
+        f.write("build_time_vars = ")
+        pprint.pprint(
+            localized_vars(sysconfigdata.build_time_vars, slice_path),
+            stream=f,
+            compact=True,
+        )
+
+    return sysconfigdata.build_time_vars
+
+
+def localize_sysconfig_vars(sysconfig_vars_path, venv_site_packages):
+    """Localize a sysconfig_vars.json file.
+
+    :param support_path: The platform config that contains the sysconfigdata module to
+        localize.
+    :param venv_site_packages: The site-packages folder where the localized
+        sysconfig_vars.json file should be output.
+    :return: The localized sysconfig
+    """
+    with sysconfig_vars_path.open("rb") as f:
+        build_time_vars = json.load(f)
+
+    prefix = sysconfig_vars_path.parent.parent.parent
+    sysconfig_vars = localized_vars(build_time_vars, prefix)
+
+    with (venv_site_packages / sysconfig_vars_path.name).open("w") as f:
+        json.dump(sysconfig_vars, f, indent=2)
+
+    return sysconfig_vars
+
+
+def convert_venv(venv_path: Path, sysconfig_path: Path):
+    """Convert a virtual environment into a cross-platform environment.
+
+    :param venv_path: The path to the root of the venv.
+    :param sysconfig_path: The path to the sysconfig_vars JSON or sysconfigdata Python
+        file for the target platform.
+    """
+    if not venv_path.exists():
+        raise ValueError(f"Virtual environment {venv_path} does not exist.")
+    if not (venv_path / "bin/python3").exists():
+        raise ValueError(f"{venv_path} does not appear to be a virtual environment.")
+
+    # Update path references in the sysconfigdata to reflect local conditions.
+    platlibs = list(venv_path.glob("lib/*/site-packages"))
+    if len(platlibs) == 0:
+        raise ValueError(f"Couldn't find site packages in {venv_path}")
+    elif len(platlibs) > 1:
+        raise ValueError(f"Found more than one site packages in {venv_path}")
+
+    venv_site_packages_path = platlibs[0]
+
+    if not sysconfig_path.is_file():
+        raise ValueError(f"Could not find sysconfig file {sysconfig_path}")
+
+    match sysconfig_path.suffix:
+        case ".json":
+            sysconfig_vars_path = sysconfig_path
+            _, _, _, abiflags, platform, multiarch = sysconfig_vars_path.stem.split("_")
+
+            sysconfigdata_path = (
+                sysconfig_vars_path.parent
+                / f"_sysconfigdata_{abiflags}_{platform}_{multiarch}.py"
+            )
+        case ".py":
+            sysconfigdata_path = sysconfig_path
+            _, _, abiflags, platform, multiarch = sysconfigdata_path.stem.split("_")
+
+            sysconfig_vars_path = (
+                sysconfigdata_path.parent
+                / f"_sysconfig_vars_{abiflags}_{platform}_{multiarch}.py"
+            )
+        case _:
+            raise ValueError(
+                "Don't know how to process sysconfig data "
+                f"of type {sysconfig_path.suffix}"
+            )
+
+    # Localize the sysconfig data. sysconfigdata *must* exist; sysconfig_vars
+    # will only exist on Python 3.14 or newer.
+    sysconfig = localize_sysconfigdata(sysconfigdata_path, venv_site_packages_path)
+    if sys.version_info[:2] >= (3, 14):
+        localize_sysconfig_vars(sysconfig_vars_path, venv_site_packages_path)
+
+    if sysconfig["VERSION"] != venv_site_packages_path.parts[-2][6:]:
+        raise ValueError(
+            f"target venv is Python {venv_site_packages_path.parts[-2][6:]}; "
+            f"sysconfig file is for Python {sysconfig['VERSION']}"
+        )
+
+    # Generate the context for the templated cross-target file
+    arch, sdk = multiarch.split("-", 1)
+    context = {
+        "platform": platform,
+        "os": platform,  # some platforms use different capitalization here
+        "multiarch": multiarch,
+        "abiflags": abiflags,
+        "arch": arch,
+        "sdk": sdk,
+    }
+
+    try:
+        platform_module = import_module(f"xvenv.platforms.{platform}")
+        platform_module.extend_context(context, sysconfig)
+    except ImportError:
+        raise ValueError(
+            f"Don't know how to build a cross-venv file for {platform}"
+        ) from None
+
+    cross_multiarch = f"_cross_{platform}_{multiarch.replace('-', '_')}"
+
+    # Render the template for the cross-target file.
+    template = (Path(__file__).parent / "_cross_target.py.tmpl").read_text()
+    rendered = template.format(**context)
+    (venv_site_packages_path / f"{cross_multiarch}.py").write_text(rendered)
+
+    # Write the .pth file that will enable the cross-target modifications
+    (venv_site_packages_path / "_cross_venv.pth").write_text(
+        f"import {cross_multiarch}\n"
+    )
+
+    return f"{context['os']} {multiarch}"

xvenv/platforms/android.py

@@ -0,0 +1,79 @@
+def extend_context(context, sysconfig):
+    # Convert the API level into a release number
+    api_level = int(sysconfig["ANDROID_API_LEVEL"])
+    if api_level >= 33:
+        release = f"{api_level - 20}"
+    elif api_level == 32:
+        release = "12L"
+    elif api_level == 31:
+        release = "12"
+    elif api_level > 28:
+        release = f"{api_level - 19}"
+    elif api_level == 27:
+        release = "8.1"
+    elif api_level == 26:
+        release = "8.0"
+    elif api_level == 25:
+        release = "7.1"
+    elif api_level == 24:
+        release = "7.0"
+    elif api_level == 23:
+        release = "6.0"
+    elif api_level == 22:
+        release = "5.1"
+    elif api_level == 21:
+        release = "5.0"
+    elif api_level == 20:
+        release = "4.4W"
+    else:
+        raise ValueError("xbuild doesn't support API levels lower than 20")
+
+    ######################################################################
+    context["os"] = "Android"
+    context["release"] = release
+    context["platform_version"] = api_level
+    context["machine"] = {
+        "x86_64": "x86_64",
+        "i686": "x86",
+        "aarch64": "arm64_v8a",
+        "armv7l": "armeabi_v7a",
+    }[context["arch"]]
+
+    # The Linux kernel version and release are unlikely to be
+    # significant, but return realistic values anyway (from an
+    # API level 24 emulator).
+    context["os_sysname"] = "Linux"
+    context["os_nodename"] = "localhost"
+    context["os_release"] = "3.18.91+"
+    context["os_version"] = "#1 SMP PREEMPT Tue Jan 9 20:35:43 UTC 2018"
+
+    context["platform_extra"] = f"""
+    @monkeypatch(platform)
+    def getandroidapilevel() -> int:
+        return {api_level}
+
+    @monkeypatch(platform)
+    def android_ver(
+        release="",
+        api_level=0,
+        manufacturer="",
+        model="",
+        device="",
+        is_emulator=False
+    ):
+        if release == "":
+            release = "{release}"
+        if api_level == 0:
+            api_level = {api_level}
+        if manufacturer == "":
+            manufacturer = "Google"
+        if model == "":
+            model = "sdk_gphone64"
+        if device == "":
+            device = "emu64"
+
+        return platform.AndroidVer(
+            release, api_level, manufacturer, model, device, True
+        )
+
+"""

xvenv/platforms/emscripten.py

@@ -0,0 +1,16 @@
+def extend_context(context, sysconfig):
+    emscripten_version = "4.0.12"
+    context["release"] = emscripten_version
+    context["platform_version"] = emscripten_version
+    context["machine"] = context["arch"]
+
+    context["os_sysname"] = "Emscripten"
+    context["os_nodename"] = "emscripten"
+    context["os_release"] = emscripten_version
+    context["os_version"] = "#1"
+
+    context["platform_extra"] = f"""
+    @monkeypatch(platform)
+    def libc_ver() -> int:
+        return ("emscripten", "{emscripten_version}")
+"""

xvenv/platforms/ios.py

@@ -0,0 +1,33 @@
+def extend_context(context, sysconfig):
+    release = sysconfig["IPHONEOS_DEPLOYMENT_TARGET"]
+    is_simulator = context["sdk"] == "iphonesimulator"
+
+    ######################################################################
+    context["os"] = "iOS"
+    context["release"] = release
+    context["platform_version"] = release
+    context["machine"] = context["multiarch"]
+
+    # The Darwin kernel version and release are unlikely to be
+    # significant, but return realistic values anyway (from an
+    # iPhone simulator).
+    context["os_sysname"] = "Darwin"
+    context["os_nodename"] = "buildmachine.local"
+    context["os_release"] = "24.4.0"
+    context["os_version"] = (
+        "Darwin Kernel Version 24.4.0: Fri Apr 11 18:33:47 PDT 2025; "
+        "root:xnu-11417.101.15~117/RELEASE_ARM64_T6000"
+    )
+
+    context["platform_extra"] = f"""
+    @monkeypatch(platform)
+    def ios_ver(system="", release="", model="", is_simulator=False):
+        if system == "":
+            system = "iOS"
+        if release == "":
+            release = "{release}"
+        if model == "":
+            model = "{context["sdk"]}"
+
+        return platform.IOSVersionInfo(system, release, model, {is_simulator})
+"""