forked from rc/aircox
154 lines
4.1 KiB
Python
154 lines
4.1 KiB
Python
import operator
|
|
import itertools
|
|
import heapq
|
|
|
|
from django.utils.translation import ugettext as _, ugettext_lazy
|
|
from django.db.models.query import QuerySet
|
|
|
|
|
|
class QCombine:
|
|
"""
|
|
This class helps to combine querysets of different models and lists of
|
|
object, and to iter over it.
|
|
|
|
Notes:
|
|
- when working on fields, we assume that they exists on all of them;
|
|
- for efficiency, there is no possibility to change order per field;
|
|
to do so, do it directly on the querysets
|
|
- we dont clone the combinator in order to avoid overhead
|
|
"""
|
|
order_fields = None
|
|
lists = None
|
|
|
|
def __init__(self, *lists):
|
|
"""
|
|
lists: list of querysets that are used to initialize the stuff.
|
|
"""
|
|
self.lists = list(lists) or []
|
|
|
|
def map(self, qs_func, non_qs = None):
|
|
"""
|
|
Map results of qs_func for QuerySet instance and of non_qs for
|
|
the others (if given), because QuerySet always clones itself.
|
|
"""
|
|
for i, qs in enumerate(self.lists):
|
|
if issubclass(type(qs), QuerySet):
|
|
self.lists[i] = qs_func(qs)
|
|
elif non_qs:
|
|
self.lists[i] = non_qs(qs)
|
|
|
|
def all(self):
|
|
self.map(lambda qs: qs.all())
|
|
|
|
def filter(self, **kwargs):
|
|
self.map(lambda qs: qs.filter(**kwargs))
|
|
return self
|
|
|
|
def exclude(self, **kwargs):
|
|
self.map(lambda qs: qs.exclude(**kwargs))
|
|
return self
|
|
|
|
def distinct(self, **kwargs):
|
|
self.map(lambda qs: qs.distinct())
|
|
return self
|
|
|
|
def get(self, **kwargs):
|
|
self.filter(**kwargs)
|
|
it = iter(self)
|
|
return next(it)
|
|
|
|
def order_by(self, *fields, reverse = False):
|
|
"""
|
|
Order using these fields. For compatibility, if there is
|
|
at least one fields whose name starts with '-', reverse
|
|
the order
|
|
"""
|
|
for i, field in enumerate(fields):
|
|
if field[0] == '-':
|
|
reverse = True
|
|
fields[i] = field[1:]
|
|
|
|
self.order_reverse = reverse
|
|
self.order_fields = fields
|
|
self.map(
|
|
lambda qs: qs.order_by(*fields),
|
|
lambda qs: sorted(
|
|
qs,
|
|
qs.sort(
|
|
key = operator.attrgetter(*fields),
|
|
reverse = reverse
|
|
)
|
|
)
|
|
)
|
|
return self
|
|
|
|
def clone(self):
|
|
"""
|
|
Make a clone of the class. Not that lists are copied, non-deeply
|
|
"""
|
|
return QCombine(*[
|
|
qs.all() if issubclass(type(qs), QuerySet) else qs.copy()
|
|
for qs in self.lists
|
|
])
|
|
|
|
def __len__(self):
|
|
return sum([len(qs) for qs in self.lists])
|
|
|
|
def __iter__(self):
|
|
if not self.order_fields:
|
|
return itertools.chain(self.lists)
|
|
|
|
# FIXME: need it lazy?
|
|
return heapq.merge(
|
|
*self.lists,
|
|
key = operator.attrgetter(*self.order_fields),
|
|
reverse = self.order_reverse
|
|
)
|
|
|
|
def __getitem__(self, k):
|
|
if type(k) == slice:
|
|
it = itertools.islice(iter(self), k.start, k.stop, k.step)
|
|
else:
|
|
it = itertools.islice(iter(self), k)
|
|
return list(it)
|
|
|
|
|
|
class Manager(type):
|
|
"""
|
|
Metaclass used to generate the GenericModel.objects property
|
|
"""
|
|
models = []
|
|
|
|
@property
|
|
def objects(self):
|
|
qs = QCombine(*[model.objects.all() for model in self.models])
|
|
return qs
|
|
|
|
|
|
class GenericModel(metaclass=Manager):
|
|
"""
|
|
This class is used to register a route for multiple models to a website.
|
|
A QCombine is created with qs for all given models when objects
|
|
property is retrieved.
|
|
|
|
Note: there no other use-case.
|
|
"""
|
|
class Meta:
|
|
verbose_name = _('publication')
|
|
verbose_name_plural = _('publications')
|
|
|
|
_meta = Meta()
|
|
|
|
def __init__(self, **kwargs):
|
|
self.__dict__.update(kwargs)
|
|
|
|
@classmethod
|
|
def reverse(cl, route, use_default = True, **kwargs):
|
|
"""
|
|
Reverse a url using a given route for the model - simple wrapper
|
|
around cl._website.reverse
|
|
"""
|
|
return cl._website.reverse(cl, route, use_default, **kwargs)
|
|
|
|
|