Here are the examples of the python api django.core.paginator.Paginator taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
359 Examples
3
Source : paginator.py
with MIT License
from a1401358759
with MIT License
from a1401358759
def paginate_inc(info_list, page_num=1, page_size=10, page_list=True):
"""如果page_num超过最大页数,返回空列表[]
page_list - 返回页脚显示样式控制字段"""
total = 0
try:
paginator = Paginator(info_list, page_size)
total = paginator.count
objects = paginator.page(page_num)
if page_list:
objects.page_list = paginator_page_list(page_num, [i for i in paginator.page_range])
except (EmptyPage, InvalidPage):
objects = []
return objects, total
3
Source : views.py
with MIT License
from abrookins
with MIT License
from abrookins
def events_offset_paginated(request):
"""Render the list of analytics events.
Paginate results using Paginator, with select_related().
"""
events = Event.objects.all().select_related(
'user', 'user__profile',
'user__profile__account').order_by('id') # < 1>
paginated = Paginator(events, settings.EVENTS_PER_PAGE)
page = request.GET.get('page', 1)
events = paginated.get_page(page)
context = {'events': events}
return render(request, "analytics/events_paginated.html",
context)
# end::paginated[]
# tag::keyset_pagination_pg[]
KEYSET_SEPARATOR = '-'
3
Source : browser.py
with GNU General Public License v3.0
from ajslater
with GNU General Public License v3.0
from ajslater
def _paginate(self, queryset):
"""Paginate the queryset into a final object list."""
paginator = Paginator(queryset, self._MAX_OBJ_PER_PAGE, orphans=self._ORPHANS)
page = self.kwargs.get("page", 1)
try:
obj_list = paginator.page(page).object_list
except EmptyPage:
if page < 1 or page > paginator.num_pages:
self._page_out_out_bounds(page, paginator.num_pages)
LOG.warning(f"No items on page {page}")
obj_list = self.model.objects.filter(pk=-1) # paginator.page(1).object_list
return obj_list, paginator.num_pages
def _get_browser_page(self):
3
Source : views.py
with MIT License
from alxojy
with MIT License
from alxojy
def following(request):
user = request.user
following = Follow.objects.filter(follower=request.user).values('following_id')
posts = Post.objects.filter(user__in=following).order_by('-timestamp')
for post in posts:
post.likes = Like.objects.filter(post=post.id).count()
post.save()
paginator = Paginator(posts, 10)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
return render(request, "network/following.html", {
"page_obj": page_obj
})
def profile(request, owner):
3
Source : views.py
with MIT License
from arcamens
with MIT License
from arcamens
def get(self, request):
quotes = models.Quote.objects.all()
quotes = quotes.order_by('id')
# Assume pages are 30 elements long.
paginator = Paginator(quotes, 30)
page = paginator.page(request.GET['page'])
return render(request, 'core_app/quote-paginator.html',
{'quotes': page})
3
Source : views.py
with MIT License
from devmahmud
with MIT License
from devmahmud
def list_by_user(request):
all_polls = Poll.objects.filter(owner=request.user)
paginator = Paginator(all_polls, 7) # Show 7 contacts per page
page = request.GET.get('page')
polls = paginator.get_page(page)
context = {
'polls': polls,
}
return render(request, 'polls/polls_list.html', context)
@login_required()
3
Source : chooser.py
with MIT License
from DivineITLimited
with MIT License
from DivineITLimited
def get_paginator(self, q=None, per_page=20):
queryset = self.get_queryset()
queryset = self.filter(q, queryset)
queryset = self.get_ordering(queryset)
queryset = self.get_fields(queryset)
paginator = Paginator(queryset, per_page=per_page)
return paginator
def serialize(self, item):
3
Source : serializers.py
with MIT License
from ebs-integrator
with MIT License
from ebs-integrator
def paginate_data(self, objects, per_page=None):
paginator = Paginator(objects, per_page if per_page else self.get_default_per_page())
page = self.get_page()
try:
data = paginator.page(page)
except EmptyPage:
raise ValidationException({
'page': [_('Page must be less than or equal to %s') % paginator.num_pages]
})
return data.object_list, data.paginator.count
class StringListField(serializers.ListField):
3
Source : notifications.py
with GNU Affero General Public License v3.0
from elixir-luxembourg
with GNU Affero General Public License v3.0
from elixir-luxembourg
def index(request):
per_page = request.GET.get('per_page', 25)
page = request.GET.get('page', '1')
notifications = request.user.notifications.ordered()
paginator = Paginator(notifications, per_page)
notifications = paginator.get_page(page)
context = {
'notifications': notifications
}
return render(request, 'notifications/list.html',context)
def admin(request, pk=None):
3
Source : web_server.py
with Apache License 2.0
from flink-extended
with Apache License 2.0
from flink-extended
def workflow_execution_metadata():
project_name = request.args.get('project_name')
workflow_name = request.args.get('workflow_name')
workflow_execution_list = scheduler.list_workflow_executions(project_name,
workflow_name) if project_name and workflow_name else None
return pagination_response(page_no=int(request.args.get('pageNo')),
total_count=len(workflow_execution_list) if workflow_execution_list else 0,
data=Paginator(workflow_execution_list, int(request.args.get('pageSize'))).get_page(
int(request.args.get('pageNo'))).object_list if workflow_execution_list else [])
@app.route('/job-execution')
3
Source : export.py
with MIT License
from g0v
with MIT License
from g0v
def prepare_houses(from_date, to_date):
global page_size
houses = House.objects.filter(
additional_fee__isnull=False,
created__lte=to_date,
crawled_at__gte=from_date
).order_by(
'-id'
)
paginator = Paginator(houses, page_size)
return paginator
def normalize_val(val, header, use_tf):
3
Source : api.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def paginate_task(self, task_list, pagenum):
paginator = Paginator(task_list, _DEFAULT_OBJ_PER_PAGINATION, allow_empty_first_page=True)
return paginator.page(pagenum)
class YarnApi(JobBrowserApi):
3
Source : tests.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def check_paginator(self, params, output):
"""
Helper method that instantiates a Paginator object from the passed
params and then checks that its attributes match the passed output.
"""
count, num_pages, page_range = output
paginator = Paginator(*params)
self.check_attribute('count', paginator, count, params)
self.check_attribute('num_pages', paginator, num_pages, params)
self.check_attribute('page_range', paginator, page_range, params, coerce=list)
def check_attribute(self, name, paginator, expected, params, coerce=None):
3
Source : tests.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_invalid_page_number(self):
"""
Invalid page numbers result in the correct exception being raised.
"""
paginator = Paginator([1, 2, 3], 2)
with self.assertRaises(InvalidPage):
paginator.page(3)
with self.assertRaises(PageNotAnInteger):
paginator.validate_number(None)
with self.assertRaises(PageNotAnInteger):
paginator.validate_number('x')
# With no content and allow_empty_first_page=True, 1 is a valid page number
paginator = Paginator([], 2)
self.assertEqual(paginator.validate_number(1), 1)
def test_paginate_misc_classes(self):
3
Source : tests.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def check_indexes(self, params, page_num, indexes):
"""
Helper method that instantiates a Paginator object from the passed
params and then checks that the start and end indexes of the passed
page_num match those given as a 2-tuple in indexes.
"""
paginator = Paginator(*params)
if page_num == 'first':
page_num = 1
elif page_num == 'last':
page_num = paginator.num_pages
page = paginator.page(page_num)
start, end = indexes
msg = ("For %s of page %s, expected %s but got %s. Paginator parameters were: %s")
self.assertEqual(start, page.start_index(), msg % ('start index', page_num, start, page.start_index(), params))
self.assertEqual(end, page.end_index(), msg % ('end index', page_num, end, page.end_index(), params))
def test_page_indexes(self):
3
Source : tests.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_page_range_iterator(self):
"""
Paginator.page_range should be an iterator.
"""
self.assertIsInstance(Paginator([1, 2, 3], 2).page_range, type(six.moves.range(0)))
class ModelPaginationTests(TestCase):
3
Source : tests.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_paginating_unordered_queryset_raises_warning(self):
with warnings.catch_warnings(record=True) as warns:
# Prevent the RuntimeWarning subclass from appearing as an
# exception due to the warnings.simplefilter() in runtests.py.
warnings.filterwarnings('always', category=UnorderedObjectListWarning)
Paginator(Article.objects.all(), 5)
self.assertEqual(len(warns), 1)
warning = warns[0]
self.assertEqual(str(warning.message), (
"Pagination may yield inconsistent results with an unordered "
"object_list: < class 'pagination.models.Article'> QuerySet."
))
# The warning points at the Paginator caller (i.e. the stacklevel
# is appropriate).
self.assertEqual(warning.filename, __file__)
def test_paginating_unordered_object_list_raises_warning(self):
3
Source : tests.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_paginating_unordered_object_list_raises_warning(self):
"""
Unordered object list warning with an object that has an orderd
attribute but not a model attribute.
"""
class ObjectList():
ordered = False
object_list = ObjectList()
with warnings.catch_warnings(record=True) as warns:
warnings.filterwarnings('always', category=UnorderedObjectListWarning)
Paginator(object_list, 5)
self.assertEqual(len(warns), 1)
self.assertEqual(str(warns[0].message), (
"Pagination may yield inconsistent results with an unordered "
"object_list: {!r}.".format(object_list)
))
3
Source : dropped.py
with BSD 2-Clause "Simplified" License
from getmetamapper
with BSD 2-Clause "Simplified" License
from getmetamapper
def apply(self, batch_size=1000):
"""Apply DELETE action to all dropped models.
"""
paginator = Paginator(self.revisions, batch_size)
for page_num in paginator.page_range:
page = paginator.get_page(page_num)
data = page.object_list.values_list('as_int', flat=True)
self.logger.info(
'[{0}] Dropped {1} of {2}'.format(self.model_class.__name__, page.end_index(), paginator.count)
)
self.model_class.objects.filter(id__in=data).delete()
class SchemaDropAction(GenericDropAction):
3
Source : default.py
with GNU General Public License v3.0
from GroupT00
with GNU General Public License v3.0
from GroupT00
def index(request):
Art = NewsSql.objects.all().filter(Art_exa=True)
paginator = Paginator(Art[::-1],15)
page = request.GET.get('page')
try:
contacts = paginator.page(page)
except PageNotAnInteger:
contacts = paginator.page(1)
except EmptyPage:
contacts = paginator.page(paginator.num_pages)
print type(contacts)
return render(request,'index.html',{'contacts': contacts})
3
Source : sort.py
with GNU General Public License v3.0
from GroupT00
with GNU General Public License v3.0
from GroupT00
def sort(request,taskid):
Art = NewsSql.objects.all().filter(Art_exa=True).filter(Art_type=taskid)
paginator = Paginator(Art[::-1],3)
page = request.GET.get('page')
try:
contacts = paginator.page(page)
except PageNotAnInteger:
contacts = paginator.page(1)
except EmptyPage:
contacts = paginator.page(paginator.num_pages)
print type(contacts)
return render(request,'index.html',{'contacts': contacts})
3
Source : views.py
with MIT License
from hugoduchene
with MIT License
from hugoduchene
def get(self, request, idArticle, idPage):
all_comments = Comment.objects.filter(id_article=idArticle).order_by('-date_comment', 'likecomment')
pagination = Paginator(all_comments, 10)
objects_page = pagination.page(idPage).object_list
serializer = AllDataComment().get_all_infos_comment(objects_page)
return Response(serializer.data)
""" Manage endpoint's like's comment """
3
Source : tests.py
with MIT License
from joe513
with MIT License
from joe513
def setUp(self):
paginator = Paginator([... for _ in range(30)], 5)
self.page = paginator.page(4)
self.request = HttpRequest()
self.base_context = {
'request': self.request,
'page_obj': paginator.page(4),
}
self.size_conf = {
'LARGE': 'pagination-lg',
'SMALL': 'pagination-sm'
}
class PaginatorTagTest(BaseTest):
3
Source : user.py
with The Unlicense
from Kartones
with The Unlicense
from Kartones
def users(request: HttpRequest) -> HttpResponse:
# For security reasons, no superadmins should have normal site profiles
users = get_user_model().objects.filter(is_active=True, is_superuser=False)
paginator = Paginator(users, settings.PAGINATION_ITEMS_PER_PAGE)
page_number = request.GET.get("page", 1)
users = paginator.get_page(page_number)
context = {
"users": users,
}
return render(request, "user/users.html", context)
def catalog(request: HttpRequest, username: str) -> HttpResponse:
3
Source : __init__.py
with BSD 3-Clause "New" or "Revised" License
from Kenstogram
with BSD 3-Clause "New" or "Revised" License
from Kenstogram
def get_paginator_items(items, paginate_by, page_number):
if not page_number:
page_number = 1
paginator = Paginator(items, paginate_by)
try:
page_number = int(page_number)
except ValueError:
raise Http404('Page can not be converted to an int.')
try:
items = paginator.page(page_number)
except InvalidPage as err:
raise Http404('Invalid page (%(page_number)s): %(message)s' % {
'page_number': page_number, 'message': str(err)})
return items
def format_money(money):
3
Source : views.py
with BSD 3-Clause "New" or "Revised" License
from Kenstogram
with BSD 3-Clause "New" or "Revised" License
from Kenstogram
def paginate_results(results, get_data, paginate_by=settings.PAGINATE_BY):
paginator = Paginator(results, paginate_by)
page_number = get_data.get('page', 1)
try:
page = paginator.page(page_number)
except InvalidPage:
raise Http404('No such page!')
return page
def evaluate_search_query(form, request):
3
Source : serializers.py
with MIT License
from konradgalczynski07
with MIT License
from konradgalczynski07
def paginated_post_comments(self, obj):
page_size = 2
paginator = Paginator(obj.post_comments.all(), page_size)
page = self.context['request'].query_params.get('page') or 1
post_comments = paginator.page(page)
serializer = CommentSerializer(post_comments, many=True)
return serializer.data
def get_liked_by_req_user(self, obj):
3
Source : serializers.py
with MIT License
from konradgalczynski07
with MIT License
from konradgalczynski07
def paginated_user_posts(self, obj):
page_size = api_settings.PAGE_SIZE
paginator = Paginator(obj.user_posts.all(), page_size)
page = self.context['request'].query_params.get('page') or 1
user_posts = paginator.page(page)
serializer = UserPostsSerializer(user_posts, many=True)
return serializer.data
def get_followed_by_req_user(self, obj):
3
Source : category.py
with BSD 3-Clause "New" or "Revised" License
from Kwpolska
with BSD 3-Clause "New" or "Revised" License
from Kwpolska
def category_list(request):
paginator = Paginator(Category.user_objects(request), settings.EXPENSES_PAGE_SIZE)
page = request.GET.get("page")
categories = paginator.get_page(page)
return render(
request,
"expenses/category_list.html",
{
"htmltitle": _("Categories"),
"pid": "category_list",
"categories": categories,
},
)
@login_required
3
Source : template.py
with BSD 3-Clause "New" or "Revised" License
from Kwpolska
with BSD 3-Clause "New" or "Revised" License
from Kwpolska
def template_list(request):
paginator = Paginator(
ExpenseTemplate.objects.filter(user=request.user).order_by("name"), settings.EXPENSES_PAGE_SIZE
)
page = request.GET.get("page")
templates = paginator.get_page(page)
return render(
request,
"expenses/template_list.html",
{
"htmltitle": _("Templates"),
"pid": "template_list",
"templates": templates,
},
)
@login_required
3
Source : video.py
with BSD 3-Clause "New" or "Revised" License
from l1f7
with BSD 3-Clause "New" or "Revised" License
from l1f7
def usage(request, video_id):
Video = get_video_model()
video = get_object_or_404(Video, id=video_id)
paginator = Paginator(video.get_usage(), per_page=25)
used_by = paginator.get_page(request.GET.get('p'))
return render(request, "wagtail_video/video/usage.html", {
'video': video,
'used_by': used_by
})
3
Source : utils.py
with Apache License 2.0
from ldv-klever
with Apache License 2.0
from ldv-klever
def paginate_queryset(queryset, page, num_per_page=None):
num_per_page = max(int(num_per_page), 1) if num_per_page else DEF_NUMBER_OF_ELEMENTS
paginator = Paginator(queryset, num_per_page)
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise BridgeException()
try:
values = paginator.page(page_number)
except PageNotAnInteger:
values = paginator.page(1)
except EmptyPage:
values = paginator.page(paginator.num_pages)
return paginator, values
3
Source : serializers_serpy.py
with MIT License
from LibrePhotos
with MIT License
from LibrePhotos
def get_items(self, obj):
page_size = self.context["request"].query_params.get("size") or 100
paginator = Paginator(obj.photos.all(), page_size)
page_number = self.context["request"].query_params.get("page") or 1
photos = paginator.page(page_number)
serializer = PigPhotoSerilizer(photos, many=True)
return serializer.data
def get_incomplete(self, obj):
3
Source : calendar.py
with BSD 3-Clause "New" or "Revised" License
from linuxsoftware
with BSD 3-Clause "New" or "Revised" License
from linuxsoftware
def _paginate(self, request, events):
paginator = Paginator(events, self.EventsPerPage)
try:
eventsPage = paginator.page(request.GET.get('page'))
except PageNotAnInteger:
eventsPage = paginator.page(1)
except EmptyPage:
eventsPage = paginator.page(paginator.num_pages)
return eventsPage
# ------------------------------------------------------------------------------
class SpecificCalendarPage(ProxyPageMixin, CalendarPage):
3
Source : tests.py
with Apache License 2.0
from lumanjiao
with Apache License 2.0
from lumanjiao
def test_invalid_page_number(self):
"""
Tests that invalid page numbers result in the correct exception being
raised.
"""
paginator = Paginator([1, 2, 3], 2)
self.assertRaises(InvalidPage, paginator.page, 3)
self.assertRaises(PageNotAnInteger, paginator.validate_number, None)
self.assertRaises(PageNotAnInteger, paginator.validate_number, 'x')
# With no content and allow_empty_first_page=True, 1 is a valid page number
paginator = Paginator([], 2)
self.assertEqual(paginator.validate_number(1), 1)
def test_paginate_misc_classes(self):
3
Source : query.py
with GNU General Public License v3.0
from lutece-awesome
with GNU General Public License v3.0
from lutece-awesome
def resolve_home_article_list(self: None, info: ResolveInfo, page: int, filter: str) -> HomeArticleListType:
home_article_list = HomeArticle.objects.all()
privilege = info.context.user.has_perm('article.view_homearticle')
if not privilege:
home_article_list = home_article_list.filter(disable=False)
if filter:
home_article_list = home_article_list.filter(title__icontains=filter)
home_article_list = home_article_list.order_by('-create_time')
paginator = Paginator(home_article_list, PER_PAGE_COUNT)
return HomeArticleListType(max_page=paginator.num_pages, home_article_list=paginator.get_page(page))
def resolve_article_comment_list(self: None, info: ResolveInfo, pk: int, page: int) -> ArticleCommentListType:
3
Source : query.py
with GNU General Public License v3.0
from lutece-awesome
with GNU General Public License v3.0
from lutece-awesome
def resolve_article_comment_list(self: None, info: ResolveInfo, pk: int, page: int) -> ArticleCommentListType:
article = get_object_or_None(Article, pk=pk)
if not article:
raise GraphQLError('No such article')
article_comment_list = ArticleComment.objects.filter(article=article)
privilege = info.context.user.has_perm('article.view_articlecomment')
if not privilege:
article_comment_list = article_comment_list.filter(disable=False)
article_comment_list = article_comment_list.order_by('-vote')
paginator = Paginator(article_comment_list, COMMENT_PER_PAGE_COUNT)
return ArticleCommentListType(max_page=paginator.num_pages, article_comment_list=paginator.get_page(page))
3
Source : query.py
with GNU General Public License v3.0
from lutece-awesome
with GNU General Public License v3.0
from lutece-awesome
def resolve_contest_list(self: None, info: ResolveInfo, page: int, filter: str):
contest_list = Contest.objects.all()
privilege = info.context.user.has_perm('contest.view_contest')
if not privilege:
contest_list = contest_list.filter(settings__disable=False)
if filter:
contest_list = contest_list.filter(Q(pk__contains=filter) | Q(title__icontains=filter))
contest_list = contest_list.order_by('-pk')
paginator = Paginator(contest_list, PER_PAGE_COUNT)
return ContestListType(max_page=paginator.num_pages, contest_list=paginator.get_page(page))
@check_contest_permission
3
Source : query.py
with GNU General Public License v3.0
from lutece-awesome
with GNU General Public License v3.0
from lutece-awesome
def resolve_contest_clarification_list(self: None, info: ResolveInfo, pk: graphene.ID(), page: graphene.Int()):
contest = get_object_or_None(Contest, pk=pk)
privilege = info.context.user.has_perm('contest.view_contest')
if datetime.now() < contest.settings.start_time and not privilege:
return ContestClarificationListType(max_page=1, contest_clarification_list=[])
if not contest:
raise GraphQLError('No such contest')
clarification_list = ContestClarification.objects.filter(contest=contest)
privilege = info.context.user.has_perm('contest.view_contestclarification')
if not privilege:
clarification_list = clarification_list.filter(disable=False)
clarification_list = clarification_list.order_by('-vote')
paginator = Paginator(clarification_list, CLARIFICATION_PER_PAGE_COUNT)
return ContestClarificationListType(max_page=paginator.num_pages,
contest_clarification_list=paginator.get_page(page))
def resolve_contest_team_list(self: None, info: ResolveInfo, pk: graphene.ID()):
3
Source : query.py
with GNU General Public License v3.0
from lutece-awesome
with GNU General Public License v3.0
from lutece-awesome
def resolve_problem_list(self: None, info: ResolveInfo, page: int, filter: str):
problem_list = Problem.objects.all()
privilege = info.context.user.has_perm('problem.view')
if not privilege:
problem_list = problem_list.filter(disable=False)
if filter:
problem_list = problem_list.filter(Q(pk__contains=filter) | Q(title__icontains=filter))
paginator = Paginator(problem_list, PER_PAGE_COUNT)
return ProblemListType(max_page=paginator.num_pages, problem_list=paginator.get_page(page))
'''
3
Source : query.py
with GNU General Public License v3.0
from lutece-awesome
with GNU General Public License v3.0
from lutece-awesome
def resolve_user_list(self: None, info: ResolveInfo, page: int, filter: str) -> UserListType:
request_usr = info.context.user
user_list = User.objects.all().order_by('-solved')
if not request_usr.has_perm('user.view'):
user_list = user_list.filter(is_active=True, is_staff=False)
if filter:
user_list = user_list.filter(username__icontains=filter)
paginator = Paginator(user_list, PER_PAGE_COUNT)
return UserListType(max_page=paginator.num_pages, user_list=paginator.get_page(page))
'''
3
Source : views.py
with MIT License
from lyk2018-python
with MIT License
from lyk2018-python
def home(request):
concobj = []
conclusions = Proof.objects.all()
for obj in conclusions:
concobj.insert(0, obj.conclusion)
paginator = Paginator(concobj,10)
page = request.GET.get('page')
concPaginationObjs = paginator.get_page(page)
return render(request, 'home.html', {
'title': 'Tümden Gelim',
'conclusions': concPaginationObjs,
})
def about(request):
3
Source : utilities.py
with BSD 2-Clause "Simplified" License
from macports
with BSD 2-Clause "Simplified" License
from macports
def paginate(request, items, paginate_by=100):
paginated_items = Paginator(items, paginate_by)
page = request.GET.get('page', 1)
try:
page_items = paginated_items.get_page(page)
except PageNotAnInteger:
page_items = paginated_items.get_page(1)
except EmptyPage:
page_items = paginated_items.get_page(paginated_items.num_pages)
return page_items
3
Source : view.py
with Apache License 2.0
from MaltoseEditor
with Apache License 2.0
from MaltoseEditor
def get_paginator(articles, page):
paginator = Paginator(articles, settings.PAGE_MAX_NUM)
try:
articles = paginator.page(page)
except PageNotAnInteger:
articles = paginator.page(1)
except EmptyPage:
articles = paginator.page(paginator.num_pages)
empty_list = ['' for _ in range(settings.PAGE_MAX_NUM - articles.object_list.count())]
return create_dict(locals(), ['articles', 'empty_list'])
class Sitemap(_Sitemap):
3
Source : views.py
with GNU General Public License v2.0
from mango-wyc
with GNU General Public License v2.0
from mango-wyc
def recommend(request):
page_number = request.GET.get('page', 1)
recommend_set = build_recommend(request, request.user)
paginator = Paginator(recommend_set, 20)
musics = paginator.page(page_number)
context = {
'musics': musics,
'user_likes': [],
'user_dislikes': []
}
user_profile = UserProfile.objects.filter(user=request.user)
if user_profile.exists():
user_profile = user_profile.first()
context['user_likes'] = user_profile.likes.all()
context['user_dislikes'] = user_profile.dislikes.all()
return render(request, 'list.html', context)
@login_required(login_url='/sign_in')
3
Source : utils.py
with Mozilla Public License 2.0
from mdn
with Mozilla Public License 2.0
from mdn
def paginate_resources(resources, per_page, page_ref):
paginator = Paginator(resources, per_page)
try:
resources = paginator.page(page_ref)
except EmptyPage:
# ie, out of range - get the last page
resources = paginator.page(paginator.num_pages)
except PageNotAnInteger:
# ie, `page_ref` is None or there's bad input
resources = paginator.page(1)
return resources
3
Source : query.py
with GNU General Public License v3.0
from Mercado-Social-de-Madrid
with GNU General Public License v3.0
from Mercado-Social-de-Madrid
def paginate(list, page, elems_perpage=10):
paginator = Paginator(list, elems_perpage)
try:
paginated = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
paginated = paginator.page(1)
except (EmptyPage, InvalidPage):
# If page is out of range (e.g. 9999), deliver last page of results.
paginated = paginator.page(paginator.num_pages)
return paginated
def generate_graph_data(stats_bydate, is_monthly=False):
3
Source : historicalDict.py
with MIT License
from mohammedi-haroune
with MIT License
from mohammedi-haroune
def genAppears(batch=10000):
paginator = Paginator(Appears.objects.select_related().all()
.order_by('meaning__entry'),batch)
for p in paginator.page_range:
print("INFO: LOADING APPEARS PAGE ",p)
for appear in paginator.get_page(p):
yield appear
def getWordStatistics(request):
3
Source : historicalDict.py
with MIT License
from mohammedi-haroune
with MIT License
from mohammedi-haroune
def genWordAppears(batch=10000):
paginator = Paginator(WordAppear.objects.all(),batch)
for p in paginator.page_range:
print("INFO: LOADING APPEARS PAGE ",p)
for appear in paginator.get_page(p):
yield appear
def fillHistoric(batch=10000):
3
Source : views.py
with MIT License
from motahharm
with MIT License
from motahharm
def courses_view(request):
context = context_load(request)
coures_models = models.course_model.objects.filter(author=request.user)
pages = Paginator(coures_models, 5)
page_num = request.GET.get('page', 1)
courses = pages.page(page_num)
context['courses'] = courses
context['pages'] = pages
return render(request, 'courses.html', context)
@login_required(login_url="/login/")
See More Examples