bakar 0.5.0__py3-none-any.whl

bakar/__init__.py

@@ -0,0 +1,3 @@
+"""bakar: practical kas wrapper for Yocto BSP development."""
+
+__version__ = "0.5.0"

bakar/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m bakar`."""
+
+from bakar.cli import app
+
+if __name__ == "__main__":
+    app()

bakar/bsp_detect.py

@@ -0,0 +1,189 @@
+"""Inspect a kas YAML and classify the BSP family.
+
+Used by the BYO (Form A) path of ``bakar build``: when the user hands
+bakar a kas YAML directly, we cannot rely on the manifest filename
+regex in :func:`bakar.bsp_model.detect_bsp_family`. Instead the
+classifier reads ``machine:`` and ``repos:`` from the YAML and applies
+a small first-match-wins rule set:
+
+* machine starts with ``imx``                                  -> ``nxp``
+* machine starts with ``am`` / ``k3-`` / ``j7-``               -> ``ti``
+* repos contains ``meta-imx`` / ``meta-freescale*`` / ``meta-nxp*`` -> ``nxp``
+* repos contains ``meta-ti-bsp`` / ``meta-ti`` / ``meta-arago`` -> ``ti``
+* parseable YAML with at least ``machine:`` or ``repos:``      -> ``generic``
+* unparseable / empty                                          -> ``unknown``
+
+The ``generic`` classification is the BSP-agnostic fallback for kas
+YAMLs that look like real builds but do not target an NXP/TI SoM
+(e.g. qemuarm64 + poky + meta-arm). Callers layer the
+``bakar-tuning-generic.yml`` overlay - which carries only the
+BSP-agnostic optimizations (ccache, MIRRORS, PREMIRRORS, FETCHCMD_wget,
+PYTHONMALLOC) - onto these YAMLs.
+
+The function never raises - I/O on the YAML is wrapped defensively so
+``bakar build my.yml`` can fail with a single typer.Exit(2) instead of
+a Python traceback.
+
+See also :func:`bakar.bsp_model.detect_bsp_family`, which classifies
+by manifest *filename* (no I/O, pure regex). The two classifiers serve
+different entry points: this module handles the BYO-yaml path
+(``bakar build my.yml``); ``detect_bsp_family`` handles the manifest
+path (``bakar build -f imx-*.xml``). Both encode NXP/TI family
+markers; if either set of markers changes, update the other.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Literal
+
+import yaml
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# Repo-name substrings that identify each BSP. Order matters within a
+# family: the first matching substring wins. The lists are kept short
+# and explicit so a future BSP addition does not collide silently.
+_NXP_REPO_NAMES: tuple[str, ...] = (
+    "meta-imx",
+    "meta-freescale",
+    "meta-nxp",
+    "meta-variscite-bsp-imx",
+    "meta-variscite-sdk-imx",
+)
+
+_TI_REPO_NAMES: tuple[str, ...] = (
+    "meta-ti-bsp",
+    "meta-ti-extras",
+    "meta-ti",
+    "meta-tisdk",
+    "meta-arago",
+    "meta-variscite-bsp-ti",
+    "meta-variscite-sdk-ti",
+)
+
+
+def _machine_family(machine: str) -> Literal["nxp", "ti", "unknown"]:
+    if not machine:
+        return "unknown"
+    name = machine.lower()
+    if name.startswith("imx"):
+        return "nxp"
+    if name.startswith(("am", "k3-", "j7-", "j72", "j78", "j784")):
+        return "ti"
+    return "unknown"
+
+
+def _repos_family(repos: dict[str, Any] | None) -> Literal["nxp", "ti", "unknown"]:
+    if not isinstance(repos, dict):
+        return "unknown"
+    names = set(repos.keys())
+    for hit in _NXP_REPO_NAMES:
+        if hit in names:
+            return "nxp"
+    for hit in _TI_REPO_NAMES:
+        if hit in names:
+            return "ti"
+    return "unknown"
+
+
+def detect_bsp_from_yaml(yaml_path: Path) -> Literal["nxp", "ti", "generic", "unknown"]:
+    """Inspect a kas YAML and classify the BSP family.
+
+    Pure function over a parsed YAML dict. Returns ``"generic"`` for a
+    kas YAML that parses cleanly but lacks NXP/TI markers; callers
+    use that to layer the BSP-agnostic tuning overlay. Returns
+    ``"unknown"`` only for unparseable, empty, or shape-incomplete
+    YAMLs - those exit with a typer.Exit(2) and a hint.
+    """
+    if yaml_path is None or not yaml_path.is_file():
+        return "unknown"
+    try:
+        with yaml_path.open("r", encoding="utf-8") as fh:
+            data = yaml.safe_load(fh)
+    except OSError, yaml.YAMLError:
+        return "unknown"
+    if not isinstance(data, dict):
+        return "unknown"
+
+    machine = data.get("machine", "")
+    machine_hit = _machine_family(machine if isinstance(machine, str) else "")
+    if machine_hit != "unknown":
+        return machine_hit
+
+    repos_hit = _repos_family(data.get("repos"))
+    if repos_hit != "unknown":
+        return repos_hit
+
+    # No NXP/TI markers but the YAML has at least a machine string or a
+    # repos block - treat as a generic kas build. Reject only YAMLs
+    # that lack both anchors (typo or empty file).
+    has_machine = isinstance(machine, str) and bool(machine.strip())
+    has_repos = isinstance(data.get("repos"), dict) and bool(data["repos"])
+    if has_machine or has_repos:
+        return "generic"
+    return "unknown"
+
+
+def is_bbsetup_workspace(path: Path) -> bool:
+    """Return True if ``path`` is an initialized ``bitbake-setup`` workspace.
+
+    A directory qualifies only when all of the following hold:
+
+    * ``<path>/config/config-upstream.json`` exists and parses as JSON
+      with top-level ``data`` and ``bitbake-config`` keys.
+    * ``<path>/build/init-build-env`` exists (the Yocto environment
+      setup script that ``bitbake-setup init`` writes).
+
+    Detection is structure-based: bitbake-setup workspaces have no
+    manifest filename to match against the regex dispatch used for
+    NXP/TI families. The function never raises - a missing file,
+    unreadable config, or malformed JSON all return False so callers
+    can fall through to the next detection path.
+    """
+    cfg = path / "config" / "config-upstream.json"
+    env = path / "build" / "init-build-env"
+    if not (cfg.exists() and env.exists()):
+        return False
+    try:
+        data = json.loads(cfg.read_text(encoding="utf-8"))
+    except json.JSONDecodeError, OSError:
+        return False
+    return isinstance(data, dict) and "data" in data and "bitbake-config" in data
+
+
+def is_meta_avocado_yaml(yaml_path: Path) -> bool:
+    """Return True if the YAML lives inside a meta-avocado repository.
+
+    Walks the resolved path and checks whether any ancestor directory is
+    named ``meta-avocado``. This is how bakar detects that a generic kas
+    YAML belongs to the Avocado OS build system and needs the
+    ``init-build``-style build-directory setup before kas can run.
+    """
+    try:
+        return "meta-avocado" in yaml_path.resolve().parts
+    except Exception:
+        return False
+
+
+def detect_kas_workspace(yaml_path: Path) -> Path:
+    """Return the effective workspace root for a generic kas YAML.
+
+    For meta-avocado YAMLs the YAML sits several levels deep inside the
+    ``meta-avocado`` repository (e.g. ``sources/meta-avocado/kas/machine/
+    qemux86-64.yml``). kas must run from a build directory that is a
+    *sibling* of ``meta-avocado/`` (e.g. ``sources/build-qemux86-64/``),
+    not from inside the repo. This function walks up from the YAML to
+    find the ``meta-avocado`` boundary and returns its parent
+    (e.g. ``sources/``) so :func:`bakar.config.BuildConfig.bsp_root`
+    can derive the correct build-directory path.
+
+    For every other generic kas YAML the workspace is simply the YAML's
+    parent directory (preserving the existing behavior).
+    """
+    resolved = yaml_path.resolve()
+    for parent in resolved.parents:
+        if parent.name == "meta-avocado":
+            return parent.parent
+    return resolved.parent

bakar/bsp_model.py

@@ -0,0 +1,260 @@
+"""Per-BSP model for the bakar CLI.
+
+NXP i.MX and TI Sitara BSP families are supported.
+Each family has its own toolchain (Google ``repo`` + ``var-setup-release.sh``
+for NXP; ``varigit/oe-layersetup`` shell wrapper for TI), its own
+manifest format (``imx-A.B.C-X.Y.Z.xml`` vs ``processor-sdk-...-config_var<N>.txt``),
+its own static tuning overlay (``overlays/bakar-tuning-<bsp>.yml``),
+and its own pre-flight checks.
+
+This module exports:
+
+* :func:`detect_bsp_family` - classify a manifest filename. Pure regex,
+  no I/O. The return value drives both the dispatcher in
+  :mod:`bakar.cli` and the ``check_host_tools`` decision. For the
+  complementary BYO-yaml classifier (content-based, not filename-based)
+  see :func:`bakar.bsp_detect.detect_bsp_from_yaml`.
+* :func:`infer_bsp_branch` - synthesize the
+  ``meta-variscite-bsp-ti`` branch suffix from a TI config filename.
+* :class:`BspModel` - dataclass + registry that hold every per-BSP
+  knob: defaults, kas template, sync/setup steps, doctor extras.
+* :func:`get_model` - factory returning the dispatched model. Imports
+  are lazy so :mod:`bakar.config` (which imports
+  :func:`infer_bsp_branch` for TI branch fallback) can keep its
+  circular dep-free top-level import.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any, Literal
+
+from bakar.vendor_config import load_vendors
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from bakar.kas import KasTemplate
+
+
+# ---------------------------------------------------------------------------
+# Manifest-shape detection (no I/O on the regex path)
+# ---------------------------------------------------------------------------
+
+
+# NXP manifest filename: imx-<kernel>-<bsp>.xml
+# Examples: imx-6.6.52-2.2.2.xml, imx-6.12.49-2.2.0.xml
+_NXP_MANIFEST_RE = re.compile(r"^imx-\d+\.\d+\.\d+-\d+\.\d+\.\d+\.xml$")
+
+# TI Processor SDK config filename:
+#   processor-sdk-<poky>-<flavour>-<sdk>-config_<var>.txt
+# where <poky> is the LTS code name (scarthgap, walnascar, ...),
+# <flavour> is "chromium" / "non-chromium" / etc,
+# <sdk> is a 4-part TI SDK version (11.00.09.04),
+# <var>  is "var01" / "var02" / ...
+_TI_PROCESSOR_SDK_RE = re.compile(
+    r"^processor-sdk-"
+    r"(?P<poky>[A-Za-z]\w*)-"
+    r".*?-"
+    r"(?P<sdk>\d+\.\d+\.\d+\.\d+)-"
+    r"config_(?P<var>var\d+)\.txt$"
+)
+
+# TI legacy/Arago manifest filename: arago-<anything>.txt
+# Kept as alternation for forward compatibility with older
+# config naming conventions.
+_TI_ARAGO_RE = re.compile(r"^arago-.*\.txt$")
+
+# Layer name string used as a fallback heuristic when a config file is
+# present but does not match either regex.
+_TI_LAYER_PREFIX = "meta-variscite-bsp-ti"
+
+
+def detect_bsp_family(
+    manifest_path: Path | None,
+    config_file: Path | None = None,
+) -> Literal["nxp", "ti", "unknown"]:
+    """Detect the BSP family from a manifest filename and optional config.
+
+    Only the filename (``path.name``) is inspected; the file need not
+    exist on disk. Pass ``None`` for either argument to skip that
+    check. The function never raises - I/O on ``config_file`` is
+    wrapped defensively.
+    """
+    if manifest_path is not None:
+        name = manifest_path.name
+        for vendor in load_vendors():
+            if re.match(vendor.manifest_regex, name):
+                return vendor.family  # type: ignore[return-value]
+        if _NXP_MANIFEST_RE.match(name):
+            return "nxp"
+        if _TI_PROCESSOR_SDK_RE.match(name) or _TI_ARAGO_RE.match(name):
+            return "ti"
+
+    if config_file is not None:
+        try:
+            text = config_file.read_text(encoding="utf-8", errors="replace")
+            if _TI_LAYER_PREFIX in text:
+                return "ti"
+        except OSError:
+            pass
+
+    return "unknown"
+
+
+def infer_bsp_branch(config_filename: str) -> str:
+    """Derive the ``meta-variscite-bsp-ti`` branch from a TI config name.
+
+    The canonical filename
+    ``processor-sdk-scarthgap-chromium-11.00.09.04-config_var01.txt``
+    parses to ``(poky=scarthgap, sdk=11.00.09.04, var=var01)`` and
+    yields ``scarthgap_11.00.09.04_var01`` - the actual branch name on
+    the layer repo.
+
+    Returns ``"<unknown>"`` for inputs that do not match the regex
+    (legacy ``arago-*.txt`` configs go through the legacy versioning
+    scheme, which is out of scope for this helper).
+    """
+    m = _TI_PROCESSOR_SDK_RE.match(config_filename)
+    if not m:
+        return "<unknown>"
+    return f"{m.group('poky')}_{m.group('sdk')}_{m.group('var')}"
+
+
+# ---------------------------------------------------------------------------
+# BspModel registry
+# ---------------------------------------------------------------------------
+
+
+# Type aliases. ``Callable[..., None]`` is intentionally permissive so
+# both the NXP sync step (``init_and_sync(cfg, log, *, force_init=...)``)
+# and the TI sync step (``populate(cfg, log, *, force_init=...)``) fit.
+SyncStep = Callable[..., None]
+SetupEnvStep = Callable[..., None]
+DoctorCheck = Callable[..., Any]
+
+
+@dataclass(frozen=True)
+class BspModel:
+    """Per-BSP knobs consumed by the dispatch layer.
+
+    Every field that varies between NXP and TI lives here. The CLI's
+    ``_dispatch_bsp`` returns one of two singleton instances; downstream
+    code reads the fields instead of switching on ``cfg.bsp_family``.
+    """
+
+    family: Literal["nxp", "ti"]
+    workspace_subdir: str  # "nxp" or "ti"
+    kas_yaml_filename: str  # "kas-nxp.yml" or "kas-ti.yml"
+    tuning_overlay_filename: str  # "bakar-tuning-nxp.yml" or "bakar-tuning-ti.yml"
+    manifest_kind: Literal["repo-xml", "oe-layertool-config"]
+    default_machine: str
+    default_distro: str
+    default_image: str
+    default_manifest: str
+    default_branch: str
+    required_host_tools: tuple[str, ...]
+    sync_step: SyncStep
+    setup_env_step: SetupEnvStep
+    kas_template: KasTemplate
+    doctor_extras: tuple[DoctorCheck, ...]
+
+
+def get_model(family: Literal["nxp", "ti"]) -> BspModel:
+    """Return the BspModel singleton for ``family``.
+
+    Imports are intentionally lazy. ``bsp_model`` is imported from
+    ``config.py`` (``infer_bsp_branch``) and from ``cli.py``; deferring
+    the heavy imports until ``get_model`` is actually called keeps the
+    import graph clean and lets unit tests construct dummy models
+    without dragging in diagnostics or steps.
+    """
+    # Lazy: avoid pulling diagnostics/steps/kas into every consumer of
+    # detect_bsp_family or infer_bsp_branch.
+    from bakar import config as cfg_mod
+    from bakar.diagnostics import (
+        check_forks_linux_imx,
+        check_forks_ti_linux_kernel,
+        check_forks_ti_u_boot,
+        check_git_object_cache,
+        check_manifest_consistency,
+        check_ti_layertool_config_consistency,
+        check_ti_layertool_present,
+    )
+    from bakar.kas import NXP_KAS_TEMPLATE, TI_KAS_TEMPLATE
+    from bakar.steps import repo as step_repo
+    from bakar.steps import setup_env as step_setup
+    from bakar.steps import ti_layertool as step_ti_layertool
+    from bakar.steps import ti_setup_env as step_ti_setup
+
+    if family == "nxp":
+        model = BspModel(
+            family="nxp",
+            workspace_subdir="nxp",
+            kas_yaml_filename="kas-nxp.yml",
+            tuning_overlay_filename="bakar-tuning-nxp.yml",
+            manifest_kind="repo-xml",
+            default_machine=cfg_mod.DEFAULT_NXP_MACHINE,
+            default_distro=cfg_mod.DEFAULT_NXP_DISTRO,
+            default_image=cfg_mod.DEFAULT_NXP_IMAGE,
+            default_manifest=cfg_mod.DEFAULT_NXP_MANIFEST,
+            default_branch=cfg_mod.DEFAULT_NXP_REPO_BRANCH,
+            required_host_tools=("repo", "kas-container", "docker", "python3"),
+            sync_step=step_repo.init_and_sync,
+            setup_env_step=step_setup.run,
+            kas_template=NXP_KAS_TEMPLATE,
+            doctor_extras=(
+                check_forks_linux_imx,
+                check_manifest_consistency,
+                check_git_object_cache,
+            ),
+        )
+    elif family == "ti":
+        model = BspModel(
+            family="ti",
+            workspace_subdir="ti",
+            kas_yaml_filename="kas-ti.yml",
+            tuning_overlay_filename="bakar-tuning-ti.yml",
+            manifest_kind="oe-layertool-config",
+            default_machine=cfg_mod.DEFAULT_TI_MACHINE,
+            default_distro=cfg_mod.DEFAULT_TI_DISTRO,
+            default_image=cfg_mod.DEFAULT_TI_IMAGE,
+            default_manifest=cfg_mod.DEFAULT_TI_MANIFEST,
+            default_branch=cfg_mod.DEFAULT_TI_REPO_BRANCH,
+            required_host_tools=("git", "kas-container", "docker", "python3"),
+            sync_step=step_ti_layertool.populate,
+            setup_env_step=step_ti_setup.run,
+            kas_template=TI_KAS_TEMPLATE,
+            doctor_extras=(
+                check_ti_layertool_present,
+                check_ti_layertool_config_consistency,
+                check_forks_ti_linux_kernel,
+                check_forks_ti_u_boot,
+            ),
+        )
+    else:
+        raise ValueError(f"Unknown BSP family: {family!r}")
+
+    # Apply optional VendorEntry overrides for the first matching vendor.
+    for entry in load_vendors():
+        if entry.family == family:
+            overrides: dict[str, Any] = {}
+            if entry.default_machine is not None:
+                overrides["default_machine"] = entry.default_machine
+            if entry.default_distro is not None:
+                overrides["default_distro"] = entry.default_distro
+            if entry.default_image is not None:
+                overrides["default_image"] = entry.default_image
+            if entry.default_manifest is not None:
+                overrides["default_manifest"] = entry.default_manifest
+            if entry.default_branch is not None:
+                overrides["default_branch"] = entry.default_branch
+            if entry.tuning_overlay is not None:
+                overrides["tuning_overlay_filename"] = entry.tuning_overlay
+            if overrides:
+                model = replace(model, **overrides)
+            break
+
+    return model

bakar/cli.py

@@ -0,0 +1,72 @@
+"""bakar entry point - imports all command modules to register @app.command() handlers."""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+
+# Typer >= 0.26 vendored Click as ``typer._click``; the exceptions raised
+# inside Typer's parser are ``typer._click.exceptions.*``, not the external
+# ``click.exceptions.*``. Older Typer still raises from the external module.
+# Catch from both so the entry point works regardless of which Typer ships.
+try:
+    from typer._click import exceptions as _click_exc  # ty: ignore[unresolved-import]
+except ImportError:  # pragma: no cover - typer < 0.26 path
+    from click import exceptions as _click_exc
+
+import bakar.commands.build  # noqa: F401
+import bakar.commands.clean  # noqa: F401
+import bakar.commands.clean_sstate  # noqa: F401
+import bakar.commands.diff  # noqa: F401
+import bakar.commands.doctor  # noqa: F401
+import bakar.commands.dump  # noqa: F401
+import bakar.commands.for_all  # noqa: F401
+import bakar.commands.gen_kas  # noqa: F401
+import bakar.commands.hashserv  # noqa: F401
+import bakar.commands.layers  # noqa: F401
+import bakar.commands.lock  # noqa: F401
+import bakar.commands.log  # noqa: F401
+import bakar.commands.override  # noqa: F401
+import bakar.commands.prefetch  # noqa: F401
+import bakar.commands.report  # noqa: F401
+import bakar.commands.settings  # noqa: F401
+import bakar.commands.shell  # noqa: F401
+import bakar.commands.stress_parse  # noqa: F401
+import bakar.commands.sync  # noqa: F401
+import bakar.commands.triage  # noqa: F401
+from bakar.commands import app  # noqa: F401 - re-exported for pyproject.toml entry point
+from bakar.commands._app import console
+
+__all__ = ["app", "main"]
+
+
+def main() -> int:
+    """Run the bakar CLI with plain (non-Rich-panel) error output."""
+    try:
+        # standalone_mode=False prevents Click from calling sys.exit AND prevents
+        # Typer's rich_utils from rendering UsageError/BadParameter inside a Panel.
+        return app(standalone_mode=False) or 0
+    except _click_exc.UsageError as exc:
+        # Captures NoSuchOption, MissingParameter, BadParameter, and bare UsageError.
+        ctx = exc.ctx
+        if ctx is not None:
+            console.print(ctx.get_usage())
+            console.print(f"Try '{ctx.command_path} --help' for help.")
+        console.print(f"Error: {exc.format_message()}")
+        return exc.exit_code if exc.exit_code is not None else 2
+    except _click_exc.ClickException as exc:
+        # Non-usage Click errors (e.g. FileError, BadOptionUsage, custom ClickException).
+        console.print(f"Error: {exc.format_message()}")
+        return exc.exit_code if exc.exit_code is not None else 1
+    except _click_exc.Abort:
+        # SIGINT during a prompt; Click convention is exit 1 with no traceback.
+        console.print("Aborted.")
+        return 1
+    except (_click_exc.Exit, typer.Exit) as exc:
+        # typer.Exit (used everywhere in our commands) -> the carried exit code.
+        return int(exc.exit_code) if getattr(exc, "exit_code", 0) is not None else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bakar/commands/__init__.py

@@ -0,0 +1,9 @@
+"""bakar command sub-package.
+
+Importing this package registers all subcommands on ``app``. Use
+``from bakar.commands import app`` to get the fully-wired Typer app.
+"""
+
+from bakar.commands._app import app, console
+
+__all__ = ["app", "console"]

bakar/commands/_app.py

@@ -0,0 +1,63 @@
+"""Typer app, Rich console, and startup state for all bakar subcommands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+from rich.console import Console
+
+from bakar import __version__
+from bakar.user_config import load_user_config
+from bakar.vendor_config import load_vendors
+
+if TYPE_CHECKING:
+    from bakar.user_config import UserConfig
+
+app = typer.Typer(
+    help="BSP orchestrator (NXP i.MX + TI Sitara built-in).",
+    no_args_is_help=True,
+    add_completion=False,
+    pretty_exceptions_enable=False,
+)
+console = Console(stderr=True)
+
+_VENDORS: list | None = None
+_USER_CONFIG: UserConfig | None = None
+
+
+def _get_vendors() -> list:
+    global _VENDORS
+    if _VENDORS is None:
+        try:
+            _VENDORS = load_vendors()
+        except ValueError as exc:
+            console.print(f"[red]Invalid vendors config:[/] {exc}")
+            raise typer.Exit(code=2) from exc
+    return _VENDORS
+
+
+def _load_user_config_safe() -> UserConfig:
+    try:
+        return load_user_config()
+    except ValueError as exc:
+        console.print(f"[red]Invalid bakar config:[/] {exc}")
+        raise typer.Exit(code=2) from exc
+
+
+def _version(value: bool) -> None:
+    if value:
+        console.print(f"bakar {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _main(
+    version: Annotated[
+        bool,
+        typer.Option("--version", callback=_version, is_eager=True, help="Show version"),
+    ] = False,
+) -> None:
+    global _USER_CONFIG
+    _USER_CONFIG = _load_user_config_safe()
+    _get_vendors()