From 680ba29ae641626275f342baf48a63c83310fe57 Mon Sep 17 00:00:00 2001 From: Oleksandr Bezdieniezhnykh Date: Tue, 19 May 2026 06:47:05 +0300 Subject: [PATCH] [AZ-621] Phase C: build_pre_constructed seeds c7_inference MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Third subtask of AZ-618. Extends airborne_bootstrap.build_pre_constructed additively with c7_inference (GPU InferenceRuntime). Wraps the existing inference_factory.build_inference_runtime so a BUILD_TENSORRT_RUNTIME / BUILD_PYTORCH_FP16_RUNTIME mismatch surfaces a clear operator-facing AirborneBootstrapError naming BOTH airborne C7 flags plus the consuming component slug, rather than bubbling up RuntimeNotAvailableError with no context. New public const C7_AIRBORNE_BUILD_FLAGS pairs each airborne runtime with its gating env flag (onnx_trt_ep deliberately omitted — research only). Tests stub at the factory boundary; real GPU/TensorRT load remains Tier-2 only (consolidated at AZ-624). AZ-619 and AZ-620 test files extended with a _stub_c7_inference_builder autouse fixture mirroring the AZ-620 pattern for _build_c6_*. 18/18 runtime_root unit tests pass. Co-authored-by: Cursor --- ...21_pre_constructed_phase_c_c7_inference.md | 0 .../batch_92_cycle1_report.md | 68 +++++++ .../reviews/batch_92_review.md | 36 ++++ _docs/_autodev_state.md | 6 +- .../runtime_root/airborne_bootstrap.py | 92 ++++++++- .../test_az619_pre_constructed_phase_a.py | 13 ++ .../test_az620_pre_constructed_phase_b.py | 14 ++ .../test_az621_pre_constructed_phase_c.py | 180 ++++++++++++++++++ 8 files changed, 398 insertions(+), 11 deletions(-) rename _docs/02_tasks/{todo => done}/AZ-621_pre_constructed_phase_c_c7_inference.md (100%) create mode 100644 _docs/03_implementation/batch_92_cycle1_report.md create mode 100644 _docs/03_implementation/reviews/batch_92_review.md create mode 100644 tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py diff --git a/_docs/02_tasks/todo/AZ-621_pre_constructed_phase_c_c7_inference.md b/_docs/02_tasks/done/AZ-621_pre_constructed_phase_c_c7_inference.md similarity index 100% rename from _docs/02_tasks/todo/AZ-621_pre_constructed_phase_c_c7_inference.md rename to _docs/02_tasks/done/AZ-621_pre_constructed_phase_c_c7_inference.md diff --git a/_docs/03_implementation/batch_92_cycle1_report.md b/_docs/03_implementation/batch_92_cycle1_report.md new file mode 100644 index 0000000..c0d1ce0 --- /dev/null +++ b/_docs/03_implementation/batch_92_cycle1_report.md @@ -0,0 +1,68 @@ +# Batch 92 Report — AZ-621 Phase C: build_pre_constructed seeds c7_inference (cycle 1) + +**Batch**: 92 +**Date**: 2026-05-19 +**Context**: Product implementation (greenfield Step 7 — Implement; AZ-618 umbrella, Phase C of 6) +**Tasks**: AZ-621 (3 cp) — 1 task +**Cycle**: 1 +**Verdict**: COMPLETE — PASS (self-reviewed inline; 18/18 runtime_root tests green) + +## Summary + +Third of six subtasks decomposing the AZ-618 umbrella. Phase C extends `airborne_bootstrap.build_pre_constructed(config)` additively with `c7_inference` (the GPU InferenceRuntime). Wraps the existing `inference_factory.build_inference_runtime` so that a `BUILD_TENSORRT_RUNTIME`/`BUILD_PYTORCH_FP16_RUNTIME` mismatch surfaces a clear operator-facing `AirborneBootstrapError` naming BOTH airborne C7 flags + the consuming component slug, rather than bubbling up the lower-level `RuntimeNotAvailableError` with no consuming-component context. + +### AZ-621 — build_pre_constructed Phase C (3 cp) + +* **`src/gps_denied_onboard/runtime_root/airborne_bootstrap.py`**: + * Imports `build_inference_runtime` from `runtime_root.inference_factory` (Layer-5 sibling). + * New public constant `C7_AIRBORNE_BUILD_FLAGS: tuple[tuple[str, str], ...] = (("tensorrt", "BUILD_TENSORRT_RUNTIME"), ("pytorch_fp16", "BUILD_PYTORCH_FP16_RUNTIME"))` — single source of truth for the airborne-buildable C7 runtimes + their gating env flags (deliberately omits `onnx_trt_ep`, which is research-only per `module-layout.md`). Exported in `__all__`. + * New module-private helper `_build_c7_inference(config)` — calls `build_inference_runtime`; on `RuntimeNotAvailableError`, re-raises as `AirborneBootstrapError` naming `c7_inference` (the missing key), BOTH `C7_AIRBORNE_BUILD_FLAGS` entries (so operator sees production-default + Tier-0 fallback), and the consuming component slug(s) via `_configured_consumers_of_pre_constructed_key`. Preserves the original error via `raise ... from exc`. + * `build_pre_constructed(config)` now returns five keys: `c13_fdr`, `clock`, `c6_descriptor_index`, `c6_tile_store`, `c7_inference`. Additivity preserved per AZ-621 Constraint "MUST be additive on top of AZ-619 + AZ-620"; docstring updated to mention AZ-621 Phase C and the new raise path. + * No new `BUILD_*` env flag introduced (constraint satisfied) — only a Python-level tuple listing already-existing flag names. + +* **`tests/unit/runtime_root/test_az619_pre_constructed_phase_a.py`**: + * New autouse fixture `_stub_c7_inference_builder` monkeypatches `_build_c7_inference` to an opaque sentinel — keeps AZ-619 tests focused on Phase A keys without entangling them with the new Phase C integration path (and avoids requiring `BUILD_TENSORRT_RUNTIME=ON` + real GPU for the AZ-619 cases). + +* **`tests/unit/runtime_root/test_az620_pre_constructed_phase_b.py`**: + * New autouse fixture `_stub_c7_inference_builder` (same pattern as the AZ-619 file) — keeps AZ-620 tests focused on Phase B C6 wiring and error-translation, independent of Phase C. + +* **`tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py`** (new): + * `test_ac_621_1_adds_c7_inference` — stubs `build_inference_runtime` to an identifiable mock; asserts the bootstrap dict contains `c7_inference` referencing the stub return, and AZ-619 + AZ-620 keys are still present. Covers AC-621.1. + * `test_ac_621_2_both_build_flags_off_with_configured_consumer_raises_named_error` — stubs `build_inference_runtime` to raise `RuntimeNotAvailableError` (mirroring real `BUILD_*=OFF` behaviour); builds a config with `c3_matcher.strategy="disk_lightglue"`; asserts `AirborneBootstrapError` is raised whose message contains `c7_inference`, BOTH `BUILD_TENSORRT_RUNTIME` and `BUILD_PYTORCH_FP16_RUNTIME` (sourced from the new constant), and `c3_matcher`. Verifies the original error is preserved as `__cause__`. Covers AC-621.2. + * `test_ac_621_2_no_configured_consumer_still_raises_with_full_set` — defence-in-depth (mirrors the AZ-620 same-name pattern): even with no consumer configured, the bootstrap still fails loudly and the message lists the FULL theoretical consumer set (`c2_vpr`, `c3_matcher`, `c3_5_adhop`). Strengthens AC-621.2's operator-facing contract. + +## File Ownership + +* OWNED (component `runtime_root`): + * `src/gps_denied_onboard/runtime_root/airborne_bootstrap.py` + * `tests/unit/runtime_root/test_az619_pre_constructed_phase_a.py` + * `tests/unit/runtime_root/test_az620_pre_constructed_phase_b.py` + * `tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py` +* READ-ONLY: imports from `runtime_root.inference_factory` (Layer-5 sibling within same package), `runtime_root.errors`, plus the AZ-619/620 modules already in scope (`storage_factory`, `clock`, `fdr_client`, `config`). +* No FORBIDDEN-zone writes. + +## Test Results + +* New unit tests: **3** under `tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py` covering AC-621.1 + AC-621.2 (twice, defence-in-depth). +* Updated unit tests: AZ-619 (5/5 passing) and AZ-620 (3/3 passing) — both files extended with one autouse stub fixture each; no behavioural changes to existing assertions. +* AZ-591 regression (`test_az591_airborne_bootstrap.py`): **7/7 passing** — `AIRBORNE_REQUIRED_PRE_CONSTRUCTED_KEYS` table consistency + airborne registration semantics + tier isolation all unchanged. +* Combined: `pytest tests/unit/runtime_root/ -q` → **18/18 passed in 0.68 s**. +* No new ruff errors on touched files. + +## Out of scope (deferred) + +* Remaining keys in `AIRBORNE_REQUIRED_PRE_CONSTRUCTED_KEYS` — AZ-622 (`c3_lightglue_runtime` + `c3_feature_extractor`), AZ-623 (`c282_ransac_filter` + c5 helpers), AZ-624 (`main()` integration + AC-1..AC-5). +* Real GPU model load / TensorRT engine deserialization — consolidated at AZ-624's Tier-2 Jetson AC-5 run per `_docs/02_document/tests/tier2-jetson-testing.md`. This subtask stubs at the factory boundary, exactly mirroring the AZ-620 pattern for C6 storage. +* Cumulative review for batches 85-92 (8 batches deferred — K=3 default missed). Recorded as outstanding work; the previous session intentionally chose AZ-621 as the next single-task batch and did not run the cumulative review at the start. Next session should run cumulative review (scope: union of files changed since `cumulative_review_batches_82-84_cycle1_report.md`) BEFORE starting batch 93 (AZ-622) or batch 94 (AZ-623) — both are still in the AZ-618 remediation cycle and the architecture surface around `airborne_bootstrap.py` deserves a cross-batch sweep before the umbrella's `main()` wiring (AZ-624) lands. + +## State + +* Spec moved: `_docs/02_tasks/todo/AZ-621_pre_constructed_phase_c_c7_inference.md` → `_docs/02_tasks/done/`. +* Tracker: AZ-621 transitioned **To Do → In Progress** at batch start; will transition **In Progress → In Testing** after this commit (per implement skill Step 12). +* `_docs/_autodev_state.md` advanced to `last_completed_batch: 92`. + +## Next Batch + +* **Batch 93**: AZ-622 (3 cp) — Phase D of AZ-618 umbrella. Adds `c3_lightglue_runtime` + `c3_feature_extractor` to `build_pre_constructed`. Depends on AZ-619 + AZ-620 + AZ-621 (all will be in `done/` after this commit) + AZ-278 (already in `done/`). +* **Alternative Batch 93**: AZ-623 (3 cp) — Phase E. Independent of AZ-621; could batch alongside AZ-622 (combined 6 cp, well under the 20-cp cap) if next session prefers throughput over single-phase review focus. +* **Recommended sequencing for next session**: (1) run the deferred cumulative review for batches 85-92; (2) then batch 93 — single task (AZ-622) to maintain the AZ-618 single-phase-per-batch pattern, OR a two-task batch (AZ-622 + AZ-623) if cumulative review surfaces no architecture drift around the bootstrap surface. diff --git a/_docs/03_implementation/reviews/batch_92_review.md b/_docs/03_implementation/reviews/batch_92_review.md new file mode 100644 index 0000000..02f5e1b --- /dev/null +++ b/_docs/03_implementation/reviews/batch_92_review.md @@ -0,0 +1,36 @@ +# Code Review Report — Batch 92 (AZ-621 Phase C: c7_inference) + +**Batch**: 92 +**Tasks**: AZ-621 (3 cp) — AZ-618 Phase C +**Date**: 2026-05-19 +**Verdict**: PASS + +## Findings + +None. + +## Phase Notes + +- **Phase 1 (Context)**: Loaded `_docs/02_tasks/todo/AZ-621_pre_constructed_phase_c_c7_inference.md` and the AZ-618 umbrella spec. Mapped batch changes to AZ-621 exclusively. +- **Phase 2 (Spec Compliance)**: + - AC-621.1: `_build_c7_inference` is called from `build_pre_constructed`; `test_ac_621_1_adds_c7_inference` asserts the key and identity to the factory return. + - AC-621.2: `_build_c7_inference` wraps `RuntimeNotAvailableError` into `AirborneBootstrapError` whose message includes both `BUILD_TENSORRT_RUNTIME` and `BUILD_PYTORCH_FP16_RUNTIME` (sourced from the new `C7_AIRBORNE_BUILD_FLAGS` const) plus the configured consumer slug. Defence-in-depth test covers the no-consumer-configured path. + - AC-621.3: `tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py` exists and contains the AC-621.1 / AC-621.2 cases. + - Constraints: no new `BUILD_*` env flag introduced (only a Python-level `tuple` listing already-existing flag names). Implementation is strictly additive — AZ-619 and AZ-620 keys still populated; AZ-619/620 test suites green after stubbing the new `_build_c7_inference` symbol via the same autouse-fixture pattern AZ-620 introduced for `_build_c6_*`. +- **Phase 3 (Code Quality)**: `_build_c7_inference` is ~25 lines, single responsibility (wrap factory + translate error), preserves cause chain via `raise ... from exc`, mirrors the established `_build_c6_descriptor_index` pattern verbatim. Tests use AAA, monkeypatch at the bootstrap module boundary (no real GPU/TensorRT load), assert message content per AC-621.2's explicit naming requirement. +- **Phase 4 (Security)**: no external inputs, no subprocess/eval/exec, no secrets. The new error message includes operator-facing flag names and component slugs only. +- **Phase 5 (Performance)**: composition-time only; one factory call per `build_pre_constructed` invocation. No hot-path change. +- **Phase 6 (Cross-Task Consistency)**: single-task batch — N/A. +- **Phase 7 (Architecture Compliance)**: + - `runtime_root.airborne_bootstrap` (Layer 5) imports `runtime_root.inference_factory` (Layer 5 sibling). Per the Allowed Dependencies table, Layer 5 may import from Layers 1–4 plus its own sibling composition modules. No layer violation. + - The imported symbol `build_inference_runtime` is part of `inference_factory.__all__` — Public API respected. + - No new module-level cycle introduced (graph remains `airborne_bootstrap → inference_factory → errors`, no back-edge). + - No duplicate symbol introduced across components. + - No cross-cutting concern locally re-implemented — error translation is bootstrap-specific (mirrors c6 path) and not a candidate for `shared/`. + +## Counts + +- Critical: 0 +- High: 0 +- Medium: 0 +- Low: 0 diff --git a/_docs/_autodev_state.md b/_docs/_autodev_state.md index 9d0a8e4..b3cd5ce 100644 --- a/_docs/_autodev_state.md +++ b/_docs/_autodev_state.md @@ -6,10 +6,10 @@ step: 7 name: Implement status: in_progress sub_step: - phase: 14 + phase: 16 name: batch-loop - detail: "next batch = AZ-621 (Phase C: c7_inference, 3pt); AZ-623 (Phase E, 3pt) also unblocked. AZ-622/AZ-624 still chained. Fresh session recommended — AZ-621 touches GPU runtimes." + detail: "batch 92 done (AZ-621 Phase C). Next: cumulative review for batches 85-92 (8 batches overdue, K=3 default missed), THEN batch 93 = AZ-622 (Phase D, 3pt) or AZ-622+AZ-623 (6pt). Fresh session recommended." retry_count: 0 cycle: 1 tracker: jira -last_completed_batch: 91 +last_completed_batch: 92 diff --git a/src/gps_denied_onboard/runtime_root/airborne_bootstrap.py b/src/gps_denied_onboard/runtime_root/airborne_bootstrap.py index 4a7f636..af6c661 100644 --- a/src/gps_denied_onboard/runtime_root/airborne_bootstrap.py +++ b/src/gps_denied_onboard/runtime_root/airborne_bootstrap.py @@ -57,6 +57,7 @@ from gps_denied_onboard.clock.wall_clock import WallClock from gps_denied_onboard.fdr_client.client import make_fdr_client from gps_denied_onboard.runtime_root import register_strategy from gps_denied_onboard.runtime_root.errors import RuntimeNotAvailableError +from gps_denied_onboard.runtime_root.inference_factory import build_inference_runtime from gps_denied_onboard.runtime_root.matcher_factory import build_matcher_strategy from gps_denied_onboard.runtime_root.pose_factory import build_pose_estimator from gps_denied_onboard.runtime_root.refiner_factory import build_refiner_strategy @@ -75,6 +76,7 @@ if TYPE_CHECKING: __all__ = [ "AIRBORNE_MAIN_PRODUCER_ID", "AIRBORNE_REQUIRED_PRE_CONSTRUCTED_KEYS", + "C7_AIRBORNE_BUILD_FLAGS", "FAISS_BUILD_FLAG", "AirborneBootstrapError", "build_pre_constructed", @@ -92,6 +94,26 @@ flag is OFF but a consuming component still requires the index. """ +C7_AIRBORNE_BUILD_FLAGS: Final[tuple[tuple[str, str], ...]] = ( + ("tensorrt", "BUILD_TENSORRT_RUNTIME"), + ("pytorch_fp16", "BUILD_PYTORCH_FP16_RUNTIME"), +) +"""Airborne-buildable C7 inference runtimes paired with their gating env flags. + +Production-default for the airborne binary is ``tensorrt`` (TensorRT FP16); +``pytorch_fp16`` is the Tier-0 / workstation fallback (per +``module-layout.md`` build-time exclusion table and the AZ-621 task spec). +``onnx_trt_ep`` is deliberately omitted — it is research-only and not built +into the airborne binary, even though +:mod:`gps_denied_onboard.runtime_root.inference_factory` supports the label. + +Surfaced here so :func:`_build_c7_inference` can name BOTH airborne flags +in an :class:`AirborneBootstrapError` (AC-621.2) — the operator sees which +flag must be flipped ON to enable the configured runtime AND which fallback +flag would unblock the bootstrap with a different runtime selection. +""" + + AIRBORNE_MAIN_PRODUCER_ID: Final[str] = "airborne_main" """Producer ID for the per-binary shared FdrClient placed under ``pre_constructed['c13_fdr']``. @@ -474,22 +496,71 @@ def _build_c6_tile_store(config: Config) -> Any: return build_tile_store(config) +def _build_c7_inference(config: Config) -> Any: + """Build ``pre_constructed['c7_inference']`` via the C7 factory. + + Wraps :func:`inference_factory.build_inference_runtime` so a + :class:`RuntimeNotAvailableError` (raised when the configured + runtime's ``BUILD_*`` flag is OFF) surfaces as an + :class:`AirborneBootstrapError` naming: + + * the missing key (``c7_inference``); + * BOTH airborne-buildable runtimes and their gating flags + (:data:`C7_AIRBORNE_BUILD_FLAGS`), so the operator sees the + production-default (``tensorrt`` / + ``BUILD_TENSORRT_RUNTIME``) AND the Tier-0 fallback + (``pytorch_fp16`` / ``BUILD_PYTORCH_FP16_RUNTIME``); + * the consuming component slug(s) — narrowed to configured + consumers when available, else the full theoretical set. + + The original factory error is preserved via ``raise ... from`` so + operators still see the upstream cause (e.g., "runtime 'tensorrt' + requires BUILD_TENSORRT_RUNTIME=ON in this binary; the flag is + OFF."). + + AC-621.2: this is the path the test exercises when both airborne C7 + flags are OFF and a configured consumer (c2_vpr / c3_matcher / + c3_5_adhop) still needs ``c7_inference``. + """ + try: + return build_inference_runtime(config) + except RuntimeNotAvailableError as exc: + consumers = _configured_consumers_of_pre_constructed_key( + config, "c7_inference" + ) + flag_options = ", ".join( + f"{flag}=ON for runtime {runtime!r}" + for runtime, flag in C7_AIRBORNE_BUILD_FLAGS + ) + raise AirborneBootstrapError( + f"airborne_bootstrap: cannot construct " + f"pre_constructed['c7_inference'] because no airborne C7 " + f"inference runtime is buildable. Consuming components: " + f"{list(consumers)}. Set one of: {flag_options}, and ensure " + f"config.components['c7_inference'].runtime matches the " + f"enabled flag. Upstream error: {exc}" + ) from exc + + def build_pre_constructed(config: Config) -> dict[str, Any]: """Build the airborne ``pre_constructed`` dict for :func:`compose_root`. AZ-619 (Phase A) seeded ``c13_fdr`` and ``clock``. AZ-620 (Phase B) - adds the two C6 storage entries (``c6_descriptor_index`` + - ``c6_tile_store``). Phases C..F (AZ-621..AZ-624) will extend this - function to populate the remaining keys in + added the two C6 storage entries (``c6_descriptor_index`` + + ``c6_tile_store``). AZ-621 (Phase C) adds ``c7_inference`` + (PyTorch FP16 vs. TensorRT, gated by + :data:`C7_AIRBORNE_BUILD_FLAGS`). Phases D..F (AZ-622..AZ-624) will + extend this function to populate the remaining keys in :data:`AIRBORNE_REQUIRED_PRE_CONSTRUCTED_KEYS`. Returns a fresh dict on each call. The ``c13_fdr`` instance is cached inside :func:`make_fdr_client` (per-producer cache) so two calls within the same process return dicts where ``pre_constructed['c13_fdr']`` is the SAME object — AC-619.2. ``clock`` is a fresh :class:`WallClock` - each call (stateless; the cache would be a no-op). The C6 entries are - constructed via the existing :mod:`storage_factory` builders without - additional caching at this layer. + each call (stateless; the cache would be a no-op). The C6 + C7 + entries are constructed via the existing :mod:`storage_factory` and + :mod:`inference_factory` builders without additional caching at this + layer. Replay-mode override: :func:`compose_root` merges ``replay_components`` over ``pre_constructed`` so the :class:`WallClock` here is replaced by @@ -500,14 +571,19 @@ def build_pre_constructed(config: Config) -> dict[str, Any]: AirborneBootstrapError: if ``BUILD_FAISS_INDEX`` is OFF and any configured consumer (per :data:`AIRBORNE_REQUIRED_PRE_CONSTRUCTED_KEYS`) requires - ``c6_descriptor_index`` — surfaces with the consuming - component slug(s) and the gating flag. + ``c6_descriptor_index``; OR if no airborne C7 inference + runtime is buildable (both ``BUILD_TENSORRT_RUNTIME`` and + ``BUILD_PYTORCH_FP16_RUNTIME`` OFF, or the configured + runtime's matching flag is OFF) and any configured consumer + requires ``c7_inference``. The message names the consuming + component slug(s) and the relevant gating flag(s). """ return { "c13_fdr": make_fdr_client(AIRBORNE_MAIN_PRODUCER_ID, config), "clock": WallClock(), "c6_descriptor_index": _build_c6_descriptor_index(config), "c6_tile_store": _build_c6_tile_store(config), + "c7_inference": _build_c7_inference(config), } diff --git a/tests/unit/runtime_root/test_az619_pre_constructed_phase_a.py b/tests/unit/runtime_root/test_az619_pre_constructed_phase_a.py index 8725d0f..75d2503 100644 --- a/tests/unit/runtime_root/test_az619_pre_constructed_phase_a.py +++ b/tests/unit/runtime_root/test_az619_pre_constructed_phase_a.py @@ -67,6 +67,19 @@ def _stub_c6_builders(monkeypatch: pytest.MonkeyPatch) -> None: ) +@pytest.fixture(autouse=True) +def _stub_c7_inference_builder(monkeypatch: pytest.MonkeyPatch) -> None: + # Arrange: stub the AZ-621 Phase C C7 inference builder so the AZ-619 + # tests stay focused on Phase A. Without this the bare Config() below + # would hit KeyError inside inference_factory's + # config.components["c7_inference"] lookup, AND the airborne BUILD_* + # flags are typically unset in the test env. The sentinel is opaque + # on purpose — AZ-619 assertions never inspect it. + monkeypatch.setattr( + airborne_bootstrap, "_build_c7_inference", lambda _config: object() + ) + + def test_ac_619_1_default_config_seeds_c13_fdr_and_clock() -> None: # Arrange config = Config() diff --git a/tests/unit/runtime_root/test_az620_pre_constructed_phase_b.py b/tests/unit/runtime_root/test_az620_pre_constructed_phase_b.py index ec36361..8aa9d7c 100644 --- a/tests/unit/runtime_root/test_az620_pre_constructed_phase_b.py +++ b/tests/unit/runtime_root/test_az620_pre_constructed_phase_b.py @@ -60,6 +60,20 @@ def _isolated_fdr_cache() -> Iterator[None]: fdr_client_module._reset_for_tests() +@pytest.fixture(autouse=True) +def _stub_c7_inference_builder(monkeypatch: pytest.MonkeyPatch) -> None: + # Arrange: stub the AZ-621 Phase C C7 inference builder so AZ-620 + # tests stay focused on the Phase B contract. Without this the + # configs used below would hit KeyError inside inference_factory's + # config.components["c7_inference"] lookup. The sentinel is opaque + # on purpose — AZ-620 assertions never inspect it. + monkeypatch.setattr( + airborne_bootstrap, + "_build_c7_inference", + lambda _config: MagicMock(name="InferenceRuntime"), + ) + + def test_ac_620_1_adds_c6_descriptor_index_and_c6_tile_store( monkeypatch: pytest.MonkeyPatch, ) -> None: diff --git a/tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py b/tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py new file mode 100644 index 0000000..a88a44a --- /dev/null +++ b/tests/unit/runtime_root/test_az621_pre_constructed_phase_c.py @@ -0,0 +1,180 @@ +"""AZ-621 — Phase C of AZ-618: ``build_pre_constructed`` seeds c7_inference. + +Verifies the contract at +``_docs/02_tasks/todo/AZ-621_pre_constructed_phase_c_c7_inference.md``: + +* AC-621.1: with a default airborne ``Config`` (and one of the airborne + C7 ``BUILD_*`` flags ON in spirit — here stubbed at the factory + boundary), ``build_pre_constructed(config)`` additionally contains + ``c7_inference`` (InferenceRuntime instance) on top of AZ-619 + AZ-620. +* AC-621.2: when BOTH ``BUILD_TENSORRT_RUNTIME=OFF`` AND + ``BUILD_PYTORCH_FP16_RUNTIME=OFF`` AND a config selects a C2 / C3 + strategy that needs c7 (here: ``c3_matcher.strategy="disk_lightglue"``), + ``build_pre_constructed`` raises ``AirborneBootstrapError`` whose + message names both airborne flags AND the consuming component slug. + +AC-621.3 (this file exists with the above tests) is satisfied by the +existence of this module. + +The tests stub the heavy ``build_inference_runtime`` factory at the +airborne_bootstrap import boundary — exactly mirroring the AZ-620 +pattern for the C6 factories. The factory itself has its own +component-level unit tests under ``tests/unit/c7_inference/`` for the +real engine-load paths; real GPU model load is Tier-2 only (consolidated +under AZ-624 per the umbrella's Tier-2 testing strategy). +""" + +from __future__ import annotations + +from collections.abc import Iterator +from dataclasses import dataclass +from unittest.mock import MagicMock + +import pytest + +from gps_denied_onboard.config import Config +from gps_denied_onboard.fdr_client import client as fdr_client_module +from gps_denied_onboard.runtime_root import airborne_bootstrap +from gps_denied_onboard.runtime_root.airborne_bootstrap import ( + C7_AIRBORNE_BUILD_FLAGS, + AirborneBootstrapError, + build_pre_constructed, +) +from gps_denied_onboard.runtime_root.errors import RuntimeNotAvailableError + + +@dataclass(frozen=True) +class _C3MatcherBlock: + """Minimal c3_matcher config block — only the field the test needs.""" + + strategy: str = "disk_lightglue" + + +@pytest.fixture(autouse=True) +def _isolated_fdr_cache() -> Iterator[None]: + # Arrange: every test starts with an empty FdrClient cache so the + # bootstrap's make_fdr_client call doesn't accidentally pick up a + # stale instance from a prior test in the same process. + fdr_client_module._reset_for_tests() + yield + fdr_client_module._reset_for_tests() + + +@pytest.fixture(autouse=True) +def _stub_c6_builders(monkeypatch: pytest.MonkeyPatch) -> None: + # Arrange: stub the AZ-620 Phase B C6 builders so AZ-621 stays + # focused on the Phase C contract. The configs used below either + # omit c6 entirely or use bare Config()-derived blocks. + monkeypatch.setattr( + airborne_bootstrap, + "_build_c6_descriptor_index", + lambda _config: MagicMock(name="DescriptorIndex"), + ) + monkeypatch.setattr( + airborne_bootstrap, + "_build_c6_tile_store", + lambda _config: MagicMock(name="TileStore"), + ) + + +def test_ac_621_1_adds_c7_inference(monkeypatch: pytest.MonkeyPatch) -> None: + # Arrange: stub build_inference_runtime to a sentinel so we can + # assert wiring without standing up real GPU/TensorRT/PyTorch. + inference_runtime_sentinel = MagicMock(name="InferenceRuntime") + monkeypatch.setattr( + airborne_bootstrap, + "build_inference_runtime", + lambda _config: inference_runtime_sentinel, + ) + config = Config() + + # Act + pre_constructed = build_pre_constructed(config) + + # Assert: AZ-621 key is present and references the exact factory + # return. AZ-619 + AZ-620 keys are still present (additivity contract). + assert "c7_inference" in pre_constructed + assert pre_constructed["c7_inference"] is inference_runtime_sentinel + assert {"c13_fdr", "clock", "c6_descriptor_index", "c6_tile_store"}.issubset( + pre_constructed.keys() + ) + + +def test_ac_621_2_both_build_flags_off_with_configured_consumer_raises_named_error( + monkeypatch: pytest.MonkeyPatch, +) -> None: + # Arrange: simulate both BUILD_TENSORRT_RUNTIME=OFF and + # BUILD_PYTORCH_FP16_RUNTIME=OFF by making build_inference_runtime + # raise RuntimeNotAvailableError the same way inference_factory does + # in production when neither flag is ON. + monkeypatch.setattr( + airborne_bootstrap, + "build_inference_runtime", + _raise_no_c7_runtime_available, + ) + config = Config.with_blocks( + c3_matcher=_C3MatcherBlock(strategy="disk_lightglue") + ) + + # Act + Assert + with pytest.raises(AirborneBootstrapError) as excinfo: + build_pre_constructed(config) + + message = str(excinfo.value) + assert "c7_inference" in message + # Both airborne C7 BUILD_* flags must be named in the message so the + # operator sees the production-default AND the Tier-0 fallback flag. + for _runtime, flag in C7_AIRBORNE_BUILD_FLAGS: + assert flag in message, f"{flag} missing from error: {message!r}" + # Consuming component slug is named. + assert "c3_matcher" in message + # The original factory error is preserved as the cause chain so the + # operator can still see the upstream reason. + assert isinstance(excinfo.value.__cause__, RuntimeNotAvailableError) + + +def test_ac_621_2_no_configured_consumer_still_raises_with_full_set( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Defence-in-depth: even with no consumer configured, AZ-621 still + fails loudly when no airborne C7 runtime is buildable. + + Mirrors the AZ-620 defence-in-depth test. ``build_pre_constructed`` + is the airborne contract's single seam — silently returning a dict + without ``c7_inference`` would let a later AZ-622..AZ-624 phase or a + downstream caller misread the state. The error message lists the + FULL theoretical consumer set so the operator still gets actionable + information. + """ + # Arrange + monkeypatch.setattr( + airborne_bootstrap, + "build_inference_runtime", + _raise_no_c7_runtime_available, + ) + config = Config() # empty components + + # Act + Assert + with pytest.raises(AirborneBootstrapError) as excinfo: + build_pre_constructed(config) + + message = str(excinfo.value) + assert "c7_inference" in message + for _runtime, flag in C7_AIRBORNE_BUILD_FLAGS: + assert flag in message + # When no consumer is configured, ALL theoretical consumers of + # c7_inference are surfaced — per AIRBORNE_REQUIRED_PRE_CONSTRUCTED_KEYS + # these are c2_vpr, c3_matcher, c3_5_adhop. + for slug in ("c2_vpr", "c3_matcher", "c3_5_adhop"): + assert slug in message, f"{slug} missing from error: {message!r}" + + +def _raise_no_c7_runtime_available(_config: Config) -> None: + # Mirrors the message that inference_factory.build_inference_runtime + # raises when the configured runtime's BUILD_* flag is OFF — except + # phrased to cover the "both flags off, nothing left" scenario the + # bootstrap is supposed to wrap into an AirborneBootstrapError. + raise RuntimeNotAvailableError( + "InferenceRuntime runtime 'tensorrt' requires " + "BUILD_TENSORRT_RUNTIME=ON in this binary; the flag is OFF." + )