class MyModelDocument(Document): # year = fields.CompletionField() # name = fields.CompletionField() # country = fields.CompletionField() # productID = fields.CompletionField() # id = fields.CompletionField() class Index: name = 'mymodels' settings = {'number_of_shards': 1, 'number_of_replicas': 0} id = fields.IntegerField(attr='id') name = fields.TextField( # analyzer=html_strip, fields={'raw': fields.KeywordField()}) country = fields.TextField( # analyzer=html_strip, fields={'raw': fields.KeywordField()}) year = fields.TextField( # analyzer=html_strip, fields={'raw': fields.KeywordField()}) productID = fields.FloatField( # analyzer=html_strip, fields={'raw': fields.KeywordField()}) class Django: model = MyModel fields = []
class ConventionDocument(DocType): label = fields.KeywordField() slot = fields.KeywordField() class Meta: model = Convention fields = ('year', )
class DocketEntryDocument(DocType): court = fields.ObjectField(properties={ 'description': fields.TextField(), 'name': fields.KeywordField(), }) case = fields.ObjectField( properties={ 'year': fields.KeywordField(), 'number': fields.KeywordField(), 'office': fields.KeywordField(), 'type': fields.KeywordField(), }) class Meta: model = models.DocketEntry fields = [ 'case_number', 'case_name', 'title', 'time_filed', ] # related_models = [models.Court] ignore_signals = True auto_refresh = False def get_queryset(self): qs = super().get_queryset().select_related('court') # FIXME out of +1M entries, only 10 have a blank case_name, for now just exclude them qs = qs.exclude( case_name='') # ES doesn't allow emtpy values on completions qs = qs[:1000] # for testing only index the first X items return qs
class MeetingDoc(Document): id = fields.IntegerField() title = fields.StringField() description = fields.TextField() venue = fields.StringField() start_date = fields.DateField() start_time = fields.KeywordField(attr='start_time_str') end_time = fields.KeywordField(attr='end_time_str') materials = fields.NestedField( properties={ 'id': fields.IntegerField(), 'download_url': fields.KeywordField(), 'name': fields.KeywordField(), }) class Index: name = mcs.ELASTICSEARCH_INDEX_NAMES['meetings'] settings = mcs.ELASTICSEARCH_DSL_INDEX_SETTINGS class Django: model = Meeting related_models = [ MeetingFile, ] def get_instances_from_related(self, related_instance): if isinstance(related_instance, MeetingFile): return related_instance.meeting def get_queryset(self): return super().get_queryset().published()
class NoteDocument(Document): """Note Elastic search document.""" class Django: model = Note id = fields.StringField(attr='id', analyzer="standard") title = fields.StringField(fields={ 'raw': fields.KeywordField(), }) user = fields.StringField(attr='user_indexing', fields={ 'raw': fields.KeywordField(), }) content = fields.StringField(fields={ 'raw': fields.KeywordField(), }) label = fields.StringField(attr='label_indexing', fields={'raw': fields.KeywordField()}) collaborator = fields.StringField(attr='collaborator_indexing', fields={ 'raw': fields.KeywordField(), }) is_archive = fields.BooleanField() is_pin = fields.BooleanField() is_trash = fields.BooleanField() reminder = fields.DateField()
class OrganizationDocument(Document): class Index: name = 'organizations' settings = {'number_of_shards': 1, 'number_of_replicas': 0} last_update = fields.DateField(attr='updated_at') public_can_view = fields.BooleanField(attr='public_can_view') name = fields.KeywordField(attr='name', normalizer="lowercase") mnemonic = fields.KeywordField(attr='mnemonic', normalizer="lowercase") extras = fields.ObjectField() user = fields.ListField(fields.KeywordField()) class Django: model = Organization fields = [ 'is_active', 'company', 'location', ] @staticmethod def prepare_extras(instance): return instance.extras or {} @staticmethod def prepare_user(instance): return list(instance.members.values_list('username', flat=True))
def datasets_field(**kwargs): return fields.NestedField(properties={ 'id': fields.IntegerField(), 'title': TranslatedTextField('title'), 'notes': TranslatedTextField('notes'), 'category': fields.KeywordField(attr='category.title'), 'formats': fields.KeywordField(attr='formats', multi=True), 'downloads_count': fields.IntegerField(attr='computed_downloads_count'), 'views_count': fields.IntegerField(attr='computed_views_count'), 'openness_scores': fields.IntegerField(attr='openness_scores'), 'modified': fields.DateField(), 'slug': TranslatedKeywordField('slug'), 'verified': fields.DateField(), }, **kwargs)
class UniversityDocument(Document): """University Elasticsearch document.""" id = fields.IntegerField(attr='id') name = fields.TextField(fields={ 'raw': fields.KeywordField(normalizer=keyword_normalizer), }, ) domain = fields.TextField( fields={'raw': fields.KeywordField(normalizer=keyword_normalizer)}) web_page = fields.TextField( fields={'raw': fields.KeywordField(normalizer=keyword_normalizer)}) country = fields.ObjectField( properties={ 'name': fields.TextField(), 'code': fields.TextField( fields={ 'raw': fields.KeywordField(normalizer=keyword_normalizer) }), }) createdAt = fields.DateField() isDelete = fields.BooleanField() class Django(object): """Meta options.""" model = University # The model associate with this DocType
class ExperimentDocument(Document): class Index: name = 'experiments' settings = {'number_of_shards': 1, 'number_of_replicas': 0} id = fields.IntegerField() title = fields.TextField(fields={'raw': fields.KeywordField()}, analyzer=analyzer) description = fields.TextField(fields={'raw': fields.KeywordField()}, analyzer=analyzer) public_access = fields.IntegerField() created_time = fields.DateField() start_time = fields.DateField() end_time = fields.DateField() update_time = fields.DateField() institution_name = fields.StringField() created_by = fields.ObjectField(properties={ 'username': fields.StringField(fields={'raw': fields.KeywordField()}, ) }) objectacls = fields.ObjectField(properties={ 'pluginId': fields.StringField(), 'entityId': fields.StringField() }) class Django: model = Experiment related_models = [User, ObjectACL] def get_instances_from_related(self, related_instance): if isinstance(related_instance, User): return related_instance.experiment_set.all() if isinstance(related_instance, ObjectACL): return related_instance.content_object return None
class LabEventDoc(Document): id = fields.IntegerField() title = TranslatedTextField('title') notes = TranslatedTextField('notes') event_type = fields.KeywordField() execution_date = fields.DateField() reports = fields.NestedField( properties={ 'type': fields.KeywordField(attr='report_type'), 'download_url': fields.TextField(), 'link': fields.StringField(), } ) class Index: name = settings.ELASTICSEARCH_INDEX_NAMES['lab_events'] settings = settings.ELASTICSEARCH_DSL_INDEX_SETTINGS class Django: model = LabEvent related_models = [LabReport, ] def get_instances_from_related(self, related_instance): if isinstance(related_instance, LabReport): return related_instance.lab_event def get_queryset(self): return super().get_queryset().filter(status='published')
class NoteDocument(Document): """ Document for the Note index. """ id = fields.IntegerField(attr='id') user = fields.KeywordField(attr='user_id') course_id = fields.KeywordField() usage_id = fields.KeywordField() quote = fields.TextField(analyzer=html_strip) text = fields.TextField(analyzer=html_strip) ranges = fields.KeywordField() created = fields.DateField() updated = fields.DateField() tags = fields.TextField(multi=True, analyzer=case_insensitive_keyword) def prepare_data(self, instance): """ Prepare data. """ return '{0}{1}'.format(instance.text, instance.tags) def prepare_tags(self, instance): return json.loads(instance.tags) class Django: model = Note class Meta: parallel_indexing = True queryset_pagination = 50
class SiteReportDocument(Document): class Index: # Name of the Elasticsearch index name = "site_reports" # See Elasticsearch Indices API reference for available settings settings = {"number_of_shards": 1, "number_of_replicas": 0} campaign = fields.ObjectField(properties={"slug": fields.KeywordField()}) topic = fields.ObjectField(properties={"slug": fields.KeywordField()}) class Django: model = SiteReport fields = [ "created_on", "assets_total", "assets_published", "assets_not_started", "assets_in_progress", "assets_waiting_review", "assets_completed", "assets_unpublished", "items_published", "items_unpublished", "projects_published", "projects_unpublished", "anonymous_transcriptions", "transcriptions_saved", "distinct_tags", "tag_uses", "campaigns_published", "campaigns_unpublished", "users_registered", "users_activated", ]
class UserDocument(Document): id = fields.IntegerField() username = fields.TextField(fields={ 'raw': fields.KeywordField(), 'suggest': fields.CompletionField(), }, ) username_color = fields.KeywordField() role = fields.IntegerField(attr='role_id') role_icon = fields.IntegerField(attr='icon') active_badge = fields.IntegerField(attr='badge') custom_images = fields.IntegerField(attr='custom_images_indexing', multi=True) class Index: name = 'user' class Django: model = User related_models = Image, def get_queryset(self): return super().get_queryset().select_related( 'role').prefetch_related_images() @staticmethod def get_instances_from_related(related_instance) -> (list, None): if related_instance.is_icon: return related_instance.icon_owners.values_list('id', flat=True) if related_instance.is_custom: return related_instance.custom_owners.values_list('id', flat=True)
class ProductDocument(Document): title = fields.TextField( analyzer=custom_analyzer, fields={ 'raw' : fields.KeywordField() } ) description = fields.TextField( analyzer=custom_analyzer, fields={'raw' : fields.KeywordField()} ) features = fields.TextField( analyzer=custom_analyzer, fields={'raw' : fields.KeywordField()} ) class Index: name = 'products' settings = {'number_of_shards': 1, 'number_of_replicas': 0} class Django: model = Product fields = [ 'id', # 'description', # 'features', # 'title', ]
class TenderDoc(DocType): description = fields.TextField( analyzer=case_insensitive_analyzer, fielddata=True, fields={ 'raw': fields.KeywordField(multi=True, ignore_above=256, normalizer=case_insensitive_normalizer) }) title = fields.TextField(analyzer=case_insensitive_analyzer, fielddata=True, fields={ 'raw': fields.KeywordField( multi=True, ignore_above=256, normalizer=case_insensitive_normalizer) }) reference = fields.KeywordField(attr='reference') class Meta: model = Tender fields = [ 'unspsc_codes', 'cpv_codes', 'organization', 'source', 'notified', ]
class AssetDocument(Document): class Index: # Name of the Elasticsearch index name = "assets" # See Elasticsearch Indices API reference for available settings settings = {"number_of_shards": 1, "number_of_replicas": 0} item = fields.ObjectField( properties={ "item_id": fields.KeywordField(), "project": fields.ObjectField( properties={ "slug": fields.KeywordField(), "campaign": fields.ObjectField( properties={"slug": fields.KeywordField()} ), "topics": fields.NestedField( properties={"slug": fields.KeywordField()} ), } ), } ) transcription_status = fields.KeywordField() latest_transcription = fields.ObjectField( properties={ "created_on": fields.DateField(), "updated_on": fields.DateField(), "accepted": fields.DateField(), "rejected": fields.DateField(), "submitted": fields.DateField(), } ) submission_count = fields.IntegerField() def prepare_submission_count(self, instance): return Transcription.objects.filter( asset=instance, submitted__isnull=True ).count() class Django: model = Asset fields = ["published", "difficulty", "slug", "sequence", "year"] def get_queryset(self): return ( super() .get_queryset() .order_by("pk") .prefetch_related( "item", "item__project", "item__project__topics", "item__project__campaign", ) )
class TranscriptionDocument(Document): class Index: # Name of the Elasticsearch index name = "transcriptions" # See Elasticsearch Indices API reference for available settings settings = {"number_of_shards": 1, "number_of_replicas": 0} asset = fields.ObjectField( properties={ "title": fields.TextField(), "slug": fields.TextField(), "transcription_status": fields.KeywordField(), "item": fields.ObjectField( properties={ "item_id": fields.TextField(), "project": fields.ObjectField( properties={ "slug": fields.KeywordField(), "campaign": fields.ObjectField( properties={"slug": fields.KeywordField()} ), "topics": fields.NestedField( properties={"slug": fields.KeywordField()} ), } ), } ), } ) user = fields.ObjectField(properties={"id": fields.IntegerField()}) reviewed_by = fields.ObjectField(properties={"id": fields.IntegerField()}) supersedes = fields.ObjectField(properties={"id": fields.IntegerField()}) class Django: model = Transcription fields = [ "id", "created_on", "updated_on", "text", "accepted", "rejected", "submitted", ] def get_queryset(self): return ( super() .get_queryset() .order_by("pk") .prefetch_related( "asset__item", "asset__item__project", "asset__item__project__topics", "asset__item__project__campaign", ) )
class PublicBodyDocument(DocType): name = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) name_auto = fields.TextField(attr='all_names', analyzer=ngram_analyzer) content = fields.TextField(analyzer=analyzer) jurisdiction = fields.IntegerField(attr='jurisdiction_id') classification = fields.ListField(fields.IntegerField()) categories = fields.ListField(fields.IntegerField()) regions = fields.ListField(fields.IntegerField()) regions_exact = fields.ListField(fields.IntegerField()) regions_kind = fields.ListField(fields.KeywordField()) class Meta: model = PublicBody queryset_chunk_size = 100 def get_queryset(self): """Not mandatory but to improve performance we can select related in one sql request""" return super().get_queryset().select_related( 'jurisdiction').prefetch_related('classification', 'categories', 'regions') def prepare_content(self, obj): content = [ obj.name, obj.other_names, obj.jurisdiction.name if obj.jurisdiction else '', obj.email or '', obj.description, obj.contact, obj.address, obj.url, obj.classification.name if obj.classification else '' ] + [o.name for o in obj.categories.all()] return ' '.join(c for c in content if c) def prepare_classification(self, obj): if obj.classification is None: return [] return [obj.classification.id ] + [c.id for c in obj.classification.get_ancestors()] def prepare_categories(self, obj): cats = obj.categories.all() return [o.id for o in cats ] + [c.id for o in cats for c in o.get_ancestors()] def prepare_regions(self, obj): regs = obj.regions.all() return [o.id for o in regs ] + [c.id for o in regs for c in o.get_ancestors()] def prepare_regions_exact(self, obj): regs = obj.regions.all() return [o.id for o in regs] def prepare_regions_kind(self, obj): regs = obj.regions.all() return [o.kind for o in regs]
class PageDocument(DocType): # Metadata project = fields.KeywordField(attr='project.slug') version = fields.KeywordField(attr='version.slug') path = fields.KeywordField(attr='processed_json.path') # Searchable content title = fields.TextField(attr='processed_json.title') headers = fields.TextField(attr='processed_json.headers') content = fields.TextField(attr='processed_json.content') class Meta(object): model = HTMLFile fields = ('commit',) ignore_signals = True @classmethod def faceted_search( cls, query, user, projects_list=None, versions_list=None, filter_by_user=True ): from readthedocs.search.faceted_search import PageSearch kwargs = { 'user': user, 'query': query, 'filter_by_user': filter_by_user, } filters = {} if projects_list: filters['project'] = projects_list if versions_list: filters['version'] = versions_list kwargs['filters'] = filters return PageSearch(**kwargs) def get_queryset(self): """Overwrite default queryset to filter certain files to index""" queryset = super(PageDocument, self).get_queryset() # Exclude some files to not index excluded_files = [ 'search.html', 'genindex.html', 'py-modindex.html', 'search/index.html', 'genindex/index.html', 'py-modindex/index.html', ] # Do not index files that belong to non sphinx project # Also do not index certain files queryset = queryset.filter(project__documentation_type__contains='sphinx') for ending in excluded_files: queryset = queryset.exclude(path__endswith=ending) return queryset
class HyperManagerDocument(Document): id = fields.IntegerField() name = KeywordField() url = fields.KeywordField() online = fields.BooleanField() version = fields.KeywordField() class Django(object): model = HyperManager
class ArticleDocument(Document): title = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) url = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) description = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) start_publication = fields.DateField() author = fields.ListField(fields.IntegerField()) category = fields.ListField(fields.IntegerField()) content = fields.TextField(analyzer=analyzer, search_analyzer=search_analyzer, search_quote_analyzer=search_quote_analyzer, index_options='offsets') special_signals = True class Django: model = Article queryset_chunk_size = 100 def get_queryset(self): return Article.published.all() def prepare_content(self, obj): html = obj.get_html_content() return ' '.join([obj.title, obj.description, strip_tags(html)] + [o.title for o in obj.categories.all()] + [t.name for t in obj.tags.all()]) def prepare_description(self, obj): return strip_tags(obj.description) def prepare_url(self, obj): return obj.get_absolute_url() def prepare_title(self, obj): return obj.title def prepare_start_publication(self, obj): return obj.start_publication def prepare_category(self, obj): cats = obj.categories.all() return [o.id for o in cats] def prepare_author(self, obj): authors = obj.authors.all() return [o.id for o in authors]
class RepositoryExampleDocument(Document): time_based = False repository_version_language = fields.ObjectField( properties={ "pk": fields.IntegerField(), "language": fields.TextField(fields={"raw": fields.KeywordField()}), } ) intent = fields.ObjectField( properties={"text": fields.TextField(fields={"raw": fields.KeywordField()})} ) entities = fields.NestedField( properties={ "entity": fields.ObjectField( properties={ "value": fields.TextField(fields={"raw": fields.KeywordField()}), } ), } ) pk = fields.IntegerField() class Django: model = RepositoryExample fields = [ "id", "text", ] related_models = [ RepositoryVersionLanguage, RepositoryIntent, RepositoryExampleEntity, ] def get_queryset(self): return ( super(RepositoryExampleDocument, self) .get_queryset() .select_related( "repository_version_language", "intent", ) .prefetch_related( "entities", "translations", ) ) def get_instances_from_related(self, related_instance): if isinstance(related_instance, RepositoryVersionLanguage): return related_instance.added.all() elif isinstance(related_instance, RepositoryIntent): return related_instance.repositoryexample_set.all() elif isinstance(related_instance, RepositoryExampleEntity): return related_instance.repository_example
class CLCEntry(InnerDoc): rating = fields.KeywordField( fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),}, copy_to="wildcard", ) text = fields.TextField(copy_to="wildcard", analyzer=descriptive_text_analyzer) category = fields.KeywordField( fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),}, ) parent = fields.ObjectField(doc_class=CLCEntryParent)
class AwardDoc(DocType): tender_title = fields.KeywordField(attr='tender.title') vendors_name = fields.KeywordField(attr='get_vendors') value = fields.TextField(attr="convert_value_to_string") class Meta: model = Award fields = [ 'currency', ]
class ExperimentDocument(Document): """ Our Experiment ElasticSearch Document, which corresponds to our Experiment model. """ # Keyword Fields title = fields.TextField(analyzer=html_strip, fielddata=True, fields={"raw": fields.KeywordField()}) publication_title = fields.TextField(analyzer=html_strip, fielddata=True, fields={"raw": fields.KeywordField()}) description = fields.TextField(analyzer=html_strip, fielddata=True, fields={"raw": fields.KeywordField()}) publication_authors = fields.TextField( analyzer=html_strip, fielddata=True, fields={"raw": fields.KeywordField()}) technology = fields.TextField(analyzer=html_strip_no_stop, fielddata=True, fields={"raw": fields.KeywordField()}) organism_names = fields.TextField(analyzer=html_strip_no_ngram, fielddata=True, fields={"raw": fields.KeywordField()}) platform_names = fields.TextField(analyzer=standard_keyword, fielddata=True, fields={"raw": fields.TextField()}) platform_accession_codes = fields.TextField( analyzer=standard_keyword, fielddata=True, fields={"raw": fields.TextField()}) # Basic Fields accession_code = fields.KeywordField() alternate_accession_code = fields.KeywordField() submitter_institution = fields.TextField() publication_doi = fields.TextField() has_publication = fields.BooleanField() sample_metadata_fields = fields.TextField() pubmed_id = fields.TextField() num_total_samples = fields.IntegerField() num_processed_samples = fields.IntegerField() num_downloadable_samples = fields.IntegerField() source_first_published = fields.DateField() # Index all downloadable samples as keywords so that we can calculate unique counts on the facets downloadable_samples = fields.ListField(fields.KeywordField()) class Django: model = Experiment parallel_indexing = True queryset_pagination = 3000 fields = [ "id", ] def get_queryset(self): """ Override default queryset """ return super(ExperimentDocument, self).get_queryset().order_by("id")
class SourceDocument(Document): class Index: name = 'sources' settings = {'number_of_shards': 1, 'number_of_replicas': 0} locale = fields.ListField(fields.KeywordField()) last_update = fields.DateField(attr='updated_at') owner = fields.KeywordField(attr='parent_resource', normalizer='lowercase') owner_type = fields.KeywordField(attr='parent_resource_type') public_can_view = fields.TextField(attr='public_can_view') source_type = fields.KeywordField(attr='source_type', normalizer='lowercase') is_active = fields.KeywordField(attr='is_active') version = fields.KeywordField(attr='version') name = fields.KeywordField(attr='name', normalizer='lowercase') canonical_url = fields.KeywordField(attr='canonical_url', normalizer='lowercase') mnemonic = fields.KeywordField(attr='mnemonic', normalizer='lowercase') extras = fields.ObjectField() class Django: model = Source fields = [ 'full_name', 'custom_validation_schema', ] @staticmethod def prepare_locale(instance): return get(instance.supported_locales, []) @staticmethod def prepare_extras(instance): return instance.extras or {}
class Party(InnerDoc): name = fields.TextField(attr="party.name", copy_to="wildcard", analyzer=descriptive_text_analyzer) address = fields.TextField(attr="party.address", copy_to="wildcard", analyzer=address_analyzer,) type = fields.KeywordField( attr="party.type", fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),}, ) country = fields.KeywordField( fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),}, attr="party.country.name", )
class ArticleDoc(DocType): id = fields.IntegerField() slug = fields.KeywordField() title = fields.TextField(analyzer=polish_analyzer, fields={ 'raw': fields.KeywordField(), 'suggest': fields.CompletionField() }) notes = fields.TextField(analyzer=polish_analyzer, fields={ 'raw': fields.TextField(), }) author = fields.TextField( analyzer=standard_analyzer, fields={ 'raw': fields.KeywordField(), # TODO: fix author data before this # 'suggest': fields.CompletionField() }) datasets = datasets_field(attr='published_datasets') license = fields.NestedField( properties={ 'id': fields.IntegerField(), 'name': fields.TextField(), 'title': fields.TextField(), 'url': fields.TextField() }) tags = fields.KeywordField(attr='tags_list', multi=True) views_count = fields.IntegerField() users_following = fields.KeywordField(attr='users_following_list', multi=True) status = fields.TextField() modified = fields.DateField() created = fields.DateField() class Meta: doc_type = 'article' model = Article related_models = [Tag, Dataset, UserFollowingArticle] def get_instances_from_related(self, related_instance): if isinstance(related_instance, UserFollowingArticle): return related_instance.follower.followed_applications.all() if isinstance(related_instance, Dataset): return related_instance.articles.all() if isinstance(related_instance, Tag): return related_instance.articles.all() def get_queryset(self): return self._doc_type.model.objects.filter( status__in=['published', 'draft'])
class ArticleDocument(DocType): title = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) url = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) description = fields.TextField( fields={'raw': fields.KeywordField()}, analyzer=analyzer, ) start_publication = fields.DateField() author = fields.ListField(fields.IntegerField()) category = fields.ListField(fields.IntegerField()) content = fields.TextField( analyzer=analyzer ) special_signals = True class Meta: model = Article queryset_chunk_size = 100 def get_queryset(self): return Article.published.all() def prepare_content(self, obj): html = obj.get_html_content() return strip_tags(html) def prepare_description(self, obj): return strip_tags(obj.description) def prepare_url(self, obj): return obj.get_absolute_url() def prepare_title(self, obj): return obj.title def prepare_start_publication(self, obj): return obj.start_publication def prepare_category(self, obj): cats = obj.categories.all() return [o.id for o in cats] def prepare_author(self, obj): authors = obj.authors.all() return [o.id for o in authors]
class Rating(InnerDoc): rating = fields.KeywordField( fields={ "raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(), }, copy_to="wildcard", ) text = fields.TextField( copy_to="wildcard", analyzer=descriptive_text_analyzer, )