feat: add project default taxa filter to OccurrenceViewSet, TaxonViewSet, SourceImageViewSet, and SummaryView

Author: mohamedelabbas1996

ami/main/api/views.py

@@ -494,9 +494,9 @@ def get_queryset(self) -> QuerySet:
 
         classification_threshold = get_default_classification_threshold(project, self.request)
         queryset = queryset.with_occurrences_count(  # type: ignore
-            classification_threshold=classification_threshold
+            classification_threshold=classification_threshold, project=project
         ).with_taxa_count(  # type: ignore
-            classification_threshold=classification_threshold
+            classification_threshold=classification_threshold, project=project
         )
 
         queryset.select_related(
@@ -1109,6 +1109,7 @@ def get_queryset(self) -> QuerySet["Occurrence"]:
         qs = qs.with_detections_count().with_timestamps()  # type: ignore
         qs = qs.with_identifications()  # type: ignore
         qs = qs.filter_by_score_threshold(project, self.request)  # type: ignore
+        qs = qs.filter_by_project_default_taxa(project, self.request)  # type: ignore
         if self.action != "list":
             qs = qs.prefetch_related(
                 Prefetch(
@@ -1340,6 +1341,8 @@ def get_queryset(self) -> QuerySet:
         qs = self.attach_tags_by_project(qs, project)
 
         if project:
+            # Filter by project default taxa
+            qs = qs.filter_by_project_default_taxa(project, self.request)  # type: ignore
             # Allow showing detail views for unobserved taxa
             include_unobserved = True
             if self.action == "list":
@@ -1349,12 +1352,12 @@ def get_queryset(self) -> QuerySet:
                 qs = qs.prefetch_related(
                     Prefetch(
                         "occurrences",
-                        queryset=Occurrence.objects.filter_by_score_threshold(project, self.request).filter(
-                            self.get_occurrence_filters(project)
-                        )[:1],
+                        queryset=Occurrence.objects.filter_by_score_threshold(  # type: ignore
+                            project, self.request
+                        ).filter(self.get_occurrence_filters(project))[:1],
                         to_attr="example_occurrences",
                     )
-                )  # type: ignore
+                )
         else:
             # Add empty occurrences list to make the response consistent
             qs = qs.annotate(example_occurrences=models.Value([], output_field=models.JSONField()))
@@ -1551,10 +1554,12 @@ def get(self, request):
                 "captures_count": SourceImage.objects.filter(deployment__project=project).count(),
                 # "detections_count": Detection.objects.filter(occurrence__project=project).count(),
                 "occurrences_count": Occurrence.objects.filter_by_score_threshold(project, self.request)
+                .filter_by_project_default_taxa(project, self.request)
                 .valid()
                 .filter(project=project)
                 .count(),  # type: ignore
                 "taxa_count": Occurrence.objects.filter_by_score_threshold(project, self.request)
+                .filter_by_project_default_taxa(project, self.request)
                 .unique_taxa(project=project)
                 .count(),  # type: ignore
             }

ami/main/models.py

@@ -874,10 +874,57 @@ def save(self, update_calculated_fields=True, regroup_async=True, *args, **kwarg
                 # ami.tasks.model_task.delay("Project", self.project.pk, "update_children_project")
 
 
+class EventQuerySet(models.QuerySet):
+    def with_taxa_count(self, project: Project | None = None, request: Request | None = None):
+        """
+        Annotate each event with the number of distinct taxa observed,
+        filtered by classification threshold and the project's default
+        include/exclude taxa settings.
+        """
+        if project is None:
+            return self
+
+        classification_threshold = get_default_classification_threshold(project, request)
+
+        # Start with a base filter for classification score
+        filter_q = models.Q(
+            occurrences__determination_score__gte=classification_threshold,
+        )
+
+        # Apply include/exclude taxa from project defaults
+        include_taxa = project.default_filters_include_taxa.all()
+        exclude_taxa = project.default_filters_exclude_taxa.all()
+
+        if include_taxa.exists():
+            include_filter = models.Q(occurrences__determination__in=include_taxa)
+            for taxon in include_taxa:
+                include_filter |= models.Q(occurrences__determination__parents_json__contains=[{"id": taxon.pk}])
+            filter_q &= include_filter
+
+        if exclude_taxa.exists():
+            exclude_filter = models.Q(occurrences__determination__in=exclude_taxa)
+            for taxon in exclude_taxa:
+                exclude_filter |= models.Q(occurrences__determination__parents_json__contains=[{"id": taxon.pk}])
+            filter_q &= ~exclude_filter
+
+        return self.annotate(
+            taxa_count=models.Count(
+                "occurrences__determination",
+                distinct=True,
+                filter=filter_q,
+            )
+        )
+
+
+class EventManager(models.Manager.from_queryset(EventQuerySet)):
+    pass
+
+
 @final
 class Event(BaseModel):
     """A monitoring session"""
 
+    objects: EventManager = EventManager()
     group_by = models.CharField(
         max_length=255,
         db_index=True,
@@ -1499,24 +1546,54 @@ def delete_source_image(sender, instance, **kwargs):
 
 
 class SourceImageQuerySet(models.QuerySet):
-    def with_occurrences_count(self, classification_threshold: float = 0):
+    def _build_default_taxa_filter(
+        self,
+        classification_threshold: float = 0,
+        project: Project | None = None,
+    ) -> Q:
+        """
+        Build a reusable Q filter that applies the classification threshold
+        and the project's default include/exclude taxa settings.
+        """
+        filter_q = Q(detections__occurrence__determination_score__gte=classification_threshold)
+
+        if not project:
+            return filter_q
+
+        include_taxa = project.default_filters_include_taxa.all()
+        exclude_taxa = project.default_filters_exclude_taxa.all()
+
+        if include_taxa.exists():
+            include_q = Q(detections__occurrence__determination__in=include_taxa)
+            for taxon in include_taxa:
+                include_q |= Q(detections__occurrence__determination__parents_json__contains=[{"id": taxon.pk}])
+            filter_q &= include_q
+
+        if exclude_taxa.exists():
+            exclude_q = Q(detections__occurrence__determination__in=exclude_taxa)
+            for taxon in exclude_taxa:
+                exclude_q |= Q(detections__occurrence__determination__parents_json__contains=[{"id": taxon.pk}])
+            filter_q &= ~exclude_q
+
+        return filter_q
+
+    def with_occurrences_count(self, classification_threshold: float = 0, project: Project | None = None):
+        filter_q = self._build_default_taxa_filter(classification_threshold, project)
         return self.annotate(
             occurrences_count=models.Count(
                 "detections__occurrence",
-                filter=models.Q(
-                    detections__occurrence__determination_score__gte=classification_threshold,
-                ),
+                filter=filter_q,
                 distinct=True,
             )
         )
 
-    def with_taxa_count(self, classification_threshold: float = 0):
+    def with_taxa_count(self, classification_threshold: float = 0, project: Project | None = None):
+        filter_q = self._build_default_taxa_filter(classification_threshold, project)
+
         return self.annotate(
             taxa_count=models.Count(
                 "detections__occurrence__determination",
-                filter=models.Q(
-                    detections__occurrence__determination_score__gte=classification_threshold,
-                ),
+                filter=filter_q,
                 distinct=True,
             )
         )
@@ -2466,6 +2543,33 @@ def filter_by_score_threshold(self, project: Project | None = None, request: Req
         score_threshold = get_default_classification_threshold(project, request)
         return self.filter(determination_score__gte=score_threshold)
 
+    def filter_by_project_default_taxa(self, project: Project | None = None, request: Request | None = None):
+        if project is None:
+            return self
+        if request is not None:
+            apply_defaults = request.query_params.get("apply_defaults", "true").lower()
+            if apply_defaults == "false":
+                return self
+        qs = self
+        include_taxa = project.default_filters_include_taxa.all()
+        exclude_taxa = project.default_filters_exclude_taxa.all()
+
+        include_filter = Q()
+        if include_taxa.exists():
+            include_filter = Q(determination__in=include_taxa)
+            for taxon in include_taxa:
+                include_filter |= Q(determination__parents_json__contains=[{"id": taxon.pk}])
+            qs = qs.filter(include_filter)
+
+        exclude_filter = Q()
+        if exclude_taxa.exists():
+            exclude_filter = Q(determination__in=exclude_taxa)
+            for taxon in exclude_taxa:
+                exclude_filter |= Q(determination__parents_json__contains=[{"id": taxon.pk}])
+            qs = qs.exclude(exclude_filter)
+
+        return qs
+
 
 class OccurrenceManager(models.Manager.from_queryset(OccurrenceQuerySet)):
     def get_queryset(self):
@@ -2732,6 +2836,33 @@ def with_occurrence_counts(self, project: Project):
 
         return qs.annotate(occurrence_count=models.Count("occurrences", distinct=True))
 
+    def filter_by_project_default_taxa(self, project: Project | None = None, request: Request | None = None):
+        """
+        Filter taxa according to a project's default include and exclude settings,
+        keeping taxa in the include set along with their descendants
+        and removing taxa in the exclude set along with their descendants.
+        """
+        if project is None:
+            return self
+
+        qs = self
+        include_taxa = project.default_filters_include_taxa.all()
+        exclude_taxa = project.default_filters_exclude_taxa.all()
+
+        if include_taxa.exists():
+            include_filter = Q(id__in=include_taxa)
+            for taxon in include_taxa:
+                include_filter |= Q(parents_json__contains=[{"id": taxon.pk}])
+            qs = qs.filter(include_filter)
+
+        if exclude_taxa.exists():
+            exclude_filter = Q(id__in=exclude_taxa)
+            for taxon in exclude_taxa:
+                exclude_filter |= Q(parents_json__contains=[{"id": taxon.pk}])
+            qs = qs.exclude(exclude_filter)
+
+        return qs
+
 
 @final
 class TaxonManager(models.Manager.from_queryset(TaxonQuerySet)):