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