def __init__(self, query):
self.query = query.copy()
q, fields, sort_field, sort_order, facets = get_solr_request_params_from_query(self.query)
year_facets = facets.pop('year_facets')
try:
page = int(self.query.get('page'))
except:
page = 1
try:
rows = int(self.query.get('rows'))
except:
rows = 50
start = rows * (page - 1)
query = q
# execute query
solr_response = execute_solr_query(q, fields, sort_field, sort_order, rows, start, facets)
# convert the solr documents to Title models
# could use solr doc instead of going to db, if performance requires it
results = get_titles_from_solr_documents(solr_response)
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, results, per_page=rows, orphans=0)
self._count = int(solr_response.results.numFound)
self._num_pages = None
self._cur_page = page
self.state_facets = sorted(solr_response.facet_counts.get(
'facet_fields')['state'].items(),
lambda x, y: x - y, lambda k: k[1], True)
self.county_facets = sorted(solr_response.facet_counts.get(
'facet_fields')['county'].items(),
lambda x, y: x - y, lambda k: k[1], True)
self.year_facets = year_facets
def __init__(self, query):
self.query = query.copy()
q, fields, sort_field, sort_order = get_solr_request_params_from_query(
self.query)
try:
page = int(self.query.get("page", 1))
except ValueError:
raise InvalidPage
try:
rows = int(self.query.get("rows", 50))
except ValueError:
raise InvalidPage
start = rows * (page - 1)
# execute query
solr_response = execute_solr_query(q, fields, sort_field, sort_order,
rows, start)
# convert the solr documents to Title models
# could use solr doc instead of going to db, if performance requires it
results = get_titles_from_solr_documents(solr_response)
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, results, per_page=rows, orphans=0)
self._count = int(solr_response.results.numFound)
self._num_pages = None
self._cur_page = page
def __init__(self,
object_list,
per_page=10,
orphans=0,
allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans,
allow_empty_first_page)
def __init__(self, query):
self.query = query.copy()
q, fields, sort_field, sort_order, facets = get_solr_request_params_from_query(
self.query)
year_facets = facets.pop('year_facets')
try:
page = int(self.query.get('page'))
except:
page = 1
try:
rows = int(self.query.get('rows'))
except:
rows = 50
start = rows * (page - 1)
query = q
# execute query
solr_response = execute_solr_query(q, fields, sort_field, sort_order,
rows, start, facets)
# convert the solr documents to Title models
# could use solr doc instead of going to db, if performance requires it
results = get_titles_from_solr_documents(solr_response)
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, results, per_page=rows, orphans=0)
self._count = int(solr_response.results.numFound)
self._num_pages = None
self._cur_page = page
self.state_facets = _sort_facets_asc(solr_response.facet_counts,
'state')
self.county_facets = _sort_facets_asc(solr_response.facet_counts,
'county')
self.year_facets = year_facets
def __init__(self, request=None, query_set=None, current_page=1, page_size=20, padding=3 ):
from re import sub
Paginator.__init__(self, query_set, page_size)
if request is None or query_set is None:
raise Http404
self.path = sub( r'page/\d+/?$', '', request.path )
self.path = sub( r'/$', '', self.path )
self.query_str = '?' + request.GET.urlencode()
if self.query_str == '?':
self.query_str = ''
self.current_page = int( current_page )
self.page_size = page_size
start = self.current_page - padding
end = self.current_page + padding
if start < 0:
end += 0 - start
start = 0
if end >= self.num_pages:
end = self.num_pages-1
if end >= self.num_pages:
start -= end - self.num_pages + 1
end = self.num_pages-1
if start < 0:
start = 0
self.first = start+1
self.last = end+1
self.page_numbers = [ { 'page': (p+1), 'url': self.path + '/page/' + str(p+1) + '/' + self.query_str } \
for p in range( start, end+1 ) ]
self.first_url = self.path + '/page/1/' + self.query_str
self.prev_enabled = int( current_page ) > int( self.first )
self.prev_url = self.path + '/page/' + str( self.current_page - 1 ) + '/' + self.query_str
self.next_enabled = int( current_page ) < int( self.last )
self.next_url = self.path + '/page/' + str( self.current_page + 1 ) + '/' + self.query_str
self.last_url = self.path + '/page/' + str( self.num_pages ) + '/' + self.query_str
self.is_paginated = self.num_pages > 1
def __init__(self, query):
self.query = query.copy()
# remove words from query as it's not part of the solr query.
if 'words' in self.query:
del self.query['words']
self._q, self.facet_params = page_search(self.query)
try:
self._cur_page = int(self.query.get('page'))
except:
self._cur_page = 1 # _cur_page is 1-based
try:
self._cur_index = int(self.query.get('index'))
except:
self._cur_index = 0
try:
rows = int(self.query.get('rows'))
except:
rows = 10
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, None, per_page=rows, orphans=0)
self.overall_index = (self._cur_page -
1) * self.per_page + self._cur_index
self._ocr_list = [
'ocr',
]
self._ocr_list.extend(['ocr_%s' % l for l in settings.SOLR_LANGUAGES])
def __init__(self, query):
self.query = query.copy()
q, fields, sort_field, sort_order = get_solr_request_params_from_query(self.query)
try:
page = int(self.query.get('page'))
except:
page = 1
try:
rows = int(self.query.get('rows'))
except:
rows = 50
start = rows * (page - 1)
# execute query
solr_response = execute_solr_query(q, fields, sort_field, sort_order, rows, start)
# convert the solr documents to Title models
# could use solr doc instead of going to db, if performance requires it
results = get_titles_from_solr_documents(solr_response)
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, results, per_page=rows, orphans=0)
self._count = int(solr_response.results.numFound)
self._num_pages = None
self._cur_page = page
def __init__(self, query):
self.query = query.copy()
# remove words from query as it's not part of the solr query.
if 'words' in self.query:
del self.query['words']
self._q = page_search(self.query)
try:
self._cur_page = int(self.query.get('page'))
except:
self._cur_page = 1 # _cur_page is 1-based
try:
self._cur_index = int(self.query.get('index'))
except:
self._cur_index = 0
try:
rows = int(self.query.get('rows'))
except:
rows = 10
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, None, per_page=rows, orphans=0)
self.overall_index = (self._cur_page - 1) * self.per_page + self._cur_index
self._ocr_list = ['ocr', ]
self._ocr_list.extend(['ocr_%s' % l for l in settings.SOLR_LANGUAGES])
def __init__(self, query):
self.query = query.copy()
# remove words from query as it's not part of the solr query.
if "words" in self.query:
del self.query["words"]
self._q = page_search(self.query)
try:
self._cur_page = int(self.query.get("page", "1"))
except ValueError:
self._cur_page = 1
try:
self._cur_index = int(self.query.get("index", "0"))
except ValueError:
self._cur_index = 0
try:
rows = int(self.query.get("rows", "10"))
except ValueError:
rows = 10
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, None, per_page=rows, orphans=0)
self.overall_index = (self._cur_page -
1) * self.per_page + self._cur_index
self._ocr_list = ["ocr"]
self._ocr_list.extend(["ocr_%s" % l for l in settings.SOLR_LANGUAGES])
def __init__(self, current_page, per_pager_num, *args, **kwargs):
# 当前页
self.current_page = int(current_page)
# 页码最大显示范围
self.per_pager_num = per_pager_num
# 继承父类Paginator的其他属性方法
Paginator.__init__(self, *args, **kwargs)
def __init__(self,
object_list,
per_page,
orphans=0,
allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans,
allow_empty_first_page)
self._count = len(list(object_list))
def __init__(self, query_set, num_per_page, orphans=0):
Paginator.__init__(self, query_set, num_per_page, orphans)
import warnings
warnings.warn("The ObjectPaginator is deprecated. Use django.core.paginator.Paginator instead.", DeprecationWarning)
# Keep these attributes around for backwards compatibility.
self.query_set = query_set
self.num_per_page = num_per_page
self._hits = self._pages = None
def __init__(self, query_set, num_per_page, orphans=0):
Paginator.__init__(self, query_set, num_per_page, orphans)
#import warnings
#warnings.warn("The ObjectPaginator is deprecated. Use django.core.paginator.Paginator instead.", DeprecationWarning)
# Keep these attributes around for backwards compatibility.
self.query_set = query_set
self.num_per_page = num_per_page
self._hits = self._pages = None
def __init__(self,
object_list,
per_page,
range_num=5,
orphans=0,
allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans,
allow_empty_first_page)
self.range_num = range_num
def __init__(self,
object_list,
per_page,
range_num=3,
orphans=0,
allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans,
allow_empty_first_page)
self.range_num = range_num
self._max_pages = self._count = None
def __init__(self, object_list, per_page, range_num=3, orphans=0, allow_empty_first_page=True):
"""
per_page: 每页显示几个；
"""
Paginator.__init__(self, object_list, per_page, orphans, allow_empty_first_page)
self.range_num = range_num # 本页页码左右各显示几页
self.show_first = False
self.show_first_dot = False
self.show_last = False
self.show_last_dot = False
self.num_count = 2 * self.range_num + 1
def __init__(self,
object_list,
per_page,
range_num=5,
orphans=0,
allow_empty_first_page=True):
'''
:param range_num: 左右各显示多少标签
'''
Paginator.__init__(self, object_list, per_page, orphans,
allow_empty_first_page)
self.range_num = range_num
class SolrTitlesPaginator(Paginator):
"""
SolrTitlesPaginator takes a QueryDict object, builds and executes a solr
query for newspaper titles, and returns a paginator for the search results
for use in a HTML form.
"""
def __init__(self, query):
self.query = query.copy()
# figure out the solr query
q = title_search(self.query)
try:
page = int(self.query.get('page'))
except:
page = 1
try:
rows = int(self.query.get('rows'))
except:
rows = 50
start = rows * (page - 1)
# determine sort order
sort_field, sort_order = _get_sort(self.query.get('sort'))
# execute query
solr = SolrConnection(
settings.SOLR) # TODO: maybe keep connection around?
solr_response = solr.query(q,
fields=[
'lccn', 'title', 'edition',
'place_of_publication', 'start_year',
'end_year', 'language'
],
rows=rows,
sort=sort_field,
sort_order=sort_order,
start=start)
# convert the solr documents to Title models
# could use solr doc instead of going to db, if performance requires it
lccns = [d['lccn'] for d in solr_response.results]
results = []
for lccn in lccns:
try:
title = models.Title.objects.get(lccn=lccn)
results.append(title)
except models.Title.DoesNotExist, e:
pass # TODO: log exception
# set up some bits that the Paginator expects to be able to use
Paginator.__init__(self, results, per_page=rows, orphans=0)
self._count = int(solr_response.results.numFound)
self._num_pages = None
self._cur_page = page
def __init__(self,
request=None,
query_set=None,
current_page=1,
page_size=20,
padding=3):
from re import sub
Paginator.__init__(self, query_set, page_size)
if request is None or query_set is None:
raise Http404
self.path = sub(r'page/\d+/?$', '', request.path)
self.path = sub(r'/$', '', self.path)
self.query_str = '?' + request.GET.urlencode()
if self.query_str == '?':
self.query_str = ''
self.current_page = int(current_page)
self.page_size = page_size
start = self.current_page - padding
end = self.current_page + padding
if start < 0:
end += 0 - start
start = 0
if end >= self.num_pages:
end = self.num_pages - 1
if end >= self.num_pages:
start -= end - self.num_pages + 1
end = self.num_pages - 1
if start < 0:
start = 0
self.first = start + 1
self.last = end + 1
self.page_numbers = [ { 'page': (p+1), 'url': self.path + '/page/' + str(p+1) + '/' + self.query_str } \
for p in range( start, end+1 ) ]
self.first_url = self.path + '/page/1/' + self.query_str
self.prev_enabled = int(current_page) > int(self.first)
self.prev_url = self.path + '/page/' + str(self.current_page -
1) + '/' + self.query_str
self.next_enabled = int(current_page) < int(self.last)
self.next_url = self.path + '/page/' + str(self.current_page +
1) + '/' + self.query_str
self.last_url = self.path + '/page/' + str(
self.num_pages) + '/' + self.query_str
self.is_paginated = self.num_pages > 1
def __init__(self, item_list, per_page, orphans=0,
allow_empty_first_page=True,navigation_steps=7):
Paginator.__init__(self, item_list, per_page, orphans,
allow_empty_first_page)
logging.debug("permage: init")
if navigation_steps < 5:
navigation_steps = 5
elif navigation_steps % 2 != 1:
navigation_steps = navigation_steps+1
self.navigation_steps = navigation_steps
self.item_list = item_list
self.ids_list = []
for itm in self.item_list:
self.ids_list.append(itm.id)
self.pages_next = []
self.page = []
self.closest_id = -1
self.last_id = self.ids_list[-1]
self.last_page_id = -1
def __init__(self, object_list, per_page=10, orphans=0, allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans, allow_empty_first_page)
def __init__(self, object_list, per_page, orphans=0,
allow_empty_first_page=True, **kwargs):
self.deltafirst = kwargs.pop('deltafirst', 0)
Paginator.__init__(self, object_list, per_page, orphans,
allow_empty_first_page)
def __init__(self, object_list, per_page, range_num=5, orphans=0, allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans, allow_empty_first_page)
self.range_num = range_num
def __init__(self, elemList, elemPerPage):
if(elemPerPage > 0):
Paginator.__init__(self, elemList, elemPerPage)
else:
raise ValueError('Amount of items per page must be greater than 0')
def __init__(self, object_list, per_page, orphans=0, allow_empty_first_page=True, object_count=None):
Paginator.__init__(self, object_list, per_page, orphans, allow_empty_first_page)
self._count = object_count
def __init__(self, *args, **kwargs):
self.use_elasticsearch_dsl = kwargs.pop('use_elasticsearch_dsl', True)
Paginator.__init__(self, *args, **kwargs)
def __init__(self,current_page,per_page_num,*args,**kwargs):
Paginator.__init__(self,*args,**kwargs)
self.current_page=int(current_page)
self.per_page_num=int(per_page_num)
def __init__(self, *args, **kwargs):
self.use_elasticsearch_dsl = kwargs.pop('use_elasticsearch_dsl', True)
Paginator.__init__(self, *args, **kwargs)
def __init__(self, qry_result, result_list, orphans=0, allow_empty_first_page=False):
self._qry_result = qry_result
Paginator.__init__(self, result_list, self._qry_result.count, orphans, allow_empty_first_page)
def __init__(self, object_list, per_page, count_query, orphans=0, allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans=orphans, allow_empty_first_page=allow_empty_first_page)
self.count_query = count_query
self._count_sql = self.count_query.query.get_compiler(self.count_query.db).as_sql()
self._count_sql = self._count_sql[0] % self._count_sql[1]
self._count_key = None
def __init__(self, page_tabs, object_list, per_page):
Paginator.__init__(self, object_list, per_page)
self.page_tabs = page_tabs
def __init__(self, queryset, page_size):
Paginator.__init__(self, queryset, page_size)
def __init__(self, object_list, per_page, currentPage, showPage, orphans=0, allow_empty_first_page=True):
Paginator.__init__(self, object_list, per_page, orphans, allow_empty_first_page)
self.currentPage =1 if currentPage ==None else currentPage
self.showPage =showPage
def __init__(self, object_list, request, per_page=12, *args, **kwargs):
self.request = request
Paginator.__init__(self, object_list, per_page, \
*args, **kwargs)
