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 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 __add__(self, other):
if not self.pdf_stream:
return other
writer = pdfrw.PdfWriter()
self_path = os.path.join(current.request.folder, "temp",
uuid.uuid4().hex + ".pdf")
other_path = os.path.join(current.request.folder, "temp",
uuid.uuid4().hex + ".pdf")
with open(self_path, "wb+") as f:
f.write(self.pdf_stream)
with open(other_path, "wb+") as f:
f.write(other.pdf_stream)
writer.addpages(pdfrw.PdfReader(self_path).pages)
writer.addpages(pdfrw.PdfReader(other_path).pages)
new_final_path = os.path.join(current.request.folder, "temp",
uuid.uuid4().hex + ".pdf")
writer.write(new_final_path)
new_obj = self.__class__()
with open(new_final_path, "rb+") as f:
new_obj.pdf_stream = f.read()
os.remove(self_path)
os.remove(other_path)
os.remove(new_final_path)
return new_obj
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 write_fillable_pdf(input_pdf_path, output_pdf_path, out_path, data_dict):
ANNOT_KEY = '/Annots'
ANNOT_FIELD_KEY = '/T'
ANNOT_VAL_KEY = '/V'
ANNOT_RECT_KEY = '/Rect'
SUBTYPE_KEY = '/Subtype'
WIDGET_SUBTYPE_KEY = '/Widget'
try:
template_pdf = pdfrw.PdfReader(input_pdf_path)
except:
try:
template_path = out_path + 'template.pdf'
req = requests.get(input_pdf_path, timeout=4)
with open(template_path, 'wb') as f:
f.write(req.content)
template_pdf = pdfrw.PdfReader(template_path)
except:
femaSetProxies()
template_path = out_path + 'template.pdf'
template_pdf = pdfrw.PdfReader(template_path)
try:
template_pdf.Root.AcroForm.update(pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true')))
except:
pass
annotations = template_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():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key]))
)
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
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 getLinks(filename, args, dirpath):
links = []
fullname = os.path.join(dirpath or '', filename)
fil = os.path.basename(filename)
href = 'Unknown error opening this file.'
page = 'n/a'
try:
PDF = pdfrw.PdfReader(fullname)
pages = PDF.Root.Pages.Kids
except ValueError:
# This might be an encrypted file. Try decrypting it.
try:
subprocess.call(['qpdf', '--decrypt', fullname, fullname + '.new'])
except FileNotFoundError:
print('qpdf is not installed. Could not attempt to decrypt ' +
filename)
href = 'Could not open - possibly encrypted file.'
return [{'filename': fil, 'href': href, 'page': page}]
# Read in and then delete the new unencrypted file
PDF = pdfrw.PdfReader(fullname + '.new')
os.remove(fullname + '.new')
if not PDF.Encrypt:
pages = PDF.Root.Pages.Kids
print('Temporarily decrypted ' + filename)
except:
print('Unknown error opening ' + os.path.basename(filename))
return [{'filename': fil, 'href': href, 'page': page}]
if PDF.Encrypt:
print('Could not decrypt ' + filename)
href = 'Cannot get URLs from encrypted file.'
return [{'filename': fil, 'href': href, 'page': page}]
for index, page in enumerate(pages):
if '/Annots' in page:
ann = page['/Annots']
for a in ann:
if '/A' in a:
if '/URI' in a['/A']:
if not PDF.Encrypt:
links.append({
'filename': os.path.basename(filename),
'href': a['/A']['/URI'][1:-1],
'page': (index + 1)
})
else:
links.append({
'filename': os.path.basename(filename),
'href': 'Cannot get URL from encrypted file.',
'page': (index + 1)
})
# Return a list of dicts full of link info
return links
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 combine_pdf(pptx_filename):
pdf_filename = pptx_filename.replace(".pptx", ".pdf")
pdf_report_pages = pdfrw.PdfReader(pdf_filename).pages
pdf_template_pages = pdfrw.PdfReader('input_data/pdf_template.pdf').pages
outdata = pdfrw.PdfWriter('output_data/plain_with_template.pdf')
outdata.addpage(pdf_template_pages[0])
outdata.addpages(pdf_report_pages)
outdata.addpage(pdf_template_pages[1])
outdata.write()
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_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 test_merging(template_stream):
obj_one = _PyPDFForm()
obj_two = _PyPDFForm()
obj_one.stream = template_stream
obj_two.stream = template_stream
result = pdfrw.PdfReader(fdata=(obj_one + obj_two).stream)
assert len(
result.pages) == len(pdfrw.PdfReader(fdata=template_stream).pages) * 2
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 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 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 main(input_paths):
if len(input_paths) > 2:
raise ValueError('program only accepts 1 or 2 files')
input_file_basename = os.path.basename(input_paths[0])
output_path = '{}-sorted{}'.format(
os.path.splitext(input_file_basename)[0],
os.path.splitext(input_file_basename)[1])
out_data = pdfrw.PdfWriter(output_path)
if len(input_paths) == 2:
odd_data = pdfrw.PdfReader(input_paths[0])
even_data = pdfrw.PdfReader(input_paths[1])
if len(odd_data.pages) != len(even_data.pages):
raise RuntimeError(
'The number of pages in the input files are unequal. '
'Something probable went wrong during the scan. Please check the '
'input files and try again.')
current_even_page = list(range(0, len(even_data.pages)))
for current_odd_page in range(0, len(odd_data.pages)):
out_data.addpage(odd_data.pages[current_odd_page])
out_data.addpage((even_data.pages[current_even_page.pop()]
)) # in practice .pop() reverses the list
out_data.write()
elif len(input_paths) == 1:
in_data = pdfrw.PdfReader(input_paths[0])
if len(in_data.pages) % 2 != 0:
raise RuntimeError(
'There are an uneven number of pages in the PDF file. '
'Something must have gone wrong during the scan. Please check the '
'input file and try again.')
all_pages = len(in_data.pages)
half_pages = all_pages // 2
odd_pages = list(range(0, half_pages))
even_pages = list(reversed(range(half_pages, all_pages)))
sorted_pages = []
for page in range(0, half_pages):
sorted_pages.append(odd_pages[page])
sorted_pages.append(even_pages[page])
for page in sorted_pages:
out_data.addpage(in_data.pages[page])
out_data.write()
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 every_other(vouch_list: str, sign: io.BytesIO) -> io.BytesIO:
v = pdfrw.PdfReader(vouch_list)
pages = v.pages
sign_page = pdfrw.PdfReader(sign).pages[0]
writer = pdfrw.PdfWriter()
for page in range(len(pages)):
writer.addpage(pages[page])
writer.addpage(sign_page)
form = io.BytesIO()
writer.write(form)
form.seek(0)
return form
def print_annotation_values(input_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
annotations = template_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 "box" not in annotation["/T"]:
print(annotation["/T"])
print(annotation["/V"])
print(annotation["/AP"])
print("#" * 30)
for annotation in annotations:
if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY:
if annotation[ANNOT_FIELD_KEY]:
key = annotation[ANNOT_FIELD_KEY][1:-1]
if "box" in annotation["/T"]:
print(annotation["/T"])
print(annotation["/V"])
print(annotation["/AP"])
print("#" * 30)
def create_1099(form, recipient_path, template_path):
data_dict = {
'payer_details':
form[PAYER][NAME] + '\n' + form[PAYER][ADDRESS] + '\n' +
form[PAYER][LOCATION],
'recipient_name':
form[RECIPIENT][NAME],
'street_address':
form[RECIPIENT][ADDRESS],
'location_details':
form[RECIPIENT][LOCATION],
'field_3':
str(form[USD_VALUE]), # other income
'field_18_a':
'0', # state income a
'field_18_b':
'0' # statw income b
}
template_pdf = pdfrw.PdfReader(template_path[0])
annotations = template_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():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
pdfrw.PdfWriter().write(os.path.join(recipient_path, template_path[1]),
template_pdf)
def _assign_uuid(self, output_stream: bytes, editable: bool) -> bytes:
"""Append UUIDs to all elements of the PDF form."""
_uuid = self._uuid
generated_pdf = pdfrw.PdfReader(fdata=output_stream)
for element in self._iterate_elements(generated_pdf):
if editable:
update_obj = pdfrw.PdfDict(T="{}_{}".format(
element[self._ANNOT_FIELD_KEY][1:-1],
_uuid,
), )
else:
update_obj = pdfrw.PdfDict(
T="{}_{}".format(
element[self._ANNOT_FIELD_KEY][1:-1],
_uuid,
),
Ff=pdfrw.PdfObject(1),
)
element.update(update_obj)
result_stream = BytesIO()
pdfrw.PdfWriter().write(result_stream, generated_pdf)
result_stream.seek(0)
result = result_stream.read()
result_stream.close()
return result
def build_elements(self, pdf_stream: bytes) -> "_PyPDFForm":
"""Builds an element list."""
if not pdf_stream:
return self
self._validate_template(pdf_stream)
element_type_mapping = {
"/Btn": "checkbox",
"/Tx": "text",
}
_pdf = pdfrw.PdfReader(fdata=pdf_stream)
for element in self._iterate_elements(_pdf):
key = element[self._ANNOT_FIELD_KEY][1:-1]
self.elements[key] = Element(
element_name=key,
element_type=element_type_mapping.get(
str(element[self._ANNOT_TYPE_KEY])),
)
return self
def dump_fields(fp):
'''
Helper function to print out different fields in a PDF.
Useful for generating keyfiles, debugging, etc.
'''
template_pdf = pdfrw.PdfReader(fp)
annotations = template_pdf.pages[0][ANNOT_KEY]
for page in template_pdf.pages:
annotations = page[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]
type = annotation[ANNOT_FIELD_TYPE]
print (key, type)
else:
print ('NOT ANNOT FIELD KEY')
if annotation['/AS']:
print ('Button', annotation['/AP']['/D'].keys(), annotation[PARENT_KEY][ANNOT_FIELD_KEY])
else:
print ('Text: ', annotation[PARENT_KEY][ANNOT_FIELD_KEY])
print (annotation[PARENT_KEY][ANNOT_VAL_KEY])
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 do_buttons(basename, data_dict, keyfile):
'''
Some buttons are tricky because they're linked together
by a single parent element that we need to update.
Handle that case here.
'''
input_pdf_path = os.path.join('filled', basename)
output_pdf_path = os.path.join('filled', basename)
template_pdf = pdfrw.PdfReader(input_pdf_path)
annotations = template_pdf.pages[0][ANNOT_KEY]
value_to_readable = parse_keyfile(keyfile)
for page in template_pdf.pages:
annotations = page[ANNOT_KEY]
for annotation in annotations:
if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY:
if not annotation[ANNOT_FIELD_KEY]:
parent_key = annotation[PARENT_KEY][ANNOT_FIELD_KEY]
if parent_key is None:
continue
parent_key = parent_key[1:-1]
if parent_key not in value_to_readable:
continue
if annotation['/AS']:
if 'BUTTONS' in data_dict:
for k, v in data_dict['BUTTONS']:
if k == value_to_readable[parent_key] and '/' + v in annotation['/AP']['/D'].keys():
annotation[PARENT_KEY].update(pdfrw.PdfDict(V=v))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def write_fillable_pdf(self):
template_pdf = pdfrw.PdfReader(self.conf["BLANK_CHAR_SHEET"])
data_dict = self.create_character_data_dict()
annotations = template_pdf.pages[0][self.conf["ANNOT_KEY"]]
for annotation in annotations:
if annotation["/Subtype"] == self.conf["WIDGET_SUBTYPE_KEY"]:
if annotation[self.conf["ANNOT_KEY_field"]]:
key = annotation[
self.conf["ANNOT_KEY_field"]][1:-1].strip()
if key in data_dict.keys():
if (annotation[self.conf["ANNOT_FORM_type"]] ==
self.conf["ANNOT_FORM_button"]):
# button field i.e. a checkbox
annotation.update(
pdfrw.PdfDict(
V=pdfrw.PdfName(data_dict[key]),
AS=pdfrw.PdfName(data_dict[key]),
))
elif (annotation[self.conf["ANNOT_FORM_type"]] ==
self.conf["ANNOT_FORM_text"]):
annotation.update(
pdfrw.PdfDict(V="{}".format(data_dict[key])))
template_pdf.Root.AcroForm.update(
pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject("true")))
new_pdf_name = (
f"{data_dict['CharacterName']}_{data_dict['Race'].replace(' ', '-')}"
f"_{data_dict['ClassLevel'][:-3].replace(' ', '-')}"
f"_{data_dict['Background'].replace(' ', '-')}")
pdfrw.PdfWriter().write(
f"pdfs/{new_pdf_name}.pdf",
template_pdf,
)
def update_form(row_data, mapping, targetfile=None, template=None):
'''
Fills up form and returns a pdfrw PdfileWriter object. Works with an existing object if specified. If not, creates new
:param row_data: Row data from excel file
:param mapping: Dictionary that maps excel row with form field in pdf
:param targetfile: Path to pdf file that needs to be filled
:param template:
:return:
'''
logger = logging.getLogger(__name__ + '.update_form')
if template is None:
if targetfile is not None:
template = pdfrw.PdfReader(targetfile)
else:
raise Exception('Target file not included. Cannot create template')
for page in range(len(template.pages)):
annotations = template.pages[page]['/Annots']
for item in annotations:
if item['/Subtype'] == '/Widget':
if item['/T']:
key = item['/T'][1:-1]
if key in mapping.keys():
if 'Check Box' in key:
if row_data[mapping[key]] == 'yes':
item.update(
pdfrw.PdfDict(AS=pdfrw.PdfName('Yes')))
elif row_data[mapping[key]] == 'no':
item.update(
pdfrw.PdfDict(AS=pdfrw.PdfName('No')))
else:
logger.debug('Textbox= {0} Value= {1}'.format(
str(key), str(row_data[mapping[key]])))
item.update(
pdfrw.PdfDict(V=str(row_data[mapping[key]])))
return template
def fill_pdf_detached():
global data_dict, FORM_KEYS_DETACHED, url_to_scrape
pdf_template = pdfrw.PdfReader(
'pdf/services/Contract_Template_Detached_V2.pdf')
for page_pdf in pdf_template.pages:
annotations = page_pdf['/Annots']
if annotations is None:
continue
for annotation in annotations:
if annotation['/Subtype'] == '/Widget':
if annotation['/T']:
key = annotation['/T'][1:-1]
if re.search(r'.-[0-9]+', key):
key = key[:-2]
if key in data_dict:
if FORM_KEYS_DETACHED[key] == CHECKBOX_PDF_TYPE:
annotation.update(
pdfrw.PdfDict(AS=encode_pdf_string(
data_dict[key], CHECKBOX_PDF_TYPE)))
else:
annotation.update(
pdfrw.PdfDict(V=encode_pdf_string(
data_dict[key], STRING_PDF_TYPE)))
annotation.update(pdfrw.PdfDict(Ff=1))
pdf_template.Root.AcroForm.update(
pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true')))
pdf_name = 'files/' + data_dict['property_details'] + '__' + data_dict['buyer_name'] \
+ '__' + date.today().strftime("%m-%d-%y") + '.pdf'
pdfrw.PdfWriter().write(pdf_name, pdf_template)
return pdf_name
def add_data_to_pdf(self, template_path, data):
print('\nAdding data to pdf...')
template = pdfrw.PdfReader(template_path)
for page in template.pages:
annotations = page['/Annots']
if annotations is None:
continue
for annotation in annotations:
#if annotation['/Subtype'] == ['/Widget']:
if annotation['/T']:
key = annotation['/T'][1:-1]
print('Key: "{}"'.format(key))
if re.search(r'.-[0-9]+', key):
key = key[:-2]
if key in data:
print('Found Key: {}'.format(key))
annotation.update(
pdfrw.PdfDict(
V=self.encode_pdf_string(data[key], 'string')))
annotation.update(pdfrw.PdfDict(Ff=1))
template.Root.AcroForm.update(
pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true')))
pdfrw.PdfWriter().write(self.temp_directory + "data.pdf", template)
print('Pdf saved')
return self.temp_directory + "data.pdf"
