def addCover(self): w = 12.25 * inch + ((self.pageNum + 2) + (4 - (self.pageNum + 2) % 4)) * 0.002252 * inch c = canvas.Canvas(self.path + 'covers\\' + self.docName + "English-" + self.lang + '.pdf', pagesize=(w, 9.25 * inch)) c.setFillColorRGB(228 / 256, 240 / 256, 255 / 256) c.rect(0 * mm, 0 * inch, w, 9.25 * inch, stroke=0, fill=1) c.setFillColorRGB(5 / 256, 92 / 256, 157 / 256) c.rect(0 * mm, (121 / 96) * inch, w, (619 / 96) * inch, stroke=0, fill=1) if self.currentBookNum % 400 < 101: pages = PdfReader(self.path + 'frames\\' + 'Frame13.pdf').pages pages = [pagexobj(x) for x in pages] elif self.currentBookNum % 400 < 201: pages = PdfReader(self.path + 'frames\\' + 'Frame15.pdf').pages pages = [pagexobj(x) for x in pages] elif self.currentBookNum % 400 < 301: pages = PdfReader(self.path + 'frames\\' + 'Frame16.pdf').pages pages = [pagexobj(x) for x in pages] else: pages = PdfReader(self.path + 'frames\\' + 'Frame17.pdf').pages pages = [pagexobj(x) for x in pages] pages1 = PdfReader(self.path + 'frames\\' + 'Frame9.pdf').pages pages1 = [pagexobj(x) for x in pages1] c.translate(0, 0) c.doForm(makerl(c, pages[0])) c.translate(w - 6.125 * inch, 0) c.doForm(makerl(c, pages1[0])) c.setFillColorRGB(0 / 256, 0 / 256, 102 / 256) c.setFont("SegoeUI", 10) text = "English - " + self.lang c.drawString((25 / 96) * inch, 8.2 * inch, text) p = Paragraph(self.engTitle, self.styles['coverTitle']) p.wrapOn(c, (514 / 96) * inch, 3 * inch) p.drawOn(c, (25 / 96) * inch, 4 * inch) p = Paragraph(self.otherTitle, self.styles['coverTitle']) x, y = p.wrapOn(c, (514 / 96) * inch, 3 * inch) p.drawOn(c, (25 / 96) * inch, 3.7 * inch - y) p = Paragraph(self.coverSubTitle[0], self.styles['coverSubTitle']) p.wrapOn(c, 5.3 * inch, 1 * inch) p.drawOn(c, (25 / 96) * inch, 0.7 * inch) p = Paragraph(self.coverSubTitle[1], self.styles['coverSubTitle']) p.wrapOn(c, 5.3 * inch, 1 * inch) p.drawOn(c, (25 / 96) * inch, 0.5 * inch) c.save()
def __init__(self, controller): self.controller = controller self.selections = self.controller.selections self._set_packet_type_id() if self.packet_type_id: # flags that indicate whether each of the files that need to be checked # are being included in the packet self.check_files_included = {i : False for i in self.check_files_ids} self.addon_ids = [] self.missing_files = [] self.selected_reports = [] self.selected_report_attributes = [] self.selected_report_ids = [] self.output_path = '' self.output_path_print = '' self.packet_type = '' self.output_name = self.output_names[self.selections.type_option] self.is_liaison = ('Liaison' in self.selections.type_option) self.create_print_file = False self.total_pages = 0 self.blank_pdf_page = pagexobj(PdfReader(self.blank_pdf_path).pages[0]) self.pdf_converter = PdfConverter() self._open_excel()
def pdf_insert_doi_using_pdfrw(req_content, doi): input_file = io.BytesIO(req_content) pdf_buffer = io.BytesIO() reader = PdfReader(input_file) pages = [pagexobj(p) for p in reader.pages] canvas = Canvas(pdf_buffer) for page_num, page in enumerate(pages, start=1): canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw footer if page_num == 1: footer_text = "https://doi.org/{}".format(doi) canvas.saveState() canvas.setFont("Helvetica-Bold", 8) canvas.setFillColor(HexColor('#990100')) canvas.drawCentredString(page.BBox[2] / 2, 20, footer_text) canvas.restoreState() canvas.showPage() canvas.save() pdf_bytes = pdf_buffer.getbuffer() return pdf_bytes
def __init__(self, filename_or_object, width=None, height=None, kind='direct'): # from reportlab.lib.units import inch # If using StringIO buffer, set pointer to begining if hasattr(filename_or_object, 'read'): filename_or_object.seek(0) page = PdfReader(filename_or_object, decompress=False).pages[0] self.xobj = pagexobj(page) self.imageWidth = width self.imageHeight = height x1, y1, x2, y2 = self.xobj.BBox self._w, self._h = x2 - x1, y2 - y1 if not self.imageWidth: self.imageWidth = self._w if not self.imageHeight: self.imageHeight = self._h self.__ratio = float(self.imageWidth) / self.imageHeight if kind in ['direct', 'absolute'] or width == None or height == None: self.drawWidth = width or self.imageWidth self.drawHeight = height or self.imageHeight elif kind in ['bound', 'proportional']: factor = min(float(width) / self._w, float(height) / self._h) self.drawWidth = self._w * factor self.drawHeight = self._h * factor
def insert_text_output_pdf(pdf_file_path, target_coordinate, insert_text): """ 既存のPDFファイルに文字を挿入し、別名で出力します :param pdf_file_path: 既存のPDFファイルパス :param target_coordinate: テキストを挿入座標値(mm) :param insert_text: 挿入するテキスト :return: """ import numpy as np from pdfrw import PdfReader from pdfrw.buildxobj import pagexobj from pdfrw.toreportlab import makerl from reportlab.pdfgen import canvas from reportlab.pdfbase.cidfonts import UnicodeCIDFont from reportlab.pdfbase import pdfmetrics from reportlab.lib.units import mm from src.utils.time_util import get_now output_name = f"{get_now()}.pdf" cc = canvas.Canvas(output_name) fontname_g = "HeiseiKakuGo-W5" pdfmetrics.registerFont(UnicodeCIDFont(fontname_g)) cc.setFont(fontname_g, 16) page = PdfReader(pdf_file_path, decompress=False).pages pp = pagexobj(page[0]) cc.doForm(makerl(cc, pp)) target_coordinate_arr = np.squeeze(np.asarray(target_coordinate)) target_x, target_y = target_coordinate_arr[0], target_coordinate_arr[1] cc.drawString(target_x*mm, target_y*mm, insert_text) cc.showPage() cc.save()
def __init__(self, pdf_template_filename, name=None): # use first page as template page = PdfReader(pdf_template_filename).pages[0] self.page_template = pagexobj(page) # Scale it to fill the complete page self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2] self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3]
def op_w_input(input_fname=None, watermark_fname=None, outfn0=os.getcwd() + "/Watermarked_PDF_Files/", pdfdir=None, outdir='tmp'): # options=list # options.input_fname=input_fname # options.watermark_fname=watermark_fname # options.pdfdir=pdfdir if input_fname and watermark_fname: watermark = pagexobj( PdfReader(watermark_fname, decompress=False).pages[0]) # outfn = 'watermark.' + os.path.basename(options.input_fname) outfn = os.path.basename(outfn0) pages = PdfReader(input_fname, decompress=False).pages # output = PdfFileWriter() # # # for i in range(0,pages.getNumPages()): # p = pages.getPage(i) # wt=watermark.getPage(0) # wt.mergePage(p) # output.addPage(wt) # outputStream=open(Wm_f, 'wb') # # outputStream=StringIO.StringIO() # # output.write(open(Wm_f, 'wb')) # output.write(outputStream) # outputStream.close() test = PdfWriter().addpages([fixpage(x, watermark) for x in pages]) test.write(outfn0) elif pdfdir and watermark_fname: batch_watermark(pdfdir, watermark_fname, outdir) else: parser.print_help()
def fixpage(*pages): pages = [pagexobj(x) for x in pages] class PageStuff(tuple): pass x = y = 0 for i, page in enumerate(pages): index = '/P%s' % i shift_right = x and '1 0 0 1 %s 0 cm ' % x or '' stuff = PageStuff((index, page)) stuff.stream = 'q %s%s Do Q\n' % (shift_right, index) x += page.BBox[2] y = max(y, page.BBox[3]) pages[i] = stuff # Multiple copies of first page used as a placeholder to # get blank page on back. for p1, p2 in zip(pages, pages[1:]): if p1[1] is p2[1]: pages.remove(p1) return IndirectPdfDict( Type=PdfName.Page, Contents=PdfDict(stream=''.join(page.stream for page in pages)), MediaBox=PdfArray([0, 0, x, y]), Resources=PdfDict( XObject=PdfDict(pages), ), )
def pdf_generate_proc(file_template, file_pdf, receiver, price): sys.stderr.write("*** pdf_generate_proc *** start ***\n") # pdf_canvas = canvas.Canvas(file_pdf) # fontname_g = "HeiseiKakuGo-W5" pdfmetrics.registerFont(UnicodeCIDFont(fontname_g)) pdf_canvas.setFont(fontname_g, 16) # page = PdfReader(file_template, decompress=False).pages pp = pagexobj(page[0]) pdf_canvas.doForm(makerl(pdf_canvas, pp)) # today = datetime.today() str_today = today.strftime('%Y-%m-%d') # pdf_canvas.drawString(400, 800, str_today) pdf_canvas.drawString(100, 725, receiver) pdf_canvas.drawString(100, 680, str(price)) # draw_rect_proc(pdf_canvas) # pdf_canvas.showPage() pdf_canvas.save() # sys.stderr.write("*** pdf_generate_proc *** end ***\n") # str_res = "Supdf_canvasess" return str_res
def __init__(self, filename_or_object, width=None, height=None, kind="direct"): if hasattr(filename_or_object, "read"): filename_or_object.seek(0) page = PdfReader(filename_or_object, decompress=False).pages[0] self.xobj = pagexobj(page) self.dynamic = 0 # Actual image size x1, y1, x2, y2 = self.xobj.BBox imgw, imgh = x2 - x1, y2 - y1 self._imgw, self._imgh = imgw, imgh if kind in ["direct", "absolute"]: self.drawWidth = width or imgw self.drawHeight = height or imgh elif kind in ["percentage", "%"]: self.drawWidth = imgw * width * 0.01 self.drawHeight = imgh * height * 0.01 elif kind in ["bound", "proportional"]: w, h = width or imgw, height or imgh factor = min(float(w) / imgw, float(h) / imgh) self.drawWidth = imgw * factor self.drawHeight = imgh * factor elif kind in ["dynamic"]: self.dynamic = 1
def fixpage(*pages): pages = [pagexobj(x) for x in pages] class PageStuff(tuple): pass x = y = 0 for i, page in enumerate(pages): index = '/P%s' % i shift_right = x and '1 0 0 1 %s 0 cm ' % x or '' stuff = PageStuff((index, page)) stuff.stream = 'q %s%s Do Q\n' % (shift_right, index) x += page.BBox[2] y = max(y, page.BBox[3]) pages[i] = stuff # Multiple copies of first page used as a placeholder to # get blank page on back. for p1, p2 in zip(pages, pages[1:]): if p1[1] is p2[1]: pages.remove(p1) return IndirectPdfDict( Type=PdfName.Page, Contents=PdfDict(stream=''.join(page.stream for page in pages)), MediaBox=PdfArray([0, 0, x, y]), Resources=PdfDict(XObject=PdfDict(pages), ), )
def include_footer(input_file_path, output_file_path, link=None): # Get pages reader = PdfReader(input_file_path) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas(output_file_path) for page_num, page in enumerate(pages, start=1): # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw footer footer_text = f"This report is reproducible with FAIR data. Find the source datasets here: {link}" x = 80 canvas.saveState() canvas.setStrokeColorRGB(0, 0, 0) canvas.setLineWidth(0.5) canvas.line(66, 40, page.BBox[2] - 66, 40) canvas.setFont('Helvetica', 8) canvas.drawString(66, 25, footer_text) canvas.linkURL(link, (66, 25, page.BBox[2] - 66, 40)) canvas.restoreState() canvas.showPage() canvas.save()
def add_footer(input_file, output_file): logging.info("add_footer started") # Get pages reader = PdfReader("%s.pdf" % (input_file)) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas("%s.pdf" % (output_file)) pdfmetrics.registerFont( TTFont('SourceSansPro', 'SourceSansPro-Regular.ttf')) for page_num, page in enumerate(pages, start=1): # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw footer footer_text = "www.borderviolence.eu" x = 80 canvas.saveState() canvas.setStrokeColorRGB(0.19, 0.19, 0.19) canvas.setLineWidth(0.3) canvas.line(75, 78, page.BBox[2] - 66, 78) canvas.setFont('SourceSansPro', 10) canvas.setFillColor(HexColor(0x333333)) canvas.drawString(page.BBox[2] - x, 85, str(page_num)) canvas.drawString(page.BBox[2] - x - 436, 85, footer_text) canvas.restoreState() canvas.showPage() canvas.save() logging.info("PDF with footer %s.pdf was saved" % (output_file)) return 1
def edit_pdf(filePath): input_file = filePath output_file = filePath # Get pages reader = PdfReader(input_file) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas(output_file) for page_num, page in enumerate(pages, start=1): # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw header header_text = "Jhon institute" x = 180 canvas.saveState() canvas.setStrokeColorRGB(0, 0, 0) canvas.drawImage('input_logo.jpg', height=60, width=110,x=60, y=700) canvas.setFont('Times-Roman', 14) canvas.drawString(page.BBox[2] -x, 730, header_text) # Draw footer footer_text = "It’s easy to play any musical instrument: all you have to do is touch the right key at " \ "the right time and the instrument will play itself." x = 70 canvas.setStrokeColorRGB(0, 0, 0) canvas.setLineWidth(0.5) canvas.setFont('Times-Roman', 10) canvas.drawString(page.BBox[1] +x, 30, footer_text) canvas.restoreState() canvas.showPage() canvas.save()
def control_forms ( pieces, output ): """Write a pdf file to 'output', and generate control forms (one or more pages each) for 'pieces'. """ c = Canvas ( output, pagesize=letter ) pdf = PdfReader ( settings.ARTSHOW_BLANK_CONTROL_FORM ) xobj = pagexobj ( pdf.pages[0] ) rlobj = makerl ( c, xobj ) for artist, piecegroup in group_pieces_by_artist_and_n ( pieces, PIECES_PER_CONTROL_FORM ): c.doForm ( rlobj ) text_into_box ( c, settings.ARTSHOW_SHOW_YEAR, 2.4, 10.3, 3.05, 10.6 ) text_into_box ( c, unicode(artist.artistid), 6.6, 10.25, 8.0, 10.5 ) text_into_box ( c, artist.person.name, 1.7, 9.875, 4.1, 10.225, style=left_align_style ) text_into_box ( c, artist.artistname(), 1.7, 9.5, 4.1, 9.85, style=left_align_style ) text_into_box ( c, artist.person.address1 + " " + artist.person.address2, 1.7, 9.125, 4.1, 9.475, style=left_align_style ) text_into_box ( c, artist.person.city, 1.7, 8.75, 4.1, 9.1, style=left_align_style ) text_into_box ( c, artist.person.state, 1.7, 8.375, 4.1, 8.725, style=left_align_style ) text_into_box ( c, artist.person.postcode, 1.7, 8.0, 4.1, 8.35, style=left_align_style ) text_into_box ( c, artist.person.country, 1.7, 7.625, 4.1, 7.975, style=left_align_style ) text_into_box ( c, artist.person.phone, 1.7, 7.25, 4.1, 7.6, style=left_align_style ) text_into_box ( c, artist.person.email, 4.9, 9.875, 8.0, 10.225, style=left_align_style, fontSize=16 ) text_into_box ( c, ", ".join ( [agent.person.name for agent in artist.agent_set.all()] ), 5.9, 7.625, 8.0, 7.975, style=left_align_style ) for i, piece in enumerate(piecegroup): if piece is None: continue y0 = 6.45 - i*0.25 y1 = 6.675 - i*0.25 text_into_box ( c, unicode(piece.pieceid), 0.5, y0, 1.0, y1 ) text_into_box ( c, piece.name, 1.0, y0, 4.0, y1, style=left_align_style ) text_into_box ( c, yn(piece.adult), 4.0, y0, 4.5, y1 ) text_into_box ( c, priceornfs(piece.not_for_sale,piece.min_bid), 4.5, y0, 5.25, y1 ) text_into_box ( c, buynoworna(piece.buy_now), 5.25, y0, 6.0, y1 ) c.showPage () c.save ()
def add_footer(): input_file = "/tmp/merged.pdf" output_file = "/tmp/merged_footer.pdf" # Get pages reader = PdfReader(input_file) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas(output_file) for page_num, page in enumerate(pages, start=1): # # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) canvas.setFont("Helvetica", 10) if canvas._pagesize[0] > canvas._pagesize[1]: canvas.saveState() canvas.rotate(270) canvas.translate(-30, -A4[0] + 30) canvas.drawRightString( -10, A4[0], "%d de %d" % (canvas._pageNumber, len(pages))) canvas.restoreState() else: canvas.drawRightString( A4[0] - 60, 30, "%d de %d" % (canvas._pageNumber, len(pages))) canvas.showPage() canvas.save()
def create_card_face(c, domain, category, header_text, footer_text, frame_colour, content_pdf_fn, offset=0, key_ring=1): # Colour frame c.setFillColorRGB(frame_colour[0], frame_colour[1], frame_colour[2]) c.roundRect(0 + offset, 0, FACE_DIM[0], FACE_DIM[1], radius=OUTER_ROUNDED_RAD, stroke=0, fill=1) # Content space c.setFillColorRGB(1, 1, 1) c.roundRect(FACE_MARGINS[3] + offset, FACE_MARGINS[2], CONTENT_DIM[0], CONTENT_DIM[1], radius=INNER_ROUNDED_RAD, stroke=0, fill=1) # Key ring cut-out, 0 = none, 1 = left, 2 = right if key_ring == 1: c.circle(0, DOCUMENT_DIM[1], KEY_RING_RAD, stroke=0, fill=1) elif key_ring == 2: c.circle(DOCUMENT_DIM[0], DOCUMENT_DIM[1], KEY_RING_RAD, stroke=0, fill=1) # Domain / Caetgory text c.setFont('Helvetica', 10, leading = None) c.drawCentredString(FACE_DIM[0]/2 + offset, FACE_DIM[1] - 0.47*cm, '- ' + domain.title() + ' -') # c.drawCentredString(FACE_DIM[0]/2 + offset, FACE_DIM[1] - 0.47*cm, domain.title() + ' / ' + category.title()) # Header text c.setFont('Helvetica-Bold', 20, leading = None) c.drawCentredString(FACE_DIM[0]/2 + offset, FACE_DIM[1] - 1.23*cm, header_text) # Footer text c.setFont('Helvetica', 8, leading = None) c.drawCentredString(FACE_DIM[0]/2 + offset, 0.15*cm, footer_text) # Include contents c.setFillColorRGB(0, 0, 0) page = pagexobj(PdfReader(content_pdf_fn).pages[0]) c.saveState() c.translate(FACE_MARGINS[3] + offset, FACE_MARGINS[2]) c.doForm(makerl(c, page)) c.restoreState()
def __init__(self, filename): pages = PdfReader(filename).pages num_pages = len(pages) assert num_pages > 0 if num_pages > 1: warning.warn("PDF file %s has %d pages, using only the first." % (filename, num_pages)) self.pagexobj = pagexobj(pages[0])
def _set_pdf_pages(self): ''' Stores all the pages of each PDF as page objects. ''' for i in self.selected_reports: i.pdf_pages = [ pagexobj(p) for p in PdfReader(i.path).pages ]
def post(self, request): fontname_g = "HeiseiKakuGo-W5" pdfmetrics.registerFont(UnicodeCIDFont(fontname_g)) buffer = io.BytesIO() cc = canvas.Canvas(buffer) cc.setFont(fontname_g, 24) page = PdfReader('media/pdf/sample.pdf', decompress=False).pages pp = pagexobj(page[0]) # reader = PdfFileReader('media/pdf/sample.pdf') # writer = PdfFileWriter() test = { "test1": "test1", "test2": "S2", "test3": "テスト", "test4": [ { "key_label": "テスト1", "flag": True }, { "key_label": "テスト2", "flag": True }, { "key_label": "テスト3", "flag": True }, ] } a = request.data['test_list'] for i in a: self.test(cc, i.get('contents'), test) cc.doForm(makerl(cc, pp)) cc.showPage() cc.save() buffer.seek(0) # new_pdf = PdfFileReader(buffer) # existing_page = reader.getPage(0) # existing_page.mergePage(new_pdf.getPage(0)) # writer.addPage(existing_page) # new = io.BytesIO() # writer.write(new) # new.seek(0) # output_pdf = open('media/pdf/sample2.pdf', 'wb') r = PdfReader(buffer) y = PdfWriter() y.addpage(r.pages[0]) with open('media/pdf/sample2.pdf', 'wb') as f: y.write(f) # writer.write(output_pdf) # output_pdf.close() return Response({'detail': _('Successfully confirmed email.')}, status=status.HTTP_201_CREATED)
def __init__(self, filename): pages = PdfReader(filename).pages num_pages = len(pages) assert num_pages > 0 if num_pages > 1: warning.warn("PDF file %s has %d pages, using only the first." % ( filename, num_pages )) self.pagexobj = pagexobj(pages[0])
def _make_cover(self): name = f'{self.jurisdiction.id}_packet_cover.pdf' path = str(constants.TEMP_FILE_PATH.joinpath(name)) reader = PdfReader(self.blank_cover_path) page = pagexobj(reader.pages[0]) canvas = Canvas(path, pagesize=letter) canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) canvas.saveState() max_title_len = 15 max_title_font_size = 60 max_title_pixel = max_title_len * max_title_font_size x = 15 mid_x = x//2 y1 = 15 fs1 = 16 y2 = y1 + mid_x + fs1 fs2 = 36 y3 = y2 + mid_x + fs2 fs3 = max_title_font_size title = self.jurisdiction.name rep_info = self._get_rep_info() # draws the email and phone of the rep canvas.setFontSize(fs1) canvas.setFillGray(0.45) canvas.drawString(x=x, y=y1, text=f'{rep_info[0]} | {rep_info[1]}') canvas.setFont('Calibri', fs2) canvas.drawString( x=x, y=y2, text=f'Economic Review {self.selections.period}') canvas.setFillColorRGB(0, .23, .34) if len(title) > max_title_len: fs3 = max_title_pixel//len(title) canvas.setFontSize(fs3) canvas.drawString(x=x, y=y3, text=title) canvas.restoreState() canvas.showPage() canvas.save() self._set_path(self.check_files_ids['cover'], path)
def get_logo(filename, target_width, width_in_file, height_in_file): '''width_in_file and height_in_file can be in any matching units''' width_in_file = 191.87 height_in_file = 54.84 s = target_width / width_in_file target_height = height_in_file * s logo = PdfImage(pagexobj(PdfReader(filename).pages[0]), target_width, target_height) return logo
def process_file(f_input, f_watermark, f_output): watermark = pagexobj(PdfReader(f_watermark, decompress=False).pages[0]) pagestream = PdfReader(f_input, decompress=False) for page in pagestream.pages: watermark_page(page, watermark) PdfWriter().write(f_output, pagestream) return len(pagestream.pages)
def fix_pdf(fname, watermark_fname, indir, outdir): from os import mkdir, path if not path.exists(outdir): mkdir(outdir) watermark = pagexobj(PdfReader(watermark_fname).pages[0]) trailer = PdfReader(path.join(indir, fname)) for page in trailer.pages: fixpage(page, watermark) PdfWriter().write(path.join(outdir, fname), trailer) return len(trailer.pages)
def go(argv): inpfn, = argv outfn = '4up.' + os.path.basename(inpfn) pages = PdfReader(inpfn).pages pages = [pagexobj(x) for x in pages] canvas = Canvas(outfn) while pages: addpage(canvas, pages) canvas.save()
def load_pdf_as_form(canvas, path): """ Convert a pdf file into a reportlab object :param canvas: Reportlab Canvas object the form may be written to :param path: path to pdf file to open :return: a reportlab object that may be drawn using canvas.doForm(obj) """ pdf = PdfReader(path) xobj = pagexobj(pdf.pages[0]) reportlab_obj = makerl(canvas, xobj) return reportlab_obj
def __init__(self, pdf_template_filename, name=None): frames = [ Frame(0.85 * inch, 0.5 * inch, PAGE_WIDTH - 1.15 * inch, PAGE_HEIGHT - (1.5 * inch)) ] PageTemplate.__init__(self, name, frames) # use first page as template page = PdfReader(pdf_template_filename).pages[0] self.page_template = pagexobj(page) # Scale it to fill the complete page self.page_xscale = PAGE_WIDTH / self.page_template.BBox[2] self.page_yscale = PAGE_HEIGHT / self.page_template.BBox[3]
def read_and_double(inpfn): pages = PdfReader(inpfn, decompress=False).pages pages = [pagexobj(x) for x in pages] if len(pages) & 1: pages.append(pages[0]) # Sentinel -- get same size for back as front xobjs = [] while len(pages) > 2: xobjs.append((pages.pop(), pages.pop(0))) xobjs.append((pages.pop(0), pages.pop())) xobjs += [(x, ) for x in pages] return xobjs
def read_and_double(inpfn): pages = PdfReader(inpfn, decompress=False).pages pages = [pagexobj(x) for x in pages] if len(pages) & 1: pages.append(pages[0]) # Sentinel -- get same size for back as front xobjs = [] while len(pages) > 2: xobjs.append((pages.pop(), pages.pop(0))) xobjs.append((pages.pop(0), pages.pop())) xobjs += [(x,) for x in pages] return xobjs
def __init__(self, document, path): self.document = document self.pages = [] self.refs = [] template = PdfReader(path) letterhead_num = 1 for page in template.pages: xobject = XObject(self, pagexobj(page), name='Letterhead{}'.format(letterhead_num)) self.pages.append(xobject.form) letterhead_num += 1
def add_page_number( pdf_name, source_data_footext=ReportParameters.REFERENCE_DATA_TEXT, reference_footer_text=ReportParameters.REFERENCE_USE_FOOTER_TEXT): """ Args: pdf_name: source_data_footext: reference_footer_text: Returns: """ input_file = pdf_name output_file = pdf_name # Get pages reader = PdfReader(input_file) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas(output_file) for page_num, page in enumerate(pages, start=1): # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw footer page_number_footer_text = "Page %s of %s" % (page_num, len(pages)) x = 128 canvas.saveState() # canvas.setStrokeColorRGB(0, 0, 0) canvas.setLineWidth(0.5) canvas.line(66, 72, page.BBox[2] - 66, 72) canvas.setFont('Times-Roman', 10) canvas.drawString(x=(page.BBox[2] - x), y=60, text=page_number_footer_text) canvas.drawString(x=66, y=60, text=source_data_footext) canvas.drawString(x=66, y=45, text=reference_footer_text) canvas.restoreState() canvas.showPage() # Save pdf canvas.save()
def get(self, request, *args, **kwargs): fontname_g = "HeiseiKakuGo-W5" pdfmetrics.registerFont(UnicodeCIDFont(fontname_g)) buffer = io.BytesIO() cc = canvas.Canvas(buffer) page = PdfReader('media/pdf/sample.pdf', decompress=False).pages pp = pagexobj(page[0]) cc.doForm(makerl(cc, pp)) cc.setFont(fontname_g, 24) cc.drawString(0, 820, "テスト") cc.showPage() cc.save() buffer.seek(0) return FileResponse(buffer, as_attachment=True, filename='hello.pdf')
def __init__(self, pdf_template_filename, name=None): frames = [Frame( PAD, PAD, PAGE_WIDTH - 2 * PAD, PAGE_HEIGHT - 2 * PAD, )] PageTemplate.__init__(self, name, frames) # use first page as template page = PdfReader(pdf_template_filename, decompress=False).pages[0] self.page_template = pagexobj(page) # Scale it to fill the complete page self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2] self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3]
def go(inpfn, firstpage, lastpage): firstpage, lastpage = int(firstpage), int(lastpage) outfn = 'subset_%s_to_%s.%s' % (firstpage, lastpage, os.path.basename(inpfn)) pages = PdfReader(inpfn).pages pages = [pagexobj(x) for x in pages[firstpage-1:lastpage]] canvas = Canvas(outfn) for page in pages: canvas.setPageSize(tuple(page.BBox[2:])) canvas.doForm(makerl(canvas, page)) canvas.showPage() canvas.save()
def __init__(self, pdf_template_filename, name=None): frames = [Frame( 0.85 * inch, 0.5 * inch, PAGE_WIDTH - 1.15 * inch, PAGE_HEIGHT - (1.5 * inch) )] PageTemplate.__init__(self, name, frames) # use first page as template page = PdfReader(pdf_template_filename).pages[0] self.page_template = pagexobj(page) # Scale it to fill the complete page self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2] self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3]
def go(inpfn, firstpage, lastpage): firstpage, lastpage = int(firstpage), int(lastpage) outfn = 'subset_%s_to_%s.%s' % (firstpage, lastpage, os.path.basename(inpfn)) pages = PdfReader(inpfn, decompress=False).pages pages = [pagexobj(x) for x in pages[firstpage-1:lastpage]] canvas = Canvas(outfn) for page in pages: canvas.setPageSize(tuple(page.BBox[2:])) canvas.doForm(makerl(canvas, page)) canvas.showPage() canvas.save()
def go(inpfn, firstpage, lastpage): firstpage, lastpage = int(firstpage), int(lastpage) outfn = 'subset.' + os.path.basename(inpfn) pages = PdfReader(inpfn).pages pages = [pagexobj(x) for x in pages[firstpage - 1:lastpage]] canvas = Canvas(outfn) for page in pages: canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) canvas.showPage() canvas.save()
def __init__(self, bg_page, name=None): frames = [Frame( 22.0*mm, 13.0*mm, PAGE_WIDTH-30.0*mm, PAGE_HEIGHT-30.0*mm, )] PageTemplate.__init__(self, name, frames) self.page_template = pagexobj(bg_page) # scale to fill the complete page self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2] self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3] # store content and absolute position of paragraphs/primitives self.abspars = [] self.absprims = []
def __init__(self, filename, width=None, height=None, kind='bound', mask=None, lazy=True, srcinfo=None): Flowable.__init__(self) self._kind = kind page = PdfReader(filename, decompress=False).pages[0] self.xobj = pagexobj(page) self.imageWidth, self.imageHeight = imageWidth, imageHeight = self.xobj.w, self.xobj.h width = width or imageWidth height = height or imageHeight if kind in ['bound','proportional']: factor = min(float(width)/imageWidth,float(height)/imageHeight) width = factor * imageWidth height = factor * imageHeight self.drawWidth = width self.drawHeight = height
def labelbooklets( labels, pagecount, booklets="booklets.pdf", output="labeled_booklets.pdf", colfname="fname", collname="lname", colid="netID", ): """ Outputs a PDF containing labeled exams given a data frame of labels, a PDF of unlabeled booklets, and the number of pages in each exam. """ # Extract pages from booklet pdf pages = PdfReader(booklets, decompress=False).pages pagex = [pagexobj(i) for i in pages] # Set output path c = canvas.Canvas(output, pagesize=letter) # Select columns (order is important) labels = labels[[colfname, collname, colid]] # Truncate any string longer than 17 chars labels = labels.applymap(func="{:.17}".format) # Loop over all students to apply labels for (i, fname, lname, netid) in labels.itertuples(): # Set font to fixed-wdith and set font size c.setFont("Courier", 32) # Extract the first page of this student's exam c.doForm(makerl(c, pagex[i * pagecount])) c.drawString(76, 481, fname.upper(), charSpace=7.8) c.drawString(76, 418, lname.upper(), charSpace=7.8) c.drawString(76, 355, netid.upper(), charSpace=7.8) c.showPage() # Loop over the rest of the pages in this student's exam for page in pagex[i * pagecount + 1:(i + 1) * pagecount]: c.doForm(makerl(c, page)) c.showPage() # Save the PDF file after processing all students c.save() print("Attempting to save output to " + output)
def popup_getpopup_xobjs(): from pdfrw.buildxobj import pagexobj popups = {} toremove = [] for page in popup_pdf.pages: if page['/SYMIDX.POPUP']: popupid = page['/SYMIDX.POPUP'].decode() if popupid in popups: raise RuntimeError( "Duplicated /SYMIDX.POPUP: {}".format(popupid)) xobj = pagexobj(page) popups[popupid] = xobj toremove.append(page) popup_removepages(popup_pdf, toremove) return popups
def getPages(allpages, x, y, gap): # Number of pages to combine count = x * y # Pull pages off the list pages = [pagexobj(p) for p in allpages[:count]] del allpages[:count] # Out page size width_max = max(page.BBox[2] for page in pages) height_max = max(page.BBox[3] for page in pages) stream = [] xobjdict = PdfDict() line = y for index, page in enumerate(pages): width = (index % x) * width_max / x if not width: line = line - 1 height = line * height_max / y # Page number index = PdfName('P{}'.format(index)) format_stream = { "x": 1./x - gap, "y": 1./y - gap, "w": width, "h": height, "i": index } stream.append('q {x} 0 0 {y} {w} {h} cm {i} Do Q\n'.format(**format_stream)) xobjdict[index] = page return PdfDict( Type = PdfName.Page, Contents = PdfDict(stream=''.join(stream)), MediaBox = PdfArray([-1000*gap, -1000*gap, width_max, height_max]), Resources = PdfDict(XObject = xobjdict), )
def __init__(self, filename_or_object, width=None, height=None, kind='direct'): # If using StringIO buffer, set pointer to begining if hasattr(filename_or_object, 'read'): filename_or_object.seek(0) page = PdfReader(filename_or_object, decompress=False).pages[0] self.xobj = pagexobj(page) self.imageWidth = width self.imageHeight = height x1, y1, x2, y2 = self.xobj.BBox self._w, self._h = x2 - x1, y2 - y1 if not self.imageWidth: self.imageWidth = self._w if not self.imageHeight: self.imageHeight = self._h self.__ratio = float(self.imageWidth)/self.imageHeight if kind in ['direct','absolute'] or width==None or height==None: self.drawWidth = width or self.imageWidth self.drawHeight = height or self.imageHeight elif kind in ['bound','proportional']: factor = min(float(width)/self._w,float(height)/self._h) self.drawWidth = self._w*factor self.drawHeight = self._h*factor
def get4(allpages): # Pull a maximum of 4 pages off the list pages = [pagexobj(x) for x in allpages[:4]] del allpages[:4] x_max = max(page.BBox[2] for page in pages) y_max = max(page.BBox[3] for page in pages) stream = [] xobjdict = PdfDict() for index, page in enumerate(pages): x = x_max * (index & 1) / 2.0 y = y_max * (index <= 1) / 2.0 index = '/P%s' % index stream.append('q 0.5 0 0 0.5 %s %s cm %s Do Q\n' % (x, y, index)) xobjdict[index] = page return PdfDict( Type = PdfName.Page, Contents = PdfDict(stream=''.join(stream)), MediaBox = PdfArray([0, 0, x_max, y_max]), Resources = PdfDict(XObject = xobjdict), )
def adjust(page): page = pagexobj(page) assert page.BBox == [0, 0, 11 * 72, int(8.5 * 72)], page.BBox margin = 72 // 2 old_x, old_y = page.BBox[2] - 2 * margin, page.BBox[3] - 2 * margin new_x, new_y = 48 * 72, 36 * 72 ratio = 1.0 * new_x / old_x assert ratio == 1.0 * new_y / old_y index = '/BasePage' x = -margin * ratio y = -margin * ratio stream = 'q %0.2f 0 0 %0.2f %s %s cm %s Do Q\n' % (ratio, ratio, x, y, index) xobjdict = PdfDict() xobjdict[index] = page return PdfDict( Type = PdfName.Page, Contents = PdfDict(stream=stream), MediaBox = PdfArray([0, 0, new_x, new_y]), Resources = PdfDict(XObject = xobjdict), )
def __init__(self, filename_or_object, width=None, height=None, kind='direct'): if hasattr(filename_or_object, 'read'): filename_or_object.seek(0) page = PdfReader(filename_or_object, decompress=False).pages[0] self.xobj = pagexobj(page) self.dynamic = 0 # Actual image size x1, y1, x2, y2 = self.xobj.BBox imgw, imgh = x2 - x1, y2 - y1 self._imgw, self._imgh = imgw, imgh if kind in ['direct', 'absolute']: self.drawWidth = width or imgw self.drawHeight = height or imgh elif kind in ['percentage', '%']: self.drawWidth = imgw * width * 0.01 self.drawHeight = imgh * height * 0.01 elif kind in ['bound', 'proportional']: w, h = width or imgw, height or imgh factor = min(float(w) / imgw, float(h) / imgh) self.drawWidth = imgw * factor self.drawHeight = imgh * factor elif kind in ['dynamic']: self.dynamic = 1
def grid_overlay(infile, outfile=sys.stdout, pagesize=letter, lpi=10): """Read PDF file 'infile'. Generates a new PDF file to 'outfile' containing the first page (only) of infile, with a 'lpi' grid overlaid. """ c = Canvas(outfile, pagesize=pagesize) pdf = PdfReader(infile) xobj = pagexobj(pdf.pages[0]) rlobj = makerl(c, xobj) c.doForm(rlobj) xmax = 9 ymax = 12 thickline = 0.5 thinline = 0.1 for x in range(0, xmax): c.setLineWidth(thickline) for xx in range(0, lpi): x0 = (x + (float(xx) / lpi)) * inch c.line(x0, 0, x0, ymax * inch) c.setLineWidth(thinline) for y in range(0, ymax): c.setLineWidth(thickline) for yy in range(0, lpi): y0 = (y + (float(yy) / lpi)) * inch c.line(0, y0, xmax * inch, y0) c.setLineWidth(thinline) c.showPage() c.save()
def __init__(self, pdfpage, width=None, height=None, kind='direct',hAlign='LEFT',rotation=0): # If using StringIO buffer, set pointer to begining self.xobj = pagexobj(pdfpage) self.rotation = rotation self.imageWidth = width self.imageHeight = height x1, y1, x2, y2 = self.xobj.BBox self.hAlign = hAlign w, h = x2 - x1, y2 - y1 self._w = abs(w * cos(radians(rotation)) + h * sin(radians(rotation))) self._h = abs(w * sin(radians(rotation)) + h * cos(radians(rotation))) if not self.imageWidth: self.imageWidth = self._w if not self.imageHeight: self.imageHeight = self._h self.__ratio = float(self.imageWidth)/self.imageHeight if kind in ['direct','absolute'] or width==None or height==None: self.drawWidth = width or self.imageWidth self.drawHeight = height or self.imageHeight elif kind in ['bound','proportional']: factor = min(float(width)/self._w,float(height)/self._h) self.drawWidth = self._w*factor self.drawHeight = self._h*factor
def draw_card_face(self, c, card_face, domain, colour_scheme, frame_layout, page_nr, offset = 0): colour = colour_scheme[domain] # Colour frame c.setFillColorRGB(colour[0], colour[1], colour[2]) c.roundRect(0 + offset, 0, frame_layout['card']['width']*cm, frame_layout['card']['height']*cm, radius=frame_layout['border']['outer_corner_radius']*cm, stroke=0, fill=1) # Content space c.setFillColorRGB(1, 1, 1) c.roundRect(frame_layout['border']['left']*cm + offset, frame_layout['border']['bottom']*cm, frame_layout['content']['width']*cm, frame_layout['content']['height']*cm, radius=frame_layout['border']['inner_corner_radius']*cm, stroke=0, fill=1) # Key ring cut-out: 0 = none, 1 = top left, 2 = top right if page_nr == 1: c.circle(0, frame_layout['card_spread']['height']*cm, frame_layout['key_ring']['radius']*cm, stroke=0, fill=1) elif page_nr == 2: c.circle(frame_layout['card_spread']['width']*cm, frame_layout['card_spread']['height']*cm, frame_layout['key_ring']['radius']*cm, stroke=0, fill=1) # Domain / Caetgory text c.setFont('Helvetica', 10, leading = None) c.drawCentredString(frame_layout['card']['width']*cm/2 + offset, frame_layout['card']['height']*cm - 0.47*cm, '- ' + domain.title() + ' -') # Header text c.setFont('Helvetica-Bold', 20, leading = None) c.drawCentredString(frame_layout['card']['width']*cm/2 + offset, frame_layout['card']['height']*cm - 1.23*cm, card_face.header) # Footer text c.setFont('Helvetica', 8, leading = None) c.drawCentredString(frame_layout['card']['width']*cm/2 + offset, 0.15*cm, frame_layout['static_text']['footer']) # Include contents c.setFillColorRGB(0, 0, 0) page = pagexobj(PdfReader(card_face.content_path).pages[0]) c.saveState() c.translate(frame_layout['border']['left']*cm + offset, frame_layout['border']['bottom']*cm) c.doForm(makerl(c, page)) c.restoreState()
def bidder_agreement(bidder, output): from reportlab.pdfbase import pdfmetrics from reportlab.pdfbase.ttfonts import TTFont pdfmetrics.registerFont(TTFont(*settings.ARTSHOW_BARCODE_FONT)) c = Canvas(output, pagesize=letter) pdf = PdfReader(settings.ARTSHOW_BLANK_BIDDER_AGREEMENT) xobj = pagexobj(pdf.pages[0]) rlobj = makerl(c, xobj) c.translate(0, 5.5 * inch) c.doForm(rlobj) text_into_box(c, u"*P" + unicode(bidder.person.id) + u"*", 3.5, 4.8, 5.5, 5.05, fontSize=14, style=barcode_style) text_into_box(c, "Ref. " + unicode(bidder.person.id), 3.5, 4.55, 5.5, 4.75, fontSize=10) text_into_box(c, bidder.person.reg_id, 6.2, 1.35, 7.7, 1.6, fontSize=12) text_into_box(c, bidder.person.name, 1.3, 1.4, 5.2, 1.7, fontSize=14) text_into_box(c, bidder.at_con_contact, 2.1, 0.5, 5.2, 0.8, fontSize=12) c.showPage() c.save()
out.close() # be careful if using libreoffice for generating pdf, in olderversions via command line # it can start differently like loffice libreoffice or similar os.system("libreoffice5.0 --writer --headless --convert-to pdf %s " % (fname + ".txt")) # Tnx to this answer for implementing footer and page numbering http://stackoverflow.com/a/28283732/2397101 # this code follows input_file = fname + ".pdf" output_file = fname.rstrip("d") + ".pdf" # Get pages reader = PdfReader(input_file) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas(output_file) for page_num, page in enumerate(pages, start=1): # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw footer footer_text = "Page %s of %s" % (page_num, len(pages)) x = 128 canvas.saveState()
if __name__ == "__main__": from optparse import OptionParser parser = OptionParser(description=__doc__) parser.add_option("-i", dest="input_fname", help="file name to be watermarked (pdf)") parser.add_option("-w", dest="watermark_fname", help="watermark file name (pdf)") parser.add_option("-d", dest="pdfdir", help="watermark all pdf files in this directory") parser.add_option("-o", dest="outdir", help="outputdir used with option -d", default="tmp") parser.add_option("-s", dest="skip_pages", help="page numbers to be skipped -d", default="") options, args = parser.parse_args() if options.input_fname and options.watermark_fname: watermark = pagexobj(PdfReader(options.watermark_fname, decompress=False).pages[0]) outfn = "watermark." + os.path.basename(options.input_fname) pages = PdfReader(options.input_fname, decompress=False).pages skip_pages = [int(y) - 1 for y in filter(lambda x: x != "", options.skip_pages.split(","))] new_pages = [] for i in range(len(pages)): if i in skip_pages: new_pages.append(pages[i]) else: new_pages.append(fixpage(pages[i], watermark)) PdfWriter().addpages(new_pages).write(outfn) elif options.pdfdir and options.watermark_fname: batch_watermark(options.pdfdir, options.watermark_fname, options.outdir)
def watermark(input_fname, watermark_fname, output_fname=None): outfn = output_fname or ('watermark.' + os.path.basename(input_fname)) w = pagexobj(PdfReader(watermark_fname).pages[0]) pages = PdfReader(input_fname).pages PdfWriter().addpages([fixpage(x, w) for x in pages]).write(outfn) return outfn
except Exception: print "%s Failed miserably" %fname print traceback.format_exc()[:2000] #raise print "success %.2f%% %s pages" %((float(good_files)/len(fnames))*100, total_pages) if __name__ == "__main__": from optparse import OptionParser parser = OptionParser(description = __doc__) parser.add_option('-i', dest='input_fname', help='file name to be watermarked (pdf)') parser.add_option('-w', dest='watermark_fname', help='watermark file name (pdf)') parser.add_option('-d', dest='pdfdir', help='watermark all pdf files in this directory') parser.add_option('-o', dest='outdir', help='outputdir used with option -d', default='tmp') options, args = parser.parse_args() if options.input_fname and options.watermark_fname: watermark = pagexobj(PdfReader(options.watermark_fname).pages[0]) outfn = 'watermark.' + os.path.basename(options.input_fname) pages = PdfReader(options.input_fname).pages PdfWriter().addpages([fixpage(x, watermark) for x in pages]).write(outfn) elif options.pdfdir and options.watermark_fname: batch_watermark(options.pdfdir, options.watermark_fname, options.outdir) else: parser.print_help()
def bid_sheets ( pieces, output ): from reportlab.pdfbase import pdfmetrics from reportlab.pdfbase.ttfonts import TTFont pdfmetrics.registerFont(TTFont(*settings.ARTSHOW_BARCODE_FONT)) c = Canvas(output,pagesize=letter) pdf = PdfReader ( settings.ARTSHOW_BLANK_BID_SHEET ) xobj = pagexobj ( pdf.pages[0] ) rlobj = makerl ( c, xobj ) nfs_pdf = PdfReader ( settings.ARTSHOW_BLANK_NFS_SHEET ) nfs_xobj = pagexobj ( nfs_pdf.pages[0] ) nfs_rlobj = makerl ( c, nfs_xobj ) sheet_offsets = [ (0,5.5), (4.25,5.5), (0,0), (4.25,0), ] sheets_per_page = len(sheet_offsets) sheet_num = 0 pieceiter = iter(pieces) if artshow_settings.ARTSHOW_BID_SHEET_PRECOLLATION: pieceiter = precollate_pieces(pieceiter) last_artist = None try: piece = pieceiter.next () while True: try: for sheet_num in range(sheets_per_page): if artshow_settings.ARTSHOW_BID_SHEET_PRECOLLATION: if piece is None: piece = pieceiter.next() continue else: if piece.artist != last_artist and sheet_num != 0: continue c.saveState () c.translate ( sheet_offsets[sheet_num][0]*inch, sheet_offsets[sheet_num][1]*inch ) if piece.not_for_sale: c.doForm ( nfs_rlobj ) else: c.doForm ( rlobj ) c.saveState () c.setLineWidth ( 4 ) c.setFillColorRGB ( 1, 1, 1 ) c.setStrokeColorRGB ( 1, 1, 1 ) c.roundRect ( 1.1875*inch, 4.4375*inch, 1.75*inch, 0.5*inch, 0.0675*inch, stroke=True, fill=True ) c.restoreState () text_into_box ( c, u"*A"+unicode(piece.artist.artistid)+u"P"+unicode(piece.pieceid)+u"*", 1.3125, 4.6, 2.8125, 4.875, fontSize=13, style=barcode_style ) text_into_box ( c, "Artist "+unicode(piece.artist.artistid), 1.25, 4.4375, 2.0, 4.625 ) text_into_box ( c, "Piece "+unicode(piece.pieceid), 2.125, 4.4375, 2.875, 4.625 ) text_into_box ( c, piece.artist.artistname(), 1.125, 4.125, 3.875, 4.375 ) text_into_box ( c, piece.name, 0.75, 3.8125, 3.875, 4.0625 ) if piece.not_for_sale: text_into_box ( c, piece.media, 0.875, 3.5, 2.375, 3.75 ) else: text_into_box ( c, piece.media, 0.875, 3.5, 3.875, 3.75 ) text_into_box ( c, piece.not_for_sale and "NFS" or unicode(piece.min_bid), 3.25, 2.625, 3.75, 3.0 ) text_into_box ( c, piece.buy_now and unicode(piece.buy_now) or "N/A", 3.25, 1.9375, 3.75, 2.3125 ) text_into_box ( c, "X", 3.375, 0.375, 3.5625, 0.675, style=left_align_style, fontSize=16 ) c.restoreState () last_artist = piece.artist piece = pieceiter.next () finally: c.showPage () except StopIteration: pass c.save ()
def file_x(route): input_file = route output_file = route.replace("static","static_pdf") print input_file # Get pages reader = PdfReader(input_file) pages = [pagexobj(p) for p in reader.pages] # Compose new pdf canvas = Canvas(output_file) for page_num, page in enumerate(pages, start=1): # Add page canvas.setPageSize((page.BBox[2], page.BBox[3])) canvas.doForm(makerl(canvas, page)) # Draw footer footer_text = "Descargado desde https://UdpCursos.com" x = 180 canvas.saveState() canvas.setFont('Times-Roman', 10) canvas.drawString(page.BBox[2]-x, 40, footer_text) canvas.restoreState() canvas.showPage() canvas.save()