def print_on_layout(report_path, layout_path): if not pdfrw: raise XlwingsError( "Couldn't find the 'pdfrw' package, which is required when using 'layout'." ) report = pdfrw.PdfReader(report_path) layout = pdfrw.PdfReader(layout_path) for ix, page in enumerate(report.pages): if len(layout.pages) == 1: # Same layout for whole report layout_page_ix = 0 elif len(report.pages) == len(layout.pages): # Every report page has a corresponding page in the layout layout_page_ix = ix else: raise XlwingsError( "The layout PDF must either be a single page or have the " f"same number of pages as the report (report: {len(report.pages)}, " f"layout: {len(layout.pages)})") merge = pdfrw.PageMerge().add(layout.pages[layout_page_ix])[0] pdfrw.PageMerge(page).add(merge, prepend=True).render() # Changing log level as the exported PDFs from Excel aren't fully compliant and # would log the following: # [WARNING] tokens.py:221 Did not find PDF object (12, 0) (...) logging.getLogger("pdfrw").setLevel(logging.CRITICAL) pdfrw.PdfWriter(report_path, trailer=report).write()
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict, signature_path): pdf = pdfrw.PdfReader(input_pdf_path) annotations = pdf.pages[0][ANNOT_KEY] for annotation in annotations: if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY: if annotation[ANNOT_FIELD_KEY]: key = annotation[ANNOT_FIELD_KEY][1:-1] if key in data_dict.keys(): if data_dict[key] == '/YES': annotation.update( pdfrw.PdfDict(AS=pdfrw.PdfName('On'), V=pdfrw.PdfName('On'))) else: annotation.update( pdfrw.PdfDict(V='{}'.format(data_dict[key]))) sgn = pdfrw.PageMerge().add(pdfrw.PdfReader(signature_path).pages[0])[0] sgn.scale(0.3) sgn.y += 100 sgn.x += 380 pdfrw.PageMerge(pdf.pages[0]).add(sgn, prepend='underneath').render() pdf.Root.AcroForm.update( pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true'))) pdfrw.PdfWriter().write(output_pdf_path, pdf)
def merge(self, canvas_data, template): overlay_pdf = pdfrw.PdfReader(canvas_data) for page, data in zip(template.pages, overlay_pdf.pages): overlay = pdfrw.PageMerge().add(data)[0] pdfrw.PageMerge(page).add(overlay).render() form = io.BytesIO() pdfrw.PdfWriter().write(form, template) form.seek(0) return form
def overlayCanvas2Pdf(canvasBuffer, underneath, inFilePath): canvasBuffer.seek(0) pdfOverlay = pdfrw.PdfReader(canvasBuffer) overlayPage = pdfrw.PageMerge().add(pdfOverlay.pages[0])[0] pdfInput = pdfrw.PdfReader(inFilePath) for page in pdfInput.pages: pdfrw.PageMerge(page).add(overlayPage, prepend=underneath).render() # return pdfInput
def merge(overlay_canvas: io.BytesIO, template_path: str) -> io.BytesIO: template_pdf = pdfrw.PdfReader(template_path) overlay_pdf = pdfrw.PdfReader(overlay_canvas) for page, data in zip(template_pdf.pages, overlay_pdf.pages): overlay = pdfrw.PageMerge().add(data)[0] pdfrw.PageMerge(page).add(overlay).render() form = io.BytesIO() pdfrw.PdfWriter().write(form, template_pdf) form.seek(0) return form
def merge(overlay_canvases, template_path): template_pdf = pdfrw.PdfReader(template_path) overlay_pdfs = [pdfrw.PdfReader(x) for x in overlay_canvases] for page, data in zip(template_pdf.pages, overlay_pdfs): overlay = pdfrw.PageMerge().add(data.pages[0])[0] pdfrw.PageMerge(page).add(overlay).render() form = io.BytesIO() pdfrw.PdfWriter().write(form, template_pdf) form.seek(0) return form
def merge(overlay_canvas: io.BytesIO, template_path: str, page) -> io.BytesIO: template_pdf = pdfrw.PdfReader(template_path) overlay_pdf = pdfrw.PdfReader(overlay_canvas) data = overlay_pdf.pages[0] for page in [template_pdf.pages[page], ]: overlay = pdfrw.PageMerge().add(data)[0] pdfrw.PageMerge(page).add(overlay).render() form = io.BytesIO() pdfrw.PdfWriter().write(form, template_pdf) form.seek(0) return form
def merge_pdfs(self, form_pdf, overlay_pdf, output): form = pdfrw.PdfReader(form_pdf) olay = pdfrw.PdfReader(overlay_pdf) for form_page, overlay_page in zip(form.pages, olay.pages): merge_obj = pdfrw.PageMerge() overlay = merge_obj.add(overlay_page)[0] pdfrw.PageMerge(form_page).add(overlay).render() writer = pdfrw.PdfWriter() writer.write(output, form)
def merge_pdfs(self, form_pdf, output): """ Merge the specified fillable form PDF with the overlay PDF and save the output """ form = pdfrw.PdfReader(form_pdf) olay = pdfrw.PdfReader(self.tmp) for form_page, overlay_page in zip(form.pages, olay.pages): merge_obj = pdfrw.PageMerge() overlay = merge_obj.add(overlay_page)[0] pdfrw.PageMerge(form_page).add(overlay).render() writer = pdfrw.PdfWriter() writer.write(output, form)
def watermark_it(file_to_be_watermarked, file_containing_watermark): # Reading the file which has to be watermarked and storing it as an object base_file_object = pdfrw.PdfReader(file_to_be_watermarked) # Initialising a writer object writer_object = pdfrw.PdfWriter() # Reading the file which contains the watermark and storing it as an object watermark_object = pdfrw.PdfReader(file_containing_watermark) # Extracting the watermark from the watermark object watermark = watermark_object.pages[0] total_pages_in_base_file = len(base_file_object.pages) # Main logic to add watermark to all pages of the pdf for page in range(total_pages_in_base_file): # Creating a merge object for all the pages of the pdf merge_object = pdfrw.PageMerge(base_file_object.pages[page]) # Adding the watermark to all the pages through the merge object merge_object.add(watermark).render() # Creating an output file with modified name watermarked_output = ( "watermarked_" + file_to_be_watermarked.split(".pdf")[0] + ".pdf" ) # Writing the merged base file object to the output file writer_object.write(watermarked_output, base_file_object) print("Your pdf file has been successfully watermarked!!!!")
def merge(overlay, basename): ''' Merge the overlay with the original form, and return the result. ''' input_pdf_path = os.path.join('templates', basename) template_pdf = pdfrw.PdfReader(input_pdf_path) overlay_pdf = pdfrw.PdfReader(overlay) for page, data in zip(template_pdf.pages, overlay_pdf.pages): overlay = pdfrw.PageMerge().add(data)[0] pdfrw.PageMerge(page).add(overlay).render() form = io.BytesIO() pdfrw.PdfWriter().write(form, template_pdf) form.seek(0) return form
def watermarkAndSave(figureName, outputPath, subtitle=None, verticalLabel=40): # CREATE WATERMARK AND SAVE PDF FILE; watermark = canvas.Canvas("dummy.pdf") watermark.setFont("Helvetica", 20) watermark.drawString(10, verticalLabel, figureName) if subtitle: watermark.setFont("Helvetica", 14) watermark.drawString(20, verticalLabel - 20, subtitle) watermark.save() #outputPath = "graphs/TGONDIILOCI_%s.pdf" % gene # JOIN WATERMARK WITH OUTPUT base = pdfrw.PdfReader(outputPath) watermark = pdfrw.PdfReader("dummy.pdf").pages[0] merger = pdfrw.PageMerge(base.pages[0]) merger.add(watermark).render() writer = pdfrw.PdfWriter() writer.write(outputPath, base) os.remove("dummy.pdf")
def merge_pdfs(child, output): create_overlay(child) overlay_path = child.child_id + "_overlay.pdf" form_pdf = child.child_id + ".pdf" form = pdfrw.PdfReader("health_forms/" + form_pdf) olay = pdfrw.PdfReader(overlay_path) for form_page, overlay_page in zip(form.pages, olay.pages): merge_obj = pdfrw.PageMerge() overlay = merge_obj.add(overlay_page)[0] pdfrw.PageMerge(form_page).add(overlay).render() writer = pdfrw.PdfWriter() writer.write(output, form) if os.path.exists(overlay_path): os.remove(overlay_path)
def signaturemerger(path, signature, output, data_dict): base_pdf = pdfrw.PdfReader(path) signature_pdf = pdfrw.PdfReader(signature) mark = signature_pdf.pages[0] merger = pdfrw.PageMerge(base_pdf.pages[2]) merger.add(mark).render() annotate_pdf(base_pdf, data_dict) writer = pdfrw.PdfWriter() writer.write(output, base_pdf)
def draw_image(self, page_number, image_file, x, y, width, height, rotation=0): image_path = os.path.join(current.request.folder, "temp", uuid.uuid4().hex + ".jpg") with open(image_path, "wb+") as f: f.write(image_file.read()) if rotation: image = Image.open(image_path) image.rotate(rotation, expand=True).save(image_path) layer_path = os.path.join(current.request.folder, "temp", uuid.uuid4().hex + ".pdf") canv = canvas.Canvas(layer_path, pagesize=(self._LAYER_SIZE_X, self._LAYER_SIZE_Y)) canv.drawImage(image_path, x, y, width=width, height=height) canv.save() layer = pdfrw.PdfReader(layer_path) output_file = pdfrw.PdfFileWriter() input_path = os.path.join(current.request.folder, "temp", uuid.uuid4().hex + ".pdf") with open(input_path, "wb+") as f: f.write(self.pdf_stream) input_file = pdfrw.PdfReader(input_path) for i in range(len(input_file.pages)): if i == page_number - 1: merger = pdfrw.PageMerge(input_file.pages[i]) merger.add(layer.pages[0]).render() output_file.write(self._final_path_with_image, input_file) with open(self._final_path_with_image, "rb+") as f: self.pdf_stream = f.read() os.remove(image_path) os.remove(layer_path) os.remove(input_path) os.remove(self._final_path_with_image) return self
def create_watermark(cls, doc_pdf: bytes) -> bytes: if cls._watermark is None: return doc_pdf trailer = pdfrw.PdfFileReader(fdata=doc_pdf) for page in trailer.pages: pdfrw.PageMerge(page).add( cls._watermark, prepend=cls._underneath, ).render() stream = io.BytesIO() pdfrw.PdfWriter(stream, trailer=trailer).write() result_pdf = stream.getvalue() stream.close() return result_pdf
def merge_watermarks_with_pdf( pdf: bytes, watermarks: List[bytes], ) -> bytes: """Merges watermarks with PDF.""" pdf_file = pdfrw.PdfReader(fdata=pdf) for i in range(len(pdf_file.pages)): if watermarks[i]: watermark = pdfrw.PdfReader(fdata=watermarks[i]) if len(watermark.pages): merger = pdfrw.PageMerge(pdf_file.pages[i]) merger.add(watermark.pages[0]).render() return Utils().generate_stream(pdf_file)
def merge_pdfrw(filename1, filename2, ofilename): import pdfrw # PdfReader isn't usable as context-manager pdf1, pdf2 = (pdfrw.PdfReader(x) for x in (filename1, filename2)) w = pdfrw.PdfWriter() for page1, page2 in zip(pdf1.pages, pdf2.pages): m = pdfrw.PageMerge(page1) m.add(page2) m.render() w.addpage(page1) # is sufficient if both files contain the same number of pages: # w.write(ofilename, pdf1) n1, n2 = len(pdf1.pages), len(pdf2.pages) if n1 != n2: for page in (pdf2.pages[n1:] if n1 < n2 else pdf1.pages[n2:]): w.addpage(page) w.write(ofilename)
def draw_text( self, text: str, page_number: int, x: Union[float, int], y: Union[float, int], ) -> "_PyPDFForm": """Draw a text on a PDF form.""" self._validate_template(self.stream) self._validate_draw_text_inputs(text, page_number, x, y) input_file = pdfrw.PdfReader(fdata=self.stream) canv_buff = BytesIO() c = canv.Canvas( canv_buff, pagesize=( float(input_file.pages[page_number - 1].MediaBox[2]), float(input_file.pages[page_number - 1].MediaBox[3]), ), ) c.drawString(x, y, text) c.save() canv_buff.seek(0) output_file = pdfrw.PdfFileWriter() for i in range(len(input_file.pages)): if i == page_number - 1: merger = pdfrw.PageMerge(input_file.pages[i]) merger.add( pdfrw.PdfReader(fdata=canv_buff.read()).pages[0]).render() result_stream = BytesIO() output_file.write(result_stream, input_file) result_stream.seek(0) self.stream = result_stream.read() canv_buff.close() result_stream.close() return self
def draw_image( self, image_stream: bytes, page_number: int, x: Union[float, int], y: Union[float, int], width: Union[float, int], height: Union[float, int], rotation: Union[float, int], ) -> "_PyPDFForm": """Draw an image on a PDF form.""" self._validate_template(self.stream) self._validate_draw_image_inputs(page_number, x, y, width, height, rotation) input_file = pdfrw.PdfReader(fdata=self.stream) buff = BytesIO() buff.write(image_stream) buff.seek(0) try: image = Image.open(buff) except Exception: raise InvalidImageError image_buff = BytesIO() image.rotate(rotation, expand=True).save(image_buff, format=image.format) image_buff.seek(0) canv_buff = BytesIO() c = canv.Canvas( canv_buff, pagesize=( float(input_file.pages[page_number - 1].MediaBox[2]), float(input_file.pages[page_number - 1].MediaBox[3]), ), ) c.drawImage(ImageReader(image_buff), x, y, width=width, height=height) c.save() canv_buff.seek(0) output_file = pdfrw.PdfFileWriter() for i in range(len(input_file.pages)): if i == page_number - 1: merger = pdfrw.PageMerge(input_file.pages[i]) merger.add( pdfrw.PdfReader(fdata=canv_buff.read()).pages[0]).render() result_stream = BytesIO() output_file.write(result_stream, input_file) result_stream.seek(0) self.stream = result_stream.read() buff.close() image_buff.close() canv_buff.close() result_stream.close() return self
def _fill_pdf_canvas( self, template_stream: bytes, text_x_offset: Union[float, int], text_y_offset: Union[float, int], ) -> bytes: """Fill a PDF form by drawing on a reportlab canvas.""" template_pdf = pdfrw.PdfReader(fdata=template_stream) layers = [] for i in range(len(template_pdf.pages)): layer = BytesIO() layers.append(layer) c = canv.Canvas( layer, pagesize=( float(template_pdf.pages[i].MediaBox[2]), float(template_pdf.pages[i].MediaBox[3]), ), ) elements = template_pdf.pages[i][self._ANNOT_KEY] if elements: for j in reversed(range(len(elements))): element = elements[j] c.setFont(self._CANVAS_FONT, self._GLOBAL_FONT_SIZE) if self._GLOBAL_FONT_COLOR != (0, 0, 0): c.setFillColorRGB( self._GLOBAL_FONT_COLOR[0], self._GLOBAL_FONT_COLOR[1], self._GLOBAL_FONT_COLOR[2], ) if (element[self._SUBTYPE_KEY] == self._WIDGET_SUBTYPE_KEY and element[self._ANNOT_FIELD_KEY]): key = element[self._ANNOT_FIELD_KEY][1:-1] if key in self._data_dict.keys(): if self._data_dict[key] in [ pdfrw.PdfName.Yes, pdfrw.PdfName.Off, ]: element.update( pdfrw.PdfDict(AS=self._data_dict[key], Ff=pdfrw.PdfObject(1))) else: max_text_length = self._MAX_TXT_LENGTH x_offset = text_x_offset y_offset = text_y_offset _element = self.elements[key] if _element.type == "text": if _element.font_size: c.setFont(self._CANVAS_FONT, _element.font_size) if _element.font_color: c.setFillColorRGB( _element.font_color[0], _element.font_color[1], _element.font_color[2], ) if _element.text_x_offset: x_offset = _element.text_x_offset if _element.text_y_offset: y_offset = _element.text_y_offset if _element.text_wrap_length: max_text_length = _element.text_wrap_length coordinates = element[self._ANNOT_RECT_KEY] elements.pop(j) if len(self._data_dict[key]) < max_text_length: c.drawString( float(coordinates[0]) + x_offset, (float(coordinates[1]) + float(coordinates[3])) / 2 - 2 + y_offset, self._data_dict[key], ) else: txt_obj = c.beginText(0, 0) start = 0 end = max_text_length while end < len(self._data_dict[key]): txt_obj.textLine( (self._data_dict[key][start:end])) start += max_text_length end += max_text_length txt_obj.textLine( self._data_dict[key][start:]) c.saveState() c.translate( float(coordinates[0]) + x_offset, (float(coordinates[1]) + float(coordinates[3])) / 2 - 2 + y_offset, ) c.drawText(txt_obj) c.restoreState() else: elements.pop(j) c.save() layer.seek(0) for i in range(len(template_pdf.pages)): layer_pdf = pdfrw.PdfReader(layers[i]) input_page = template_pdf.pages[i] merger = pdfrw.PageMerge(input_page) if len(layer_pdf.pages) > 0: merger.add(layer_pdf.pages[0]).render() layers[i].close() result_stream = BytesIO() pdfrw.PdfWriter().write(result_stream, template_pdf) result_stream.seek(0) result = result_stream.read() result_stream.close() return result
def set_watermark_file(cls, watermark_filename: Optional[str]): if watermark_filename is None: cls._watermark = None cls._watermark = pdfrw.PageMerge().add( pdfrw.PdfReader(fname=watermark_filename).pages[0], )[0]
def set_watermark_bytes(cls, watermark_pdf: Optional[bytes]): if watermark_pdf is None: cls._watermark = None cls._watermark = pdfrw.PageMerge().add( pdfrw.PdfReader(fdata=watermark_pdf).pages[0], )[0]
def generateFloor(self): pdfmetrics.registerFont(TTFont('THSarabunNew', 'THSarabunNew.ttf')) y = 792.52 Building = self.ui.comboBox.currentText() Date = self.ui.dateEdit.date().toString("dd/MM/yyyy") Floor = self.ui.floor.text() self.PicPathFloor = { 'Pic1': self.ui.Pic1.topath(), 'Pic2': self.ui.Pic2.topath(), 'Pic3': self.ui.Pic3.topath(), 'Pic4': self.ui.Pic4.topath(), 'Pic5': self.ui.Pic5.topath(), 'Pic6': self.ui.Pic6.topath(), 'Pic7': self.ui.Pic7.topath(), 'Pic8': self.ui.Pic8.topath(), 'Pic9': self.ui.Pic9.topath(), 'Pic10': self.ui.Pic10.topath(), } A1 = self.ui.A1.text() A2 = self.ui.A2.text() N1 = self.ui.N1.text() N2 = self.ui.N2.text() Location = A1 + ', ' + A2 + ' - ' + N1 + ', ' + N2 can = canvas.Canvas('File_merge.pdf', pagesize=(A4)) can.setFillColorRGB(0, 0, 0) can.setFont("Helvetica", 20) if self.ui.CC1.isChecked(): can.drawString(195, y - 630, u'\u2713') else: can.drawString(195, y - 649, u'\u2713') if self.ui.DL1.isChecked(): can.drawString(167, y - 676, u'\u2713') elif self.ui.DL2.isChecked(): can.drawString(275, y - 676, u'\u2713') elif self.ui.DL3.isChecked(): can.drawString(420, y - 676, u'\u2713') can.setFont("THSarabunNew", 14) can.drawString(128, y - 149, Building) can.drawString(433, y - 93, Date) can.drawString(323, y - 120, Floor) can.drawString(425, y - 120, Location) can.drawString(128, y - 214, N1) can.drawString(128, y - 430, N2) can.drawString(166, y - 190, A1) can.drawString(440, y - 190, A2) if self.PicPathFloor['Pic1'] != '': can.drawImage(self.PicPathFloor['Pic1'], 72, y - 597, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic2'] != '': can.drawImage(self.PicPathFloor['Pic2'], 315, y - 597, width=240, height=140, preserveAspectRatio=True) can.drawString(135, y - 710, self.ui.textEdit.toPlainText()) can.showPage() can.setFillColorRGB(0, 0, 0) can.setFont("THSarabunNew", 14) can.drawString(128, y - 149, Building) can.drawString(433, y - 93, Date) can.drawString(323, y - 120, Floor) can.drawString(425, y - 120, Location) if self.PicPathFloor['Pic3'] != '': can.drawImage(self.PicPathFloor['Pic3'], 72, y - 315, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic4'] != '': can.drawImage(self.PicPathFloor['Pic4'], 315, y - 315, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic5'] != '': can.drawImage(self.PicPathFloor['Pic5'], 72, y - 460, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic6'] != '': can.drawImage(self.PicPathFloor['Pic6'], 315, y - 460, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic7'] != '': can.drawImage(self.PicPathFloor['Pic7'], 72, y - 605, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic8'] != '': can.drawImage(self.PicPathFloor['Pic8'], 315, y - 605, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic9'] != '': can.drawImage(self.PicPathFloor['Pic9'], 72, y - 750, width=240, height=140, preserveAspectRatio=True) if self.PicPathFloor['Pic10'] != '': can.drawImage(self.PicPathFloor['Pic10'], 315, y - 750, width=240, height=140, preserveAspectRatio=True) can.save() Outpath = os.path.join( BASE_DIR, Building + '_' + Location + '_' + Floor + '.pdf') base_pdf = pdfrw.PdfReader('Floor.pdf') pdfrw.PdfWriter().write('Temp.pdf', base_pdf) base = pdfrw.PdfReader('Temp.pdf') watermark_pdf = pdfrw.PdfReader('File_merge.pdf') for page in range(len(base.pages)): mark = watermark_pdf.pages[page] merger = pdfrw.PageMerge(base.pages[page]) merger.add(mark).render() writer = pdfrw.PdfWriter() writer.write('Temp.pdf', base) inpfn = 'Temp.pdf' out = pdfrw.PdfWriter() write = pdfrw.PdfReader(inpfn) if self.PicPathFloor['Pic3'] == '': out.addpage(write.pages[0]) out.write(Outpath) else: out.addpages(write.pages) out.write(Outpath) os.remove("Temp.pdf")
def generateBeam(self): pdfmetrics.registerFont(TTFont('THSarabunNew', 'THSarabunNew.ttf')) y = 792.52 Building = self.ui.comboBox3.currentText() Date = self.ui.dateEdit3.date().toString("dd/MM/yyyy") Floor = self.ui.floor3.text() self.PicPathBeam = { 'Pic1': self.ui.Pic1_3.topath(), 'Pic2': self.ui.Pic2_3.topath(), 'Pic3': self.ui.Pic3_3.topath(), 'Pic4': self.ui.Pic4_3.topath(), 'Pic5': self.ui.Pic5_3.topath(), 'Pic6': self.ui.Pic6_3.topath(), 'Pic7': self.ui.Pic7_3.topath(), 'Pic8': self.ui.Pic8_3.topath(), 'Pic9': self.ui.Pic9_3.topath(), 'Pic10': self.ui.Pic10_3.topath(), } A1 = self.ui.A1_3.text() N1 = self.ui.N1_3.text() Location = A1 + N1 can = canvas.Canvas('File_merge.pdf', pagesize=(A4)) can.setFillColorRGB(0, 0, 0) can.setFont("Helvetica", 20) if self.ui.CC1_3.isChecked(): can.drawString(195, y - 615, u'\u2713') elif self.ui.CC2_3.isChecked(): can.drawString(386, y - 615, u'\u2713') elif self.ui.CC3_3.isChecked(): can.drawString(195, y - 632, u'\u2713') if self.ui.DL1_3.isChecked(): can.drawString(167, y - 668, u'\u2713') elif self.ui.DL2_3.isChecked(): can.drawString(275, y - 668, u'\u2713') elif self.ui.DL3_3.isChecked(): can.drawString(420, y - 668, u'\u2713') can.setFont("THSarabunNew", 14) can.drawString(128, y - 149, Building) can.drawString(433, y - 93, Date) can.drawString(323, y - 120, Floor) can.drawString(425, y - 120, Location) if self.PicPathBeam['Pic1'] != '': can.drawImage(self.PicPathBeam['Pic1'], 72, y - 580, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic2'] != '': can.drawImage(self.PicPathBeam['Pic2'], 315, y - 580, width=240, height=140, preserveAspectRatio=True) can.drawString(135, y - 710, self.ui.remark3.toPlainText()) can.showPage() can.setFillColorRGB(0, 0, 0) can.setFont("THSarabunNew", 14) can.drawString(128, y - 149, Building) can.drawString(433, y - 93, Date) can.drawString(323, y - 120, Floor) can.drawString(425, y - 120, Location) if self.PicPathBeam['Pic3'] != '': can.drawImage(self.PicPathBeam['Pic3'], 72, y - 315, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic4'] != '': can.drawImage(self.PicPathBeam['Pic4'], 315, y - 315, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic5'] != '': can.drawImage(self.PicPathBeam['Pic5'], 72, y - 460, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic6'] != '': can.drawImage(self.PicPathBeam['Pic6'], 315, y - 460, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic7'] != '': can.drawImage(self.PicPathBeam['Pic7'], 72, y - 605, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic8'] != '': can.drawImage(self.PicPathBeam['Pic8'], 315, y - 605, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic9'] != '': can.drawImage(self.PicPathBeam['Pic9'], 72, y - 750, width=240, height=140, preserveAspectRatio=True) if self.PicPathBeam['Pic10'] != '': can.drawImage(self.PicPathBeam['Pic10'], 315, y - 750, width=240, height=140, preserveAspectRatio=True) can.save() Outpath = os.path.join( BASE_DIR, Building + '_' + Location + '_' + Floor + '.pdf') base_pdf = pdfrw.PdfReader('Beam.pdf') pdfrw.PdfWriter().write('Temp.pdf', base_pdf) base = pdfrw.PdfReader('Temp.pdf') watermark_pdf = pdfrw.PdfReader('File_merge.pdf') for page in range(len(base.pages)): mark = watermark_pdf.pages[page] merger = pdfrw.PageMerge(base.pages[page]) merger.add(mark).render() writer = pdfrw.PdfWriter() writer.write('Temp.pdf', base) inpfn = 'Temp.pdf' out = pdfrw.PdfWriter() write = pdfrw.PdfReader(inpfn) if self.PicPathBeam['Pic3'] == '': out.addpage(write.pages[0]) out.write(Outpath) else: out.addpages(write.pages) out.write(Outpath) os.remove("Temp.pdf")
import sys, os, pdfrw writer = pdfrw.PdfWriter() soma = 0 for page in pdfrw.PdfReader('Doc1.pdf').pages: for y in [0, 0.5]: soma = soma + 1 newpage = pdfrw.PageMerge() newpage.add(page, viewrect=(0, y, 1, 0.5)) writer = pdfrw.PdfWriter() writer.addpages([newpage.render()]) writer.write(f'divididos/output{soma}.pdf') print()
def main(): parser = argparse.ArgumentParser( description= "Add links to sci-hub for all hyperlinks with DOIs found in the article" ) parser.add_argument('inputfile', type=str, help='input pdf') oparser = parser.add_mutually_exclusive_group() oparser.add_argument('outputfile', nargs='?', type=str, help='output pdf') oparser.add_argument( '-i', metavar='extension', nargs='?', type=str, help= 'edit file inplace (save a backup with specified extension if provided)' ) args = parser.parse_args() if (not args.outputfile) and (not args.i): print("Error: no outputfile nor inplace option provided") exit(-1) try: inputpdf = pdfrw.PdfReader(args.inputfile) except pdfrw.errors.PdfParseError: print("Error when reading the PDF, trying to fix with ghostscript...", end='') tmp = tempfile.NamedTemporaryFile(dir='.', suffix='.pdf') tmp_name = tmp.name subprocess.run([ "gs", "-o", tmp_name, "-q", "-sDEVICE=pdfwrite", "-dPDFSETTINGS=/prepress", "-dPRINTED=false", args.inputfile ], capture_output=True) inputpdf = pdfrw.PdfReader(tmp_name) print(" Success") logofile = os.path.join(os.path.dirname(__file__), "logo_raven.pdf") logo = pdfrw.PdfReader(logofile).pages[0] size_x = 15 size_y = None x_offset = 1 y_offset = 3 found_doi = set() for page in inputpdf.pages: if not page.Annots: # Nothing on this page continue for i in range(len(page.Annots)): annot = page.Annots[i] link = annot['/A'] if not link: continue if not ('/URI' in link): continue uri = link['/URI'].to_unicode() if ('https://doi.org' in uri) or ('http://doi.org' in uri) or ( 'https://dx.doi.org' in uri) or ('http://dx.doi.org' in uri): if uri in found_doi: # We already saw this DOI before continue found_doi.add(uri) # Find the sci-hub url newlink = pdfrw.objects.pdfstring.PdfString.from_unicode( uri.replace("dx.doi.org", "sci-hub.tw").replace("doi.org", "sci-hub.tw")) # Create a new hypertext link in the pdf # pdfrw does not provide functions for deep copy, so we have to improvise newannot = pdfrw.objects.pdfdict.PdfDict(annot) newannot.Subtype = annot['/Subtype'] newannot.P = annot['/P'] newannot.F = annot['/F'] newannot.BS = annot['/BS'] newannot.Border = annot['/Border'] newannot.A = pdfrw.objects.pdfdict.PdfDict(annot['/A']) newannot.A.URI = newlink newannot.Rect = pdfrw.objects.pdfarray.PdfArray(annot['/Rect']) # Scale the sci-hub logo so we can compute the position of this link wmark = pdfrw.PageMerge().add(logo)[0] if size_x: wmark.scale(size_x / wmark.w) elif size_y: wmark.scale(size_y / wmark.h) # Finish computing the position of the link and actually add it to the pdf xlink = float(annot['/Rect'][2]) ylink = float(annot['/Rect'][1]) hlink = float(annot['/Rect'][3]) - float(annot['/Rect'][1]) wlink = float(annot['/Rect'][2]) - float(annot['/Rect'][0]) newannot.Rect[0] = pdfrw.objects.pdfobject.PdfObject( str(xlink + x_offset)) newannot.Rect[2] = pdfrw.objects.pdfobject.PdfObject( str(wmark.w + xlink + x_offset)) wmark.x = float(newannot.Rect[0]) newannot.Rect[1] = pdfrw.objects.pdfobject.PdfObject( str(ylink + y_offset + hlink / 2 - wmark.h / 2)) newannot.Rect[3] = pdfrw.objects.pdfobject.PdfObject( str(ylink + y_offset + hlink / 2 + wmark.h / 2)) wmark.y = ylink + y_offset + hlink / 2 - wmark.h / 2 page.Annots.append(newannot) pdfrw.PageMerge(page).add(wmark).render() if args.i: tmp = tempfile.NamedTemporaryFile(dir='.', delete=False) pdfrw.PdfWriter(tmp, trailer=inputpdf).write() tmp.close() os.replace(args.inputfile, args.inputfile + '.' + args.i) os.replace(tmp.name, args.inputfile) else: pdfrw.PdfWriter(args.outputfile, trailer=inputpdf).write() print("%s: found %d DOI links" % (args.inputfile, len(found_doi)))
can.setFont("THSarabunNew", 14) can.drawString(128, y - 149, Building) can.drawString(433, y - 93, Date) can.drawString(323, y - 120, Floor) can.drawString(425, y - 120, Location) can.drawImage('IMG_0526.jpg', 72, y - 597, width=240, height=140, preserveAspectRatio=True) can.showPage() can.setFillColorRGB(0, 0, 0) can.setFont("THSarabunNew", 10) can.save() PATH = open('Floor.pdf') base_pdf = pdfrw.PdfReader('Floor.pdf') pdfrw.PdfWriter().write('Outpath.pdf', base_pdf) base = pdfrw.PdfReader('Outpath.pdf') watermark_pdf = pdfrw.PdfReader('File_merge.pdf') for page in range(len(base.pages)): mark = watermark_pdf.pages[page] merger = pdfrw.PageMerge(base.pages[page]) merger.add(mark).render() writer = pdfrw.PdfWriter() writer.write('Outpath.pdf', base)
def _fill_pdf_canvas(self): template_pdf = pdfrw.PdfReader(self._template_path) layers = [] for i in range(len(template_pdf.pages)): layer_path = os.path.join(current.request.folder, "temp", uuid.uuid4().hex + ".pdf") layers.append(layer_path) canv = canvas.Canvas(layer_path, pagesize=(self._LAYER_SIZE_X, self._LAYER_SIZE_Y)) canv.setFont(self._CANVAS_FONT, self._global_font_size) annotations = template_pdf.pages[i][self._ANNOT_KEY] if annotations: for j in reversed(range(len(annotations))): annotation = annotations[j] if (annotation[self._SUBTYPE_KEY] == self._WIDGET_SUBTYPE_KEY and annotation[self._ANNOT_FIELD_KEY]): key = annotation[self._ANNOT_FIELD_KEY][1:-1] if key in self._data_dict.keys(): if self._data_dict[key] in [ pdfrw.PdfName.Yes, pdfrw.PdfName.Off, ]: annotation.update( pdfrw.PdfDict(AS=self._data_dict[key], Ff=pdfrw.PdfObject(1))) else: coordinates = annotation[self._ANNOT_RECT_KEY] annotations.pop(j) if len(self._data_dict[key] ) < self._max_txt_length: canv.drawString( float(coordinates[0]), (float(coordinates[1]) + float(coordinates[3])) / 2 - 2, self._data_dict[key], ) else: txt_obj = canv.beginText(0, 0) start = 0 end = self._max_txt_length while end < len(self._data_dict[key]): txt_obj.textLine( (self._data_dict[key][start:end])) start += self._max_txt_length end += self._max_txt_length txt_obj.textLine( self._data_dict[key][start:]) canv.saveState() canv.translate( float(coordinates[0]), (float(coordinates[1]) + float(coordinates[3])) / 2 - 2, ) canv.drawText(txt_obj) canv.restoreState() else: annotations.pop(j) canv.save() pdfrw.PdfWriter().write(self._output_path, template_pdf) output_file = pdfrw.PdfFileWriter() input_file = pdfrw.PdfReader(self._output_path) for i in range(len(template_pdf.pages)): layer_pdf = pdfrw.PdfReader(layers[i]) os.remove(layers[i]) input_page = input_file.pages[i] merger = pdfrw.PageMerge(input_page) if len(layer_pdf.pages) > 0: merger.add(layer_pdf.pages[0]).render() output_file.write(self._final_path, input_file)