django.core.paginator.Paginator

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 7

3 Source : paginator.py
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

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

    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

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

    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

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

    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

    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

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

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

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

  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

    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

    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

    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

    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

    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

    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

    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

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

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

    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

    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

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

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

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

    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

    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

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

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

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

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

    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

    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

    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

    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

    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

    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

    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

    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

    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

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

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

    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

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

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

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

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

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

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