def run():
inpdir=os.path.abspath('./input')
outdir=os.path.abspath('./tmp')
# Discard output, this is not about whether things
# work or not, that's testing ;-)
for f in os.listdir(inpdir):
if f.endswith('.txt'): # Test case
print 'Running: ', f
sheet=os.path.join(inpdir, f[:-4]+'.style')
if os.path.exists(sheet):
sheet=[sheet]
else:
sheet=[]
r2p=RstToPdf(stylesheets=sheet)
try:
fname=os.path.join(inpdir, f)
r2p.createPdf(
text=open(fname).read(),
output=os.path.join(outdir,f+'.pdf'),
source_path=fname,
)
except:
print 'FAIL'
def renderQueue(render_queue, pdf_queue, doctree_queue):
_renderer = RstToPdf(splittables=True)
def render(doctree, preview=True):
'''Render text to PDF via rst2pdf'''
# FIXME: get parameters for this from somewhere
sio=StringIO()
_renderer.createPdf(doctree=doctree, output=sio, debugLinesPdf=preview)
return sio.getvalue()
while True:
try:
style_file, text, preview = render_queue.get(10)
style_file, text, preview = render_queue.get(False)
except Empty: # no more things to render, so do it
try:
if style_file:
_renderer.loadStyles([style_file])
flag = True
#os.unlink(style_file)
warnings=StringIO()
doctree = docutils.core.publish_doctree(text,
settings_overrides={'warning_stream':warnings})
doctree_queue.put([doctree,warnings.getvalue()])
pdf_queue.put(render(doctree, preview))
except Exception as e:
# Don't crash ever ;-)
print(e)
pass
if os.getppid()==1: # Parent died
sys.exit(0)
def _generate_pdf(self, rst_file_path, result_pdf_path):
"""
Generates a PDF file based on the input RST file.
"""
if not os.path.exists(rst_file_path):
raise DocGenerateException(
"Provided RST file: %s does not exists." % rst_file_path)
# We suppose all RST files have references relative to their folder
# So we have to force rst2pdf to be executed in the folder where RST file resides.
basedir = os.path.split(rst_file_path)[0]
baseurl = "file://" + basedir
r2p = RstToPdf(style_path=[self._styles_folder],
stylesheets=[self.PDF_STYLE],
basedir=basedir,
baseurl=baseurl,
breakside="any")
try:
with open(rst_file_path) as file_rst:
content = file_rst.read()
r2p.createPdf(text=content,
source_path=rst_file_path,
output=result_pdf_path)
self.logger.debug("PDF file %s generated successfully." %
result_pdf_path)
except Exception, ex:
self.logger.exception("Could not generate PDF documentation")
raise DocGenerateException("Could not generate PDF documentation",
ex)
def __init__(self, *args, **kwargs):
try:
from rst2pdf.createpdf import RstToPdf
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=['twelvepoint'])
except ImportError:
raise Exception("unable to find rst2pdf")
super(PdfGenerator, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
pdf_style_path = os.path.join(self.settings['PDF_STYLE_PATH'])
pdf_style = self.settings['PDF_STYLE']
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=[pdf_style],
style_path=[pdf_style_path])
def download(self, pageid):
p = model.FlatPage.by_id(pageid) or abort(404)
out = BytesIO()
rst2pdf = RstToPdf()
rst2pdf.createPdf(p.content, output=out)
out.seek(0)
return out.read()
def rst2pdf(content, theme=None):
topdf = RstToPdf(basedir=current_app.config.root_path, breaklevel=0)
buf = BytesIO()
if not content:
content = '\0'
content_utf8 = utf8codec.encode(content)[0]
topdf.createPdf(text=content_utf8, output=buf, compressed=False)
return buf.getvalue()
def rst2pdf(content, theme=None):
topdf = RstToPdf(basedir=current_app.config.root_path, breaklevel=0)
buf = StringIO()
if not content:
content = '\0'
content_utf8 = utf8codec.encode(content)[0]
topdf.createPdf(text=content_utf8, output=buf, compressed=False)
return buf.getvalue()
def pdf_output(locale, **extra_settings):
if "styleshees" not in extra_settings:
extra_settings["stylesheets"] = load_stylesheets("*.style")
if "breaklevel" not in extra_settings:
extra_settings["breaklevel"] = 0
parser = RstToPdf(**extra_settings)
with closing(StringIO()) as fp:
parser.createPdf(text=split_rst_file(locale), output=fp)
rs = fp.getvalue()
return rs
def download(self, pageid):
from rst2pdf.createpdf import RstToPdf
p = model.FlatPage.by_id(pageid) or abort(404)
out = BytesIO()
rst2pdf = RstToPdf()
rst2pdf.createPdf(p.content, output=out)
out.seek(0)
return out.read()
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
try:
from rst2pdf.createpdf import RstToPdf
pdf_style_path = os.path.join(self.settings['PDF_STYLE_PATH'])
pdf_style = self.settings['PDF_STYLE']
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=[pdf_style],
style_path=[pdf_style_path])
except ImportError:
raise Exception("unable to find rst2pdf")
class PdfGenerator(Generator):
"""Generate PDFs on the output dir, for all articles and pages coming from
rst"""
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
try:
from rst2pdf.createpdf import RstToPdf
if 'PDF_STYLE_PATH' in self.settings.keys():
pdf_style_path = os.path.join(self.settings['PDF_STYLE_PATH'])
else:
pdf_style_path = ''
if 'PDF_STYLE' in self.settings.keys():
pdf_style = self.settings.get('PDF_STYLE', 'twelvepoint')
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=[pdf_style],
style_path=[pdf_style_path])
except ImportError:
raise Exception("unable to find rst2pdf")
def _create_pdf(self, obj, output_path):
if obj.source_path.endswith('.rst'):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
# print('Generating pdf for', obj.source_path, 'in', output_pdf)
with open(obj.source_path) as f:
self.pdfcreator.createPdf(text=f.read(), output=output_pdf)
logger.info(' [ok] writing %s' % output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(' Generating PDF files...')
pdf_path = os.path.join(self.output_path, 'pdf')
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
for article in self.context['articles']:
self._create_pdf(article, pdf_path)
for page in self.context['pages']:
self._create_pdf(page, pdf_path)
class PdfGenerator(Generator):
"""Generate PDFs on the output dir, for all articles and pages coming from
rst"""
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
try:
from rst2pdf.createpdf import RstToPdf
if 'PDF_STYLE_PATH' in self.settings.keys():
pdf_style_path = os.path.join(self.settings['PDF_STYLE_PATH'])
else:
pdf_style_path = ''
if 'PDF_STYLE' in self.settings.keys():
pdf_style = self.settings.get('PDF_STYLE', 'twelvepoint')
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=[pdf_style],
style_path=[pdf_style_path])
except ImportError:
raise Exception("unable to find rst2pdf")
def _create_pdf(self, obj, output_path):
if obj.source_path.endswith('.rst'):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
# print('Generating pdf for', obj.source_path, 'in', output_pdf)
with open(obj.source_path) as f:
self.pdfcreator.createPdf(text=f.read(), output=output_pdf)
logger.info(' [ok] writing %s' % output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(' Generating PDF files...')
pdf_path = os.path.join(self.output_path, 'pdf')
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
for article in self.context['articles']:
self._create_pdf(article, pdf_path)
for page in self.context['pages']:
self._create_pdf(page, pdf_path)
def get_submission_confirmation_report(submission):
sections = []
for section, fields in SUBMIT_CONFIRMATION:
cv_items = []
for field in fields:
model_field = Submission._meta.get_field_by_name(field)[0]
name = model_field.verbose_name
if getattr(model_field, 'choices', None):
value = getattr(submission, 'get_%s_display' % field)()
else:
value = getattr(submission, field)
cv_items.append((name, value))
sections.append((section, cv_items))
permissions = []
for field in SUBMIT_CONFIRMATION_PERMISSIONS:
value = getattr(submission, field)
if value != 1:
continue
model_field = Submission._meta.get_field_by_name(field)[0]
name = model_field.verbose_name
permissions.append(name)
if permissions:
permissions = [(_('Permissions'), permissions)]
docs = os.path.join(APP_ROOT, 'docs')
lang = translation.get_language().lower()
submission_rst = os.path.join(
docs, SUBMISSION_RST.get(lang, DEFAULT_SUBMISSION_RST))
with io.open(submission_rst, encoding='utf-8') as submission_head:
rst_data = submission_head.read() % _get_rst_fields(
sections, permissions)
from rst2pdf.createpdf import RstToPdf
pdf_creator = RstToPdf(
stylesheets=[os.path.join(docs, 'submission2.stylesheet')],
font_path=['/usr/share/fonts/TTF/'],
breaklevel=0,
)
with io.open('/tmp/cpm.rst', 'w', encoding='utf-8') as w:
w.write(rst_data)
pdf_content = StringIO()
pdf_creator.createPdf(text=rst_data, output=pdf_content)
return pdf_content.getvalue()
def generate_random_act_attach(cls, act, n=1):
"""
generates n random pdf attachments for an act
title and body, are built using a lorem ipsum generator
the attachments are built with text and a pdf file upload is simulated
"""
# random title and body generation
g = lipsum.MarkupGenerator()
for i in range(1, n + 1):
title = g.generate_sentences_plain(1)
body = g.generate_paragraphs_plain(random.randint(3, 50),
start_with_lorem=True)
# attach object created and saved
attach = Attach(act=act, title=title, text=body)
attach.save()
#
# pdf document generation and upload in proper directory
#
# document setup
if act is not None:
header = "Atto %s - ###Title###" % (act.idnum, )
else:
header = "###Title###"
footer = "###Section### - Pagina: ###Page###"
text = "%s\n%s\n%s\n" % ("=" * int(len(title) * 1.5), title,
"=" * int(len(title) * 1.5))
text += body
# pdf saved into tmp file
file_name = "%s_%s.pdf" % (act.idnum, attach.id)
tmp_file = os.path.join("/tmp", file_name)
rst2pdf = RstToPdf(breaklevel=0, header=header, footer=footer)
rst2pdf.createPdf(text=text, output=tmp_file)
# file is saved as attribute of the attach object and moved in the right path
# see https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.FieldFile.save
f = open(tmp_file, 'r')
attach.file.save(file_name, File(f))
attach.save()
os.remove(tmp_file)
print "%s: %s uploaded" % (i, file_name)
def __init__(self, *args, **kwargs):
try:
from rst2pdf.createpdf import RstToPdf
self.pdfcreator = RstToPdf(breakside=0, stylesheets=['twelvepoint'])
except ImportError:
raise Exception("unable to find rst2pdf")
super(PdfGenerator, self).__init__(*args, **kwargs)
def get_submission_confirmation_report(submission):
sections = []
for section, fields in SUBMIT_CONFIRMATION:
cv_items = []
for field in fields:
model_field = Submission._meta.get_field_by_name(field)[0]
name = model_field.verbose_name
if getattr(model_field, 'choices', None):
value = getattr(submission, 'get_%s_display' % field)()
else:
value = getattr(submission, field)
cv_items.append((name, value))
sections.append((section, cv_items))
permissions = []
for field in SUBMIT_CONFIRMATION_PERMISSIONS:
value = getattr(submission, field)
if value != 1:
continue
model_field = Submission._meta.get_field_by_name(field)[0]
name = model_field.verbose_name
permissions.append(name)
if permissions:
permissions = [(_('Permissions'), permissions)]
docs = os.path.join(APP_ROOT, 'docs')
lang = translation.get_language().lower()
submission_rst = os.path.join(
docs, SUBMISSION_RST.get(lang, DEFAULT_SUBMISSION_RST))
with io.open(submission_rst, encoding='utf-8') as submission_head:
rst_data = submission_head.read() % _get_rst_fields(
sections, permissions)
from rst2pdf.createpdf import RstToPdf
pdf_creator = RstToPdf(
stylesheets=[os.path.join(docs, 'submission2.stylesheet')],
font_path=['/usr/share/fonts/TTF/'],
breaklevel=0,
)
with io.open('/tmp/cpm.rst', 'w', encoding='utf-8') as w:
w.write(rst_data)
pdf_content = StringIO()
pdf_creator.createPdf(text=rst_data, output=pdf_content)
return pdf_content.getvalue()
def generate_random_act_attach(cls, act, n=1):
"""
generates n random pdf attachments for an act
title and body, are built using a lorem ipsum generator
the attachments are built with text and a pdf file upload is simulated
"""
# random title and body generation
g = lipsum.MarkupGenerator()
for i in range(1, n+1):
title = g.generate_sentences_plain(1)
body = g.generate_paragraphs_plain(random.randint(3, 50), start_with_lorem=True)
# attach object created and saved
attach = Attach(act=act, title=title, text=body)
attach.save()
#
# pdf document generation and upload in proper directory
#
# document setup
if act is not None:
header = "Atto %s - ###Title###" % (act.idnum,)
else:
header = "###Title###"
footer = "###Section### - Pagina: ###Page###"
text = "%s\n%s\n%s\n" % ("=" * int(len(title)*1.5), title, "=" * int(len(title)*1.5))
text += body
# pdf saved into tmp file
file_name = "%s_%s.pdf" % (act.idnum, attach.id)
tmp_file = os.path.join("/tmp", file_name)
rst2pdf = RstToPdf(breaklevel=0, header=header, footer=footer)
rst2pdf.createPdf(text=text,
output=tmp_file)
# file is saved as attribute of the attach object and moved in the right path
# see https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.FieldFile.save
f = open(tmp_file, 'r')
attach.file.save(file_name, File(f))
attach.save()
os.remove(tmp_file)
print "%s: %s uploaded" % (i, file_name)
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
if "PDF_STYLE_PATH" in self.settings:
pdf_style_path = [self.settings["PDF_STYLE_PATH"]]
else:
pdf_style_path = []
if "PDF_STYLE" in self.settings:
pdf_style = [self.settings["PDF_STYLE"]]
else:
pdf_style = []
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=pdf_style,
style_path=pdf_style_path,
raw_html=True)
class PdfGenerator(Generator):
"""Generate PDFs on the output dir, for all articles and pages coming from
rst"""
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
try:
from rst2pdf.createpdf import RstToPdf
pdf_style_path = (
os.path.join(self.settings["PDF_STYLE_PATH"]) if "PDF_STYLE_PATH" in self.settings.keys() else ""
)
pdf_style = self.settings["PDF_STYLE"] if "PDF_STYLE" in self.settings.keys() else "twelvepoint"
self.pdfcreator = RstToPdf(breakside=0, stylesheets=[pdf_style], style_path=[pdf_style_path])
except ImportError:
raise Exception("unable to find rst2pdf")
def _create_pdf(self, obj, output_path):
if obj.filename.endswith(".rst"):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
# print "Generating pdf for", obj.filename, " in ", output_pdf
with open(obj.filename) as f:
self.pdfcreator.createPdf(text=f.read(), output=output_pdf)
logger.info(" [ok] writing %s" % output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(" Generating PDF files...")
pdf_path = os.path.join(self.output_path, "pdf")
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " + pdf_path)
for article in self.context["articles"]:
self._create_pdf(article, pdf_path)
for page in self.context["pages"]:
self._create_pdf(page, pdf_path)
def test_rst2pdf(self):
assert RstToPdf, 'rst2pdf not installed - cannot test compatibility.'
rst2pdf = RstToPdf(breaklevel=0)
rst2pdf.styles['heading1'].spaceBefore = 36
buffer = BytesIO()
rst2pdf.createPdf(text, output=buffer)
pdf = buffer.getvalue()
buffer.close()
assert b'ReportLab generated PDF document' in pdf
assert b'Rst2Pdf MultiBuild Test Case For Wordaxe' in pdf
assert b'Test Section' in pdf
assert blah.encode() in pdf
class PdfGenerator(Generator):
"""Generate PDFs on the output dir, for all articles and pages coming from
rst"""
def __init__(self, *args, **kwargs):
try:
from rst2pdf.createpdf import RstToPdf
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=['twelvepoint'])
except ImportError:
raise Exception("unable to find rst2pdf")
super(PdfGenerator, self).__init__(*args, **kwargs)
def _create_pdf(self, obj, output_path):
if obj.filename.endswith(".rst"):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
# print "Generating pdf for", obj.filename, " in ", output_pdf
with open(obj.filename) as f:
self.pdfcreator.createPdf(text=f, output=output_pdf)
logger.info(u' [ok] writing %s' % output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(u' Generating PDF files...')
pdf_path = os.path.join(self.output_path, 'pdf')
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
pass
for article in self.context['articles']:
self._create_pdf(article, pdf_path)
for page in self.context['pages']:
self._create_pdf(page, pdf_path)
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
try:
from rst2pdf.createpdf import RstToPdf
pdf_style_path = os.path.join(self.settings['PDF_STYLE_PATH'])
pdf_style = self.settings['PDF_STYLE']
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=[pdf_style],
style_path=[pdf_style_path])
except ImportError:
raise Exception("unable to find rst2pdf")
class PdfGenerator(Generator):
"""Generate PDFs on the output dir, for all articles and pages coming from
rst"""
def __init__(self, *args, **kwargs):
try:
from rst2pdf.createpdf import RstToPdf
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=['twelvepoint'])
except ImportError:
raise Exception("unable to find rst2pdf")
super(PdfGenerator, self).__init__(*args, **kwargs)
def _create_pdf(self, obj, output_path):
if obj.filename.endswith(".rst"):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
# print "Generating pdf for", obj.filename, " in ", output_pdf
with open(obj.filename) as f:
self.pdfcreator.createPdf(text=f, output=output_pdf)
logger.info(u' [ok] writing %s' % output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(u' Generating PDF files...')
pdf_path = os.path.join(self.output_path, 'pdf')
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " + pdf_path)
pass
for article in self.context['articles']:
self._create_pdf(article, pdf_path)
for page in self.context['pages']:
self._create_pdf(page, pdf_path)
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
try:
from rst2pdf.createpdf import RstToPdf
pdf_style_path = (
os.path.join(self.settings["PDF_STYLE_PATH"]) if "PDF_STYLE_PATH" in self.settings.keys() else ""
)
pdf_style = self.settings["PDF_STYLE"] if "PDF_STYLE" in self.settings.keys() else "twelvepoint"
self.pdfcreator = RstToPdf(breakside=0, stylesheets=[pdf_style], style_path=[pdf_style_path])
except ImportError:
raise Exception("unable to find rst2pdf")
def produce_pdf(rst_content=None, doctree_content=None, filename=None):
"""produce a pdf content based of a given rst content
If filename is given, it will store the result using the given filename
if no filename is given, it will generate a pdf in /tmp/ with a random
name
"""
if filename is None:
filename = os.path.join(
"/tmp", ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(15)
]) + '.pdf')
r2p = RstToPdf(
stylesheets=['pdf.style'],
style_path=[os.path.join(os.path.dirname(__file__), 'styles')],
breaklevel=0,
splittables=True,
footer="""###Title### - ###Page###/###Total###""")
r2p.createPdf(text=rst_content, doctree=doctree_content, output=filename)
return filename
def produce_pdf(rst_content=None, doctree_content=None, filename=None):
"""produce a pdf content based of a given rst content
If filename is given, it will store the result using the given filename
if no filename is given, it will generate a pdf in /tmp/ with a random
name
"""
if filename is None:
filename = os.path.join(
"/tmp", ''.join([random.choice(string.ascii_letters +
string.digits) for n in range(15)]) + '.pdf')
r2p = RstToPdf(stylesheets=['pdf.style'],
style_path=[os.path.join(os.path.dirname(__file__),
'styles')],
breaklevel=0,
splittables=True,
footer="""###Title### - ###Page###/###Total###""")
r2p.createPdf(text=rst_content,
doctree=doctree_content,
output=filename)
return filename
def _generate_pdf(self, rst_file_path, result_pdf_path):
"""
Generates a PDF file based on the input RST file.
"""
if not os.path.exists(rst_file_path):
raise DocGenerateException("Provided RST file: %s does not exists." % rst_file_path)
# We suppose all RST files have references relative to their folder
# So we have to force rst2pdf to be executed in the folder where RST file resides.
basedir = os.path.split(rst_file_path)[0]
baseurl = "file://" + basedir
r2p = RstToPdf(style_path=[self._styles_folder], stylesheets=[self.PDF_STYLE],
basedir=basedir, baseurl=baseurl, breakside="any")
try:
with open(rst_file_path) as file_rst:
content = file_rst.read()
r2p.createPdf(text=content, source_path=rst_file_path, output=result_pdf_path)
self.logger.debug("PDF file %s generated successfully." % result_pdf_path)
except Exception, ex:
self.logger.exception("Could not generate PDF documentation")
raise DocGenerateException("Could not generate PDF documentation", ex)
def document(report, fmt='html'):
'''
Creates a document in the desired `fmt`. Defaults to html.
'''
if fmt == 'csv':
return report2csv(report)
doctree = doctree_factory(report, fmt=fmt)
dt_settings = {
'input_encoding': 'unicode',
}
if fmt == 'pdf':
if not RST2PDF:
raise Exception('rst2pdf is not available')
return None
buff = StringIO()
rst2pdf = RstToPdf()
rst2pdf.createPdf(doctree=doctree, output=buff)
return buff.getvalue()
if fmt in DOCUTILS_WRITER_NAMES:
if fmt == 'odt':
fmt = 'odf_odt' # Docutils writer name
if fmt in ('txt', 'rst'):
return gen_rst(doctree, 0)
return publish_from_doctree(
doctree,
writer_name=fmt,
settings_overrides=dt_settings
)
else:
raise Exception('Format not supported. Not in %s' % (
SUPPORTED_FORMATS,
)
)
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
if 'PDF_STYLE_PATH' in self.settings:
pdf_style_path = [self.settings['PDF_STYLE_PATH']]
else:
pdf_style_path = []
if 'PDF_STYLE' in self.settings:
pdf_style = [self.settings['PDF_STYLE']]
else:
pdf_style = []
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=pdf_style,
style_path=pdf_style_path)
def splitn_command(secret, n, out_file, secret_name, **kwargs):
"""
N shares so that any two shares can be combined to obtain the secret.
Each share will contain n-1 share values, each matching a different share.
The secret can be obtained by combining two share values with the same
share ID.
The share tables and instructions are saved to pdf.
"""
if secret is None:
secret = getpass(prompt='Secret: ')
ids = list(range(100, 999))
n_share_values = (n * n) / 2 - n
if len(ids) < n_share_values:
raise ValueError(
f"Share ID space too small for n={n}. Choose smaller n.")
shuffle(ids)
shares = [[] for _ in range(n)]
for i in range(n):
for j in range(i + 1, n):
share_a, share_b = split_secret(secret)
share_id = ids.pop()
shares[i].append([j + 1, f'#{share_id}', f'``{share_a}``'])
shares[j].append([i + 1, f'#{share_id}', f'``{share_b}``'])
pages = [
create_page(secret_name=secret_name,
sheet_id=i,
n_sheet=n,
records=share) for i, share in enumerate(shares, 1)
]
rst_doc = join_pages(pages)
# with open('foo.rst', 'w') as fh:
# fh.write(rst_doc)
RstToPdf().createPdf(text=rst_doc, output=out_file)
class PdfGenerator(Generator):
"Generate PDFs on the output dir, for all articles and pages"
supported_md_fields = ["date"]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if "PDF_STYLE_PATH" in self.settings:
pdf_style_path = [self.settings["PDF_STYLE_PATH"]]
else:
pdf_style_path = []
if "PDF_STYLE" in self.settings:
pdf_style = [self.settings["PDF_STYLE"]]
else:
pdf_style = []
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=pdf_style,
style_path=pdf_style_path,
raw_html=True)
def _create_pdf(self, obj, output_path):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
mdreader = MarkdownReader(self.settings)
_, ext = os.path.splitext(obj.source_path)
if ext == ".rst":
with open(obj.source_path, encoding="utf-8") as f:
text = f.read()
header = ""
elif ext[1:] in mdreader.file_extensions and mdreader.enabled:
text, meta = mdreader.read(obj.source_path)
header = ""
if "title" in meta:
title = meta["title"]
header = title + "\n" + "#" * len(title) + "\n\n"
del meta["title"]
for k in list(meta):
# We can't support all fields, so we strip the ones that won't
# look good
if k not in self.supported_md_fields:
del meta[k]
header += "\n".join([":{}: {}".format(k, meta[k]) for k in meta])
header += "\n\n.. raw:: html\n\n\t"
text = text.replace("\n", "\n\t")
# rst2pdf casts the text to str and will break if it finds
# non-escaped characters. Here we nicely escape them to XML/HTML
# entities before proceeding
text = text.encode("ascii", "xmlcharrefreplace").decode()
else:
# We don't support this format
logger.warn("Ignoring unsupported file " + obj.source_path)
return
# Find intra-site links and replace placeholder with actual path / url
hrefs = self._get_intrasite_link_regex()
text = hrefs.sub(lambda m: obj._link_replacer(obj.get_siteurl(), m),
text)
logger.info(" [ok] writing %s" % output_pdf)
self.pdfcreator.createPdf(text=(header + text), output=output_pdf)
def _get_intrasite_link_regex(self):
intrasite_link_regex = self.settings["INTRASITE_LINK_REGEX"]
regex = r"""
(?P<markup>)(?P<quote>)(?P<path>(\:?){}(?P<value>.*?)(?=[>\n]))
""".format(intrasite_link_regex)
return re.compile(regex, re.X)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(" Generating PDF files...")
pdf_path = os.path.join(self.output_path, "pdf")
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
for obj in chain(self.context["articles"], self.context["pages"]):
self._create_pdf(obj, pdf_path)
for obj_trans in obj.translations:
self._create_pdf(obj_trans, pdf_path)
def setUp(self):
self.converter=RstToPdf()
def summary_cover(self, sub_id=None, out_file=None):
""" Generates a cover page with subject information """
from mriqc import __version__
import datetime
import numpy as np
from logging import CRITICAL
from rst2pdf.createpdf import RstToPdf
from rst2pdf.log import log
import pkg_resources as pkgr
failed = self.failed
if failed is None:
failed = []
log.setLevel(CRITICAL)
newdf = self.dataframe.copy()
# Format the size
#pylint: disable=E1101
newdf[['size_x', 'size_y', 'size_z']] = newdf[['size_x', 'size_y', 'size_z']].astype(np.uint16)
formatter = lambda row: '%d \u00D7 %d \u00D7 %d' % (
row['size_x'], row['size_y'], row['size_z'])
newdf['size'] = newdf[['size_x', 'size_y', 'size_z']].apply(formatter, axis=1)
# Format spacing
newdf[['spacing_x', 'spacing_y', 'spacing_z']] = newdf[[
'spacing_x', 'spacing_y', 'spacing_z']].astype(np.float32) #pylint: disable=E1101
formatter = lambda row: '%.3f \u00D7 %.3f \u00D7 %.3f' % (
row['spacing_x'], row['spacing_y'], row['spacing_z'])
newdf['spacing'] = newdf[['spacing_x', 'spacing_y', 'spacing_z']].apply(formatter, axis=1)
# columns
cols = ['session_id', 'run_id', 'size', 'spacing']
colnames = ['Session', 'Run', 'Size', 'Spacing']
if 'tr' in newdf.columns.ravel():
cols.append('tr')
colnames.append('TR (sec)')
if 'size_t' in newdf.columns.ravel():
cols.append('size_t')
colnames.append('# Timepoints')
# Format parameters table
if sub_id is None:
cols.insert(0, 'subject_id')
colnames.insert(0, 'Subject')
else:
newdf = newdf[newdf.subject_id == sub_id]
newdf = newdf[cols]
colsizes = []
for col, colname in zip(cols, colnames):
try:
newdf[[col]] = newdf[[col]].astype(str)
except NameError:
newdf[[col]] = newdf[[col]].astype(str)
colsize = np.max([len('{}'.format(val)) for val in newdf.loc[:, col]])
# colsize = newdf.loc[:, col].map(len).max()
colsizes.append(colsize if colsize > len(colname) else len(colname))
colformat = ' '.join('{:<%d}' % c for c in colsizes)
formatter = lambda row: colformat.format(*row)
rowsformatted = newdf[cols].apply(formatter, axis=1).ravel().tolist()
# rowsformatted = [formatter.format(*row) for row in newdf.iterrows()]
header = colformat.format(*colnames)
sep = colformat.format(*['=' * c for c in colsizes])
ptable = '\n'.join([sep, header, sep] + rowsformatted + [sep])
title = 'MRIQC: %s MRI %s report' % (
self.qctype, 'group' if sub_id is None else 'individual')
# Substitution dictionary
context = {
'title': title + '\n' + ''.join(['='] * len(title)),
'timestamp': datetime.datetime.now().strftime("%Y-%m-%d, %H:%M"),
'version': __version__,
'failed': failed,
'imparams': ptable
}
if sub_id is not None:
context['sub_id'] = sub_id
if sub_id is None:
template = ConfigGen(pkgr.resource_filename(
'mriqc', op.join('data', 'reports', 'cover_group.rst')))
else:
template = ConfigGen(pkgr.resource_filename(
'mriqc', op.join('data', 'reports', 'cover_individual.rst')))
RstToPdf().createPdf(
text=template.compile(context), output=out_file)
def render(self, input_file, output_file):
style_file = os.path.join(self.base_dir, self.style)
with open(input_file) as input_file:
RstToPdf(stylesheets=[style_file]).createPdf(
text=input_file.read(), output=output_file)
#!/usr/bin/env python2
import subprocess
import jinja2
from rst2pdf.createpdf import RstToPdf
import tabulate
import yaml
with open("secrets.yaml", 'r') as stream:
secrets = yaml.load(stream)
table = [
[secrets['address'], secrets['email']],
[secrets['phone'], "http://bradym.net"]
]
rst_table = tabulate.tabulate(table, tablefmt='rst')
rendered = jinja2.Environment(loader=jinja2.FileSystemLoader('./'))\
.get_template('resume.rst').render({'table': rst_table})
RstToPdf(stylesheets=['style.json'], breaklevel=0).createPdf(rendered, output='resume.pdf')
subprocess.call('open resume.pdf', shell=True)
class PdfGenerator(Generator):
"Generate PDFs on the output dir, for all articles and pages"
supported_md_fields = ["date"]
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
if "PDF_STYLE_PATH" in self.settings:
pdf_style_path = [self.settings["PDF_STYLE_PATH"]]
else:
pdf_style_path = []
if "PDF_STYLE" in self.settings:
pdf_style = [self.settings["PDF_STYLE"]]
else:
pdf_style = []
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=pdf_style,
style_path=pdf_style_path,
raw_html=True)
def _create_pdf(self, obj, output_path):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
mdreader = MarkdownReader(self.settings)
_, ext = os.path.splitext(obj.source_path)
if ext == ".rst":
with open(obj.source_path, encoding="utf-8") as f:
text = f.read()
header = ""
elif ext[1:] in mdreader.file_extensions and mdreader.enabled:
text, meta = mdreader.read(obj.source_path)
header = ""
if "title" in meta:
title = meta["title"]
header = title + "\n" + "#" * len(title) + "\n\n"
del meta["title"]
for k in meta.keys():
# We can't support all fields, so we strip the ones that won't
# look good
if k not in self.supported_md_fields:
del meta[k]
header += "\n".join([":%s: %s" % (k, meta[k]) for k in meta])
header += "\n\n.. raw:: html\n\n\t"
text = text.replace("\n", "\n\t")
# rst2pdf casts the text to str and will break if it finds
# non-escaped characters. Here we nicely escape them to XML/HTML
# entities before proceeding
text = text.encode("ascii", "xmlcharrefreplace").decode()
else:
# We don't support this format
logger.warn("Ignoring unsupported file " + obj.source_path)
return
logger.info(" [ok] writing %s" % output_pdf)
self.pdfcreator.createPdf(text=(header + text), output=output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(" Generating PDF files...")
pdf_path = os.path.join(self.output_path, "pdf")
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
for article in self.context["articles"]:
self._create_pdf(article, pdf_path)
for page in self.context["pages"]:
self._create_pdf(page, pdf_path)
class PdfGenerator(Generator):
"Generate PDFs on the output dir, for all articles and pages"
supported_md_fields = ['date']
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
if 'PDF_STYLE_PATH' in self.settings:
pdf_style_path = [self.settings['PDF_STYLE_PATH']]
else:
pdf_style_path = []
if 'PDF_STYLE' in self.settings:
pdf_style = [self.settings['PDF_STYLE']]
else:
pdf_style = []
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=pdf_style,
style_path=pdf_style_path,
raw_html=True)
def _create_pdf(self, obj, output_path):
filename = obj.slug + '.pdf'
output_pdf = os.path.join(output_path, filename)
mdreader = MarkdownReader(self.settings)
_, ext = os.path.splitext(obj.source_path)
if ext == '.rst':
with open(obj.source_path, encoding='utf-8') as f:
text = f.read()
header = ''
elif ext[1:] in mdreader.file_extensions and mdreader.enabled:
text, meta = mdreader.read(obj.source_path)
header = ''
if 'title' in meta:
title = meta['title']
header = title + '\n' + '#' * len(title) + '\n\n'
del meta['title']
for k in meta.keys():
# We can't support all fields, so we strip the ones that won't
# look good
if k not in self.supported_md_fields:
del meta[k]
header += '\n'.join([':%s: %s' % (k, meta[k]) for k in meta])
header += '\n\n.. raw:: html\n\n\t'
text = text.replace('\n', '\n\t')
# rst2pdf casts the text to str and will break if it finds
# non-escaped characters. Here we nicely escape them to XML/HTML
# entities before proceeding
text = text.encode('ascii', 'xmlcharrefreplace')
else:
# We don't support this format
logger.warn('Ignoring unsupported file ' + obj.source_path)
return
logger.info(' [ok] writing %s' % output_pdf)
self.pdfcreator.createPdf(text=(header+text),
output=output_pdf)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(' Generating PDF files...')
pdf_path = os.path.join(self.output_path, 'pdf')
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
for article in self.context['articles']:
self._create_pdf(article, pdf_path)
for page in self.context['pages']:
self._create_pdf(page, pdf_path)
class PdfGenerator(Generator):
"""Generate PDFs on the output dir, for all articles and pages coming from
rst"""
def __init__(self, *args, **kwargs):
super(PdfGenerator, self).__init__(*args, **kwargs)
pdf_style_path = os.path.join(self.settings['PDF_STYLE_PATH'])
pdf_style = self.settings['PDF_STYLE']
self.pdfcreator = RstToPdf(breakside=0,
stylesheets=[pdf_style],
style_path=[pdf_style_path],
def_dpi=100)
def _create_pdf(self, obj, output_path):
if obj.source_path.endswith('.rst'):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
print('Generating pdf for', obj.source_path, 'in', output_pdf)
with open(obj.source_path) as f:
self.pdfcreator.createPdf(text=f.read(), output=output_pdf)
logger.info(' [ok] writing %s' % output_pdf)
def _upload_figshare(self, obj, output_path):
if obj.source_path.endswith('.rst'):
filename = obj.slug + ".pdf"
output_pdf = os.path.join(output_path, filename)
client_key = '8BeN60jNpgmgIN6G8oaCXQ'
client_secret = 'oSj6EZkWChEifWOADJcKUw'
token_key = 'sZegoc5oOgPsXfeATZGvRggVLkqc9lrYFCI9pYvDWkZAsZegoc5oOgPsXfeATZGvRg'
token_secret = 'fifOafUWFAFcKxN6ZO9fbg'
oauth = OAuth1(client_key=client_key, client_secret=client_secret,
resource_owner_key=token_key, resource_owner_secret=token_secret,
signature_type = 'auth_header')
client = requests.session()
body = {'title':obj.title, 'description':obj.summary,'defined_type':'dataset'}
headers = {'content-type':'application/json'}
#response = client.post('http://api.figshare.com/v1/my_data/articles', auth=oauth, data=json.dumps(body), headers=headers)
#results = json.loads(response.content)
#print(results["doi"])
#article_id = results["article_id"]
article_id = 852126
body = {'category_id':77} # applied computer science
headers = {'content-type':'application/json'}
response = client.put('http://api.figshare.com/v1/my_data/articles/%d/categories' % article_id, auth=oauth,
data=json.dumps(body), headers=headers)
results = json.loads(response.content)
body = {'tag_name':'proceedings'}
headers = {'content-type':'application/json'}
response = client.put('http://api.figshare.com/v1/my_data/articles/%d/tags' % article_id, auth=oauth,
data=json.dumps(body), headers=headers)
results = json.loads(response.content)
authors = [author.strip() for author in obj.author.name.split(",")]
for author in authors:
print(author)
response = client.get('http://api.figshare.com/v1/my_data/authors?search_for=Kapil Arya', auth=oauth)
results = json.loads(response.content)
print(results)
if results["results"] == 0:
body = {'full_name':author}
headers = {'content-type':'application/json'}
response = client.post('http://api.figshare.com/v1/my_data/authors', auth=oauth,
data=json.dumps(body), headers=headers)
results = json.loads(response.content)
print(results)
body = {'author_id':results["author_id"]}
headers = {'content-type':'application/json'}
response = client.put('http://api.figshare.com/v1/my_data/articles/%d/authors' % article_id, auth=oauth,
data=json.dumps(body), headers=headers)
results = json.loads(response.content)
files = {'filedata':(os.path.basename(output_pdf), open(output_pdf, 'rb'))}
response = client.put('http://api.figshare.com/v1/my_data/articles/%d/files' % article_id, auth=oauth,
files=files)
results = json.loads(response.content)
print(results)
#response = client.post('http://api.figshare.com/v1/my_data/articles/%d/action/make_public' % article_id, auth=oauth)
#results = json.loads(response.content)
def generate_context(self):
pass
def generate_output(self, writer=None):
# we don't use the writer passed as argument here
# since we write our own files
logger.info(' Generating PDF files...')
pdf_path = os.path.join(self.output_path, 'pdf')
if not os.path.exists(pdf_path):
try:
os.mkdir(pdf_path)
except OSError:
logger.error("Couldn't create the pdf output folder in " +
pdf_path)
for article in self.context['articles']:
self._create_pdf(article, pdf_path)
self._upload_figshare(article, pdf_path)
for page in self.context['pages']:
self._create_pdf(page, pdf_path)