list: Pages that link to this page

            Note:
                Not settable
190054
def backlinks(self):
        
        if self._backlinks is None:
            self._backlinks = list()
            params = {
                "action": "query",
                "list": "backlinks",
                "bltitle": self.title,
                "bllimit": "max",
                "blfilterredir": "nonredirects",
                "blnamespace": 0,
            }
            tmp = [link["title"] for link in self._continued_query(params, "backlinks")]
            self._backlinks = sorted(tmp)
        return self._backlinks
1236730
def get_pages(self):
        ''''''
        pages = []
        page = []
        for i, item in enumerate(self.get_rows):
            if i > 0 and i % self.objects_per_page == 0:
                pages.append(page)
                page = []
            page.append(item)
        pages.append(page)
        return pages
1333130
def list_build_records_for_set(id=None, name=None, page_size=200, page_index=0, sort="", q=""):
    
    content = list_build_records_for_set_raw(id, name, page_size, page_index, sort, q)
    if content:
        return utils.format_json_list(content)
771118
def list(self, limit=None, offset=None):
        """"""
        uri = "/%s%s" % (self.uri_base, self._get_pagination_qs(limit, offset))
        return self._list(uri)
439981
public Page<Table> list() {
    // [START ]
    Page<Table> tables = dataset.list();
    for (Table table : tables.iterateAll()) {
      // do something with the table
    }
    // [END ]
    return tables;
  }
1233247
def link_page_filter(self, page, modelview_name):
        
        new_args = request.view_args.copy()
        args = request.args.copy()
        args["page_" + modelview_name] = page
        return url_for(
            request.endpoint,
            **dict(list(new_args.items()) + list(args.to_dict().items()))
        )
699941
def group_list
      page = 1
      not_done = true
      count = 0
      while not_done
        current_path = '/api/v1/groups?page=' << page.to_s
        res = @conn.get(current_path)
        if res['groups'] == []
          not_done = false
        elsif !res['message'].nil?
          return { 'message' => res['message'] }
        elsif page == 1
          count = res['count']
          groups = res['groups']
        else
          res['groups'].each do |group|
            groups << group
          end
        end
        page += 1
      end
      { 'count' => count, 'groups' => groups }
    end
385048
def page_list(
    request, template_name='wakawaka/page_list.html', extra_context=None
):
    
    page_list = WikiPage.objects.all()
    page_list = page_list.order_by('slug')

    template_context = {
        'page_list': page_list,
        'index_slug': getattr(settings, 'WAKAWAKA_DEFAULT_INDEX', 'WikiIndex'),
    }
    template_context.update(extra_context or {})
    return render(request, template_name, template_context)
1140252
def link(self, x,y,w,h,link):
        ""
        if not self.page in self.page_links:
            self.page_links[self.page] = []
        self.page_links[self.page] += [(x*self.k,self.h_pt-y*self.k,w*self.k,h*self.k,link),]
588542
private Content getClassLinks(LinkInfoImpl.Kind context, Collection<?> list) {
        Object[] typeList = list.toArray();
        Content dd = new HtmlTree(HtmlTag.DD);
        boolean isFirst = true;
        for (Object item : typeList) {
            if (!isFirst) {
                Content separator = new StringContent(", ");
                dd.addContent(separator);
            } else {
                isFirst = false;
            }

            if (item instanceof ClassDoc) {
                Content link = getLink(new LinkInfoImpl(configuration, context, (ClassDoc)item));
                dd.addContent(link);
            } else {
                Content link = getLink(new LinkInfoImpl(configuration, context, (Type)item));
                dd.addContent(link);
            }
        }
        return dd;
    }
42590
def list(self, page=1, per_page=50):
        
        data = {"page": page,
                "per_page": per_page}
        return self.get(self.base_url, data=data)
472148
def filter_pages(pages, pagenum, pagename):
    
    if pagenum:
        try:
            pages = [list(pages)[pagenum - 1]]
        except IndexError:
            raise IndexError('Invalid page number: %d' % pagenum)

    if pagename:
        pages = [page for page in pages if page.name == pagename]
        if pages == []:
            raise IndexError('Page not found: pagename=%s' % pagename)

    return pages
776163
def navigation_list(site, page)
      pages = site['pages'].select { |p|
        p.data['navigation'] && p.data['title']
      }.sort_by { |p| p.data['navigation'] }

      list = []
      list << pages.map { |p|
        active = (p.url == page['url']) || (page.key?('next') && File.join(p.dir, p.basename) == '/index')
        navigation_list_item(File.join(site['url'], p.url), p.data['title'], active)
      }
      list.join("\n")
    end
1006769
def pages(self):
        
        # Start with a page object for unknown entries if the HAR data has
        # any entries with no page ID
        pages = []
        if any('pageref' not in entry for entry in self.har_data['entries']):
            pages.append(HarPage('unknown', har_parser=self))
        for har_page in self.har_data['pages']:
            page = HarPage(har_page['id'], har_parser=self)
            pages.append(page)

        return pages
360124
def list_next_page(self):
        
        uri = self._paging.get("domain", {}).get("next_uri")
        if uri is None:
            raise exc.NoMoreResults("There are no more pages of domains to "
                    "list.")
        return self._list(uri)
913679
def list_build_set_records(id=None, name=None, page_size=200, page_index=0, sort="", q=""):
    
    content = list_build_set_records_raw(id, name, page_size, page_index, sort, q)
    if content:
        return utils.format_json_list(content)
526650
def default_links_pagination_factory(page, urlkwargs):
    """"""
    endpoint = '.communities_list'

    links = {
        'self': url_for(endpoint, page=page.page, _external=True, **urlkwargs),
    }

    if page.has_prev:
        links['prev'] = url_for(endpoint, page=page.prev_num, _external=True,
                                **urlkwargs)
    if page.has_next:
        links['next'] = url_for(endpoint, page=page.next_num, _external=True,
                                **urlkwargs)

    return links