Removed GroupedPageFilter

Author: anti-social

elasticmagic/ext/queryfilter/__init__.py

@@ -2,6 +2,6 @@
 from .queryfilter import FacetQueryFilter, FacetQueryValue
 from .queryfilter import SimpleFilter, SimpleQueryFilter, SimpleQueryValue
 from .queryfilter import OrderingFilter, OrderingValue
-from .queryfilter import GroupedPageFilter, PageFilter
+from .queryfilter import PageFilter
 from .queryfilter import NestedFacetFilter, NestedRangeFilter
 from .queryfilter import BinaryFilter

elasticmagic/ext/queryfilter/queryfilter.py

@@ -1123,199 +1123,6 @@ def __init__(
         self.has_next = self.page < self.pages
 
 
-class GroupedPageFilter(PageFilter):
-    DEFAULT_MAX_ITEMS = 1000
-
-    def __init__(
-            self, name, group_by, group_kwargs=None, alias=None,
-            per_page_param=None, per_page_values=None, max_items=None,
-    ):
-        super(GroupedPageFilter, self).__init__(
-            name, alias=alias,
-            per_page_param=per_page_param,
-            per_page_values=per_page_values,
-            max_items=max_items,
-        )
-        self.group_by = group_by
-        self.group_kwargs = group_kwargs or {}
-
-    @property
-    def _agg_name(self):
-        return '{}.{}'.format(self.qf._name, self.name)
-
-    @property
-    def _filter_agg_name(self):
-        return '{}.filter'.format(self._agg_name)
-
-    @property
-    def _pagination_agg_name(self):
-        return '{}.pagination'.format(self._agg_name)
-
-    _top_hits_agg_name = 'top_items'
-
-    def _order_agg_name(self, ix):
-        return 'order_{}'.format(ix)
-
-    def _apply_filter(self, search_query, params):
-        self.per_page = self._get_per_page(params)
-        self.page = self._get_page(params)
-
-        return search_query
-
-    def _extract_orders(self, search_query):
-        order_aggs = {}
-        order_by = []
-        if search_query._order_by:
-            for i, o in enumerate(search_query._order_by):
-                order_name = self._order_agg_name(i)
-                if isinstance(o, Sort):
-                    expr = o.expr
-                    order = o.order
-                else:
-                    expr = o
-                    order = None
-
-                if isinstance(expr, Field):
-                    field_name = expr.get_name()
-                elif isinstance(expr, AttributedField):
-                    field_name = expr.get_field_name()
-                else:
-                    field_name = expr
-
-                if field_name == '_score':
-                    # default ordering for _score is desc
-                    desc = order is None or order == 'desc'
-                else:
-                    desc = order == 'desc'
-
-                if desc:
-                    if field_name == '_score':
-                        order_aggs[order_name] = agg.Max(script='_score')
-                    else:
-                        order_aggs[order_name] = agg.Max(expr)
-                    order_by.append({order_name: 'desc'})
-                else:
-                    if field_name == '_score':
-                        order_aggs[order_name] = agg.Min(script='_score')
-                    else:
-                        order_aggs[order_name] = agg.Min(expr)
-                    order_by.append({order_name: 'asc'})
-        else:
-            order_aggs = {
-                self._order_agg_name(0): agg.Max(script='_score')
-            }
-            order_by = [{self._order_agg_name(0): 'desc'}]
-
-        return order_aggs, order_by
-
-    def _apply_agg(self, search_query):
-        order_aggs, order_by = self._extract_orders(search_query)
-
-        group_agg = agg.Terms(
-            self.group_by,
-            size=self.per_page,
-            order=order_by,
-            aggs=dict(
-                {self._top_hits_agg_name: agg.TopHits(**self.group_kwargs)},
-                **order_aggs
-            )
-        )
-
-        pagination_agg = agg.Terms(
-            self.group_by,
-            size=self.max_items,
-            order=order_by,
-            aggs=order_aggs,
-        )
-
-        post_filters = list(search_query.get_context().iter_post_filters())
-
-        if self.page == 1:
-            page_aggs = {
-                self._agg_name: group_agg,
-                self._pagination_agg_name: pagination_agg,
-            }
-        else:
-            group_values = self._get_group_values(search_query, post_filters, pagination_agg)
-            post_filters.append(self.group_by.in_(group_values))
-            page_aggs={
-                self._agg_name: group_agg,
-            }
-
-        if post_filters:
-            aggs = {
-                self._filter_agg_name: agg.Filter(
-                    Bool.must(*post_filters),
-                    aggs=page_aggs
-                )
-            }
-        else:
-            aggs = page_aggs
-
-        search_query = search_query.aggs(aggs)
-
-        return search_query
-
-    def _get_group_values(self, search_query, post_filters, pagination_agg):
-        if post_filters:
-            aggs = {
-                self._filter_agg_name: agg.Filter(
-                    Bool.must(*post_filters),
-                    aggs={self._pagination_agg_name: pagination_agg}
-                )
-            }
-        else:
-            aggs = {self._pagination_agg_name: pagination_agg}
-
-        sq = (
-            search_query
-            .with_search_type('count')
-            .aggs(None)
-            .aggs(**aggs)
-        )
-
-        pagination_agg_res = self._get_pagination_agg_result(sq.result)
-        self._process_pagination_agg(pagination_agg_res)
-        values = [
-            group_bucket.key for group_bucket in pagination_agg_res.buckets
-        ]
-
-        offset = self._get_offset()
-        return values[offset:offset + self.per_page]
-
-    def _get_offset(self):
-        return (self.page - 1) * self.per_page
-
-    def _get_pagination_agg_result(self, result):
-        filter_agg = result.get_aggregation(self._filter_agg_name)
-        if filter_agg:
-            return filter_agg.get_aggregation(self._pagination_agg_name)
-        return result.get_aggregation(self._pagination_agg_name)
-
-    def _get_groups_agg_result(self, result):
-        filter_agg = result.get_aggregation(self._filter_agg_name)
-        if filter_agg:
-            return filter_agg.get_aggregation(self._agg_name)
-        return result.get_aggregation(self._agg_name)
-
-    def _process_result(self, result, params):
-        pagination_agg = self._get_pagination_agg_result(result)
-        if pagination_agg:
-            total = len(pagination_agg.buckets)
-        else:
-            total = 0
-
-        groups_agg = self._get_groups_agg_result(result)
-        items = groups_agg.buckets
-        return PageFilterResult(
-            total=total, hits=items, page=self.page,
-            per_page_param=self.per_page_param,
-            per_page=self.per_page,
-            per_page_values=self.per_page_values,
-            max_items=self.max_items,
-        )
-
-
 class NestedFacetFilter(BaseFilter):
 
     def __init__(