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 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)