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 write_fillable_pdf2(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
for i in range(0, len(template_pdf.pages)):
annotations = template_pdf.pages[i][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 key == 'FTEstart3':
print("hi")
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def make_referee_sheets(df, template):
# Robot Game sheets
rg_tables = pd.concat([df['Table1'],
df['Table2'],
df['Table3']]).unique()
rg_tables.sort()
print('Robot Game: ', end='', flush=True)
for table in rg_tables:
rg_writer = pdfrw.PdfWriter()
rg_template_pdf = pdfrw.PdfReader(template)
pdf = 'Robot Game {0}.pdf'.format(table)
print('{0} '.format(table), end='', flush=True)
# For each 8 tables and 48 teams, this probably comes down to:
# 3x Round 1, 3x Round 2, 3x Round 1, 3x Round 2, 6x Round 3, but this
# method should be generic for any 3-round tournament setup
# teams_on_table = df[(df['Table1'] == table) |
# (df['Table2'] == table) |
# (df['Table3'] == table)]
table_round_1 = df[df['Table1'] == table].sort_values('Time1')
table_round_2 = df[df['Table2'] == table].sort_values('Time2')
table_round_3 = df[df['Table3'] == table].sort_values('Time3')
teams_on_table = pd.concat([table_round_1[['Team', 'Time1']],
table_round_2[['Team', 'Time2']],
table_round_3[['Team', 'Time3']]],
sort=True)
teams_on_table['Round'] = teams_on_table.apply(
lambda row: which_round(row, table), axis=1)
teams_on_table['Time'] = teams_on_table.apply(
lambda row: which_time(row), axis=1)
# Make a bunch of empty sheets for the merge
print("({0} teams), ".format(len(teams_on_table)), end='', flush=True)
for i in range(len(teams_on_table)):
rg_writer.addpage(rg_template_pdf.pages[0])
rg_writer.write(pdf)
# This is a bit heavy on the reading/writing, but at 144 total pages,
# it's not too bad so far.
page_number = 0
for index, row in teams_on_table.sort_values('Time').iterrows():
print("{0} ".format(row['Team'].astype(int)), end='', flush=True)
# base_pdf = pdfrw.PdfReader(pdf)
canvas_data = rg_get_overlay_canvas(row['Round'].astype(int),
row['Team'].astype(int),
table)
form = merge(canvas_data, template_path=pdf, page=page_number)
page_number = page_number + 1
save(form, filename=pdf)
print(". ")
print('')
def form_valid(self, form):
template_pdf = pdfrw.PdfReader(os.path.abspath(os.path.join(os.path.dirname(__file__), "templates/AOC-175.pdf")))
plaintiff_name = (
f"{self.request.user.first_name} {self.request.user.first_name}"
if (self.request.user.first_name and self.request.user.first_name)
else f"{form.cleaned_data['sender_first_name']} {form.cleaned_data['sender_last_name']}"
)
data_dict = {
"county": form.cleaned_data["county"],
"plaintiff_full_name": plaintiff_name,
"plaintiff_full_name_2": plaintiff_name,
"plaintiff_address_1": form.cleaned_data["sender_address_1"],
"plaintiff_address_2": form.cleaned_data["sender_address_2"],
"plaintiff_city_state_zip": f"{form.cleaned_data['sender_city']}, {form.cleaned_data['sender_state']} {form.cleaned_data['sender_zip_code']}",
"defendant_full_name": form.cleaned_data["unit"].landlord_name,
"defendant_address_1": form.cleaned_data["unit"].landlord_address_1,
"defendant_address_2": form.cleaned_data["unit"].landlord_address_2,
"defendant_city_state_zip": f"{form.cleaned_data['unit'].landlord_city}, {form.cleaned_data['unit'].landlord_state} {form.cleaned_data['unit'].landlord_zip_code}",
"claims_sum": "${0:.2f}".format(form.cleaned_data["claims_sum"]),
"court_costs": "${0:.2f}".format(form.cleaned_data["court_costs"]),
"claims": form.cleaned_data["claims"],
}
if form.cleaned_data["is_landlord_company"]:
data_dict["defendant_company"] = "X"
else:
data_dict["defendant_individual"] = "X"
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]
if key in data_dict.keys():
annotation.update(pdfrw.PdfDict(V="{}".format(data_dict[key])))
template_pdf.Root.AcroForm.update(pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject("true")))
with tempfile.TemporaryFile() as fp:
pdfrw.PdfWriter().write(fp, template_pdf)
fp.seek(0)
response = HttpResponse(fp.read(), content_type="application/pdf")
response["Content-Disposition"] = "attachment; filename=SmallClaims.pdf"
messages.add_message(self.request, messages.SUCCESS, _("File downloaded."))
return response
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
annotations = template_pdf.pages[1][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():
print("Matched: ", key)
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
# Hack to change appearance so filled up text fields show in Preview
annotation.update(pdfrw.PdfDict(AP=''))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
template_pdf.Root.AcroForm.update(pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true')))
annotations = template_pdf.pages[0][ANNOT_KEY]
#print(annotations)
for annotation in annotations:
if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY:
if annotation[ANNOT_FIELD_KEY]:
key = annotation[ANNOT_FIELD_KEY][1:-1]
#print(key)
if key in data_dict.keys():
annotation.update(
pdfrw.PdfDict(AP=data_dict[key], V=data_dict[key])
)
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def populate_fields(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
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]
key_main = KEY_MATCH.search(key).group(
1) if KEY_MATCH.search(key) else key
print(key_main)
if key_main in data_dict.keys():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key_main])))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict):
'''
This function will fill in pdf's forms based on a form pdf
'''
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 key in data_dict.keys():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def merge_pdfs(form_pdf, overlay_pdf, output):
"""
Merge the specified fillable form PDF with the
overlay PDF and save the 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 writeFillablePDF(input_pdf_path, output_pdf_path, data_dict):
# Read Input PDF
template_pdf = pdfrw.PdfReader(input_pdf_path)
# Set Apparences ( Make Text field visible )
template_pdf.Root.AcroForm.update(pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true')))
# Loop all Annotations
for annotation in template_pdf.pages[0]['/Annots']:
# Custom/Fields
if annotation['/Subtype'] == '/Widget' and ('/Parent' in annotation):
key = annotation['/Parent']['/T'][1:-1] # Remove parentheses
if key in data_dict.keys():
annotation['/Parent'].update(pdfrw.PdfDict(V=f'{data_dict[key]}'))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def pdf_writer(input_pdf_path,
output_pdf_path=None,
data_dict=None,
lock=None):
ANNOT_KEY = '/Annots'
ANNOT_FIELD_KEY = '/T'
ANNOT_FORM_type = '/FT' # Form type (e.g. text/button)
ANNOT_FORM_button = '/Btn' # ID for buttons, i.e. a checkbox
ANNOT_FORM_text = '/Tx' # ID for textbox
ANNOT_VAL_KEY = '/V'
ANNOT_RECT_KEY = '/Rect'
SUBTYPE_KEY = '/Subtype'
WIDGET_SUBTYPE_KEY = '/Widget'
template_pdf = pdfrw.PdfReader(input_pdf_path)
annotation_col = []
for page in template_pdf.pages:
annotation_col.append(page[ANNOT_KEY])
if data_dict:
data_dict = data_dict
else:
data_dict = {} #creating empty dict, won't trigger later if statement
for annotations in annotation_col:
for annotation in annotations:
if type(annotation) != None:
if annotation[ANNOT_FIELD_KEY] and annotation[
SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY:
key = annotation[ANNOT_FIELD_KEY][1:-1]
if key in data_dict.keys():
try:
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
except:
print("didn't work boss")
if lock:
if lock == False:
annotation.update(pdfrw.PdfDict(Ff=0))
if lock == True:
annotation.update(pdfrw.PdfDict(Ff=1))
if output_pdf_path:
output_pdf_path = output_pdf_path
else:
output_pdf_path = input_pdf_path
template_pdf.Root.AcroForm.update(
pdfrw.PdfDict(NeedAppearances=pdfrw.PdfObject('true')))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def write_fillable_pdf(input_pdf_path, output_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 key in data_dict.keys():
annotation.update(pdfrw.PdfDict(T=data_dict[key]))
#annotation.update(
# pdfrw.PdfDict(AS='{}'.format(data_dict[key]))
# )
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def merge_two_pdfs(pdf: bytes, other: bytes) -> bytes:
"""Merges two PDFs into one PDF."""
writer = pdfrw.PdfWriter()
writer.addpages(pdfrw.PdfReader(fdata=pdf).pages)
writer.addpages(pdfrw.PdfReader(fdata=other).pages)
result_stream = BytesIO()
writer.write(result_stream)
result_stream.seek(0)
result = result_stream.read()
result_stream.close()
return result
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
annotations = template_pdf.pages[1][ANNOT_KEY]
print(annotations)
print('\n')
print('LINE')
print('\n')
for annotation in annotations:
if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY:
if annotation[ANNOT_FIELD_KEY]:
key = annotation[ANNOT_FIELD_KEY][1:-1]
print(key)
if key in data_dict.keys():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
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 write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path) #reads the file from the input_pdf_path that was passed in
annotations = template_pdf.pages[1][ANNOT_KEY] #populating data onto the second page of the pdf
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) #populates the fields of the pdf with the corresponding data from data_dict and writes it to the output_pdf_path that was passed in
data_dict = {
'show': '11/7/2018',
'judge': 'Bertha',
} #hardcoded info to populate the pdf's "show" and 'judge' fields
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 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 write_fillable_pdf(input_pdf_path, output_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 key in data_dict.keys():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
annotation.update(
pdfrw.PdfDict(AS=pdfrw.PdfName(str(data_dict[key]))))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
#def main():
#write_fillable_pdf(INVOICE_TEMPLATE_PATH, INVOICE_OUTPUT_PATH, data_dict)
'''charName = data_dict.get("CharacterName")
def append_pdf(self):
for item in self.results_buffer:
# pull the new page out of the work item
newpage = pdfrw.PdfReader(fdata=item.thing, verbose=False).pages[0]
# if necessary, create the output pdf
if self.pdf is None:
self.pdf = pdfrw.PdfWriter(self.options.general.pdfname,
version="1.4")
# add the page to the output pdf
self.pdf.addpage(newpage)
self.write_pdf()
# increase internal counter
self.last_written = item.number
self.results_buffer = []
def fill_pdf(data_dict):
template_pdf = pdfrw.PdfReader(Defendant_Form_TEMPLATE_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 key in data_dict.keys():
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key]))
# pdfrw.PdfDict(V=data_dict[key])
)
# print(template_pdf)
output_filename = Filled_Form_OUTPUT_PATH #+ str(random.randint(1000,9999))
pdfrw.PdfWriter().write(output_filename, template_pdf)
return output_filename
def writePDF(inputPath, outputPath, dataDict):
"""Function to fill in the forms of a PDF with values from Dict.
:param inputPath: Path of template PDF
:param outputPath: Path to make new PDF at
:param dataDict: Dictionary with keys with same name as form fields.
"""
templatePDF = pdfrw.PdfReader(inputPath)
annotations = templatePDF.pages[0][annotMarker]
for annotation in annotations:
if annotation[subMarker] == widgetMarker:
if annotation[fieldMarker]:
key = annotation[fieldMarker][1:-1]
if key in dataDict.keys():
annotation.update(pdfrw.PdfDict(V='{}'.format(dataDict[key])))
pdfrw.PdfWriter().write(outputPath, templatePDF)
def _make_pdf_pdfrw(fields: dict, src_pdf: str, basename: str, flatten: bool=False):
"""Backup make_pdf function in case pdftk is not available."""
template = pdfrw.PdfReader(src_pdf)
# Different types of PDF fields
BUTTON = '/Btn'
# Names for entries in PDF annotation list
DEFAULT_VALUE = '/DV'
APPEARANCE = '/MK'
FIELD = '/T'
PROPS = '/P'
TYPE = '/FT'
FLAGS = '/Ff'
SUBTYPE = '/Subtype'
ALL_KEYS = ['/DV', '/F', '/FT', '/Ff', '/MK', '/P', '/Rect',
'/Subtype', '/T', '/Type']
annots = template.pages[0]['/Annots']
# Update each annotation if it's in the requested dictionary
for annot in annots:
this_field = annot[FIELD][1:-1]
# Check if the field has a new value passed
if this_field in fields.keys():
val = fields[this_field]
# Convert integers to strings
if isinstance(val, int):
val = str(val)
log.debug(f"Set field '{this_field}' "
f"({annot[TYPE]}) "
f"to `{val}` ({val.__class__}) "
f"in file '{basename}.pdf'")
# Prepare a PDF dictionary based on the fields properties
if annot[TYPE] == BUTTON:
# Radio buttons require special appearance streams
if val == CHECKBOX_ON:
val = bytes(val, 'utf-8')
pdf_dict = pdfrw.PdfDict(V=val, AS=val)
else:
continue
else:
# All other widget types
pdf_dict = pdfrw.PdfDict(V=val)
annot.update(pdf_dict)
else:
log.debug(f"Skipping unused field '{this_field}' in file '{basename}.pdf'")
# Now write the PDF to the new pdf file
pdfrw.PdfWriter().write(f'{basename}.pdf', template)
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict):
# reads the file from the input_pdf_path that was passed in
template_pdf = pdfrw.PdfReader(input_pdf_path)
for i in range(1, 22):
# populating data onto the second page of the pdf
annotations = template_pdf.pages[i][ANNOT_KEY]
for annotation in annotations:
# print(annotation)
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():
# print(key + ": " + data_dict[key])
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
# populates the fields of the pdf with the corresponding data from data_dict and writes it to the output_pdf_path that was passed in
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def read_fillable_pdf2(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
annotations = template_pdf.pages[0][ANNOT_KEY]
i = 0
for annotation in annotations:
if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY:
if annotation[ANNOT_FIELD_KEY]:
key = annotation['/T'][1:-1]
# if parsedKey=='death_year':
# print('id=',i,'key=',key)
if (i == 22):
print("before: ", annotation)
annotation.update(pdfrw.PdfDict(AS='/1'))
print('id=', i, 'key=', key)
print('after: ', annotation)
# annotation.update(pdfrw.PdfDict(V=pdfrw.PdfName('Y')))
i += 1
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def optimize_pdf(filename, output, encode_params, parallel=None):
pdf = pdfrw.PdfReader(filename)
parallel = parallel or os.cpu_count()
with concurrent.futures.ThreadPoolExecutor(
max_workers=parallel) as executor:
futures = []
completed = 0
for page in pdf.pages:
# _optimize_obj(page, encode_params)
futures.append(executor.submit(_optimize_obj, page, encode_params))
total = len(futures)
for fut in concurrent.futures.as_completed(futures):
completed += 1
print('%d/%d %d%%\r' % (completed, total, 100 * completed / total),
end='')
print('Completed. Writing pdf...')
writer = pdfrw.PdfWriter(output, trailer=pdf)
writer.write()
def fill_pdf(input_pdf_path, output_pdf_path, data_dict):
template_pdf = pdfrw.PdfReader(input_pdf_path)
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]
if key in data_dict.keys():
if type(data_dict[key]) == bool:
if data_dict[key] == True:
annotation.update(
pdfrw.PdfDict(AS=pdfrw.PdfName('Yes')))
else:
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
annotation.update(pdfrw.PdfDict(AP=''))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
def _assign_uuid(self):
generated_pdf = pdfrw.PdfReader(self._output_path)
for i in range(len(generated_pdf.pages)):
annotations = generated_pdf.pages[i][self._ANNOT_KEY]
if annotations:
for annotation in annotations:
if self._ANNOT_FIELD_KEY in annotation.keys():
annotation.update(
pdfrw.PdfDict(
T="{}_{}".format(
annotation[self._ANNOT_FIELD_KEY][1:-1],
self._uuid,
),
Ff=pdfrw.PdfObject(1),
))
pdfrw.PdfWriter().write(self._final_path, generated_pdf)
def fill_pdf(data_dict):
template_pdf = pdfrw.PdfReader('5E_CharacterSheet_Fillable.pdf')
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]
if key in data_dict.keys():
if type(data_dict[key]) == bool:
if data_dict[key] == True:
annotation.update(
pdfrw.PdfDict(AS=pdfrw.PdfName('Yes')))
else:
annotation.update(
pdfrw.PdfDict(V='{}'.format(data_dict[key])))
annotation.update(pdfrw.PdfDict(AP=''))
pdfrw.PdfWriter().write('../Versao_final.pdf', template_pdf)
def write_fillable_pdf2(input_pdf_path, output_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 key in data_dict.keys():
annotation.update(
pdfrw.PdfDict(V=pdfrw.PdfName.Yes,
AS=pdfrw.PdfName.On,
AP=pdfrw.PdfName.Yes))
print(
pdfrw.PdfDict(V=pdfrw.PdfName.Yes,
AS=pdfrw.PdfName.On,
AP=pdfrw.PdfName.On))
pdfrw.PdfWriter().write(output_pdf_path, template_pdf)
