def splitpage(src):
''' Split a page into two (top and bottom)
'''
# Yield a result for each half of the page
for y_pos in (0, 0.5):
# Create a blank, unsized destination page.
page = PageMerge()
# add a portion of the source page to it as
# a Form XObject.
page.add(src, viewrect=(0, y_pos, 1, 0.5))
# By default, the object we created will be
# at coordinates (0, 0), which is the lower
# left corner. To move it up on the page
# to the top, we simply use its height
# (which is half the source page height) as
# its y value.
page[0].y = page[0].h
# When we render the page, the media box will
# encompass (0, 0) and all the objects we have
# placed on the page, which means the output
# page will be the same size as the input page.
yield page.render()
def filigrana(input_file,
output_file="output.pdf",
path_filigrana_ver="",
path_filigrana_or=""):
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
page = reader_input.pages[0]
w, h = sizepage(page)
watermark_input = None
watermark = None
if int(w) > int(h):
if path_filigrana_or == "":
print(
"Non hai fornito la corretta filigrana o hai dimenticato di fornirla."
)
else:
watermark_input = PdfReader(path_filigrana_or)
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
if path_filigrana_ver == "":
print(
"Non hai fornito la corretta filigrana o hai dimenticato di fornirla."
)
else:
watermark_input = PdfReader(path_filigrana_ver)
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark).render()
writer_output.write(output_file, reader_input)
def filigrana(tipo, opacita, input_file, output_file):
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
page = reader_input.pages[0]
w, h = sizepage(page)
if tipo == "logo":
if int(w) > int(h):
watermark_input = PdfReader("filigrane/fil_" + str(opacita) +
"_logo_or.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
watermark_input = PdfReader("filigrane/fil_" + str(opacita) +
"_logo_ver.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
if int(w) > int(h):
watermark_input = PdfReader("filigrane/fil_" + str(opacita) +
"_or.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
watermark_input = PdfReader("filigrane/fil_" + str(opacita) +
"_ver.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark).render()
writer_output.write(output_file, reader_input)
def fixpage(page, count=[0]):
count[0] += 1
oddpage = (count[0] & 1)
result = PageMerge()
for rotation in (180 + 180 * oddpage, 180 * oddpage):
result.add(page, rotate=rotation)
result[1].x = result[0].w
return result.render()
def watermarker(path, watermark, output):
base_pdf = PdfReader(path)
watermark_pdf = PdfReader(watermark)
mark = watermark_pdf.pages[0]
for page in range(len(base_pdf.pages)):
merger = PageMerge(base_pdf.pages[page])
merger.add(mark).render()
writer = PdfWriter()
writer.write(output, base_pdf)
def filigrana(input_file, output_file, chat_id):
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
page = reader_input.pages[0]
w, h = sizepage(page)
try:
logo = open(
"/home/{user}/{path}/converter_bot/" + str(chat_id) +
"_logo_settings.txt", "r")
setting = logo.read()
logo.close()
except IOError:
logo = open(
"/home/{user}/{path}/converter_bot/" + str(chat_id) +
"_logo_settings.txt", "w")
logo.write("on")
setting = "on"
try:
opacity = open(
"/home/{user}/{path}/converter_bot/" + str(chat_id) +
"_opacity_settings.txt", "r")
value_opacity = opacity.read()
opacity.close()
except IOError:
opacity = open(
"/home/{user}/{path}/converter_bot/" + str(chat_id) +
"_opacity_settings.txt", "w")
opacity.write("25")
opacity.close()
value_opacity = 25
if setting == "on":
if int(w) > int(h):
watermark_input = PdfReader("/home/{user}/{path}/filigrane/fil_" +
str(value_opacity) + "_logo_or.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
watermark_input = PdfReader("/home/{user}/{path}/filigrane/fil_" +
str(value_opacity) + "_logo_ver.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
if int(w) > int(h):
watermark_input = PdfReader("/home/{user}/{path}/filigrane/fil_" +
str(value_opacity) + "_or.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
else:
watermark_input = PdfReader("/home/{user}/{path}/filigrane/fil_" +
str(value_opacity) + "_ver.pdf")
watermark = fixpage(watermark_input.pages[0], int(w), int(h))
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark).render()
writer_output.write(output_file, reader_input)
def pdf(rm_files_path, path_original_pdf, path_annotated_pdf, path_oap_pdf):
""" Render pdf with annotations. The path_oap_pdf defines the pdf
which includes only annotated pages.
"""
base_pdf = PdfReader(open(path_original_pdf, "rb"))
# Parse remarkable files and write into pdf
annotations_pdf = []
for page_nr in range(base_pdf.numPages):
rm_file_name = "%s/%d" % (rm_files_path, page_nr)
rm_file = "%s.rm" % rm_file_name
if not os.path.exists(rm_file):
annotations_pdf.append(None)
continue
page_layout = base_pdf.pages[page_nr].MediaBox
crop_box = base_pdf.pages[page_nr].CropBox
if page_layout is None:
page_layout = base_pdf.pages[page_nr].ArtBox
if page_layout is None:
annotations_pdf.append(None)
continue
image_width, image_height = float(page_layout[2]), float(
page_layout[3])
annotated_page = _render_rm_file(rm_file_name,
image_width=image_width,
image_height=image_height,
crop_box=crop_box)
if len(annotated_page.pages) <= 0:
annotations_pdf.append(None)
else:
page = annotated_page.pages[0]
annotations_pdf.append(page)
# Merge annotations pdf and original pdf
writer_full = PdfWriter()
writer_oap = PdfWriter()
for i in range(base_pdf.numPages):
annotations_page = annotations_pdf[i]
if annotations_page != None:
merger = PageMerge(base_pdf.pages[i])
merger.add(annotations_page).render()
writer_oap.addpage(base_pdf.pages[i])
writer_full.addpage(base_pdf.pages[i])
writer_full.write(path_annotated_pdf)
writer_oap.write(path_oap_pdf)
def makeA3(ipath, opath, onesided=False):
"""Take the first 4 (A4) pages of the input file and place them in
"booklet" order on an A3 sheet (double-sided, short-side join).
If <onesided> is <True>, or there are only two pages in the input file,
place the first two (A4) pages on one side of an A3 sheet, the first
page on the right-hand side.
Note that the input pages do not have to be A4, the output will simply
be twice as wide (as the first page). All input pages should have the same size.
"""
ipages = PdfReader(ipath).pages
# Make sure we have an even number of pages
if len(ipages) & 1:
ipages.append(None)
fpage = PageMerge()
fpage.add(ipages[0])
width = fpage[0].w
opages = []
if onesided or len(ipages) == 2:
p4 = ipages[1]
else:
p4 = ipages[3]
bpage = PageMerge()
bpage.add(ipages[1])
bpage.add(ipages[2], prepend=True)
bpage[0].x = width
opages.append(bpage.render())
if p4:
fpage.add(p4)
fpage[0].x = width
opages.insert(0, fpage.render())
PdfWriter().addpages(opages).write(opath)
def fixpage(page, width, height):
result = PageMerge()
result.add(page)
if width > height:
if width > 842:
result[0].w = height * 1.6
result[0].x = 50
else:
result[0].x = 0
result[0].w = height * 1.4
else:
if height > 842:
result[0].y = 125
result[0].w = width
result[0].x = 0
return result.render()
def Add_Watermark(input_file, output_file, watermark_file):
# define the reader and writer objects
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
watermark_input = PdfReader(watermark_file)
watermark = watermark_input.pages[8]
# go through the pages one after the next
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark).render()
# write the modified content to disk
writer_output.write(output_file, reader_input)
def make_all_up(pages):
result = PageMerge()
# note: pagemerge() resizes based on content so we now have a
# (pagecount)*width by height page. Ideally we'd then resize the page, but
# this is fine for now since we can use print to scale in print programs.
for page in pages:
# p.scale(0.5)
result.add(page)
first_page_added = len(result) == 1
if first_page_added:
continue
added_page = result[-1]
second_last_page_added = result[-2]
added_page.x = second_last_page_added.x + second_last_page_added.w
return result.render()
def notebook(path,
uuid,
path_annotated_pdf,
is_landscape,
path_templates=None):
rm_files_path = "%s/%s" % (path, uuid)
annotations_pdf = []
p = 0
while True:
rm_file_name = "%s/%d" % (rm_files_path, p)
rm_file = "%s.rm" % rm_file_name
if not os.path.exists(rm_file):
break
overlay, _ = _render_rm_file(rm_file_name,
PDFPageLayout(is_landscape=is_landscape))
annotations_pdf.append(overlay)
p += 1
# Write empty notebook notes containing blank pages or templates
writer = PdfWriter()
templates = _get_templates_per_page(path, uuid, path_templates)
for template in templates:
if template is None:
writer.addpage(_blank_page())
else:
writer.addpage(template.pages[0])
writer.write(path_annotated_pdf)
# Overlay empty notebook with annotations
templates_pdf = PdfReader(path_annotated_pdf)
for i in range(len(annotations_pdf)):
templates_pdf.pages[i].Rotate = 90 if is_landscape else 0
is_empty_page = len(annotations_pdf[i].pages) <= 0
if is_empty_page:
continue
annotated_page = annotations_pdf[i].pages[0]
annotated_page.Rotate = -90 if is_landscape else 0
merger = PageMerge(templates_pdf.pages[i])
merger.add(annotated_page).render()
writer = PdfWriter()
writer.write(path_annotated_pdf, templates_pdf)
def write_pdf_overlay(outfile, ta_data, TEMPLATE="DDAH.pdf"):
from pdfrw import PdfReader, PdfWriter, PageMerge
generate_page1(ta_data)
generate_page2(ta_data)
base_pdf = pdfrw.PdfReader(TEMPLATE)
page1 = pdfrw.PdfReader("page1.pdf")
merger = PageMerge(base_pdf.pages[0])
merger.add(page1.pages[0]).render()
page2 = pdfrw.PdfReader("page2.pdf")
merger2 = PageMerge(base_pdf.pages[1])
merger2.add(page2.pages[0]).render()
writer = PdfWriter()
writer.write(outfile, base_pdf)
def watermark_pdf(email, file):
"""Watermarks the file using users email"""
pdf = gen_watermark_pdf(email)
reader_input = PdfReader(file)
writer_output = PdfWriter()
buf = io.BytesIO()
with io.BytesIO(pdf) as f:
watermark_input = PdfReader(f)
watermark = watermark_input.pages[0]
# go through the pages one after the next
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark, prepend=False).render()
# write the modified content to disk
writer_output.write(buf, reader_input)
return buf
def pdf(rm_files_path, path_highlighter, path_original_pdf, path_annotated_pdf, path_oap_pdf):
""" Render pdf with annotations. The path_oap_pdf defines the pdf
which includes only annotated pages.
"""
base_pdf = PdfReader(open(path_original_pdf, "rb"))
# Parse remarkable files and write into pdf
annotations_pdf = []
for page_nr in range(base_pdf.numPages):
rm_file_name = "%s/%d" % (rm_files_path, page_nr)
rm_file = "%s.rm" % rm_file_name
if not os.path.exists(rm_file):
annotations_pdf.append(None)
continue
page_layout = PDFPageLayout(base_pdf.pages[page_nr])
if page_layout.layout is None:
annotations_pdf.append(None)
continue
annotated_page = _render_rm_file(rm_file_name, page_layout=page_layout, path_highlighter=path_highlighter)
if len(annotated_page.pages) <= 0:
annotations_pdf.append(None)
else:
page = annotated_page.pages[0]
annotations_pdf.append(page)
# Merge annotations pdf and original pdf
writer_full = PdfWriter()
writer_oap = PdfWriter()
for i in range(base_pdf.numPages):
annotations_page = annotations_pdf[i]
if annotations_page is not None:
merger = PageMerge(base_pdf.pages[i])
merger.add(annotations_page).render()
writer_oap.addpage(base_pdf.pages[i])
writer_full.addpage(base_pdf.pages[i])
writer_full.write(path_annotated_pdf)
writer_oap.write(path_oap_pdf)
def notebook(path, id, path_annotated_pdf, path_templates=None):
rm_files_path = "%s/%s" % (path, id)
annotations_pdf = []
p = 0
while True:
rm_file_name = "%s/%d" % (rm_files_path, p)
rm_file = "%s.rm" % rm_file_name
if not os.path.exists(rm_file):
break
overlay = _render_rm_file(rm_file_name)
annotations_pdf.append(overlay)
p += 1
# Write empty notebook notes containing blank pages or templates
writer = PdfWriter()
templates = _get_templates_per_page(path, id, path_templates)
for template in templates:
if template == None:
writer.addpage(_blank_page())
else:
writer.addpage(template.pages[0])
writer.write(path_annotated_pdf)
# Overlay empty notebook with annotations
templates_pdf = PdfReader(path_annotated_pdf)
for i in range(len(annotations_pdf)):
empty_page = len(annotations_pdf[i].pages) <= 0
if empty_page:
continue
annotated_page = annotations_pdf[i].pages[0]
if templates != None:
merger = PageMerge(templates_pdf.pages[i])
merger.add(annotated_page).render()
else:
output_pdf.addPage(annotated_page)
writer = PdfWriter()
writer.write(path_annotated_pdf, templates_pdf)
def pageLayout(self, seed):
'''
page layout
'''
pageLayoutList = self.genIndex(seed)
for i in pageLayoutList:
page = PageMerge()
y_pos = 0
for j in i:
x_pos = 0
for k in j:
page.add(self.objs[k])
page[-1].scale(self.info.w / page[-1].w,
self.info.h / page[-1].h)
page[-1].x = x_pos * self.info.w
page[-1].y = y_pos * self.info.h
x_pos += 1
y_pos += 1
self.opages.append(page.render())
def merge_pdfs(form_pdf, overlay_pdf, output):
"""
Merge the specified fillable form PDF with the overlay PDF
and save the output.
"""
form = PdfReader(form_pdf)
olay = PdfReader(overlay_pdf)
for form_page, overlay_page in zip(form.pages, olay.pages):
merge_obj = PageMerge()
overlay = merge_obj.add(overlay_page)[0]
PageMerge(form_page).add(overlay).render()
writer = PdfWriter()
writer.write(output, form)
def make_card():
"""Render a message via the API, then composite the render on top of an
existing template, at the correct position.
"""
# render the message
message_render = render_handwritten_msg(HANDWRITING_ID, MESSAGE_TO_RENDER)
# wrap the render and the template files with pdfrw
template_pdf = PdfReader('template.pdf')
message_pdf = PdfReader(fdata=message_render)
# set up our render as a "stamp" to put on the template
stamp = PageMerge().add(message_pdf.pages[0])[0]
# x is the distance from the left edge of the template to the left edge of the stamp:
stamp.x = OFFSET_X_POINTS
# y is the distance from the bottom edge of the template to the top edge of the stamp:
stamp.y = CARD_H_POINTS - OFFSET_Y_POINTS
pm = PageMerge(template_pdf.pages[0])
pm.add(stamp)
pm.render()
PdfWriter().write('out.pdf', template_pdf)
def make_card():
"""Render a message via the API, then composite the render on top of an
existing template, at the correct position.
"""
# render the message
message_render = render_handwritten_msg(HANDWRITING_ID, MESSAGE_TO_RENDER)
# wrap the render and the template files with pdfrw
template_pdf = PdfReader('template.pdf')
message_pdf = PdfReader(fdata=message_render)
# set up our render as a "stamp" to put on the template
stamp = PageMerge().add(message_pdf.pages[0])[0]
# x is the distance from the left edge of the template to the left edge of the stamp:
stamp.x = OFFSET_X_POINTS
# y is the distance from the bottom edge of the template to the top edge of the stamp:
stamp.y = CARD_H_POINTS - OFFSET_Y_POINTS
pm = PageMerge(template_pdf.pages[0])
pm.add(stamp)
pm.render()
PdfWriter().write('out.pdf', template_pdf)
def generateButton_handler(self, data_dict, file_path):
pdf = canvas.Canvas('eod_template_overlay.pdf')
pdf.setFont('Courier', 14)
# write general information strings
pdf.drawString(90, 742, data_dict['store'])
pdf.drawString(90, 713, H.day_of_week(self,
data_dict['date'].weekday()))
pdf.drawString(90, 685, data_dict['date'].strftime('%d/%m/%Y'))
pdf.drawString(90, 657, data_dict['staff'])
# array of cash values
cash_arr = [
H.char_remover(self, data_dict['cash aside']),
H.char_remover(self, data_dict['cash 100s']),
H.char_remover(self, data_dict['cash 50s']),
H.char_remover(self, data_dict['cash 20s']),
H.char_remover(self, data_dict['cash 10s']),
H.char_remover(self, data_dict['cash 5s']),
H.char_remover(self, data_dict['cash coins'])
]
# calculate total cash
total = 0
for value in cash_arr:
if value != None:
total += value
if data_dict['cash payouts'] != None:
total -= H.char_remover(self, data_dict['cash payouts'])
# write cash strings
pdf.drawString(
153, 577,
H.dollar_adder(self, H.char_remover(self,
data_dict['cash payouts'])))
pdf.drawString(
153, 550,
H.dollar_adder(self, H.char_remover(self,
data_dict['cash aside'])))
pdf.drawString(
153, 523,
H.dollar_adder(self, H.char_remover(self, data_dict['cash 100s'])))
pdf.drawString(
153, 495,
H.dollar_adder(self, H.char_remover(self, data_dict['cash 50s'])))
pdf.drawString(
153, 467,
H.dollar_adder(self, H.char_remover(self, data_dict['cash 20s'])))
pdf.drawString(
153, 440,
H.dollar_adder(self, H.char_remover(self, data_dict['cash 10s'])))
pdf.drawString(
153, 413,
H.dollar_adder(self, H.char_remover(self, data_dict['cash 5s'])))
pdf.drawString(
153, 385,
H.dollar_adder(self, H.char_remover(self,
data_dict['cash coins'])))
pdf.drawString(153, 358, H.dollar_adder(self, total))
pdf.drawString(
153, 330,
H.dollar_adder(self,
H.char_remover(self, data_dict['cash register'])))
pdf.drawString(
153, 303,
H.diff_dollar_adder(
self,
H.calc_diff(self, total,
H.char_remover(self, data_dict['cash register']))))
# write lotto strings
lotto_actual = H.char_remover(self, data_dict['lotto actual'])
lotto_register = H.char_remover(self, data_dict['lotto register'])
pdf.drawString(153, 220, H.dollar_adder(self, lotto_actual))
pdf.drawString(153, 193, H.dollar_adder(self, lotto_register))
pdf.drawString(
153, 166,
H.diff_dollar_adder(
self, H.calc_diff(self, lotto_register, lotto_actual)))
# write eftpos strings
eftpos_actual = H.char_remover(self, data_dict['eftpos actual'])
eftpos_register = H.char_remover(self, data_dict['eftpos register'])
pdf.drawString(429, 715, H.dollar_adder(self, eftpos_actual))
pdf.drawString(429, 688, H.dollar_adder(self, eftpos_register))
pdf.drawString(
429, 661,
H.diff_dollar_adder(
self, H.calc_diff(self, eftpos_actual, eftpos_register)))
# write epay strings
epay_actual = H.char_remover(self, data_dict['epay actual'])
epay_register = H.char_remover(self, data_dict['epay register'])
pdf.drawString(429, 577, H.dollar_adder(self, epay_actual))
pdf.drawString(429, 550, H.dollar_adder(self, epay_register))
pdf.drawString(
429, 523,
H.diff_dollar_adder(self,
H.calc_diff(self, epay_register, epay_actual)))
# write scratchie strings
scratchie_actual = H.char_remover(self, data_dict['scratchies actual'])
scratchie_register = H.char_remover(self,
data_dict['scratchies register'])
pdf.drawString(
429, 440,
H.diff_dollar_adder(
self, H.calc_diff(self, scratchie_actual, scratchie_register)))
# write scratchie payout strings
scratchie_pay_actual = H.char_remover(
self, data_dict['scratchies pay actual'])
scratchie_pay_register = H.char_remover(
self, data_dict['scratchies pay register'])
pdf.drawString(429, 358, H.dollar_adder(self, scratchie_pay_actual))
pdf.drawString(429, 330, H.dollar_adder(self, scratchie_pay_register))
pdf.drawString(
429, 303,
H.diff_dollar_adder(
self,
H.calc_diff(self, scratchie_pay_actual,
scratchie_pay_register)))
# write lotto payout strings
lotto_pay_actual = H.char_remover(self, data_dict['lotto pay actual'])
lotto_pay_register = H.char_remover(self,
data_dict['lotto pay register'])
pdf.drawString(429, 220, H.dollar_adder(self, lotto_pay_actual))
pdf.drawString(429, 193, H.dollar_adder(self, lotto_pay_register))
pdf.drawString(
429, 166,
H.diff_dollar_adder(
self, H.calc_diff(self, lotto_pay_actual, lotto_pay_register)))
# write notes section at the bottom of the page
text = data_dict['notes']
length = 62
x_pos = 37
y_pos = 135
y_offset = 10
if len(text) > length:
wraps = textwrap.wrap(text, length)
for x in range(len(wraps)):
pdf.drawString(x_pos, y_pos, wraps[x])
y_pos -= y_offset
y_pos += y_offset # add back offset after last wrapped line
else:
pdf.drawString(x_pos, y_pos, text)
pdf.showPage()
pdf.save()
base_pdf = PdfReader('eod_template.pdf')
watermark_pdf = PdfReader('eod_template_overlay.pdf')
mark = watermark_pdf.pages[0]
for page in range(len(base_pdf.pages)):
merger = PageMerge(base_pdf.pages[page])
merger.add(mark).render()
print(file_path)
writer = PdfWriter()
writer.write(file_path, base_pdf)
def render_1054(id):
"""
Note that all rendering views have same "core" inside and that is the for loop we use over pdf.Annots . With this
for loop we extract the form-field names so as locations of fields. Once we have all the names we can use our Tax
database model and its json_data column that contains exact same keys as pdf-form. I am going to leave some commets
after each important step , but PDFRW doc is the key to understand parts of this script. Despite all efforts
a lot of things are still hard coded , because pdf is simply stupid format.
"""
all = Tax.query.filter_by(id=id).first()
if current_user.id != all.author.id:
return "ERROR 403"
# Finding the right form of pdf
file_pdf = os.path.abspath(
os.path.dirname('app/static/img/pdf/prim_1054.pdf'))
pdf_to_read = os.path.join(file_pdf, 'prim_1054.pdf')
template_pdf = pdfrw.PdfReader(pdf_to_read)
# Query for selected data input
all = all.json_data
# Creating two bytes object to store new canvs and final pdf in memory
data = io.BytesIO()
overlay_io = io.BytesIO()
# Excluding the data we are going to automate
presist = [
all['(3 Porezna godina)'][2:], all['(6 Porezni period)'], all['(do)']
]
exclude = [
'(3 Porezna godina)',
'(6 Porezni period)',
'(do)',
]
for i in exclude:
if all[i]:
all.pop(i)
pdf = canvas.Canvas(data)
for page in template_pdf.Root.Pages.Kids:
for field in page.Annots:
# The main loop of view , we are going to extract all the neccessary data from page.Annots
# Label names and rect positions.
label = field.T
side = field.Rect
left = min(side[0], side[2])
bottom = min(side[1], side[3])
value = all.get(label, '')
pdf.drawString(x=float(left), y=float(bottom), text=value)
pdf.drawString(x=216.96,
y=609.12,
charSpace=9,
text=str(current_user.jmbg))
pdf.drawString(x=479, y=610, text=presist[0], charSpace=9)
pdf.drawString(x=459, y=583, text=presist[1], charSpace=9)
pdf.drawString(x=507, y=583, text=presist[2], charSpace=9)
pdf.drawString(x=72,
y=608,
text='{} {}'.format(current_user.ime,
current_user.prezime))
pdf.showPage()
pdf.save()
data.seek(0)
# Creating overlay
overlay = pdfrw.PdfReader(data)
mark = overlay.pages[0]
for page in range(len(template_pdf.pages)):
merger = PageMerge(template_pdf.pages[page])
merger.add(mark).render()
pdfrw.PdfWriter().write(overlay_io, template_pdf)
overlay_io.seek(0)
# for page, data in zip(template_pdf.pages, overlay.pages):
# overlay = pdfrw.PageMerge().add(data)[0]
# pdfrw.PageMerge(page).add(overlay).render()
# pdfrw.PdfWriter().write(overlay_io, template_pdf)
#
# overlay_io.seek(0)
return send_file(overlay_io,
as_attachment=True,
attachment_filename='prim1054.pdf',
mimetype='application/pdf')
def pdf(rm_files_path, path_highlighter, pages, path_original_pdf,
path_annotated_pdf, path_oap_pdf):
""" Render pdf with annotations. The path_oap_pdf defines the pdf
which includes only annotated pages.
"""
base_pdf = PdfReader(open(path_original_pdf, "rb"))
# Parse remarkable files and write into pdf
annotations_pdf = []
offsets = []
for page_nr in range(base_pdf.numPages):
rm_file_name = "%s/%d" % (rm_files_path, page_nr)
rm_file = "%s.rm" % rm_file_name
if not os.path.exists(rm_file):
annotations_pdf.append(None)
offsets.append(None)
continue
if hasattr(base_pdf,
"Root") and hasattr(base_pdf.Root, "Pages") and hasattr(
base_pdf.Root.Pages, "MediaBox"):
default_layout = base_pdf.Root.Pages.MediaBox
else:
default_layout = None
page_layout = PDFPageLayout(base_pdf.pages[page_nr],
default_layout=default_layout)
if page_layout.layout is None:
annotations_pdf.append(None)
offsets.append(None)
continue
page_file = os.path.join(path_highlighter, f"{pages[page_nr]}.json")
annotated_page, offset = _render_rm_file(
rm_file_name,
page_layout=page_layout,
page_file=page_file,
)
if len(annotated_page.pages) <= 0:
annotations_pdf.append(None)
else:
page = annotated_page.pages[0]
annotations_pdf.append(page)
offsets.append(offset)
# Merge annotations pdf and original pdf
writer_full = PdfWriter()
writer_oap = PdfWriter()
for i in range(base_pdf.numPages):
annotations_page = annotations_pdf[i]
if annotations_page is not None:
# The annotations page is at least as large as the base PDF page,
# so we merge the base PDF page under the annotations page.
merger = PageMerge(annotations_page)
pdf = merger.add(base_pdf.pages[i], prepend=True)[0]
pdf.x -= offsets[i][0]
pdf.y -= offsets[i][1]
merger.render()
writer_oap.addpage(annotations_page)
writer_full.addpage(annotations_page)
else:
writer_full.addpage(base_pdf.pages[i])
writer_full.write(path_annotated_pdf)
writer_oap.write(path_oap_pdf)
# Добавление QR-кода в многостраничный PDF документ
from pdfrw import PdfReader, PdfWriter, PageMerge
input_file = "source/Computer-Vision-Resources.pdf"
output_file = "dist/Computer-Vision-Resources-QR-pages.pdf"
watermark_file = "source/waksoft-QR-code.pdf"
# определяем объекты чтения и записи
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
watermark_input = PdfReader(watermark_file)
watermark = watermark_input.pages[0]
# просматривать страницы одну за другой
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark).render()
# записать измененный контент на диск
writer_output.write(output_file, reader_input)
def render_pr1(id):
file_pdf = os.path.abspath(os.path.dirname('app/static/img/pdf/pr_1.pdf'))
pdf_to_read = os.path.join(file_pdf, 'pr_1.pdf')
q = db.session.query(Tax).filter(Tax.id == id).first()
buffer = io.BytesIO()
overlay_io = io.BytesIO()
template_pdf = pdfrw.PdfReader(pdf_to_read)
pdf_canvas = canvas.Canvas(buffer, pagesize=A4)
width, height = A4
styles = getSampleStyleSheet()
data = [
[
'', 'Vrsta imovine \n (a)',
'Lokacija imovine \n (b)',
'Jedinica mjere \n (c)',
'Broj jedinica mjere \n (d)',
' Porez po \n jedinici mjere \n (f)',
'Iznos Poreza \n (g)'
],
]
right = [
'kuca',
'Kuca, zgrada\n ili stan',
'poslovni',
'Poslovni prostor',
'garaza',
'Garaza koja se \n izdaje',
'parking',
'Parking prostor',
'vozilo',
'Putnicko vozilo',
'tvozilo',
'Teretno vozilo',
'plovni',
'Plovni objekat',
'letljelica',
'Letljelica',
'stol',
'Stol u kazinu',
'automat',
'Automat za \n zabavne igre',
]
index_v = 1
final_sum = 0
for k, v in q.json_data.items():
if isinstance(q.json_data[k], List):
if k[-2].isdigit():
k = ''.join([i for i in k if not i.isdigit()])
key_pair = right.index(k) + 1
if k in right:
v.pop(0)
v.insert(0, index_v)
v.insert(1, right[key_pair])
data.append(v)
final_sum += int(v[-1])
index_v += 1
data.append(['', 'UKUPNO', '', '', '', '', final_sum])
def calc_h(num_lines, extended):
start = (2, 520)
e_start = 520 - (extended * 11.5)
result = num_lines - start[0]
position = e_start - (result * 18)
return position
table = Table(data,
colWidths=(0.7 * cm, 2.5 * cm, None, None, None, None, None))
table.setStyle(
TableStyle([('ALIGN', (1, 1), (-1, -1), 'LEFT'),
('FONTSIZE', (0, 0), (6, 0), 10),
('FONTSIZE', (1, 1), (6, 20), 8),
('FONTNAME', (0, 0), (6, 0), 'Times-Bold'),
('BOX', (0, 0), (-1, -1), 0.75, colors.black),
('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black)]))
table.wrapOn(pdf_canvas, width, height)
table.drawOn(
pdf_canvas, 40,
calc_h(len(data), len([len(e[1]) for e in data if len(e[1]) >= 22])))
pdf_canvas.drawString(x=128.5,
y=725,
text=str(current_user.jmbg),
charSpace=4.5)
pdf_canvas.drawString(x=260,
y=702,
text='{} {}'.format(current_user.ime,
current_user.prezime))
pdf_canvas.drawString(x=425, y=727, text=q.json_data['(godina)'])
pdf_canvas.drawString(x=135, y=650, text=q.json_data['(kanton)'])
pdf_canvas.drawString(x=170, y=675, text=q.json_data['(adresa)'])
pdf_canvas.drawString(x=190, y=611, text=q.json_data['(racun)'])
pdf_canvas.drawString(x=415, y=611, text=q.json_data['(banka)'])
pdf_canvas.showPage()
pdf_canvas.save()
buffer.seek(0)
overlay = pdfrw.PdfReader(buffer)
mark = overlay.pages[0]
for page in range(len(template_pdf.pages)):
merger = PageMerge(template_pdf.pages[page])
merger.add(mark).render()
pdfrw.PdfWriter().write(overlay_io, template_pdf)
overlay_io.seek(0)
return send_file(overlay_io,
as_attachment=True,
attachment_filename='pr-1.pdf',
mimetype='application/pdf')
def anim_pdf(name, rotate=0, history=True, lines=True, flatten=False, place='left', add_name='_anim', two_screens=False, skip=0):
# The optional arguments are also available as command line options and explained in anim_pdf_command_line()
# check whether file exists
if not isfile(name + '.pdf'):
raise Exception('File ' + name + '.pdf not found.')
# integrate annotations (if required) and read file
gs = Ghostscript()
if flatten:
gs.flatten_pdf(name, name + '_flat')
pdf = PdfReader(name + '_flat.pdf')
else:
pdf = PdfReader(name + '.pdf')
out = PdfWriter()
for j in range(len(pdf.pages)-skip):
print('slide', j+1)
pdf.pages[j].Rotate = rotate
# get pixels
temp_out = PdfWriter()
temp_out.addpage(pdf.pages[j])
temp_out.write('temp' + str(j) + '.pdf')
gs.pdf2jpg('temp' + str(j))
image = Image.open('temp' + str(j) + '.jpg')
pixels = image.load()
# determine background color from first page (usually white) and create background image
if j == 0:
bkgr = background(image.size[0], image.size[1], pixels)
Image.new('RGB', (1, 1), bkgr).save('white.pdf')
white = PdfReader('white.pdf').pages[0]
if lines:
# determine data for animation
ends = endpoints(image.size[0], image.size[1], pixels)
else:
ends = [image.size[1]-1]
for i in range(len(ends)):
# make animation
merge_anim = PageMerge()
merge_anim.add(pdf.pages[j])
merge_anim.add(white)
factor_w = merge_anim[0].w/merge_anim[1].w
factor_h = (1-ends[i]/image.size[1])*merge_anim[0].h/merge_anim[1].h
merge_anim[1].scale(factor_w,factor_h)
merge_anim_rendered = merge_anim.render()
if not history:
out.addpage(merge_anim_rendered)
else:
history_first = ((place == 'top') or (place == 'left')) and ((j>=1) or two_screens)
horizontal = (place == 'left') or (place == 'right')
merge_two = PageMerge()
if history_first:
h = 0
m = 1
else:
m = 0
h = 1
if not history_first:
merge_two.add(merge_anim_rendered)
if j>=1:
merge_two.add(pdf.pages[j-1])
else:
merge_two.add(white)
if history_first:
merge_two.add(merge_anim_rendered)
if j==0:
merge_two[h].scale(merge_two[m].w/merge_two[h].w,merge_two[m].h/merge_two[h].h)
if horizontal:
merge_two[1].x = merge_two[0].w
else:
merge_two[0].y = merge_two[1].h
out.addpage(merge_two.render())
remove('temp' + str(j) + '.jpg')
remove('temp' + str(j) + '.pdf')
if flatten:
remove(name + '_flat.pdf')
out.write(name + add_name + '.pdf')
remove('white.pdf')
def copyrightParse(sourceKey, bucketName, context):
# BOTO3 objects
s3 = boto3.resource('s3')
s3client = boto3.client('s3')
object = s3.Object(bucketName, sourceKey)
# Copyright Data
metadata = object.metadata
if "copyright" in metadata:
return 'Copyright already exists - aborting'
dateTimeObj = datetime.now()
timestampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M:%S.%f)")
metadata['copyright'] = timestampStr
# Get prelim data from object
with io.BytesIO(object.get()['Body'].read()) as pdf_content_sample:
existing_pdf = PdfReader(pdf_content_sample)
# Get Dimensions of document to make corresponding sized watermark
mbox = existing_pdf.pages[0].MediaBox
mediabox = tuple(float(x) for x in mbox)
### ReportLab implementation
# Get Source PDF to watermark - Load single page to generate watermark to the right size
# Create memory position for Watermark PDF
with io.BytesIO() as packet:
print('Loading PDF file - Watermark generation')
height = 40
width = mediabox[2]
# create a new PDF with Reportlab
can = canvas.Canvas(packet)
can.setPageSize((width, height))
# Get Copyright content
copyrightContent = getCopyrightContent()
# Stylesheet additions
stylesheet = getSampleStyleSheet()
style_watermark = stylesheet["Normal"]
style_watermark.alignment = TA_CENTER
style_watermark.textColor = colors.Color(0, 0, 0, alpha=0.5)
style_watermark.fontSize = 8
style_watermark.font = 'Helvetica'
# Creating Paragraph
copyright_paragraph = Paragraph(copyrightContent, style_watermark)
# Creating Table to wrap Paragraph
data = [[copyright_paragraph]]
table = Table(data)
table.setStyle(
TableStyle([
('BACKGROUND', (0, 0), (-1, -1),
colors.Color(255, 255, 255, alpha=0.5)),
]))
# Adding Table to Canvas
# Make sure the width is an integer!
print(f'Table width set to {math.floor(width)}')
table.wrapOn(can, math.floor(width), 15)
table.drawOn(can, 0, 0)
# Saving
can.save()
# Move to start of memory pointer
packet.seek(0)
watermark_input = PdfReader(packet)
watermark = watermark_input.pages[0]
# Iterate through pages, updating source file.
for current_page in range(len(existing_pdf.pages)):
merger = PageMerge(existing_pdf.pages[current_page])
merger.add(watermark).render()
# write the modified content to disk
writer_output = PdfWriter()
outputStream = io.BytesIO()
with outputStream as pdfOutput:
writer_output.write(pdfOutput, existing_pdf)
print('File written to PDFWriter')
pdfOutput.seek(0)
s3client.upload_fileobj(pdfOutput,
bucketName,
sourceKey,
ExtraArgs={"Metadata": metadata})
status = f'Copyright Set: {timestampStr}'
return status
def stampcopyright(username, input_file, top=True, bottom=True, suffix=""):
def new_page():
fpdf = FPDF()
fpdf.add_page()
fpdf.set_font("helvetica", size=36)
fpdf.text(50, 50, "Hello!")
reader = PdfReader(fdata=bytes(fpdf.output()))
return reader.pages[0]
# generate 'watermark' merge file
try:
headerfooterfile_base = next(tempfile._get_candidate_names()) + ".pdf"
headerfooterfile = os.path.join(tempfile.gettempdir(),
headerfooterfile_base)
pdf = PDF()
#pdf.font_size_pt = 24
#pdf.font_family = "helvetica"
pdf.username_to_set = username
pdf.alias_nb_pages("{nb}")
pdf.add_page()
pdf.output(headerfooterfile, 'F')
except Exception as e:
logger.error(f"Error writing PDF HeaderFooter File: {e}")
else:
logger.debug(f"Wrote PDF HeaderFooter File: {headerfooterfile}")
if opasConfig.LOCAL_TRACE:
print(f"Wrote PDF HeaderFooter File: {headerfooterfile}")
# now merge with download file
#pisa.showLogging() # debug only
input_file_basename = ntpath.basename(input_file)
try:
input_file_basename = os.path.splitext(input_file_basename)[0]
except Exception as e:
logger.info(f"Error removing extension: {e}")
output_file = None
if suffix != "":
sep = "-"
else:
sep = ""
try:
output_file = os.path.join(tempfile.gettempdir(),
input_file_basename + f"{sep}{suffix}.pdf")
logger.debug(f"Writing Stamped Copyright Output File: {output_file}")
if opasConfig.LOCAL_TRACE:
print(f"Writing Stamped Copyright Output File: {output_file}")
watermark_file = headerfooterfile
# define the reader and writer objects
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
watermark_input = PdfReader(watermark_file)
watermark = watermark_input.pages[0]
# go through the pages one after the next
for current_page in range(len(reader_input.pages)):
merger = PageMerge(reader_input.pages[current_page])
merger.add(watermark).render()
if 0: # doesn't work
append_page_path = localsecrets.PDF_ORIGINALS_PATH + localsecrets.PATH_SEPARATOR + COPYRIGHT_PAGE
append_page = get_append_page(append_page_path) # append at end
reader_input.pages.append(append_page)
# write the modified content to disk
writer_output.write(output_file, reader_input)
if 0: # doesn't work...work on this later
# add final copyright page
writer = PdfWriter(trailer=PdfReader(output_file))
try:
append_page_path = localsecrets.PDF_ORIGINALS_PATH + localsecrets.PATH_SEPARATOR + COPYRIGHT_PAGE
append_page = get_append_page(
append_page_path) # append at end
writer.pagearray.append(append_page)
writer.pagearray.append(new_page())
except Exception as e:
logger.error(
f"Could not access copyright page in {append_page_path} (error:{e})"
)
else:
print("Success writing new page")
# final write
writer.write(output_file)
except Exception as e:
logger.error(
f"Could not add copyright page for user {username} to {suffix} PDF; returning without marks (error:{e})"
)
output_file = input_file
else:
logger.debug(
f"Copyright info added for user {username} to Original PDF")
return output_file
def debug(event, context):
# Get Source PDF to watermark
filename = "sample.pdf"
existing_pdf = PdfReader(open(filename, "rb"))
# Get Dimensions of document to make corresponding sized watermark
mbox = existing_pdf.pages[0].MediaBox
mediabox = tuple(float(x) for x in mbox)
with io.BytesIO() as packet:
height = 40
width = mediabox[2]
# create a new PDF with Reportlab
can = canvas.Canvas(packet)
can.setPageSize((width, height))
# Get Copyright content
copyrightContent = getCopyrightContent()
# Stylesheet additions
stylesheet = getSampleStyleSheet()
style_watermark = stylesheet["Normal"]
style_watermark.alignment = TA_CENTER
style_watermark.textColor = colors.Color(0, 0, 0, alpha=0.5)
style_watermark.fontSize = 8
style_watermark.font = 'Helvetica'
# Creating Paragraph
copyright_paragraph = Paragraph(copyrightContent, style_watermark)
# Creating Table to wrap Paragraph
data = [[copyright_paragraph]]
table = Table(data)
table.setStyle(
TableStyle([
('BACKGROUND', (0, 0), (-1, -1),
colors.Color(255, 255, 255, alpha=0.5)),
]))
# Adding Table to Canvas
table.wrapOn(can, math.floor(width), 15)
table.drawOn(can, 0, 0)
# Saving
can.save()
# Move to start of memory pointer
packet.seek(0)
# Setting up PDF as a PDFFileReader object
watermark_input = PdfReader(packet)
watermark = watermark_input.pages[0]
# Iterate through pages, updating source file.
for current_page in range(len(existing_pdf.pages)):
print(f'page {current_page}')
merger = PageMerge(existing_pdf.pages[current_page])
merger.add(watermark).render()
# write the modified content to disk
writer_output = PdfWriter()
outputStream = open(f"processed_{filename}", "wb")
with outputStream as pdfOutput:
writer_output.write(pdfOutput, existing_pdf)
print('Processed PDF - copyright added')
# !/usr/bin/python
# Adding a watermark to a multi-page PDF
import os
from pdfrw import PdfReader, PdfWriter, PageMerge
input_file_name = "input.pdf"
output_file_name = "output.pdf"
watermark_file_name = "watermark.pdf"
# define the reader and writer objects
input_file = PdfReader(input_file_name)
watermark_file = PdfReader(watermark_file_name)
watermark_page = watermark_file.pages[0]
# go through the pages one after the next
for current_page in range(len(input_file.pages)):
current_merge_page = PageMerge(input_file.pages[current_page])
current_merge_page.add(watermark_page).render()
# write the modified content to disk
output_file = PdfWriter()
output_file.write(output_file_name, input_file)
def generate_certificate_pdf(person: Person,
reason: int,
start: datetime,
generated: datetime) -> str:
""" Generate the certificate required when leaving the place of confinement.
Arguments
---------
person: :class:`Person`
For whom the certificate is generated.
reason: `int`
For which the person is leaving her place of confinement. This is an
index into ``REASONS``.
start: `datetime`
Date and time the person is leaving her place of confinement.
generated: `datetime`
Date and time the certificate is generated.
Returns
-------
str
Path to the PDF file generated. """
def cm_to_point(cm: float) -> int:
return int(cm / 2.54 * 72)
if sys.platform == 'ios':
LEGEND_FONT = 'Helvetica'
LEGEND_FONT_SIZE = 24
else:
LEGEND_FONT = 'arial.ttf'
LEGEND_FONT_SIZE = 24
font = ImageFont.truetype(LEGEND_FONT, LEGEND_FONT_SIZE)
fields = [
TextField(text=f"{person.first_name} {person.last_name}",
font=font,
x=3.27, y=24.8, scale=.47),
TextField(text=person.birthdate,
font=font,
x=3.27, y=24.15, scale=.47),
TextField(text=person.birthplace,
font=font,
x=7.55, y=24.15, scale=.47),
TextField(text=f"{person.address} {person.postal_code} {person.city} ",
font=font,
x=3.68, y=23.476, scale=.47),
TextField(text="X" if reason == 0 else " ",
font=font,
x=1.625, y=19.52, scale=.37),
TextField(text="X" if reason == 1 else " ",
font=font,
x=1.625, y=17.02, scale=.37),
TextField(text="X" if reason == 2 else " ",
font=font,
x=1.625, y=15.32, scale=.37),
TextField(text="X" if reason == 3 else " ",
font=font,
x=1.625, y=14.47, scale=.37),
TextField(text="X" if reason == 4 else " ",
font=font,
x=1.66, y=12.32, scale=.37),
TextField(text=person.city,
font=font,
x=2.8, y=2.7, scale=.47),
TextField(text=start.strftime('%d/%m/%Y'),
font=font,
x=2.22, y=2.05, scale=.47),
TextField(text=start.strftime('%H:%M'),
font=font,
x=8.02, y=2.05, scale=.47),
QRCodeField(person=person, reason=reason, start=start, generated=generated,
x=15.35, y=.9, scale=.65)
]
def set_position(obj: RectXObj, x: float, y: float, scale: float) -> None:
obj.x = cm_to_point(x)
obj.y = cm_to_point(y)
obj.w *= scale
# Generate page 1
page1_xobj = PageMerge(PdfReader(TEMPLATE_PDF).pages[0])
for field in fields:
pdf = PdfReader(field.filename).pages[0]
page1_xobj.add(pdf)
set_position(page1_xobj[-1], field.x, field.y, field.scale)
if isinstance(field, QRCodeField):
qrcode = pdf
page1 = page1_xobj.render()
# Generate page 2
qrcode_xobj = PageMerge().add(qrcode)
set_position(qrcode_xobj[0], 1.3, 16.9, 2.15)
page2 = qrcode_xobj.render()
page2.MediaBox = page1.MediaBox
# Generate certificate document
PdfWriter().addpages([page1, page2]).write(CERTIFICATE_PDF)
# Remove temporary files.
for field in fields:
Path(field.filename).unlink()
return CERTIFICATE_PDF
def sizepage(page):
result = PageMerge()
result.add(page)
return result[0].w, result[0].h
