pyxbuild 0.1.0__py3-none-any.whl

pyxbuild/__init__.py

@@ -0,0 +1,3 @@
+"""pyxbuild: build Windows x64 applications from a Python project on any OS."""
+
+__version__ = "0.1.0"

pyxbuild/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

pyxbuild/_boot/_pyxbuild_boot.py

@@ -0,0 +1,169 @@
+"""Start-up shim of applications built by pyxbuild (copied to runtime/Lib).
+
+The launcher runs ``python -I -c "import _pyxbuild_boot;_pyxbuild_boot.main('<script>')"``.
+This module reads ``runtime/pyxbuild.json`` and prepares the process before
+calling the entry point:
+
+* removes environment variables that would point the app at another
+  installation (``clean-env``, e.g. TCL_LIBRARY, QT_PLUGIN_PATH);
+* sets variables from ``[tool.pyxbuild.env]`` (``{app_dir}``, ``{exe_dir}``, ``{data_dir}``
+  and ``{localappdata}`` are expanded);
+* for GUI scripts: gives ``print``/``logging`` a log file instead of
+  ``sys.stdout = None``, shows unhandled exceptions in a message box instead
+  of exiting silently, sets the AppUserModelID and per-monitor DPI awareness;
+* optionally lets ``ssl`` use the Windows certificate store (``truststore``).
+
+Only the standard library is used; failures here never prevent the app from
+starting.
+"""
+
+import importlib
+import json
+import os
+import sys
+
+_LOG_LIMIT = 1 << 20
+
+
+def _config():
+    with open(os.path.join(sys.prefix, "pyxbuild.json"), encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _user_data_home():
+    """Per-user data folder when LOCALAPPDATA is not set: the home folder on
+    Windows (as before), $XDG_DATA_HOME or ~/.local/share elsewhere."""
+    if os.name == "nt":
+        return os.path.expanduser("~")
+    xdg = os.environ.get("XDG_DATA_HOME", "")
+    return xdg if os.path.isabs(xdg) else os.path.expanduser("~/.local/share")
+
+
+def _expand(value, names):
+    for key, path in names.items():
+        value = value.replace("{" + key + "}", path)
+    return value
+
+
+def _gui_streams(log_path):
+    """pythonw.exe has no console: sys.stdout/stderr are None and print() fails.
+
+    ``_pyxbuild_streams`` (run from a .pth file before this) may already have
+    put a devnull placeholder there; it is replaced by the log, and child
+    processes find the log through PYXBUILD_GUI_LOG.
+    """
+    try:
+        from _pyxbuild_streams import PLACEHOLDER, open_append
+    except ImportError:
+        PLACEHOLDER = None
+
+        def open_append(path):
+            return open(path, "a", encoding="utf-8", buffering=1,  # noqa: SIM115
+                        errors="backslashreplace")
+    missing = [s for s in ("stdout", "stderr")
+               if getattr(sys, s) is None or getattr(sys, s) is PLACEHOLDER]
+    if not missing:
+        return None
+    try:
+        os.makedirs(os.path.dirname(log_path), exist_ok=True)
+        if os.path.exists(log_path) and os.path.getsize(log_path) > _LOG_LIMIT:
+            os.replace(log_path, log_path + ".1")
+        stream = open_append(log_path)  # shared with child processes
+    except OSError:
+        stream = open(os.devnull, "w", encoding="utf-8")  # noqa: SIM115
+        log_path = None  # do not point the user at a file that was not written
+    for name in missing:
+        setattr(sys, name, stream)
+    if log_path:
+        os.environ["PYXBUILD_GUI_LOG"] = log_path  # for child processes
+    return log_path
+
+
+def _message_box(title, text):
+    if os.environ.get("PYXBUILD_BOOT_NO_DIALOG"):
+        return
+    try:
+        import ctypes
+
+        ctypes.windll.user32.MessageBoxW(None, text, title, 0x10)  # MB_ICONERROR
+    except Exception:
+        pass
+
+
+def _gui_excepthook(app_name, log_path):
+    import traceback
+
+    def hook(exc_type, exc, tb):
+        text = "".join(traceback.format_exception(exc_type, exc, tb))
+        try:
+            sys.stderr.write(text)
+            sys.stderr.flush()
+        except Exception:
+            pass
+        lines = text.strip().splitlines()[-12:]
+        where = f"\n\nDetails were written to:\n{log_path}" if log_path else ""
+        _message_box(f"{app_name} error", "\n".join(lines) + where)
+
+    sys.excepthook = hook
+
+
+def _gui_process(app_id, dpi_aware):
+    try:
+        import ctypes
+
+        if app_id:
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
+        if dpi_aware:
+            # DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2; pythonw.exe declares
+            # none, so the UI would be bitmap-scaled (blurry) on high-DPI screens
+            ctypes.windll.user32.SetProcessDpiAwarenessContext(ctypes.c_void_p(-4))
+    except Exception:
+        pass
+
+
+def main(script):
+    cfg = _config()
+    launcher = cfg["launchers"][script]
+    boot = cfg.get("boot", {})
+    # the launcher passes its own path first; it becomes sys.argv[0]
+    sys.argv[0:2] = sys.argv[1:2]
+    # the bundle's root (the folder holding runtime\): the launcher's folder,
+    # or the extracted copy of a onefile executable; exe_dir is where the
+    # .exe the user started lives
+    app_dir = os.path.dirname(os.path.abspath(sys.prefix))
+    exe_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+    app_name = cfg.get("project", {}).get("name", script)
+    localappdata = os.environ.get("LOCALAPPDATA") or _user_data_home()
+    names = {"app_dir": app_dir, "exe_dir": exe_dir, "localappdata": localappdata,
+             "data_dir": os.path.join(localappdata, app_name)}
+
+    for var in boot.get("clean-env", []):
+        os.environ.pop(var, None)
+    for key, value in boot.get("env", {}).items():
+        os.environ[key] = _expand(value, names)
+
+    if launcher.get("gui"):
+        log_path = None
+        gui_log = boot.get("gui-log", True)
+        if gui_log is True:
+            log_path = _gui_streams(os.path.join(names["data_dir"], "logs", script + ".log"))
+        elif gui_log:  # a template: {data_dir}-style names and strftime codes
+            import time
+
+            log_path = _gui_streams(os.path.normpath(time.strftime(_expand(gui_log, names))))
+        _gui_excepthook(app_name, log_path)
+        _gui_process(boot.get("app-id"), boot.get("dpi-aware", True))
+
+    if boot.get("truststore"):
+        try:
+            import truststore
+
+            truststore.inject_into_ssl()
+        except ImportError:
+            pass
+
+    module, _, attr = launcher["entry-point"].partition(":")
+    target = importlib.import_module(module)
+    for part in attr.split("."):
+        target = getattr(target, part)
+    sys.exit(target())

pyxbuild/_boot/_pyxbuild_patch.py

@@ -0,0 +1,211 @@
+"""Apply a pyxbuild patch (see src/pyxbuild/patch.py).
+
+A patch executable extracts its payload (this module, ``patch.json`` and the
+changed files under ``blobs/``) to a temporary folder and runs this module
+with the Python of the installed version the patch was made for. It
+assembles the new version in the onefile cache, next to the old one:
+
+* files whose content the old version already has are hard-linked (or
+  copied) from it after checking their sha256 (the cache is user-writable);
+* new files come from ``blobs/<sha256>``, or, for files of public wheels
+  when the patch was made with ``--fetch-public``, from the wheel downloaded
+  from the URL in the lock file and checked against its sha256;
+* every file written is checked against the hash the new version expects;
+* the folder is renamed into place only when complete (``.pyx-complete``),
+  and ``.pyx-next`` in the old folder points older executables at it.
+
+The result is the folder the new full executable would extract itself.
+Standard library only.
+"""
+
+import hashlib
+import json
+import os
+import shutil
+import sys
+import tempfile
+import urllib.request
+import zipfile
+
+
+class PatchError(Exception):
+    pass
+
+
+def _sha256(path, cache={}):  # noqa: B006 - deliberate per-run memo
+    if path not in cache:
+        h = hashlib.sha256()
+        with open(path, "rb") as f:
+            while block := f.read(1 << 20):
+                h.update(block)
+        cache[path] = h.hexdigest()
+    return cache[path]
+
+
+def _mutex(name):
+    """The launcher's extraction mutex, so a full executable of the same
+    version never extracts into the folder while we assemble it."""
+    try:
+        import ctypes
+
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        kernel32.CreateMutexW.restype = ctypes.c_void_p
+        handle = kernel32.CreateMutexW(None, False, name)
+        if handle:
+            kernel32.WaitForSingleObject(ctypes.c_void_p(handle), 0xFFFFFFFF)
+        return kernel32, handle
+    except (AttributeError, OSError):  # not Windows (tests)
+        return None, None
+
+
+def _read12(path):
+    with open(path, encoding="ascii", errors="replace") as f:
+        return f.read(12)
+
+
+def _release(mutex):
+    kernel32, handle = mutex
+    if handle:
+        import ctypes
+
+        kernel32.ReleaseMutex(ctypes.c_void_p(handle))
+        kernel32.CloseHandle(ctypes.c_void_p(handle))
+
+
+def _download(url, sha256, size, dest):
+    print(f"  downloading {url.rsplit('/', 1)[-1]}", flush=True)
+    h = hashlib.sha256()
+    got = 0
+    with urllib.request.urlopen(url, timeout=120) as resp, open(dest, "wb") as out:
+        while block := resp.read(1 << 20):
+            got += len(block)
+            if size is not None and got > size:
+                raise PatchError(f"{url}: larger than expected")
+            h.update(block)
+            out.write(block)
+    if h.hexdigest() != sha256:
+        raise PatchError(f"{url}: sha256 mismatch")
+
+
+def _place(src, dst, link):
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    if link:
+        try:
+            os.link(src, dst)
+            return
+        except OSError:
+            pass  # other volume, FAT, no permission: copy
+    shutil.copyfile(src, dst)
+
+
+def apply(payload, appdir, log=print):
+    with open(os.path.join(payload, "patch.json"), encoding="utf-8") as f:
+        patch = json.load(f)
+    if patch.get("format") != 1:
+        raise PatchError("unsupported patch format")
+    base = os.path.join(appdir, patch["base"][:12])
+    target12 = patch["target"][:12]
+    target = os.path.join(appdir, target12)
+    if not os.path.isfile(os.path.join(base, ".pyx-complete")):
+        raise PatchError(f"the version this patch is for is not installed: {base}")
+
+    mutex = _mutex("Local\\pyx-onefile-" + target12)
+    try:
+        installed = os.path.isfile(os.path.join(target, ".pyx-complete"))
+        if installed:
+            log(f"{patch['app']} {patch['version']} is already installed")
+        else:
+            _assemble(patch, payload, base, target, log)
+    finally:
+        _release(mutex)
+
+    # older executables follow .pyx-next to the newest version; also re-point
+    # versions that pointed at our base so that chains stay one hop long
+    base12 = patch["base"][:12]
+    for name in os.listdir(appdir):
+        nxt = os.path.join(appdir, name, ".pyx-next")
+        if name != base12 and not (os.path.isfile(nxt) and _read12(nxt) == base12):
+            continue
+        with open(nxt, "w", encoding="ascii") as f:
+            f.write(target12 + "\n")
+    if not installed:
+        log(f"updated {patch['app']} to {patch['version']}")
+    return target
+
+
+def _assemble(patch, payload, base, target, log):
+    files = patch["files"]
+    work = f"{target}.tmp-{os.getpid():x}-patch"
+    if os.path.exists(work):
+        shutil.rmtree(work)
+    downloads = tempfile.mkdtemp(prefix="pyx-patch-wheels-")
+    try:
+        # 1. the old version's files we reuse must still be what we expect
+        keep = patch["keep"]
+        moved = [e for e in files if e["from"] == "base"]
+        log(f"  checking {len(keep) + len(moved)} unchanged file(s)")
+        digest = hashlib.sha256()
+        for path in keep:
+            src = os.path.join(base, *path.split("/"))
+            if not os.path.isfile(src):
+                raise PatchError(f"the installed version is damaged ({path} is missing); "
+                                 "install the full version")
+            digest.update(_sha256(src).encode())
+        if digest.hexdigest() != patch["keep_sha256"]:
+            raise PatchError("the installed version is damaged; install the full version")
+        for e in moved:
+            src = os.path.join(base, *e["src"].split("/"))
+            if not os.path.isfile(src) or _sha256(src) != e["sha256"]:
+                raise PatchError(f"the installed version is damaged ({e['src']}); "
+                                 "install the full version")
+        # 2. wheels with public files (--fetch-public)
+        wheels = {}
+        for i, w in enumerate(patch.get("wheels", [])):
+            path = os.path.join(downloads, w["url"].rsplit("/", 1)[-1])
+            _download(w["url"], w["sha256"], w.get("size"), path)
+            wheels[i] = zipfile.ZipFile(path)
+        # 3. assemble
+        log(f"  writing {len(keep) + len(files)} file(s)")
+        for path in keep:
+            _place(os.path.join(base, *path.split("/")),
+                   os.path.join(work, *path.split("/")), link=True)
+        for e in files:
+            dst = os.path.join(work, *e["path"].split("/"))
+            if e["from"] == "base":
+                _place(os.path.join(base, *e["src"].split("/")), dst, link=True)
+                continue
+            if e["from"] == "payload":
+                _place(os.path.join(payload, "blobs", e["sha256"]), dst, link=False)
+            else:
+                index, member = e["src"]
+                os.makedirs(os.path.dirname(dst), exist_ok=True)
+                with wheels[index].open(member) as src, open(dst, "wb") as out:
+                    shutil.copyfileobj(src, out)
+            if os.path.getsize(dst) != e["size"] or _sha256(dst) != e["sha256"]:
+                raise PatchError(f"{e['path']}: content does not match the new version")
+        for z in wheels.values():
+            z.close()
+        with open(os.path.join(work, ".pyx-complete"), "w", encoding="utf-8") as f:
+            f.write(patch["target"] + "\n")
+        try:
+            os.rename(work, target)
+        except OSError:
+            if not os.path.isfile(os.path.join(target, ".pyx-complete")):
+                if os.path.exists(target):  # an incomplete earlier attempt
+                    shutil.rmtree(target)
+                    os.rename(work, target)
+                else:
+                    raise
+    finally:
+        shutil.rmtree(downloads, ignore_errors=True)
+        if os.path.exists(work):
+            shutil.rmtree(work, ignore_errors=True)
+
+
+def main():
+    try:
+        apply(os.environ["PYX_PATCH_PAYLOAD"], os.environ["PYX_PATCH_APPDIR"])
+    except (PatchError, OSError) as exc:
+        print(f"update failed: {exc}", file=sys.stderr, flush=True)
+        return 1
+    return 0

pyxbuild/_boot/_pyxbuild_streams.py

@@ -0,0 +1,64 @@
+"""Standard streams for windowless processes of applications built by pyxbuild.
+
+pythonw.exe starts with ``sys.stdout``/``sys.stderr`` set to None: ``print()``
+is silently dropped, but ``sys.stdout.write()``, ``logging`` handlers created
+early or libraries that flush the streams raise AttributeError. That also
+hits every child process (multiprocessing, ProcessPoolExecutor), which never
+runs ``_pyxbuild_boot``. ``_pyxbuild_streams.pth`` in site-packages imports
+this module at the start of every interpreter of the bundle; it does nothing
+when the streams exist. Output goes to the GUI log the main process chose
+(``PYXBUILD_GUI_LOG``, inherited), otherwise nowhere.
+"""
+
+import os
+import sys
+
+PLACEHOLDER = None
+
+
+def open_append(path):
+    """A line-buffered text stream that several processes can append to at once.
+
+    The C runtime's "a" mode seeks to the end before every write, so on
+    Windows concurrent writers overwrite each other's lines. A handle opened
+    with FILE_APPEND_DATA but without FILE_WRITE_DATA makes the system append
+    every write atomically at the end of the file.
+    """
+    if sys.platform == "win32":
+        try:
+            import ctypes
+            import msvcrt
+            from ctypes import wintypes
+
+            create = ctypes.WinDLL("kernel32", use_last_error=True).CreateFileW
+            create.restype = wintypes.HANDLE
+            create.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD,
+                               wintypes.LPVOID, wintypes.DWORD, wintypes.DWORD,
+                               wintypes.HANDLE]
+            # FILE_APPEND_DATA; share read/write/delete; OPEN_ALWAYS; normal file
+            handle = create(path, 0x0004, 0x0007, None, 4, 0x80, None)
+            if handle and handle != wintypes.HANDLE(-1).value:
+                fd = msvcrt.open_osfhandle(handle, os.O_WRONLY | os.O_BINARY)
+                stream = open(fd, "w", encoding="utf-8", buffering=1,  # noqa: SIM115
+                              errors="backslashreplace")
+                stream.buffer.raw.name = path  # not the descriptor number
+                return stream
+        except Exception:
+            pass
+    return open(path, "a", encoding="utf-8", buffering=1,  # noqa: SIM115
+                errors="backslashreplace")
+
+
+if sys.stdout is None or sys.stderr is None:
+    try:
+        _log = os.environ.get("PYXBUILD_GUI_LOG")
+        if _log:
+            PLACEHOLDER = open_append(_log)
+    except OSError:
+        PLACEHOLDER = None
+    if PLACEHOLDER is None:
+        PLACEHOLDER = open(os.devnull, "w", encoding="utf-8")  # noqa: SIM115
+    if sys.stdout is None:
+        sys.stdout = PLACEHOLDER
+    if sys.stderr is None:
+        sys.stderr = PLACEHOLDER

pyxbuild/_boot/posix_script_head.txt

@@ -0,0 +1,3 @@
+#!/bin/sh
+'''exec' "$(dirname -- "$(readlink -f -- "$0")")/python{python}" "$0" "$@"
+' '''

pyxbuild/_cross_hook/sitecustomize.py

@@ -0,0 +1,152 @@
+"""Loaded into the PEP 517 build process by ``pyxbuild.crossbuild`` (via PYTHONPATH).
+
+Replaces setuptools' ``build_ext.build_extension`` and ``build_clib.build_libraries``
+with versions that compile C/C++ sources for Windows x64 with ``zig cc``
+against the headers and import library of the *target* CPython. Everything
+else (setup.py logic, Cython code generation, packaging) runs unchanged on
+the host. Only active when PYXBUILD_CROSS is set.
+"""
+
+import json
+import os
+
+
+def _install() -> None:
+    cfg = json.loads(os.environ["PYXBUILD_CROSS"])
+    zig = cfg["zig"]
+    target = cfg["target"]
+    include = cfg["include"]
+    libdir = cfg["libdir"]
+    pylib = cfg["pylib"]
+    ext_suffix = cfg["ext_suffix"]
+
+    import subprocess
+    import sysconfig
+
+    host_includes = {sysconfig.get_paths()[k] for k in ("include", "platinclude")}
+    case_shims = cfg["case_shims"]
+    cxx_suffixes = (".cpp", ".cc", ".cxx", ".c++")
+
+    def portable(args):
+        # MSVC-style switches ("/O2", "/EHsc") make no sense for clang; keep
+        # absolute POSIX paths (extra objects, static libraries)
+        return [a for a in (args or [])
+                if not (a.startswith("/") and len(a) < 16 and not os.path.exists(a))]
+
+    def run(cmd):
+        print("pyxbuild-cross:", " ".join(cmd), flush=True)
+        subprocess.run(cmd, check=True)
+
+    def compile_sources(sources, build_temp, macros, undef, include_dirs, extra):
+        objects = []
+        for src in sources:
+            obj = os.path.join(build_temp, os.path.splitdrive(src)[1].lstrip("/\\") + ".obj")
+            os.makedirs(os.path.dirname(obj), exist_ok=True)
+            tool = "c++" if src.lower().endswith(cxx_suffixes) else "cc"
+            # MS_WIN64: PC/pyconfig.h sets it for MinGW only since 3.12
+            cmd = [*zig, tool, "-target", target, "-c", "-O2", "-DNDEBUG", "-DMS_WIN64"]
+            for name, value in macros or []:
+                cmd.append(f"-D{name}" if value is None else f"-D{name}={value}")
+            cmd += [f"-U{name}" for name in undef or []]
+            cmd += [f"-I{d}" for d in [*(include_dirs or []), include]]
+            cmd += ["-idirafter", case_shims]
+            cmd += portable(extra)
+            cmd += [src, "-o", obj]
+            run(cmd)
+            objects.append(obj)
+        return objects
+
+    def build_extension(self, ext):
+        sources = self.swig_sources(list(ext.sources), ext)
+        ext_path = self.get_ext_fullpath(ext.name)
+        os.makedirs(os.path.dirname(ext_path) or ".", exist_ok=True)
+        # build_ext-level include dirs, minus the host interpreter's headers
+        host = {os.path.normcase(os.path.abspath(p)) for p in host_includes}
+        includes = [*(ext.include_dirs or []),
+                    *[d for d in (self.include_dirs or [])
+                      if os.path.normcase(os.path.abspath(d)) not in host]]
+        objects = compile_sources(sources, self.build_temp, ext.define_macros,
+                                  ext.undef_macros, includes, ext.extra_compile_args)
+        is_cxx = any(s.lower().endswith(cxx_suffixes) for s in sources) or ext.language == "c++"
+        cmd = [*zig, "c++" if is_cxx else "cc", "-target", target, "-shared", "-o", ext_path]
+        cmd += objects + list(ext.extra_objects or [])
+        # self.libraries / self.library_dirs carry build_clib output
+        cmd += [f"-L{d}" for d in [*(ext.library_dirs or []), *(self.library_dirs or []),
+                                   self.build_temp, libdir]]
+        cmd += [f"-l{lib}" for lib in [*(ext.libraries or []), *(self.libraries or [])]]
+        cmd += [os.path.join(libdir, pylib + ".lib")]
+        cmd += portable(ext.extra_link_args)
+        cmd.append("-s")
+        out_dir = os.path.dirname(ext_path) or "."
+        before = set(os.listdir(out_dir))
+        run(cmd)
+        # the linker leaves an import library and a .pdb next to the .pyd
+        for junk in set(os.listdir(out_dir)) - before:
+            if junk.lower().endswith((".lib", ".pdb")):
+                os.remove(os.path.join(out_dir, junk))
+
+    def build_libraries(self, libraries):
+        for name, info in libraries:
+            objects = compile_sources(info.get("sources", []), self.build_temp,
+                                      info.get("macros"), None, info.get("include_dirs"),
+                                      info.get("cflags"))
+            out = os.path.join(self.build_clib, f"lib{name}.a")
+            os.makedirs(self.build_clib, exist_ok=True)
+            run([*zig, "ar", "rcs", out, *objects])
+
+    def get_ext_filename(self, fullname):
+        ext = getattr(self, "ext_map", {}).get(fullname)
+        # abi3 extensions on Windows are plain ".pyd"
+        suffix = ".pyd" if ext is not None and getattr(ext, "py_limited_api", False) \
+            else ext_suffix
+        return os.path.join(*fullname.split(".")) + suffix
+
+    # Patch the command classes when the build imports them, not earlier:
+    # importing setuptools from sitecustomize changes how its distutils shim
+    # initialises and breaks some setup.py files (zstandard). Projects that
+    # subclass distutils' commands directly (PyYAML) need the base classes
+    # patched as well.
+    patches = {
+        "setuptools.command.build_ext": {"build_ext": {"build_extension": build_extension,
+                                                       "get_ext_filename": get_ext_filename}},
+        "setuptools.command.build_clib": {"build_clib": {"build_libraries": build_libraries}},
+        "setuptools._distutils.command.build_ext": {
+            "build_ext": {"build_extension": build_extension,
+                          "get_ext_filename": get_ext_filename}},
+        "setuptools._distutils.command.build_clib": {
+            "build_clib": {"build_libraries": build_libraries}},
+    }
+    # setuptools' _distutils_hack serves "distutils" from setuptools/_distutils
+    # under the "distutils.*" names: separate module objects (Cython's build_ext)
+    patches["distutils.command.build_ext"] = patches["setuptools._distutils.command.build_ext"]
+    patches["distutils.command.build_clib"] = patches["setuptools._distutils.command.build_clib"]
+
+    import importlib.abc
+    import importlib.machinery
+    import sys
+
+    class _Patcher(importlib.abc.MetaPathFinder):
+        def find_spec(self, name, path, target=None):
+            if name not in patches:
+                return None
+            spec = importlib.machinery.PathFinder.find_spec(name, path)
+            if spec is None or spec.loader is None:
+                return None
+            loader = spec.loader
+            exec_module = loader.exec_module
+
+            def patched_exec(module, _exec=exec_module, _name=name):
+                _exec(module)
+                for cls_name, attrs in patches[_name].items():
+                    cls = getattr(module, cls_name)
+                    for attr, func in attrs.items():
+                        setattr(cls, attr, func)
+
+            loader.exec_module = patched_exec
+            return spec
+
+    sys.meta_path.insert(0, _Patcher())
+
+
+if os.environ.get("PYXBUILD_CROSS"):
+    _install()