Python weasyprint.HTML类代码示例

def md2pdf(pdf_file_path, md_content=None, md_file_path=None,
           css_file_path=None, base_url=None):
    """
    Convert markdown file to pdf with styles
    """

    # Convert markdown to html
    raw_html = ""
    extras = ["cuddled-lists"]
    if md_file_path:
        raw_html = markdown_path(md_file_path, extras=extras)
    elif md_content:
        raw_html = markdown(md_content, extras=extras)

    if not len(raw_html):
        raise ValidationError('Input markdown seems empty')

    # Weasyprint HTML object
    html = HTML(string=raw_html, base_url=base_url)

    # Get styles
    css = []
    if css_file_path:
        css.append(CSS(filename=css_file_path))

    # Generate PDF
    html.write_pdf(pdf_file_path, stylesheets=css)

    return

def download_pdf(story, output='', message=True):
    """ Download a story to pdf.
    :type message: bool
    """
    if output == '':
        output = _get_download_name(story)
    output = _add_extension(output, 'pdf')
    if message:
        print 'Downloading \'%s\' to %s...' % (story.title, output)
    html = ''
    for chapter in story.get_chapters():
        if message:
            print 'Adding %s...' % (chapter.title)
        html += '<h2>Chapter %d: %s</h2>' % (chapter.number, chapter.title)
        html += chapter.raw_text
        html += '</br>' * 10
    if message:
        print 'Compiling PDF...'

    # This turned out not to work on the command line as it needed an X interface.
    #pdfkit.from_string(html, output)
    # Instead trying with weasyprint
    content = unicode(html.strip(codecs.BOM_UTF8), 'utf-8')
    h = HTML(content)
    h.write_pdf(output)

def export_schedule_to_pdf(request, callgroup):
	from weasyprint import HTML
	context = get_context(request)

	context['site'] = callgroup.description
	month, year = int(request.GET.get('month', 1)), int(request.GET.get('year', 9999))
	weekstart = int(request.GET.get('weekstart', 0))
	monthstart = datetime.date(year, month, day=1)
	context['month'] = monthstart.strftime("%B %Y")
	monthstart = monthstart - datetime.timedelta(days=monthstart.day - 1)
	# make sure we start on a sunday (or monday if weekstart=1)
	monthstart = monthstart - datetime.timedelta(days=(monthstart.isoweekday() % 7)) + \
		datetime.timedelta(weekstart)
	user = request.session['MHL_Users']['MHLUser']
	context['weeks'] = generateOnCallList(callgroup, monthstart, weekstart, user)
	context['days'] = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
	for _ in range(weekstart):
		context['days'].append(context['days'].pop(0))
	# load template with context and static root for pdf renderer, generate pdf buffer
	static_root = settings.STATICFILES_DIRS[0]
	html = render_to_string('pdf_schedule.html', {'STATIC_ROOT': static_root}, context)
	weasyhtml = HTML(string=html)
	schedcss = join(static_root, 'css', 'pdf_schedule.css')
	pdf = weasyhtml.write_pdf(stylesheets=[schedcss])  # ,target='/tmp/test.pdf') 
	# prepare response, append &nopdf to GET url for test
	response = HttpResponse(pdf, mimetype="application/pdf")
	response["Cache-Control"] = "no-cache"
	response["Accept-Ranges"] = "none"
	response["Content-Disposition"] = "attachment; filename=schedule-%d-%d.pdf" % (year, month)
	return response if 'nopdf' not in request.GET else \
		render_to_response("pdf_schedule.html", context)

def pdf_print(request, requisition_id):
    """Exports the requisition in PDF."""
    # Selecting the requisition
    requisition = get_object_or_404(models.Requisition, pk=requisition_id)

    rendered = render_to_response('purchase/requisition_report.html', {
        'vessel': Vessel.objects.latest('id'),
        'title': _("Requisition"),
        'user': request.user,
        'requisition': requisition,
        'today': datetime.date.today(),
        },
        context_instance=RequestContext(request))

    # Creating the response
    filename = "pharmaship_requisition_{0}.pdf".format(requisition.reference)
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'attachment; filename="{0}"'.format(filename)

    # Converting it into PDF
    html = HTML(string=rendered.content,
                base_url=request.build_absolute_uri()
                )
    html.write_pdf(response,
                   stylesheets=[
                       CSS(settings.BASE_DIR + '/purchase/static/css/purchase/report.css')
                       ])
    return response

 def make_book(self, filename, config):
     #QtGui.QMessageBox.critical(None, "Network Error","make_book")
     with tempfile.TemporaryDirectory(prefix="pySpellbook-") as tempdir:
         temphtml = tempfile.NamedTemporaryFile(dir=tempdir, delete=False, suffix=".html", mode="w")
         temphtml.write(self.rendered)
         #QtGui.QMessageBox.critical(None, "Network Error","wrote html")
         tmpname = temphtml.name
         temphtml.close()
         #QtGui.QMessageBox.critical(None, "Network Error",tmpname)
         #os.mkdir(os.path.join(tempdir, "resources"))
         #for r in self.resourcelist:
         #    shutil.copy(r, os.path.join(tempdir,"resources"))
         if config['backend'] == 'prince':
             os.system("\"%s\" %s -o %s" % (config['prince_path'], tmpname, filename))
         elif config['backend'] == 'HTML':
             shutil.copy(os.path.join(tempdir, tmpname), filename)
             webbrowser.open_new_tab("file:///%s" % filename)
         elif config['backend'] == 'custom':
             custom_command = config['custom'].replace("$INPUT", temphtml).replace("$OUTPUT", filename)
             shutil.copy(custom_command)
         else:
             if weasy:
                 html = HTML("file://%s" % tmpname)
                 html.write_pdf(target=filename)
             else:
                 import pySpellbook.qtpdf
                 os.chdir(tempdir)
                 printer = pySpellbook.qtpdf.Printer(self.parent)
                 printer.load(tmpname)
                 printer.print(filename)

   def savePDF(self, pdf_filename, parent_soup, target_node, yes_phrase, url, key, school_name):
       if target_node:
          grandparent_node = target_node.parent.parent
          tag = self.highlightedNode(target_node, yes_phrase, parent_soup)
          self.replaceNode(target_node, tag)
          body = Tag(parent_soup,"body")
          body.append(grandparent_node)
       else:
          body = parent_soup
       try:
          weasyprint = HTML(string=body.prettify())
          tmp_filename = 'pdfs/tmp.pdf'
          weasyprint.write_pdf(tmp_filename,stylesheets=[CSS(string='body { font-size: 10px; font-family: serif !important }')])
       except:
          print "weasyprint failed on url: "+url
          if target_node:
             self.replaceNode(tag, target_node) #return to old state
          return

       if target_node:
          self.replaceNode(tag, target_node) #return to old state

       sep_filename = "pdfs/sep.pdf"
       self.makeSepPage(sep_filename, url, key, school_name)

       merger = PdfFileMerger()
       if (os.path.exists(pdf_filename)):
           merger.append(PdfFileReader(file(pdf_filename, 'rb')))
       merger.append(PdfFileReader(file(sep_filename, 'rb')))
       merger.append(PdfFileReader(file(tmp_filename, 'rb')))
       merger.write(pdf_filename)

    def print_certidao(self, request, diligencias):
        """
        :param diligencias:
        :return:
        """
        from weasyprint import HTML, CSS
        from django.conf import settings
        from app.models import Diligencia
        from django.utils import datetime_safe


        modelo_html = ''
        for i in range(len(diligencias)):
            if i == 0:                                          #primeira certidão # '<meta charset="utf-8" />'
                modelo_html += '<html>' \
                               '<head>' \
                               '<meta charset="utf-8" />' \
                               '<base href="http://ofjusapp.pythonanywhere.com/">'\
                               '</head>' \
                               '<body>' \
                               '<div style="float: none;">' \
                               '<div>'
                modelo_html += diligencias[i].documento
                modelo_html += '</div>'
            else:                                               #certidões intermediarias
                modelo_html += '<div style="page-break-before:always;">'
                modelo_html += diligencias[i].documento
                modelo_html += '</div>'
        modelo_html += '</div></body></html>'
        pdf_html = HTML(string=modelo_html)
        main_doc = pdf_html.render()
        pdf_file = main_doc.write_pdf()
        diligencias.update(imprimir=False)
        #pdf_file = HTML('http://weasyprint.org/').write_pdf('/tmp/weasyprint-website.pdf')
        return pdf_file  # returns the response.

 def render_pdf(self):
     total = self.doc['total']
     if self.home_country:
         invoice_country_iso = self.doc['address']['country_iso_alpha2']
         if invoice_country_iso and invoice_country_iso != self.home_country:  # no tax in bill
             total = self.doc['amount']
             self.doc['total'] = total
     tpl = self.jinja_env.get_template('invoice_tpl.html')
     self.invoice_fname = "{date}_CHF{total:.2f}_Nr{nr}_hosting-{name}_ta".format(
         date=self.doc['date'].strftime("%Y-%m-%d"),
         total=total,
         nr=self.doc['nr'],
         name=self.client_name_normalized()
     )
     for file_format in ['html', 'pdf']:
         path = "%s/%s" % (self.output_dir, file_format)
         if not os.path.exists(path):
             os.mkdir(path)
     with codecs.open(
         '%s/html/%s.html' % (self.output_dir, self.invoice_fname),
         'w+', encoding="utf-8"
     ) as invoice_html:
         invoice_html.write(tpl.render(**self.doc))
         invoice_html.seek(0)
         base_url = "%s/html" % self.invoice_template_dir
         html = HTML(invoice_html, base_url=base_url)
         html.write_pdf('%s/pdf/%s.pdf' % (self.output_dir, self.invoice_fname))

 def render(test_id):
     document = HTML(safe_join(suite_directory, test_id + ".htm"), encoding="utf8").render(
         stylesheets=[default_stylesheet], enable_hinting=True
     )
     pages = [
         "data:image/png;base64," + document.copy([page]).write_png().encode("base64").replace("\n", "")
         for page in document.pages
     ]
     return render_template("render.html", **locals())

 def render(test_id):
     document = HTML(
         safe_join(suite_directory, test_id + '.htm'),
         encoding='utf8',
     ).render(stylesheets=[default_stylesheet], enable_hinting=True)
     pages = [
         'data:image/png;base64,' + document.copy([page]).write_png(
             )[0].encode('base64').replace('\n', '')
         for page in document.pages]
     return render_template('render.html', **locals())

def generate():
    name = request.args.get('filename', 'unnamed.pdf')
    app.logger.info('POST  /pdf?filename=%s' % name)
    html = HTML(string=request.data)
    pdf = html.write_pdf()
    response = make_response(pdf)
    response.headers['Content-Type'] = 'application/pdf'
    response.headers['Content-Disposition'] = 'inline;filename=%s' % name
    app.logger.info(' ==> POST  /pdf?filename=%s  ok' % name)
    return response

def make_pdf(config, data):
    """
    Generate PDF file out of generated 'index.html' page.
    """
    from weasyprint import HTML
    output_dir = config.get('output_dir', 'build')
    output_file = os.path.join(output_dir, config.get('pdf_file', 'resume.pdf'))
    input_file = os.path.join(output_dir, 'index.html')
    theme_location = os.path.join('themes', config['theme'])
    html = HTML(input_file, base_url=theme_location)
    html.write_pdf(output_file)

 def get_data():
     if 'wsgi.input' in environ and request_body_size:
         request = environ['wsgi.input'].read(request_body_size)
         content = parse_qs(request.decode('utf-8'))['content'][0]
     else:
         content = DEFAULT_CONTENT
     html = HTML(string=content)
     png = BytesIO()
     html.write_png(png)
     png.seek(0)
     return content, b64encode(png.read()).decode('ascii')

 def generate_pdf(self):
     ''' renders html from file with given context and creates pdf file from it
     '''
     html_string = Template(self.template.template.read()).render(Context(json.loads(self.content)))
     html = HTML(string=html_string, base_url='')
     filename = self.name.replace('/', '.') + '.pdf'
     buffer = BytesIO()
     html.write_pdf(target=buffer)
     pdf = buffer.getvalue()
     buffer.close()
     self.file.save(filename, ContentFile(pdf))

def print_order(orders, name, phone):
    template = env.get_template('template.md')

    total = sum(order.price for order in orders)
    md = template.render(name=name, phone=phone, orders=orders, total=total)
    html = markdown.markdown(md, extensions=['markdown.extensions.tables'])
    document = HTML(string=html)

    tmp = tempfile.NamedTemporaryFile(mode='wb', suffix='.pdf')
    document.write_pdf(tmp, stylesheets=[CSS(filename='order-style.css')])

    return tmp