move kbs libary files to src/

src/kupferbootstrap/devices/cli.py

@@ -0,0 +1,80 @@
+import click
+import logging
+
+from json import dumps as json_dump
+from typing import Optional
+
+from config.state import config
+from config.cli import resolve_profile_field
+from utils import color_mark_selected, colors_supported
+
+from .device import get_devices, get_device
+
+
+@click.command(name='devices')
+@click.option('-j', '--json', is_flag=True, help='output machine-parsable JSON format')
+@click.option(
+    '--force-parse-deviceinfo/--no-parse-deviceinfo',
+    is_flag=True,
+    default=None,
+    help="Force or disable deviceinfo parsing. The default is to try but continue if it fails.",
+)
+@click.option(
+    '--download-packages/--no-download-packages',
+    is_flag=True,
+    default=False,
+    help='Download packages while trying to parse deviceinfo',
+)
+@click.option('--output-file', type=click.Path(exists=False, file_okay=True), help="Dump JSON to file")
+def cmd_devices(
+    json: bool = False,
+    force_parse_deviceinfo: Optional[bool] = True,
+    download_packages: bool = False,
+    output_file: Optional[str] = None,
+):
+    'list the available devices and descriptions'
+    devices = get_devices()
+    if not devices:
+        raise Exception("No devices found!")
+    profile_device = None
+    profile_name = config.file.profiles.current
+    selected, inherited_from = None, None
+    try:
+        selected, inherited_from = resolve_profile_field(None, profile_name, 'device', config.file.profiles)
+        if selected:
+            profile_device = get_device(selected)
+    except Exception as ex:
+        logging.debug(f"Failed to get profile device for marking as currently selected, continuing anyway. Exception: {ex}")
+    output = ['']
+    json_output = {}
+    interactive_json = json and not output_file
+    if output_file:
+        json = True
+    use_colors = colors_supported(False if interactive_json else config.runtime.colors)
+    for name in sorted(devices.keys()):
+        device = devices[name]
+        assert device
+        if force_parse_deviceinfo in [None, True]:
+            try:
+                device.parse_deviceinfo(try_download=download_packages)
+            except Exception as ex:
+                if not force_parse_deviceinfo:
+                    logging.debug(f"Failed to parse deviceinfo for extended description, not a problem: {ex}")
+                else:
+                    raise ex
+
+        if json:
+            json_output[name] = device.get_summary().toDict()
+            if interactive_json:
+                continue
+        snippet = device.nice_str(colors=use_colors, newlines=True)
+        if profile_device and profile_device.name == device.name:
+            snippet = color_mark_selected(snippet, profile_name or '[unknown]', inherited_from)
+        output.append(f"{snippet}\n")
+    if interactive_json:
+        output = ['\n' + json_dump(json_output, indent=4)]
+    if output_file:
+        with open(output_file, 'w') as fd:
+            fd.write(json_dump(json_output))
+    for line in output:
+        print(line)

src/kupferbootstrap/devices/device.py

@@ -0,0 +1,209 @@
+import logging
+import os
+
+from typing import Optional
+
+from config.state import config
+from constants import Arch, ARCHES
+from dictscheme import DictScheme
+from distro.distro import get_kupfer_local
+from distro.package import LocalPackage
+from packages.pkgbuild import Pkgbuild, _pkgbuilds_cache, discover_pkgbuilds, get_pkgbuild_by_path, init_pkgbuilds
+from utils import read_files_from_tar, color_str
+
+from .deviceinfo import DEFAULT_IMAGE_SECTOR_SIZE, DeviceInfo, parse_deviceinfo
+
+DEVICE_DEPRECATIONS = {
+    "oneplus-enchilada": "sdm845-oneplus-enchilada",
+    "oneplus-fajita": "sdm845-oneplus-fajita",
+    "xiaomi-beryllium-ebbg": "sdm845-xiaomi-beryllium-ebbg",
+    "xiaomi-beryllium-tianma": "sdm845-xiaomi-beryllium-tianma",
+    "bq-paella": "msm8916-bq-paella",
+}
+
+
+class DeviceSummary(DictScheme):
+    name: str
+    description: str
+    arch: str
+    package_name: Optional[str]
+    package_path: Optional[str]
+
+    def nice_str(self, newlines: bool = False, colors: bool = False) -> str:
+        separator = '\n' if newlines else ', '
+        assert bool(self.package_path) == bool(self.package_name)
+        package_path = {"Package Path": self.package_path} if self.package_path else {}
+        fields = {
+            "Device": self.name,
+            "Description": self.description or f"[no package {'description' if self.package_name else 'associated (?!)'} and deviceinfo not parsed]",
+            "Architecture": self.arch,
+            "Package Name": self.package_name or "no package associated. PROBABLY A BUG!",
+            **package_path,
+        }
+        return separator.join([f"{color_str(name, bold=True, use_colors=colors)}: {value}" for name, value in fields.items()])
+
+
+class Device(DictScheme):
+    name: str
+    arch: Arch
+    package: Pkgbuild
+    deviceinfo: Optional[DeviceInfo]
+
+    def __repr__(self):
+        return f'Device<{self.name},{self.arch},{self.package.path if self.package else "[no package]"}>'
+
+    def __str__(self):
+        return self.nice_str(newlines=True)
+
+    def nice_str(self, *args, **kwargs) -> str:
+        return self.get_summary().nice_str(*args, **kwargs)
+
+    def get_summary(self) -> DeviceSummary:
+        result: dict[str, Optional[str]] = {}
+        description = ((self.package.description if self.package else "").strip() or
+                       (self.deviceinfo.get("name", "[No name in deviceinfo]") if self.deviceinfo else "")).strip()
+        result["name"] = self.name
+        result["description"] = description
+        result["arch"] = self.arch
+        result["package_name"] = self.package.name if self.package else None
+        result["package_path"] = self.package.path if self.package else None
+        return DeviceSummary(result)
+
+    def parse_deviceinfo(self, try_download: bool = True, lazy: bool = True) -> DeviceInfo:
+        if not lazy or 'deviceinfo' not in self or self.deviceinfo is None:
+            # avoid import loop
+            from packages.build import check_package_version_built
+            is_built = check_package_version_built(self.package, self.arch, try_download=try_download)
+            if not is_built:
+                raise Exception(f"device package {self.package.name} for device {self.name} couldn't be acquired!")
+            pkgs: dict[str, LocalPackage] = get_kupfer_local(arch=self.arch, in_chroot=False, scan=True).get_packages()
+            if self.package.name not in pkgs:
+                raise Exception(f"device package {self.package.name} somehow not in repos, this is a kupferbootstrap bug")
+            pkg = pkgs[self.package.name]
+            file_path = pkg.acquire()
+            assert file_path
+            assert os.path.exists(file_path)
+            deviceinfo_path = 'etc/kupfer/deviceinfo'
+            for path, f in read_files_from_tar(file_path, [deviceinfo_path]):
+                if path != deviceinfo_path:
+                    raise Exception(f'Somehow, we got a wrong file: expected: "{deviceinfo_path}", got: "{path}"')
+                with f as fd:
+                    lines = fd.readlines()
+                    assert lines
+                    if lines and isinstance(lines[0], bytes):
+                        lines = [line.decode() for line in lines]
+            info = parse_deviceinfo(lines, self.name)
+            assert info.arch
+            assert info.arch == self.arch
+            self['deviceinfo'] = info
+        assert self.deviceinfo
+        return self.deviceinfo
+
+    def get_image_sectorsize(self, **kwargs) -> Optional[int]:
+        """Gets the deviceinfo_rootfs_image_sector_size if defined, otherwise None"""
+        return self.parse_deviceinfo(**kwargs).get('rootfs_image_sector_size', None)
+
+    def get_image_sectorsize_default(self, **kwargs) -> int:
+        return self.get_image_sectorsize(**kwargs) or DEFAULT_IMAGE_SECTOR_SIZE
+
+
+def check_devicepkg_name(name: str, log_level: Optional[int] = None):
+    valid = True
+    if not name.startswith('device-'):
+        valid = False
+        if log_level is not None:
+            logging.log(log_level, f'invalid device package name "{name}": doesn\'t start with "device-"')
+    if name.endswith('-common'):
+        valid = False
+        if log_level is not None:
+            logging.log(log_level, f'invalid device package name "{name}": ends with "-common"')
+    return valid
+
+
+def parse_device_pkg(pkgbuild: Pkgbuild) -> Device:
+    if len(pkgbuild.arches) != 1:
+        raise Exception(f"{pkgbuild.name}: Device package must have exactly one arch, but has {pkgbuild.arches}")
+    arch = pkgbuild.arches[0]
+    if arch == 'any' or arch not in ARCHES:
+        raise Exception(f'unknown arch for device package: {arch}')
+    if pkgbuild.repo != 'device':
+        logging.warning(f'device package {pkgbuild.name} is in unexpected repo "{pkgbuild.repo}", expected "device"')
+    name = pkgbuild.name
+    prefix = 'device-'
+    if name.startswith(prefix):
+        name = name[len(prefix):]
+    return Device(name=name, arch=arch, package=pkgbuild, deviceinfo=None)
+
+
+def sanitize_device_name(name: str, warn: bool = True) -> str:
+    if name not in DEVICE_DEPRECATIONS:
+        return name
+    warning = f"Deprecated device {name}"
+    replacement = DEVICE_DEPRECATIONS[name]
+    if replacement:
+        warning += (f': Device has been renamed to {replacement}! Please adjust your profile config!\n'
+                    'This will become an error in a future version!')
+        name = replacement
+    if warn:
+        logging.warning(warning)
+    return name
+
+
+_device_cache: dict[str, Device] = {}
+_device_cache_populated: bool = False
+
+
+def get_devices(pkgbuilds: Optional[dict[str, Pkgbuild]] = None, lazy: bool = True) -> dict[str, Device]:
+    global _device_cache, _device_cache_populated
+    use_cache = _device_cache_populated and lazy
+    if not use_cache:
+        logging.info("Searching PKGBUILDs for device packages")
+        if not pkgbuilds:
+            pkgbuilds = discover_pkgbuilds(lazy=lazy, repositories=['device'])
+        _device_cache.clear()
+        for pkgbuild in pkgbuilds.values():
+            if not (pkgbuild.repo == 'device' and check_devicepkg_name(pkgbuild.name, log_level=None)):
+                continue
+            dev = parse_device_pkg(pkgbuild)
+            _device_cache[dev.name] = dev
+        _device_cache_populated = True
+    return _device_cache.copy()
+
+
+def get_device(name: str, pkgbuilds: Optional[dict[str, Pkgbuild]] = None, lazy: bool = True, scan_all=False) -> Device:
+    global _device_cache, _device_cache_populated
+    assert lazy or pkgbuilds
+    name = sanitize_device_name(name)
+    if lazy and name in _device_cache:
+        return _device_cache[name]
+    if scan_all:
+        devices = get_devices(pkgbuilds=pkgbuilds, lazy=lazy)
+        if name not in devices:
+            raise Exception(f'Unknown device {name}!\n'
+                            f'Available: {list(devices.keys())}')
+        return devices[name]
+    else:
+        pkgname = f'device-{name}'
+        if pkgbuilds:
+            if pkgname not in pkgbuilds:
+                raise Exception(f'Unknown device {name}!')
+            pkgbuild = pkgbuilds[pkgname]
+        else:
+            if lazy and pkgname in _pkgbuilds_cache:
+                pkgbuild = _pkgbuilds_cache[pkgname]
+            else:
+                init_pkgbuilds()
+                relative_path = os.path.join('device', pkgname)
+                if not os.path.exists(os.path.join(config.get_path('pkgbuilds'), relative_path)):
+                    logging.debug(f'Exact device pkgbuild path "pkgbuilds/{relative_path}" doesn\'t exist, scanning entire repo')
+                    return get_device(name, pkgbuilds=pkgbuilds, lazy=lazy, scan_all=True)
+                pkgbuild = [p for p in get_pkgbuild_by_path(relative_path, lazy=lazy) if p.name == pkgname][0]
+        device = parse_device_pkg(pkgbuild)
+        if lazy:
+            _device_cache[name] = device
+        return device
+
+
+def get_profile_device(profile_name: Optional[str] = None, hint_or_set_arch: bool = False):
+    profile = config.enforce_profile_device_set(profile_name=profile_name, hint_or_set_arch=hint_or_set_arch)
+    return get_device(profile.device)

src/kupferbootstrap/devices/deviceinfo.py

@@ -0,0 +1,273 @@
+# Copyright 2022 Oliver Smith
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Taken from postmarketOS/pmbootstrap, modified for kupferbootstrap by Prawn
+import copy
+import logging
+import os
+
+from typing import Mapping, Optional
+
+from config.state import config
+from constants import Arch
+from dictscheme import DictScheme
+
+PMOS_ARCHES_OVERRIDES: dict[str, Arch] = {
+    "armv7": 'armv7h',
+}
+
+DEFAULT_IMAGE_SECTOR_SIZE = 512
+
+
+class DeviceInfo(DictScheme):
+    arch: Arch
+    name: str
+    manufacturer: str
+    codename: str
+    chassis: str
+    flash_pagesize: int
+    flash_method: str
+    rootfs_image_sector_size: Optional[int]
+
+    @classmethod
+    def transform(cls, values: Mapping[str, Optional[str]], **kwargs):
+        kwargs = {'allow_extra': True} | kwargs
+        return super().transform(values, **kwargs)
+
+
+# Variables from deviceinfo. Reference: <https://postmarketos.org/deviceinfo>
+deviceinfo_attributes = [
+    # general
+    "format_version",
+    "name",
+    "manufacturer",
+    "codename",
+    "year",
+    "dtb",
+    "modules_initfs",
+    "arch",
+
+    # device
+    "chassis",
+    "keyboard",
+    "external_storage",
+    "screen_width",
+    "screen_height",
+    "dev_touchscreen",
+    "dev_touchscreen_calibration",
+    "append_dtb",
+
+    # bootloader
+    "flash_method",
+    "boot_filesystem",
+
+    # flash
+    "flash_heimdall_partition_kernel",
+    "flash_heimdall_partition_initfs",
+    "flash_heimdall_partition_system",
+    "flash_heimdall_partition_vbmeta",
+    "flash_heimdall_partition_dtbo",
+    "flash_fastboot_partition_kernel",
+    "flash_fastboot_partition_system",
+    "flash_fastboot_partition_vbmeta",
+    "flash_fastboot_partition_dtbo",
+    "generate_legacy_uboot_initfs",
+    "kernel_cmdline",
+    "generate_bootimg",
+    "bootimg_qcdt",
+    "bootimg_mtk_mkimage",
+    "bootimg_dtb_second",
+    "flash_offset_base",
+    "flash_offset_kernel",
+    "flash_offset_ramdisk",
+    "flash_offset_second",
+    "flash_offset_tags",
+    "flash_pagesize",
+    "flash_fastboot_max_size",
+    "flash_sparse",
+    "flash_sparse_samsung_format",
+    "rootfs_image_sector_size",
+    "sd_embed_firmware",
+    "sd_embed_firmware_step_size",
+    "partition_blacklist",
+    "boot_part_start",
+    "partition_type",
+    "root_filesystem",
+    "flash_kernel_on_update",
+    "cgpt_kpart",
+    "cgpt_kpart_start",
+    "cgpt_kpart_size",
+
+    # weston
+    "weston_pixman_type",
+
+    # keymaps
+    "keymaps",
+]
+
+# Valid types for the 'chassis' atribute in deviceinfo
+# See https://www.freedesktop.org/software/systemd/man/machine-info.html
+deviceinfo_chassis_types = [
+    "desktop",
+    "laptop",
+    "convertible",
+    "server",
+    "tablet",
+    "handset",
+    "watch",
+    "embedded",
+    "vm",
+]
+
+
+def sanity_check(deviceinfo: dict[str, Optional[str]], device_name: str):
+    try:
+        _pmos_sanity_check(deviceinfo, device_name)
+    except RuntimeError as err:
+        raise Exception(f"{device_name}: The postmarketOS checker for deviceinfo files has run into an issue.\n"
+                        "Here at kupfer, we usually don't maintain our own deviceinfo files "
+                        "and instead often download them postmarketOS in our PKGBUILDs.\n"
+                        "Please make sure your PKGBUILDs.git is up to date. (run `kupferbootstrap packages update`)\n"
+                        "If the problem persists, please open an issue for this device's deviceinfo file "
+                        "in the kupfer pkgbuilds git repo on Gitlab.\n\n"
+                        "postmarketOS error message (referenced file may not exist until you run makepkg in that directory):\n"
+                        f"{err}")
+
+
+def _pmos_sanity_check(info: dict[str, Optional[str]], device_name: str):
+    # Resolve path for more readable error messages
+    path = os.path.join(config.get_path('pkgbuilds'), 'device', device_name, 'deviceinfo')
+
+    # Legacy errors
+    if "flash_methods" in info:
+        raise RuntimeError("deviceinfo_flash_methods has been renamed to"
+                           " deviceinfo_flash_method. Please adjust your"
+                           " deviceinfo file: " + path)
+    if "external_disk" in info or "external_disk_install" in info:
+        raise RuntimeError("Instead of deviceinfo_external_disk and"
+                           " deviceinfo_external_disk_install, please use the"
+                           " new variable deviceinfo_external_storage in your"
+                           " deviceinfo file: " + path)
+    if "msm_refresher" in info:
+        raise RuntimeError("It is enough to specify 'msm-fb-refresher' in the"
+                           " depends of your device's package now. Please"
+                           " delete the deviceinfo_msm_refresher line in: " + path)
+    if "flash_fastboot_vendor_id" in info:
+        raise RuntimeError("Fastboot doesn't allow specifying the vendor ID"
+                           " anymore (#1830). Try removing the"
+                           " 'deviceinfo_flash_fastboot_vendor_id' line in: " + path + " (if you are sure that "
+                           " you need this, then we can probably bring it back to fastboot, just"
+                           " let us know in the postmarketOS issues!)")
+    if "nonfree" in info:
+        raise RuntimeError("deviceinfo_nonfree is unused. "
+                           "Please delete it in: " + path)
+    if "dev_keyboard" in info:
+        raise RuntimeError("deviceinfo_dev_keyboard is unused. "
+                           "Please delete it in: " + path)
+    if "date" in info:
+        raise RuntimeError("deviceinfo_date was replaced by deviceinfo_year. "
+                           "Set it to the release year in: " + path)
+
+    # "codename" is required
+    codename = os.path.basename(os.path.dirname(path))
+    if codename.startswith("device-"):
+        codename = codename[7:]
+    # kupfer prepends the SoC
+    codename_alternative = codename.split('-', maxsplit=1)[1] if codename.count('-') > 1 else codename
+    _codename = info.get('codename', None)
+    if not _codename or not (_codename in [codename, codename_alternative] or codename.startswith(_codename) or
+                             codename_alternative.startswith(_codename)):
+        raise RuntimeError(f"Please add 'deviceinfo_codename=\"{codename}\"' "
+                           f"to: {path}")
+
+    # "chassis" is required
+    chassis_types = deviceinfo_chassis_types
+    if "chassis" not in info or not info["chassis"]:
+        logging.info("NOTE: the most commonly used chassis types in"
+                     " postmarketOS are 'handset' (for phones) and 'tablet'.")
+        raise RuntimeError(f"Please add 'deviceinfo_chassis' to: {path}")
+
+    # "arch" is required
+    if "arch" not in info or not info["arch"]:
+        raise RuntimeError(f"Please add 'deviceinfo_arch' to: {path}")
+
+    # "chassis" validation
+    chassis_type = info["chassis"]
+    if chassis_type not in chassis_types:
+        raise RuntimeError(f"Unknown chassis type '{chassis_type}', should"
+                           f" be one of {', '.join(chassis_types)}. Fix this"
+                           f" and try again: {path}")
+
+
+def parse_kernel_suffix(deviceinfo: dict[str, Optional[str]], kernel: str = 'mainline') -> dict[str, Optional[str]]:
+    """
+    Remove the kernel suffix (as selected in 'pmbootstrap init') from
+    deviceinfo variables. Related:
+    https://wiki.postmarketos.org/wiki/Device_specific_package#Multiple_kernels
+
+    :param info: deviceinfo dict, e.g.:
+                 {"a": "first",
+                  "b_mainline": "second",
+                  "b_downstream": "third"}
+    :param device: which device info belongs to
+    :param kernel: which kernel suffix to remove (e.g. "mainline")
+    :returns: info, but with the configured kernel suffix removed, e.g:
+              {"a": "first",
+               "b": "second",
+               "b_downstream": "third"}
+    """
+    # Do nothing if the configured kernel isn't available in the kernel (e.g.
+    # after switching from device with multiple kernels to device with only one
+    # kernel)
+    # kernels = pmb.parse._apkbuild.kernels(args, device)
+    if not kernel:  # or kernel not in kernels:
+        logging.debug(f"parse_kernel_suffix: {kernel} not set, skipping")
+        return deviceinfo
+
+    ret = copy.copy(deviceinfo)
+
+    suffix_kernel = kernel.replace("-", "_")
+    for key in deviceinfo_attributes:
+        key_kernel = f"{key}_{suffix_kernel}"
+        if key_kernel not in ret:
+            continue
+
+        # Move ret[key_kernel] to ret[key]
+        logging.debug(f"parse_kernel_suffix: {key_kernel} => {key}")
+        ret[key] = ret[key_kernel]
+        del (ret[key_kernel])
+
+    return ret
+
+
+def parse_deviceinfo(deviceinfo_lines: list[str], device_name: str, kernel='mainline') -> DeviceInfo:
+    """
+    :param device: defaults to args.device
+    :param kernel: defaults to args.kernel
+    """
+    info: dict[str, Optional[str]] = {}
+    for line in deviceinfo_lines:
+        line = line.strip()
+        if line.startswith("#") or not line:
+            continue
+        if "=" not in line:
+            raise SyntaxError(f"{device_name}: No '=' found:\n\t{line}")
+        split = line.split("=", 1)
+        if not split[0].startswith("deviceinfo_"):
+            logging.warning(f"{device_name}: Unknown key {split[0]} in deviceinfo:\n{line}")
+            continue
+        key = split[0][len("deviceinfo_"):]
+        value = split[1].replace("\"", "").replace("\n", "")
+        info[key] = value
+
+    # Assign empty string as default
+    for key in deviceinfo_attributes:
+        if key not in info:
+            info[key] = None
+
+    info = parse_kernel_suffix(info, kernel)
+    sanity_check(info, device_name)
+    if 'arch' in info:
+        arch = info['arch']
+        info['arch'] = PMOS_ARCHES_OVERRIDES.get(arch, arch)  # type: ignore[arg-type]
+    dev = DeviceInfo.fromDict(info)
+    return dev

src/kupferbootstrap/devices/test_device.py

@@ -0,0 +1,100 @@
+import pytest
+
+import os
+
+from copy import copy
+
+from config.state import ConfigStateHolder, config
+from packages.pkgbuild import init_pkgbuilds, discover_pkgbuilds, Pkgbuild, parse_pkgbuild
+from .device import Device, DEVICE_DEPRECATIONS, get_device, get_devices, parse_device_pkg, check_devicepkg_name
+
+
+@pytest.fixture(scope='session')
+def initialise_pkgbuilds_dir() -> ConfigStateHolder:
+    config.try_load_file()
+    init_pkgbuilds(interactive=False)
+    return config
+
+
+@pytest.fixture()
+def pkgbuilds_dir(initialise_pkgbuilds_dir: ConfigStateHolder) -> str:
+    global config
+    config = initialise_pkgbuilds_dir
+    return config.get_path('pkgbuilds')
+
+
+@pytest.fixture(scope='session')
+def pkgbuilds_repo_cached(initialise_pkgbuilds_dir) -> dict[str, Pkgbuild]:
+    return discover_pkgbuilds()
+
+
+@pytest.fixture()
+def pkgbuilds_repo(pkgbuilds_dir, pkgbuilds_repo_cached):
+    # use pkgbuilds_dir to ensure global config gets overriden, can't be done from session scope fixtures
+    return pkgbuilds_repo_cached
+
+
+ONEPLUS_ENCHILADA = 'sdm845-oneplus-enchilada'
+ONEPLUS_ENCHILADA_PKG = f'device-{ONEPLUS_ENCHILADA}'
+
+
+@pytest.fixture(scope='session')
+def enchilada_pkgbuild(initialise_pkgbuilds_dir: ConfigStateHolder):
+    config = initialise_pkgbuilds_dir
+    config.try_load_file()
+    return parse_pkgbuild(os.path.join('device', ONEPLUS_ENCHILADA_PKG))[0]
+
+
+def validate_oneplus_enchilada(d: Device):
+    assert d
+    assert d.arch == 'aarch64'
+    assert d.package and d.package.name == ONEPLUS_ENCHILADA_PKG
+
+
+def test_fixture_initialise_pkgbuilds_dir(initialise_pkgbuilds_dir: ConfigStateHolder):
+    assert os.path.exists(os.path.join(config.get_path('pkgbuilds'), 'device'))
+
+
+def test_fixture_pkgbuilds_dir(pkgbuilds_dir):
+    assert os.path.exists(os.path.join(pkgbuilds_dir, 'device'))
+
+
+def test_get_device():
+    name = ONEPLUS_ENCHILADA
+    d = get_device(name)
+    validate_oneplus_enchilada(d)
+
+
+def test_get_device_deprecated():
+    name = 'oneplus-enchilada'
+    assert name in DEVICE_DEPRECATIONS
+    d = get_device(name)
+    # currently redirects to correct package, need to change this test when changed to an exception
+    validate_oneplus_enchilada(d)
+
+
+def test_parse_device_pkg_enchilada(enchilada_pkgbuild):
+    validate_oneplus_enchilada(parse_device_pkg(enchilada_pkgbuild))
+
+
+def test_parse_device_pkg_malformed_arch(enchilada_pkgbuild):
+    enchilada_pkgbuild = copy(enchilada_pkgbuild)
+    enchilada_pkgbuild.arches.append('x86_64')
+    with pytest.raises(Exception):
+        parse_device_pkg(enchilada_pkgbuild)
+
+
+def test_discover_packages_and_warm_cache_sorry_takes_long(pkgbuilds_repo):
+    # mostly used to warm up the cache in a user-visible way
+    assert pkgbuilds_repo
+    assert ONEPLUS_ENCHILADA_PKG in pkgbuilds_repo
+
+
+def test_get_devices(pkgbuilds_repo: dict[str, Pkgbuild]):
+    d = get_devices(pkgbuilds_repo)
+    assert d
+    assert ONEPLUS_ENCHILADA in d
+    for p in d.values():
+        check_devicepkg_name(p.package.name)
+    assert 'sdm845-oneplus-common' not in d
+    validate_oneplus_enchilada(d[ONEPLUS_ENCHILADA])

src/kupferbootstrap/devices/test_deviceinfo.py

@@ -0,0 +1,87 @@
+from config.state import config
+
+from .deviceinfo import DeviceInfo, parse_deviceinfo
+from .device import get_device
+
+deviceinfo_text = """
+# Reference: <https://postmarketos.org/deviceinfo>
+# Please use double quotes only. You can source this file in shell scripts.
+
+deviceinfo_format_version="0"
+deviceinfo_name="BQ Aquaris X5"
+deviceinfo_manufacturer="BQ"
+deviceinfo_codename="bq-paella"
+deviceinfo_year="2015"
+deviceinfo_dtb="qcom/msm8916-longcheer-l8910"
+deviceinfo_append_dtb="true"
+deviceinfo_modules_initfs="smb1360 panel-longcheer-yushun-nt35520 panel-longcheer-truly-otm1288a msm himax-hx852x"
+deviceinfo_arch="aarch64"
+
+# Device related
+deviceinfo_gpu_accelerated="true"
+deviceinfo_chassis="handset"
+deviceinfo_keyboard="false"
+deviceinfo_external_storage="true"
+deviceinfo_screen_width="720"
+deviceinfo_screen_height="1280"
+deviceinfo_getty="ttyMSM0;115200"
+
+# Bootloader related
+deviceinfo_flash_method="fastboot"
+deviceinfo_kernel_cmdline="earlycon console=ttyMSM0,115200 PMOS_NO_OUTPUT_REDIRECT"
+deviceinfo_generate_bootimg="true"
+deviceinfo_flash_offset_base="0x80000000"
+deviceinfo_flash_offset_kernel="0x00080000"
+deviceinfo_flash_offset_ramdisk="0x02000000"
+deviceinfo_flash_offset_second="0x00f00000"
+deviceinfo_flash_offset_tags="0x01e00000"
+deviceinfo_flash_pagesize="2048"
+deviceinfo_flash_sparse="true"
+"""
+
+
+def test_parse_deviceinfo():
+    config.try_load_file()
+    d = parse_deviceinfo(deviceinfo_text.split('\n'), 'device-bq-paella')
+    assert isinstance(d, DeviceInfo)
+    assert d
+    assert d.arch
+    assert d.chassis
+    assert d.flash_method
+    assert d.flash_pagesize
+    # test that fields not listed in the class definition make it into the object
+    assert d.dtb
+    assert d.gpu_accelerated
+
+
+def test_parse_variant_deviceinfo():
+    config.try_load_file()
+    # {'variant1': 'AAAAA', 'variant2': 'BBBBB', 'variant3': 'CCCCC'}
+    variants = {f"variant{i+1}": chr(ord('A') + i) * 5 for i in range(0, 3)}
+    field = "dev_touchscreen_calibration"
+    text = deviceinfo_text + '\n'.join([""] + [f"deviceinfo_{field}_{variant}={value}" for variant, value in variants.items()])
+    for variant, result in variants.items():
+        d = parse_deviceinfo(text.split('\n'), 'device-bq-paella', kernel=variant)
+        # note: the python code from pmb only strips one variant, the shell code in packaging strips all variants
+        assert f'{field}_{variant}' not in d
+        assert field in d
+        assert d[field] == result
+
+
+def test_get_deviceinfo_from_repo():
+    config.try_load_file()
+    dev = get_device('sdm845-oneplus-enchilada')
+    assert dev
+    info = dev.parse_deviceinfo()
+    assert info
+
+
+def test_get_variant_deviceinfo_from_repo():
+    config.try_load_file()
+    dev = get_device('sdm845-xiaomi-beryllium-ebbg')
+    assert dev
+    info = dev.parse_deviceinfo()
+    assert info
+    assert 'dtb' in info  # variant-specific variable, check it has been stripped down from 'dtb_ebbg' to 'dtb'
+    assert 'dtb_tianma' not in info
+    assert info.dtb