perf: optimize artifact state collection and remove redundant APK hashing

Refactor artifact state collection into a single filesystem traversal to reduce repeated IO and metadata work during diff report generation.

Key changes:

- Replace three independent scans (files/build.props/apks) with one _collect_state_entries pass.

- Reuse per-file size/sha256 for APK metadata to avoid hashing APK files twice.

- Cache aapt tool resolution with lru_cache so tool probing occurs once per process.

- Keep diff report schema unchanged while improving runtime efficiency for large target trees.

Tests:

- Add regression test to ensure each file is hashed exactly once during collect_artifact_state.

- Existing diff-report behavior test remains green.

Verification:

- .venv/bin/python -m ruff check src/app/diff_report.py tests/test_diff_report.py

- .venv/bin/python -m mypy --config-file mypy-curated.ini

- .venv/bin/python -m pytest -q tests/test_diff_report.py

- .venv/bin/python -m pytest -q

Co-authored-by: OpenAI Codex <noreply@openai.com>

Author: toraidl

src/app/diff_report.py

@@ -6,7 +6,9 @@
 import json
 import logging
 import re
+import shutil
 import subprocess
+from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
@@ -43,19 +45,6 @@ def _sha256(path: Path) -> str:
     return digest.hexdigest()
 
 
-def _collect_files(root: Path) -> dict[str, dict[str, Any]]:
-    files: dict[str, dict[str, Any]] = {}
-    for path in root.rglob("*"):
-        if not path.is_file():
-            continue
-        rel = str(path.relative_to(root))
-        files[rel] = {
-            "size": path.stat().st_size,
-            "sha256": _sha256(path),
-        }
-    return files
-
-
 def _parse_prop_file(path: Path) -> dict[str, str]:
     props: dict[str, str] = {}
     with open(path, "r", encoding="utf-8", errors="ignore") as handle:
@@ -68,60 +57,73 @@ def _parse_prop_file(path: Path) -> dict[str, str]:
     return props
 
 
-def _collect_build_props(root: Path) -> dict[str, dict[str, str]]:
-    result: dict[str, dict[str, str]] = {}
-    for prop_file in root.rglob("build.prop"):
-        if not prop_file.is_file():
-            continue
-        rel = str(prop_file.relative_to(root))
-        result[rel] = _parse_prop_file(prop_file)
-    return result
+@lru_cache(maxsize=1)
+def _resolve_aapt_tool() -> str | None:
+    for tool in ("aapt2", "aapt"):
+        if shutil.which(tool):
+            return tool
+    return None
 
 
-def _extract_apk_metadata(apk_path: Path) -> dict[str, Any]:
+def _extract_apk_metadata(apk_path: Path, file_meta: dict[str, Any] | None = None) -> dict[str, Any]:
+    if file_meta is None:
+        file_meta = {"size": apk_path.stat().st_size, "sha256": _sha256(apk_path)}
+
     metadata: dict[str, Any] = {
-        "size": apk_path.stat().st_size,
-        "sha256": _sha256(apk_path),
+        "size": file_meta["size"],
+        "sha256": file_meta["sha256"],
         "package": None,
         "version_name": None,
         "version_code": None,
     }
 
-    for tool in ("aapt2", "aapt"):
-        try:
-            proc = subprocess.run(
-                [tool, "dump", "badging", str(apk_path)],
-                check=False,
-                capture_output=True,
-                text=True,
-            )
-        except FileNotFoundError:
-            continue
+    tool = _resolve_aapt_tool()
+    if tool is None:
+        return metadata
 
-        if proc.returncode != 0 or not proc.stdout:
-            continue
-
-        match = re.search(
-            r"package: name='([^']+)'.*versionCode='([^']+)'.*versionName='([^']*)'",
-            proc.stdout,
-        )
-        if match:
-            metadata["package"] = match.group(1)
-            metadata["version_code"] = match.group(2)
-            metadata["version_name"] = match.group(3)
-        break
+    proc = subprocess.run(
+        [tool, "dump", "badging", str(apk_path)],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0 or not proc.stdout:
+        return metadata
 
+    match = re.search(
+        r"package: name='([^']+)'.*versionCode='([^']+)'.*versionName='([^']*)'",
+        proc.stdout,
+    )
+    if match:
+        metadata["package"] = match.group(1)
+        metadata["version_code"] = match.group(2)
+        metadata["version_name"] = match.group(3)
     return metadata
 
 
-def _collect_apks(root: Path) -> dict[str, dict[str, Any]]:
-    result: dict[str, dict[str, Any]] = {}
-    for apk in root.rglob("*.apk"):
-        if not apk.is_file():
+def _collect_state_entries(
+    root: Path,
+) -> tuple[dict[str, dict[str, Any]], dict[str, dict[str, str]], dict[str, dict[str, Any]]]:
+    files: dict[str, dict[str, Any]] = {}
+    build_props: dict[str, dict[str, str]] = {}
+    apks: dict[str, dict[str, Any]] = {}
+
+    for path in root.rglob("*"):
+        if not path.is_file():
             continue
-        rel = str(apk.relative_to(root))
-        result[rel] = _extract_apk_metadata(apk)
-    return result
+        rel = str(path.relative_to(root))
+        file_meta = {
+            "size": path.stat().st_size,
+            "sha256": _sha256(path),
+        }
+        files[rel] = file_meta
+
+        if path.name == "build.prop":
+            build_props[rel] = _parse_prop_file(path)
+        if path.suffix == ".apk":
+            apks[rel] = _extract_apk_metadata(path, file_meta=file_meta)
+
+    return files, build_props, apks
 
 
 def collect_artifact_state(root: str | Path, logger: logging.Logger) -> dict[str, Any]:
@@ -132,11 +134,12 @@ def collect_artifact_state(root: str | Path, logger: logging.Logger) -> dict[str
         return {"root": str(target), "files": {}, "build_props": {}, "apks": {}}
 
     logger.info("Collecting artifact state from: %s", target)
+    files, build_props, apks = _collect_state_entries(target)
     return {
         "root": str(target),
-        "files": _collect_files(target),
-        "build_props": _collect_build_props(target),
-        "apks": _collect_apks(target),
+        "files": files,
+        "build_props": build_props,
+        "apks": apks,
     }
 
 

tests/test_diff_report.py

@@ -1,6 +1,7 @@
 import logging
 from pathlib import Path
 
+import src.app.diff_report as diff_report
 from src.app.diff_report import collect_artifact_state, generate_diff_report
 
 
@@ -35,3 +36,24 @@ def test_generate_diff_report_tracks_file_and_prop_changes(tmp_path: Path):
         flag["code"] == "IDENTITY_PROP_CHANGED"
         for flag in report["highlights"]["risk_flags"]
     )
+
+
+def test_collect_artifact_state_hashes_each_file_once(tmp_path: Path, monkeypatch):
+    target = tmp_path / "target"
+    (target / "system").mkdir(parents=True)
+    (target / "system" / "build.prop").write_text("ro.product.name=device_a\n", encoding="utf-8")
+    (target / "system" / "app.apk").write_bytes(b"apk-bytes")
+    (target / "system" / "plain.txt").write_text("hello", encoding="utf-8")
+
+    hash_calls: list[str] = []
+    original_sha = diff_report._sha256
+
+    def counting_sha256(path: Path) -> str:
+        hash_calls.append(str(path.relative_to(target)))
+        return original_sha(path)
+
+    monkeypatch.setattr(diff_report, "_sha256", counting_sha256)
+    state = collect_artifact_state(target, logger=logging.getLogger("test"))
+
+    assert sorted(hash_calls) == ["system/app.apk", "system/build.prop", "system/plain.txt"]
+    assert "system/app.apk" in state["apks"]