def solve_problems(pdf_file, pages, student_ids, problems, solve, copies_per_student):
if solve < 0.01:
# nothing to solve
return
with NamedTemporaryFile() as sol_file:
pdf = canvas.Canvas(sol_file.name, pagesize=A4)
for id, number_of_copies in zip(student_ids, copies_per_student):
for _ in range(number_of_copies):
generate_solution(pdf, pages, id, [p for p in problems if random.random() < solve])
if pages % 2 == 1:
# for an odd number of pages, zesje adds a blank page at the end
pdf.showPage()
pdf.save()
exam_pdf = PdfReader(pdf_file)
overlay_pdf = PdfReader(sol_file)
for page_idx, exam_page in enumerate(exam_pdf.pages):
overlay_merge = PageMerge().add(overlay_pdf.pages[page_idx])[0]
exam_merge = PageMerge(exam_page).add(overlay_merge)
exam_merge.render()
PdfWriter(pdf_file.name, trailer=exam_pdf).write()
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 makeDraft(pdffile, folder=None, printername=None):
"""Make a "draft" version of the given pdf file by adding a watermark.
Print this file and then delete it. The '.pdf' suffix may be omitted
in <pdffile>, but the file itself must have this suffix.
If <folder> is given, <pdffile> is the name of a (pdf-)file within that
folder. Otherwise <pdffile> is the complete file path.
If <printername> is given, it must be the name of a known printer.
If no <printername> is given, the system default printer is used.
"""
pdffile, filepath = _filecheck(pdffile, folder)
if not filepath:
return False
wmarkfn = Configuration.getFormsDir('Draft.pdf')
wmark = PageMerge().add(PdfReader(wmarkfn).pages[0])[0]
underneath = True
opath = os.path.join(os.path.dirname(filepath), "Entwurf.pdf")
reader = PdfReader(filepath)
for page in reader.pages:
PageMerge(page).add(wmark, prepend=underneath).render()
PdfWriter().write(opath, reader)
rc = toPrinter(opath, printername=printername)
if rc:
# delete the draft file
os.remove(opath)
return rc
def main():
selection, start_page_num, sb_or_count = io_check()
print(u"稼動中...\n")
print(u"AddText2PDF by WEN")
assert path.exists('conf.ini')
ini_file = 'conf.ini'
ini_object = IniInfo(ini_file)
# IO
input_folder = ini_object.get_input_folder()
input_file_list = [x for x in listdir(input_folder) if x.endswith('.pdf')]
input_file = input_file_list[0]
input_path = path.join(input_folder, input_file)
output_folder = ini_object.get_output_folder()
output_file = u'編集済み-' + input_file
output_path = path.join(output_folder, output_file)
source_pdf = PdfReader(input_path)
total_page_num = int(source_pdf.Root.Pages.Count)
for page_num in range(total_page_num):
canvas_data = get_canvas_data(selection, sb_or_count,
page_num + int(start_page_num),
ini_object)
wm_pdf = PdfReader(canvas_data)
wm_obj = PageMerge().add(wm_pdf.pages[0])[0]
PageMerge(source_pdf.pages[page_num]).add(wm_obj).render()
output_data = BytesIO()
PdfWriter().write(output_data, source_pdf)
output_data.seek(0)
save2pdf(output_data, output_path)
def adjust(page, margin=36, scale=4.8):
info = PageMerge().add(page)
x1, y1, x2, y2 = info.xobj_box
viewrect = (margin, margin, x2 - x1 - 2 * margin, y2 - y1 - 2 * margin)
page = PageMerge().add(page, viewrect=viewrect)
page[0].scale(scale)
return page.render()
def _pdfrw_adjust(self, page):
info = PageMerge().add(page)
x1, y1, x2, y2 = info.xobj_box
viewrect = (self.margin_x, self.margin_y, x2 - x1 - 2 * self.margin_x,
y2 - y1 - 2 * self.margin_y)
page = PageMerge().add(page, viewrect=viewrect)
page[0].scale(self.scale)
return page.render()
def watermark(self):
ipdf = PdfReader('1.pdf')
wpdf = PdfReader('watermark.pdf')
wmark = PageMerge().add(wpdf.pages[0])[0]
for page in ipdf.pages:
PageMerge(page).add(wmark).render()
PdfWriter().write('merged.pdf', ipdf)
def splitPage(page):
'''
Split a page into two (left and right)
'''
# return two half of the page
leftHalf = PageMerge().add(page, viewrect=(0, 0, 0.5, 1)).render()
rightHalf = PageMerge().add(page, viewrect=(0.5, 0, 0.5, 1)).render()
# page=[leftHalf, rightHalf]
return leftHalf, rightHalf
def merge(overlay_canvas: io.BytesIO, template_path: str) -> io.BytesIO:
template_pdf = PdfReader(template_path)
overlay_pdf = PdfReader(overlay_canvas)
for page, data in zip(template_pdf.pages, overlay_pdf.pages):
overlay = PageMerge().add(data)[0]
PageMerge(page).add(overlay).render()
form = io.BytesIO()
PdfWriter().write(form, template_pdf)
form.seek(0)
return form
def sign(self, event):
#save signature biometric data in meta headers and draw signature image to pdf
try:
#clear tkinter signature canvas
self.tkinter_signature_canvas.delete("all")
templete_bytes = BytesIO()
templete_bytes.write(self.pdf_to_sign)
templete_bytes.seek(0)
# open templete,write biometric data and save to new virual file
trailer = PdfReader(templete_bytes)
#
#
#
trailer.Info.biometric_date = str(self.biometric_data)
PdfWriter(templete_bytes, trailer=trailer).write()
# signature_canvas.drawPath()
self.signature_canvas.save()
#set position to 0
self.singature_bytes.seek(0)
templete_bytes.seek(0)
#merge signature and templete dpf bytes
signature = PageMerge().add(
PdfReader(self.singature_bytes).pages[0])[0]
# trailer = PdfReader(templete_bytes)
#add signature to all pages
for page in trailer.pages:
PageMerge(page).add(signature).render()
#save merged result to new res.pdf file
res_bytes = BytesIO()
# PdfWriter('res.pdf', trailer=trailer).write()
PdfWriter(res_bytes, trailer=trailer).write()
res_bytes.seek(0)
self.bytes = res_bytes.getvalue()
res_bytes.close()
except Exception as e:
print(e)
finally:
#clear global variables and define again
self.singature_bytes.close()
templete_bytes.close()
self.reinit_global_var()
self.localstatus = False
def adjust(page, params):
scale, margin, is_vertical = params
info = PageMerge().add(page)
x1, y1, x2, y2 = info.xobj_box
if is_vertical == 1:
viewrect = (0, margin / scale, x2, y2 - 2 * margin / scale)
else:
viewrect = (margin / scale, 0, x2 - 2 * margin / scale, y2)
page = PageMerge().add(page, viewrect=viewrect)
page[0].scale(scale)
return page.render()
def pdfWaterMark(files_folder):
water_mark = PageMerge().add(
PdfReader('%s/wtmrk.pdf' % files_folder).pages[0]
)[0]
trailer = PdfReader('%s/mergedPDF.pdf' % files_folder)
for page in trailer.pages:
PageMerge(page).add(water_mark, prepend='-u').render()
PdfWriter("%s/resultPDF.pdf" % (files_folder), trailer=trailer).write()
def add_page_number(target_file):
"""Helper function to add page numbers to a pdf-file.
Writes a pdf file containing page numbers.
"""
from PyPDF2 import PdfFileReader
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4
from pdfrw import PdfReader, PdfWriter, PageMerge
tmp_pagenum = 'wmark_' + target_file
# Create object for page numbers
c = canvas.Canvas(
tmp_pagenum,
pagesize=A4,
)
# Read the target file
input_pdf = PdfFileReader(open(target_file, 'rb'))
# Count number of pages in the target file
number_of_pages = input_pdf.getNumPages()
# Loop through all pages in the target file and create a page number
# in a new file. Not using
for i in range(input_pdf.getNumPages()):
text = '- Committee Pack, page ' + str(
(i + 1)) + ' / ' + str(number_of_pages) + ' -'
c.setFont("Helvetica", 7)
c.drawString(
20,
8,
text,
)
c.showPage()
c.save()
# Open the watermark file
trailer = PdfReader(target_file)
# Loop through the target file and append the page number
for i, page in enumerate(trailer.pages):
wmark = PageMerge().add(PdfReader(tmp_pagenum).pages[i])[0]
PageMerge(page).add(wmark, prepend=True).render()
PdfWriter(target_file, trailer=trailer).write()
# Cleanup
os.unlink(tmp_pagenum)
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 adicionaBackground(dadosFormatados):
ipdf = PdfReader('resources/pdfs/sample.pdf')
wpdf = PdfReader('resources/pdfs/cracha.pdf')
wmark = PageMerge().add(wpdf.pages[0])[0]
writer = PdfWriter()
blank = wpdf.pages[0]
PageMerge(ipdf.pages[0]).add(wmark).render()
for i in range(len(dadosFormatados) - 1):
writer.addpage(blank)
writer.write('resources/pdfs/newfile.pdf')
def _merge_overlay(self, overlay):
"""Merge the overlay into the template"""
# open a copy of the template form to merge in
self.form.seek(0)
template = PdfReader(self.form)
# merge the overlay and template
overlay_pdf = PdfReader(overlay)
for t_page, o_page in zip(template.pages, overlay_pdf.pages):
overlay = PageMerge().add(o_page)[0]
PageMerge(t_page).add(overlay).render()
final_form = StringIO()
PdfWriter().write(final_form, template)
final_form.seek(0)
return final_form
def create_match_sheet(match_num, blue_team=None, red_team=None, male=False,
female=False, a_team=False, b_team=False, c_team=False):
teams_canvas = canvas.Canvas("teams.pdf", pagesize=letter)
teams_canvas.setLineWidth(3)
xoffset, yoffset = 0, 0
if male:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
xoffset = 4.23 * inch
if female:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
yoffset = -.3 * inch
if c_team:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
xoffset = 0
if a_team:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
xoffset = 4.23/ 2 * inch
if b_team:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
teams_canvas.setFont('Helvetica', 24)
teams_canvas.drawString(1.7*inch, 7.8*inch, str(match_num))
teams_canvas.setFont('Helvetica', 18)
if blue_team:
teams_canvas.drawString(.65*inch, 6.65*inch, blue_team)
xoffset = 3.75*inch
if red_team:
teams_canvas.drawString(.65*inch + xoffset, 6.65*inch, red_team)
teams_canvas.save()
match_sheet_fn = '/home/user/dev/match_sheet/match_sheet.pdf'
teams_fn = 'teams.pdf'
output_fn = os.path.join(match_sheet_dir, 'match_%d.pdf' %(match_num))
output_canvas = PageMerge().add(PdfReader(match_sheet_fn).pages[0])[0]
trailer = PdfReader(teams_fn)
for page in trailer.pages:
PageMerge(page).add(output_canvas, prepend=True).render()
PdfWriter().write(output_fn, trailer)
return output_fn
def mark_pdf(clean_path, marked_path):
"""Draw rectangles around the boxes, lines, and characters in a document."""
try:
with open(os.path.join(clean_path)) as fp:
parser = PDFParser(fp)
pdf = PDFDocument(parser)
parser.set_document(pdf)
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
marked_dir, marked_fn = os.path.split(marked_path)
rect_file = os.path.join(marked_dir, ".rects." + marked_fn)
c = canvas.Canvas(rect_file)
for i, page in enumerate(PDFPage.create_pages(pdf)):
interpreter.process_page(page)
layout = device.get_result()
boxes = [obj for obj in layout if isinstance(obj, LTTextBox)]
for box in boxes:
c.setLineWidth(1)
c.setStrokeColorRGB(1, 0, 0)
make_rectangle(c, box.bbox)
lines = [obj for obj in box if isinstance(obj, LTTextLine)]
for line in lines:
c.setLineWidth(0.5)
c.setStrokeColorRGB(0, 1, 0)
make_rectangle(c, line.bbox)
for char in line:
if isinstance(char, LTChar):
c.setLineWidth(0.3)
c.setStrokeColorRGB(0, 0, 1)
make_rectangle(c, char.bbox)
c.showPage()
c.save()
pdf_content = PdfReader(clean_path)
for i, page in enumerate(pdf_content.pages):
rects = PageMerge().add(PdfReader(rect_file).pages[i])[0]
PageMerge(page).add(rects).render()
PdfWriter().write(marked_path, pdf_content)
os.remove(rect_file)
except Exception as e:
print(e)
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 split(page):
x, y, width, height = page.MediaBox
if width > height:
for x_pos in (0, 0.5):
yield PageMerge().add(page, viewrect=(x_pos, 0, 0.5, 1)).render()
else:
yield page
def get_single_side_quire_page(pages):
number_of_pages = len(pages)
assert number_of_pages == round(QUIRE_SIZE / 2)
half_index = round(number_of_pages / 2)
rotate_all(180, pages[half_index:])
result = PageMerge() + (x for x in pages if x is not None)
width = result[0].w
height = result[0].h
for i in range(half_index):
dx = i * width
dy = height
result[i].x += dx
result[i].y += dy
for i in range(half_index, number_of_pages):
dx = (i - half_index) * width
dy = 0
result[i].x += dx
result[i].y += dy
return result.render()
def resize(outpages: List, output_size: List[int]) -> List:
current_size = get_media_box_size(outpages)
o = list(outpages)
# rotate output_size if outpages would fit better
out_ratio = output_size[0] / output_size[1]
cur_ratio = current_size[0] / current_size[1]
if out_ratio > 1 and cur_ratio <= 1 or out_ratio <= 1 and cur_ratio > 1:
output_size = list(reversed(output_size))
scale, x_margin, y_margin = calculate_margins(output_size, current_size)
for idx, page in enumerate(outpages):
page = PageMerge().add(page)
# scale page
page[0].scale(scale)
page[0].x += x_margin
page[0].y += y_margin
# set new mediabox size
page.mbox = [0, 0] + output_size
# replace original with resized page
o[idx] = page.render()
return o
def create_watermark(waterpath, watermarkcontent):
"""创建PDF水印模板
"""
# 使用reportlab来创建一个PDF文件来作为一个水印文件
pdfmetrics.registerFont(TTFont('song', APILOG_PATH['pdfwaterfontPath']))
if not isinstance(watermarkcontent, list):
watermarkcontent = []
while len(watermarkcontent) < 3:
watermarkcontent.append(u'多维海拓')
c = canvas.Canvas(waterpath, A1)
c.rotate(45)
fontsize = 20 # 水印字体大小
fontAlpha = 0.05 # 水印字体透明度
space = 80 # 水印间距
c.setFont("song", fontsize)
c.translate(0, -A1[1] * 0.5)
width0 = c.stringWidth(text=watermarkcontent[0], fontName='song', fontSize=fontsize)
width1 = c.stringWidth(text=watermarkcontent[1], fontName='song', fontSize=fontsize)
width2 = c.stringWidth(text=watermarkcontent[2].replace('@', '[at]'), fontName='song', fontSize=fontsize)
y = 0
while y < A1[1]:
x = 100
while x < A1[0]:
c.setFillAlpha(fontAlpha)
c.drawString(x, y, watermarkcontent[0])
x = x + width0 + space
c.drawString(x, y, watermarkcontent[1])
x = x + width1 + space
c.drawString(x, y, watermarkcontent[2].replace('@', '[at]'))
x = x + width2 + space
y += 60
c.save()
pdf_watermark = PageMerge().add(PdfReader(waterpath).pages[0])[0]
return pdf_watermark
def splitpage(page):
"""Splits a page in two
"""
# We define half the page
for x in (0, 0.5):
# We return (yield) a generator, which in turn generates a collection later
yield PageMerge().add(page, viewrect=(x, 0, 0.5, 1)).render()
def fixpage(*pages):
""" Taken from example project in pdfrw.
Puts two pages together into one
"""
result = PageMerge() + (x for x in pages if x is not None)
result[-1].x += result[0].w
return result.render()
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 add_date(self, xy, page, page_w, page_h):
print('calling date_scale_and_locate')
date_pdf = self.signature.date_scale_and_locate(xy, page_w, page_h)
for date in date_pdf:
PageMerge(page).add(date, prepend=False).render()
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 addWaterMarkToPdfFiles(pdfpaths, watermarkcontent=None):
try:
if len(pdfpaths) == 0:
return
watermarkpath = pdfpaths[0].split('.')[0] + '-water' + '.pdf'
watermark = create_watermark(watermarkpath, watermarkcontent)
except Exception:
now = datetime.datetime.now()
print('制作水印pdf--%s'%now)
filepath = APILOG_PATH['excptionlogpath'] + '/' + now.strftime('%Y-%m-%d')
f = open(filepath, 'a')
f.writelines(now.strftime('%H:%M:%S') + '\n' + traceback.format_exc() + '\n\n')
f.close()
return
# Get our files ready
for path in pdfpaths:
now = datetime.datetime.now()
try:
print('覆盖水印pdf--%s--源文件%s' % (now, path))
out_path = path.split('.')[0] + '-out' + '.pdf'
input_file = PdfReader(path)
for page in input_file.pages:
PageMerge(page).add(watermark, prepend=False).render()
PdfWriter(out_path, trailer=input_file).write()
os.remove(path)
os.rename(out_path, path)
except Exception as err:
print('覆盖水印pdf失败--%s--源文件%s' % (now, path))
filepath = APILOG_PATH['excptionlogpath'] + '/' + now.strftime('%Y-%m-%d')
f = open(filepath, 'a')
f.writelines(now.strftime('%H:%M:%S') + '\n' + traceback.format_exc() + '\n\n')
f.close()
if os.path.exists(watermarkpath):
os.remove(watermarkpath)
return
def save_with_even_pages(exam_id, exam_pdf_file):
"""Save a finalized exam pdf with evem number of pages.
The exam is saved in the path returned by `get_exam_dir(exam_id)` with the name `exam.pdf`.
If the pdf has an odd number of pages, an extra blank page is added at the end,
this is specially usefull for printing and contatenating multiple copies at once.
Parameters
----------
exam_id : int
The exam identifier
exam_pdf_file : str or File like object
The exam pdf to be saved inthe data directory
"""
os.makedirs(exam_dir(exam_id), exist_ok=True)
pdf_path = exam_pdf_path(exam_id)
exam_pdf = PdfReader(exam_pdf_file)
pagecount = len(exam_pdf.pages)
if (pagecount % 2 == 0):
exam_pdf_file.seek(0)
exam_pdf_file.save(pdf_path)
return
new = PdfWriter()
new.addpages(exam_pdf.pages)
blank = PageMerge()
box = exam_pdf.pages[0].MediaBox
blank.mbox = box
blank = blank.render()
new.addpage(blank)
new.write(pdf_path)
