def chordbook(filename, objects, title, subtitle, url, settings):
"""Generate the PDF version of the chordbook
Parameters:
filename (str): The complete path to the destination filename
objects (list): An ordered list of song objects that will be inserted into
this chordbook
title (str): The title that will be shown in italics. This is normally
something like "Collection"
subtitle (str): The subtitle. This is normally the name of the collection
url (str): The URL to this PDF, so people can download it
settings (dict): Pelican settings
Returns:
SongBookTemplate: A ReportLab BaseDocTemplate with all the songs encoded
inside.
"""
from reportlab.platypus.tableofcontents import TableOfContents
from reportlab.platypus import NextPageTemplate, PageBreak
with pelican_locale(settings):
doc = SongBookTemplate(filename)
siteurl = settings.get('SITEURL', 'http://example.com')
doc.author = settings.get('AUTHOR', 'Unknown Editor')
doc.title = 'Cifras de %s' % siteurl
doc.subject = 'Compilação de Letras e Cifras'
dateformat = settings.get('DEFAULT_DATE_FORMAT', '%d/%m/%Y')
story = cover_page(title, subtitle, url, siteurl, dateformat)
#appends and prepares table of contents
story.append(NextPageTemplate('TOC'))
story.append(PageBreak())
story.append(TableOfContents())
story[-1].levelStyles[0] = style['toc-entry']
story[-1].dotsMinLevel = 0 #connecting dots
#adds the lyrics
for o in objects:
po = PdfSong(o, dateformat)
po.add_page_template(doc)
story.append(NextPageTemplate(po.template_id()))
story.append(PageBreak())
story += po.story(doc)
#multi-pass builds are necessary to handle TOCs correctly
doc.multiBuild(story)
return doc
def writesection(story, section, contents):
for key, content in contents.items():
if key == 'scans':
story = writescanlist(story, content)
elif key == 'description':
print('***TitlePage***')
story.append(NextPageTemplate('TitlePage'))
story.append(PageBreak())
story = build_title_page(
doc=self.doc,
Story=self.Story,
title=section,
subtitle=content,
)
elif key == 'content':
story = writesection(story, key, content)
elif key == 'comparison':
print("!!!Comparison!!!")
num_columns = len(content['scans'])
pagetemplate = 'Comparison_' + str(
num_columns) #only handles 2-4 columns
story.append(NextPageTemplate(pagetemplate))
story.append(PageBreak())
story = writecomparison(story=self.Story,
comparison=content)
else:
pass
return story
def alternate_orientations():
doc = SimpleDocTemplate("orientations.pdf",
pagesize=letter,
rightMargin=72,
leftMargin=72,
topMargin=72,
bottomMargin=18)
styles = getSampleStyleSheet()
normal = styles["Normal"]
margin = 0.5 * inch
frame = Frame(margin, margin, doc.width, doc.height, id='frame')
portrait_template = PageTemplate(id='portrait',
frames=[frame],
pagesize=letter)
landscape_template = PageTemplate(id='landscape',
frames=[frame],
pagesize=landscape(letter))
doc.addPageTemplates([portrait_template, landscape_template])
story = []
story.append(Paragraph('This is a page in portrait orientation', normal))
# Change to landscape orientation
story.append(NextPageTemplate('landscape'))
story.append(PageBreak())
story.append(Spacer(inch, 2 * inch))
story.append(Paragraph('This is a page in landscape orientation', normal))
# Change back to portrait
story.append(NextPageTemplate('portrait'))
story.append(PageBreak())
story.append(Paragraph("Now we're back in portrait mode again", normal))
doc.build(story)
def build_page(self, template_id, flowable_map):
"""Build a pdf page by looking up the specified template and then mapping the flowable_map items to the
appropriate named Frame
"""
pt = self.get_page_template(template_id)
# If this is the first page then ensure the page template is ordered first and no breaks or changes
# are requested otherwise blank page shows up
if self.active_template_id is None:
self.make_template_first(template_id)
self.story.append(NextPageTemplate(template_id))
self.inc_cover and self.story.append(PageBreak())
self.active_template_id = template_id
elif self.active_template_id == template_id:
# TODO - understand why this is necessary to not get a blank page between pages
self.story.append(PageBreak())
else:
self.story.append(NextPageTemplate(template_id))
self.story.append(PageBreak())
self.active_template_id = template_id
for idx, frame in enumerate(pt.frames):
if frame.id not in flowable_map:
# Add a note to the template to show that nothing was defined for this area
self.story.append(Paragraph('NOT DEFINED: %s' % frame.id, getSampleStyleSheet()['Normal']))
else:
flowables = flowable_map[frame.id]
if not isinstance(flowables, Flowable) and hasattr(flowables, '__iter__'):
[self.story.append(f) for f in flowables]
else:
self.story.append(flowables)
if idx < (len(pt.frames) - 1):
self.story.append(FrameBreak())
return self
def get_flowables(layout, resource, items, labels=None, cards_per_page=1):
"""
Get the Flowable-instances for the data items
@param layout: the S3PDFCardLayout subclass implementing the
card layout
@param resource: the resource
@param items: the data items
@param labels: the field labels
@param cards_per_page: the number of cards per page
"""
if not len(items):
# Need at least one flowable even to produce an empty doc
return [PageBreak()]
# Determine the number of pages
number_of_pages = int(len(items) / cards_per_page) + 1
multiple = cards_per_page > 1
# Look up common data
common = layout.lookup(resource, items)
# Generate the pages
flowables = []
append = flowables.append
for i in range(number_of_pages):
# Get the items for the current page
batch = items[i * cards_per_page:(i+1) * cards_per_page]
if not batch:
continue
# Add the flowables for the card fronts to the page
append(NextPageTemplate("Front"))
if i > 0:
append(PageBreak())
for item in batch:
append(layout(resource,
item,
labels = labels,
common = common,
multiple = multiple,
))
if layout.doublesided:
# Add the flowables for the backsides on a new page
append(NextPageTemplate("Back"))
append(PageBreak())
for item in batch:
append(layout(resource,
item,
labels = labels,
common = common,
multiple = multiple,
backside = True,
))
return flowables
def main(sFilename,invoice):
pdf_file = sFilename
t = get_table(invoice)
Elements = []
def pgHdr(c, doc):
width,height = A4
#c.saveState()
#c.translate(.3 * inch, 0 * inch)
# STUFF RELATED TO 2 INCH STTIC HEADER FOR FIRST PAGE
#c.restoreState()
def othPg(c,doc):
width,height = A4
styles = getSampleStyleSheet()
Elements.append(Spacer(1,2*inch))
style = styles["Normal"]
for i in range(3):
bogustext = ("This is Paragraph number %s. " % i) * 2
p = Paragraph(bogustext, style)
Elements.append(p)
Elements.append(Spacer(1,0.2*inch))
doc = BaseDocTemplate(pdf_file,
pagesize=A4,
leftMargin=.3*inch,
rightMargin= .1 * inch,
topMargin= .1 * inch,
bottomMargin=.3 * inch,
showBoundary=0)
#normal frame as for SimpleFlowDocument
#frameT = Frame(doc.leftMargin + 2*inch, doc.bottomMargin, doc.width - 2.01*inch, doc.height - 4.1*inch, id='normal', showBoundary=0)
#frameB = Frame(doc.leftMargin+2, doc.bottomMargin, 7.5*inch, 10*inch, id='small', showBoundary=0)
frameT = Frame(doc.leftMargin , doc.bottomMargin + 1*inch, doc.width, doc.height, id='normal', showBoundary=0)
frameB = Frame(doc.leftMargin , doc.bottomMargin + 1*inch, doc.width, doc.height, id='normal', showBoundary=0)
doc.addPageTemplates([PageTemplate(id='First',frames=frameT,onPage=pgHdr),
PageTemplate(id='Later',frames=frameB,onPage=othPg)
])
Elements.append(NextPageTemplate('First'))
Elements.append(NextPageTemplate('Later'))
Elements.append(t)
#doc.addPageTemplates([PageTemplate(id='First',onPage=pgHdr)])
#Elements.append(BaseDocTemplate)
#Elements.append(t)
doc.build(Elements)
def __init__(self, project_panel, output_filename, title="Project Report"):
self.overall_title = title
self.project = project_panel.project
PDFExporterBase.__init__(self, self.project.filename.value,
output_filename, title)
# TODO: Contents page
self.elements.append(PageBreak())
self.elements.append(
self.make_report_header("Project Information", self.filename))
self.elements.append(Spacer(1, cm))
self.make_project_info_inner()
self.elements.append(
self.make_report_header("Method Report",
self.project.method.value))
self.elements.append(Spacer(1, cm))
self.method = self.project.method_data
self.make_method_inner()
self.elements.append(PageBreak())
self.elements.append(
self.make_report_header("Ammunition Details Report",
self.project.ammo_details.value))
self.elements.append(Spacer(1, cm))
self.ammo_details = self.project.ammo_data
self.make_ammo_details_inner()
self.elements.append(PageBreak())
# for experiment in self.project.experiment_objects:
# TODO: Experiment Report for each experiment
if self.project.alignment_performed:
self.elements.append(
self.make_report_header("Alignment Report", self.filename))
self.elements.append(Spacer(1, cm))
self.alignment_panel = project_panel.alignment_page
self.make_alignment_inner()
self.elements.append(PageBreak())
if self.project.consolidate_performed:
# TODO: Wrong width
self.elements.append(
self.make_report_header("Consolidated Peaks", self.filename))
self.consolidate_panel = project_panel.compounds_tab.consolidate_panel
self.elements.append(NextPageTemplate("landscape"))
self.elements.append(PageBreak())
self.elements.append(NextPageTemplate("landscape"))
self.make_consolidate_inner()
self.build()
def init_letter(
self,
page_fn=dummy_stationery,
page_fn_later=None,
address_y=None,
address_x=None,
):
frame_kwargs = {
"showBoundary": self.show_boundaries,
"leftPadding": 0,
"rightPadding": 0,
"topPadding": 0,
"bottomPadding": 0,
}
address_frame = Frame(address_x or 2.6 * cm, address_y or 20.2 * cm,
16.4 * cm, 4 * cm, **frame_kwargs)
rest_frame = Frame(2.6 * cm, 2 * cm, 16.4 * cm, 18.2 * cm,
**frame_kwargs)
full_frame = Frame(2.6 * cm, 2 * cm, 16.4 * cm, 25 * cm,
**frame_kwargs)
self.doc.addPageTemplates([
PageTemplate(id="First",
frames=[address_frame, rest_frame],
onPage=page_fn),
PageTemplate(id="Later",
frames=[full_frame],
onPage=page_fn_later or page_fn),
])
self.story.append(NextPageTemplate("Later"))
self.generate_style()
def init_letter(self,
page_fn=dummy_stationery,
page_fn_later=None,
address_y=None):
frame_kwargs = {
'showBoundary': self.show_boundaries,
'leftPadding': 0,
'rightPadding': 0,
'topPadding': 0,
'bottomPadding': 0
}
address_frame = Frame(2.6 * cm, address_y or 20.2 * cm, 16.4 * cm,
4 * cm, **frame_kwargs)
rest_frame = Frame(2.6 * cm, 2 * cm, 16.4 * cm, 18.2 * cm,
**frame_kwargs)
full_frame = Frame(2.6 * cm, 2 * cm, 16.4 * cm, 25 * cm,
**frame_kwargs)
self.doc.addPageTemplates([
PageTemplate(id='First',
frames=[address_frame, rest_frame],
onPage=page_fn),
PageTemplate(id='Later',
frames=[full_frame],
onPage=page_fn_later or page_fn),
])
self.story.append(NextPageTemplate('Later'))
self.generate_style(font_size=9)
def create_pdf(togen, template_page, pos, dat):
"Create the pdf, stream api"
document = BaseDocTemplate(togen)
page = MyPage(template_page, name='background')
document.addPageTemplates([page])
elements = [NextPageTemplate('background')]
# may add flowables to element here
# add absolute content
for posname in dat:
if posname.startswith("_"): # ignore extra info
continue
if posname not in pos:
raise Exception("%s does not have a position" % posname)
tup = pos[posname]
x, y = tup[0], tup[1]
width = tup[2] if len(tup) > 2 else PAGE_WIDTH
style = tup[3] if len(tup) > 3 else DEFAULT_STYLE
data = dat[posname]
if type(data) in (str, unicode):
page.addAbsParagraph(data, x, y, width, style)
else:
page.addAbsPrimitive(data, x, y, width) # don't need no style
# create page
document.multiBuild(elements)
def generate(self, report_elements=[]):
elements = []
h1 = ParagraphStyle(name='Heading1', fontSize=14, leading=16)
h2 = ParagraphStyle(name='Heading2',
fontSize=12,
leading=14,
leftIndent=5)
# First page
elements.append(Paragraph("", self.styles['Normal']))
elements.append(NextPageTemplate('OneCol'))
elements.append(PageBreak())
self.add_title(elements, "Table of contents")
toc = TableOfContents()
# For conciseness we use the same styles for headings and TOC entries
toc.levelStyles = [h1, h2]
elements.append(toc)
elements.append(PageBreak())
if len(report_elements) > 0:
elements.extend(report_elements)
self.add_title(elements, "Organisation")
elements.append(self.last_page())
elements.append(PageBreak())
self.multiBuild(elements)
def run(in_data, out_file_path, frame_border=0):
story = []
# FirstPage Template is already active and will draw its stuff before the PageBreak
story.append(NextPageTemplate('ContentPage'))
story.append(PageBreak())
files = in_data['image_files']
for f in files:
story.append(
Paragraph(
f"Chunk {f['chunk_idx']} / {in_data['meta']['chunks_total']}"))
story.append(Spacer(width=0, height=5 * mm))
img_dim = (page_width / 2) - 50 * mm
story.append(
Image(f['chunk_img_path'],
width=img_dim,
height=img_dim,
hAlign='LEFT'))
story.append(FrameBreak())
doc = qr_code_doc_template(in_metadata=in_data['meta'],
out_file_path=out_file_path,
frame_border=frame_border,
pagesize=A4)
doc.multiBuild(story)
def generate_templates(self):
frame_kwargs = {
# 'showBoundary': 1,
'leftPadding': 0,
'rightPadding': 0,
'topPadding': 0,
'bottomPadding': 0
}
address_frame_kwargs = frame_kwargs.copy()
address_frame_kwargs.update(bottomPadding=2 * mm)
sender_frame = NoSplitFrame(
self.settings.page_size.from_left(),
self.settings.page_size.from_bottom(
12 * mm), # 25mm height + (-13mm) offset
self.settings.page_size.scaled_width(100 * mm),
25 * mm,
**frame_kwargs)
billing_frame = NoSplitFrame(
self.settings.page_size.from_left(),
self.settings.page_size.from_bottom(
60 * mm), # 40mm height + 8mm offset + 12mm previous
self.settings.page_size.scaled_width(75 * mm),
40 * mm,
**address_frame_kwargs)
shipping_frame = NoSplitFrame(
self.settings.page_size.from_left(
self.settings.page_size.scaled_width(
95 * mm)), # 75mm width + 20mm offset
self.settings.page_size.from_bottom(
60 * mm), # 40mm height + 8mm offset + 12mm previous
self.settings.page_size.scaled_width(75 * mm),
40 * mm,
**address_frame_kwargs)
rest_frame = Frame(
self.settings.page_size.from_left(),
self.settings.page_size.margin[2],
self.settings.page_size.available_width(),
self.settings.page_size.available_height(
87 * mm), # 27mm offset + 60mm previous
**frame_kwargs)
full_frame = Frame(self.settings.page_size.from_left(),
self.settings.page_size.margin[2],
self.settings.page_size.available_width(),
self.settings.page_size.available_height(),
**frame_kwargs)
self.doc.addPageTemplates([
PageTemplate(id='First',
frames=[
sender_frame, billing_frame, shipping_frame,
rest_frame
],
onPage=self.on_first_page_cb),
PageTemplate(id='Other',
frames=[full_frame],
onPage=self.on_other_pages_cb),
])
self.story.append(NextPageTemplate('Other'))
def init_templates(self, page_fn, page_fn_later=None):
self.doc.addPageTemplates([
PageTemplate(id='First', frames=[self.frame], onPage=page_fn),
PageTemplate(id='Later',
frames=[self.frame],
onPage=page_fn_later or page_fn),
])
self.story.append(NextPageTemplate('Later'))
def getData(self, session):
paras = []
gen = self.docStream.find_documents(session, cache=self.cache)
for text in gen:
for t in text:
paras.append(platypus.Paragraph(t, ParagraphStyle, bulletText=None))
paras.append(NextPageTemplate("noHeader"))
return paras
def generate_order_pdf(order, filename=_default_filename):
firstpage = FirstPageTemplate(order=order)
laterpages = LaterPageTemplate(order=order)
doc = BaseDocTemplate(filename,
pagesize=PAGESIZE,
pageTemplates=[firstpage, laterpages])
story = [NextPageTemplate('later')]
columns = [1.0 * cm, 2.75 * cm, 6 * cm, 3.25 * cm, 3 * cm, 1.5 * cm]
data = [[
Paragraph('Qty', styleTH),
Paragraph('ISBN', styleTH),
Paragraph('Title', styleTH),
Paragraph('Author', styleTH),
Paragraph('Publisher', styleTH),
Paragraph('Binding', styleTH),
]]
def compare_titles(a, b):
return cmp(a.book.title, b.book.title)
for entry in sorted(order.order_entries, compare_titles):
row = [
Paragraph(unicode(entry.quantity), styleTR),
Paragraph(unicode(entry.book.isbn13), styleTR),
Paragraph(unicode(entry.book.title), styleTR),
Paragraph(unicode(entry.book.author_lastname()), styleTR),
Paragraph(unicode(entry.book.publisher), styleTR),
Paragraph(unicode(entry.book.binding), styleTR),
]
data.append(row)
table = Table(data, colWidths=columns, repeatRows=1)
table.setStyle(
TableStyle([
('BOTTOMPADDING', (0, 0), (-1, -1), 0.5 * cm),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
#('FONT', (0, 0), (-1, 0), styleTH.fontName, styleTH.fontSize),
#('LEADING', (0, 0), (-1, 0), styleTH.leading),
#('FONT', (0, 1), (-1, -1), styleTR.fontName, styleTR.fontSize),
#('LEADING', (0, 1), (-1, -1), styleTR.leading),
]))
if len(order.order_entries) > 1:
plural = 's'
else:
plural = ''
story.append(Spacer(1, 1 * cm))
story.append(Paragraph("ATTENTION: ORDER DEPARTMENT", styleN))
story.append(
Paragraph("<i>Special Instructions</i>:<b>" + order.comment + "</b>",
styleN))
story.append(
Paragraph('<i>Please send the following title' + plural + ':</i>',
styleN))
story.append(table)
doc.build(story, canvasmaker=NumberedCanvas)
def build_pdf(self):
"""Using different internal page methods and given the data provided build the report
"""
# doc options to abstract and set
# doc.creator
# doc.encrypt
# doc.author
# doc.subject
# doc.title
style = self.styles["Normal"]
doc = BaseDocTemplate(self._filename)
# Flowables to be added to document
Story = []
# could create different sized frames and set addPageTemplate frames to array frames=[frame1, frame2]
standard_frame = Frame(doc.leftMargin, doc.bottomMargin, doc.width, doc.height, id='sframe')
Story.append(NextPageTemplate('host'))
# space for title page
Story.append(PageBreak())
# Host data
Story.append(Paragraph('Scanned Hosts ---------------------', self.styles['Heading2']))
for h in self._report['hosts']:
if h.get_display_val():
hname = f'Hostname: {h.get_display_name()}'
ip = f'IP Address: {h.get_ip()}'
mac = f'MAC Address: {h.get_mac_address()}'
Story.append(Paragraph(hname, style))
Story.append(Paragraph(ip, style))
Story.append(Paragraph(mac, style))
Story.append(Spacer(1, 0.2 * inch))
# cpe data
Story.append(Paragraph('CPEs ---------------------', self.styles['Heading2']))
if self._report['cpes']:
for c in self._report['cpes']:
if self._report['cpes'][c][0]:
cpe = self._report['cpes'][c][0]
Story.append(Paragraph(cpe, style))
Story.append(Spacer(1, 0.2 * inch))
else:
Story.append(Paragraph('No CPEs found', style))
# Vuln Data
Story.append(Paragraph('Vulnerabilities ---------------------', self.styles['Heading2']))
if self._report['vulns']:
for v in self._report['vulns']:
Story.append(Paragraph(v, style))
else:
Story.append(Paragraph('No vulnerabilities found.', style))
doc.addPageTemplates([PageTemplate(id='title', frames=standard_frame, onPage=self.title_page),
PageTemplate(id='host', frames=standard_frame, onPage=self.host_page)])
doc.build(Story)
def alternate_orientation():
"""
Criando paginas com em formaro landscape e quebra de pagina com
PageBreak
"""
doc = SimpleDocTemplate('gen/cap03/alternate_orientation.pdf',
pagesize=A4,
rightMargin=1 * cm,
leftMargin=1.5 * cm,
topMargin=2.5 * cm,
bottomMargim=1.5 * cm)
styles = getSampleStyleSheet()
normal = styles['Normal']
# Aqui criamos um frame e um template para cada tipo de orientação
margin = 0.5 * cm
frame = Frame(margin, margin, doc.width, doc.height, id='frame')
frame_landscape = Frame(margin, margin, doc.height, doc.width, id='frame')
portrait_template = PageTemplate(id='portrait',
frames=[frame],
pagesize=A4)
landscape_template = PageTemplate(id='landscape',
frames=[frame_landscape],
pagesize=landscape(A4))
doc.addPageTemplates([portrait_template, landscape_template])
story = []
story.append(Paragraph('This is a page in portrait orientation', normal))
# alterar a orientação da página para landscape
story.append(NextPageTemplate('landscape'))
story.append(PageBreak())
story.append(Spacer(cm, 0.5 * cm))
story.append(Paragraph('This is a page in landscape orientation', normal))
# altera a orientação de volta para retrato
story.append(NextPageTemplate('portrait'))
story.append(PageBreak())
story.append(Paragraph('Now back to portrait again', normal))
doc.build(story)
def add_PDF(self, t, BCTh, defor):
self.tiemp = t
self.Bh = BCTh
self.Def = defor
self.num_prueb += 1
print "Número de prueba " + str(self.num_prueb) + " en PDF"
self.story.append(
Paragraph(
"Informe del ensayo de resistencia a la compresión (<b><i>BCT</i></b>) de la prueba {}."
.format(self.num_prueb), self.estilo['Title']))
self.story.append(NextPageTemplate('UnaColumna'))
#***************** Agregar imagen *****************
graf = Image(
'/home/pi/Desktop/InterfazG-BCT/resources/graf/GraficoBCT_{}.png'.
format(self.num_prueb))
self.story.append(graf)
etiqueta_grafico = "<b><i>Gráfico {}.1.</i></b> Gráfico del ensayo de BCT de la prueba {}.".format(
self.num_prueb, self.num_prueb)
#self.story.append(Paragraph('-------', self.estilo['CuerpoC']))
self.story.append(Paragraph(etiqueta_grafico, self.estilo['CuerpoC']))
#***************** Tabla de datos *****************
txt_tabla = "<b><i>Tabla {}.2.</i></b> Datos obtenidos del ensayo del BCT".format(
self.num_prueb, self.num_prueb)
self.story.append(Paragraph(txt_tabla, self.estilo['CuerpoJ']))
# Obtención de datos
s = str(self.tiemp) + " s"
kg = str(self.Bh) + " Kg"
mm = str(self.Def) + " mm"
data = [['Tiempo', 'Valor BCT mas alto', 'Deformación'], [s, kg, mm]]
# Insertar la tabla con los datos de la variable 'data'
t = Table(data)
t.setStyle(
TableStyle([('BACKGROUND', (0, 0), (2, 0), colors.darkorange),
('GRID', (0, 0), (2, 1), 1, colors.black),
('TEXTCOLOR', (0, 0), (2, 0), colors.whitesmoke),
('BACKGROUND', (0, 1), (-1, -1), colors.navajowhite),
('TEXTCOLOR', (0, 1), (2, 1), colors.black),
('ALIGN', (0, 1), (-1, -1), 'CENTER')]))
self.story.append(t)
#***************** Salto de página *****************
self.story.append(PageBreak())
#CREAMOS LOS PAGETEMPLATE, le asignamos los frames y los canvas
#=================================
#PageTemplate(id=None,frames=[],onPage=_doNothing,onPageEnd=_doNothing)
self.PTUnaColumna = PageTemplate(id='UnaColumna',
frames=self.frameN,
onPage=self.encabezado,
onPageEnd=self.pie)
'''self.PTDosColumnas= PageTemplate(id='DosColumnas',
def _print_reference(self):
index = SimpleIndex()
index.setup(self._styles['root'])
self._story.append(NextPageTemplate('SimpleIndex'))
self._story.append(PageBreak())
self._story.append(RLParagraph(self.TITLE_INDEX, self._styles['h3']))
self._story.append(index)
return index.getCanvasMaker()
def writescanlist(story, scanlist):
scandat = self.readscans(
scanlist=scanlist
) #ghetto, maybe keep channels in upper level (assume constant for all scans in set, probably good assumption)
print('---scanlist----')
keys = [int(x) for x in list(scandat.keys())]
keys.sort()
for key in keys:
scan = key
vals = scandat[key]
impaths = []
for channel, data in vals['xrf'].items():
impaths.append(
self.plotxrf(scan=scan,
channel=channel,
x=vals['x'],
y=vals['y'],
xrf=data))
overviewpath = self.plotoverview(scan, scandat)
integratedspectrumpath = self.plotintegratedxrf(scan, vals)
scan_params = {
'x_range':
int(max(vals['x']) - min(vals['x'])),
'y_range':
int(max(vals['y']) - min(vals['y'])),
'stepsize':
str((max(vals['x']) - min(vals['x'])) /
(len(vals['x']) - 1)),
'dwell':
scanlist[str(scan)]['dwell'],
'energy':
scanlist[str(scan)]['energy']
}
story.append(NextPageTemplate('ScanPage'))
story.append(PageBreak())
story = build_scan_page(
doc=self.doc,
Story=story,
scan_number=scan,
title='Scan ' + str(scan),
text=vals['description'],
scan_params=scan_params,
overviewmap_image_filepath=overviewpath,
scan_image_filepaths=impaths,
)
return story
def create_toc(self):
"""
insert table of contents to pdf.
"""
title = self.create_toc_title()
self.toc.levelStyles = [LEVEL_ONE, LEVEL_TWO]
self.story += [
title,
Spacer(self.width, 1 * cm), self.toc,
NextPageTemplate('letter'),
PageBreak()
]
def __init__(self, items=[], title='', pretext=''):
super(Checklist, self).__init__(title, pretext)
FRAMEBREAK = PDF.Item(_type='FRAMEBREAK',\
order=len(self.story) + 1,\
data=FrameBreak())
self.story.append(FRAMEBREAK)
NEXTPAGETEMPLATE = PDF.Item(_type='TEMPLATE',\
order=len(self.story) + 1,\
data=NextPageTemplate('LaterPages'))
self.story.append(NEXTPAGETEMPLATE)
if items:
items = flatten(items)
self.add(items)
def _make_story(self, *args, **kargs) -> list:
"""
Crea una lista en el orden que se escribirá el contenido del pdf.
Con los espacios,salto de paginas, selección de template, etc.
parameters:
:param **kargs: Diccionario con el conetenido del pdf (titulos, tablas, graficas, textos).
USAGE:
>>>kargs = self._make_table_graphics(estilo) # Dicionario con las tablas y graficas para el story
>>>story=self._make_story(**kargs)
return story
"""
story: List = []
story.append(Spacer(0, 100))
story.append(kargs['texto_tabla_produccion'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['titulo_tabla_produccion'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['tabla_produccion'])
story.append(Spacer(0, 1 * cm))
story.append(kargs['texto_grafica_produccion'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['titulo_grafica_produccion'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['grafica_produccion'])
story.append(NextPageTemplate('contenido'))
story.append(PageBreak()) # Salto de pagina
story.append(Spacer(0, 40))
story.append(kargs['titulo_grafica_produccion_total'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['grafica_produccion_total'])
story.append(Spacer(0, 0.6 * cm))
story.append(kargs['texto_tabla_mantenimiento'])
story.append(Spacer(0, 1 * cm))
story.append(kargs['titulo_tabla_mantenimiento'])
story.append(Spacer(0, 0.6 * cm))
story.append(kargs['tabla_mantenimiento'])
story.append(PageBreak())
story.append(Spacer(0, 40))
story.append(kargs['texto_grafica_mantenimiento'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['titulo_grafica_mantenimiento'])
story.append(Spacer(0, 0.5 * cm))
story.append(kargs['grafica_mantenimiento'])
# story.append(Spacer(0,0.3*cm))
story.append(kargs['titulo_grafica_mantenimiento_total'])
story.append(Spacer(0, 1.5 * cm))
story.append(kargs['grafica_mantenimiento_total'])
return story
def create_second_letter(self):
"""
create second letter of the pdf.
Note: goes after table of contents (TOC)
"""
letter_header = self.create_letter_header()
para_one = self.create_second_letter_paragraph_one()
bullets_one = self.create_second_letter_bullet_one()
bullets_two = self.create_second_letter_bullet_two()
para_two = Paragraph('Ejemplo:', style=ADMIN_REP)
diagram_one = self.create_letter_two_diagram_one()
bullets_three = self.create_second_letter_bullet_three()
diagram_two = self.create_second_letter_diagram_two()
bullets_four = self.create_second_letter_bullet_four()
bullets_five = self.create_second_letter_bullet_five()
indent_one = self.create_indented_paragraph('H = Horizontal')
indent_two = self.create_indented_paragraph('V = Vertical')
indent_three = self.create_indented_paragraph('A = Axial')
bullets_six = self.create_second_letter_bullet_six()
indent_four = self.create_indented_paragraph('V = Velocidad')
indent_five = self.create_indented_paragraph('A = Aceleración')
indent_six = self.create_indented_paragraph('D = Desplazamiento')
para_three = self.create_second_letter_paragraph_three()
self.story += [
*letter_header,
NextPageTemplate('measurement_two'), self.spacer_one, para_one,
self.spacer_two, bullets_one, self.spacer_two, bullets_two,
self.spacer_two, para_two, self.spacer_one, diagram_one,
PageBreak(), bullets_three, self.spacer_one, diagram_two,
self.spacer_one, bullets_four, self.spacer_one, bullets_five,
self.spacer_two, indent_one, indent_two, indent_three,
self.spacer_one, bullets_six, self.spacer_one, indent_four,
indent_five, indent_six, para_three,
NextPageTemplate('letter'),
PageBreak()
]
def create_pred(self, query_instance):
"""
creates a measurement segment
for measurement instance.
"""
especifications = self.machine_specifications_table(query_instance)
# TODO check title
title = self.create_measurement_title_entry(
query_instance.machine.name.upper())
diagram = self.pictures_table(query_instance.machine.images.diagram,
query_instance.machine.images.image)
graphs = self.add_graphs(query_instance)
analysis = self.create_analysis_table(query_instance.analysis,
query_instance.recomendation)
self.story += [
especifications,
NextPageTemplate('measurement_two'), self.spacer_two, title,
diagram, self.spacer_two, *graphs, self.spacer_one, analysis,
NextPageTemplate('measurement'),
PageBreak()
]
def create(self, strategy, template, data):
header = strategy.create_header(data)
customer_section = strategy.create_customer_table(data)
invoice_footer = strategy.create_invoice_footer(data)
footer = strategy.create_footer(data)
story = [NextPageTemplate(template.FIRST_PAGE_TEMPLATE_ID)]
rows_chunks = chunks(data.rows, strategy.MAX_ROWS_PER_TABLE,
strategy.FILL_ROWS_WITH)
for counter, row_chunk in enumerate(rows_chunks):
is_first_page = counter == 0
is_last_page = len(rows_chunks) == counter + 1
story.extend(header)
story.extend(
strategy.create_metadata_table(counter + 1, len(rows_chunks),
data))
if is_first_page:
story.extend(customer_section)
story.append(
strategy.create_rows_table(row_chunk, data, is_last_page))
if is_last_page:
story.extend(invoice_footer)
story.extend(footer)
story.append(NextPageTemplate(template.LATER_PAGES_TEMPLATE_ID))
if not is_last_page:
story.append(PageBreak())
return story
def build_credits(acknowledgement, members):
'''
Breaks the document and add a Credits template (the credits chapter) to report list.
'''
report.append(NextPageTemplate('Credits'))
report.append(PageBreak())
ptxt = Paragraph('<font color = "{color}">{txt}</font>'.\
format(color = white,txt='Credits'), title_1_style)
report.append(ptxt)
report.append(Paragraph('Acknowledgement: ' + acknowledgement, v10_style))
report.append(Spacer(1, 5))
report.append(Paragraph('Developed by:', v10_style))
for member in members:
report.append(Paragraph(member, v10_style))
def __init__(self,
empfaenger: Mitglied,
abrechnung: Abrechnung,
buffer=BytesIO()):
self._abrechnung = abrechnung
self._empfaenger = empfaenger
self._buffer = buffer
first_page_tpl = PageTemplate(id='first_page_tpl',
onPage=self._first_page_static,
frames=[
Frame(
x1=10 * mm,
y1=15 * mm,
width=PAGE_WIDTH - 20 * mm,
height=PAGE_HEIGHT - 105 * mm,
showBoundary=DEBUG,
id='mainFrame',
),
])
next_page_tpl = PageTemplate(id='next_page_tpl',
onPage=self._next_page_static,
frames=[
Frame(x1=10 * mm,
y1=15 * mm,
width=PAGE_WIDTH - 20 * mm,
height=PAGE_HEIGHT - 25 * mm,
showBoundary=DEBUG,
id='mainFrame'),
])
self.doc = BaseDocTemplate(
self._buffer,
pagesize=A4,
pageTemplates=[first_page_tpl, next_page_tpl],
showBoundary=DEBUG,
title=f'Abrechnung für {self.filename}',
author=PDF_AUTHOR,
# Die folgenden sind nur für nicht-flowables interessant:
# (falls überhaupt)
leftMargin=10 * mm,
rightMargin=10 * mm,
topMargin=10 * mm,
bottomMargin=10 * mm,
#
)
self._elements = [NextPageTemplate('next_page_tpl')]
def create_pdf(filename, pdf_template_filename):
"""Create the pdf, with all the contents"""
pdf_report = open(filename, "w")
document = MyDocTemplate(pdf_report)
templates = [MyTemplate(pdf_template_filename, name='background')]
document.addPageTemplates(templates)
styles = getSampleStyleSheet()
elements = [NextPageTemplate('background')]
elements.extend(create_toc())
# Dummy content (hello world x 200)
for i in range(200):
elements.append(Paragraph("Hello World" + str(i), styles['Heading1']))
document.multiBuild(elements)
pdf_report.close()
