Merge pull request #12 from PyAutoLabs/feature/build-pulse-agent-separation

Jammy2211 · web-flow · commit bd6c10dd3fe5 · 2026-06-24T12:23:48.000+01:00
Pulse owns workspace-integration validation (Stage 4 Phase B, Pulse side)
diff --git a/.github/workflows/workspace-validation.yml b/.github/workflows/workspace-validation.yml
@@ -0,0 +1,175 @@
+name: Workspace Validation
+
+# Pulse-owned workspace-integration validation (Stage 4 Phase B).
+#
+# This is the "heavy validation CI" that used to live in PyAutoBuild's
+# release.yml (find_scripts / run_scripts / analyze_results). Pulse owns it now:
+# Build is a pure executor. It runs every workspace's scripts against the CURRENT
+# source `main` of the 5 libraries (source-shadowed via PYTHONPATH), aggregates
+# into the same report.json contract, and uploads it as the
+# `workspace-validation-report` artifact. Pulse's test_run check reads that run's
+# conclusion + timestamp into the authoritative `readiness` verdict (with a
+# staleness window).
+#
+# Run mechanics (script_matrix.py / run_python.py / aggregate_results.py) are
+# Build's executor primitives — checked out from PyAutoBuild, not duplicated.
+#
+# Triggers: weekly schedule (the continuous readiness signal), manual dispatch,
+# and workflow_call (so a release path can invoke it on demand). Heavy, so never
+# in the <30s pulse tick.
+
+on:
+  schedule:
+    - cron: "0 3 * * 1"   # Mondays 03:00 UTC
+  workflow_dispatch:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  # Workspace pins lag the libraries' source __version__ between releases;
+  # without this every script fails fast with WorkspaceVersionMismatchError.
+  # Same bypass run_scripts uses in release.yml.
+  PYAUTO_SKIP_WORKSPACE_VERSION_CHECK: "1"
+
+jobs:
+  find_scripts:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.script_matrix.outputs.matrix }}
+    steps:
+      - name: Checkout PyAutoBuild (run primitives)
+        uses: actions/checkout@v4
+        with:
+          repository: PyAutoLabs/PyAutoBuild
+          path: PyAutoBuild
+      - name: Clone workspaces (paths match script_matrix project names)
+        run: |
+          set -e
+          declare -A WS=(
+            [autofit]=autofit_workspace [autogalaxy]=autogalaxy_workspace [autolens]=autolens_workspace
+            [autofit_test]=autofit_workspace_test [autogalaxy_test]=autogalaxy_workspace_test
+            [autolens_test]=autolens_workspace_test
+            [howtogalaxy]=HowToGalaxy [howtolens]=HowToLens [howtofit]=HowToFit
+          )
+          for proj in "${!WS[@]}"; do
+            git clone --depth 1 "https://github.com/PyAutoLabs/${WS[$proj]}" "$proj"
+          done
+      - name: Make script matrix
+        id: script_matrix
+        run: |
+          matrix="$(python3 PyAutoBuild/autobuild/script_matrix.py \
+            autofit autogalaxy autolens autofit_test autogalaxy_test autolens_test \
+            howtogalaxy howtolens howtofit)"
+          echo "matrix=$matrix" >> "$GITHUB_OUTPUT"
+
+  run_scripts:
+    runs-on: ubuntu-latest
+    needs: find_scripts
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12"]
+        project: ${{ fromJSON(needs.find_scripts.outputs.matrix) }}
+    steps:
+      - name: Checkout PyAutoBuild (run primitives)
+        uses: actions/checkout@v4
+        with:
+          repository: PyAutoLabs/PyAutoBuild
+          path: PyAutoBuild
+      - name: Resolve workspace repo for ${{ matrix.project.name }}
+        id: ws
+        run: |
+          case "${{ matrix.project.name }}" in
+            autofit)         echo "repo=autofit_workspace" >> "$GITHUB_OUTPUT" ;;
+            autogalaxy)      echo "repo=autogalaxy_workspace" >> "$GITHUB_OUTPUT" ;;
+            autolens)        echo "repo=autolens_workspace" >> "$GITHUB_OUTPUT" ;;
+            autofit_test)    echo "repo=autofit_workspace_test" >> "$GITHUB_OUTPUT" ;;
+            autogalaxy_test) echo "repo=autogalaxy_workspace_test" >> "$GITHUB_OUTPUT" ;;
+            autolens_test)   echo "repo=autolens_workspace_test" >> "$GITHUB_OUTPUT" ;;
+            howtogalaxy)     echo "repo=HowToGalaxy" >> "$GITHUB_OUTPUT" ;;
+            howtolens)       echo "repo=HowToLens" >> "$GITHUB_OUTPUT" ;;
+            howtofit)        echo "repo=HowToFit" >> "$GITHUB_OUTPUT" ;;
+            *)               echo "repo=autolens_workspace_test" >> "$GITHUB_OUTPUT" ;;
+          esac
+      - name: Checkout workspace
+        uses: actions/checkout@v4
+        with:
+          repository: PyAutoLabs/${{ steps.ws.outputs.repo }}
+          ref: main
+          path: workspace
+      - name: Checkout libraries (current main; source-shadowed via PYTHONPATH)
+        run: |
+          set -e
+          for lib in PyAutoConf PyAutoArray PyAutoFit PyAutoGalaxy PyAutoLens; do
+            git clone --depth 1 "https://github.com/PyAutoLabs/$lib" "libs/$lib"
+          done
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      - name: Install third-party deps (libs run from source)
+        run: |
+          # Pull the full transitive dependency set (matplotlib/numba/jax/…) by
+          # installing the published autolens[optional]; the source checkouts
+          # below shadow the PyAuto packages via PYTHONPATH.
+          pip install "autolens[optional]"
+          pip install "jax>=0.7,<0.11" "jaxlib>=0.7,<0.11"
+      - name: Run Python scripts
+        run: |
+          LIBS="$(pwd)/libs"
+          export PYTHONPATH="$LIBS/PyAutoConf:$LIBS/PyAutoArray:$LIBS/PyAutoFit:$LIBS/PyAutoGalaxy:$LIBS/PyAutoLens:$(pwd)/PyAutoBuild:$PYTHONPATH"
+          pushd workspace
+          python3 "$(pwd)/../PyAutoBuild/autobuild/run_python.py" \
+            "${{ matrix.project.name }}" "scripts/${{ matrix.project.directory }}" \
+            --report-dir test-results
+      - name: Upload script results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: results-scripts-${{ matrix.project.name }}-${{ matrix.project.directory }}
+          path: workspace/test-results/
+          retention-days: 30
+
+  analyze:
+    runs-on: ubuntu-latest
+    needs: run_scripts
+    if: always()
+    steps:
+      - name: Checkout PyAutoBuild (aggregate_results)
+        uses: actions/checkout@v4
+        with:
+          repository: PyAutoLabs/PyAutoBuild
+          path: PyAutoBuild
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Download all result artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: all-results
+          pattern: results-*
+          merge-multiple: true
+      - name: Aggregate into report.json
+        run: |
+          export PYTHONPATH="$PYTHONPATH:$(pwd)/PyAutoBuild"
+          python3 PyAutoBuild/autobuild/aggregate_results.py all-results/ \
+            --output report.json --markdown report.md
+      - name: Post summary
+        if: always()
+        run: cat report.md >> "$GITHUB_STEP_SUMMARY" || true
+      - name: Upload report (consumed by pyauto-pulse readiness)
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: workspace-validation-report
+          path: |
+            report.json
+            report.md
+          retention-days: 90
+      - name: Fail the run if validation is not ready
+        run: |
+          python3 -c "import json,sys; sys.exit(0 if json.load(open('report.json')).get('ready') else 1)"
diff --git a/pulse/checks/test_run.py b/pulse/checks/test_run.py
@@ -20,7 +20,9 @@
 
 from __future__ import annotations
 
+import datetime
 import json
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -32,6 +34,46 @@
 TEST_RESULTS_LATEST = PYAUTO_ROOT / "PyAutoBuild" / "test_results" / "latest"
 PULSE_STATE_DIR = Path.home() / ".pyauto-pulse"
 
+# The cloud workspace-validation workflow (Pulse-owned) is the continuous source
+# of the workspace-integration verdict. The tick reads only its conclusion +
+# timestamp via one `gh run list` call (cheap, same budget as ci_status); the
+# full report.json detail still comes from a local `autobuild run_all`.
+VALIDATION_REPO = "PyAutoLabs/PyAutoPulse"
+VALIDATION_WORKFLOW = "workspace-validation.yml"
+
+
+def _cloud_verdict() -> dict[str, Any] | None:
+    """Latest cloud workspace-validation run: {ready, ts, run_id, url} or None.
+
+    ready is True/False on a completed run, None while in progress. Never raises;
+    returns None if gh is unavailable or no run exists."""
+    try:
+        out = subprocess.run(
+            ["gh", "run", "list", "--repo", VALIDATION_REPO,
+             "--workflow", VALIDATION_WORKFLOW, "--limit", "1",
+             "--json", "conclusion,status,createdAt,databaseId,url"],
+            capture_output=True, text=True, timeout=30,
+        )
+        runs = json.loads(out.stdout or "[]")
+    except Exception:
+        return None
+    if not runs:
+        return None
+    r = runs[0]
+    conclusion = r.get("conclusion")
+    status = r.get("status")
+    ready: bool | None
+    if status != "completed":
+        ready = None
+    else:
+        ready = conclusion == "success"
+    return {
+        "ready": ready,
+        "ts": r.get("createdAt"),
+        "run_id": r.get("databaseId"),
+        "url": r.get("url"),
+    }
+
 
 def _read_json(path: Path) -> Any:
     try:
@@ -100,15 +142,40 @@ def _from_per_job(results_dir: Path) -> dict[str, Any]:
     }
 
 
-def run(results_dir: Path | None = None) -> dict[str, Any]:
+def run(results_dir: Path | None = None, fetch_cloud: bool | None = None) -> dict[str, Any]:
+    default_path = results_dir is None
     results_dir = results_dir or TEST_RESULTS_LATEST
+    if fetch_cloud is None:
+        fetch_cloud = default_path  # only hit the network on the real tick path
+
     summary: dict[str, Any]
     report = _read_json(results_dir / "report.json")
     if isinstance(report, dict):
         summary = _from_report(report)
     else:
         summary = _from_per_job(results_dir)
 
+    report_path = results_dir / "report.json"
+    if summary and report_path.is_file():
+        summary["ts"] = datetime.datetime.fromtimestamp(
+            report_path.stat().st_mtime, datetime.timezone.utc
+        ).isoformat()
+
+    # The cloud workspace-validation run is the authoritative continuous verdict;
+    # let it set ready/ts (the local report still supplies the count detail).
+    cloud = _cloud_verdict() if fetch_cloud else None
+    if cloud is not None:
+        if not summary:
+            summary = {
+                "passed": 0, "failed": 0, "skipped": 0, "timeout": 0,
+                "per_project": {}, "parked_stale_count": 0, "parked_stale": [],
+            }
+        summary["ready"] = cloud["ready"]
+        summary["ts"] = cloud["ts"]
+        summary["run_label"] = summary.get("run_label") or f"cloud#{cloud['run_id']}"
+        summary["cloud_url"] = cloud["url"]
+        summary["source"] = "cloud"
+
     PULSE_STATE_DIR.mkdir(parents=True, exist_ok=True)
     (PULSE_STATE_DIR / "test_run.json").write_text(json.dumps(summary, indent=2))
     return summary
diff --git a/pulse/readiness.py b/pulse/readiness.py
@@ -76,6 +76,7 @@
     "install_not_ready": (40, 40),
     "install_stale": (10, 10),
     "install_unknown": (10, 10),
+    "test_stale": (10, 10),
 }
 
 
@@ -98,6 +99,8 @@ def _as_int(v: Any, default: int = 0) -> int:
 
 # install verification older than this many days is treated as stale (YELLOW).
 INSTALL_STALE_DAYS = 14
+# workspace-validation test run older than this many days is treated as stale.
+TEST_STALE_DAYS = 10
 
 
 def _parse_ts(ts: Any) -> datetime.datetime | None:
@@ -163,7 +166,12 @@ def hit(key: str, n: int = 1) -> None:
         if ready is False:
             red.append(f"test run not ready ({test_run.get('run_label', '?')})")
             hit("test_not_ready")
-        elif ready is not True:
+        elif ready is True:
+            age = _age_days(test_run.get("ts"), ref)
+            if age is not None and age > TEST_STALE_DAYS:
+                yellow.append(f"test run stale ({int(age)}d old)")
+                hit("test_stale")
+        else:
             yellow.append("test run status unknown")
             hit("test_unknown")
         # parked staleness (YELLOW)
diff --git a/tests/test_readiness.py b/tests/test_readiness.py
@@ -55,6 +55,22 @@ def test_one_library_ci_failing_is_red():
     assert v["score"] == 70
 
 
+def test_test_run_stale_is_yellow():
+    # ready but ~31 days before the snapshot ts → stale caution, not a blocker.
+    snap = make_snapshot(test_run={"ready": True, "ts": "2026-05-01T00:00:00+00:00",
+                                   "parked_stale_count": 0})
+    v = compute(snap)
+    assert v["verdict"] == "yellow"
+    assert any("test run stale" in r for r in v["yellow_reasons"])
+
+
+def test_test_run_fresh_ready_is_green():
+    snap = make_snapshot(test_run={"ready": True, "ts": "2026-06-01T00:00:00+00:00",
+                                   "parked_stale_count": 0})
+    v = compute(snap)
+    assert v["verdict"] == "green"
+
+
 def test_test_run_not_ready_is_red():
     v = compute(make_snapshot(test_run={"ready": False, "run_label": "x"}))
     assert v["verdict"] == "red"
diff --git a/tests/test_test_run.py b/tests/test_test_run.py
@@ -68,3 +68,38 @@ def test_run_falls_back_to_per_job_when_no_report(tmp_path):
 def test_run_empty_dir_returns_empty(tmp_path):
     out = tr.run(results_dir=tmp_path)
     assert out == {}
+
+
+def test_cloud_verdict_parses_completed_run(monkeypatch):
+    import types
+    monkeypatch.setattr(tr.subprocess, "run", lambda *a, **k: types.SimpleNamespace(
+        stdout=json.dumps([{"conclusion": "success", "status": "completed",
+                            "createdAt": "2026-06-23T00:00:00Z", "databaseId": 42, "url": "u"}])))
+    v = tr._cloud_verdict()
+    assert v["ready"] is True and v["run_id"] == 42 and v["ts"] == "2026-06-23T00:00:00Z"
+
+
+def test_cloud_verdict_in_progress_is_unknown(monkeypatch):
+    import types
+    monkeypatch.setattr(tr.subprocess, "run", lambda *a, **k: types.SimpleNamespace(
+        stdout=json.dumps([{"conclusion": None, "status": "in_progress",
+                            "createdAt": "t", "databaseId": 1, "url": "u"}])))
+    assert tr._cloud_verdict()["ready"] is None
+
+
+def test_cloud_verdict_no_runs_is_none(monkeypatch):
+    import types
+    monkeypatch.setattr(tr.subprocess, "run", lambda *a, **k: types.SimpleNamespace(stdout="[]"))
+    assert tr._cloud_verdict() is None
+
+
+def test_run_cloud_overrides_ready_keeps_local_detail(monkeypatch, tmp_path):
+    (tmp_path / "report.json").write_text(json.dumps({
+        "ready": True, "run_label": "local", "summary": {"passed": 5, "failed": 0}}))
+    monkeypatch.setattr(tr, "_cloud_verdict", lambda: {
+        "ready": False, "ts": "2026-06-20T00:00:00Z", "run_id": 7, "url": "U"})
+    out = tr.run(results_dir=tmp_path, fetch_cloud=True)
+    assert out["ready"] is False                  # cloud is authoritative
+    assert out["ts"] == "2026-06-20T00:00:00Z"
+    assert out["source"] == "cloud"
+    assert out["passed"] == 5                      # detail retained from local report
