Run automated tracking from the admin as a post-processing method, with editable settings

ami/main/admin.py

@@ -16,8 +16,11 @@
 from ami.ml.post_processing.admin.actions import make_post_processing_action
 from ami.ml.post_processing.admin.class_masking_form import ClassMaskingActionForm
 from ami.ml.post_processing.admin.small_size_filter_form import SmallSizeFilterActionForm
+from ami.ml.post_processing.admin.tracking_actions import build_tracking_jobs_for_events
+from ami.ml.post_processing.admin.tracking_form import TrackingActionForm
 from ami.ml.post_processing.class_masking import ClassMaskingTask
 from ami.ml.post_processing.small_size_filter import SmallSizeFilterTask
+from ami.ml.post_processing.tracking import TrackingTask
 from ami.ml.tasks import remove_duplicate_classifications
 
 from .models import (
@@ -314,8 +317,16 @@ def update_calculated_fields(self, request: HttpRequest, queryset: QuerySet[Even
         update_calculated_fields_for_events(qs=queryset)
         self.message_user(request, f"Updated {queryset.count()} events.")
 
+    # One Job per project, since a Job belongs to a single project and the changelist can span several.
+    run_tracking = make_post_processing_action(
+        TrackingTask,
+        TrackingActionForm,
+        build_jobs=build_tracking_jobs_for_events,
+        description="Run Occurrence tracking on the selected sessions (async)",
+    )
+
     list_filter = ("deployment", "project", "start")
-    actions = [update_calculated_fields]
+    actions = [update_calculated_fields, run_tracking]
 
 
 @admin.register(SourceImage)
@@ -861,11 +872,20 @@ def populate_collection_async(self, request: HttpRequest, queryset: QuerySet[Sou
             f"Post-processing: {task_cls.name} on Capture Set {collection.pk}"
         ),
     )
+    run_tracking = make_post_processing_action(
+        TrackingTask,
+        TrackingActionForm,
+        scope_resolver=lambda collection: {"source_image_collection_id": collection.pk},
+        name_resolver=lambda task_cls, collection: (
+            f"Post-processing: {task_cls.name} on Capture Set {collection.pk}"
+        ),
+    )
     actions = [
         populate_collection,
         populate_collection_async,
         run_small_size_filter,
         run_class_masking,
+        run_tracking,
     ]
 
     # Hide images many-to-many field from form. This would list all source images in the database.

ami/main/api/occurrence_history/serializers.py

@@ -109,6 +109,12 @@ class AlgorithmResultEntrySerializer(HistoryEntryBaseSerializer):
     classifications = CreatedClassificationSerializer(
         many=True, help_text="The classifications the run created, best score first."
     )
+    results_merged_in = serializers.IntegerField(
+        help_text=(
+            "Other results of the same run, brought onto this occurrence by merging occurrences. The entry "
+            "shows the newest result, with the classifications all of them created."
+        )
+    )
 
 
 HISTORY_ENTRY_SERIALIZERS = {

ami/main/api/occurrence_history/tests.py

@@ -106,13 +106,24 @@ def get(self, user: User | None = None):
         return response.data
 
     def _add_history(self, start: datetime.datetime, rounds: int = 1) -> None:
-        """Per round: a size filter result with the classification it created, and an identification."""
+        """Per round: a size filter result with the classification it created, and an identification.
+
+        The first result is ``self.job``'s; each later one comes from a run of its own with the same config,
+        since one run records one result per occurrence.
+        """
         for i in range(rounds):
             at = start + datetime.timedelta(hours=4 * i)
+            job = (
+                self.job
+                if not AlgorithmResult.objects.filter(job=self.job, occurrence=self.occurrence).exists()
+                else Job.objects.create(
+                    project=self.project, name=self.job.name, job_type_key="post_processing", params=self.job.params
+                )
+            )
             result = AlgorithmResult.objects.record(
                 occurrence=self.occurrence,
                 algorithm=self.size_filter,
-                job=self.job,
+                job=job,
                 kind=SIZE_FILTER,
                 value=0.001,
                 data={
@@ -128,7 +139,7 @@ def _add_history(self, start: datetime.datetime, rounds: int = 1) -> None:
                 score=0.1,
                 algorithm=self.size_filter,
                 timestamp=at,
-                job=self.job,
+                job=job,
                 algorithm_result=result,
             )
             identification = Identification.objects.create(
@@ -426,6 +437,54 @@ def test_predictions_carry_the_job_that_wrote_them(self):
         self.assertTrue(predictions)
         self.assertTrue(all(e.job == self.job for e in predictions))
 
+    def test_results_of_one_run_on_merged_occurrences_show_as_one_entry(self):
+        """A merge brings the absorbed occurrences' results along, so one run can hold several on the kept one.
+
+        They show as the newest result with every classification the run created, and a count of the rest;
+        a result of another run, and one with no job, stay entries of their own.
+        """
+        now = datetime.datetime.now() - datetime.timedelta(days=1)
+        other_job = Job.objects.create(
+            project=self.project, name="Second run", job_type_key="post_processing", params=self.job.params
+        )
+        rows = []
+        for job, detection, hours in (
+            (self.job, self.detections[0], 3),
+            (self.job, self.detections[1], 2),
+            (self.job, self.detections[2], 1),
+            (other_job, self.detections[3], 4),
+            (None, self.detections[3], 5),
+        ):
+            at = now - datetime.timedelta(hours=hours)
+            result = AlgorithmResult.objects.record(
+                occurrence=self.occurrence,
+                algorithm=self.size_filter,
+                job=job,
+                kind=SIZE_FILTER,
+                data={"relative_size": 0.001 * hours},
+                timestamp=at,
+            )
+            Classification.objects.create(
+                detection=detection,
+                taxon=self.taxon,
+                score=0.1,
+                algorithm=self.size_filter,
+                timestamp=at,
+                job=job,
+                algorithm_result=result,
+            )
+            rows.append(result)
+
+        entries = [e for e in self.get() if e["type"] == "algorithm_result"]
+
+        self.assertEqual([e["id"] for e in entries], [rows[2].pk, rows[3].pk, rows[4].pk])
+        newest = entries[0]
+        self.assertEqual(newest["results_merged_in"], 2)
+        self.assertEqual(
+            sorted(c["detection_id"] for c in newest["classifications"]), sorted(d.pk for d in self.detections[:3])
+        )
+        self.assertEqual([e["results_merged_in"] for e in entries[1:]], [0, 0])
+
     def test_a_result_without_a_job_has_no_config(self):
         AlgorithmResult.objects.record(
             occurrence=self.occurrence,

ami/main/api/occurrence_history/timeline.py

@@ -52,6 +52,8 @@ class OccurrenceTimelineEntry:
     determination_before: Taxon | None = None
     determination_after: Taxon | None = None
     classifications: list[CreatedClassification] = dataclasses.field(default_factory=list)
+    # Other results of the same run, brought here by merging occurrences; see ``_one_entry_per_run``.
+    results_merged_in: int = 0
     # --- Identification and prediction
     details: dict = dataclasses.field(default_factory=dict)
 
@@ -77,22 +79,31 @@ def occurrence_timeline(occurrence: Occurrence) -> list[OccurrenceTimelineEntry]
     )
     created_by_result = _classifications_created_by(results, occurrence)
     created_ids = {c.classification.pk for created in created_by_result.values() for c in created}
-    entries = [
-        OccurrenceTimelineEntry(
-            type="algorithm_result",
-            id=result.pk,
-            timestamp=result.timestamp,
-            algorithm=result.algorithm,
-            job=result.job,
-            value=result.value,
-            kind=result.kind,
-            data=result.data,
-            determination_before=taxa.get(result.data.get("determination_before_id")),
-            determination_after=taxa.get(result.data.get("determination_after_id")),
-            classifications=created_by_result.get(result.pk, []),
+    entries = []
+    for result, merged_in in _one_entry_per_run(results):
+        classifications = [c for r in (result, *merged_in) for c in created_by_result.get(r.pk, [])]
+        if merged_in:
+            # Best score first, as for one result's classifications.
+            classifications.sort(
+                key=lambda c: (c.classification.score is not None, c.classification.score or 0, c.classification.pk),
+                reverse=True,
+            )
+        entries.append(
+            OccurrenceTimelineEntry(
+                type="algorithm_result",
+                id=result.pk,
+                timestamp=result.timestamp,
+                algorithm=result.algorithm,
+                job=result.job,
+                value=result.value,
+                kind=result.kind,
+                data=result.data,
+                determination_before=taxa.get(result.data.get("determination_before_id")),
+                determination_after=taxa.get(result.data.get("determination_after_id")),
+                classifications=classifications,
+                results_merged_in=len(merged_in),
+            )
         )
-        for result in results
-    ]
 
     identifications = Identification.objects.filter(occurrence=occurrence).select_related("user", "taxon")
     entries.extend(
@@ -133,6 +144,25 @@ def occurrence_timeline(occurrence: Occurrence) -> list[OccurrenceTimelineEntry]
     return entries
 
 
+def _one_entry_per_run(results: list[AlgorithmResult]) -> list[tuple[AlgorithmResult, list[AlgorithmResult]]]:
+    """Each run's newest result on the occurrence, with its other results there, keeping the results' order.
+
+    A run records one result per occurrence, so more than one of a job, kind and algorithm means merged
+    occurrences brought theirs along. They show as one entry until results can name detections (#1412).
+    The entry carries the newest result's figures and determination, which may describe an absorbed
+    occurrence, so the card shows only the count and the classifications of such an entry. A result with
+    no job is its own entry.
+    """
+    runs: dict[tuple, tuple[AlgorithmResult, list[AlgorithmResult]]] = {}
+    for result in results:
+        key = (result.job_id, result.kind, result.algorithm_id) if result.job_id is not None else ("result", result.pk)
+        if key in runs:
+            runs[key][1].append(result)
+        else:
+            runs[key] = (result, [])
+    return list(runs.values())
+
+
 def _by_id(model, ids: set) -> dict:
     ids.discard(None)
     return {row.pk: row for row in model.objects.filter(pk__in=ids)} if ids else {}

ami/main/migrations/0100_detection_next_detection.py

@@ -0,0 +1,45 @@
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    """Add the column that links a detection to the one that follows it in a tracking sequence.
+
+    Django would add this column together with a unique constraint and a foreign key in one
+    statement, which takes a lock on the large detection table that blocks reads while the
+    unique index is built. Here the column is added on its own: a nullable column without a
+    default is a catalogue change that does not scan the table. Migration 0101 adds the unique
+    constraint and the foreign key afterwards without blocking readers or writers.
+    """
+
+    dependencies = [
+        ("main", "0099_classification_algorithm_result_index"),
+    ]
+
+    operations = [
+        # Adding the column takes a brief exclusive lock. Give up rather than queue behind a long query on
+        # the table, which would block every other query until it ends; rerun the migration if it gives up.
+        migrations.RunSQL(sql="SET LOCAL lock_timeout = '10s';", reverse_sql=migrations.RunSQL.noop),
+        migrations.SeparateDatabaseAndState(
+            state_operations=[
+                migrations.AddField(
+                    model_name="detection",
+                    name="next_detection",
+                    field=models.OneToOneField(
+                        blank=True,
+                        help_text="The detection that follows this one in the tracking sequence.",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="previous_detection",
+                        to="main.detection",
+                    ),
+                ),
+            ],
+            database_operations=[
+                migrations.RunSQL(
+                    sql='ALTER TABLE "main_detection" ADD COLUMN "next_detection_id" bigint NULL;',
+                    reverse_sql='ALTER TABLE "main_detection" DROP COLUMN "next_detection_id";',
+                ),
+            ],
+        ),
+    ]

ami/main/migrations/0101_detection_next_detection_constraints.py

@@ -0,0 +1,72 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    """Give ``Detection.next_detection`` the unique constraint and foreign key that Django would have created.
+
+    Both are built so that neither blocks reads or writes on the large detection table. The
+    unique index is built CONCURRENTLY, which needs a non-atomic migration, and is then attached
+    as a constraint, which is a catalogue change. The foreign key is added NOT VALID, so existing
+    rows are not checked while a strong lock is held, and validated afterwards, which takes only a
+    light lock. See 0093 for why the statement timeout is cleared and restored around the build.
+
+    The constraint names match the ones Django generates, so later AlterField migrations find them.
+    If the index build is interrupted it leaves an invalid index of the same name, and if a lock times out the
+    index already exists; drop it before retrying.
+    """
+
+    atomic = False
+
+    dependencies = [
+        ("main", "0100_detection_next_detection"),
+    ]
+
+    operations = [
+        migrations.RunSQL(
+            sql="SET statement_timeout = 0;",
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+        migrations.RunSQL(
+            sql=(
+                'CREATE UNIQUE INDEX CONCURRENTLY "main_detection_next_detection_id_key" '
+                'ON "main_detection" ("next_detection_id");'
+            ),
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+        # The two ALTER TABLE statements below take brief strong locks. Give up rather than queue behind a long
+        # query on the table, which would block every other query until it ends.
+        migrations.RunSQL(sql="SET lock_timeout = '10s';", reverse_sql=migrations.RunSQL.noop),
+        migrations.RunSQL(
+            sql=(
+                'ALTER TABLE "main_detection" ADD CONSTRAINT "main_detection_next_detection_id_key" '
+                'UNIQUE USING INDEX "main_detection_next_detection_id_key";'
+            ),
+            reverse_sql='ALTER TABLE "main_detection" DROP CONSTRAINT "main_detection_next_detection_id_key";',
+        ),
+        migrations.RunSQL(
+            sql=(
+                'ALTER TABLE "main_detection" ADD CONSTRAINT "main_detection_next_detection_id_f0201e13_fk_main_detection_id" '
+                'FOREIGN KEY ("next_detection_id") REFERENCES "main_detection" ("id") '
+                "DEFERRABLE INITIALLY DEFERRED NOT VALID;"
+            ),
+            reverse_sql=(
+                'ALTER TABLE "main_detection" '
+                'DROP CONSTRAINT "main_detection_next_detection_id_f0201e13_fk_main_detection_id";'
+            ),
+        ),
+        migrations.RunSQL(
+            sql=(
+                'ALTER TABLE "main_detection" VALIDATE CONSTRAINT '
+                '"main_detection_next_detection_id_f0201e13_fk_main_detection_id";'
+            ),
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+        migrations.RunSQL(
+            sql="RESET lock_timeout;",
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+        migrations.RunSQL(
+            sql="RESET statement_timeout;",
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+    ]