ci.yml

name: CI

# Branch-neutral workflow: the image tag, make.py argument, and Gramps
# series pin are all derived from the branch ref at runtime, so the same
# file runs unchanged on maintenance/gramps60, maintenance/gramps61, and
# any future maintenance/grampsNN branch.
#
# NOTE for maintainers — first push to a new maintenance branch: the
# corresponding gramps-ci:<suffix> image does not exist in GHCR yet, so
# the container jobs in this workflow will fail at "Initialize containers"
# on the very first run. The companion docker-build.yml workflow fires
# on the same push and builds/pushes the image (~5 min cold). After it
# finishes, re-run the failed CI jobs (Actions tab → this run → "Re-run
# failed jobs") and they will pull the now-existing image. This race
# happens only on initial branch creation — every subsequent push to
# that branch finds the image already in GHCR.
#
# Full operational runbook (GHCR visibility, PyPI-release transitions,
# diagnostic log markers, etc.): .github/CI-MAINTAINER.md

on:
  push:
    branches: [maintenance/gramps**]
  pull_request:
    branches: [maintenance/gramps**]

# Least privilege. Every job only reads the repo; the CI image is a public
# GHCR package, so pulling it needs no `packages` scope. This workflow runs
# addon-influenced code (pip package hooks derived from requires_mod, and
# addon import-time code in the load/test lanes), so the ambient token it
# hands that code must not carry write scopes. Presumes the gramps-ci package
# is public (the one-time visibility flip in .github/CI-MAINTAINER.md).
permissions:
  contents: read

jobs:
  # -----------------------------------------------------------------
  # Setup — derive the branch suffix (gramps60 / gramps61 / …) from
  # the ref. On push events github.ref_name is the branch being
  # pushed; on pull_request events github.base_ref is the target
  # branch. Either way the suffix is what follows "maintenance/".
  # -----------------------------------------------------------------
  setup:
    name: Setup
    runs-on: ubuntu-latest
    outputs:
      branch_suffix: ${{ steps.compute.outputs.branch_suffix }}
      ci_image: ${{ steps.compute.outputs.ci_image }}
    steps:
      - id: compute
        shell: bash
        run: |
          ref="${{ github.base_ref || github.ref_name }}"
          suffix="${ref#maintenance/}"
          case "$suffix" in
            gramps[0-9][0-9]) ;;
            *) echo "::error::unexpected ref '$ref' (suffix '$suffix')"; exit 1 ;;
          esac
          echo "branch_suffix=$suffix" >> "$GITHUB_OUTPUT"
          # Lowercase the owner/name: GHCR refs must be lowercase, and
          # docker-build's metadata-action lowercases what it PUSHES, so the
          # pull side must match — otherwise a fork whose owner has uppercase
          # letters pulls an invalid (mixed-case) reference and every container
          # job fails at init. ${VAR,,} is a bash lowercasing expansion; there
          # is no expression-level equivalent in Actions.
          repo_lc="${GITHUB_REPOSITORY,,}"
          echo "ci_image=ghcr.io/${repo_lc}/gramps-ci:$suffix" >> "$GITHUB_OUTPUT"

  # -----------------------------------------------------------------
  # Lint (ci container)
  # -----------------------------------------------------------------
  lint:
    name: Lint
    needs: setup
    runs-on: ubuntu-latest
    container:
      image: ${{ needs.setup.outputs.ci_image }}
    steps:
      - uses: actions/checkout@v4

      - name: Run ruff (syntax and import errors only)
        # Skip addon directories whose every register() in .gpr.py sets
        # include_in_listing=False — those addons are not built or released
        # by make.py, so CI does not gate on their lint state (per Gary
        # Griffin's request on PR #820). To re-enable lint gating for an
        # addon, set include_in_listing=True on at least one register()
        # call in its descriptor (or remove the field — Gramps' default
        # is True). Repeated inline rather than centralised so each job
        # step stays self-contained.
        shell: bash
        run: |
          source .github/scripts/active_addons.sh
          excludes=""
          for d in */; do
            d="${d%/}"
            ls "$d"/*.gpr.py >/dev/null 2>&1 || continue
            is_active "$d" || excludes="$excludes --exclude=$d"
          done
          ruff check --select=E9,F63,F7,F82 --no-fix --exclude='*.gpr.py' $excludes .

      - name: Check trailing whitespace in Python files
        run: |
          # Use PCRE (-P): in BRE/ERE the bracket expression [ \t] is the
          # set { space, backslash, 't' } — git grep matches anything ending
          # in 't', not just whitespace. -P makes \t a tab.
          if git --no-pager grep --color -n --full-name -P '[ \t]+$' -- '*.py'; then
            echo "::error::Trailing whitespace found in Python files"
            exit 1
          fi

  # -----------------------------------------------------------------
  # Addon structure (bare runner — just bash, no deps needed)
  # -----------------------------------------------------------------
  addon-structure:
    name: Addon Structure
    runs-on: ubuntu-latest
    # Non-blocking until the four addons missing po/template.pot are fixed
    # in a follow-up PR. Flip this off in that PR.
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Check all listed addons have po/template.pot
        # Skip include_in_listing=False addons (see lint job for rationale).
        shell: bash
        run: |
          source .github/scripts/active_addons.sh
          failed=0
          for gpr in */*.gpr.py; do
            addon_dir="$(dirname "$gpr")"
            is_active "$addon_dir" || continue
            if [ ! -d "$addon_dir/po" ]; then
              echo "::error::$addon_dir is missing po/ directory"
              failed=1
            elif [ ! -f "$addon_dir/po/template.pot" ]; then
              echo "::error::$addon_dir is missing po/template.pot"
              failed=1
            fi
          done
          if [ "$failed" -eq 0 ]; then
            echo "All listed addons have po/template.pot"
          fi
          exit $failed

  # -----------------------------------------------------------------
  # Compile check (ci container)
  # -----------------------------------------------------------------
  compile-check:
    name: Compile Check
    needs: setup
    runs-on: ubuntu-latest
    container:
      image: ${{ needs.setup.outputs.ci_image }}
    steps:
      - uses: actions/checkout@v4

      - name: Compile all Python files in listed addons (excluding .gpr.py)
        # Skip include_in_listing=False addons (see lint job for rationale).
        shell: bash
        run: |
          source .github/scripts/active_addons.sh
          skipped=""
          for d in */; do
            d="${d%/}"
            ls "$d"/*.gpr.py >/dev/null 2>&1 || continue
            is_active "$d" || skipped="$skipped $d"
          done
          failed=0
          while IFS= read -r f; do
            skip=0
            for s in $skipped; do
              case "$f" in ./$s/*) skip=1; break;; esac
            done
            [ "$skip" = 1 ] && continue
            if ! python3 -m py_compile "$f" 2>&1; then
              failed=1
            fi
          done < <(find . -name '*.py' ! -name '*.gpr.py' ! -path './.git/*' ! -path '*/__pycache__/*')
          exit $failed

  # -----------------------------------------------------------------
  # Unit tests — Linux (ci container)
  # -----------------------------------------------------------------
  unit-test-linux:
    name: Unit Tests (Linux)
    needs: setup
    runs-on: ubuntu-latest
    container:
      image: ${{ needs.setup.outputs.ci_image }}
    steps:
      - uses: actions/checkout@v4

      - name: Install addon system deps (requires_gi / requires_exe / source-built requires_mod)
        # System deps (GI typelibs, executables, and the -dev headers / libpq that
        # source-built requires_mod link against — pygraphviz→libgraphviz-dev,
        # psycopg2/psycopg→libpq-dev) are not pip-installable as named and gramps
        # only *checks* requires_mod, so the image cannot bake them generically
        # (its build context excludes addons-source). Derive the apt set from every
        # .gpr.py via the single-source map and install it — the container runs as
        # root. MUST run before "Install addon runtime deps" so the headers are
        # present when pip compiles the source-built modules; the compiler toolchain
        # those builds need lives in the CI image (no longer purged there).
        shell: bash
        run: |
          pkgs=$(python3 .github/scripts/addon_system_deps.py --platform apt)
          if [ -n "$pkgs" ]; then
            echo "→ addon system deps (apt): $pkgs"
            apt-get update
            apt-get install -y --no-install-recommends $pkgs
          else
            echo "no requires_gi / requires_exe / source-built requires_mod declarations found"
          fi

      - name: Validate addon system deps are mapped
        # Every requires_gi / requires_exe an addon declares must have an entry in
        # addon_system_deps.py, and every requires_mod must be classified as either
        # wheel-only or source-built (with a system package), so the install list
        # never silently drifts from what addons declare — the build-toolchain
        # coverage gap returns the moment a new source-built requires_mod is added
        # without a mapping. (The system-dep analogue of the requires_mod dep
        # gate below.)
        shell: bash
        run: |
          python3 .github/scripts/addon_system_deps.py --unmapped . || {
            echo "::error::Addon(s) declare requires_gi/requires_exe/requires_mod with no entry in .github/scripts/addon_system_deps.py — add a mapping row (or, for a wheel-only module, list it in WHEEL_ONLY_MODS)."
            exit 1
          }

      - name: Install addon runtime deps (derived from requires_mod)
        # Auto-derive the union of requires_mod across every .gpr.py in
        # the repo. Mirrors Gramps' Addon Manager install path
        # (gramps/gui/plug/_windows.py __on_install_clicked → req.install →
        # gen/utils/requirements.py). Keeps .gpr.py files as the single
        # source of truth for addon deps — no parallel list to maintain
        # in the image or workflow. Import→distribution names (PIL→Pillow)
        # come from the installed gramps' own _IMPORT_TO_PYPI table
        # (gen/utils/pypi.py, gramps 6.1+, PR #2308), with a local mirror
        # in addon_python_deps.py for lanes on 6.0. Best-effort: a package
        # needing exotic
        # system deps (pygraphviz → graphviz-dev, psycopg2 → libpq-dev)
        # may fail here; the affected addon's tests will skip or fail in
        # isolation without blocking the rest.
        shell: bash
        run: |
          addon_mods=$(python3 .github/scripts/addon_python_deps.py --install-list .)
          if [ -n "$addon_mods" ]; then
            echo "→ addon deps: $addon_mods"
            for mod in $addon_mods; do
              pip install "$mod" || echo "× $mod failed to install (continuing)"
            done
          else
            echo "no requires_mod declarations found"
          fi

      - name: Validate requires_mod names against Gramps' dep gate
        # Cross-check: every requires_mod entry that pip successfully
        # installed in the previous step must also pass Gramps' own dep
        # gate — the script delegates to the installed gramps'
        # Requirements().check_mod (gramps/gen/utils/requirements.py):
        # find_spec on 6.0; find_spec plus a real import on 6.1+ (gramps
        # PR #2308), so the gate matches whichever series this lane
        # ships. A name that pip-installs but does not import is a
        # declaration bug — e.g. requires_mod=["Pillow"] when the
        # importable name is "PIL". Pip-installed-ness is probed by the
        # mapped distribution name (pip only knows "Pillow", not "PIL").
        # A name whose distribution never installed is judged by category:
        # a wheel-only module (WHEEL_ONLY_MODS) ships a wheel that installs
        # everywhere, so a miss is a provisioning regression and FAILS the
        # gate; a source-built module (pygraphviz/psycopg2) can miss on an
        # image/system gap and stays an advisory skip.
        shell: bash
        run: |
          python3 .github/scripts/addon_python_deps.py --check-resolves .

      - name: Run per-addon unit tests
        # Filename convention (all OSes):
        #   test_*.py              — general (any OS)
        #   test_linux_*.py        — Linux-only
        #   test_windows_*.py      — Windows-only
        #   test_integration_*.py  — Linux-only, full-pipeline/DB-backed
        # The Linux job runs test_*.py except the Windows-only and
        # integration buckets. Integration tests run in their own job.
        #
        # shell: bash — the container's default shell is /bin/sh
        # (dash on python:3.12-slim), which does not support the
        # ${var//pattern/repl} and ${var%.py} parameter expansions
        # used below.
        shell: bash
        env:
          PYTHONPATH: .
        run: |
          source .github/scripts/active_addons.sh
          modules=""
          shopt -s globstar  # also match nested-package tests/<subpkg>/test_*.py
          # Glob is scoped to */tests/**/ ON PURPOSE. The only root-level test
          # module in the tree, DynamicWeb/test_dynamicweb.py, is a nose-era dev
          # harness (nose is gone on py3.12; it asserts a USER_PLUGINS install and
          # drives Gramps.py from a source checkout) — unrunnable here, and it
          # declares no requires_gi, so it would hard-fail if matched. Its
          # CI-shaped sibling DynamicWeb/tests/test_dwr_tree_names.py IS matched,
          # so DynamicWeb keeps coverage. The runner can load a root-level module,
          # so this is a policy choice, not a limitation.
          for f in */tests/**/test_*.py; do
            [ -f "$f" ] || continue
            addon="${f%%/*}"
            is_active "$addon" || continue
            case "$(basename "$f")" in
              test_integration*) continue ;;
              test_windows_*)    continue ;;
            esac
            case "$f" in
              # Sqlite/tests/test_sqlite.py predates this pipeline: it needs
              # GRAMPS_RESOURCES + example/gramps/example.gramps from a gramps
              # SOURCE checkout (the pip/conda wheels ship only gramps/ + share,
              # not example/) and writes fixed /tmp paths with no cleanup. Un-
              # excluding is a follow-up: provide example.gramps in the lane and
              # port the test to tempfile.
              Sqlite/tests/test_sqlite.py) continue ;;
            esac
            mod="${f%.py}"
            mod="${mod//\//.}"
            modules="$modules $mod"
          done
          if [ -n "$modules" ]; then
            echo "Running unit tests:$modules"
            # xvfb-run: some addons create a Gtk style context at import and
            #   need a display (else a hard Gtk-ERROR abort, not a clean skip).
            # run_addon_tests.py: pins the GI versions like gramps' launcher
            #   (so gramps.gui imports load GTK 3, no PyGIWarning) and fails a
            #   wholly-skipped module unless the addon's deps are unavailable on
            #   this platform.
            xvfb-run -a --server-args="-screen 0 1920x1080x24" \
              python3 .github/scripts/run_addon_tests.py --platform apt --root . $modules
          else
            echo "No per-addon unit test modules found"
          fi

  # -----------------------------------------------------------------
  # Unit tests — Windows (conda-forge: bundles PyGObject + GTK + Gramps)
  # -----------------------------------------------------------------
  unit-test-windows:
    name: Unit Tests (Windows)
    needs: setup
    runs-on: windows-latest
    defaults:
      run:
        shell: bash -el {0}
    steps:
      - uses: actions/checkout@v4

      - name: Set up Miniforge
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniforge-version: latest
          activate-environment: addons-ci
          environment-file: .github/environment.yml
          use-mamba: true

      - name: Verify environment
        run: |
          mamba info
          mamba list | head -30
          python -c "import gramps, gi; print('deps OK')"

      - name: Report gramps-vs-branch series (Windows lane caveat)
        # The Linux lane runs the branch's exact gramps in its CI image
        # (.github/docker/gramps-ci/Dockerfile, PyPI-first / git-tip fallback).
        # The conda Windows lane installs gramps from PyPI via environment.yml's
        # `pip:` block (NOT from conda-forge), pinned `gramps>=6.0,<6.1`. So on a
        # maintenance/gramps61 (or later) branch it validates addons against
        # 6.0.x, not the branch's series — for two independent reasons: the pin's
        # `<6.1` excludes 6.1, and 6.1 is not published on PyPI yet anyway. This
        # step surfaces the mismatch honestly; it does NOT fail. Addon tests that
        # depend on series-exact gramps behaviour skip themselves on Windows
        # (e.g. TMGimporter's real-DB import tests) and run on the Linux lane
        # instead. The caveat clears only when BOTH hold: gramps 6.1 is on PyPI,
        # AND environment.yml's pin has been bumped on that branch (it does not
        # self-heal — see .github/CI-MAINTAINER.md).
        run: |
          suffix="${{ needs.setup.outputs.branch_suffix }}"   # e.g. gramps61
          digits="${suffix#gramps}"                            # e.g. 61
          want="${digits:0:1}.${digits:1}"                     # e.g. 6.1
          have="$(python -c 'from gramps.version import major_version; print(major_version)')"
          if [ "$want" = "$have" ]; then
            echo "conda-forge gramps $have matches branch series $want — addons tested against the branch's gramps"
          else
            echo "::warning::Windows lane: branch targets gramps $want but conda-forge ships $have; addons here are validated against $have. Full $want coverage is on the Linux lane (its CI image git-builds $want). See step comment for why conda-Windows cannot build $want."
          fi

      - name: Install addon system deps (requires_gi / requires_exe / source-built requires_mod)
        # The conda-forge-available subset of the single-source map. This lane
        # provisions its OWN deps and must mirror the apt lane: source-built
        # requires_mod that conda-forge ships prebuilt — pygraphviz, psycopg2,
        # psycopg — are installed here as full conda-forge packages
        # (MOD_BUILD_PACKAGES' conda side), so the later pip step finds them already
        # satisfied and the affected addons' suites RUN on Windows instead of
        # silently skipping. `mamba install` fails the job if a mapped package
        # cannot be resolved, so a provisioning gap aborts honestly — never a silent
        # green. The GTK 3 addon GI libs (goocanvas/osm-gps-map/gexiv2) are
        # genuinely NOT on conda-forge, so the map keeps them at None and they are
        # not installed; addons needing only those skip on Windows by necessity,
        # which run_addon_tests tolerates for declared GI deps (--platform conda).
        run: |
          pkgs=$(python .github/scripts/addon_system_deps.py --platform conda)
          if [ -n "$pkgs" ]; then
            echo "→ addon system deps (conda): $pkgs"
            mamba install -y -c conda-forge $pkgs
          else
            echo "no conda-available addon system deps to install"
          fi

      - name: Validate addon system deps are mapped
        # Same drift gate as unit-test-linux (see its comment). This lane runs
        # it independently and BEFORE its own pip step: unit-test-windows only
        # `needs: setup`, not unit-test-linux, so it must not lean on the Linux
        # gate — otherwise a novel requires_mod would reach `pip install`
        # unguarded here (arbitrary package execution) while Linux blocks it.
        # `python` (conda-forge env) to match the surrounding Windows style.
        run: |
          python .github/scripts/addon_system_deps.py --unmapped . || {
            echo "::error::Addon(s) declare requires_gi/requires_exe/requires_mod with no entry in .github/scripts/addon_system_deps.py — add a mapping row (or, for a wheel-only module, list it in WHEEL_ONLY_MODS)."
            exit 1
          }

      - name: Install addon runtime deps (derived from requires_mod)
        # See unit-test-linux for rationale. Uses `python` (conda-forge
        # env) to match the surrounding Windows job style.
        run: |
          addon_mods=$(python .github/scripts/addon_python_deps.py --install-list .)
          if [ -n "$addon_mods" ]; then
            echo "→ addon deps: $addon_mods"
            for mod in $addon_mods; do
              pip install "$mod" || echo "× $mod failed to install (continuing)"
            done
          else
            echo "no requires_mod declarations found"
          fi

      - name: Validate requires_mod names against Gramps' dep gate
        # See unit-test-linux for rationale. Uses `python` (conda-forge
        # env) to match the surrounding Windows job style.
        run: |
          python .github/scripts/addon_python_deps.py --check-resolves .

      - name: Run per-addon unit tests
        # See filename-convention note in unit-test-linux. The Windows
        # job runs test_*.py except test_linux_* and test_integration_*.
        env:
          PYTHONPATH: .
        run: |
          source .github/scripts/active_addons.sh
          modules=""
          # Glob scoped to */tests/**/ (see unit-test-linux for why DynamicWeb's
          # root-level test module is deliberately not matched).
          shopt -s globstar  # also match nested-package tests/<subpkg>/test_*.py
          for f in */tests/**/test_*.py; do
            [ -f "$f" ] || continue
            addon="${f%%/*}"
            is_active "$addon" || continue
            case "$(basename "$f")" in
              test_integration*) continue ;;
              test_linux_*)      continue ;;
            esac
            case "$f" in
              # excluded — see unit-test-linux for the rationale (needs a gramps
              # source checkout's example.gramps; a follow-up).
              Sqlite/tests/test_sqlite.py) continue ;;
            esac
            mod="${f%.py}"
            mod="${mod//\//.}"
            modules="$modules $mod"
          done
          if [ -n "$modules" ]; then
            echo "Running unit tests:$modules"
            # No xvfb on Windows (GTK renders natively). run_addon_tests pins
            # the GI versions and tolerates addons whose GI deps are not on
            # conda-forge (they skip here by platform necessity).
            python .github/scripts/run_addon_tests.py --platform conda --root . $modules
          else
            echo "No per-addon unit test modules found"
          fi

  # -----------------------------------------------------------------
  # Integration tests — Gramps (ci container, xvfb available)
  # -----------------------------------------------------------------
  integration-test:
    name: Integration Tests (Gramps)
    runs-on: ubuntu-latest
    needs: [setup, unit-test-linux]
    container:
      image: ${{ needs.setup.outputs.ci_image }}
      options: --init
    steps:
      - uses: actions/checkout@v4

      - name: Install addon system deps (requires_gi / requires_exe / source-built requires_mod)
        # Same as unit-test-linux: derive the apt set from the single-source
        # map and install it (container runs as root). The plugin registration
        # test subprocess-loads each addon module, so the GI typelibs those
        # modules import — and the -dev headers / libpq their source-built
        # requires_mod compile/link against — must be present here too. (Mapping is
        # drift-guarded in unit-test-linux, which this job needs:, so no duplicate
        # gate here.)
        shell: bash
        run: |
          pkgs=$(python3 .github/scripts/addon_system_deps.py --platform apt)
          if [ -n "$pkgs" ]; then
            echo "→ addon system deps (apt): $pkgs"
            apt-get update
            apt-get install -y --no-install-recommends $pkgs
          fi

      - name: Install addon runtime deps (derived from requires_mod)
        # See unit-test-linux for rationale. The plugin registration test
        # subprocess-loads each addon's module, which imports its
        # requires_mod packages.
        shell: bash
        run: |
          addon_mods=$(python3 .github/scripts/addon_python_deps.py --install-list .)
          if [ -n "$addon_mods" ]; then
            echo "→ addon deps: $addon_mods"
            for mod in $addon_mods; do
              pip install "$mod" || echo "× $mod failed to install (continuing)"
            done
          else
            echo "no requires_mod declarations found"
          fi

      - name: Validate requires_mod names against Gramps' dep gate
        # See unit-test-linux for rationale.
        shell: bash
        run: |
          python3 .github/scripts/addon_python_deps.py --check-resolves .

      - name: Run plugin registration tests
        # shell: bash for consistency with the surrounding steps; the
        # current command uses no bashisms, but keeps this block safe
        # against future edits. Container default is /bin/sh → dash.
        #
        # gi_bootstrap on PYTHONPATH pins the GI versions (like the gramps GUI
        # launcher) for this process AND the addon-module subprocesses this test
        # spawns, so gramps.gui imports load GTK 3 without a PyGIWarning.
        #
        # NOT run under xvfb: this test only *loads* (imports) addon modules in
        # subprocesses and tolerates load failures; it does not render. Giving it
        # a display made an addon load hang on the (absent) AT-SPI accessibility
        # bus until the per-load timeout. Imports that build a Gtk style context
        # are exercised under xvfb in the unit/integration test runs instead.
        shell: bash
        env:
          PYTHONPATH: .github/scripts/gi_bootstrap:.
        run: |
          python3 -m unittest discover -s tests -p "test_*.py" -t . -v

      - name: Run per-addon integration tests
        # shell: bash — see unit-test-linux for rationale; the
        # ${var//pattern/repl} and ${var%.py} expansions below are
        # bash-only.
        shell: bash
        env:
          PYTHONPATH: .
        run: |
          source .github/scripts/active_addons.sh
          modules=""
          shopt -s globstar  # also match nested-package tests/<subpkg>/test_integration*.py
          for f in */tests/**/test_integration*.py; do
            [ -f "$f" ] || continue
            addon="${f%%/*}"
            is_active "$addon" || continue
            mod="${f%.py}"
            mod="${mod//\//.}"
            modules="$modules $mod"
          done
          if [ -n "$modules" ]; then
            echo "Running per-addon integration tests:$modules"
            xvfb-run -a --server-args="-screen 0 1920x1080x24" \
              python3 .github/scripts/run_addon_tests.py --platform apt --root . $modules
          else
            echo "No per-addon integration test modules found"
          fi

  # -----------------------------------------------------------------
  # Build (ci container)
  # -----------------------------------------------------------------
  build:
    name: Build
    needs: setup
    runs-on: ubuntu-latest
    container:
      image: ${{ needs.setup.outputs.ci_image }}
    steps:
      - uses: actions/checkout@v4

      - name: Determine GRAMPSPATH
        id: gramps-path
        run: |
          GPATH=$(python3 -c "import gramps, os; print(os.path.dirname(os.path.dirname(gramps.__file__)))")
          echo "path=$GPATH" >> "$GITHUB_OUTPUT"

      - name: Build all addons
        env:
          GRAMPSPATH: ${{ steps.gramps-path.outputs.path }}
        run: |
          mkdir -p ../download
          python3 make.py "${{ needs.setup.outputs.branch_suffix }}" build all