Add FilterSet subsetting, re-add caching

- FilterSet subsetting reduces the cost of initialization by limiting
  the base_fields of the subclass. This reduces `deepcopy` overhead.
- Added back caching. It now occurs at the class level instead of the
  instance level, which should help prevent race conditions.

Author: Ryan P Kilby

rest_framework_filters/backends.py

@@ -5,3 +5,13 @@
 
 class DjangoFilterBackend(rest_framework.filters.DjangoFilterBackend):
     default_filter_set = FilterSet
+    _related_filterset_cache = {}  # set to None to disable cache propagation
+
+    def filter_queryset(self, request, queryset, view):
+        filter_class = self.get_filter_class(view, queryset)
+
+        if filter_class:
+            cache = self._related_filterset_cache
+            return filter_class(request.query_params, queryset=queryset, cache=cache).qs
+
+        return queryset

rest_framework_filters/filters.py

@@ -1,6 +1,7 @@
 from __future__ import absolute_import
 from __future__ import unicode_literals
 
+from collections import OrderedDict
 from django.utils import six
 
 from rest_framework.settings import api_settings
@@ -63,6 +64,27 @@ def fset(self, value):
         return locals()
     filterset = property(**filterset())
 
+    def get_filterset_subset(self, filter_names):
+        """
+        Returns a FilterSet subclass that contains the subset of filters
+        specified in `filter_names`. This is useful for creating FilterSets
+        used across relationships, as it minimizes the deepcopy overhead
+        incurred when instantiating the FilterSet.
+        """
+        BaseFilterSet = self.filterset
+
+        class FilterSetSubset(BaseFilterSet):
+            pass
+
+        FilterSetSubset.__name__ = str('%sSubset' % (BaseFilterSet.__name__))
+        FilterSetSubset.base_filters = OrderedDict([
+            (name, f)
+            for name, f in six.iteritems(BaseFilterSet.base_filters)
+            if name in filter_names
+        ])
+
+        return FilterSetSubset
+
     def setup_filterset(self):
         self.extra['queryset'] = self.filterset._meta.model.objects.all()
 

rest_framework_filters/filterset.py

@@ -69,6 +69,8 @@ class FilterSet(six.with_metaclass(FilterSetMetaclass, filterset.FilterSet)):
     }
 
     def __init__(self, *args, **kwargs):
+        self._related_filterset_cache = kwargs.pop('cache', {})
+
         super(FilterSet, self).__init__(*args, **kwargs)
 
         for name, filter_ in six.iteritems(self.filters):
@@ -86,14 +88,14 @@ def get_filters(self):
         """
         requested_filters = OrderedDict()
 
-        # filter out any filters not included in the request data
+        # Add plain lookup filters if match. ie, `username__icontains`
         for filter_key, filter_value in six.iteritems(self.filters):
             if filter_key in self.data:
                 requested_filters[filter_key] = filter_value
 
-        # build a map of potential {rel: [filter]} pairs
+        # build a map of potential {rel: {filter: value}} data
         related_data = OrderedDict()
-        for filter_key in self.data:
+        for filter_key, value in six.iteritems(self.data):
             if filter_key not in self.filters:
 
                 # skip non lookup/related keys
@@ -102,28 +104,66 @@ def get_filters(self):
 
                 rel_name, filter_key = filter_key.split(LOOKUP_SEP, 1)
 
-                related_data.setdefault(rel_name, [])
-                related_data[rel_name].append(filter_key)
+                related_data.setdefault(rel_name, OrderedDict())
+                related_data[rel_name][filter_key] = value
 
-        # walk the related lookup data. If the rel is a RelatedFilter,
-        # then instantiate its filterset and append its filters
+        # walk the related lookup data. If the filter is a RelatedFilter,
+        # then instantiate its filterset and append its filters.
         for rel_name, rel_data in related_data.items():
             related_filter = self.filters.get(rel_name, None)
 
             # skip non-`RelatedFilter`s
             if not isinstance(related_filter, filters.RelatedFilter):
                 continue
 
-            filterset = related_filter.filterset(data=rel_data)
-            rel_filters = filterset.get_filters()
+            # get known filter names
+            filterset_class = related_filter.filterset
+            filter_names = [filterset_class.get_filter_name(param) for param in rel_data.keys()]
+
+            # attempt to retrieve related filterset subset from the cache
+            key = self.cache_key(filterset_class, filter_names)
+            subset_class = self.cache_get(key)
+
+            # otherwise build and insert it into the cache
+            if subset_class is None:
+                subset_class = related_filter.get_filterset_subset(filter_names)
+                self.cache_set(key, subset_class)
 
+            # initialize and copy filters
+            filterset = subset_class(data=rel_data)
+            rel_filters = filterset.get_filters()
             for filter_key, filter_value in six.iteritems(rel_filters):
+                # modify filter name to account for relationship
                 rel_filter_key = LOOKUP_SEP.join([rel_name, filter_key])
                 filter_value.name = LOOKUP_SEP.join([related_filter.name, filter_value.name])
                 requested_filters[rel_filter_key] = filter_value
 
         return requested_filters
 
+    @classmethod
+    def get_filter_name(cls, param):
+        """
+        Get the filter name for the request data parameter.
+        """
+        # Attempt to match against filters with lookups first. (username__endswith)
+        if param in cls.base_filters:
+            return param
+
+        # Fallback to matching against relationships. (author__username__endswith)
+        param = param.split(LOOKUP_SEP, 1)[0]
+        f = cls.base_filters.get(param, None)
+        if isinstance(f, filters.RelatedFilter):
+            return param
+
+    def cache_key(self, filterset, filter_names):
+        return '%sSubset-%s' % (filterset.__name__, '-'.join(sorted(filter_names)), )
+
+    def cache_get(self, key):
+        return self._related_filterset_cache.get(key)
+
+    def cache_set(self, key, value):
+        self._related_filterset_cache[key] = value
+
     @property
     def qs(self):
         available_filters = self.filters

rest_framework_filters/tests.py

@@ -669,3 +669,14 @@ def test_inset_filter(self):
         self.assertEqual(len(f), 2)
         self.assertIn(p1, f)
         self.assertIn(p2, f)
+
+    def test_get_filterset_subset(self):
+        related_filter = NoteFilterWithRelated.base_filters['author']
+        filterset_class = related_filter.get_filterset_subset(['email'])
+
+        # ensure that the class name is useful when debugging
+        self.assertEqual(filterset_class.__name__, 'UserFilterSubset')
+
+        # ensure that the FilterSet subset only contains the requested fields
+        self.assertIn('email', filterset_class.base_filters)
+        self.assertEqual(len(filterset_class.base_filters), 1)