def _delete(self, url, headers=None, callback=None):
h = HTTPHeaders()
h.update(self._default_headers)
if headers:
h.update(headers)
req = HTTPRequest(url, headers=headers, method="DELETE")
self._client.fetch(req, callback)
def make_post_request(url,
data='',
headers=None,
files=None,
content_type=None,
connect_timeout=None,
request_timeout=None,
follow_redirects=True):
if files:
body, content_type = make_mfd(data, files)
else:
body = make_body(data)
headers = HTTPHeaders() if headers is None else HTTPHeaders(headers)
if content_type is None:
content_type = headers.get('Content-Type',
'application/x-www-form-urlencoded')
headers.update({
'Content-Type': content_type,
'Content-Length': str(len(body))
})
return HTTPRequest(url=_encode(url),
body=body,
method='POST',
headers=headers,
follow_redirects=follow_redirects,
connect_timeout=connect_timeout,
request_timeout=request_timeout)
def set_stub(http_client,
url,
request_method='GET',
response_function=None,
response_file=None,
response_body='',
response_code=httpcodes.OK,
response_headers=None,
response_body_processor=safe_template,
**kwargs):
"""Set response stub for requested url.
:param str url: url to be stubbed. Url can contain PEP-292 placeholders
(see https://docs.python.org/3/library/string.html#template-strings) which will be replaced
with `kwargs` values.
:param str request_method: 'GET', 'POST' or any other request method.
:param callable response_function: function that takes the `HTTPRequest` instance passed to `fetch_impl`
and must return an instance of `HTTPResponse` instead of making actual HTTP request.
If `response_function` is defined, all other response_* arguments are ignored.
:param str response_file: filename containing response body. If `response_file` is specified,
`response_body` argument is ignored.
:param str response_body: a string containing response body.
:param int response_code: response code of the stub response.
:param dict response_headers: stub response headers.
:param callable response_body_processor: a function that takes response body
(loaded from `response_file` or specified in `response_body`) and `kwargs`.
It can be used to make any kind of modifications to response body, like templating or
gzipping. By default the same templating function that is used for replacing PEP-292 placeholders
in `url` is called.
:param kwargs: parameters that are passed to `url` templating function and to `response_body_processor`.
"""
url = safe_template(url, **kwargs)
if response_function is not None:
_add_route(http_client, url, request_method, response_function)
return
if response_file is not None:
headers = _guess_headers(response_file)
content = _get_stub(response_file)
else:
headers = HTTPHeaders()
content = response_body
if callable(response_body_processor):
content = response_body_processor(content, **kwargs)
if response_headers is not None:
headers.update(response_headers)
def _response_function(request):
return get_response_stub(request,
code=response_code,
headers=headers,
buffer=content,
effective_url=url)
_add_route(http_client, url, request_method, _response_function)
def _get(self, url, headers=None, callback=None):
"""
A `GET` request to the solr.
"""
h = HTTPHeaders()
h.update(self._default_headers)
if headers:
h.update(headers)
req = HTTPRequest(url, headers=headers)
self._client.fetch(req, callback)
def _get(self, url, headers=None, callback=None):
"""
A `GET` request to the solr.
"""
h = HTTPHeaders()
h.update(self._default_headers)
if headers:
h.update(headers)
req = HTTPRequest(url, headers=headers)
self._client.fetch(req, callback)
def make_post_request(url, data='', headers=None, files=None, content_type=None,
connect_timeout=None, request_timeout=None, follow_redirects=True):
if files:
body, content_type = make_mfd(data, files)
else:
body = make_body(data)
headers = HTTPHeaders() if headers is None else HTTPHeaders(headers)
if content_type is None:
content_type = headers.get('Content-Type', 'application/x-www-form-urlencoded')
headers.update({'Content-Type': content_type, 'Content-Length': str(len(body))})
return HTTPRequest(
url=url,
body=body,
method='POST',
headers=headers,
follow_redirects=follow_redirects,
connect_timeout=connect_timeout,
request_timeout=request_timeout
)
class SolrClient(object):
"""
Apache Solr Client class.
"""
def __init__(self, search_host, update_host=None, default_headers=None,
required_query_params=[], client_args={}, select_path='/select',
update_path='/update/json', mlt_path='/mlt',
document_verifier=None, ioloop=None):
"""
Initialize me.
"""
self._ioloop = ioloop or IOLoop.instance()
self._search_url = '%s%s' % (search_host, select_path)
self._mlt_url = '%s%s' % (search_host, mlt_path)
uhost = update_host or search_host
self._update_url = '%s%s' % (uhost, update_path)
self._required_query_params = required_query_params
if len([k for (k,v) in self._required_query_params if k=="wt"]) == 0:
self._required_query_params.append(('wt', 'json'))
self._document_verifier = document_verifier
self._default_headers = HTTPHeaders()
if default_headers:
self._default_headers.update(default_headers)
self._client = AsyncHTTPClient(self._ioloop, **client_args)
def _get(self, url, headers=None, callback=None):
"""
A `GET` request to the solr.
"""
h = HTTPHeaders()
h.update(self._default_headers)
if headers:
h.update(headers)
req = HTTPRequest(url, headers=headers)
self._client.fetch(req, callback)
def _post(self, url, body, headers=None, callback=None):
"""
A `POST` request to the solr.
"""
h = headers or HTTPHeaders()
h.update(self._default_headers)
h["Content-type"] = "application/json"
request = HTTPRequest(url, headers=h, method="POST",
body=json.dumps(body))
self._client.fetch(request, callback)
def search(self, querybuilder, callback=None):
"""
Search the Solr with `querybuilder.get_params()` as query parameter.
"""
query_params = querybuilder.get_params()
for p in self._required_query_params:
if p not in query_params:
query_params.append(p)
log.debug('Searching solr with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = "?".join([self._search_url, qs])
log.debug('Final search URL: %s' % final_url)
self._get(final_url, headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
def more_like_this(self, querybuilder, callback=None, match_include=True,
match_offset=None, interestingTerms=None):
"""
`interestingTerms` can be one of: 'list', 'details', 'none'.
"""
query_params = querybuilder.get_params()
for p in self._required_query_params:
if p not in query_params:
query_params.append(p)
if match_include and isinstance(match_include, types.BooleanType):
query_params.append(('mlt.match.include', str(match_include).lower()))
if match_offset:
query_params.append(('mlt.match.offset', str(match_offset)))
if interestingTerms:
query_params.append(('mlt.interestingTerms', interestingTerms))
self.log.debug('MoreLikeThis with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = '?'.join([self._mlt_url, qs])
self.log.debug('Final MLT URL: %s' % final_url)
self._get(final_url, headers=querybuilder.headers,
callback=self._handle_search_response(querybuilder, callback))
def index_document(self, doc, callback=None, commit=False):
"""
Index a `doc` into Solr. The `callback` will be called from within
`self._handle_indexing_response`. If `commit is True`, then a `commit`
request is sent to Solr.
"""
verification = self._document_verifier(doc)
if 'error' in verification:
callback({'error': 'document refused', 'reason': verification,
'doc': doc})
return
to_index = {'add': {'doc': doc}}
if commit:
final_url = "%s?commit=true" % self._update_url
else:
final_url = self._update_url
self._post(final_url, to_index,
callback=handle_indexing_response(callback))
def commit(self, callback=None):
"""
Commit any pending changes within Solr.
"""
to_commit = {}
final_url = "%s?commit=true" % self._update_url
self._post(final_url, to_commit,
callback=handle_indexing_response(callback))
def remove_by_id(self, doc_id, callback=None, commit=False):
"""
Remove the document with id `doc_id`.
If `commit=True` the change will be committed immidiately.
The `callback` is called from within the
`self._handle_indexing_response` method.
"""
to_remove = {'delete': {'id': doc_id}}
if commit:
final_url = "%s?commit=true" % self._update_url
else:
final_url = self._update_url
self._post(final_url, to_remove,
callback=handle_indexing_response(callback))
def remove_by_query(self, query, callback=None, commit=False):
"""
Remote any documents matching the given query.
The query must be of the form `field:value`.
"""
to_remove = {'delete': {'query': query}}
if commit:
final_url = "%s?commit=true" % self._update_url
else:
final_url = self._update_url
self._post(final_url, to_remove,
callback=handle_indexing_response(callback))
class SolrClient(object):
"""
Apache Solr Client class.
"""
def __init__(self, search_host, update_host=None, default_headers=None,
required_query_params=[], client_args={}, select_path='/select',
update_path='/update/json', mlt_path='/mlt', get_path='/get',
suggest_path='/suggest', document_verifier=None, ioloop=None):
"""
Initialize me.
"""
self._ioloop = ioloop or IOLoop.instance()
self._search_url = '%s%s' % (search_host, select_path)
self._mlt_url = '%s%s' % (search_host, mlt_path)
self._get_url = '%s%s' % (search_host, get_path)
self._termsuggest_url = '%s%s' % (search_host, suggest_path)
uhost = update_host or search_host
self._update_url = '%s%s' % (uhost, update_path)
self._required_query_params = required_query_params
if len([k for (k,v) in self._required_query_params if k=="wt"]) == 0:
self._required_query_params.append(('wt', 'json'))
self._document_verifier = document_verifier or \
default_document_verifier
self._default_headers = HTTPHeaders()
if default_headers:
self._default_headers.update(default_headers)
self._client = AsyncHTTPClient(self._ioloop, **client_args)
def _get(self, url, headers=None, callback=None):
"""
A `GET` request to the solr.
"""
h = HTTPHeaders()
h.update(self._default_headers)
if headers:
h.update(headers)
req = HTTPRequest(url, headers=headers)
self._client.fetch(req, callback)
def _post(self, url, body, headers=None, callback=None):
"""
A `POST` request to the solr.
"""
h = headers or HTTPHeaders()
h.update(self._default_headers)
if type(body) == str:
body, h["Content-type"] = body, "application/x-www-form-urlencoded"
else:
body, h["Content-type"] = json.dumps(body), "application/json"
request = HTTPRequest(url, headers=h, method="POST", body=body)
self._client.fetch(request, callback)
def _get_params(self, querybuilder):
query_params = querybuilder.get_params()
for p in self._required_query_params:
if p not in query_params:
query_params.append(p)
return query_params
def search(self, querybuilder, callback=None):
"""
Search the Solr with `querybuilder.get_params()` as query parameters.
Use GET by default, but switch to POST in case of very long urls.
"""
query_params = self._get_params(querybuilder)
log.debug('Searching solr with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = "?".join([self._search_url, qs])
# use POST if the final url is very long
final_url, use_post = (self._search_url, True) if len(final_url) > 2000 \
else (final_url, False)
log.debug('Final search URL: %s' % final_url)
if use_post:
self._post(final_url, qs, headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
else:
self._get(final_url, headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
def more_like_this(self, querybuilder, callback=None, match_include=True,
match_offset=None, interestingTerms=None):
"""
`interestingTerms` can be one of: 'list', 'details', 'none'.
"""
query_params = self._get_params(querybuilder)
if match_include and isinstance(match_include, types.BooleanType):
query_params.append(('mlt.match.include', str(match_include).lower()))
if match_offset:
query_params.append(('mlt.match.offset', str(match_offset)))
if interestingTerms:
query_params.append(('mlt.interestingTerms', interestingTerms))
log.debug('MoreLikeThis with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = '?'.join([self._mlt_url, qs])
final_url, use_post = (self._mlt_url, True) if len(final_url) > 2000 \
else (final_url, False)
log.debug('Final MLT URL: %s' % final_url)
if use_post:
self._post(final_url, qs, headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
else:
self._get(final_url, headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
def term_suggest(self, querybuilder, callback=None):
"""
simple query against the /term_suggest requesthandler from solr.
"""
query_params = self._get_params(querybuilder)
log.debug('term_suggest with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = '?'.join([self._termsuggest_url, qs])
log.debug('Final suggest URL: %s' % final_url)
self._get(final_url, headers=querybuilder.headers,
callback=handle_suggest_response(querybuilder, callback))
def get_ids(self, ids, fields=None, response_mapper=None, callback=None):
"""
Using the Solr 4.X realtime /get handler:
https://wiki.apache.org/solr/RealTimeGet
"""
log.debug('realtime get with ids: %s' % ids)
params = [('ids', ','.join(map(unicode, ids)))]
if fields:
params.append(('fl', ','.join(fields)))
qs = urllib.urlencode(params)
final_url = '?'.join([self._get_url, qs])
log.debug('Final get URL: %s' % final_url)
qb = QueryBuilder(response_mapper=(response_mapper or (lambda x: x)))
self._get(final_url, callback=handle_search_response(qb, callback))
def index_document(self, doc, callback=None, commit=False,
commitWithin=None, softCommit=None, overwrite=None,
boost=None):
"""
Index a `doc` into Solr. The `callback` will be called from within
`self._handle_indexing_response`. If `commit is True`, then a `commit`
request is sent to Solr.
"""
verification = self._document_verifier(doc)
if 'error' in verification:
callback({'error': 'document refused', 'reason': verification,
'doc': doc})
return
to_index = {'add': {'doc': doc}}
if boost:
to_index['add']['boost'] = boost
params = []
if commitWithin:
params.append(('commitWithin', str(commitWithin)))
if overwrite is not None:
if not overwrite:
params.append(('overwrite', 'false'))
if commit:
params.append(('commit', 'true'))
if softCommit:
params.append(('softCommit', 'true'))
final_url = '%s?%s' % (self._update_url, urllib.urlencode(params))
self._post(final_url, to_index,
callback=handle_indexing_response(callback))
def index_documents(self, list_of_docs, callback=None, commit=False,
commitWithin=None, softCommit=None, overwrite=None,
boost=None):
"""
Index a `list_of_docs` into Solr. Only available in Solr 4+.
"""
error_reasons, error_docs = [], []
for doc in list_of_docs:
verification = self._document_verifier(doc)
if 'error' in verification:
error_reasons.append(verification)
error_docs.append(doc)
if error_reasons:
callback({'error': 'document(s) refused', 'reasons':
list(error_reasons), 'docs': list(error_docs)})
return
params = []
if commitWithin:
params.append(('commitWithin', str(commitWithin)))
if overwrite is not None:
if not overwrite:
params.append(('overwrite', 'false'))
if commit:
params.append(('commit', 'true'))
if softCommit:
params.append(('softCommit', 'true'))
final_url = '%s?%s' % (self._update_url, urllib.urlencode(params))
self._post(final_url, list_of_docs,
callback=handle_indexing_response(callback))
def commit(self, callback=None):
"""
Commit any pending changes within Solr.
"""
to_commit = {}
final_url = "%s?commit=true" % self._update_url
self._post(final_url, to_commit,
callback=handle_indexing_response(callback))
def remove_by_id(self, doc_id, callback=None, commit=False,
commitWithin=None, softCommit=None):
"""
Remove the document with id `doc_id`.
If `commit=True` the change will be committed immidiately.
The `callback` is called from within the
`self._handle_indexing_response` method.
"""
to_remove = {'delete': {'id': doc_id}}
params = []
if commitWithin:
params.append(('commitWithin', str(commitWithin)))
if commit:
params.append(('commit', 'true'))
if softCommit:
params.append(('softCommit', 'true'))
final_url = '%s?%s' % (self._update_url, urllib.urlencode(params))
self._post(final_url, to_remove,
callback=handle_indexing_response(callback))
def remove_by_query(self, query, callback=None, commit=False,
commitWithin=None, softCommit=None):
"""
Remote any documents matching the given query.
The query must be of the form `field:value`.
"""
to_remove = {'delete': {'query': query}}
params = []
if commitWithin:
params.append(('commitWithin', str(commitWithin)))
if commit:
params.append(('commit', 'true'))
if softCommit:
params.append(('softCommit', 'true'))
final_url = '%s?%s' % (self._update_url, urllib.urlencode(params))
self._post(final_url, to_remove,
callback=handle_indexing_response(callback))
class Configuration(object):
"""Configuration object for requests at a given URI"""
HTTP_VERBS = [
'delete',
'get',
'head',
'options',
'patch',
'post',
'put',
'trace'
]
FLAVORS = {
'json': {
'content-type': 'application/json',
'accept': 'application/json',
},
'xml': {
'content-type': 'application/xml',
'accept': 'application/xml',
},
'plain': {
'content-type': 'text/plain',
'accept': 'text/plain',
},
# POST and PUT only flavors
'form': {
'content-type': 'application/x-www-form-urlencoded',
},
'multipart': {
'content-type': 'multipart/form-data; boundary=AaB03x',
},
}
# Default tornado timeout
TIMEOUT = 20
def __init__(self, uri, flavors=None, chain=None, compress=False,
ca_certs=None, connect_timeout=None, request_timeout=None):
"""Initialize the configuration for requests at the given URI"""
self.uri = uri
self.headers = HTTPHeaders()
self.flavors = flavors or ['json', 'xml']
self.processors = chain or tornado_chain
self.credentials = {}
self.verb = None
self.use_gzip = compress
self.ca_certs = ca_certs
# Request extra arguments
self.progress_callback = None
self.connect_timeout = connect_timeout or self.TIMEOUT
self.request_timeout = request_timeout or self.TIMEOUT
def __iter__(self):
"""Iterate over properties"""
prop_filter = lambda x: x[0][0] != '_'
return itertools.ifilter(prop_filter, self.__dict__.iteritems())
def __getattr__(self, value):
"""
Perform an HTTP request. This method supports calls to the following
methods: delete, get, head, options, patch, post, put, trace
Once the HTTP call is performed, a response is returned (unless the
async method is used).
"""
if (value not in self.HTTP_VERBS):
raise AttributeError(value)
# store current verb to be passed to Request
self.verb = value.upper()
# set accept if it wasn't set previously
if 'accept' not in self.headers:
for flavor in self.flavors:
if 'accept' in self.FLAVORS[flavor]:
self.headers.add('accept', self.FLAVORS[flavor]['accept'])
# set form type and default if noone is present
verb_allowed = self.verb in ('POST', 'PUT', 'PATCH')
if verb_allowed and 'content-type' not in self.headers:
self.headers['content-type'] = self.FLAVORS['form']['content-type']
# Debug helper
if __debug__:
sys.stderr.write("=" * 70)
sys.stderr.write("\nRequest:{0} {1}".format(self.verb, self.uri))
sys.stderr.write("\nHeaders:")
sys.stderr.write("\n Accept:'{0}'".format(self.headers['accept']))
if 'content-type' in self.headers:
ctype = self.headers['content-type']
sys.stderr.write("\n Content-Type:'{0}'".format(ctype))
sys.stderr.write("\n Compressed:'{0}'".format(self.use_gzip))
if self.uri.startswith("https"):
sys.stderr.write("\nCerts:'{0}'".format(self.ca_certs))
sys.stderr.write("\n{0}\n".format("=" * 70))
return Request(self)
def use(self, feature):
"""Register a feature (processor) at this configuration"""
self.processors.insert(0, feature)
return self
def secure(self, value=None, port=None, ca_certs=None):
"""Force connection using https protocol at port specified"""
if isinstance(value, bool):
scheme = 'http' if not value else 'https'
self.uri = _PROT_RE.sub(scheme + r"://\g<url>", self.uri)
if isinstance(port, int):
regx_str = r"\g<proto>\g<host>:{0}\g<url>".format(port)
self.uri = _PORT_RE.sub(regx_str, self.uri)
if isinstance(ca_certs, basestring):
self.ca_certs = ca_certs
return self
def compress(self, compress=True):
"""Notify server that we will be zipping request"""
self.use_gzip = bool(compress)
return self
def progress(self, progress_callback):
"""
Allow to define a progress callback about operaiton. This
progress callback takes 2 arguments, total length, if any and
amount of bytes already transfered
"""
self.progress_callback = progress_callback
return self
def until(self, connect_timeout=None, request_timeout=None):
"""Set current timeout in seconds for every call"""
self.connect_timeout = connect_timeout or self.connect_timeout
self.request_timeout = request_timeout or self.request_timeout
return self
def as_(self, flavor):
"""Set up the Content-Type"""
if flavor is not None:
# Just use default flavors in case we pass a None param
if flavor in self.FLAVORS:
self.headers.update(self.FLAVORS[flavor])
else:
self.headers["accept"] = flavor
self.headers["content-type"] = flavor
return self
def accepts(self, flavor):
"""Configure the accepted response format"""
if flavor is not None:
if flavor in self.FLAVORS:
flavor = self.FLAVORS[flavor]['accept']
self.headers.add('accept', flavor)
return self
def auth(self, credentials, path="*", method='plain'):
"""Authentication feature. It does simple HTTP auth"""
# already defined ?
if path in self.credentials or method is None:
return self
# process a regex valid for path
expr = "%s.*" if path.endswith('*') else "%s$"
rmatch = re.compile(expr % path.rsplit('*', 1)[0])
# now store it
self.credentials[path] = (rmatch, method, credentials,)
return self
class SolrClient(object):
"""
Apache Solr Client class.
"""
def __init__(self,
search_host,
update_host=None,
default_headers=None,
required_query_params=[],
client_args={},
select_path='/select',
update_path='/update/json',
mlt_path='/mlt',
suggest_path='/suggest',
document_verifier=None,
ioloop=None):
"""
Initialize me.
"""
self._ioloop = ioloop or IOLoop.instance()
self._search_url = '%s%s' % (search_host, select_path)
self._mlt_url = '%s%s' % (search_host, mlt_path)
self._termsuggest_url = '%s%s' % (search_host, suggest_path)
uhost = update_host or search_host
self._update_url = '%s%s' % (uhost, update_path)
self._required_query_params = required_query_params
if len([k for (k, v) in self._required_query_params
if k == "wt"]) == 0:
self._required_query_params.append(('wt', 'json'))
self._document_verifier = document_verifier or \
default_document_verifier
self._default_headers = HTTPHeaders()
if default_headers:
self._default_headers.update(default_headers)
self._client = AsyncHTTPClient(self._ioloop, **client_args)
def _get(self, url, headers=None, callback=None):
"""
A `GET` request to the solr.
"""
h = HTTPHeaders()
h.update(self._default_headers)
if headers:
h.update(headers)
req = HTTPRequest(url, headers=headers)
self._client.fetch(req, callback)
def _post(self, url, body, headers=None, callback=None):
"""
A `POST` request to the solr.
"""
h = headers or HTTPHeaders()
h.update(self._default_headers)
h["Content-type"] = "application/json"
request = HTTPRequest(url,
headers=h,
method="POST",
body=json.dumps(body))
self._client.fetch(request, callback)
def _get_params(self, querybuilder):
query_params = querybuilder.get_params()
for p in self._required_query_params:
if p not in query_params:
query_params.append(p)
return query_params
def search(self, querybuilder, callback=None):
"""
Search the Solr with `querybuilder.get_params()` as query parameters.
Use GET by default, but switch to POST in case of very long urls.
"""
query_params = self._get_params(querybuilder)
log.debug('Searching solr with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = "?".join([self._search_url, qs])
# use POST if the final url is very long
final_url, use_post = (self._search_url, True) if len(final_url) > 2000 \
else (final_url, False)
log.debug('Final search URL: %s' % final_url)
if use_post:
self._post(final_url,
qs,
headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
else:
self._get(final_url,
headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
def more_like_this(self,
querybuilder,
callback=None,
match_include=True,
match_offset=None,
interestingTerms=None):
"""
`interestingTerms` can be one of: 'list', 'details', 'none'.
"""
query_params = self._get_params(querybuilder)
if match_include and isinstance(match_include, types.BooleanType):
query_params.append(
('mlt.match.include', str(match_include).lower()))
if match_offset:
query_params.append(('mlt.match.offset', str(match_offset)))
if interestingTerms:
query_params.append(('mlt.interestingTerms', interestingTerms))
log.debug('MoreLikeThis with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = '?'.join([self._mlt_url, qs])
log.debug('Final MLT URL: %s' % final_url)
self._get(final_url,
headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
def term_suggest(self, querybuilder, callback=None):
"""
simple query against the /term_suggest requesthandler from solr.
"""
query_params = self._get_params(querybuilder)
log.debug('term_suggest with params: %s' % query_params)
qs = urllib.urlencode(query_params)
final_url = '?'.join([self._termsuggest_url, qs])
log.debug('Final suggest URL: %s' % final_url)
self._get(final_url,
headers=querybuilder.headers,
callback=handle_search_response(querybuilder, callback))
def index_document(self,
doc,
callback=None,
commit=False,
commitWithin=None,
overwrite=None,
boost=None):
"""
Index a `doc` into Solr. The `callback` will be called from within
`self._handle_indexing_response`. If `commit is True`, then a `commit`
request is sent to Solr.
"""
verification = self._document_verifier(doc)
if 'error' in verification:
callback({
'error': 'document refused',
'reason': verification,
'doc': doc
})
return
to_index = {'add': {'doc': doc}}
if boost:
to_index['add']['boost'] = boost
params = []
if commitWithin:
params.append(('commitWithin', str(commitWithin)))
if overwrite is not None:
if not overwrite:
params.append(('overwrite', 'false'))
if commit:
params.append(('commit', 'true'))
final_url = '%s?%s' % (self._update_url, urllib.urlencode(params))
self._post(final_url,
to_index,
callback=handle_indexing_response(callback))
def commit(self, callback=None):
"""
Commit any pending changes within Solr.
"""
to_commit = {}
final_url = "%s?commit=true" % self._update_url
self._post(final_url,
to_commit,
callback=handle_indexing_response(callback))
def remove_by_id(self, doc_id, callback=None, commit=False):
"""
Remove the document with id `doc_id`.
If `commit=True` the change will be committed immidiately.
The `callback` is called from within the
`self._handle_indexing_response` method.
"""
to_remove = {'delete': {'id': doc_id}}
if commit:
final_url = "%s?commit=true" % self._update_url
else:
final_url = self._update_url
self._post(final_url,
to_remove,
callback=handle_indexing_response(callback))
def remove_by_query(self, query, callback=None, commit=False):
"""
Remote any documents matching the given query.
The query must be of the form `field:value`.
"""
to_remove = {'delete': {'query': query}}
if commit:
final_url = "%s?commit=true" % self._update_url
else:
final_url = self._update_url
self._post(final_url,
to_remove,
callback=handle_indexing_response(callback))