def __init__(self):
    self.prepared_data = None
    content_fields = []
    self.field_map = dict()
    for field_name, field in self.fields.items():
        #form field map
        self.field_map[field.index_fieldname] = field_name
        if field.document is True:
            content_fields.append(field_name)
    if not len(content_fields) == 1:
        raise SearchFieldError("The index '%s' must have one (and only one) SearchField with document=True." % self.__class__.__name__)

def build_queryset(self, using=None, start_date=None, end_date=None):
    """
    Get the default QuerySet to index when doing an index update.
    Subclasses can override this method to take into account related
    model modification times.
    The default is to use ``SearchIndex.index_queryset`` and filter
    based on ``SearchIndex.get_updated_field``
    """
    extra_lookup_kwargs = {}
    model = self.get_model()
    updated_field = self.get_updated_field()
    update_field_msg = ("No updated date field found for '%s' "
                        "- not restricting by age.") % model.__name__
    if start_date:
        if updated_field:
            extra_lookup_kwargs['%s__gte' % updated_field] = start_date
        else:
            warnings.warn(update_field_msg)
    if end_date:
        if updated_field:
            extra_lookup_kwargs['%s__lte' % updated_field] = end_date
        else:
            warnings.warn(update_field_msg)
    index_qs = None
    if hasattr(self, 'get_queryset'):
        warnings.warn("'SearchIndex.get_queryset' was deprecated in Haystack v2. Please rename the method 'index_queryset'.")
        index_qs = self.get_queryset()
    else:
        index_qs = self.index_queryset(using=using)
    if not hasattr(index_qs, 'filter'):
        raise ImproperlyConfigured("The '%r' class must return a 'QuerySet' in the 'index_queryset' method." % self)
    # `.select_related()` seems like a good idea here but can fail on
    # nullable `ForeignKey` as well as what seems like other cases.
    return index_qs.filter(**extra_lookup_kwargs).order_by(model._meta.pk.name)

def clear(self, using=None):
    """
    Clears the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.clear(models=[self.get_model()])

def full_prepare(self, obj):
    self.prepared_data = self.prepare(obj)
    for field_name, field in self.fields.items():
        # Duplicate data for faceted fields.
        if getattr(field, 'facet_for', None):
            source_field_name = self.fields[field.facet_for].index_fieldname
            # If there's data there, leave it alone. Otherwise, populate it
            # with whatever the related field has.
            if self.prepared_data[field_name] is None and source_field_name in self.prepared_data:
                self.prepared_data[field.index_fieldname] = self.prepared_data[source_field_name]
        # Remove any fields that lack a value and are ``null=True``.
        if field.null is True:
            if self.prepared_data[field.index_fieldname] is None:
                del(self.prepared_data[field.index_fieldname])
    return self.prepared_data

def get_content_field(self):
    """Returns the field that supplies the primary document to be indexed."""
    for field_name, field in self.fields.items():
        if field.document is True:
            return field.index_fieldname

def get_field_weights(self):
    """Returns a dict of fields with weight values"""
    weights = {}
    for field_name, field in self.fields.items():
        if field.boost:
            weights[field_name] = field.boost
    return weights

def get_model(self):
    return InstrumentAlias

def get_updated_field(self):
    """
    Get the field name that represents the updated date for the model.
    If specified, this is used by the reindex command to filter out results
    from the QuerySet, enabling you to reindex only recent records. This
    method should either return None (reindex everything always) or a
    string of the Model's DateField/DateTimeField name.
    """
    return None

def index_queryset(self, using=None):
    instrualias = MediaItemPerformance.objects.values('alias')
    return InstrumentAlias.objects.filter(pk__in=instrualias)

def load_all_queryset(self):
    """
    Provides the ability to override how objects get loaded in conjunction
    with ``SearchQuerySet.load_all``.
    This is useful for post-processing the results from the query, enabling
    things like adding ``select_related`` or filtering certain data.
    By default, returns ``all()`` on the model's default manager.
    """
    return self.get_model()._default_manager.all()

def prepare(self, obj):
    """
    Fetches and adds/alters data before indexing.
    """
    self.prepared_data = {
        ID: get_identifier(obj),
        DJANGO_CT: get_model_ct(obj),
        DJANGO_ID: force_text(obj.pk),
    }
    for field_name, field in self.fields.items():
        # Use the possibly overridden name, which will default to the
        # variable name of the field.
        self.prepared_data[field.index_fieldname] = field.prepare(obj)
        if hasattr(self, "prepare_%s" % field_name):
            value = getattr(self, "prepare_%s" % field_name)(obj)
            self.prepared_data[field.index_fieldname] = value
    return self.prepared_data

def read_queryset(self, using=None):
    """
    Get the default QuerySet for read actions.
    Subclasses can override this method to work with other managers.
    Useful when working with default managers that filter some objects.
    """
    return self.index_queryset(using=using)

def reindex(self, using=None):
    """
    Completely clear the index for this model and rebuild it.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    self.clear(using=using)
    self.update(using=using)

def remove_object(self, instance, using=None, **kwargs):
    """
    Remove an object from the index. Attached to the class's
    post-delete hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.remove(instance, **kwargs)

def should_update(self, instance, **kwargs):
    """
    Determine if an object should be updated in the index.
    It's useful to override this when an object may save frequently and
    cause excessive reindexing. You should check conditions on the instance
    and return False if it is not to be indexed.
    By default, returns True (always reindex).
    """
    return True

def update(self, using=None):
    """
    Updates the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.update(self, self.index_queryset(using=using))

def update_object(self, instance, using=None, **kwargs):
    """
    Update the index for a single object. Attached to the class's
    post-save hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    # Check to make sure we want to index this first.
    if self.should_update(instance, **kwargs):
        backend = self._get_backend(using)
        if backend is not None:
            backend.update(self, [instance])

def __init__(self):
    self.prepared_data = None
    content_fields = []
    self.field_map = dict()
    for field_name, field in self.fields.items():
        #form field map
        self.field_map[field.index_fieldname] = field_name
        if field.document is True:
            content_fields.append(field_name)
    if not len(content_fields) == 1:
        raise SearchFieldError("The index '%s' must have one (and only one) SearchField with document=True." % self.__class__.__name__)

def build_queryset(self, using=None, start_date=None, end_date=None):
    """
    Get the default QuerySet to index when doing an index update.
    Subclasses can override this method to take into account related
    model modification times.
    The default is to use ``SearchIndex.index_queryset`` and filter
    based on ``SearchIndex.get_updated_field``
    """
    extra_lookup_kwargs = {}
    model = self.get_model()
    updated_field = self.get_updated_field()
    update_field_msg = ("No updated date field found for '%s' "
                        "- not restricting by age.") % model.__name__
    if start_date:
        if updated_field:
            extra_lookup_kwargs['%s__gte' % updated_field] = start_date
        else:
            warnings.warn(update_field_msg)
    if end_date:
        if updated_field:
            extra_lookup_kwargs['%s__lte' % updated_field] = end_date
        else:
            warnings.warn(update_field_msg)
    index_qs = None
    if hasattr(self, 'get_queryset'):
        warnings.warn("'SearchIndex.get_queryset' was deprecated in Haystack v2. Please rename the method 'index_queryset'.")
        index_qs = self.get_queryset()
    else:
        index_qs = self.index_queryset(using=using)
    if not hasattr(index_qs, 'filter'):
        raise ImproperlyConfigured("The '%r' class must return a 'QuerySet' in the 'index_queryset' method." % self)
    # `.select_related()` seems like a good idea here but can fail on
    # nullable `ForeignKey` as well as what seems like other cases.
    return index_qs.filter(**extra_lookup_kwargs).order_by(model._meta.pk.name)

def clear(self, using=None):
    """
    Clears the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.clear(models=[self.get_model()])

def full_prepare(self, obj):
    self.prepared_data = self.prepare(obj)
    for field_name, field in self.fields.items():
        # Duplicate data for faceted fields.
        if getattr(field, 'facet_for', None):
            source_field_name = self.fields[field.facet_for].index_fieldname
            # If there's data there, leave it alone. Otherwise, populate it
            # with whatever the related field has.
            if self.prepared_data[field_name] is None and source_field_name in self.prepared_data:
                self.prepared_data[field.index_fieldname] = self.prepared_data[source_field_name]
        # Remove any fields that lack a value and are ``null=True``.
        if field.null is True:
            if self.prepared_data[field.index_fieldname] is None:
                del(self.prepared_data[field.index_fieldname])
    return self.prepared_data

def get_content_field(self):
    """Returns the field that supplies the primary document to be indexed."""
    for field_name, field in self.fields.items():
        if field.document is True:
            return field.index_fieldname

def get_field_weights(self):
    """Returns a dict of fields with weight values"""
    weights = {}
    for field_name, field in self.fields.items():
        if field.boost:
            weights[field_name] = field.boost
    return weights

def get_model(self):
    return Instrument

def get_updated_field(self):
    """
    Get the field name that represents the updated date for the model.
    If specified, this is used by the reindex command to filter out results
    from the QuerySet, enabling you to reindex only recent records. This
    method should either return None (reindex everything always) or a
    string of the Model's DateField/DateTimeField name.
    """
    return None

def index_queryset(self, using=None):
    instrus = MediaItemPerformance.objects.values('instrument')
    return Instrument.objects.filter(pk__in=instrus)

def load_all_queryset(self):
    """
    Provides the ability to override how objects get loaded in conjunction
    with ``SearchQuerySet.load_all``.
    This is useful for post-processing the results from the query, enabling
    things like adding ``select_related`` or filtering certain data.
    By default, returns ``all()`` on the model's default manager.
    """
    return self.get_model()._default_manager.all()

def prepare(self, obj):
    """
    Fetches and adds/alters data before indexing.
    """
    self.prepared_data = {
        ID: get_identifier(obj),
        DJANGO_CT: get_model_ct(obj),
        DJANGO_ID: force_text(obj.pk),
    }
    for field_name, field in self.fields.items():
        # Use the possibly overridden name, which will default to the
        # variable name of the field.
        self.prepared_data[field.index_fieldname] = field.prepare(obj)
        if hasattr(self, "prepare_%s" % field_name):
            value = getattr(self, "prepare_%s" % field_name)(obj)
            self.prepared_data[field.index_fieldname] = value
    return self.prepared_data

def read_queryset(self, using=None):
    """
    Get the default QuerySet for read actions.
    Subclasses can override this method to work with other managers.
    Useful when working with default managers that filter some objects.
    """
    return self.index_queryset(using=using)

def reindex(self, using=None):
    """
    Completely clear the index for this model and rebuild it.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    self.clear(using=using)
    self.update(using=using)

def remove_object(self, instance, using=None, **kwargs):
    """
    Remove an object from the index. Attached to the class's
    post-delete hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.remove(instance, **kwargs)

def should_update(self, instance, **kwargs):
    """
    Determine if an object should be updated in the index.
    It's useful to override this when an object may save frequently and
    cause excessive reindexing. You should check conditions on the instance
    and return False if it is not to be indexed.
    By default, returns True (always reindex).
    """
    return True

def update(self, using=None):
    """
    Updates the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.update(self, self.index_queryset(using=using))

def update_object(self, instance, using=None, **kwargs):
    """
    Update the index for a single object. Attached to the class's
    post-save hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    # Check to make sure we want to index this first.
    if self.should_update(instance, **kwargs):
        backend = self._get_backend(using)
        if backend is not None:
            backend.update(self, [instance])

def __init__(self, **kwargs):
    if kwargs.get('facet_class') is None:
        kwargs['facet_class'] = FacetCharField
    super(CharField, self).__init__(**kwargs)

def convert(self, value):
    if value is None:
        return None
    return six.text_type(value)

def has_default(self):
    """Returns a boolean of whether this field has a default value."""
    return self._default is not NOT_PROVIDED

def prepare(self, obj):
    return self.convert(super(CharField, self).prepare(obj))

def prepare_template(self, obj):
    """
    Flattens an object for indexing.
    This loads a template
    (``search/indexes/{app_label}/{model_name}_{field_name}.txt``) and
    returns the result of rendering that template. ``object`` will be in
    its context.
    """
    if self.instance_name is None and self.template_name is None:
        raise SearchFieldError("This field requires either its instance_name variable to be populated or an explicit template_name in order to load the correct template.")
    if self.template_name is not None:
        template_names = self.template_name
        if not isinstance(template_names, (list, tuple)):
            template_names = [template_names]
    else:
        app_label, model_name = get_model_ct_tuple(obj)
        template_names = ['search/indexes/%s/%s_%s.txt' % (app_label, model_name, self.instance_name)]
    t = loader.select_template(template_names)
    return t.render(Context({'object': obj}))

def set_instance_name(self, instance_name):
    self.instance_name = instance_name
    if self.index_fieldname is None:
        self.index_fieldname = self.instance_name

def __init__(self):
    self.prepared_data = None
    content_fields = []
    self.field_map = dict()
    for field_name, field in self.fields.items():
        #form field map
        self.field_map[field.index_fieldname] = field_name
        if field.document is True:
            content_fields.append(field_name)
    if not len(content_fields) == 1:
        raise SearchFieldError("The index '%s' must have one (and only one) SearchField with document=True." % self.__class__.__name__)

def build_queryset(self, using=None, start_date=None, end_date=None):
    """
    Get the default QuerySet to index when doing an index update.
    Subclasses can override this method to take into account related
    model modification times.
    The default is to use ``SearchIndex.index_queryset`` and filter
    based on ``SearchIndex.get_updated_field``
    """
    extra_lookup_kwargs = {}
    model = self.get_model()
    updated_field = self.get_updated_field()
    update_field_msg = ("No updated date field found for '%s' "
                        "- not restricting by age.") % model.__name__
    if start_date:
        if updated_field:
            extra_lookup_kwargs['%s__gte' % updated_field] = start_date
        else:
            warnings.warn(update_field_msg)
    if end_date:
        if updated_field:
            extra_lookup_kwargs['%s__lte' % updated_field] = end_date
        else:
            warnings.warn(update_field_msg)
    index_qs = None
    if hasattr(self, 'get_queryset'):
        warnings.warn("'SearchIndex.get_queryset' was deprecated in Haystack v2. Please rename the method 'index_queryset'.")
        index_qs = self.get_queryset()
    else:
        index_qs = self.index_queryset(using=using)
    if not hasattr(index_qs, 'filter'):
        raise ImproperlyConfigured("The '%r' class must return a 'QuerySet' in the 'index_queryset' method." % self)
    # `.select_related()` seems like a good idea here but can fail on
    # nullable `ForeignKey` as well as what seems like other cases.
    return index_qs.filter(**extra_lookup_kwargs).order_by(model._meta.pk.name)

def clear(self, using=None):
    """
    Clears the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.clear(models=[self.get_model()])

def full_prepare(self, obj):
    self.prepared_data = self.prepare(obj)
    for field_name, field in self.fields.items():
        # Duplicate data for faceted fields.
        if getattr(field, 'facet_for', None):
            source_field_name = self.fields[field.facet_for].index_fieldname
            # If there's data there, leave it alone. Otherwise, populate it
            # with whatever the related field has.
            if self.prepared_data[field_name] is None and source_field_name in self.prepared_data:
                self.prepared_data[field.index_fieldname] = self.prepared_data[source_field_name]
        # Remove any fields that lack a value and are ``null=True``.
        if field.null is True:
            if self.prepared_data[field.index_fieldname] is None:
                del(self.prepared_data[field.index_fieldname])
    return self.prepared_data

def get_content_field(self):
    """Returns the field that supplies the primary document to be indexed."""
    for field_name, field in self.fields.items():
        if field.document is True:
            return field.index_fieldname

def get_field_weights(self):
    """Returns a dict of fields with weight values"""
    weights = {}
    for field_name, field in self.fields.items():
        if field.boost:
            weights[field_name] = field.boost
    return weights

def get_model(self):
    return LocationAlias

def get_updated_field(self):
    """
    Get the field name that represents the updated date for the model.
    If specified, this is used by the reindex command to filter out results
    from the QuerySet, enabling you to reindex only recent records. This
    method should either return None (reindex everything always) or a
    string of the Model's DateField/DateTimeField name.
    """
    return None

def index_queryset(self, using=None):
    l = MediaItem.objects.values('location')
    return LocationAlias.objects.filter(location__in=l)

def load_all_queryset(self):
    """
    Provides the ability to override how objects get loaded in conjunction
    with ``SearchQuerySet.load_all``.
    This is useful for post-processing the results from the query, enabling
    things like adding ``select_related`` or filtering certain data.
    By default, returns ``all()`` on the model's default manager.
    """
    return self.get_model()._default_manager.all()

def prepare(self, obj):
    """
    Fetches and adds/alters data before indexing.
    """
    self.prepared_data = {
        ID: get_identifier(obj),
        DJANGO_CT: get_model_ct(obj),
        DJANGO_ID: force_text(obj.pk),
    }
    for field_name, field in self.fields.items():
        # Use the possibly overridden name, which will default to the
        # variable name of the field.
        self.prepared_data[field.index_fieldname] = field.prepare(obj)
        if hasattr(self, "prepare_%s" % field_name):
            value = getattr(self, "prepare_%s" % field_name)(obj)
            self.prepared_data[field.index_fieldname] = value
    return self.prepared_data

def read_queryset(self, using=None):
    """
    Get the default QuerySet for read actions.
    Subclasses can override this method to work with other managers.
    Useful when working with default managers that filter some objects.
    """
    return self.index_queryset(using=using)

def reindex(self, using=None):
    """
    Completely clear the index for this model and rebuild it.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    self.clear(using=using)
    self.update(using=using)

def remove_object(self, instance, using=None, **kwargs):
    """
    Remove an object from the index. Attached to the class's
    post-delete hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.remove(instance, **kwargs)

def should_update(self, instance, **kwargs):
    """
    Determine if an object should be updated in the index.
    It's useful to override this when an object may save frequently and
    cause excessive reindexing. You should check conditions on the instance
    and return False if it is not to be indexed.
    By default, returns True (always reindex).
    """
    return True

def update(self, using=None):
    """
    Updates the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.update(self, self.index_queryset(using=using))

def update_object(self, instance, using=None, **kwargs):
    """
    Update the index for a single object. Attached to the class's
    post-save hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    # Check to make sure we want to index this first.
    if self.should_update(instance, **kwargs):
        backend = self._get_backend(using)
        if backend is not None:
            backend.update(self, [instance])

def __init__(self):
    self.prepared_data = None
    content_fields = []
    self.field_map = dict()
    for field_name, field in self.fields.items():
        #form field map
        self.field_map[field.index_fieldname] = field_name
        if field.document is True:
            content_fields.append(field_name)
    if not len(content_fields) == 1:
        raise SearchFieldError("The index '%s' must have one (and only one) SearchField with document=True." % self.__class__.__name__)

def build_queryset(self, using=None, start_date=None, end_date=None):
    """
    Get the default QuerySet to index when doing an index update.
    Subclasses can override this method to take into account related
    model modification times.
    The default is to use ``SearchIndex.index_queryset`` and filter
    based on ``SearchIndex.get_updated_field``
    """
    extra_lookup_kwargs = {}
    model = self.get_model()
    updated_field = self.get_updated_field()
    update_field_msg = ("No updated date field found for '%s' "
                        "- not restricting by age.") % model.__name__
    if start_date:
        if updated_field:
            extra_lookup_kwargs['%s__gte' % updated_field] = start_date
        else:
            warnings.warn(update_field_msg)
    if end_date:
        if updated_field:
            extra_lookup_kwargs['%s__lte' % updated_field] = end_date
        else:
            warnings.warn(update_field_msg)
    index_qs = None
    if hasattr(self, 'get_queryset'):
        warnings.warn("'SearchIndex.get_queryset' was deprecated in Haystack v2. Please rename the method 'index_queryset'.")
        index_qs = self.get_queryset()
    else:
        index_qs = self.index_queryset(using=using)
    if not hasattr(index_qs, 'filter'):
        raise ImproperlyConfigured("The '%r' class must return a 'QuerySet' in the 'index_queryset' method." % self)
    # `.select_related()` seems like a good idea here but can fail on
    # nullable `ForeignKey` as well as what seems like other cases.
    return index_qs.filter(**extra_lookup_kwargs).order_by(model._meta.pk.name)

def clear(self, using=None):
    """
    Clears the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.clear(models=[self.get_model()])

def full_prepare(self, obj):
    self.prepared_data = self.prepare(obj)
    for field_name, field in self.fields.items():
        # Duplicate data for faceted fields.
        if getattr(field, 'facet_for', None):
            source_field_name = self.fields[field.facet_for].index_fieldname
            # If there's data there, leave it alone. Otherwise, populate it
            # with whatever the related field has.
            if self.prepared_data[field_name] is None and source_field_name in self.prepared_data:
                self.prepared_data[field.index_fieldname] = self.prepared_data[source_field_name]
        # Remove any fields that lack a value and are ``null=True``.
        if field.null is True:
            if self.prepared_data[field.index_fieldname] is None:
                del(self.prepared_data[field.index_fieldname])
    return self.prepared_data

def get_content_field(self):
    """Returns the field that supplies the primary document to be indexed."""
    for field_name, field in self.fields.items():
        if field.document is True:
            return field.index_fieldname

def get_field_weights(self):
    """Returns a dict of fields with weight values"""
    weights = {}
    for field_name, field in self.fields.items():
        if field.boost:
            weights[field_name] = field.boost
    return weights

def get_model(self):
    return Location

def get_updated_field(self):
    """
    Get the field name that represents the updated date for the model.
    If specified, this is used by the reindex command to filter out results
    from the QuerySet, enabling you to reindex only recent records. This
    method should either return None (reindex everything always) or a
    string of the Model's DateField/DateTimeField name.
    """
    return None

def index_queryset(self, using=None):
    loc = MediaItem.objects.values('location')
    old = Location.objects.filter(current_location__in=loc).values('id')
    anc = LocationRelation.objects.filter(location__in=loc).values('ancestor_location')
    return Location.objects.filter(Q(pk__in=loc)|Q(pk__in=old)|Q(pk__in=anc))

def load_all_queryset(self):
    """
    Provides the ability to override how objects get loaded in conjunction
    with ``SearchQuerySet.load_all``.
    This is useful for post-processing the results from the query, enabling
    things like adding ``select_related`` or filtering certain data.
    By default, returns ``all()`` on the model's default manager.
    """
    return self.get_model()._default_manager.all()

def prepare(self, obj):
    """
    Fetches and adds/alters data before indexing.
    """
    self.prepared_data = {
        ID: get_identifier(obj),
        DJANGO_CT: get_model_ct(obj),
        DJANGO_ID: force_text(obj.pk),
    }
    for field_name, field in self.fields.items():
        # Use the possibly overridden name, which will default to the
        # variable name of the field.
        self.prepared_data[field.index_fieldname] = field.prepare(obj)
        if hasattr(self, "prepare_%s" % field_name):
            value = getattr(self, "prepare_%s" % field_name)(obj)
            self.prepared_data[field.index_fieldname] = value
    return self.prepared_data

def read_queryset(self, using=None):
    """
    Get the default QuerySet for read actions.
    Subclasses can override this method to work with other managers.
    Useful when working with default managers that filter some objects.
    """
    return self.index_queryset(using=using)

def reindex(self, using=None):
    """
    Completely clear the index for this model and rebuild it.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    self.clear(using=using)
    self.update(using=using)

def remove_object(self, instance, using=None, **kwargs):
    """
    Remove an object from the index. Attached to the class's
    post-delete hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.remove(instance, **kwargs)

def should_update(self, instance, **kwargs):
    """
    Determine if an object should be updated in the index.
    It's useful to override this when an object may save frequently and
    cause excessive reindexing. You should check conditions on the instance
    and return False if it is not to be indexed.
    By default, returns True (always reindex).
    """
    return True

def update(self, using=None):
    """
    Updates the entire index.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    backend = self._get_backend(using)
    if backend is not None:
        backend.update(self, self.index_queryset(using=using))

def update_object(self, instance, using=None, **kwargs):
    """
    Update the index for a single object. Attached to the class's
    post-save hook.
    If ``using`` is provided, it specifies which connection should be
    used. Default relies on the routers to decide which backend should
    be used.
    """
    # Check to make sure we want to index this first.
    if self.should_update(instance, **kwargs):
        backend = self._get_backend(using)
        if backend is not None:
            backend.update(self, [instance])

def __init__(self):
    self.prepared_data = None
    content_fields = []
    self.field_map = dict()
    for field_name, field in self.fields.items():
        #form field map
        self.field_map[field.index_fieldname] = field_name
        if field.document is True:
            content_fields.append(field_name)
    if not len(content_fields) == 1:
        raise SearchFieldError("The index '%s' must have one (and only one) SearchField with document=True." % self.__class__.__name__)

def build_queryset(self, using=None, start_date=None, end_date=None):
    """
    Get the default QuerySet to index when doing an index update.
    Subclasses can override this method to take into account related
    model modification times.
    The default is to use ``SearchIndex.index_queryset`` and filter
    based on ``SearchIndex.get_updated_field``
    """
    extra_lookup_kwargs = {}
    model = self.get_model()
    updated_field = self.get_updated_field()
    update_field_msg = ("No updated date field found for '%s' "
                        "- not restricting by age.") % model.__name__
    if start_date:
        if updated_field:
            extra_lookup_kwargs['%s__gte' % updated_field] = start_date
        else:
            warnings.warn(update_field_msg)
    if end_date:
        if updated_field:
            extra_lookup_kwargs['%s__lte' % updated_field] = end_date
        else:
            warnings.warn(update_field_msg)
    index_qs = None
    if hasattr(self, 'get_queryset'):
        warnings.warn("'SearchIndex.get_queryset' was deprecated in Haystack v2. Please rename the method 'index_queryset'.")
        index_qs = self.get_queryset()
    else:
        index_qs = self.index_queryset(using=using)
    if not hasattr(index_qs, 'filter'):
        raise ImproperlyConfigured("The '%r' class must return a 'QuerySet' in the 'index_queryset' method." % self)
    # `.select_related()` seems like a good idea here but can fail on
    # nullable `ForeignKey` as well as what seems like other cases.
    return index_qs.filter(**extra_lookup_kwargs).order_by(model._meta.pk.name)