class MetadataBaseIndex(CustomQuerySetIndex, indexes.Indexable):
"""
Subclassable class for creating III "metadata" indexes --
Locations, Itypes, etc. (E.g. admin parameters.) Most of them are
just key/value pairs (code/label), so they follow a predictable
pattern. In each subclass just be sure to set your model and
type_name and any fields and/or prepare methods that need to be
customized. The prepare_label method will always need to be
overridden. See LocationIndex, etc., below for examples.
"""
model = None
type_name = ''
text = indexes.CharField(document=True, use_template=False)
code = indexes.FacetCharField(model_attr='code')
label = indexes.FacetCharField()
type = indexes.FacetCharField()
_version_ = indexes.IntegerField()
def get_model(self):
return self.model
def prepare_label(self, obj):
return None
def prepare_type(self, obj):
return self.type_name
def prepare(self, obj):
self.prepared_data = super(MetadataBaseIndex, self).prepare(obj)
include = ('code', 'label', 'type')
self.prepared_data["text"] = cat_fields(self.prepared_data,
include=include)
return self.prepared_data
class ExplicitFacetSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
author = indexes.CharField(faceted=True)
title = indexes.CharField()
title_facet = indexes.FacetCharField(facet_for="title")
bare_facet = indexes.FacetCharField()
def get_model(self):
return MockModel
class CandidateIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
first_name = indexes.CharField(indexed=True)
party = indexes.FacetCharField(indexed=True)
college = indexes.FacetCharField(indexed=True)
state = indexes.FacetCharField(indexed=True)
issues = indexes.FacetMultiValueField(indexed=True)
race = indexes.FacetCharField(indexed=True)
race_type = indexes.FacetCharField(indexed=True)
women = indexes.BooleanField(indexed=True)
active = indexes.BooleanField(indexed=True)
random = indexes.CharField()
def get_model(self):
return Candidate
def prepare_first_name(self, obj):
return obj.first_name
def prepare_issues(self, obj):
return [(issue.issue.parent_name)
for issue in obj.issues.all()] or None
def prepare_party(self, obj):
return obj.party
def prepare_state(self, obj):
return obj.state
def prepare_race(self, obj):
if obj.race:
return obj.race.title
def prepare_active(self, obj):
return obj.active
def prepare_women(self, obj):
if obj.man:
return False
return True
def prepare_race_type(self, obj):
if obj.race:
return obj.race.race_type
def prepare_random(self, obj):
return random.randint(0, 99999999)
def prepare_college(self, obj):
if obj.college:
return obj.college.name
return None
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.all()
def __init__(self, queryset=None, using=None):
super(MarcIndex, self).__init__(queryset=queryset, using=using)
for mf in range(10, 1000):
fname = 'mf_{:03d}'.format(mf)
setattr(self, fname, indexes.FacetCharField(stored=False))
for sf in [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]:
sfname = 'sf_{:03d}{}'.format(mf, sf)
setattr(self, sfname, indexes.FacetCharField(stored=False))
class InitiativeIndex(AbstractIndex, indexes.ModelSearchIndex,
indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
# facets
years = indexes.FacetMultiValueField()
recipients = indexes.FacetMultiValueField()
agency = indexes.FacetCharField()
aid_types = indexes.FacetMultiValueField()
channels = indexes.FacetMultiValueField()
finance_type = indexes.FacetCharField()
sectors = indexes.FacetMultiValueField()
def prepare_years(self, obj):
return obj.years_range()
def prepare_recipients(self, obj):
return self._prepare_codelist(obj.recipients(), roots=False)
def prepare_agency(self, obj):
agency = obj.agency()
return agency.code if agency else None
def prepare_aid_types(self, obj):
return self._prepare_codelist(obj.aid_types())
def prepare_channels(self, obj):
return self._prepare_codelist(obj.channels())
def prepare_finance_type(self, obj):
finance_type = obj.finance_type()
return finance_type.code if finance_type else None
def prepare_sectors(self, obj):
return self._prepare_codelist(obj.sectors())
class Meta:
model = Initiative
# fields = ['years', 'recipients', 'agency', 'aid_types',
# 'channels', 'finance_type', 'sectors',
# 'code', 'start_year', 'end_year', 'has_focus']
excludes = [
'code', 'title', 'total_project_costs', 'loan_amount_approved',
'grant_amount_approved', 'photo_set', 'document_set', 'updated_at',
'created_at'
]
for f in Initiative._meta.fields:
if f.attname.endswith('_temp') or f.attname[-3:] in ('_it', '_en'):
excludes.append(f.attname)
class EventIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
# faceting fields
date = indexes.FacetDateField(model_attr='date')
institution = indexes.FacetCharField(model_attr='institution')
title = indexes.CharField(indexed=False,
stored=True,
model_attr='title',
default='')
address = indexes.CharField(indexed=False,
stored=True,
model_attr='address')
url = indexes.CharField(indexed=False, stored=True)
n_acts = indexes.IntegerField()
def get_model(self):
return Event
def prepare_url(self, obj):
return obj.get_absolute_url()
def prepare_n_acts(self, obj):
return obj.eventact_set.count()
class AnswerBaseIndex(indexes.SearchIndex, indexes.Indexable):
text = fields.CharFieldWithSynonyms(document=True,
use_template=True,
boost=10.0)
autocomplete = indexes.EdgeNgramField(use_template=True, indexed=True)
url = indexes.CharField(use_template=True, indexed=False)
tags = indexes.MultiValueField(indexed=True, boost=10.0)
language = indexes.CharField(model_attr='language')
suggestions = indexes.FacetCharField()
def prepare_answer(self, obj):
data = super(AnswerBaseIndex, self).prepare(obj)
if obj.question.lower().startswith('what is'):
data['boost'] = 2.0
return data
def prepare_tags(self, obj):
return obj.clean_search_tags
def prepare(self, obj):
data = super(AnswerBaseIndex, self).prepare(obj)
data['suggestions'] = data['text']
return data
def get_model(self):
return AnswerPage
def index_queryset(self, using=None):
return self.get_model().objects.filter(live=True,
redirect_to_page=None)
class UserInfoIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
courses = indexes.MultiValueField(indexed=True, stored=True)
suggestions = indexes.FacetCharField()
def prepare(self, obj):
prepared_data = super(UserInfoIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
def prepare_courses(self, obj):
return [str(s) for s in obj.courses.all()]
def index_queryset(self):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(user__is_active=True)
def get_model(self):
return UserInfo
def should_update(self, instance, **kwargs):
if True:
return True
else:
self.remove_object(instance, **kwargs)
return False
class MeagazinesIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
Title = indexes.CharField(model_attr='Title')
Keywords = indexes.CharField(model_attr='Keywords')
Author = indexes.CharField(model_attr='Author')
Description = indexes.CharField(model_attr='Description')
FiledOfStudies = indexes.CharField(model_attr='FiledOfStudies')
content_auto_1 = indexes.EdgeNgramField(model_attr='Title')
content_auto_2 = indexes.EdgeNgramField(model_attr='Keywords')
content_auto_3 = indexes.EdgeNgramField(model_attr='Author')
content_auto_4 = indexes.EdgeNgramField(model_attr='Description')
content_auto_5 = indexes.EdgeNgramField(model_attr='FiledOfStudies')
suggestions = indexes.FacetCharField()
def prepare(self, obj):
prepared_data = super(MeagazinesIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
def get_model(self):
return Meagazines
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.all()
class ProductIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(
document=True,
use_template=True,
template_name=
'/home/gublu/Desktop/DjangoHasytackElasticSearchDemo/searchDemo/templates/search/indexes/product_text.txt'
)
title = indexes.EdgeNgramField(model_attr='title')
description = indexes.EdgeNgramField(model_attr="description", null=True)
category = indexes.CharField(model_attr='category', faceted=True)
brand = indexes.CharField(model_attr='brand', faceted=True)
# for auto complete
content_auto = indexes.EdgeNgramField(model_attr='title')
# Spelling suggestions
suggestions = indexes.FacetCharField()
def get_model(self):
return Product
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(timestamp__lte=timezone.now())
class ClassNumberIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
suggestions = indexes.FacetCharField()
def prepare(self, obj):
prepared_data = super(ClassNumberIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
def prepare_text(self, obj):
return obj.number + " " + obj.class_obj.title
def index_queryset(self):
"""Used when the entire index for model is updated."""
return self.get_model().objects.all()
def get_model(self):
return ClassNumber
def should_update(self, instance, **kwargs):
if True:
return True
else:
self.remove_object(instance, **kwargs)
return False
class MyfeedIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(
document=True, use_template=True,
template_name='/home/aptus/rssfeeds/Td/feed/templates/search/indexes/myfeed_text.txt')
title = indexes.EdgeNgramField(model_attr='title')
slug = indexes.EdgeNgramField(model_attr='slug', null=True)
description = indexes.EdgeNgramField(model_attr="description", null=True)
category = indexes.CharField(model_attr='category', null=True, faceted=True)
main_link = indexes.CharField(model_attr='main_link', null=True, faceted=True)
sub_link = indexes.CharField(model_attr='sub_link', null=True, faceted=True)
tag_id = indexes.CharField(model_attr='tag_id', null=True, faceted=True)
published = indexes.CharField(model_attr='published', null=True, faceted=True)
updated = indexes.CharField(model_attr='updated', null=True, faceted=True)
# for auto complete
content_auto = indexes.EdgeNgramField(model_attr='title')
# Spelling suggestions
suggestions = indexes.FacetCharField()
def get_model(self):
return Myfeed
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(timestamp__lte=timezone.now())
class CardIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
SubjectName = indexes.CharField(model_attr='SubjectName',
faceted=True,
null=True)
SubjectDescription = indexes.CharField(model_attr="SubjectDescription",
faceted=True,
null=True)
PhotoDescription = indexes.CharField(model_attr="PhotoDescription",
faceted=True,
null=True)
Photographer = indexes.CharField(model_attr="Photographer",
faceted=True,
null=True)
Location = indexes.CharField(model_attr="Location",
faceted=True,
null=True)
BoxNumber = indexes.MultiValueField(indexed=True, stored=True)
Negative = indexes.CharField(model_attr="Negative",
faceted=True,
null=True)
Year = indexes.IntegerField(model_attr="Year", faceted=True, null=True)
Day = indexes.IntegerField(model_attr="Day", faceted=True, null=True)
Month = indexes.IntegerField(model_attr="Month", faceted=True, null=True)
date = indexes.CharField(model_attr="date", faceted=True, null=True)
Quantity = indexes.IntegerField(model_attr="Quantity",
faceted=True,
null=True)
suggestions = indexes.FacetCharField()
def get_model(self):
return Card
def prepare_BoxNumber(self, object):
return [BoxNumber.box for BoxNumber in object.BoxNumber.all()]
class PublicBodyIndex(SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
name = indexes.CharField(model_attr='name', boost=1.5)
name_auto = indexes.NgramField(model_attr='name')
jurisdiction = indexes.FacetCharField(model_attr='jurisdiction__name',
default='')
tags = indexes.FacetMultiValueField()
url = indexes.CharField(model_attr='get_absolute_url')
def get_model(self):
return PublicBody
def index_queryset(self, **kwargs):
"""Used when the entire index for model is updated."""
return self.get_model().objects.get_for_search_index()
def prepare_tags(self, obj):
return [t.name for t in obj.tags.all()]
def prepare(self, obj):
data = super(PublicBodyIndex, self).prepare(obj)
if obj.classification in PUBLIC_BODY_BOOSTS:
data['boost'] = PUBLIC_BODY_BOOSTS[obj.classification]
print("Boosting %s at %f" % (obj, data['boost']))
return data
class PublicBodyIndex(SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
name = indexes.CharField(model_attr='name', boost=1.5)
name_auto = SuggestField(model_attr='all_names', boost=2.5)
jurisdiction = indexes.FacetCharField(model_attr='jurisdiction__name',
default='')
classification = indexes.FacetMultiValueField()
categories = indexes.FacetMultiValueField()
def get_model(self):
return PublicBody
def index_queryset(self, **kwargs):
"""Used when the entire index for model is updated."""
return self.get_model().objects.get_for_search_index()
def prepare_classification(self, obj):
if obj.classification is None:
return []
return [obj.classification.name
] + [c.name for c in obj.classification.get_ancestors()]
def prepare_categories(self, obj):
cats = obj.categories.all()
return [o.name for o in cats
] + [c.name for o in cats for c in o.get_ancestors()]
class DocumentIndex(CelerySearchIndex, indexes.Indexable):
text = indexes.CharField(use_template=True, document=True)
datetime = indexes.DateTimeField(model_attr="data__datetime")
parent_ids = indexes.MultiValueField()
suggestions = indexes.FacetCharField()
def get_model(self):
return Document
def index_queryset(self, using=None):
return self.get_model().objects.all().exclude(parent=None)
def prepare_parent_ids(self, obj):
return _parent_ids(obj)
def prepare(self, obj):
data = super().prepare(obj)
file_obj = obj.data.file
extracted_data = self.get_backend().extract_file_contents(file_obj)
t = loader.select_template(
('search/indexes/documents/document_text.txt', ))
data['text'] = t.render(
Context({
'object': obj,
'extracted': extracted_data
}))
# data['suggestions'] = data['text'][:30000]
return data
class ProductIndex(indexes.SearchIndex, indexes.Indexable):
# template_name='/home/manhee/anaconda3/envs/djviews1/src/templates/product_text.txt'
text = indexes.EdgeNgramField(model_attr='name',
document=True,
use_template=True)
category = indexes.CharField(model_attr='cat_id__rus_name', faceted=True)
name = indexes.EdgeNgramField(model_attr='name')
price = indexes.IntegerField(model_attr='price')
cond = indexes.CharField(model_attr='cond', faceted=True)
brand = indexes.CharField(model_attr='brand', faceted=True)
car = indexes.CharField(model_attr='car', faceted=True)
car_model = indexes.CharField(model_attr='car_model', faceted=True)
cat_n = indexes.CharField(model_attr='cat_n')
color = indexes.CharField(model_attr='color')
fuel = indexes.CharField(model_attr='fuel', faceted=True)
value = indexes.CharField(model_attr='value', faceted=True)
cat_id = indexes.IntegerField(model_attr='cat_id__id')
# for auto complete
content_auto = indexes.EdgeNgramField(model_attr='name')
# Spelling suggestions
suggestions = indexes.FacetCharField()
def get_model(self):
return AlegroGoodsSpec
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.all()
class ProjectIndex(AbstractIndex, indexes.ModelSearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
# facets
years = indexes.FacetMultiValueField()
# facets for code-lists
recipient = indexes.FacetCharField()
agencies = indexes.FacetMultiValueField()
aid_types = indexes.FacetMultiValueField()
channels = indexes.FacetMultiValueField()
finance_types = indexes.FacetMultiValueField()
sectors = indexes.FacetMultiValueField()
def prepare_recipient(self, obj):
return obj.recipient.code
def prepare_agencies(self, obj):
return self._prepare_codelist(obj.agencies(), roots=False)
def prepare_aid_types(self, obj):
return self._prepare_codelist(obj.aid_types())
def prepare_channels(self, obj):
return self._prepare_codelist(obj.channels())
def prepare_finance_types(self, obj):
return self._prepare_codelist(obj.finance_types())
def prepare_sectors(self, obj):
return self._prepare_codelist(obj.sectors())
def get_facets_counts(self):
return self.objects.facet('year').facet_counts().get('fields', {})
class Meta:
model = Project
# fields = ['years', 'markers', 'recipient', 'agency', 'aid_type',
# 'channel', 'finance_type', 'sector', 'initiative',
# 'crsid', 'start_year', 'end_year', 'has_focus']
excludes = [
'is_suspended', 'status', 'expected_start_year',
'expected_completion_year', 'expected_start_date',
'completion_date', 'last_update', 'outcome', 'beneficiaries',
'beneficiaries_female', 'total_project_costs', 'other_financiers',
'loan_amount_approved', 'grant_amount_approved',
'counterpart_authority', 'email', 'location', 'description',
'title', 'title_it', 'title_en', 'description_it',
'description_en', 'number', 'outcome_it', 'beneficiaries_it',
'other_financiers_it', 'counterpart_authority_it', 'location_it',
'outcome_en', 'beneficiaries_en', 'other_financiers_en',
'counterpart_authority_en', 'location_en'
]
class ElasticsearchFacetingMockSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
author = indexes.CharField(model_attr='author', faceted=True)
editor = indexes.CharField(model_attr='editor', faceted=True)
pub_date = indexes.DateField(model_attr='pub_date')
facet_field = indexes.FacetCharField(model_attr='author')
def prepare_text(self, obj):
return '%s %s' % (obj.author, obj.editor)
def get_model(self):
return AFourthMockModel
class SubcategoryIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
name = indexes.CharField(model_attr='name')
slug_sub = indexes.CharField(model_attr='slug_sub')
suggestions = indexes.FacetCharField()
def get_model(self):
return Subcategory
def prepare(self, obj):
prepared_data = super(SubcategoryIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
class OrganizationIndex(CelerySearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
created = indexes.DateTimeField(model_attr='created')
modified = indexes.DateTimeField(model_attr='modified')
state = indexes.FacetCharField(model_attr='state')
tags = indexes.FacetMultiValueField()
def prepare_tags(self, my_model):
return [tag.id for tag in my_model.tags.all()]
def get_model(self):
return models.Organization
class CommunityIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, model_attr='name')
category = indexes.CharField(model_attr='category', faceted=True)
created_at = indexes.DateTimeField(model_attr='created_at', faceted=True)
# for spelling suggestions
suggestions = indexes.FacetCharField()
def get_model(self):
return Community
def index_queryset(self, using=None):
# """Used when the entire index for model is updated."""
return self.get_model().objects.all()
class ServerIndex(indexes.SearchIndex, indexes.Indexable):
name = indexes.CharField(model_attr='name')
hostname = indexes.CharField(model_attr='hostname')
ip = indexes.CharField(model_attr='ip')
category = indexes.FacetCharField(model_attr='category__name')
description = indexes.CharField(model_attr='description')
fqdn = indexes.CharField()
text = indexes.CharField(document=True)
operating_system = indexes.FacetCharField(model_attr='operating_system')
distribution = indexes.FacetCharField(
model_attr='operating_system__distribution')
platform = indexes.FacetCharField(model_attr='operating_system__platform')
def get_model(self):
return Server
def index_queryset(self, using=None):
return self.get_model().objects.all()
def prepare_fqdn(self, object):
return '{}.{}'.format(object.hostname, object.domain.fqdn)
class PublisherIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
document = indexes.FacetCharField(default='Publisher')
title = indexes.CharField()
url = indexes.CharField(model_attr='url', indexed=False)
def get_model(self):
return Publisher
def index_queryset(self, using=None):
return self.get_model().objects.filter(live=True)
def prepare_title(self, publisher):
return publisher.__unicode__()
class AddressIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
city = indexes.CharField(model_attr='city__name')
company = indexes.CharField(model_attr='company__pk')
suggestions = indexes.FacetCharField()
def prepare(self, obj):
prepared_data = super(AddressIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
def get_model(self):
return Address
class BaseIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
name = indexes.CharField(model_attr='name')
slug = indexes.CharField(model_attr='slug')
file = indexes.CharField(model_attr='file')
suggestions = indexes.FacetCharField()
class Meta:
abstract = True
def prepare(self, obj):
prepared_data = super(BaseIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
class WorkIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
document = indexes.FacetCharField(default='General information')
title = indexes.CharField(model_attr='title')
sort_order = indexes.FloatField(model_attr='sort_order')
url = indexes.CharField(model_attr='url', indexed=False)
def get_model(self):
return Work
def index_queryset(self, using=None):
return self.get_model().objects.filter(live=True)
def prepare_text(self, work):
return work.heading
class GoodFacetedMockSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
author = indexes.CharField(model_attr="author")
author_foo = indexes.FacetCharField(facet_for="author")
pub_date = indexes.DateTimeField(model_attr="pub_date")
pub_date_exact = indexes.FacetDateTimeField(facet_for="pub_date")
def get_model(self):
return MockModel
def prepare_author(self, obj):
return "Hi, I'm %s" % self.prepared_data["author"]
def prepare_pub_date_exact(self, obj):
return "2010-10-26T01:54:32"
class ProductIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True, template_name="search/product_text.txt")
name = indexes.EdgeNgramField(model_attr='name')
description = indexes.EdgeNgramField(model_attr='description')
category = indexes.CharField(model_attr='category', faceted=True)
producer = indexes.CharField(model_attr='producer', faceted=True)
content_auto = indexes.EdgeNgramField(model_attr='name')
suggestions = indexes.FacetCharField()
def get_model(self):
return Product
def index_queryset(self, using=None):
return self.get_model().objects.all()
class PostIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
author = indexes.CharField(model_attr='user')
pub_date = indexes.DateTimeField(model_attr='pub_date')
suggestions = indexes.FacetCharField()
def prepare(self, obj):
prepared_data = super(PostIndex, self).prepare(obj)
prepared_data['suggestions'] = prepared_data['text']
return prepared_data
def get_model(self):
return Post
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(pub_date__lte=datetime.datetime.now())
