Algolia Search integration for Django
Project description
Algolia Search API Client for Django
Algolia Search is a hosted full-text, numerical, and faceted search engine capable of delivering realtime results from the first keystroke.
This package lets you easily integrate the Algolia Search API to your Django project. It’s based on the algoliasearch-client-python package.
You might be interested in this sample Django application providing a typeahead.js based auto-completion and Google-like instant search: algoliasearch-django-example
Compatible with Python 2.7, Python 3.3+ and Django 1.7+
API Documentation
You can find the full reference on Algolia’s website.
Table of Contents
`Setup <#setup>`__
`Commands <#commands>`__
`Search <#search>`__
`Geo-Search <#geo-search>`__
`Tags <#tags>`__
`Options <#options>`__
Custom ``objectID` <#custom-objectid>`__
`Tests <#tests>`__
Setup
Install
pip install algoliasearch-django
Setup
In your Django settings, add algoliasearch_django to INSTALLED_APPS and add these two settings:
ALGOLIA = {
'APPLICATION_ID': 'MyAppID',
'API_KEY': 'MyApiKey'
}
There are several optional settings:
INDEX_PREFIX: prefix all indexes. Use it to separate different applications, like site1_Products and site2_Products.
INDEX_SUFFIX: suffix all indexes. Use it to differentiate development and production environment, like Location_dev and Location_prod.
AUTO_INDEXING: automatically synchronize the models with Algolia (default to True).
RAISE_EXCEPTIONS: raise exceptions on network errors instead of logging them (default to settings.DEBUG).
Quick Start
Simply call algoliasearch.register() for each of the models you want to index. A good place to do this is in your application’s AppConfig (generally named apps.py). More info in the documentation
from django.apps import AppConfig
import algoliasearch_django as algoliasearch
class YourAppConfig(AppConfig):
name = 'your_app'
def ready(self):
YourModel = self.get_model('your_model')
algoliasearch.register(YourModel)
And then, don’t forget the line below in the __init__.py file of your Django application.
default_app_config = 'your_django_app.apps.YourAppConfig'
By default, all the fields of your model will be used. You can configure the index by creating a subclass of AlgoliaIndex. A good place to do this is in a separate file, like index.py.
from algoliasearch_django import AlgoliaIndex
class YourModelIndex(AlgoliaIndex):
fields = ('name', 'date')
geo_field = 'location'
settings = {'searchableAttributes': ['name']}
index_name = 'my_index'
And then replace algoliasearch.register(YourModel) with algoliasearch.register(YourModel, YourModelIndex).
Commands
Commands
python manage.py algolia_reindex: reindex all the registered models. This command will first send all the record to a temporary index and then moves it.
you can pass --model parameter to reindex a given model
python manage.py algolia_applysettings: (re)apply the index settings.
python manage.py algolia_clearindex: clear the index
Search
Search
We recommend the usage of our JavaScript API Client to perform queries directly from the end-user browser without going through your server.
However, if you want to search from your backend you can use the raw_search(YourModel, 'yourQuery', params) method. It retrieves the raw JSON answer from the API.
from algoliasearch_django import raw_search
params = { "hitsPerPage": 5 }
raw_search(Contact, "jim", params)
Geo-Search
Geo-Search
Use the geo_field attribute to localize your record. geo_field should be a callable that returns a tuple (latitude, longitude).
class Contact(models.model):
name = models.CharField(max_lenght=20)
lat = models.FloatField()
lng = models.FloatField()
def location(self):
return (self.lat, self.lng)
class ContactIndex(AlgoliaIndex):
fields = 'name'
geo_field = 'location'
algoliasearch.register(Contact, ContactIndex)
Options
Custom objectID
You can choose which field will be used as the objectID. The field should be unique and can be a string or integer. By default, we use the pk field of the model.
class ArticleIndex(AlgoliaIndex):
custom_objectID = 'post_id'
Custom index name
You can customize the index name. By default, the index name will be the name of the model class.
class ContactIndex(algoliaindex):
index_name = 'Enterprise'
Index settings
We provide many ways to configure your index allowing you to tune your overall index relevancy. All the configuration is explained on our doc.
class ArticleIndex(AlgoliaIndex):
settings = {
'searchableAttributes': ['name', 'description', 'url'],
'customRanking': ['desc(vote_count)', 'asc(name)']
}
Restrict indexing to a subset of your data
You can add constraints controlling if a record must be indexed or not. should_index should be a callable that returns a boolean.
class Contact(models.model):
name = models.CharField(max_lenght=20)
age = models.IntegerField()
def is_adult(self):
return (self.age >= 18)
class ContactIndex(AlgoliaIndex):
should_index = 'is_adult'
Multiple indices per model
It is possible to have several indices for a single model.
First, define all your indices that you want for a model:
from django.contrib.algoliasearch import AlgoliaIndex
class MyModelIndex1(AlgoliaIndex):
name = 'MyModelIndex1'
...
class MyModelIndex2(AlgoliaIndex):
name = 'MyModelIndex2'
...
Then, define a meta model which will aggregate those indices:
class MyModelMetaIndex(AlgoliaIndex):
def __init__(self, model, client, settings):
self.indices = [
MyModelIndex1(model, client, settings),
MyModelIndex2(model, client, settings),
]
def raw_search(self, query='', params=None):
res = {}
for index in self.indices:
res[index.name] = index.raw_search(query, params)
return res
def update_records(self, qs, batch_size=1000, **kwargs):
for index in self.indices:
index.update_records(qs, batch_size, **kwargs)
def reindex_all(self, batch_size=1000):
for index in self.indices:
index.reindex_all(batch_size)
def set_settings(self):
for index in self.indices:
index.set_settings()
def clear_index(self):
for index in self.indices:
index.clear_index()
def save_record(self, instance, update_fields=None, **kwargs):
for index in self.indices:
index.save_record(instance, update_fields, **kwargs)
def delete_record(self, instance):
for index in self.indices:
index.delete_record(instance)
Finally, register this AlgoliaIndex with your Model:
import algoliasearch_django as algoliasearch
algoliasearch.register(MyModel, MyModelMetaIndex)
Tests
Run Tests
To run the tests, first find your Algolia application id and Admin API key (found on the Credentials page).
ALGOLIA_APPLICATION_ID={APPLICATION_ID} ALGOLIA_API_KEY={ADMIN_API_KEY} tox
To override settings for some tests, use the settings method:
class OverrideSettingsTestCase(TestCase):
def setUp(self):
with self.settings(ALGOLIA={
'APPLICATION_ID': 'foo',
'API_KEY': 'bar',
'AUTO_INDEXING': False
}):
algolia_engine.reset(settings.ALGOLIA)
def tearDown(self):
algolia_engine.reset(settings.ALGOLIA)
def test_foo():
# ...
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for algoliasearch-django-1.5.4.tar.gz
Algorithm | Hash digest | |
---|---|---|
SHA256 | 3b45c6f3a338b8b7269d52af25b39978774df6689efc12d4f027e803f1a90156 |
|
MD5 | d32ef909f3d6369ff25e637b4e7940df |
|
BLAKE2b-256 | c1e228b314af751181e47c574018cd027a7c9689f3859b81b5bdf1ad27b00bc5 |
Hashes for algoliasearch_django-1.5.4-py2.py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | d81689d066e49cd64c81f5eac74c75f494a6207b4189881eb2b275b1dc704cdd |
|
MD5 | 314fe632bb3a07e1b0ffc08891c6050e |
|
BLAKE2b-256 | a4166311ca14c8ac2dd6dbb308f3f64d1dd0b5245c457bb2ca342af180644a23 |