build.py

"""Module to build the native library and the bindings."""

from os import getenv
from pathlib import Path
from platform import machine
from shutil import copy
from subprocess import run
from sysconfig import get_platform

PYTHON_LIB_DIR = Path("rgb_lib")
UNIFFI_DIR = Path("rgb-lib/bindings/uniffi")
MANIFEST_PATH = UNIFFI_DIR.joinpath("Cargo.toml")
UDL_PATH = UNIFFI_DIR.joinpath("src", "rgb-lib.udl")
OSX_VERSION = "12.3"

# supported platforms metadata
PLATFORMS = {
    "linux-x86_64": {
        "target": "x86_64-unknown-linux-gnu",
        "filename": "librgblibuniffi",
        "extension": "so",
        "wheel_tag": "manylinux_2_34_x86_64",
    },
    "linux-aarch64": {
        "target": "aarch64-unknown-linux-gnu",
        "filename": "librgblibuniffi",
        "extension": "so",
        "wheel_tag": "manylinux_2_34_aarch64",
    },
    "macosx-x86_64": {
        "target": "x86_64-apple-darwin",
        "filename": "librgblibuniffi",
        "extension": "dylib",
        "wheel_tag": "macosx_12_0_x86_64",
    },
    "macosx-arm64": {
        "target": "aarch64-apple-darwin",
        "filename": "librgblibuniffi",
        "extension": "dylib",
        "wheel_tag": "macosx_12_0_arm64",
    },
    "win-amd64": {
        "target": "x86_64-pc-windows-gnu",
        "filename": "rgblibuniffi",
        "extension": "dll",
        "wheel_tag": "win_amd64",
    },
}


def build():
    """Handle the platform-specfic part of the build process."""
    # platform selection: from env var or auto-detected
    platform = getenv("PLATFORM")
    if not platform:
        platform = get_current_platform()
    elif platform and platform not in PLATFORMS:
        raise RuntimeError(f"unsupported platform: {platform}")
    # platform-specific build (native, no cross needed)
    build_rust_library(platform)
    copy_rust_library(platform)
    generate_bindings(platform)


def build_rust_library(platform):
    """Build the Rust library for the specified target using native cargo."""
    target = PLATFORMS[platform]["target"]
    run(
        [
            "cargo",
            "build",
            "--manifest-path",
            str(MANIFEST_PATH),
            "--release",
            "--target",
            target,
        ],
        check=True,
    )


def copy_rust_library(platform):
    """Copy the compiled Rust library to the Python package directory."""
    target = PLATFORMS[platform]["target"]
    lib_name = get_lib_name(platform)
    src = UNIFFI_DIR.joinpath("target", target, "release", lib_name)
    dst = PYTHON_LIB_DIR.joinpath(lib_name)
    copy(src, dst)


def generate_bindings(platform):
    """Generate Python bindings using uniffi-bindgen."""
    target = PLATFORMS[platform]["target"]
    lib_name = get_lib_name(platform)
    lib_path = UNIFFI_DIR.joinpath(
        "target",
        target,
        "release",
        lib_name,
    )
    if not lib_path.exists():
        raise RuntimeError(f"lib path ({lib_path}) not found")
    run(
        [
            "cargo",
            "run",
            "--manifest-path",
            str(MANIFEST_PATH),
            "--bin",
            "rgb-lib-uniffi-bindgen",
            "generate",
            str(UDL_PATH),
            "--out-dir",
            str(PYTHON_LIB_DIR),
            "--language",
            "python",
            "--no-format",
        ],
        check=True,
    )


def get_current_platform():
    """Get the platform for the running system."""
    platform = get_platform()
    if platform.startswith("macosx"):
        arch = machine()
        platform = f"macosx-{arch}"
    return platform


def get_lib_name(platform):
    """Get library name based on provided target."""
    filename = PLATFORMS[platform]["filename"]
    extension = PLATFORMS[platform]["extension"]
    return f"{filename}.{extension}"


if __name__ == "__main__":
    build()