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)
