def create_bookmarks(bookmarks, pages, parent=None): count = len(bookmarks) bookmark_objects = [] for label, target, children in bookmarks: destination = (pages[target[0]].indirect, PdfName('XYZ'), target[1], target[2], 0) bookmark_object = PdfDict(Title=PdfString.encode(label), A=PdfDict(Type=PdfName('Action'), S=PdfName('GoTo'), D=PdfArray(destination))) bookmark_object.indirect = True children_objects, children_count = create_bookmarks( children, pages, parent=bookmark_object) bookmark_object.Count = 1 + children_count if bookmark_objects: bookmark_object.Prev = bookmark_objects[-1] bookmark_objects[-1].Next = bookmark_object if children_objects: bookmark_object.First = children_objects[0] bookmark_object.Last = children_objects[-1] if parent is not None: bookmark_object.Parent = parent count += children_count bookmark_objects.append(bookmark_object) return bookmark_objects, count
def _create_pdf_attachment(attachment, url_fetcher): """ Create an attachment to the PDF stream :return: the object representing the ``/Filespec`` object or :obj:`None` if the attachment couldn't be read. """ try: # Attachments from document links like <link> or <a> can only be URLs. # They're passed in as tuples if isinstance(attachment, tuple): url, description = attachment attachment = Attachment(url=url, url_fetcher=url_fetcher, description=description) elif not isinstance(attachment, Attachment): attachment = Attachment(guess=attachment, url_fetcher=url_fetcher) with attachment.source as (source_type, source, url, _): if isinstance(source, bytes): source = io.BytesIO(source) pdf_file_object = _create_compressed_file_object(source) except URLFetchingError as exc: LOGGER.error('Failed to load attachment: %s', exc) return None # TODO: Use the result object from a URL fetch operation to provide more # details on the possible filename return PdfDict(Type=PdfName('Filespec'), F=PdfString.encode(''), UF=PdfString.encode(_get_filename_from_result(url, None)), EF=PdfDict(F=pdf_file_object), Desc=PdfString.encode(attachment.description or ''))
def fixpage(page, watermark): # Find the page's resource dictionary. Create if none resources = page.inheritable.Resources if resources is None: resources = page.Resources = PdfDict() # Find or create the parent's xobject dictionary xobjdict = resources.XObject if xobjdict is None: xobjdict = resources.XObject = PdfDict() # Allow for an infinite number of cascaded watermarks index = 0 while 1: watermark_name = '/Watermark.%d' % index if watermark_name not in xobjdict: break index += 1 xobjdict[watermark_name] = watermark # Turn the contents into an array if it is not already one contents = page.Contents if not isinstance(contents, PdfArray): contents = page.Contents = PdfArray([contents]) # Save initial state before executing page contents.insert(0, IndirectPdfDict(stream='q\n')) # Restore initial state and append the watermark contents.append(IndirectPdfDict(stream='Q %s Do\n' % watermark_name)) return page
def write_fillable_pdf(self, input_pdf_path, output_pdf_path, data_dict): template_pdf = PdfReader(input_pdf_path) for index, _ in enumerate(template_pdf.pages): annotations = template_pdf.pages[index][self.ANNOT_KEY] if hasattr(annotations, "__len__"): for annotation in annotations: if annotation[self.SUBTYPE_KEY] == self.WIDGET_SUBTYPE_KEY: if self.ANNOT_FIELD_KEY in annotation: key = annotation[self.ANNOT_FIELD_KEY][1:-1] if key in data_dict.keys(): value = data_dict[key] if annotation["/FT"] == "/Tx": if value != "-": annotation.update( PdfDict( V='{}'.format(value.upper()))) elif annotation[ "/FT"] == "/Btn" and value == "Yes": annotation.update( PdfDict(V=objects.pdfname.BasePdfName( '/Yes'))) annotation.update(PdfDict(Ff=1)) template_pdf.Root.AcroForm.update( PdfDict(NeedAppearances=PdfObject('true'))) PdfWriter().write(output_pdf_path, template_pdf)
def _create_compressed_file_object(source): """ Create a file like object as ``/EmbeddedFile`` compressing it with deflate. :return: the object representing the compressed file stream object """ md5 = hashlib.md5() compress = zlib.compressobj() pdf_file_object = PdfDict(Type=PdfName('EmbeddedFile'), Filter=PdfName('FlateDecode')) # pdfrw needs Latin-1-decoded unicode strings in object.stream pdf_file_object.stream = '' size = 0 for data in iter(lambda: source.read(4096), b''): size += len(data) md5.update(data) pdf_file_object.stream += compress.compress(data).decode('latin-1') pdf_file_object.stream += compress.flush(zlib.Z_FINISH).decode('latin-1') pdf_file_object.Params = PdfDict(CheckSum=PdfString('<{}>'.format( md5.hexdigest())), Size=size) return pdf_file_object
def fill_form(input_file, output_file, data): """input_file can be file object or path name output_file can be file object or path name data is dictionary with keys corresponding to the form fields""" the_pdf = PdfReader(input_file) for page in the_pdf.pages: annotations = page[ANNOT_KEY] for annotation in annotations: if annotation[SUBTYPE_KEY] == WIDGET_SUBTYPE_KEY: key = annotation[ANNOT_FIELD_KEY][1:-1] if key in data.keys(): val = data[key] if val == None: # skip nulls continue if val == True: # treat booleans as checkboxes annotation.update(PdfDict(V=PdfName("On"))) else: # set annotation value annotation.update(PdfDict(V="{}".format(val))) # and empty appearance to make field visible in Apple Preview annotation.update(PdfDict(AP="")) # mark the fields as un-editable annotation.update(PdfDict(Ff=1)) # set NeedAppearances to ensure the fields are visible in Adobe Reader if the_pdf.Root.AcroForm: the_pdf.Root.AcroForm.update( PdfDict(NeedAppearances=PdfObject("true"))) PdfWriter().write(output_file, the_pdf)
def fixpage(*pages): pages = [pagexobj(x) for x in pages] class PageStuff(tuple): pass x = y = 0 for i, page in enumerate(pages): index = '/P%s' % i shift_right = x and '1 0 0 1 %s 0 cm ' % x or '' stuff = PageStuff((index, page)) stuff.stream = 'q %s%s Do Q\n' % (shift_right, index) x += page.BBox[2] y = max(y, page.BBox[3]) pages[i] = stuff # Multiple copies of first page used as a placeholder to # get blank page on back. for p1, p2 in zip(pages, pages[1:]): if p1[1] is p2[1]: pages.remove(p1) return IndirectPdfDict( Type=PdfName.Page, Contents=PdfDict(stream=''.join(page.stream for page in pages)), MediaBox=PdfArray([0, 0, x, y]), Resources=PdfDict(XObject=PdfDict(pages), ), )
def popup_bg_links(show_ocmd, ocgs): from pdfrw import PdfDict, PdfArray, PdfName if not pdf_popup_config['backgroundlink']: return if pdf_popup_config['backgroundlink'] not in ('front', 'back'): raise ValueError( "pdf_popup_config['backgroundlink'] must be front or back or None") for page in popup_pdf.pages: rect = page.MediaBox if pdf_popup_config['backgroundlink-debug']: rect = [90, 800, 180, 200] link = PdfDict( indirect=True, Type=PdfName.Annot, H=PdfName.N, Subtype=PdfName.Link, Rect=rect, #F=2, # Link is hidden Border=[0, 0, 10] if pdf_popup_config['backgroundlink-debug'] else [0, 0, 0], C=[1, 0, 0] if pdf_popup_config['backgroundlink-debug'] else None, OC=show_ocmd, A=PdfDict(S=PdfName.SetOCGState, State=PdfArray([PdfName.OFF] + ocgs)), ) if page.Annots == None: page.Annots = PdfArray() if pdf_popup_config['backgroundlink'] == 'back': page.Annots.insert(0, link) elif pdf_popup_config['backgroundlink'] == 'front': page.Annots.append(link) else: raise RuntimeException("Unexpected value")
def generate_pdf_outline(pdf, contents, parent=None): if parent is None: parent = PdfDict(indirect=True) if not contents: return parent first = prev = None for k, row in enumerate(contents): page = pdf.writer.pagearray[int(row['pnum'])-1] bookmark = PdfDict( Parent=parent, Title=row['label'], A=PdfDict( D=[page, PdfName.Fit], S=PdfName.GoTo ), indirect=True ) children = row.get('children') if children: bookmark = generate_pdf_outline(pdf, children, bookmark) if first: bookmark[PdfName.Prev] = prev prev[PdfName.Next] = bookmark else: first = bookmark prev = bookmark parent[PdfName.Count] = k + 1 parent[PdfName.First] = first parent[PdfName.Last] = prev return parent
def add_payload(name, output, path): print('[*] Reading PDF file: %s' % name) reader = PdfReader(name) print('[*] Injecting the payload in the PDF file...') reader.pages[0].AA = PdfDict( O=PdfDict(F=r'%s' % path, D=[0, PdfName('Fit')], S=PdfName('GoToE'))) writer = PdfWriter() writer.addpages(reader.pages) print('[*] Saving modified PDF as: %s' % output) writer.write(output) print('[*] Done!')
def fillPDF(pdf_file, fields, workId): pdf = PdfReader(pdf_file) anns = pdf.pages[0]['/Annots'] for ann in anns: key = ann['/T'][1:-1] if key in fields: ann.update(PdfDict(V='{}'.format(fields[key]))) filename = 'registro{}_s{}-{}{}.pdf'.format(workId, fields['Semana'], fields['Mes'], fields['Anio']) pdf.Root.AcroForm.update(PdfDict(NeedAppearances=PdfObject('true'))) PdfWriter().write(filename, pdf) print(filename)
def aggr_pdf(pdfname, pdfpaths, origin_directory): params = setup() (G, o, g1, g2, e) = params # ä»å¤äøŖę件äøčÆ»åŗęęē¾å sigs = [] for path in pdfpaths: pdf = PdfReader(path + os.path.sep + pdfname) try: sig_str:str = pdf.Info.signature sig_str = sig_str[1:-1] sig_bytes = base64.b64decode( sig_str.encode("utf-8") ) sig_g1elem = G1Elem.from_bytes(sig_bytes,G) except: sig_g1elem = None sigs.append(sig_g1elem) print('all_sigs:',sigs) # čåęęē¾å sigma = aggregate_sigma(params, sigs) print('type sigma:',type(sigma)) sigma_bytes = sigma.export() sigma_str = base64.b64encode(sigma_bytes).decode() # å°čååēē¾åååčæč”č·Æå¾äøę°å»ŗē仄blockstackidå½åēpdfäø pdf = PdfReader(origin_directory + os.path.sep + pdfname) metadata_new = PdfDict(signature = sigma_str) pdf.Info.update(metadata_new) PdfWriter().write(pdfname, pdf)
def get_form_fields_from_fdf(pdf_file_path): try: pdf_reader = PdfReader(pdf_file_path) except errors.PdfParseError: print(f'File \'{pdf_file_path}\' not found please specify full path') return None try: # Check if PDF has Form Fields and if we can read them pdf_form_fields = pdf_reader.Root.AcroForm.Fields except AttributeError: print(f'File \'{pdf_file_path}\' no Form Fields') return None # Create an empty PdfDict to collect Form Fields and Values pdf_metadata = PdfDict() # Define list of Form Fields to be ignored from transfer to PdfDict # For example: field Sig ignore_fields = ('/Sig',) # Load Form Fields into PdfDict for field in pdf_form_fields: if field.FT not in ignore_fields: field_name = field.T if field_name is not None: key_name = PdfName(field_name.decode()) pdf_metadata[key_name] = field.V return pdf_metadata
def apply_updated_text(document, text_tokens, page_tokens): # Create a new content stream for each page by concatenating the # tokens in the page_tokens lists. from pdfrw import PdfArray for i, page in enumerate(document.pages): if page.Contents is None: continue # nothing was here # Replace the page's content stream with our updated tokens. # The content stream may have been an array of streams before, # so replace the whole thing with a single new stream. Unfortunately # the str on PdfArray and PdfDict doesn't work right. def tok_str(tok): if isinstance(tok, PdfArray): return "[ " + " ".join(tok_str(x) for x in tok) + "] " if isinstance(tok, InlineImage): return "BI " + " ".join( tok_str(x) + " " + tok_str(y) for x, y in tok.items()) + " ID " + tok.stream + " EI " if isinstance(tok, PdfDict): return "<< " + " ".join( tok_str(x) + " " + tok_str(y) for x, y in tok.items()) + ">> " return str(tok) page.Contents = PdfDict() page.Contents.stream = "\n".join( tok_str(tok) for tok in page_tokens[i]) page.Contents.Length = len(page.Contents.stream) # reset
def remove_chainpoint_proof_and_hash(pdf_file): filename = os.path.basename(pdf_file) tmp_filename = '__' + filename shutil.copy(pdf_file, tmp_filename) # get txid and target hash from proof pdf = PdfReader(tmp_filename) try: proof = json.loads(pdf.Info.chainpoint_proof.decode()) except AttributeError: # TODO: log error return None, None except json.decoder.JSONDecodeError: # TODO: log error return None, None txid = proof['anchors'][0]['sourceId'] targetHash = proof['targetHash'] # remove the proof and get the hash metadata = PdfDict(chainpoint_proof='') pdf.Info.update(metadata) PdfWriter().write(tmp_filename, pdf) cert_hash = None with open(tmp_filename, 'rb') as cert: # note that the cert_hash is a hash object -- can use hexdigest() to debug cert_hash = hashlib.sha256(cert.read()) os.remove(tmp_filename) if targetHash == cert_hash.hexdigest(): return cert_hash.digest(), txid else: return None, None
def _fill_pdf_metadata(out_file, issuer, issuer_address, columns, data): # create metadata objest (json) metadata_object = {} metadata_fields = columns.split(",") for md in metadata_fields: if md in data: metadata_object[md] = data[md] # issuer and issuer_address used to go as separate metadata fields # but now go to the metadata_object. They are still compulsory! # The validator that reads metadata requires to look for issuer and # issuer_address both in the metadata_object and if not fount it has # to look for them as separate metadata fields for backwards # compatibility (certificates issued with v0.9.3 and before) metadata_object['issuer'] = issuer metadata_object['issuer_address'] = issuer_address # add the metadata metadata = PdfDict(metadata_object=json.dumps(metadata_object), chainpoint_proof='') pdf = PdfReader(out_file) pdf.Info.update(metadata) PdfWriter().write(out_file, pdf) # print progress print('.', end="", flush=True)
def write_fillable_pdf(input_pdf_path, output_pdf_path, data_dict): template_pdf = PdfReader(input_pdf_path) # Para que se vean los campos rellenados template_pdf.Root.AcroForm.update( PdfDict(NeedAppearances=PdfObject('true'))) 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(): #HACK PARA LOS CHECK - Guardar documento a mano con los checks que sean. Y aquĆ si es un check, evitarlo y no cambiar if key == "untitled6" or key == "untitled21" or key == "untitled22" or key == "untitled23" or key == "untitled24" or key == "untitled25": continue #this depends on page orientation rct = annotation.Rect hight = round(float(rct[3]) - float(rct[1]), 2) width = (round(float(rct[2]) - float(rct[0]), 2)) xobj = PdfDict( BBox=[0, 0, width, hight], FormType=1, Resources=PdfDict( ProcSet=[PdfName.PDF, PdfName.Text]), Subtype=PdfName.Form, Type=PdfName.XObject) #assign a stream to it xobj.stream = '''/Tx BMC BT /Helvetica 8.0 Tf 1.0 5.0 Td 0 g (''' + data_dict[key] + ''') Tj ET EMC''' annotation.update( PdfDict(AP=PdfDict(N=xobj), V='{}'.format(data_dict[key]))) #annotation.update(pdfrw.PdfDict(V='{}'.format(data_dict[key]),AP='{}'.format(data_dict[key]))) PdfWriter().write(output_pdf_path, template_pdf)
def insert_proof_to_certificates(conf, cp, txid, cert_files): print('') for ind, val in enumerate(cert_files): proof = json.dumps(cp.get_receipt(ind, txid)) metadata = PdfDict(chainpoint_proof=proof) pdf = PdfReader(val) pdf.Info.update(metadata) PdfWriter().write(val, pdf)
def getPages(allpages, x, y, gap): # Number of pages to combine count = x * y # Pull pages off the list pages = [pagexobj(p) for p in allpages[:count]] del allpages[:count] # Out page size width_max = max(page.BBox[2] for page in pages) height_max = max(page.BBox[3] for page in pages) stream = [] xobjdict = PdfDict() line = y for index, page in enumerate(pages): width = (index % x) * width_max / x if not width: line = line - 1 height = line * height_max / y # Page number index = '/P{}'.format(index) format_stream = { "x": 1. / x - gap, "y": 1. / y - gap, "w": width, "h": height, "i": index } stream.append( 'q {x} 0 0 {y} {w} {h} cm {i} Do Q\n'.format(**format_stream)) xobjdict[index] = page return PdfDict( Type=PdfName.Page, Contents=PdfDict(stream=''.join(stream)), MediaBox=PdfArray([-1000 * gap, -1000 * gap, width_max, height_max]), Resources=PdfDict(XObject=xobjdict), )
def get_and_remove_chainpoint_proof(pdf_file): pdf = PdfReader(pdf_file) try: proof = json.loads(pdf.Info.chainpoint_proof.decode()) except AttributeError: return None metadata = PdfDict(chainpoint_proof='') pdf.Info.update(metadata) PdfWriter().write(pdf_file, pdf) return proof
def pdfobjs(self): """Returns a tuple of two elements to insert in the PageLabels.Nums entry of a pdf""" pagenum = PdfObject(self.startpage) opts = PdfDict(S=styles[self.style]) if self.prefix != defaults["prefix"]: opts.P = PdfString.encode(self.prefix) if self.firstpagenum != defaults["firstpagenum"]: opts.St = PdfObject(self.firstpagenum) return (pagenum, opts)
def _build_certificate_of_mailing_pdf( user_information: Dict[str, str]) -> PdfReader: form = from_dict(data_class=CertificateFormData, data=user_information) pdf_path = path.join( Path(__file__).parent, "files", f"certificate_of_mailing.pdf") pdf = PdfReader(pdf_path) for field in pdf.Root.AcroForm.Fields: field_name = field.T.lower().replace(" ", "_").replace("(", "").replace( ")", "") field_value = getattr(form, field_name) field.V = field_value for page in pdf.pages: annotations = page.get("/Annots") if annotations: for annotation in annotations: annotation.update(PdfDict(AP="")) pdf.Root.AcroForm.update(PdfDict(NeedAppearances=PdfObject("true"))) return pdf
def make_image_xobject(image): """Construct a PdfDict representing the Image XObject, for inserting into the AP Resources dict. PNGs and GIFs are treated equally - the raw sample values are included using PDF's FlateDecode compression format. JPEGs can be included in their original form using the DCTDecode filter. PNGs with transparency have the alpha channel split out and included as an SMask, since PDFs don't natively support transparent PNGs. Details about file formats and allowed modes can be found at https://pillow.readthedocs.io/en/5.3.x/handbook/image-file-formats.html :param str|ImageFile image: Either a str representing the path to the image filename, or a PIL.ImageFile.ImageFile object representing the image loaded using the PIL library. :returns PdfDict: Image XObject """ image = Image.resolve_image(image) # PILImage.convert drops the format attribute image_format = image.format width, height = image.size # Normalize images to RGB or grayscale color spaces, and split out the # alpha layer into a PDF smask XObject image, smask_xobj = Image.convert_to_compatible_image( image, image_format, ) if image_format in ('PNG', 'GIF'): content = Image.make_compressed_image_content(image) filter_type = 'FlateDecode' # TODO use a predictor elif image_format == 'JPEG': content = Image.make_jpeg_image_content(image) filter_type = 'DCTDecode' else: raise ValueError( 'Unsupported image format: {}. Supported formats are ' 'PNG, JPEG, and GIF'.format(image.format)) xobj = PdfDict( stream=content, BitsPerComponent=8, Filter=PdfName(filter_type), ColorSpace=Image._get_color_space_name(image), Width=width, Height=height, Subtype=PdfName('Image'), Type=PdfName('XObject'), ) if smask_xobj is not None: xobj.SMask = smask_xobj return xobj
def popup_make_ocgs(num): from pdfrw import PdfDict, PdfArray, PdfName n = 2 while choose(n, n / 2) < num: n += 1 ocgs = [] for i in range(n): ocg = PdfDict(Type=PdfName.OCG, Name="OCG {}".format(i), indirect=True) ocgs.append(ocg) if popup_pdf.Root.OCProperties: print "Root.OCProperties already exists" ocgs = PdfArray(ocgs) #ocgs.indirect = True popup_pdf.Root.OCProperties = PdfDict(OCGs=ocgs, D=PdfDict(Order=ocgs, ON=[], OFF=ocgs)) code = [([], [])] for ocg in ocgs: code = [(c + [ocg], d) if take else (c, d + [ocg]) for c, d in code for take in (True, False)] code = [(c, d) for c, d in code if len(c) == n / 2] # code is now an array of all different pairs (c,d) # where c contains floor(n/2) OCGs and d the rest of the OCGs hide_ocmd = PdfDict(indirect=True, Type=PdfName.OCMD, OCGs=ocgs, P=PdfName.AllOff) show_ocmd = PdfDict(indirect=True, Type=PdfName.OCMD, OCGs=ocgs, P=PdfName.AnyOn) return code, ocgs, hide_ocmd, show_ocmd
def populateSheet(character, context, options=default_options): pdfPath = Path(context.function_directory) pdf = PdfReader(pdfPath / options['template']) pdf.Root.AcroForm.update(PdfDict(NeedAppearances=PdfObject('true'))) populateFields(character, pdf.Root.AcroForm.Fields) output = BytesIO() PdfWriter().write(output, pdf) output.seek(0) return output.read()
def test_indirect_set_get(self): io = PdfIndirect((1, 2, 3)) io.value = 42 d = PdfDict() d.Name = io test, = (x for x in dict.values(d)) self.assertEqual(test, io) v = d['/Name'] self.assertEqual(v, io.value) test, = d self.assertEqual(type(test), type(PdfName.Name))
def _fill_pdf_metadata(out_file, issuer, issuer_address, column_fields, data, global_columns, verify_issuer, interactive=False): # create version version = 1 # create issuer object (json) issuer = { "name": issuer, "identity": { "address": issuer_address, "verification": json.loads(verify_issuer)['methods'] } } # create metadata object (json) and add metadata metadata = {} # add custom metadata if column_fields: metadata_fields = json.loads(column_fields)['columns'] for f in metadata_fields: key = list(f)[0] if key in data: field_properties = f[key] field_properties['value'] = data[key] metadata[key] = field_properties # add global field metadata if global_columns: global_fields = json.loads(global_columns)['fields'] for g in global_fields: key = list(g)[0] # note that global fields override column data metadata[key] = g[key] # add the metadata pdf_metadata = PdfDict(version=version, issuer=json.dumps(issuer), metadata=json.dumps(metadata), chainpoint_proof='') pdf = PdfReader(out_file) pdf.Info.update(pdf_metadata) PdfWriter().write(out_file, pdf) if interactive: # print progress print('.', end="", flush=True)
def make_popup(page, rect, popupname, popup, code): from pdfrw import PdfDict, PdfArray, PdfName from pdfrw.uncompress import uncompress codeword_on, codeword_off = code show_action = PdfDict(S=PdfName.SetOCGState, State=PdfArray([PdfName.OFF] + codeword_off + [PdfName.ON] + codeword_on)) link = PdfDict(indirect=True, Type=PdfName.Annot, H=PdfName.I, Subtype=PdfName.Link, A=show_action, Rect=rect) if pdf_popup_config['popuplinkcolor']: link.C = PdfArray(pdf_popup_config['popuplinkcolor']) else: link.Border = [0, 0, 0] page.Annots.append(link) ocmd = PdfDict(Type=PdfName.OCMD, OCGs=codeword_on, P=PdfName.AllOn) popup_pdfname = '/SPopup' + popupname ocmd_pdfname = '/SPopupOCMD{}'.format(popup_unique_id()) if not page.Resources.Properties: page.Resources.Properties = PdfDict() if not page.Resources.XObject: page.Resources.XObject = PdfDict() page.Resources.XObject[popup_pdfname] = popup page.Resources.Properties[ocmd_pdfname] = ocmd if page.Contents.Filter: uncompress( [page.Contents] ) # Important. Otherwise appending to stream add plain text to compressed stream page.Contents.stream += "q /OC {ocmd} BDC 1 0 0 1 {x} {y} cm {popup} Do EMC Q\n".\ format(x=rect[0],y=float(rect[1])-popup.BBox[3], ocmd=ocmd_pdfname, popup=popup_pdfname)
def insert_proof_to_certificates(conf, cp, txid, cert_files, interactive=False): if interactive: print('') for ind, val in enumerate(cert_files): proof = json.dumps( cp.get_receipt(ind, txid) ) metadata = PdfDict(chainpoint_proof=proof) pdf = PdfReader(val) pdf.Info.update(metadata) PdfWriter().write(val, pdf) if interactive: # print progress print('.', end="", flush=True)
def make_font_object(): """Make a PDF Type1 font object for embedding in the annotation's Resources dict. Only Helvetica is supported as a base font. :returns PdfDict: Resources PdfDict object, ready to be included in the Resources 'Font' subdictionary. """ return PdfDict( Type=PdfName('Font'), Subtype=PdfName('Type1'), BaseFont=PdfName(DEFAULT_BASE_FONT), Encoding=PdfName('WinAnsiEncoding'), )