Get full page HTML.

    .. warning:: This can get pretty slow on long pages.
194176
def html(self):
    '''
    
    '''

    if not getattr(self, '_html', False):
      query_params = {
        'prop': 'revisions',
        'rvprop': 'content',
        'rvlimit': 1,
        'rvparse': '',
        'titles': self.title
      }

      request = _wiki_request(query_params)
      self._html = request['query']['pages'][self.pageid]['revisions'][0]['*']

    return self._html
83114
def to_html
      links = @options[:page_links] ? windowed_links : []
      # previous/next buttons
      links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:prev_label])
      links.push    page_link_or_span(@collection.next_page,     'disabled next_page', @options[:next_label])
      
      html = links.join(@options[:separator])
      @options[:container] ? @template.content_tag(:div, html, html_attributes) : html
    end
1239527
def get_large_image_url(self, page=1):
        
        template = self.resources.page.get('image')
        return template.replace("{page}", str(page)).replace("{size}", "large")
445971
def _get_html(self, url):
        
        self.log.info(u"/GET {}".format(url))
        r = requests.get(url)
        if hasattr(r, 'from_cache'):
            if r.from_cache:
                self.log.info("(from cache)")

        if r.status_code != 200:
            throw_request_err(r)

        return r.content
111358
def show
      @all_pages = @question_sheet.pages.find(:all)
      @page = @all_pages[0]

      respond_to do |format|
        format.html # show.rhtml
        format.xml  { render :xml => @question_sheet.to_xml }
      end
    end
848132
def html(self):
        
        if self._html is False:
            self._html = None
            query_params = {
                "prop": "revisions",
                "rvprop": "content",
                "rvlimit": 1,
                "rvparse": "",
                "titles": self.title,
            }
            request = self.mediawiki.wiki_request(query_params)
            page = request["query"]["pages"][self.pageid]
            self._html = page["revisions"][0]["*"]
        return self._html
1186859
def to_html(options = :DEFAULT, extensions = [])
      opts = Config.process_options(options, :render)
      _render_html(opts, extensions).force_encoding('utf-8')
    end
941730
def _get_results(self, page):
		""""""

		soup = _get_soup(page)
		details = soup.find_all("tr", class_="odd")
		even = soup.find_all("tr", class_="even")
		# Join the results
		for i in range(len(even)):
			details.insert((i * 2)+1, even[i])

		return self._parse_details(details)
893668
def _dump_to_pages(dump):
  
  pos = 0
  ret = []
  start_tag = u"<page>\n"
  end_tag = u"</page>\n"
  while True:
    start_pos = dump.find(start_tag, pos)
    if start_pos == -1:
      break
    start_pos += len(start_tag)
    end_pos = dump.find(end_tag, start_pos)
    if end_pos == -1:
      break
    ret.append(dump[start_pos:end_pos])
    pos = end_pos + len(end_tag)
  return ret
1370556
def get_html(grafs):
    
    html = [format_html('<p>{}</p>', p) for p in grafs]
    html = [p.replace("\n", "<br>") for p in html]
    return format_html(six.text_type('\n\n'.join(html)))
1130494
def get_beautiful_soup(self, source=None):
        
        from bs4 import BeautifulSoup
        if not source:
            self.wait_for_ready_state_complete()
            source = self.get_page_source()
        soup = BeautifulSoup(source, "html.parser")
        return soup
3880
def get(self):
        """"""
        return self.render(
            'index.html',
            databench_version=DATABENCH_VERSION,
            meta_infos=self.meta_infos(),
            **self.info
        )
824810
def _render_pages(self):
        """"""
        self.style_log = StyleLog(self.stylesheet)
        self.floats = set()
        self.placed_footnotes = set()
        self._start_time = time.time()

        part_page_counts = {}
        part_page_count = PartPageCount()
        last_number_format = None
        for part_template in self.part_templates:
            part = part_template.document_part(self, part_page_count.count + 1)
            if part is None:
                continue
            if part_template.page_number_format != last_number_format:
                part_page_count = PartPageCount()
            part_page_count += part.render(part_page_count.count + 1)
            part_page_counts[part_template.name] = part_page_count
            last_number_format = part_template.page_number_format
        sys.stdout.write('\n')     # for the progress indicator
        return part_page_counts
1201483
def to_html(input, context = {}, result = nil)
      result = call(input, context, result = nil)
      output = result[:output]
      if output.respond_to?(:to_html)
        output.to_html
      else
        output.to_s
      end
    end
793295
def render_full(self, request, lodgeit_url=None):
        """"""
        app = request.app
        root_path = request.app.ps.debugtoolbar.cfg.prefix
        exc = escape(self.exception)
        summary = self.render_summary(include_title=False, request=request)
        token = request.app['debugtoolbar']['pdbt_token']

        vars = {
            'evalex': app.ps.debugtoolbar.cfg.intercept_exc == 'debug' and 'true' or 'false',
            'console': 'console',
            'lodgeit_url': lodgeit_url and escape(lodgeit_url) or '',
            'title': exc,
            'exception': exc,
            'exception_type': escape(self.exception_type),
            'summary': summary,
            'plaintext': self.plaintext,
            'plaintext_cs': re.sub('-{2,}', '-', self.plaintext),
            'traceback_id': self.id,
            'static_path': root_path + 'static/',
            'token': token,
            'root_path': root_path,
            'url': root_path + 'exception?token=%s&tb=%s' % (token, self.id),
        }
        template = app.ps.jinja2.env.get_template('debugtoolbar/exception.html')
        return template.render(app=app, request=request, **vars)
580540
def _page_to_text(page):
  
  # text start tag looks like "<text ..otherstuff>"
  start_pos = page.find(u"<text")
  assert start_pos != -1
  end_tag_pos = page.find(u">", start_pos)
  assert end_tag_pos != -1
  end_tag_pos += len(u">")
  end_pos = page.find(u"</text>")
  if end_pos == -1:
    return u""
  return page[end_tag_pos:end_pos]
172969
def get_pages(url):
    
    while True:
        yield url
        doc = html.parse(url).find("body")
        links = [a for a in doc.findall(".//a") if a.text and a.text.startswith("next ")]
        if not links:
            break
        url = urljoin(url, links[0].get('href'))