Mauricio Mauricio - 1 year ago 164
Python Question

Django filter with OR condition using dict argument

I have a function on my Django app where I perform some Queryset actions and set it's result to Memcache. Since it's function it has to be of general usage. So in order to make it reusable I pass a dict as parameter for

actions. This is the function:

def cached_query(key, model, my_filter=None, exclude=None, order_by=None, sliced=50):
:param key: string used as key reference to store on Memcached
:param model: model reference on which 'filter' will be called
:param my_filter: dictionary containing the filter parameters (eg.: {'title': 'foo', 'category': 'bar'}
:param sliced: integer limit of results from the query. The lower the better, since for some reason Django Memcached
won't store thousands of entries in memory
:param exclude: dictionary containing the exclude parameters (eg.: {'title': 'foo', 'category': 'bar'}
:param order_by: tuple containing the list of fields upon which the model will be ordered.
:return: list of models. Not a QuerySet, since it was sliced.
result = cache.get(key, None)
if not result:
if my_filter:
result = model.objects.filter(**my_filter)
if exclude:
result = result.exclude(**exclude)
if order_by:
result = result.order_by(*order_by)
result = model.objects.all()
result = result[:sliced]
cache.set(key, result, cache_timeout)
return result

It works pretty fine if I filter the queryset with a simple dict like
{'title': 'foo', 'name': 'bar'}
. However that won't be always the case. I need to perform filters using the
utility for more complex queries which require

So, how can I pass these parameters as a dictionary on a filter. Is there any approach for this?


You can restructure your dictionary into a list of single key-value dictionaries and use unpacking on each dict inside the Q expression like so:

from functools import reduce
import operator

from django.db.models import Q

# your dict is my_filter
q = model.objects.filter(reduce(operator.or_, 
                                (Q(**d) for d in [dict([i]) for i in my_filter.items()])))

reduce on or_ joins the Q expressions on an OR.

You could also use a generator expression where you have the list of dicts:

q = model.objects.filter(reduce(operator.or_, 
                                (Q(**d) for d in (dict([i]) for i in my_filter.items()))))