Python reportlab.lib.styles 模块，getSampleStyleSheet() 实例源码

def test_11_drawing(self):
        from reportlab.lib.styles import getSampleStyleSheet
        from reportlab.lib import colors
        from reportlab.platypus import SimpleDocTemplate, Spacer, Paragraph
        from reportlab.pdfbase import pdfmetrics
        from reportlab.graphics.shapes import Drawing, Rect
        from reportlab.pdfbase.ttfonts import TTFont

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        stylesheet = getSampleStyleSheet()

        elements = []
        doc = SimpleDocTemplate("demo.pdf")

        elements.append(Paragraph('<font name="chsFont">JY.zenist.song - ??</font>', stylesheet['Title']))
        elements.append(Spacer(1,12))

        d = Drawing(400,200)
        d.add(Rect(50,50,300,100, fillColor=colors.yellow))
        elements.append(d)

        doc.build(elements)

def imprimir(self):
        buffer = self.buffer
        doc = SimpleDocTemplate(buffer,
                                rightMargin=50,
                                leftMargin=50,
                                topMargin=20,
                                bottomMargin=50,
                                pagesize=self.pagesize)

        elements = []
        styles = getSampleStyleSheet()
        elements.append(self.tabla_encabezado(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_datos(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_detalle())
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_observaciones())
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_firmas())
        doc.build(elements)
        pdf = buffer.getvalue()
        buffer.close()
        return pdf

def buildContext(stylesheet=None):
    result = {}
    from reportlab.lib.styles import getSampleStyleSheet
    if stylesheet is not None:
        # Copy styles with the same name as aliases
        for stylenamekey, stylenamevalue in DEFAULT_ALIASES.items():
            if stylenamekey in stylesheet:
                result[stylenamekey] = stylesheet[stylenamekey]
        # Then make aliases
        for stylenamekey, stylenamevalue in DEFAULT_ALIASES.items():
            if stylenamevalue in stylesheet:
                result[stylenamekey] = stylesheet[stylenamevalue]

    styles = getSampleStyleSheet()
    # Then, fill in defaults if they were not filled yet.
    for stylenamekey, stylenamevalue in DEFAULT_ALIASES.items():
        if stylenamekey not in result and stylenamevalue in styles:
            result[stylenamekey] = styles[stylenamevalue]
    return result

def convertSourceFiles(filenames):
    "Helper function - makes minimal PDF document"

    from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, XPreformatted
    from reportlab.lib.styles import getSampleStyleSheet
    styT=getSampleStyleSheet()["Title"]
    styC=getSampleStyleSheet()["Code"]
    doc = SimpleDocTemplate("pygments2xpre.pdf")
    S = [].append
    for filename in filenames:
        S(Paragraph(filename,style=styT))
        src = open(filename, 'r').read()
        fmt = pygments2xpre(src)
        S(XPreformatted(fmt, style=styC))
    doc.build(S.__self__)
    print('saved pygments2xpre.pdf')

def test_09_docTemplate(self):
        from reportlab.lib.styles import getSampleStyleSheet
        from reportlab.platypus import SimpleDocTemplate, Spacer, Paragraph
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        stylesheet = getSampleStyleSheet()

        elements = []
        doc = SimpleDocTemplate("demo.pdf")

        elements.append(Paragraph('<font name="chsFont">AUT OOM????</font>', stylesheet['Title']))
        elements.append(Spacer(1,12))

        doc.build(elements)

def _add_notes(self, canvas):
        """
        This is designed to be the last element on the page.
        Don't move it or stuff will break
        """
        start_posn = self.start_posn
        start_posn = self.start_posn
        canvas.setFillColor(colors.blue)
        canvas.setFont('Helvetica', 10)
        canvas.drawString(0.5*inch, start_posn,
                          'Section E - Registration Notes')
        canvas.setFillColor(colors.black)
        canvas.rect(0.5*inch, 0.75*inch,
                    PAGE_WIDTH-inch, start_posn-0.85*inch)
        style_sheet = getSampleStyleSheet()
        style = style_sheet['BodyText']
        para = Paragraph(self.details['registration_notes'], style)
        h=para.wrap(7.1 * inch, start_posn-0.65*inch)[1]
        para.drawOn(canvas, 0.7 * inch, start_posn-h-0.2*inch)

def __init__(self, config, request, output, download_server):

        self.config = config
        self.client = config.client
        self.c_asdf = self.client.asdf.data

        self.request_id = str(request['_id'])
        self.request = request
        self.output = output

        self.assets_dir = os.path.join(config.source_dir, 'geo-hpc/assets')

        self.download_server = download_server

        self.doc = 0

        # container for the 'Flowable' objects
        self.Story = []

        self.styles = getSampleStyleSheet()
        self.styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))
        self.styles.add(ParagraphStyle(name='Center', alignment=TA_CENTER))

def main():
    import sys
    import urllib2
    from cStringIO import StringIO
    from reportlab.platypus import SimpleDocTemplate, Image, Paragraph, PageBreak
    from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet

    #This is needed because ReportLab accepts the StringIO as a file-like object,
    #but doesn't accept urllib2.urlopen's return value
    def get_image(url):
        u = urllib2.urlopen(url)
        return StringIO(u.read())

    styles = getSampleStyleSheet()
    styleN = ParagraphStyle(styles['Normal'])

    # build doc

    if len(sys.argv) > 1:
        fn = sys.argv[1]
    else:
        fn = "filename.pdf"
    doc = SimpleDocTemplate(open(fn, "wb"))
    elements = [
        Paragraph("Hello,", styleN),
        Image(get_image("http://www.red-dove.com/images/rdclogo.gif")),
        PageBreak(),
        Paragraph("world!", styleN),
        Image(get_image("http://www.python.org/images/python-logo.gif")),
    ]
    doc.build(elements, canvasmaker=NumberedCanvas)

def get_paragraph_style():
    style = getSampleStyleSheet()
    # TODO: font
    # style.fontName = 'OpenSans'
    style['Normal'].fontSize = FONTSIZE
    style['Normal'].leading = int(1.5 * FONTSIZE)
    return style

def hello(c, link):
    c.translate(ORIGIN_X, ORIGIN_Y)

    # Draw paragraph
    stylesheet = getSampleStyleSheet()
    style = stylesheet['BodyText']
    style.fontName = 'LeagueGothic'
    style.fontSize = 42
    style.leading = 44

    p = Paragraph('<b>print</b><br/>your<br/><b>badge</b><br/>here', style)
    qr_left = 30*mm
    p_w, p_h = p.wrap(qr_left, HEIGHT)
    p.drawOn(c, 0, 0)


    # Add QR Code
    qr_code = qr.QrCodeWidget(link)
    qr_bounds = qr_code.getBounds()
    qr_width = qr_bounds[2] - qr_bounds[0]
    qr_height = qr_bounds[3] - qr_bounds[1]
    d = Drawing(HEIGHT, HEIGHT, transform=[HEIGHT/qr_width,0,0,HEIGHT/qr_height,0,0])
    d.add(qr_code)
    renderPDF.draw(d, c, qr_left, 0)

    # Draw thin line between text and QR code
    c.line(qr_left, 0, qr_left, HEIGHT)
    c.line(qr_left + HEIGHT, 0, qr_left+HEIGHT, HEIGHT)

    img_left = qr_left + HEIGHT

    # Draw images
    c.drawImage('images/ipv6.jpg', img_left, 0, 20*mm, 1/3 * HEIGHT, mask=None, preserveAspectRatio=True, anchor='c')
    c.drawImage('images/ffrhein_logo_claim_line_rot.png', img_left, 1/3*HEIGHT, 20*mm, 2/3 * HEIGHT, mask=None, preserveAspectRatio=True, anchor='c')

def __init__( self, data_dir, uid,  out_dir=None, filename=None, load=True, user=None,
                 report_type='saxs',md=None ):
        self.data_dir = data_dir
        self.uid = uid
        self.md = md        
        #print(md)
        if user is None:
            user = 'chx'
        self.user = user
        if out_dir is None:
            out_dir = data_dir 
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)
        self.out_dir=out_dir

        self.styles = getSampleStyleSheet()
        self.width, self.height = letter

        self.report_type = report_type        
        dt =datetime.now()
        CurTime = '%02d/%02d/%s/-%02d/%02d/' % ( dt.month, dt.day, dt.year,dt.hour,dt.minute)
        self.CurTime = CurTime
        if filename is None:
            filename="XPCS_Analysis_Report_for_uid=%s.pdf"%uid
        filename=out_dir + filename
        c = canvas.Canvas( filename, pagesize=letter)
        self.filename= filename
        #c.setTitle("XPCS Analysis Report for uid=%s"%uid)
        c.setTitle(filename)
        self.c = c
        if load:
            self.load_metadata()

def render(self):
        style = getSampleStyleSheet()['Normal']
        style.alignment = self.text_align
        style.fontName = self.font_name
        if self._layout.debug_fields:
            style.backColor = "rgba(255, 0, 0, 0.5)"

        if self.fit_text:
            original_size = self.font_size
            text_width = stringWidth(self.data, self.font_name, self.font_size)
            while text_width > self.width:
                self.font_size -= 1
                text_width = stringWidth(self.data, self.font_name, self.font_size)
            # Size has been adjusted. Lower text accordingly
            if original_size > self.font_size:
                self._offset_top = (original_size - self.font_size) / 2.0

        if self.height == 0:
            self.height = self.font_size
        style.fontSize = self.font_size
        style.leading = self.font_size


        p = Paragraph('<font color="%s">%s</font>' % (self.color, self.data), style)
        p.wrap(self.width, self.height)
        top = self._layout.height - self.top - self.height - self._offset_top
        p.drawOn(self._canvas, self.left, top)

def __init__(self, *args, **kwargs):
        __version_info__ = ('1', '0', '0')
        self.__version__ = __version_info__
        self.games = kwargs.get('games', [])  # list of 'game' objects
        self.user = kwargs.get('user', '')
        self.time = kwargs.get('time', 'UK')
        self.filename = kwargs.get('filename')
        self.progress = kwargs.get('progress', False)
        self.family_names = kwargs.get('familys', [])
        self.font_names = kwargs.get('fonts', [])
        self.page_footer = kwargs.get(
            'page_footer', '')
        self.page_header = kwargs.get(
            'page_header', 'Board Game Geek Collection Printer (v0.1)')
        header = kwargs.get('header')
        body = kwargs.get('left')
        margin = kwargs.get('margin', 72)
        page_size = kwargs.get('page', 'A4')
        if page_size == 'A4':
            size = A4
        elif page_size == 'letter':
            size = Letter
        else:
            raise NotImplementedError('Page size "%" is not available' % page_size)
        self.set_doc(filename=self.filename, margin=margin, page=size)
        # fonts & styles
        for fname in self.family_names:
            self.ttf_register(fname, family=True)
        for fname in self.font_names:
            self.ttf_register(fname, family=False)
        self.styles = getSampleStyleSheet()
        self.set_styles(body, header)  # style sheets pre-made

def _header_footer(self, canvas, doc):
        # Save the state of our canvas so we can draw on it
        canvas.saveState()
        styles = getSampleStyleSheet()
        style_right = ParagraphStyle(name='right', parent=styles['Normal'], fontName='Helvetica',
                fontSize=10, alignment=TA_RIGHT)
        # Header


        fieldsight_logo = Image('http://' + self.base_url +'/static/images/fs1.jpg')
        fieldsight_logo._restrictSize(1.5 * inch, 1.5 * inch)


        # headerleft = Paragraph("FieldSight", styles['Normal'])
        headerright = Paragraph(self.project_name, style_right)

        # w1, h1 = headerleft.wrap(doc.width, doc.topMargin)
        w2, h2 = headerright.wrap(doc.width, doc.topMargin)

        textWidth = stringWidth(self.project_name, fontName='Helvetica',
                fontSize=10) 

        fieldsight_logo.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin + 12)
        headerright.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin + 20)

        project_logo = Image('http://' + self.base_url + self.project_logo)
        project_logo._restrictSize(0.4 * inch, 0.4 * inch)
        project_logo.drawOn(canvas, headerright.width + doc.leftMargin -0.5 * inch - textWidth, doc.height + doc.topMargin + 10)

        # header.drawOn(canvas, doc.leftMargin + doc.width, doc.height + doc.topMargin +20)

        # Footer
        footer = Paragraph('Page no. '+str(canvas._pageNumber), style_right)
        w, h = footer.wrap(doc.width, doc.bottomMargin)
        footer.drawOn(canvas, doc.leftMargin, h + 40)

        # Release the canvas
        canvas.restoreState()

def imprimir(self):
        y=300
        buffer = self.buffer
        izquierda = ParagraphStyle('parrafos',
                                   alignment = TA_LEFT,
                                   fontSize = 10,
                                   fontName="Times-Roman")
        doc = SimpleDocTemplate(buffer,
                                rightMargin=50,
                                leftMargin=50,
                                topMargin=20,
                                bottomMargin=50,
                                pagesize=self.pagesize)

        elements = [] 
        styles = getSampleStyleSheet()        
        elements.append(self.tabla_encabezado(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_datos(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_detalle())
        elements.append(Spacer(1,0.25 * cm))
        elements.append(self.tabla_total_letras())        
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_otros())
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_observaciones())
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_afectacion_presupuestal())
        linea_firma = Line(280, y-250, 470, y-250)
        d = Drawing(100, 1)
        d.add(linea_firma)
        elements.append(d)
        doc.build(elements)
        pdf = buffer.getvalue()
        buffer.close()
        return pdf

def imprimir(self):
        y=300
        buffer = self.buffer
        izquierda = ParagraphStyle('parrafos',
                                   alignment = TA_LEFT,
                                   fontSize = 10,
                                   fontName="Times-Roman")
        doc = SimpleDocTemplate(buffer,
                                rightMargin=50,
                                leftMargin=50,
                                topMargin=20,
                                bottomMargin=50,
                                pagesize=self.pagesize)

        elements = [] 
        styles = getSampleStyleSheet()        
        elements.append(self.tabla_encabezado(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_datos(styles))        
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_detalle())
        elements.append(Spacer(1,0.25 * cm))
        elements.append(self.tabla_total())   
        elements.append(Spacer(1, 0.25 * cm))     
        elements.append(self.tabla_observaciones())
        elements.append(Spacer(1, 4 * cm))
        elements.append(self.tabla_firmas())        
        doc.build(elements, onFirstPage=self.pie_pagina, onLaterPages=self.pie_pagina)
        pdf = buffer.getvalue()
        buffer.close()
        return pdf

def get(self, request, *args, **kwargs): 
        response = HttpResponse(content_type='application/pdf')
        pdf_name = "clientes.pdf"  # llamado clientes
        # la linea 26 es por si deseas descargar el pdf a tu computadora
        # response['Content-Disposition'] = 'attachment; filename=%s' % pdf_name
        buff = BytesIO()
        doc = SimpleDocTemplate(buff,
                                pagesize=letter,
                                rightMargin=40,
                                leftMargin=40,
                                topMargin=60,
                                bottomMargin=18,
                                )
        clientes = []
        styles = getSampleStyleSheet()
        header = Paragraph("Listado de Clientes", styles['Heading1'])
        clientes.append(header)
        headings = ('Nombre', 'Email', 'Edad', 'Direccion')
        allclientes = [(p.codigo, p.descripcion, p.precio_mercado, p.grupo_suministros) for p in Producto.objects.all()]

        t = Table([headings] + allclientes)
        t.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (3, -1), 1, colors.dodgerblue),
                ('LINEBELOW', (0, 0), (-1, 0), 2, colors.darkblue),
                ('BACKGROUND', (0, 0), (-1, 0), colors.dodgerblue)
            ]
        ))
        clientes.append(t)
        doc.build(clientes)
        response.write(buff.getvalue())
        buff.close()
        return response

def __init__(self, records, Lang):
        self.records, self.Lang = records, Lang
        styles = getSampleStyleSheet()
        styles.add(ParagraphStyle(name='Justify', wordWrap=True))
        styles.add(
            ParagraphStyle(
                name='Pre',
                wordWrap=True,
                fontName=FONT_FAMILY,
                fontSize=FONT_SIZE['rightpane'],
                spaceAfter=FONT_SIZE['rightpane']))
        self.style = styles['Justify']
        self.style_pre = styles['Pre']

def wrap(self,aW,aH):
        value = self.get_value(aW,aH)
        P = self.klass
        if not P:
            from reportlab.platypus.paragraph import Paragraph as P
        style = self.style
        if not style:
            from reportlab.lib.styles import getSampleStyleSheet
            style=getSampleStyleSheet()['Code']
        if self.escape:
            from xml.sax.saxutils import escape
            value=escape(value)
        self.add_content(P(value,style=style))
        return 0,0

def defaultContext():
    result = {}
    from reportlab.lib.styles import getSampleStyleSheet
    styles = getSampleStyleSheet()
    for stylenamekey, stylenamevalue in DEFAULT_ALIASES.items():
        result[stylenamekey] = styles[stylenamevalue]
    return result

def test_08_table(self):
        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
        from reportlab.platypus import SimpleDocTemplate, Spacer, Paragraph, Table
        from reportlab.lib.units import inch
        from reportlab.lib.enums import TA_JUSTIFY
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont
        from reportlab.lib import fonts, colors

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        stylesheet = getSampleStyleSheet()

        elements = []
        doc = SimpleDocTemplate("demo.pdf")

        elements.append(Paragraph('<font name="chsFont">AUT OOM????</font>', stylesheet['Title']))
        elements.append(Spacer(1,12))

        stylesheet.add(ParagraphStyle(name="Justify", alignment=TA_JUSTIFY))
        stylesheet['Justify'].contName = 'chsFont'

        data  = []
        data.append(["???","???","???"])
        data.append(["120","6","50"])
        ts = [('INNERGRID',(0,0),(-1,-1),0.25, colors.black),("BOX",(0,0),(-1,-1),0.25,colors.black),('FONT',(0,0),(-1,-1), 'chsFont')]
        table = Table(data, 2.1*inch, 0.24*inch, ts)
        elements.append(table)

        doc.build(elements)

def test_22_lineCharts(self):
        from reportlab.lib.styles import getSampleStyleSheet
        from reportlab.lib import colors
        from reportlab.lib.units import inch
        from reportlab.platypus import SimpleDocTemplate, Spacer, Paragraph
        from reportlab.pdfbase import pdfmetrics
        from reportlab.graphics.shapes import Drawing
        from reportlab.pdfbase.ttfonts import TTFont
        from reportlab.graphics.charts.linecharts import HorizontalLineChart
        import random

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        stylesheet = getSampleStyleSheet()

        elements = []
        doc = SimpleDocTemplate("demo.pdf")

        elements.append(Paragraph('<font name="chsFont">JY.zenist.song - ??</font>', stylesheet['Title']))
        elements.append(Spacer(1,1*inch))

        d = Drawing(400,200)
        data = [
            [13,5,20,22,37,45,19,4],
            # [14,6,21,23,38,46,20,5]
        ]
        for i in range(500):
            data[0].append(random.randint(1,100))
            # data[1].append(random.randint(1,100))
        lc = HorizontalLineChart()
        lc.x = 50
        lc.y = 50
        lc.height = 180
        lc.width = 300
        lc.data = data
        lc.joinedLines = 1
        # lc.categoryAxis.categoryNames = data[0]
        d.add(lc)

        elements.append(d)

        doc.build(elements)

def test_24_PieCharts(self):
        from reportlab.lib.styles import getSampleStyleSheet
        from reportlab.lib import colors
        from reportlab.lib.units import inch
        from reportlab.platypus import SimpleDocTemplate, Spacer, Paragraph
        from reportlab.pdfbase import pdfmetrics
        from reportlab.graphics.shapes import Drawing
        from reportlab.pdfbase.ttfonts import TTFont
        from reportlab.graphics.charts.piecharts import Pie

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        stylesheet = getSampleStyleSheet()

        elements = []
        doc = SimpleDocTemplate("demo.pdf")

        elements.append(Paragraph('<font name="chsFont">JY.zenist.song - ??</font>', stylesheet['Title']))
        elements.append(Spacer(1,1*inch))

        d = Drawing(400,200)
        data = [13,5,20,22,37,45]
        pc = Pie()
        pc.x = 65
        pc.y = 15
        pc.width = 150
        pc.height = 150
        pc.data = data
        pc.labels = ['a','b','c','d','e','f']
        d.add(pc)

        elements.append(d)

        doc.build(elements)

def _add_company_information(self, canvas):
        start_posn = self.start_posn
        canvas.setFillColor(colors.blue)
        canvas.setFont('Helvetica', 10)
        canvas.drawString(0.5*inch, start_posn,
                          'Section C: Company Information')
        canvas.setFillColor(colors.black)
        canvas.rect(0.5*inch, start_posn-1.2*inch,
                    PAGE_WIDTH-inch, 1.1*inch)
        canvas.line(2.5*inch, start_posn-1.2*inch,
                    2.5*inch, start_posn-0.1*inch)
        canvas.drawString(0.7*inch, start_posn-0.3*inch, 'Company Name:')
        canvas.drawString(2.7*inch, start_posn-0.3*inch,
                          self.details['name'].strip())
        canvas.line(0.5*inch, start_posn-0.4*inch,
                    PAGE_WIDTH-0.5*inch, start_posn-0.4*inch)
        canvas.drawString(0.7*inch, start_posn-0.6*inch, 'Mailing Address:')
        address = ''
        if self.details['address1'].strip() != '':
            address += self.details['address1'].strip() + '<br/>'
        if self.details['address2'].strip() != '':
            address += self.details['address2'].strip() + '<br/>'
        if self.details['city'].strip() != '' or \
                self.details['state_prov'].strip() != '':
            if self.details['city'].strip() != '':
                address += self.details['city'].strip() + ', '
            address += self.details['state_prov'].strip() + '<br/>'
        if self.details['postal_code'].strip() != '':
            address += self.details['postal_code'].strip() + '  '
        address += self.details['country'].strip()
        style_sheet = getSampleStyleSheet()
        style = style_sheet['BodyText']
        para = Paragraph(address, style)
        h = para.wrap(4.7 * inch, 0.9* inch)[1]
        para.drawOn(canvas, 2.7 * inch, start_posn-h-0.45*inch)
        self.start_posn = start_posn-1.45*inch

def _add_assistant_details(self, canvas):
        start_posn = self.start_posn
        canvas.setFillColor(colors.blue)
        canvas.setFont('Helvetica', 10)
        canvas.drawString(0.5*inch, start_posn, 'Assistant Details')
        canvas.setFillColor(colors.black)
        canvas.rect(0.5*inch, start_posn-0.9*inch,
                    PAGE_WIDTH-inch, 0.8*inch)
        canvas.line(2.5*inch, start_posn-0.9*inch,
                    2.5*inch, start_posn-0.1*inch)
        canvas.drawString(0.7*inch, start_posn-0.3*inch, 'Assistant:')
        assistant_deets = ''
        new_line = False
        if self.details['assistant_salutation'].strip() != '':
            new_line = True
            assistant_deets += self.details['assistant_salutation'].strip() + ' '
        if self.details['assistant_first_name'].strip() != '':
            new_line = True
            assistant_deets += self.details['assistant_first_name'].strip() + ' '
        if self.details['assistant_last_name'].strip() != '':
            new_line = True
            assistant_deets += self.details['assistant_last_name'].strip() + ' '
        if new_line:
            assistant_deets += '<br/>'
        if self.details['assistant_title'].strip() != '':
            assistant_deets += self.details['assistant_title'].strip()
            assistant_deets += '<br/>'
        if self.details['assistant_email'].strip() != '':
            assistant_deets += 'Email: '
            assistant_deets += self.details['assistant_email'] + '<br/>'
        if self.details['assistant_phone'].strip() != '':
            assistant_deets += 'Phone: ' + self.details['assistant_phone']
        style_sheet = getSampleStyleSheet()
        style = style_sheet['BodyText']
        para = Paragraph(assistant_deets, style)
        h = para.wrap(4.7*inch, 0.8*inch)[1]
        para.drawOn(canvas, 2.7*inch, start_posn-h-0.15*inch)
        self.start_posn = start_posn-1.1*inch

def generate_report(self):
        report_name = 'Conference Registration Form'
        buffr = BytesIO()
        styles = getSampleStyleSheet()
        report = canvas.Canvas(buffr, pagesize=letter)
        self._draw_stuff(report)
        report.showPage()
        report.save()
        pdf = buffr.getvalue()
        buffr.close()
        return pdf

def _header(canvas, doc, event, report_title, confidential=True, offset=0):
        canvas.saveState()
        styles = getSampleStyleSheet()
        canvas.drawImage(LOGO_PATH, 0.45 * inch, PAGE_HEIGHT - inch * 0.75,
                         height=0.5*inch, width=1.875*inch)
        canvas.setFont('Helvetica-Bold', 18)
        y_coord = PAGE_HEIGHT - inch * 0.45 - offset * inch
        canvas.drawString(2.75 * inch, y_coord, report_title)
        canvas.setFont('Helvetica', 16)
        event_title = str(event.number) + ' - ' + event.title
        y_coord -= 18
        canvas.drawString(2.75 * inch, y_coord, event_title)
        event_date = event.date_begins.strftime('%-d %B, %Y')
        y_coord -= 14
        canvas.setFont('Helvetica', 12)
        canvas.drawString(2.75 * inch, y_coord, event_date)
        event_venue = ''
        if event.hotel:
            event_venue += event.hotel.name + ': '
        event_venue += event.city + ', ' + event.state_prov
        y_coord -= 14
        canvas.drawString(2.75 * inch, y_coord, event_venue)
        if confidential:
            canvas.setFont('Helvetica', 16)
            y_coord -= 30
            canvas.drawString(2.75 * inch, y_coord, 'Do Not Copy or Distribute')
            canvas.restoreState()

def __init__(self,mypagesize=(21*cm,25*cm),passwd='',path="/tmp/report.pdf",auto_open=True):
        # Encrypts if password is passed as passwd='mypass'

        self.path=path
        self.auto_open=auto_open
        self.name="TEST"
        self.year="TEST"
        self.class_="TEST"
        self.roll_no="TEST"
        self.admission_no="TEST"
        self.school="test"
        styleSheet = getSampleStyleSheet()
        self.mypagesize=mypagesize
        self.elements = []


        enc=pdfencrypt.StandardEncryption(passwd,canPrint=0)


        self.doc = SimpleDocTemplate(self.path, pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur",encrypt=enc)

        self.DB=db_operations()

        self.Set_Content()




        # Starts measurement

        self.cW1=(mypagesize[0]/cm)/4.8
        self.cW=(mypagesize[0]/cm)/11.6

        self.rH1=(mypagesize[1]/cm)/14
        self.rH2=(mypagesize[1]/cm)/19
        self.rH=(mypagesize[1]/cm)/25



        #end of measurement

def __init__(self,mypagesize=(21*cm,25*cm)):


        self.path="/tmp/report.pdf"
        self.name="TEST"
        self.year="TEST"
        self.class_="TEST"
        self.roll_no="TEST"
        self.admission_no="TEST"
        self.school="test"
        styleSheet = getSampleStyleSheet()
        self.mypagesize=mypagesize
        self.elements = []
        self.doc = SimpleDocTemplate(self.path, pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")

        self.DB=db_operations()

        self.Set_Content()





        # Starts measurement

        self.cW1=(mypagesize[0]/cm)/4.8
        self.cW=(mypagesize[0]/cm)/11.6

        self.rH1=(mypagesize[1]/cm)/14
        self.rH2=(mypagesize[1]/cm)/19
        self.rH=(mypagesize[1]/cm)/25



        #end of measurement

def __init__(self,mypagesize=(21*cm,25*cm)):

        self.name="TEST"
        self.year="TEST"
        self.class_="TEST"
        self.roll_no="TEST"
        self.admission_no="TEST"
        self.school="test"
        styleSheet = getSampleStyleSheet()
        self.mypagesize=mypagesize
        self.elements = []
        self.doc = SimpleDocTemplate("/tmp/report.pdf", pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")
        self.DB=db_operations()


        self.Set_Content()





        # Starts measurement

        self.cW1=(mypagesize[0]/cm)/5.25
        self.cW=(mypagesize[0]/cm)/11.6

        self.rH1=(mypagesize[1]/cm)/14
        self.rH2=(mypagesize[1]/cm)/19
        self.rH=(mypagesize[1]/cm)/25



        #end of measurement

def Format_Adm_No(self,ad_no):

        style = getSampleStyleSheet()
        normal = style["Normal"]

        style1=ParagraphStyle(name='normal',fontSize = 8,alignment = TA_CENTER)


        ad_text= Paragraph('<font size=6>'+str(ad_no)+'</font>',style1)
        return verticaltext(str(ad_no))

def __init__(self,mypagesize=(21*cm,25*cm)):

        self.name="TEST"
        self.year="TEST"
        self.class_="TEST"
        self.roll_no="TEST"
        self.admission_no="TEST"
        self.school="test"
        styleSheet = getSampleStyleSheet()
        self.mypagesize=mypagesize
        self.elements = []
        self.doc = SimpleDocTemplate("/tmp/report.pdf", pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")
        self.DB=db_operations()


        self.Set_Content()





        # Starts measurement

        self.cW1=(mypagesize[0]/cm)/5.25
        self.cW=(mypagesize[0]/cm)/11.6

        self.rH1=(mypagesize[1]/cm)/14
        self.rH2=(mypagesize[1]/cm)/19
        self.rH=(mypagesize[1]/cm)/25



        #end of measurement

def __init__(self,mypagesize=(18*cm,22*cm)):

        styleSheet = getSampleStyleSheet()

        self.doc = SimpleDocTemplate("/tmp/Consolidated_report.pdf", pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")

def __init__(self,mypagesize=A4):


        styleSheet = getSampleStyleSheet()

        self.doc = SimpleDocTemplate("/tmp/Promotion_List.pdf", pagesize=mypagesize,title="PromotionList Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")

def __init__(self,mypagesize=(18*cm,22*cm)):

        self.path="/tmp/report_t2_only.pdf"

        self.name="TEST"
        self.year="TEST"
        self.class_="TEST"
        self.roll_no="TEST"
        self.admission_no="TEST"
        self.school="test"
        styleSheet = getSampleStyleSheet()
        self.mypagesize=mypagesize
        self.elements = []
        self.doc = SimpleDocTemplate(self.path, pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")
        self.Set_Content()






        # Starts measurement

        self.cW1=(mypagesize[0]/cm)/5.25
        self.cW=(mypagesize[0]/cm)/11.6

        self.rH1=(mypagesize[1]/cm)/14
        self.rH2=(mypagesize[1]/cm)/19
        self.rH=(mypagesize[1]/cm)/26.8



        #end of measurement

def __init__(self,mypagesize=(18*cm,22*cm)):

        self.name="TEST"
        self.year="TEST"
        self.class_="TEST"
        self.roll_no="TEST"
        self.admission_no="TEST"
        self.school="test"
        styleSheet = getSampleStyleSheet()
        self.mypagesize=mypagesize
        self.elements = []
        self.doc = SimpleDocTemplate("/tmp/report.pdf", pagesize=mypagesize,title="Performance Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")
        self.Set_Content()





        # Starts measurement

        self.cW1=(mypagesize[0]/cm)/5.25
        self.cW=(mypagesize[0]/cm)/11.6

        self.rH1=(mypagesize[1]/cm)/14
        self.rH2=(mypagesize[1]/cm)/19
        self.rH=(mypagesize[1]/cm)/27



        #end of measurement

def get_template(self, template_file, url):
        formatted_time = time.ctime()
        company = self.application.config['mailer.company_name']
        sender = self.application.config['mailer.source_email_alias']

        story = []
        click_me = saxutils.escape(self.config['link_text'])
        link = '<font color=blue><link href="' + url + '">' + click_me + '</link></font>'

        logo_path = self.config['logo']
        if logo_path:
            img = platypus.Image(logo_path, 2 * inch, inch)
            story.append(img)

        style_sheet = styles.getSampleStyleSheet()
        style_sheet.add(styles.ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))
        ptext = '<font size=10>' + formatted_time + '</font>'
        story.append(platypus.Spacer(1, 12))
        story.append(platypus.Paragraph(ptext, style_sheet['Normal']))
        story.append(platypus.Spacer(1, 12))
        with open(template_file, 'r') as file_h:
            for line in file_h:
                story.append(platypus.Paragraph(line, style_sheet['Normal']))
        story.append(platypus.Spacer(1, 8))
        story.append(platypus.Paragraph(link, style_sheet['Justify']))
        story.append(platypus.Spacer(1, 12))
        ptext = '<font size=10>Sincerely,</font>'
        story.append(platypus.Paragraph(ptext, style_sheet['Normal']))
        story.append(platypus.Spacer(1, 12))
        ptext = '<font size=10>' + sender + '</font>'
        story.append(platypus.Paragraph(ptext, style_sheet['Normal']))
        story.append(platypus.Spacer(1, 12))
        ptext = '<font size=10>' + company + '</font>'
        story.append(platypus.Paragraph(ptext, style_sheet['Normal']))
        return story

def test():
        from reportlab.platypus.paragraph import Paragraph as platypus_Paragraph
        from wordaxe.DCWHyphenator import DCWHyphenator
        wordaxe.hyphRegistry["DE"] = DCWHyphenator("DE")
        stylesheet = getSampleStyleSheet()
        for indx, klass in enumerate([Paragraph, platypus_Paragraph]):
            normal = stylesheet['BodyText']
            normal.fontName = "Helvetica"
            normal.fontSize = 12
            normal.leading = 16
            if klass is Paragraph:
                normal.language = 'DE'
                normal.hyphenation = True
            normal.alignment = TA_JUSTIFY
            normal.firstLineIndent = 15*pt
            normal.leftIndent = 20*pt

            text = """Bedauerlicherweise ist ein <u>Donau</u>dampfschiffkapitän auch nur ein <a href="http://www.reportlab.org">Dampfschiff</a>kapitän."""
            # strange behaviour when next line uncommented
            text = " ".join(['<font color="red">%s</font>' % w for w in text.split()])

            text="""Das jeweils aktuelle Release der Software kann aber von der entsprechenden
    SourceForge <a color="blue" backColor="yellow" href="http://sourceforge.net/project/showfiles.php?group_id=105867">Download-Seite</a>
    heruntergeladen werden. Die allerneueste in Entwicklung befindliche Version
    wird im Sourceforge Subversion-Repository verwaltet.
    """.replace("\n"," ")

            story = []
            #story.append(Paragraph(text, style=normal))
            story.append(klass(u"Eine <font backcolor='yellow'>Aufzählung</font>, bei der der <font backcolor='green'>Text</font> hoffentlich etwas länger als eine Zeile ist.", style=normal, bulletText="\xe2\x80\xa2"))
            #story.append(klass(u"Silbentrennungsverfahren helfen dabei, extrem lange Donaudampfschiffe in handliche Schiffchen aufzuteilen. " * 10, style=normal))
            #story.append(klass(u"Silbentrennungsverfahren helfen dabei, extrem lange Donaudampfschiffe in handliche Schiffchen aufzuteilen.", style=normal, bulletText="\xe2\x80\xa2"))
            doc = TwoColumnDocTemplate(("test_NewParagraph_%d.pdf" %indx), pagesize=PAGESIZE)
            doc.build(story)

def pdfgen(relevant_extracts, sector, keywords):
    today = datetime.datetime.today()
    today.replace(second=0, microsecond=0)

    outputdir = join('..', 'output')
    if not exists(outputdir):
        mkdir(outputdir)
    chdir(outputdir)

    doc = SimpleDocTemplate('%s_%s.pdf' % (sector, today.strftime("%Y-%m-%d_%H.%M")))
    template = PageTemplate('normal', [Frame(2.5*cm, 2.5*cm, 15*cm, 25*cm, id='F1')])
    doc.addPageTemplates(template)

    Story = [Spacer(1,0.5*inch)]
    styleSheet=getSampleStyleSheet()
    style = styleSheet['BodyText']
    title = Paragraph('<para align=center><b>%s Industry Earnings Call Transcripts Report</b></para>' % sector,
                      style)
    Story.append(title)
    subtitle = Paragraph('<para align=center>Keywords: %s</para>' % ", ".join(keywords),
                         style)
    Story.append(subtitle)
    Story.append(Spacer(1,0.5*inch))


    for extract in relevant_extracts:
        Story.append(Paragraph("From %s" % extract["title"], h1))
        Story.append(Paragraph("Published on %s at %s" % (extract["date"], extract["time"]), h1))
        text = Preformatted(extract["bodyContent"].encode('utf8'), style, maxLineLength=100)
        Story.append(text)
        Story.append(Spacer(1,0.2*inch))

    doc.build(Story)

def main():
    context = {
        'instructor': INSTRUCTOR,
        'course': COURSE,
        'student': STUDENT,
        'hours': HOURS,
    }
    styles = getSampleStyleSheet()
    styles.add(
        ParagraphStyle(
            name='Justify', alignment=TA_JUSTIFY, fontSize=16, leading=22
        )
    )
    elements = []
    certificate_txt = render(TEXT_PATH, context)
    paragraphs = certificate_txt.split(os.linesep)
    elements.append(Spacer(1, 50))
    for p in paragraphs:
        elements.append(Paragraph(p, styles['Justify']))
        elements.append(Spacer(1, 16))

    certificate = tempfile.NamedTemporaryFile()
    doc = SimpleDocTemplate(certificate, topMargin=3 * cm, bottomMargin=0)
    doc.pagesize = landscape(A4)
    doc.build(elements)

    output = PdfFileWriter()
    template_file = open('template.pdf', 'rb')
    input1 = PdfFileReader(template_file)
    page1 = input1.getPage(0)
    content = PdfFileReader(certificate)
    page1.mergePage(content.getPage(0))
    output.addPage(page1)
    save_file = open(SAVE_AS, 'wb')
    output.write(save_file)
    print('Certificado gerado com sucesso em %s' % SAVE_AS)

def main():
        from reportlab.graphics.barcode.code128 import Code128
        from reportlab.platypus import Spacer, SimpleDocTemplate
        from reportlab.lib.units import inch, cm
        from reportlab.lib.styles import getSampleStyleSheet
        from reportlab.platypus.paragraph import Paragraph
        from reportlab.platypus.flowables import KeepTogether
        import os
        styles = getSampleStyleSheet()
        styleN = styles['Normal']
        styleH = styles['Heading1']
        story = []
        storyAdd = story.append
        for s in (
            'BBBB123456BBB',
            'BBBB12345BBB',
            'BBBB1234BBB',
            'BBBB123BBB',
            'BBBB12BBB',
            'BBBB1BBB',
            'BBBB123456aa',
            'BBBB1234aa',
            'BBBB123aa',
            'BBBB12aa',
            'BBBB1aa',
            'BBBB123456',
            'BBBB12345',
            'BBBB1234',
            'BBBB123',
            'BBBB12',
            'BBBB1',
            '\xf11234B',
            'Ba\xf11234B',
            'Ba12',
            'Ba123B',
            'Ba1234B',
            'BBBB1234567',
            'BBBB1234567aa',
            ):
            storyAdd(KeepTogether([Paragraph('Code 128 %r' % s, styleN),Code128(s)]))
            storyAdd(Spacer(inch,inch))
        SimpleDocTemplate('code128-out.pdf').build(story)

def generateReport(self, results):

        #Pintamos la tabla con sus contenidos
        doc = IOCDocTemplate(DEFAULT_REPORT_NAME, pagesize=A4, results=results)

        doc.addPageTemplates(
            [
                PageTemplate(id='summary',
                             frames=[Frame(doc.leftMargin, doc.bottomMargin, doc.width, 425)],
                             onPage=doc.summary, onPageEnd=doc.footer),

                PageTemplate(id='content',
                             frames=[Frame(doc.leftMargin, doc.bottomMargin, doc.width, doc.height)],
                             onPage=doc.header, onPageEnd=doc.footer),

            ]
        )

        estiloHoja = getSampleStyleSheet()

        # Estilos de la tabla para cabeceras y datos
        thead = estiloHoja["BodyText"]
        thead.fontSize = 7

        table_data = [ ['INDICADOR DE COMPROMISO', 'FORMATO', 'TIPO DE EVIDENCIA', 'VALOR', 'PRUEBA'] ]
        for incident in results.incidents:
            for evidence in incident.evidences:
                table_data.append([Paragraph(self.__prettyPrint__(incident.indicator.id),thead),
                                   Paragraph(self.__prettyPrint__(incident.indicator.format.value),thead),
                                   Paragraph(self.__prettyPrint__(evidence.context),thead),
                                   Paragraph(self.__prettyPrint__(evidence.value),thead),
                                   Paragraph(self.__prettyPrint__(evidence.proof),thead)])

        table_report=[]
        table_report.append(NextPageTemplate('summary'))
        table_report.append(NextPageTemplate('content'))
        table_report.append(Table(table_data, colWidths=[120, 50, 75, 120, 180],
                              style=TableStyle([
                                  ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
                                  ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
                                  ('SIZE', (0, 0), (-1, -1), 7),
                                  ('GRID', (0, 0), (-1, -1), 0.5, colors.black),
                                  ('BOX', (0, 0), (-1, -1), 1, colors.black),
                                  ('BACKGROUND', (0, 0), (-1, 0), colors.lavender),
                              ])
                              )
                            )

        doc.build(table_report)

def call_report(request):
    event_assignment = get_object_or_404(EventAssignment,
                                         pk=request.session['assignment_id'])
    event = event_assignment.event
    user = request.user
    contact_history = Contact.objects.filter(
        event=event, author=user
    ).order_by('-date_of_contact')
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'inline; filename="call_report.pdf"'
    buffr = BytesIO()

    styles = getSampleStyleSheet()
    cell_style = styles['BodyText']
    cell_style.alignment = TA_LEFT

    report_details = []
    title = Paragraph('Call Note Report', styles['title'])
    report_details.append(title)
    conf_details_text = event.number + ': ' + event.title + ' (' \
        + user.username+ ')'
    report_details.append(Paragraph(conf_details_text, styles['h2']))
    report = SimpleDocTemplate(buffr, pagesize=letter,
                               leftMargin=inch/2, rightMargin = inch/2)
    data = []
    for contact in contact_history:
        person = contact.person.name
        if contact.person.title:
            person = person + '<br/>' + contact.person.title
        if contact.person.company:
            person = person + '<br/>' + contact.person.company
        date = Paragraph(str(contact.date_of_contact.date()), cell_style)
        person = Paragraph(person, cell_style)
        notes = Paragraph(contact.notes[:3500], cell_style)
        data.append([date, person, notes])
        table = Table(data, [inch, 3 * inch, 4.5 * inch])
        table.setStyle(TableStyle([('VALIGN', (0,0), (-1, -1), 'TOP')]))
        report_details.append(table)
        data = []
    # if len(data) > 0:
    #     call_detail_table = Table(data, [inch, 2 * inch, 4.5 * inch])
    #     call_detail_table.setStyle(TableStyle([('VALIGN', (0,0),
    #                                             (-1, -1), 'TOP')]))
    #     report_details.append(call_detail_table)


    report.build(report_details)

    pdf = buffr.getvalue()
    buffr.close()
    response.write(pdf)
    return response