:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
fix(signals): stop closed source records from forking resolved reports (#126419)
Dylan Martin60d784ab5e37
diff --git a/products/signals/backend/emission/pipeline.py b/products/signals/backend/emission/pipeline.pyindex 9ded74f98ebe..44d06a12b9f2 100644--- a/products/signals/backend/emission/pipeline.py+++ b/products/signals/backend/emission/pipeline.py@@ -31,7 +31,9 @@ from products.signals.backend.emission.registry import (from products.signals.backend.emission.steering import SourceSteering, apply_steering, steering_from_configfrom products.signals.backend.facade.api import emit_signalfrom products.signals.backend.llm_spend import generate_with_spend-from products.signals.backend.models import SignalEmissionRecord+from products.signals.backend.models import SignalEmissionRecord, SignalReport+from products.signals.backend.recurrence import reports_fork_recurrence+from products.signals.backend.report_merge import signal_target_reportsfrom products.signals.backend.spend import complete_signal_pipeline, finalized_signal_ids, signal_id_forfrom products.signals.backend.spend_billing import system_source_exemptfrom products.signals.backend.system_one_decision import run_model_decision@@ -628,6 +630,16 @@ async def _emit_signals(return succeeded+def _reports_closed_to_source_state(team_id: int, report_ids: set[str]) -> set[str]:+ """The matched reports whose signals would fork a recurrence, after following merges and recurrences."""+ if not report_ids:+ return set()+ reports = list(SignalReport.objects.filter(team_id=team_id, id__in=report_ids))+ targets = signal_target_reports(team_id=team_id, reports=reports)+ closed_targets = reports_fork_recurrence(team_id=team_id, reports=list(targets.values()))+ return {report_id for report_id, target in targets.items() if str(target.id) in closed_targets}++async def run_signal_pipeline(team: Team,config: SignalSourceTableConfig,@@ -712,8 +724,21 @@ async def run_signal_pipeline(else outputfor output in outputs]+ # A source state change such as a closed issue only refreshes an open report. On a resolved+ # report it usually means the fix landed, so it must not file a recurrence.+ closed_report_ids = await database_sync_to_async(_reports_closed_to_source_state, thread_sensitive=False)(+ team.id,+ {+ output.source_match_report_id+ for output in outputs+ if output.existing_source_only and output.source_match_report_id is not None+ },+ )+ kept_outputs = []for output in outputs:- if output.existing_source_only and output.source_match_report_id is None:+ if not output.existing_source_only:+ kept_outputs.append(output)+ elif output.source_match_report_id is None:capture_pipeline_stage("signal_data_source_filtered",team,@@ -721,9 +746,17 @@ async def run_signal_pipeline(output,{"filter_reason": "source_state_without_report"},)- outputs = [- output for output in outputs if not output.existing_source_only or output.source_match_report_id is not None- ]+ elif output.source_match_report_id in closed_report_ids:+ capture_pipeline_stage(+ "signal_data_source_filtered",+ team,+ organization,+ output,+ {"filter_reason": "source_state_on_closed_report"},+ )+ else:+ kept_outputs.append(output)+ outputs = kept_outputsif config.summarization_prompt is not None and config.description_summarization_threshold_chars is not None:threshold = config.description_summarization_threshold_charsdiff --git a/products/signals/backend/emission/tests/test_emit_signals.py b/products/signals/backend/emission/tests/test_emit_signals.pyindex 046f0d262009..c4b1f5239bc2 100644--- a/products/signals/backend/emission/tests/test_emit_signals.py+++ b/products/signals/backend/emission/tests/test_emit_signals.py@@ -8,7 +8,9 @@ from typing import Anyimport pytestfrom unittest.mock import AsyncMock, MagicMock, patch+from django.db import connectionfrom django.test import override_settings+from django.test.utils import CaptureQueriesContextfrom django.utils import timezoneimport temporalio.worker@@ -21,6 +23,7 @@ from posthog.hogql import astfrom posthog.sync import database_sync_to_asyncfrom products.ml_inference.backend.facade.contracts import DecisionResult, NoulAnswer+from products.signals.backend.artefact_schemas import Dismissal, ReportLinkfrom products.signals.backend.emission._prompts import ISSUE_ACTIONABILITY_PROMPTfrom products.signals.backend.emission.emit_signals import (EmitDataImportSignalsWorkflow,@@ -32,6 +35,7 @@ from products.signals.backend.emission.pipeline import (LLM_MAX_ATTEMPTS,TEMPORAL_PAYLOAD_MAX_BYTES,_emit_signals,+ _reports_closed_to_source_state,_summarize_description,build_emitter_outputs,check_actionability,@@ -40,7 +44,8 @@ from products.signals.backend.emission.pipeline import (summarize_long_descriptions,)from products.signals.backend.emission.registry import SignalEmitterOutput, SignalSourceTableConfig-from products.signals.backend.models import SignalEmissionRecord, SignalSpend+from products.signals.backend.enums import ReportLinkKind+from products.signals.backend.models import SignalEmissionRecord, SignalReport, SignalReportArtefact, SignalSpendfrom products.signals.backend.spend import signal_id_forPIPELINE_MODULE_PATH = "products.signals.backend.emission.pipeline"@@ -923,18 +928,79 @@ class TestEmitSignals:@pytest.mark.django_db(transaction=True)class TestExistingSourceOnlyOutputs:+ def test_closed_report_lookup_batches_reports_links_and_dismissals(self, team):+ resolved = SignalReport.objects.create(team=team, status=SignalReport.Status.RESOLVED)+ fixed_dismissal = SignalReport.objects.create(team=team, status=SignalReport.Status.SUPPRESSED)+ SignalReportArtefact.objects.create(+ team=team,+ report=fixed_dismissal,+ type=SignalReportArtefact.ArtefactType.DISMISSAL,+ content=Dismissal(state="suppressed", reason="already_fixed").model_dump_json(),+ )++ merge_survivor = SignalReport.objects.create(team=team, status=SignalReport.Status.READY)+ merged_source = SignalReport.objects.create(team=team, status=SignalReport.Status.SUPPRESSED)+ SignalReportArtefact.objects.create(+ team=team,+ report=merged_source,+ type=SignalReportArtefact.ArtefactType.DISMISSAL,+ content=Dismissal(state="suppressed", reason="merged").model_dump_json(),+ )+ SignalReportArtefact.objects.create(+ team=team,+ report=merged_source,+ type=SignalReportArtefact.ArtefactType.REPORT_LINK,+ content=ReportLink(kind=ReportLinkKind.DUPLICATE_OF, report_id=str(merge_survivor.id)).model_dump_json(),+ link_target_id=merge_survivor.id,+ )++ recurrence_parent = SignalReport.objects.create(team=team, status=SignalReport.Status.RESOLVED)+ recurrence = SignalReport.objects.create(team=team, status=SignalReport.Status.READY)+ SignalReportArtefact.objects.create(+ team=team,+ report=recurrence,+ type=SignalReportArtefact.ArtefactType.REPORT_LINK,+ content=ReportLink(+ kind=ReportLinkKind.RECURRENCE_OF, report_id=str(recurrence_parent.id)+ ).model_dump_json(),+ link_target_id=recurrence_parent.id,+ )++ closed = _reports_closed_to_source_state(+ team.id,+ {str(resolved.id), str(fixed_dismissal.id), str(merged_source.id), str(recurrence_parent.id)},+ )++ assert closed == {str(resolved.id), str(fixed_dismissal.id)}++ direct_reports = SignalReport.objects.bulk_create(+ [SignalReport(team=team, status=SignalReport.Status.RESOLVED) for _ in range(20)]+ )+ with CaptureQueriesContext(connection) as one_report_queries:+ _reports_closed_to_source_state(team.id, {str(direct_reports[0].id)})+ with CaptureQueriesContext(connection) as many_report_queries:+ _reports_closed_to_source_state(team.id, {str(report.id) for report in direct_reports})++ assert len(many_report_queries) == len(one_report_queries)+@pytest.mark.asyncioasync def test_terminal_source_only_emits_when_it_already_has_a_report(self, team):config = _make_config(sync_with_source=True, actionability_prompt="Actionable? {description}")+ open_report = await SignalReport.objects.acreate(team=team, status=SignalReport.Status.READY)+ resolved_report = await SignalReport.objects.acreate(team=team, status=SignalReport.Status.RESOLVED)records: list[dict[str, Any]] = [{"id": "open", "state": "open"},{"id": "known-closed", "state": "closed", "existing_source_only": True},{"id": "new-closed", "state": "closed", "existing_source_only": True},+ {"id": "resolved-closed", "state": "closed", "existing_source_only": True},]with (patch(f"{PIPELINE_MODULE_PATH}.fetch_source_signal_matches",- return_value={"known-closed": [MagicMock(signal_id="previous-signal", report_id="existing-report")]},+ return_value={+ "known-closed": [MagicMock(signal_id="previous-signal", report_id=str(open_report.id))],+ "resolved-closed": [MagicMock(signal_id="fixed-signal", report_id=str(resolved_report.id))],+ },),patch(f"{PIPELINE_MODULE_PATH}.emit_signal", new_callable=AsyncMock) as emit,patch(@@ -951,19 +1017,22 @@ class TestExistingSourceOnlyOutputs:assert {call.kwargs["source_id"] for call in emit.await_args_list} == {"open", "known-closed"}known_call = next(call for call in emit.await_args_list if call.kwargs["source_id"] == "known-closed")assert known_call.kwargs["source_match_signal_id"] == "previous-signal"- assert known_call.kwargs["source_match_report_id"] == "existing-report"+ assert known_call.kwargs["source_match_report_id"] == str(open_report.id)assert filter_actionable.await_args is not Noneassert [output.source_id for output in filter_actionable.await_args.kwargs["outputs"]] == ["open"]filtered = [call for call in capture.call_args_list if call.kwargs["event"] == "signal_data_source_filtered"]- assert [call.kwargs["properties"]["source_id"] for call in filtered] == ["new-closed"]- assert filtered[0].kwargs["properties"]["filter_reason"] == "source_state_without_report"+ assert [+ (call.kwargs["properties"]["source_id"], call.kwargs["properties"]["filter_reason"]) for call in filtered+ ] == [+ ("new-closed", "source_state_without_report"),+ ("resolved-closed", "source_state_on_closed_report"),+ ]@pytest.mark.django_db(transaction=True)class TestPipelineStageTelemetry:@pytest.mark.asyncioasync def test_captures_each_stage_per_signal(self, team):-short_description = "short actionable bug"long_description = "x" * 500non_actionable_description = "billing question, not actionable"diff --git a/products/signals/backend/recurrence.py b/products/signals/backend/recurrence.pyindex ffd04f123ba9..a71e4951b2dc 100644--- a/products/signals/backend/recurrence.py+++ b/products/signals/backend/recurrence.py@@ -5,6 +5,7 @@ A wrong-repo dismissal leaves the issue unresolved. Both need a fresh report forsignals, but only fixed verdicts supply prior-fix context to research."""+from collections.abc import Collectionfrom datetime import datetimefrom pydantic import ValidationError@@ -54,6 +55,61 @@ def recurrence_dismissal_at(report: SignalReport) -> datetime | None:return _dismissal_at(report, FIXED_DISMISSAL_REASONS | {DISMISSAL_REASON_WRONG_REPO})+def dismissal_reasons_by_report(*, team_id: int, report_ids: Collection[str]) -> dict[str, list[str | None]]:+ """Dismissal reasons for several reports in newest-first order, including malformed rows as None."""+ if not report_ids:+ return {}+ rows = (+ SignalReportArtefact.objects.using("default")+ .filter(+ report_id__in=report_ids,+ team_id=team_id,+ type=SignalReportArtefact.ArtefactType.DISMISSAL,+ )+ .order_by("report_id", "-created_at")+ .values_list("report_id", "content")+ )+ reasons_by_report: dict[str, list[str | None]] = {}+ for report_id, content in rows:+ try:+ reason = Dismissal.model_validate_json(content).reason+ except ValidationError:+ reason = None+ reasons_by_report.setdefault(str(report_id), []).append(reason)+ return reasons_by_report+++def reports_fork_recurrence(*, team_id: int, reports: Collection[SignalReport]) -> set[str]:+ """The reports that fork new evidence, with dismissal state loaded once for the batch."""+ from products.signals.backend.report_content_gates import (+ team_report_monitoring_enabled, # noqa: PLC0415 — keeps the flag client off module startup+ )++ monitoring_enabled = not any(report.status == SignalReport.Status.MONITORING for report in reports) or (+ team_report_monitoring_enabled(team_id)+ )+ terminal_ids = {+ str(report.id)+ for report in reports+ if report.status in {SignalReport.Status.RESOLVED, SignalReport.Status.CLOSED}+ or (report.status == SignalReport.Status.MONITORING and not monitoring_enabled)+ }+ suppressed_ids = {str(report.id) for report in reports if report.status == SignalReport.Status.SUPPRESSED}+ reasons_by_report = dismissal_reasons_by_report(team_id=team_id, report_ids=suppressed_ids)+ return terminal_ids | {+ report_id+ for report_id in suppressed_ids+ if reasons_by_report.get(report_id, [None])[0] in (FIXED_DISMISSAL_REASONS | {DISMISSAL_REASON_WRONG_REPO})+ }+++def forks_recurrence(report: SignalReport) -> bool:+ """Whether a new signal on `report` starts a fresh recurrence report instead of joining it."""+ if report.effective_status in {SignalReport.Status.RESOLVED, SignalReport.Status.CLOSED}:+ return True+ return report.status == SignalReport.Status.SUPPRESSED and recurrence_dismissal_at(report) is not None++def recurrence_rejects_repository(*, team_id: int, report_id: str, repository: str) -> bool:for edge in outgoing_links(team_id=team_id, report_id=report_id, kinds=(ReportLinkKind.RECURRENCE_OF,)):latest = _latest_dismissal(team_id=team_id, report_id=edge.target_id)diff --git a/products/signals/backend/report_merge.py b/products/signals/backend/report_merge.pyindex 6d294a6ccd70..73dbf4c78b9a 100644--- a/products/signals/backend/report_merge.py+++ b/products/signals/backend/report_merge.py@@ -43,9 +43,10 @@ from products.signals.backend.models import (SignalReportGithubComment,SignalScoutRun,)-from products.signals.backend.recurrence import latest_recurrence_report+from products.signals.backend.recurrence import dismissal_reasons_by_report, latest_recurrence_reportfrom products.signals.backend.report_tags import set_report_tags, union_report_tagsfrom products.signals.backend.signal_metadata import REASSIGN_SIGNAL_ROW_CAP+from products.signals.backend.typed_report_links import incoming_links_by_report, outgoing_links_by_reportlogger = structlog.get_logger(__name__)@@ -208,6 +209,105 @@ def signal_target_report(report: SignalReport, *, lock: bool = False) -> SignalRreturn report+def signal_target_reports(*, team_id: int, reports: list[SignalReport]) -> dict[str, SignalReport]:+ """`signal_target_report` for a batch, loading each graph level in a fixed number of queries."""+ targets = {str(report.id): report for report in reports}+ outer_visited: dict[str, set[UUID]] = {report_id: set() for report_id in targets}+ active = set(targets)++ for _ in range(SignalReportArtefact.MAX_REPORT_LINK_GRAPH_NODES):+ if not active:+ break+ starting_targets = {report_id: targets[report_id] for report_id in active}+ for report_id, report in starting_targets.items():+ outer_visited[report_id].add(report.id)++ recurrence_cursors = {report_id: targets[report_id] for report_id in active}+ recurrence_visited = {report_id: {targets[report_id].id} for report_id in active}+ recurrence_active = set(active)+ for _ in range(SignalReportArtefact.MAX_REPORT_LINK_GRAPH_LEVELS):+ if not recurrence_active:+ break+ cursor_ids = {str(recurrence_cursors[report_id].id) for report_id in recurrence_active}+ recurrence_edges = incoming_links_by_report(+ team_id=team_id,+ report_ids=cursor_ids,+ kinds=(ReportLinkKind.RECURRENCE_OF,),+ include_deleted_sources=True,+ )+ recurrence_ids = {edge.source_id for edges in recurrence_edges.values() for edge in edges}+ recurrence_reports = {+ str(report.id): report for report in SignalReport.objects.filter(team_id=team_id, id__in=recurrence_ids)+ }+ next_active: set[str] = set()+ for report_id in recurrence_active:+ cursor_id = str(recurrence_cursors[report_id].id)+ candidates = [+ recurrence_reports[edge.source_id]+ for edge in recurrence_edges.get(cursor_id, [])+ if edge.source_id in recurrence_reports+ ]+ if not candidates:+ continue+ successor = max(candidates, key=lambda report: report.created_at)+ if successor.id in recurrence_visited[report_id]:+ continue+ recurrence_visited[report_id].add(successor.id)+ recurrence_cursors[report_id] = successor+ if successor.status != SignalReport.Status.DELETED:+ targets[report_id] = successor+ next_active.add(report_id)+ recurrence_active = next_active++ merge_active = set(active)+ merge_visited = {report_id: {targets[report_id].id} for report_id in active}+ for _ in range(SignalReportArtefact.MAX_REPORT_LINK_GRAPH_LEVELS):+ suppressed_ids = {+ str(targets[report_id].id)+ for report_id in merge_active+ if targets[report_id].status == SignalReport.Status.SUPPRESSED+ }+ reasons_by_report = dismissal_reasons_by_report(team_id=team_id, report_ids=suppressed_ids)+ merged_ids = {+ report_id+ for report_id in suppressed_ids+ if MERGE_DISMISSAL_REASON in reasons_by_report.get(report_id, [])+ }+ merge_edges = outgoing_links_by_report(+ team_id=team_id,+ report_ids=merged_ids,+ kinds=(ReportLinkKind.DUPLICATE_OF,),+ )+ survivor_ids = {edges[-1].target_id for edges in merge_edges.values() if edges}+ survivors = {+ str(report.id): report+ for report in SignalReport.objects.filter(team_id=team_id, id__in=survivor_ids).exclude(+ status=SignalReport.Status.DELETED+ )+ }+ next_active = set()+ for report_id in merge_active:+ current_id = str(targets[report_id].id)+ edges = merge_edges.get(current_id, [])+ survivor = survivors.get(edges[-1].target_id) if edges else None+ if survivor is None or survivor.id in merge_visited[report_id]:+ continue+ targets[report_id] = survivor+ merge_visited[report_id].add(survivor.id)+ next_active.add(report_id)+ if not next_active:+ break+ merge_active = next_active++ active = {+ report_id+ for report_id in active+ if targets[report_id].id != starting_targets[report_id].id+ and targets[report_id].id not in outer_visited[report_id]+ }+ return targets++def _release_source_claim(source: SignalReport, attribution: ArtefactAttribution) -> bool:"""End any active claim on the source, so no claim is left stranded on an archived report.diff --git a/products/signals/backend/temporal/grouping.py b/products/signals/backend/temporal/grouping.pyindex c10a4bd0e56e..7d3a6aadf0c1 100644--- a/products/signals/backend/temporal/grouping.py+++ b/products/signals/backend/temporal/grouping.py@@ -39,7 +39,7 @@ from products.signals.backend.enums import ReportLinkKind, ReportLinkWritePath,from products.signals.backend.models import SignalEmissionRecord, SignalReport, SignalReportArtefactfrom products.signals.backend.quota import capture_signal_report_quota_paused, self_driving_quota_gatefrom products.signals.backend.receivers import _is_safety_suppressed-from products.signals.backend.recurrence import recurrence_dismissal_at+from products.signals.backend.recurrence import forks_recurrencefrom products.signals.backend.report_merge import signal_target_reportfrom products.signals.backend.report_monitoring_signals import current_research_attemptfrom products.signals.backend.signal_metadata import EMBEDDING_MODEL@@ -930,13 +930,7 @@ async def assign_and_emit_signal_activity(input: AssignAndEmitSignalInput) -> As# Wrong-repo feedback rejects the repository choice rather than the issue, so new# evidence needs fresh research, just as it does after a fixed verdict.report = signal_target_report(report, lock=True)- dismissed_for_recurrence_at = (- recurrence_dismissal_at(report) if report.status == SignalReport.Status.SUPPRESSED else None- )- if (- report.effective_status in {SignalReport.Status.RESOLVED, SignalReport.Status.CLOSED}- or dismissed_for_recurrence_at is not None- ):+ if forks_recurrence(report):parent_report = reportinherit_content = not _is_safety_suppressed(str(parent_report.id), input.team_id)report = SignalReport.objects.create(diff --git a/products/signals/backend/test/test_report_links.py b/products/signals/backend/test/test_report_links.pyindex e1f4138fe900..1d526299dc3d 100644--- a/products/signals/backend/test/test_report_links.py+++ b/products/signals/backend/test/test_report_links.py@@ -13,8 +13,10 @@ from products.signals.backend.typed_report_links import (duplicate_root,has_open_or_merged_pull_request,incoming_links,+ incoming_links_by_report,linked_reports,outgoing_links,+ outgoing_links_by_report,)@@ -67,6 +69,25 @@ class TestReportLinkReaders(BaseTest):assert len(incoming_links(team_id=self.team.id, report_id=str(target.id).upper())) == 1+ @parameterized.expand([("outgoing",), ("incoming",)])+ def test_the_row_budget_applies_to_each_report_in_a_batch(self, direction: str):+ busy, quiet, other = self._report("busy"), self._report("quiet"), self._report("other")+ if direction == "outgoing":+ self._link(busy, other, ReportLinkKind.DEPENDS_ON)+ self._link(busy, quiet, ReportLinkKind.PART_OF)+ self._link(quiet, other, ReportLinkKind.RECURRENCE_OF)+ else:+ self._link(other, busy, ReportLinkKind.DEPENDS_ON)+ self._link(quiet, busy, ReportLinkKind.PART_OF)+ self._link(busy, quiet, ReportLinkKind.RECURRENCE_OF)+ read = outgoing_links_by_report if direction == "outgoing" else incoming_links_by_report++ with patch.object(SignalReportArtefact, "MAX_REPORT_LINK_GRAPH_ROWS", 1):+ edges = read(team_id=self.team.id, report_ids=[str(busy.id), str(quiet.id)])++ assert len(edges[str(busy.id)]) == 1+ assert [edge.kind for edge in edges[str(quiet.id)]] == [ReportLinkKind.RECURRENCE_OF]+@parameterized.expand([("outgoing",), ("incoming",)])def test_a_row_that_no_longer_parses_names_no_edge(self, direction: str):source, target = self._report("source"), self._report("target")diff --git a/products/signals/backend/typed_report_links.py b/products/signals/backend/typed_report_links.pyindex 06ea7516d7ff..fb4c62078728 100644--- a/products/signals/backend/typed_report_links.py+++ b/products/signals/backend/typed_report_links.py@@ -14,6 +14,9 @@ parsing. Nothing mirrors the row onto the target, because the direction is the pimport uuidfrom collections.abc import Collection+from django.db.models import F, QuerySet, Window+from django.db.models.functions import RowNumber+import structlogimport posthoganalyticsfrom pydantic import ValidationError@@ -68,6 +71,28 @@ def _edges_from_rows(return edges+def _rows_within_budget_per_report(+ candidates: QuerySet[SignalReportArtefact], *, partition_field: str+) -> QuerySet[SignalReportArtefact, tuple[uuid.UUID, str]]:+ """`(report_id, content)` rows, oldest first, with the graph row budget applied to each report.++ One budget shared by the whole batch would let a report with many links hide the links of every+ report after it, so a batch read could give a different answer than the single-report read.+ """+ return (+ candidates.annotate(+ _report_rank=Window(+ expression=RowNumber(),+ partition_by=[F(partition_field)],+ order_by=[F("created_at").asc(), F("id").asc()],+ )+ )+ .filter(_report_rank__lte=SignalReportArtefact.MAX_REPORT_LINK_GRAPH_ROWS)+ .order_by("created_at", "id")+ .values_list("report_id", "content")+ )++def outgoing_links(*, team_id: int, report_id: str | uuid.UUID, kinds: Collection[ReportLinkKind] | None = None) -> list[ReportEdge]:@@ -91,14 +116,12 @@ def outgoing_links_by_report(source_ids = [source_id for source_id in map(_canonical_report_id, report_ids) if source_id is not None]if not source_ids:return {}- rows = (- SignalReportArtefact.objects.using("default")- .filter(team_id=team_id, report_id__in=source_ids, type=SignalReportArtefact.ArtefactType.REPORT_LINK)- .order_by("created_at", "id")- .values_list("report_id", "content")[: SignalReportArtefact.MAX_REPORT_LINK_GRAPH_ROWS]+ candidates = SignalReportArtefact.objects.using("default").filter(+ team_id=team_id, report_id__in=source_ids, type=SignalReportArtefact.ArtefactType.REPORT_LINK)+ rows = list(_rows_within_budget_per_report(candidates, partition_field="report_id"))edges_by_report: dict[str, list[ReportEdge]] = {}- for edge in _edges_from_rows(list(rows), kinds=kinds):+ for edge in _edges_from_rows(rows, kinds=kinds):edges_by_report.setdefault(edge.source_id, []).append(edge)return edges_by_report@@ -135,6 +158,32 @@ def incoming_links(return [edge for edge in _edges_from_rows(rows, kinds=kinds) if edge.target_id == target_id]+def incoming_links_by_report(+ *,+ team_id: int,+ report_ids: Collection[str],+ kinds: Collection[ReportLinkKind] | None = None,+ include_deleted_sources: bool = False,+) -> dict[str, list[ReportEdge]]:+ """`incoming_links` for several reports in one query, keyed by target report id."""+ target_ids = {target_id for target_id in map(_canonical_report_id, report_ids) if target_id is not None}+ if not target_ids:+ return {}+ candidates = SignalReportArtefact.objects.using("default").filter(+ team_id=team_id,+ type=SignalReportArtefact.ArtefactType.REPORT_LINK,+ link_target_id__in=target_ids,+ )+ if not include_deleted_sources:+ candidates = candidates.exclude(report__status=SignalReport.Status.DELETED)+ rows = list(_rows_within_budget_per_report(candidates, partition_field="link_target_id"))+ edges_by_report: dict[str, list[ReportEdge]] = {}+ for edge in _edges_from_rows(rows, kinds=kinds):+ if edge.target_id in target_ids:+ edges_by_report.setdefault(edge.target_id, []).append(edge)+ return edges_by_report++def duplicate_chain(*, team_id: int, report_id: str | uuid.UUID) -> list[str]:"""The reports this one duplicates, nearest first, ending at the one that duplicates nothing.