CI: Notify open PRs that conflict on uv.lock after main merges by potiuk · Pull Request #65765 · apache/airflow

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk · 2026-04-24T09:53:38Z

When `uv.lock` moves on `main`, any open PR that also touches `uv.lock` usually ends up with a rebase conflict. This workflow closes that feedback loop: on every push to `main` that modifies `uv.lock`, scan open non-draft PRs (updated in the last 14 days), find those currently conflicting, and post — or update in place, deduped via an HTML-comment marker — a single nudge with the exact rebase + `uv lock` commands.

The source PR that caused the `uv.lock` change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice; falls back to the commit URL when no match.

Summary

Workflow (`.github/workflows/notify-uv-lock-conflicts.yml`): path-filtered to `uv.lock` on `main`; installs `uv` from `uv.lock` (same pattern as `scheduled-verify-release-calendar.yml`) and runs the script.
Script (`scripts/ci/notify_uv_lock_conflicts.py`): standalone PEP 723 (`httpx`, Python ≥ 3.10). One paginated GraphQL query for PR list + files + comments + mergeable, plus a retry loop (5 × 30 s) for PRs whose `mergeable` is still `UNKNOWN` after the initial 30 s settle. Writes a diagnostics table to `GITHUB_STEP_SUMMARY`.
Unit tests (`scripts/tests/ci/test_notify_uv_lock_conflicts.py`): 29 tests covering the commit-regex, classifier, pagination early-exit on stale, UNKNOWN retry behaviour, and create-vs-update notice posting. Run with `uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py`.

Test plan

`uv run --project scripts pytest scripts/tests/ci/test_notify_uv_lock_conflicts.py` — 29 passed
`uv run ruff format / check --fix` on all three files — clean
`prek run --from-ref upstream/main --stage pre-commit` via commit hook — all applicable hooks passed
First real run on `main` after merge — confirm the notice renders with a source-PR link and dedupe marker

Was generative AI tooling used to co-author this PR?

Yes — Claude Opus 4.7 (via Claude Code, auto mode)

Generated-by: Claude Opus 4.7 following the guidelines

When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting.

The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment).

github-actions · 2026-04-25T19:22:30Z

Backport successfully created: v3-2-test

Note: As of Merging PRs targeted for Airflow 3.X
the committer who merges the PR is responsible for backporting the PRs that are bug fixes (generally speaking) to the maintenance branches.

In matter of doubt please ask in #release-management Slack channel.

Status	Branch	Result
✅	v3-2-test

…erges (#65765) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

…erges (#65765) (#65851) * CI: Notify open PRs that conflict on uv.lock after main merges When `uv.lock` changes on `main`, open PRs that touch `uv.lock` frequently end up with rebase conflicts. This adds a workflow that, on each push to `main` that modifies `uv.lock`, scans open non-draft PRs (updated in the last 14 days), identifies those currently reporting conflicts, and posts (or updates, deduped via an HTML-comment marker) a single comment with rebase-and-`uv lock` instructions. The source PR that caused the change is resolved from the squash-merge commit headline's trailing `(#NNN)` and linked in the notice. Implemented as a standalone PEP 723 Python script (`httpx` + GitHub's GraphQL API) so logic stays testable; workflow YAML is a thin driver that installs `uv` from `uv.lock` and runs the script. Unit tests cover the regex, classifier, pagination/early-exit, UNKNOWN-mergeable retry loop, and notice posting. * Fix scripts-tests by stubbing httpx in unit-test module The scripts-project CI venv doesn't have httpx installed, so importing ``notify_uv_lock_conflicts`` fails with ``ModuleNotFoundError: No module named 'httpx'`` before any test runs. httpx is a PEP 723 runtime dep of the script; the tests mock the client and never need the real library. Stub ``httpx`` in ``sys.modules`` with ``setdefault`` before loading the module under test: keeps the scripts distribution's declared deps unchanged, and leaves real ``httpx`` alone when present (e.g. in the workspace-wide dev environment). (cherry picked from commit 4fae29c) Co-authored-by: Jarek Potiuk <jarek@potiuk.com>

potiuk requested review from amoghrajesh, ashb, bugraoz93, gopidesupavan, jason810496, jscheffl and kaxil as code owners April 24, 2026 09:53