def create_match_sheet(match_num, blue_team=None, red_team=None, male=False,
female=False, a_team=False, b_team=False, c_team=False):
teams_canvas = canvas.Canvas("teams.pdf", pagesize=letter)
teams_canvas.setLineWidth(3)
xoffset, yoffset = 0, 0
if male:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
xoffset = 4.23 * inch
if female:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
yoffset = -.3 * inch
if c_team:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
xoffset = 0
if a_team:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
xoffset = 4.23/ 2 * inch
if b_team:
teams_canvas.ellipse(
3.2*inch + xoffset, 9.5*inch + yoffset,
2.4*inch + xoffset, 9.1*inch + yoffset)
teams_canvas.setFont('Helvetica', 24)
teams_canvas.drawString(1.7*inch, 7.8*inch, str(match_num))
teams_canvas.setFont('Helvetica', 18)
if blue_team:
teams_canvas.drawString(.65*inch, 6.65*inch, blue_team)
xoffset = 3.75*inch
if red_team:
teams_canvas.drawString(.65*inch + xoffset, 6.65*inch, red_team)
teams_canvas.save()
match_sheet_fn = '/home/user/dev/match_sheet/match_sheet.pdf'
teams_fn = 'teams.pdf'
output_fn = os.path.join(match_sheet_dir, 'match_%d.pdf' %(match_num))
output_canvas = PageMerge().add(PdfReader(match_sheet_fn).pages[0])[0]
trailer = PdfReader(teams_fn)
for page in trailer.pages:
PageMerge(page).add(output_canvas, prepend=True).render()
PdfWriter().write(output_fn, trailer)
return output_fn
def create_merged_pdf(in_pdf_dir):
"""Create merged pdf."""
writer = PdfWriter()
files = [x for x in os.listdir(in_pdf_dir) if x.endswith('.pdf')]
pagenums = [1]
pagenum = 1
for fname in natsorted(files):
page_length = len((PdfReader(os.path.join(in_pdf_dir, fname)).pages))
pagenum = pagenum + page_length
pagenums.append(pagenum)
writer.addpages(PdfReader(os.path.join(in_pdf_dir, fname)).pages)
outpdf = "tmp.pdf"
writer.write(outpdf)
del pagenums[-1] # we dont need last page number
return pagenums
def mark_pdf(clean_path, marked_path):
"""Draw rectangles around the boxes, lines, and characters in a document."""
try:
with open(os.path.join(clean_path)) as fp:
parser = PDFParser(fp)
pdf = PDFDocument(parser)
parser.set_document(pdf)
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
marked_dir, marked_fn = os.path.split(marked_path)
rect_file = os.path.join(marked_dir, ".rects." + marked_fn)
c = canvas.Canvas(rect_file)
for i, page in enumerate(PDFPage.create_pages(pdf)):
interpreter.process_page(page)
layout = device.get_result()
boxes = [obj for obj in layout if isinstance(obj, LTTextBox)]
for box in boxes:
c.setLineWidth(1)
c.setStrokeColorRGB(1, 0, 0)
make_rectangle(c, box.bbox)
lines = [obj for obj in box if isinstance(obj, LTTextLine)]
for line in lines:
c.setLineWidth(0.5)
c.setStrokeColorRGB(0, 1, 0)
make_rectangle(c, line.bbox)
for char in line:
if isinstance(char, LTChar):
c.setLineWidth(0.3)
c.setStrokeColorRGB(0, 0, 1)
make_rectangle(c, char.bbox)
c.showPage()
c.save()
pdf_content = PdfReader(clean_path)
for i, page in enumerate(pdf_content.pages):
rects = PageMerge().add(PdfReader(rect_file).pages[i])[0]
PageMerge(page).add(rects).render()
PdfWriter().write(marked_path, pdf_content)
os.remove(rect_file)
except Exception as e:
print(e)
def main():
args = parse_args()
page = PdfReader(args.pdf_filepath, decompress=True).pages[args.page_index]
target_substrings = [(encode(args.target_substring,
font2cmap(font))[1:-1].upper(), font_id)
for font_id, font in page.Resources.Font.items()]
target_substrings.append((args.target_substring, None))
contents = page.Contents if isinstance(page.Contents,
PdfArray) else [page.Contents]
matching_line = None
for content in contents:
for i, line in enumerate(content.stream.split('\n')):
for encoded_substring, font_id in target_substrings:
if encoded_substring in line:
matching_line = line
break # font_id is also captured here
if matching_line:
break
if matching_line:
break
if not matching_line:
raise IndexError('Target substring not found in PDF on page {}'.format(
args.page_index))
matching_str = matching_line.split('[')[1].split(']')[0]
if font_id is None:
print(matching_str)
else:
print(decode(matching_str, font2cmap(page.Resources.Font[font_id])))
def load_pdf(self):
"""
return: PdfReader object.
Can use index and slice obj.pages for the pages, then call Path.save_pdf to save
"""
from pdfrw import PdfReader
return PdfReader(self)
def __init__(self, controller):
self.controller = controller
self.selections = self.controller.selections
self._set_packet_type_id()
if self.packet_type_id:
# flags that indicate whether each of the files that need to be checked
# are being included in the packet
self.check_files_included = {i : False for i in self.check_files_ids}
self.addon_ids = []
self.missing_files = []
self.selected_reports = []
self.selected_report_attributes = []
self.selected_report_ids = []
self.output_path = ''
self.output_path_print = ''
self.packet_type = ''
self.output_name = self.output_names[self.selections.type_option]
self.is_liaison = ('Liaison' in self.selections.type_option)
self.create_print_file = False
self.total_pages = 0
self.blank_pdf_page = pagexobj(PdfReader(self.blank_pdf_path).pages[0])
self.pdf_converter = PdfConverter()
self._open_excel()
def pdf_generate_proc(file_template, file_pdf, receiver, price):
sys.stderr.write("*** pdf_generate_proc *** start ***\n")
#
pdf_canvas = canvas.Canvas(file_pdf)
#
fontname_g = "HeiseiKakuGo-W5"
pdfmetrics.registerFont(UnicodeCIDFont(fontname_g))
pdf_canvas.setFont(fontname_g, 16)
#
page = PdfReader(file_template, decompress=False).pages
pp = pagexobj(page[0])
pdf_canvas.doForm(makerl(pdf_canvas, pp))
#
today = datetime.today()
str_today = today.strftime('%Y-%m-%d')
#
pdf_canvas.drawString(400, 800, str_today)
pdf_canvas.drawString(100, 725, receiver)
pdf_canvas.drawString(100, 680, str(price))
#
draw_rect_proc(pdf_canvas)
#
pdf_canvas.showPage()
pdf_canvas.save()
#
sys.stderr.write("*** pdf_generate_proc *** end ***\n")
#
str_res = "Supdf_canvasess"
return str_res
def test_bookmarks_6():
pdf_bytes = FakeHTML(string='''
<h2>1</h2> h2 level 1
<h4>2</h4> h4 level 2
<h3>3</h3> h3 level 2
<h5>4</h5> h5 level 3
<h1>5</h1> h1 level 1
<h2>6</h2> h2 level 2
<h2>7</h2> h2 level 2
<h4>8</h4> h4 level 3
<h1>9</h1> h1 level 1
''').write_pdf()
# 1
# |_ 2
# L_ 3
# L_ 4
# 5
# |_ 6
# L_ 7
# L_ 8
# 9
outlines = PdfReader(fdata=pdf_bytes).Root.Outlines
assert outlines.Count == '9'
assert outlines.First.Title == '(1)'
assert outlines.First.First.Title == '(2)'
assert outlines.First.First.Next.Title == '(3)'
assert outlines.First.First.Next.First.Title == '(4)'
assert outlines.First.Next.Title == '(5)'
assert outlines.First.Next.First.Title == '(6)'
assert outlines.First.Next.First.Next.Title == '(7)'
assert outlines.First.Next.First.Next.First.Title == '(8)'
assert outlines.Last.Title == '(9)'
def add_footer(input_file, output_file):
logging.info("add_footer started")
# Get pages
reader = PdfReader("%s.pdf" % (input_file))
pages = [pagexobj(p) for p in reader.pages]
# Compose new pdf
canvas = Canvas("%s.pdf" % (output_file))
pdfmetrics.registerFont(
TTFont('SourceSansPro', 'SourceSansPro-Regular.ttf'))
for page_num, page in enumerate(pages, start=1):
# Add page
canvas.setPageSize((page.BBox[2], page.BBox[3]))
canvas.doForm(makerl(canvas, page))
# Draw footer
footer_text = "www.borderviolence.eu"
x = 80
canvas.saveState()
canvas.setStrokeColorRGB(0.19, 0.19, 0.19)
canvas.setLineWidth(0.3)
canvas.line(75, 78, page.BBox[2] - 66, 78)
canvas.setFont('SourceSansPro', 10)
canvas.setFillColor(HexColor(0x333333))
canvas.drawString(page.BBox[2] - x, 85, str(page_num))
canvas.drawString(page.BBox[2] - x - 436, 85, footer_text)
canvas.restoreState()
canvas.showPage()
canvas.save()
logging.info("PDF with footer %s.pdf was saved" % (output_file))
return 1
def upscale(file_name, scale=1.5, margin_x=0, margin_y=0, suffix='scaled', tempdir=None):
"""Upscale a PDF to a large size."""
def adjust(page):
info = PageMerge().add(page)
x1, y1, x2, y2 = info.xobj_box
viewrect = (margin_x, margin_y, x2 - x1 - 2 * margin_x, y2 - y1 - 2 * margin_y)
page = PageMerge().add(page, viewrect=viewrect)
page[0].scale(scale)
return page.render()
# Set output file name
if tempdir:
output = NamedTemporaryFile(suffix='.pdf', dir=tempdir, delete=False).name
elif suffix:
output = os.path.join(os.path.dirname(file_name), add_suffix(file_name, suffix))
else:
output = NamedTemporaryFile(suffix='.pdf').name
reader = PdfReader(file_name)
writer = PdfWriter(output)
for i in list(range(0, len(reader.pages))):
writer.addpage(adjust(reader.pages[i]))
writer.trailer.Info = IndirectPdfDict(reader.Info or {})
writer.write()
return output
def _create_overlay(self, data):
"""Create the filled in overlay"""
# initiate an overlay buffer where we will fill in the information
overlay_buffer = StringIO()
overlay_canvas = canvas.Canvas(overlay_buffer)
overlay_canvas.setFont('Times-Roman', 10)
# open a copy of the template form to fill in
self.form.seek(0)
template = PdfReader(self.form)
# for each field on each page, find the position and fill in the information
for page in template.Root.Pages.Kids:
for field in page.Annots:
sides_positions = [float(i) for i in field.Rect]
left = min(sides_positions[0], sides_positions[2])
bottom = min(sides_positions[1], sides_positions[3])
label = field.T.decode() if field.T else None
value = data.get(label, '')
overlay_canvas.drawString(
x=left + 2,
y=bottom + 1,
text=value,
)
overlay_canvas.showPage()
overlay_canvas.save()
overlay_buffer.seek(0)
return overlay_buffer
def makeA3(ipath, opath, onesided=False):
"""Take the first 4 (A4) pages of the input file and place them in
"booklet" order on an A3 sheet (double-sided, short-side join).
If <onesided> is <True>, or there are only two pages in the input file,
place the first two (A4) pages on one side of an A3 sheet, the first
page on the right-hand side.
Note that the input pages do not have to be A4, the output will simply
be twice as wide (as the first page). All input pages should have the same size.
"""
ipages = PdfReader(ipath).pages
# Make sure we have an even number of pages
if len(ipages) & 1:
ipages.append(None)
fpage = PageMerge()
fpage.add(ipages[0])
width = fpage[0].w
opages = []
if onesided or len(ipages) == 2:
p4 = ipages[1]
else:
p4 = ipages[3]
bpage = PageMerge()
bpage.add(ipages[1])
bpage.add(ipages[2], prepend=True)
bpage[0].x = width
opages.append(bpage.render())
if p4:
fpage.add(p4)
fpage[0].x = width
opages.insert(0, fpage.render())
PdfWriter().addpages(opages).write(opath)
def 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 extract_crossword(file_path: Path,
output_path: Path,
overwrite: bool = True) -> Path:
"""Save page with crossword.
Open a PDF document, search for a string identifying Le Monde
crossword, and save the corresponding page to a file.
Args:
file_path: Path of the PDF document to process
output_path: Path of the output directory
overwrite: Whether to overwrite existing files (default to True)
Returns:
Path of the saved file
"""
LOGGER.debug(f'Processing {file_path}')
max_extracted_pages = 15
rsrcmgr = PDFResourceManager(caching=True)
crossword_page = None
m = None
with open(file_path, 'rb') as f:
pages = [page for page in PDFPage.get_pages(f)]
LOGGER.debug(f'Found {len(pages)} pages')
first_checked_pageno = max(0, len(pages) - max_extracted_pages)
LOGGER.debug(f'Searching last {max_extracted_pages} pages first')
for i, page in enumerate(pages[first_checked_pageno:]):
m = _search_in_page(page, rsrcmgr)
if m:
crossword_page = first_checked_pageno + i
break
if not crossword_page:
LOGGER.debug(f'Extending search to all pages')
for i, page in enumerate(pages[:first_checked_pageno]):
m = _search_in_page(page, rsrcmgr)
if m:
crossword_page = i
break
if not crossword_page or not m:
raise CrosswordNotFoundError
LOGGER.debug(f'Crossword found on page {crossword_page}')
path = output_path / '{}.pdf'.format(m.group(1))
if path.exists() and not overwrite:
LOGGER.debug(f'File already exist ${path}')
raise FileAlreadyExistError
x = PdfReader(file_path)
page = x.pages[crossword_page]
y = PdfWriter()
y.addpage(page)
y.write(path)
return path
def ocr(tar_gz_filename, empty_page_threshold, language='eng'):
tar = tarfile.open(tar_gz_filename)
tar.extractall(path=TMP_DIR)
env = os.environ.copy()
env.update(dict(LD_LIBRARY_PATH=LIB_DIR, TESSDATA_PREFIX="{}/tessdata".format(SCRIPT_DIR)))
output = PdfWriter()
for filename in tar.getnames():
cmd = ['./tesseract', '-l', language,
'-c', 'min_orientation_margin=0', # don't leave out characters close to border
'{}/{}'.format(TMP_DIR, filename),
'{}/partial'.format(TMP_DIR),
'pdf']
try:
out = subprocess.check_output(cmd, cwd=SCRIPT_DIR, env=env, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
print('tesseract call failed, here\'s the output so far:')
print(e.output)
sys.exit(1)
print(out)
for p in PdfReader("{}/{}".format(TMP_DIR, "partial.pdf")).pages:
try:
if int(p.Contents['/Length']) < empty_page_threshold:
continue
except:
# if in doubt add the page
pass
output.addpage(p)
output.write('{}/output.pdf'.format(TMP_DIR))
for f in ['partial.pdf', DOWNLOAD_FILE] + tar.getnames():
os.remove("{}/{}".format(TMP_DIR, f))
return '{}/output.pdf'.format(TMP_DIR)
def test_relative_links_relative():
# Relative URI reference without a base URI: allowed for anchors
pdf_bytes = FakeHTML(string='<a href="../lipsum" style="display: block">',
base_url=None).write_pdf()
link, = PdfReader(fdata=pdf_bytes).Root.Pages.Kids[0].Annots
assert link.A == {'/URI': '(../lipsum)', '/S': '/URI', '/Type': '/Action'}
assert [round(float(value)) for value in link.Rect] == [0, TOP, RIGHT, TOP]
def subset_pdf(inp_file, ranges): # Create PDF with subset pages
ranges = ranges.split(' ')
for x in ranges: # If ranges is something like a word or negative
for y in x.split('-'):
try:
int(y)
except ValueError:
return -1
ranges = ([int(y) for y in x.split('-')] for x in ranges)
pages = PdfReader(inp_file).pages
out_data = PdfWriter(inp_file)
num_pages = 0
try:
for one_range in ranges:
one_range = (one_range + one_range[-1:])[:2]
for page_num in range(one_range[0], one_range[1] + 1):
out_data.addpage(pages[page_num - 1])
num_pages += 1
except IndexError: # If user gave invalid pages
return -1
out_data.write()
return num_pages
async def makePdf(Item: Item):
pdfBytes = base64.b64decode(Item.pdffile)
reader = PdfReader(fdata=pdfBytes)
annotator = PdfAnnotator(reader)
for i in Item.annotations:
if i.anType == "line":
await addLine(annotator, i)
elif i.anType == 'polyline':
await addLine(annotator, i)
elif i.anType == 'highlighter':
await addHighlight(annotator, i)
elif i.anType == 'highlighterPolyline':
await addHighlight(annotator, i)
elif i.anType == 'text':
await addText(annotator, i)
elif i.anType == 'identity':
await addIdentity(annotator, i)
# Creating file results
fileid = uuid.uuid4()
fileName = str(fileid) + ".pdf"
annotator.write(fileName)
encoded_string = ""
with open(fileName, "rb") as pdf_file:
encoded_string = base64.b64encode(pdf_file.read())
os.remove(fileName)
return {"result": encoded_string}
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 __init__(self,
filename_or_object,
width=None,
height=None,
kind="direct"):
if hasattr(filename_or_object, "read"):
filename_or_object.seek(0)
page = PdfReader(filename_or_object, decompress=False).pages[0]
self.xobj = pagexobj(page)
self.dynamic = 0
# Actual image size
x1, y1, x2, y2 = self.xobj.BBox
imgw, imgh = x2 - x1, y2 - y1
self._imgw, self._imgh = imgw, imgh
if kind in ["direct", "absolute"]:
self.drawWidth = width or imgw
self.drawHeight = height or imgh
elif kind in ["percentage", "%"]:
self.drawWidth = imgw * width * 0.01
self.drawHeight = imgh * height * 0.01
elif kind in ["bound", "proportional"]:
w, h = width or imgw, height or imgh
factor = min(float(w) / imgw, float(h) / imgh)
self.drawWidth = imgw * factor
self.drawHeight = imgh * factor
elif kind in ["dynamic"]:
self.dynamic = 1
def upload_book(request):
if request.method == 'POST':
form = BookForm(request.POST, request.FILES)
if form.is_valid():
form2 = form.save(commit=False)
inpfn = form.cleaned_data['pdf']
print(inpfn)
page_range = [int(y) for y in form.cleaned_data['page'].split('-')]
page_start = int(page_range[0])
page_end = int(page_range[1])
path = os.path.join('/books/pdfs', 'extracted_page_{}-{}.pdf'.format(page_start, page_end))
outfn = os.path.join('media', 'extracted_page_{}-{}.pdf'.format(page_start, page_end))
pages = PdfReader(inpfn).pages
outdata = PdfWriter(outfn)
page_range = (page_range + page_range[-1:])[:2]
for pagenum in range(page_range[0], page_range[1]+1):
outdata.addpage(pages[pagenum-1])
outdata.write()
form2.pdf = os.path.join('extracted_page_{}-{}.pdf'.format(page_start, page_end))
form2.save()
return redirect('book_list')
else:
form = BookForm()
return render(request, 'upload_book.html', {
'form': form
})
def re_arrange(file_path, output_file_name, dic):
"""
The function reorder takes two arguments path and dic
path is the path of the source pdf file which is in wrong
order and then creates a modified pdf file with pages in the right order.
Parameters:
path : Path of the pdf file to be modified
dic : A dictionary with key value pairs of pages.
Returns:
None
"""
file_path = Path(file_path)
# create a pdf object using PdfReader that could be read
pdf_obj = PdfReader(file_path)
# pdf_obj.pages attribute gives the length of the pages in pdf
total_pages = len(pdf_obj.pages)
print("Total Pages in PDF are:", total_pages)
# Initialising the writer object using the PdfWriter class,from this we would create a new modified Pdf
writer = PdfWriter()
# new and old here mean the new position of the "old" page location
for new, old in dic.items():
# indexing pages list
writer.addpage(pdf_obj.pages[old - 1])
print(f"page{new} added from {old}")
# accesing the name of the file without .pdf to save it with a new one
writer.write(Path(os.path.dirname(file_path) + "\\" + output_file_name))
def __init__(self,
filename_or_object,
width=None,
height=None,
kind='direct'):
# from reportlab.lib.units import inch
# If using StringIO buffer, set pointer to begining
if hasattr(filename_or_object, 'read'):
filename_or_object.seek(0)
page = PdfReader(filename_or_object, decompress=False).pages[0]
self.xobj = pagexobj(page)
self.imageWidth = width
self.imageHeight = height
x1, y1, x2, y2 = self.xobj.BBox
self._w, self._h = x2 - x1, y2 - y1
if not self.imageWidth:
self.imageWidth = self._w
if not self.imageHeight:
self.imageHeight = self._h
self.__ratio = float(self.imageWidth) / self.imageHeight
if kind in ['direct', 'absolute'] or width == None or height == None:
self.drawWidth = width or self.imageWidth
self.drawHeight = height or self.imageHeight
elif kind in ['bound', 'proportional']:
factor = min(float(width) / self._w, float(height) / self._h)
self.drawWidth = self._w * factor
self.drawHeight = self._h * factor
def strip_pages_pdf(indir,
infile,
outdir=None,
outfile=None,
numpages=1,
keep=False):
'''
Deletes the first pages from a PDF. Omit outfile name to replace. Default is one page.
If option keep is specified, keeps first pages of PDF, dropping rest.
'''
if outfile is None:
outfile = infile
if outdir is None:
outdir = indir
output = PdfWriter()
inpath = os.path.join(indir, infile)
outpath = os.path.join(outdir, outfile)
for i, page in enumerate(PdfReader(inpath).pages):
if not keep:
if i > (numpages - 1):
output.addpage(page)
if keep:
if i <= (numpages - 1):
output.addpage(page)
output.write(outpath)
def total_pdf_pages_in_tar_gz(tfn):
tar = tarfile.open(tfn, "r:gz")
errors = {}
pages = {}
for i, tarinfo in enumerate(tar):
name = tarinfo.name
name = name.split('/')[-1]
if tarinfo.isreg():
member = tar.getmember(tarinfo.name)
try:
f = tar.extractfile(member)
pdf = PdfReader(f)
count = len(pdf.pages)
pages[name] = count
except Exception as e:
pages[name] = 0
msg = e.msg
if msg in errors:
errors[msg] += 1
else:
errors[msg] = 1
finally:
f.close()
elif tarinfo.isdir():
pass
else:
print("something else.")
return (pages, errors)
def test_html_to_pdf(self):
output = BytesIO()
for chunk in PDFStreamer(HTMLParser(self.html, CSS(''))):
output.write(chunk)
pdf = PdfReader(fdata=output.getvalue())
self.assertEqual(pdf['/Info']['/Producer'], '(bericht)')
self.assertEqual(pdf['/Root']['/Pages']['/Count'], '3')
def go(inpfn, outfn):
reader = PdfReader(inpfn, decompress=False)
page, = reader.pages
writer = PdfWriter()
writer.addpage(adjust(page))
writer.trailer.Info = IndirectPdfDict(reader.Info)
writer.write(outfn)
def new_page():
fpdf = FPDF()
fpdf.add_page()
fpdf.set_font("helvetica", size=36)
fpdf.text(50, 50, "Hello!")
reader = PdfReader(fdata=bytes(fpdf.output()))
return reader.pages[0]
def pdf_insert_doi_using_pdfrw(req_content, doi):
input_file = io.BytesIO(req_content)
pdf_buffer = io.BytesIO()
reader = PdfReader(input_file)
pages = [pagexobj(p) for p in reader.pages]
canvas = Canvas(pdf_buffer)
for page_num, page in enumerate(pages, start=1):
canvas.setPageSize((page.BBox[2], page.BBox[3]))
canvas.doForm(makerl(canvas, page))
# Draw footer
if page_num == 1:
footer_text = "https://doi.org/{}".format(doi)
canvas.saveState()
canvas.setFont("Helvetica-Bold", 8)
canvas.setFillColor(HexColor('#990100'))
canvas.drawCentredString(page.BBox[2] / 2, 20, footer_text)
canvas.restoreState()
canvas.showPage()
canvas.save()
pdf_bytes = pdf_buffer.getbuffer()
return pdf_bytes
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)
