442 lines
13 KiB
Python
442 lines
13 KiB
Python
# encoding: utf-8
|
|
from __future__ import absolute_import, division, print_function, unicode_literals
|
|
|
|
import re
|
|
|
|
from django.template import Context, loader
|
|
from django.utils import datetime_safe, six
|
|
|
|
from haystack.exceptions import SearchFieldError
|
|
from haystack.utils import get_model_ct_tuple
|
|
|
|
|
|
class NOT_PROVIDED:
|
|
pass
|
|
|
|
|
|
DATETIME_REGEX = re.compile('^(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})(T|\s+)(?P<hour>\d{2}):(?P<minute>\d{2}):(?P<second>\d{2}).*?$')
|
|
|
|
|
|
# All the SearchFields variants.
|
|
|
|
class SearchField(object):
|
|
"""The base implementation of a search field."""
|
|
field_type = None
|
|
|
|
def __init__(self, model_attr=None, use_template=False, template_name=None,
|
|
document=False, indexed=True, stored=True, faceted=False,
|
|
default=NOT_PROVIDED, null=False, index_fieldname=None,
|
|
facet_class=None, boost=1.0, weight=None):
|
|
# Track what the index thinks this field is called.
|
|
self.instance_name = None
|
|
self.model_attr = model_attr
|
|
self.use_template = use_template
|
|
self.template_name = template_name
|
|
self.document = document
|
|
self.indexed = indexed
|
|
self.stored = stored
|
|
self.faceted = faceted
|
|
self._default = default
|
|
self.null = null
|
|
self.index_fieldname = index_fieldname
|
|
self.boost = weight or boost
|
|
self.is_multivalued = False
|
|
|
|
# We supply the facet_class for making it easy to create a faceted
|
|
# field based off of this field.
|
|
self.facet_class = facet_class
|
|
|
|
if self.facet_class is None:
|
|
self.facet_class = FacetCharField
|
|
|
|
self.set_instance_name(None)
|
|
|
|
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 has_default(self):
|
|
"""Returns a boolean of whether this field has a default value."""
|
|
return self._default is not NOT_PROVIDED
|
|
|
|
@property
|
|
def default(self):
|
|
"""Returns the default value for the field."""
|
|
if callable(self._default):
|
|
return self._default()
|
|
|
|
return self._default
|
|
|
|
def prepare(self, obj):
|
|
"""
|
|
Takes data from the provided object and prepares it for storage in the
|
|
index.
|
|
"""
|
|
# Give priority to a template.
|
|
if self.use_template:
|
|
return self.prepare_template(obj)
|
|
elif self.model_attr is not None:
|
|
# Check for `__` in the field for looking through the relation.
|
|
attrs = self.model_attr.split('__')
|
|
current_object = obj
|
|
|
|
for attr in attrs:
|
|
if not hasattr(current_object, attr):
|
|
raise SearchFieldError("The model '%s' does not have a model_attr '%s'." % (repr(current_object), attr))
|
|
|
|
current_object = getattr(current_object, attr, None)
|
|
|
|
if current_object is None:
|
|
if self.has_default():
|
|
current_object = self._default
|
|
# Fall out of the loop, given any further attempts at
|
|
# accesses will fail miserably.
|
|
break
|
|
elif self.null:
|
|
current_object = None
|
|
# Fall out of the loop, given any further attempts at
|
|
# accesses will fail miserably.
|
|
break
|
|
else:
|
|
raise SearchFieldError("The model '%s' combined with model_attr '%s' returned None, but doesn't allow a default or null value." % (repr(obj), self.model_attr))
|
|
|
|
if callable(current_object):
|
|
return current_object()
|
|
|
|
return current_object
|
|
|
|
if self.has_default():
|
|
return self.default
|
|
else:
|
|
return None
|
|
|
|
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 convert(self, value):
|
|
"""
|
|
Handles conversion between the data found and the type of the field.
|
|
|
|
Extending classes should override this method and provide correct
|
|
data coercion.
|
|
"""
|
|
return value
|
|
|
|
|
|
class CharField(SearchField):
|
|
field_type = 'string'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetCharField
|
|
|
|
super(CharField, self).__init__(**kwargs)
|
|
|
|
def prepare(self, obj):
|
|
return self.convert(super(CharField, self).prepare(obj))
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
return six.text_type(value)
|
|
|
|
|
|
class LocationField(SearchField):
|
|
field_type = 'location'
|
|
|
|
def prepare(self, obj):
|
|
from haystack.utils.geo import ensure_point
|
|
|
|
value = super(LocationField, self).prepare(obj)
|
|
|
|
if value is None:
|
|
return None
|
|
|
|
pnt = ensure_point(value)
|
|
pnt_lng, pnt_lat = pnt.get_coords()
|
|
return "%s,%s" % (pnt_lat, pnt_lng)
|
|
|
|
def convert(self, value):
|
|
from haystack.utils.geo import ensure_point, Point
|
|
|
|
if value is None:
|
|
return None
|
|
|
|
if hasattr(value, 'geom_type'):
|
|
value = ensure_point(value)
|
|
return value
|
|
|
|
if isinstance(value, six.string_types):
|
|
lat, lng = value.split(',')
|
|
elif isinstance(value, (list, tuple)):
|
|
# GeoJSON-alike
|
|
lat, lng = value[1], value[0]
|
|
elif isinstance(value, dict):
|
|
lat = value.get('lat', 0)
|
|
lng = value.get('lon', 0)
|
|
|
|
value = Point(float(lng), float(lat))
|
|
return value
|
|
|
|
|
|
class NgramField(CharField):
|
|
field_type = 'ngram'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('faceted') is True:
|
|
raise SearchFieldError("%s can not be faceted." % self.__class__.__name__)
|
|
|
|
super(NgramField, self).__init__(**kwargs)
|
|
|
|
|
|
class EdgeNgramField(NgramField):
|
|
field_type = 'edge_ngram'
|
|
|
|
|
|
class IntegerField(SearchField):
|
|
field_type = 'integer'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetIntegerField
|
|
|
|
super(IntegerField, self).__init__(**kwargs)
|
|
|
|
def prepare(self, obj):
|
|
return self.convert(super(IntegerField, self).prepare(obj))
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
return int(value)
|
|
|
|
|
|
class FloatField(SearchField):
|
|
field_type = 'float'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetFloatField
|
|
|
|
super(FloatField, self).__init__(**kwargs)
|
|
|
|
def prepare(self, obj):
|
|
return self.convert(super(FloatField, self).prepare(obj))
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
return float(value)
|
|
|
|
|
|
class DecimalField(SearchField):
|
|
field_type = 'string'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetDecimalField
|
|
|
|
super(DecimalField, self).__init__(**kwargs)
|
|
|
|
def prepare(self, obj):
|
|
return self.convert(super(DecimalField, self).prepare(obj))
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
return six.text_type(value)
|
|
|
|
|
|
class BooleanField(SearchField):
|
|
field_type = 'boolean'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetBooleanField
|
|
|
|
super(BooleanField, self).__init__(**kwargs)
|
|
|
|
def prepare(self, obj):
|
|
return self.convert(super(BooleanField, self).prepare(obj))
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
return bool(value)
|
|
|
|
|
|
class DateField(SearchField):
|
|
field_type = 'date'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetDateField
|
|
|
|
super(DateField, self).__init__(**kwargs)
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
if isinstance(value, six.string_types):
|
|
match = DATETIME_REGEX.search(value)
|
|
|
|
if match:
|
|
data = match.groupdict()
|
|
return datetime_safe.date(int(data['year']), int(data['month']), int(data['day']))
|
|
else:
|
|
raise SearchFieldError("Date provided to '%s' field doesn't appear to be a valid date string: '%s'" % (self.instance_name, value))
|
|
|
|
return value
|
|
|
|
|
|
class DateTimeField(SearchField):
|
|
field_type = 'datetime'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetDateTimeField
|
|
|
|
super(DateTimeField, self).__init__(**kwargs)
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
if isinstance(value, six.string_types):
|
|
match = DATETIME_REGEX.search(value)
|
|
|
|
if match:
|
|
data = match.groupdict()
|
|
return datetime_safe.datetime(int(data['year']), int(data['month']), int(data['day']), int(data['hour']), int(data['minute']), int(data['second']))
|
|
else:
|
|
raise SearchFieldError("Datetime provided to '%s' field doesn't appear to be a valid datetime string: '%s'" % (self.instance_name, value))
|
|
|
|
return value
|
|
|
|
|
|
class MultiValueField(SearchField):
|
|
field_type = 'string'
|
|
|
|
def __init__(self, **kwargs):
|
|
if kwargs.get('facet_class') is None:
|
|
kwargs['facet_class'] = FacetMultiValueField
|
|
|
|
if kwargs.get('use_template') is True:
|
|
raise SearchFieldError("'%s' fields can not use templates to prepare their data." % self.__class__.__name__)
|
|
|
|
super(MultiValueField, self).__init__(**kwargs)
|
|
self.is_multivalued = True
|
|
|
|
def prepare(self, obj):
|
|
return self.convert(super(MultiValueField, self).prepare(obj))
|
|
|
|
def convert(self, value):
|
|
if value is None:
|
|
return None
|
|
|
|
return list(value)
|
|
|
|
|
|
class FacetField(SearchField):
|
|
"""
|
|
``FacetField`` is slightly different than the other fields because it can
|
|
work in conjunction with other fields as its data source.
|
|
|
|
Accepts an optional ``facet_for`` kwarg, which should be the field name
|
|
(not ``index_fieldname``) of the field it should pull data from.
|
|
"""
|
|
instance_name = None
|
|
|
|
def __init__(self, **kwargs):
|
|
handled_kwargs = self.handle_facet_parameters(kwargs)
|
|
super(FacetField, self).__init__(**handled_kwargs)
|
|
|
|
def handle_facet_parameters(self, kwargs):
|
|
if kwargs.get('faceted', False):
|
|
raise SearchFieldError("FacetField (%s) does not accept the 'faceted' argument." % self.instance_name)
|
|
|
|
if not kwargs.get('null', True):
|
|
raise SearchFieldError("FacetField (%s) does not accept False for the 'null' argument." % self.instance_name)
|
|
|
|
if not kwargs.get('indexed', True):
|
|
raise SearchFieldError("FacetField (%s) does not accept False for the 'indexed' argument." % self.instance_name)
|
|
|
|
if kwargs.get('facet_class'):
|
|
raise SearchFieldError("FacetField (%s) does not accept the 'facet_class' argument." % self.instance_name)
|
|
|
|
self.facet_for = None
|
|
self.facet_class = None
|
|
|
|
# Make sure the field is nullable.
|
|
kwargs['null'] = True
|
|
|
|
if 'facet_for' in kwargs:
|
|
self.facet_for = kwargs['facet_for']
|
|
del(kwargs['facet_for'])
|
|
|
|
return kwargs
|
|
|
|
def get_facet_for_name(self):
|
|
return self.facet_for or self.instance_name
|
|
|
|
|
|
class FacetCharField(FacetField, CharField):
|
|
pass
|
|
|
|
|
|
class FacetIntegerField(FacetField, IntegerField):
|
|
pass
|
|
|
|
|
|
class FacetFloatField(FacetField, FloatField):
|
|
pass
|
|
|
|
|
|
class FacetDecimalField(FacetField, DecimalField):
|
|
pass
|
|
|
|
|
|
class FacetBooleanField(FacetField, BooleanField):
|
|
pass
|
|
|
|
|
|
class FacetDateField(FacetField, DateField):
|
|
pass
|
|
|
|
|
|
class FacetDateTimeField(FacetField, DateTimeField):
|
|
pass
|
|
|
|
|
|
class FacetMultiValueField(FacetField, MultiValueField):
|
|
pass
|