Apply an include_ancestors toggle after all standard filters in a Django FilterSet

Run include_ancestors/with_parents last in django-filter: override FilterSet.qs to get the fully filtered queryset first, then conditionally add ancestors.

When a custom filter in django-filter needs to run after all standard fields, the usual method-based hook won’t help. A typical case is an include-ancestors toggle that must evaluate only after the base result set is known, for example after applying an is_archived constraint. Here’s how to structure the FilterSet so that the ancestors step runs last and only if requested.

Problem statement

The goal is to push the include_ancestors logic to the very end of filtering, because it depends on which records remained after all other filters were applied.

import django_filters
class NodeFilters(django_filters.FilterSet):
    model = CatalogItem
    fields = {
        "archived_flag": ("exact",),
    }
    with_parents = django_filters.BooleanFilter(method="with_parents_hook")
    def with_parents_hook(self, queryset, name, value):
        pass

The question is how to ensure the with_parents filter runs after archived_flag (and any other field filters) so it can work against the final result set.

Why this happens

Method-backed filters participate in the same filtering pipeline as any other field. If the ancestors step must be aware of the already filtered result, it shouldn’t be executed as a regular field filter within that pipeline. Instead, it has to be applied after the base queryset is produced.

Solution

Declare the toggle as a regular BooleanFilter without a method. Then override the qs property to first obtain the fully filtered queryset, and only then, if the toggle is present, apply the ancestors logic to that final queryset.

import django_filters
class NodeFilters(django_filters.FilterSet):
    with_parents = django_filters.BooleanFilter(required=False)
    class Meta:
        model = CatalogItem
        fields = {"archived_flag": ["exact"]}
    @property
    def qs(self):
        base_qs = super().qs
        if self.form.cleaned_data.get("with_parents"):
            base_qs = self._expand_with_parents(base_qs)
        return base_qs
    def _expand_with_parents(self, queryset):
        pass

This way the standard filters run first via super().qs. Only after that, if with_parents is truthy in the submitted parameters, the result is augmented by _expand_with_parents.

Why this matters

When a filter’s semantics depend on the outcome of other filters, timing is everything. Applying the ancestors step last ensures it operates on the correct, final selection, which is exactly what’s needed when inclusion depends on which children survived earlier constraints.

Takeaways

Use a non-method BooleanFilter for the toggle and move the conditional logic into the qs property. First pull the fully filtered queryset from super().qs, then apply the ancestors augmentation only if requested. This keeps your filtering predictable and lets the final step depend on the actual result set.