Why view_shortcuts.filters, not django.contrib.admin.filterspecs?

- ordinary views, not only admin

- lookups mapped to params --> security

- no pre-generated html --> valid, flexible

- QuerySet in, QuerySet out: can pre- and post-filter

- choices with respect to existing QuerySet

What's good in filterspecs (included here now, too):

- factory with simple tests

  - enables field-specific behaviour

  - easily extendable with custom filterspecs

TODO:

- more filters:

  - alphabetic

  - date drilldown

  - date fadeout

  - range selection

- add ability to enforce a filter when creating a FilterList

  (e.g. date drilldown/fadeout have to pass the same test and, therefore,

  the one which is declared earlier will be chosen automatically; this makes

  no sense and developer should be able to choose the field manually.)

import warnings

from django.db import models

from django.utils.translation import ugettext_lazy as _

    warnings.warn("filter_field() is deprecated, use FilterList() instead.",

                  DeprecationWarning, 2)

    warnings.warn("filter_param() is deprecated, use FilterList() instead.",

                  DeprecationWarning, 2)

                    lookup, param = p

                    lookup = param = p

                f = Filter.create(param, qs=qs, lookup=lookup, active=False, sort_by_usage=sort_by_usage)

            (filter.lookup, filter.value) for filter in self.active

    Each filter subclass knows how to display a filter for a field that passes a

    certain test -- e.g. being a DateField or ForeignKey.

    filter_specs = []

    def __init__(self, param, qs, lookup, field, active, value, sort_by_usage):

        self.lookup = lookup

    def __repr__(self):

        return u'<%s "%s": %s>' % (self.__class__.__name__, self.param, self.active)

    @classmethod

    def register(cls, test, factory):

        cls.filter_specs.append((test, factory))

    @classmethod

    def create(cls, param, qs=None, lookup=None, active=False, value=None, sort_by_usage=True):

        fn = lookup.split('__')[0]  # we need the "author" part of "author__pk"

        field = qs.model._meta.get_field(fn)

        for test, factory in cls.filter_specs:

            if test(field):

                return factory(param, qs, lookup, field, active, value, sort_by_usage)

    def extra_title(self):

        """Filter subclasses may overload this method to provide extra sources

        for filter title; they will only be used if no verbose name is specified

        in current model's field definition.

        """

        return None

        return unicode(self.field.verbose_name or self.extra_title())

    def generate_choices(self):

        raise NotImplementedError

        return list(self.generate_choices())

    def _annotate(self, choices, by='pk'):

        """Counts related objects for each choice in given queryset (i.e. discover

        how popular is each option). Returns annotated queryset.

        """

        # 

        choices = choices.annotate(items_count=models.Count(by))

        if self.sort_by_usage:

            choices = choices.order_by('-items_count')

        return choices

class RelationFilter(Filter):

    def extra_title(self):

        if isinstance(self.field, models.ManyToManyField):

            return self.field.rel.to._meta.verbose_name

    def generate_choices(self):

        # TODO: when multiple filters are active, count only intersections (? - can be heavy)

        related_name = getattr(self.field.rel, 'related_name', None) or \

                self.qs.model._meta.module_name

        # get all possible choices

        choices = self.field.rel.to.objects

        # apply constraints from field definition

        choices = choices.filter(**self.field.rel.limit_choices_to)

        # get intersection with current queryset

        choices = choices.filter(**{'%s__in' % related_name: self.qs })

        # count usage

        choices = self._annotate(choices, by=related_name)

        for c in choices:

            yield FilterChoice(self, unicode(c), c.pk, c.items_count)

Filter.register(lambda f: f.rel, RelationFilter)

'''

class DateFadeoutFilter(Filter):

    "Represents dates as single-level categories by remoteness from now."

    # see django.contrib.admin.filterspecs.DateFieldFilterSpec

    pass

Filter.register(lambda f: isinstance(f, models.DateField), DateDrilldownFilter)

class DateDrilldownFilter(Filter):

    "Represents dates as nested levels for year, month and day."

    pass

Filter.register(lambda f: isinstance(f, models.DateField), DateDrilldownFilter)

'''

class BooleanFilter(Filter):

    def generate_choices(self):

        # retrieve unique values and count how many times each is used

        choices = self.qs.values(self.lookup).distinct()

        choices = self._annotate(choices)

        bool_choices = (

            ('True',  _('yes')),

            ('False', _('no')),

        )

        for val,name in bool_choices:

            for c in choices:

                v = unicode(c.get(self.lookup))

                if v == val:

                    yield FilterChoice(self, name, val, c['items_count'])

Filter.register(lambda f: isinstance(f, models.BooleanField), BooleanFilter)

class AllValuesFilter(Filter):

    def generate_choices(self):

        # retrieve unique values and count how many times each is used

        choices = self.qs.values(self.lookup).distinct()

        choices = self._annotate(choices)

        # if list of choices is explicitly defined, exclude choices that

        # are not in this list (e.g. if the list was added post factum)

        if self.field.choices:

            explicit_values = [ c[0] for c in self.field.choices ]

            choices = choices.filter(**{'%s__in' % self.lookup: explicit_values})

        # choice title is its value unless the label is explicitly defined

        _value = lambda c: unicode(c.get(self.lookup))

        _title = lambda c: self.field.choices and \

                        dict(self.field.choices).get(c.get(self.lookup)) or _value(c)

        for c in choices:

            yield FilterChoice(self, _title(c), _value(c), c['items_count'])

Filter.register(lambda f: True, AllValuesFilter)

>>> s1 = Story(title='s1', text='test', status=Story.PUBLISHED, paid=True)

>>> s2 = Story(title='s2', text='test', status=Story.PUBLISHED, paid=False)

>>> s3 = Story(title='s3', text='test', status=Story.DRAFT, paid=True)

>>> params = ('category', 'author', 'status', 'paid')

4

[<RelationFilter "category": False>, <RelationFilter "author": False>, <AllValuesFilter "status": False>, <BooleanFilter "paid": False>]

[<RelationFilter "category": False>, <RelationFilter "author": True>, <AllValuesFilter "status": False>, <BooleanFilter "paid": False>]

[<RelationFilter "author": True>]

[<RelationFilter "author": True>, <AllValuesFilter "status": True>]

[<RelationFilter "category": False>, <RelationFilter "author": True>, <AllValuesFilter "status": True>, <BooleanFilter "paid": False>]

<RelationFilter "author": True>

...         print u'    - %s (%s) --> [%s]' % (c.title, c.items_count, c.urlencode)

Paid:   [paid=None]

    - yes (2) --> [paid=True]

    - no (1) --> [paid=False]

...         print u'    - %s (%s) --> [%s]' % (c.title, c.items_count, c.urlencode)

Paid:   [paid=None]

    - yes (1) --> [paid=True]

    - no (1) --> [paid=False]

from django.db.models import BooleanField, CharField, ForeignKey, IntegerField, \

    paid     = BooleanField(_('Paid'))