def setUp(self):
mock_file = join(dirname(__file__), 'mocks/highlightingquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/statsquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3 and sys.version_info[1] == 2:
raw_content = json.dumps(eval(f.read())).encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def fetch(self, rows=None):
""" Generator method that grabs all the documents in bulk sets of
'rows' documents
:param rows: number of rows for each request
"""
if rows:
self.query['rows'] = rows
if 'rows' not in self.query:
self.query['rows'] = 10
self.query['start'] = 0
end = False
docs_retrieved = 0
while not end:
if self.use_get:
http_response = self.make_request.get(self.url,
params=self.query)
else:
http_response = self.make_request.post(self.url,
data=self.query)
solr_response = SolrResponse(http_response)
yield solr_response
total_results = solr_response.total_results
docs_retrieved += len(solr_response.documents)
end = docs_retrieved == total_results
self.query['start'] += self.query['rows']
class QueryResultTestCase(unittest.TestCase):
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/query')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode('utf-8')
else:
raw_content = f.read()
self.solr_response = SolrResponse()
self.solr_response.raw_content = raw_content
self.solr_response.status = 200
self.solr_response.parse_content()
def tearDown(self):
pass
def test_raw_content(self):
self.assertNotEqual(self.solr_response.raw_content, None)
def test_status(self):
self.assertNotEqual(self.solr_response.solr_status, None)
self.assertEqual(self.solr_response.solr_status, 0)
def test_qtime(self):
self.assertNotEqual(self.solr_response.qtime, None)
self.assertEqual(self.solr_response.qtime, 101)
def test_total_results(self):
self.assertNotEqual(self.solr_response.total_results, None)
self.assertEqual(self.solr_response.total_results, 2)
def test_start(self):
self.assertNotEqual(self.solr_response.start, None)
self.assertEqual(self.solr_response.start, 0)
def test_documents(self):
self.assertNotEqual(self.solr_response.documents, None)
self.assertEqual(len(self.solr_response.documents), 2)
def test_facets(self):
self.assertNotEqual(self.solr_response.facets, None)
class QueryResultTestCase(unittest.TestCase):
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/query')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode('utf-8')
else:
raw_content = f.read()
self.solr_response = SolrResponse()
self.solr_response.raw_content = raw_content
self.solr_response.status = 200
self.solr_response.parse_content()
def tearDown(self):
pass
def test_raw_content(self):
self.assertNotEqual(self.solr_response.raw_content, None)
def test_status(self):
self.assertNotEqual(self.solr_response.solr_status, None)
self.assertEqual(self.solr_response.solr_status, 0)
def test_qtime(self):
self.assertNotEqual(self.solr_response.qtime, None)
self.assertEqual(self.solr_response.qtime, 101)
def test_total_results(self):
self.assertNotEqual(self.solr_response.total_results, None)
self.assertEqual(self.solr_response.total_results, 2)
def test_start(self):
self.assertNotEqual(self.solr_response.start, None)
self.assertEqual(self.solr_response.start, 0)
def test_documents(self):
self.assertNotEqual(self.solr_response.documents, None)
self.assertEqual(len(self.solr_response.documents), 2)
def test_facets(self):
self.assertNotEqual(self.solr_response.facets, None)
class HighlightingQueryResultTestCase(unittest.TestCase):
""" """
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/highlightingquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def tearDown(self):
pass
def test_query(self):
self.assertNotEqual(self.response.highlighting, None)
class StatsQueryTestCase(unittest.TestCase):
""" """
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/statsquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3 and sys.version_info[1] == 2:
raw_content = json.dumps(eval(f.read())).encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def tearDown(self):
pass
def test_query(self):
self.assertNotEqual(self.response.stats, None)
def delete_by_query(self, query, commit=True):
"""Sends a query delete message to Solr.
:param commit: If True, sends a commit message after the operation is
executed.
"""
xml = '<delete><query>%s</query></delete>' % (query)
http_response = self._post_xml(xml)
if commit:
self.commit()
return SolrResponse(http_response)
def delete_by_key(self, identifier, commit=True):
"""Sends an ID delete message to Solr.
:param commit: If True, sends a commit message after the operation is
executed.
"""
xml = '<delete><id>%s</id></delete>' % (identifier)
http_response = self._post_xml(xml)
if commit:
self.commit()
return SolrResponse(http_response)
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/query')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode('utf-8')
else:
raw_content = f.read()
self.solr_response = SolrResponse()
self.solr_response.raw_content = raw_content
self.solr_response.status = 200
self.solr_response.parse_content()
def setUp(self):
mock_file = join(dirname(__file__), "mocks/highlightingquery")
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode("utf-8")
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
class StatsQueryResultTestCase(unittest.TestCase):
""" """
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/statsquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3:
raw_content = f.read().encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def tearDown(self):
pass
def test_query(self):
self.assertNotEqual(self.response.stats, None)
class SpellQueryTestCase(unittest.TestCase):
""" """
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/spellquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3 and sys.version_info[1] == 2:
raw_content = json.dumps(eval(f.read())).encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def tearDown(self):
pass
def test_query(self):
self.assertNotEqual(self.response.spellcheck, None)
def setUp(self):
mock_file = join(dirname(__file__), 'mocks/spellquery')
with open(mock_file) as f:
raw_content = None
if sys.version_info[0] == 3 and sys.version_info[1] == 2:
raw_content = json.dumps(eval(f.read())).encode('utf-8')
else:
raw_content = f.read()
self.response = SolrResponse()
self.response.raw_content = raw_content
self.response.status = 200
self.response.parse_content()
def more_like_this(self, resource='mlt', text=None, **kwargs):
"""Implements convenient access to Solr MoreLikeThis functionality
Please, visit http://wiki.apache.org/solr/MoreLikeThis to learn more
about MLT configuration and common parameters.
There are two ways of using MLT in Solr:
Using a previously configured RequestHandler
You normally specify a query and the first matching document for
that query is used to retrieve similar documents.
You can however specify a text instead of a query, and similar
documents to the text will be returned.
You must configure a MLT RequestHandler in your solrconfig.xml in
order to get advantage of this functionality.
Note that this method has a default resource name with value "mlt",
but if your RequestHandler has a different name you must specify it
when calling the more_like_this method.
Using the MLT Search Component:
The resulting documents in this case will be those that match the
regular query, but the SolrResponse will have a "mlt" section where
similar documents for each result document will be given.
:param resource: Request dispatcher. 'ml' by default.
:param text: Text to use for similar documents retrieval. None by
default.
:param **kwargs: Dictionary containing any of the available Solr query
parameters described in
http://wiki.apache.org/solr/CommonQueryParameters
or MoreLikeThis Common parameters described in
http://wiki.apache.org/solr/MoreLikeThis.
'q' is a mandatory parameter in all cases except
when using a MLT RequestHandler with a Text parameter.
"""
if text is not None: #RequestHandler with Content-Streamed Text
#we dont call build_query because 'q' is NOT mandatory in this case
kwargs['wt'] = 'json'
headers = {'Content-type': 'text/json'}
url = urljoin(self.base_url, resource)
http_response = self.make_request.post(url,
params=kwargs,
data=text,
headers=headers)
solr_response = SolrResponse(http_response)
return solr_response
else:
return self.search(resource=resource, **kwargs)
def search(self, resource='select', **kwargs):
"""Queries Solr with the given kwargs and returns a SolrResponse
object.
:param resource: Request dispatcher. 'select' by default.
:param **kwargs: Dictionary containing any of the available Solr query
parameters described in
http://wiki.apache.org/solr/CommonQueryParameters.
'q' is a mandatory parameter.
"""
query = build_request(kwargs)
url = urljoin(self.base_url, resource)
if self.use_get:
http_response = self.make_request.get(url, params=query)
else:
http_response = self.make_request.post(url, data=query)
solr_response = SolrResponse(http_response)
return solr_response
def async_search(self, queries, size=10, resource='select'):
""" Asynchronous search using async module from requests.
:param queries: List of queries. Each query is a dictionary containing
any of the available Solr query parameters described in
http://wiki.apache.org/solr/CommonQueryParameters.
'q' is a mandatory parameter.
:param size: Size of threadpool
:param resource: Request dispatcher. 'select' by default.
"""
try:
import grequests
except:
raise RuntimeError('grequests is required for Solr.async_search.')
url = urljoin(self.base_url, resource)
queries = map(build_request, queries)
rs = (grequests.post(url, data=query) for query in queries)
responses = grequests.map(rs, size=size)
return [SolrResponse(http_response) for http_response in responses]
def optimize(self, wait_flush=True, wait_searcher=True, max_segments=1):
"""Sends an optimize message to Solr.
:param wait_flush: Block until index changes are flushed to disk
(default is True)
:param wait_searcher: Block until a new searcher is opened and
registered as the main query searcher, making the
changes visible (default is True)
:param max_segments: Optimizes down to at most this number of segments
(default is 1)
"""
xml = '<optimize '
if self.version < 4:
xml += 'waitFlush="%s" ' % str(wait_flush).lower()
xml += 'waitSearcher="%s" ' % str(wait_searcher).lower()
xml += 'maxSegments="%s" ' % max_segments
xml += '/>'
http_response = self._post_xml(xml)
return SolrResponse(http_response)
def update(self, documents, input_type='json', commit=True):
"""Sends an update/add message to add the array of hashes(documents) to
Solr.
:param documents: A list of solr-compatible documents to index. You
should use unicode strings for text/string fields.
:param input_type: The format which documents are sent. Remember that
json is not supported until version 3.
:param commit: If True, sends a commit message after the operation is
executed.
"""
assert input_type in ['xml', 'json']
if input_type == 'xml':
http_response = self._post_xml(_get_add_xml(documents))
else:
http_response = self._post_json(json.dumps(documents))
if commit:
self.commit()
return SolrResponse(http_response)
def commit(self,
wait_flush=True,
wait_searcher=True,
expunge_deletes=False):
"""Sends a commit message to Solr.
:param wait_flush: Block until index changes are flushed to disk
(default is True).
:param wait_searcher: Block until a new searcher is opened and
registered as the main query searcher, making the
changes visible (default is True).
:param expunge_deletes: Merge segments with deletes away (default is
False)
"""
xml = '<commit '
if self.version < 4:
xml += 'waitFlush="%s" ' % str(wait_flush).lower()
xml += 'waitSearcher="%s" ' % str(wait_searcher).lower()
xml += 'expungeDeletes="%s" ' % str(expunge_deletes).lower()
xml += '/>'
http_response = self._post_xml(xml)
return SolrResponse(http_response)
def get_system_info(self):
""" Gets solr system status. """
url = urljoin(self.base_url, 'admin/system')
params = {'wt': 'json'}
http_response = self.make_request.get(url, params=params)
return SolrResponse(http_response)
def rollback(self):
"""Sends a rollback message to Solr server."""
xml = '<rollback />'
http_response = self._post_xml(xml)
return SolrResponse(http_response)
def ping(self):
""" Ping call to solr server. """
url = urljoin(self.base_url, 'admin/ping')
http_response = self.make_request.get(url, params={'wt': 'json'})
return SolrResponse(http_response)
