def test():
doc = Document("utils_escape_latex")
section = Section('Escape LaTeX characters test')
text = escape_latex('''\
& (ampersand)
% (percent)
$ (dollar)
# (number)
_ (underscore)
{ (left curly brace)
} (right curly brace)
~ (tilde)
^ (caret)
\\ (backslash)
--- (three minuses)
a\xA0a (non breaking space)
[ (left bracket)
] (right bracket)
''')
section.append(text)
doc.append(section)
doc.generate_pdf()
def circuit_to_pdf_using_qcircuit_via_tex(circuit: circuits.Circuit,
filepath: str,
pdf_kwargs=None,
qcircuit_kwargs=None,
clean_ext=('dvi', 'ps'),
documentclass='article'):
"""Compiles the QCircuit-based latex diagram of the given circuit.
Args:
circuit: The circuit to produce a pdf of.
filepath: Where to output the pdf.
pdf_kwargs: The arguments to pass to generate_pdf.
qcircuit_kwargs: The arguments to pass to
circuit_to_latex_using_qcircuit.
clean_ext: The file extensions to clean up after compilation. By
default, latexmk is used with the '-pdfps' flag, which produces
intermediary dvi and ps files.
documentclass: The documentclass of the latex file.
"""
pdf_kwargs = {'compiler': 'latexmk', 'compiler_args': ['-pdfps'],
**({} if pdf_kwargs is None else pdf_kwargs)}
qcircuit_kwargs = {} if qcircuit_kwargs is None else qcircuit_kwargs
tex = circuit_to_latex_using_qcircuit(circuit, **qcircuit_kwargs)
doc = Document(documentclass=documentclass, document_options='dvips')
doc.packages.append(Package('amsmath'))
doc.packages.append(Package('qcircuit'))
doc.append(NoEscape(tex))
doc.generate_pdf(filepath, **pdf_kwargs)
for ext in clean_ext:
try:
os.remove(filepath + '.' + ext)
except (OSError, IOError) as e:
if e.errno != errno.ENOENT:
raise
def test():
doc = Document('jobname_test', data=['Jobname test'])
doc.generate_pdf()
assert os.path.isfile('jobname_test.pdf')
os.remove('jobname_test.pdf')
folder = 'tmp_jobname'
os.makedirs(folder)
path = os.path.join(folder, 'jobname_test_dir')
doc = Document(path, data=['Jobname test dir'])
doc.generate_pdf()
assert os.path.isfile(path + '.pdf')
shutil.rmtree(folder)
folder = 'tmp_jobname2'
os.makedirs(folder)
path = os.path.join(folder, 'jobname_test_dir2')
doc = Document(path, data=['Jobname test dir'])
doc.generate_pdf(os.path.join(folder, ''))
assert os.path.isfile(path + '.pdf')
shutil.rmtree(folder)
def get_cv_doc(filename):
"""Returns a pylatex.Document instance pre-loaded with everything needed for my cv style."""
doc = Document(filename,
documentclass='article')
# Set Packages
doc.packages.append(Package('marginnote'))
doc.packages.append(UnsafeCommand('reversemarginpar'))
doc.packages.append(Package('graphicx'))
doc.packages.append(Package('classicthesis', options='nochapters'))
doc.packages.append(Package('currvita', options='LabelsAligned'))
doc.packages.append(Package('hyperref'))
doc.packages.append(UnsafeCommand('hypersetup', extra_arguments=r'colorlinks, breaklinks, urlcolor=Maroon, linkcolor=Maroon'))
doc.packages.append(UnsafeCommand('newlength', r'\datebox', ))
doc.packages.append(UnsafeCommand('settowidth', r'\datebox', extra_arguments='Tuebingen, Germany'))
doc.packages.append(UnsafeCommand('renewcommand', r'\cvheadingfont', extra_arguments=r'\LARGE\color{Maroon}'))
# Unchanged-ish (Extra line break at the end)
doc.packages.append(UnsafeCommand('newcommand', r'\SubHeading', options=1,
extra_arguments=r'\vspace{1em}\noindent\spacedlowsmallcaps{#1}\vspace{0.7em}\\'))
doc.packages.append(UnsafeCommand('newcommand', r'\Email', options=1,
extra_arguments=r'\href{mailto:#1}{#1}'))
# Unchanged
doc.packages.append(UnsafeCommand('newcommand', r'\MarginText', options=1, extra_arguments=r'\marginpar{\raggedleft\small#1}'))
# Unchanged
doc.packages.append(UnsafeCommand('newcommand', r'\Description', options=1,
extra_arguments=r'\hangindent=2em\hangafter=0\footnotesize{#1}\par\normalsize\vspace{1em}'))
doc.packages.append(UnsafeCommand('newcommand', r'\DescMarg', options=2,
extra_arguments=r'\noindent\hangindent=2em\hangafter=0 \parbox{\datebox}{\small} \MarginText{#1} #2 \vspace{0.3em}\\'))
##################
doc.packages.append(UnsafeCommand('newcommand', r'\HeaderOnly', options=2,
extra_arguments= r'\noindent\hangindent=2em\hangafter=0 \parbox{\datebox}{\small \textit{#1}}\hspace{1.5em} #2 \vspace{0.5em}\\'))
doc.packages.append(UnsafeCommand('newcommand', r'\EntryHeader', options=3,
extra_arguments=r'\noindent\hangindent=2em\hangafter=0 \parbox{\datebox}{\small \textit{#2}}\hspace{1.5em} \MarginText{#1} #3 \vspace{0.5em}'))
doc.packages.append(UnsafeCommand('newcommand', r'\NewEntry', options=4,
extra_arguments=r'\EntryHeader{#1}{#2}{#3}\\\Description{#4}'))
# Fill Document
doc.append(UnsafeCommand('thispagestyle', 'empty'))
doc.append(NoEscape(r'\raggedright'))
return doc
def test():
doc = Document()
section = Section('Multirow Test')
figure = Figure()
image_filename = os.path.join(os.path.dirname(__file__),
'../examples/kitten.jpg')
figure.add_image(image_filename)
figure.add_caption('Whoooo an imagage of a pdf')
section.append(figure)
doc.append(section)
doc.generate_pdf()
def test():
doc = Document()
Subsection('Only a single string', data='Some words')
sec1 = Section('Only contains one subsection', data='Subsection')
sec2 = Section('Only a single italic command', data=Command('textit',
'Hey'))
sec2.append('something else that is not italic')
doc.append(sec1)
doc.append(sec2)
doc.generate_pdf()
def arxiv_search(search_query):
url = 'http://export.arxiv.org/api/query?search_query=all:' + \
search_query + '&start=0&max_results=5'
data = urllib.request.urlopen(url).read()
soup = bs(data, features='xml')
title_array = []
summary_array = []
for i in soup.findAll('title'):
title_array.append(i)
for i in soup.findAll('summary'):
summary_array.append(i)
doc = Document()
doc.packages.append(
Package(
'geometry',
options=[
'tmargin=1cm',
'lmargin=1cm',
'rmargin=1cm']))
with doc.create(Section('Search results for \"' + search_query + '\"')):
for i in range(1, 5):
doc.append(Subsection(italic(title_array[i].string)))
doc.append(summary_array[i].string)
doc.generate_pdf()
def test():
doc = Document("multirow_cm")
with doc.create(Section('Multirow Test')):
with doc.create(Subsection('Multicol')):
# we need to keep track of the object here
with doc.create(Tabular('|c|c|')) as table1:
table1.add_hline()
table1.add_multicolumn(2, '|c|', 'Multicol')
table1.add_hline()
table1.add_row((1, 2))
table1.add_hline()
table1.add_row((3, 4))
table1.add_hline()
with doc.create(Subsection('Multirow')):
with doc.create(Tabular('|c|c|c|')) as table2:
table2.add_hline()
table2.add_multirow(3, '*', 'Multirow', cells=((1, 2), (3, 4),
(5, 6)))
table2.add_hline()
table2.add_multirow(3, '*', 'Multirow2')
table2.add_hline()
doc.generate_pdf()
def createSimpleTable(tableColumns,d,filename):
doc = Document()
with doc.create(Table('|c|c|c|c|c|c|c|c|c|')) as table:
for row in d:
row[0]=row[0].replace('_','\_')
row[0]="\\textbf{"+row[0]+"}"
table.add_hline()
table.add_row(tuple(row))
table.add_hline()
a = open(filename, 'wr')
table.dump(a)
def __init__(self, lda_based_context):
self.lda_based_context = lda_based_context
self.doc =\
Document(Constants.ITEM_TYPE + '-topic-models-nouns-complete-3')
self.num_cols = Constants.TOPIC_MODEL_STABILITY_NUM_TERMS
self.num_topics = Constants.TOPIC_MODEL_NUM_TOPICS
self.rgb_tuples = None
self.automatic_context_topic_colors = None
self.keyword_context_topic_colors = None
self.manual_context_topic_colors = None
self.automatic_context_topic_ids = None
self.keyword_context_topic_ids = None
self.manual_context_topic_ids = None
self.automatic_context_topic_words = None
self.keyword_context_topic_words = None
self.manual_context_topic_words = None
self.headers = None
self.topic_words_map = None
self.table_format = '|c|' + 'c|' * (self.num_cols + 1)
self.tagger = nltk.PerceptronTagger()
self.tag_count_map = {'NN': 0, 'JJ': 0, 'VB': 0}
self.init_colors()
self.init_headers()
self.init_topic_words()
self.init_topic_ids()
self.doc.packages.append(Package('color'))
new_comm = UnsafeCommand(
'newcommand', '\exampleCommand', options=4,
extra_arguments=r'\colorbox[rgb]{#1,#2,#3}{#4} \color{black}')
self.doc.append(new_comm)
new_comm2 = UnsafeCommand('tiny')
self.doc.append(new_comm2)
def setuplatex(self):
self.filename = self.id + '-' + time.strftime('%Y')
self.documentclass = Command('documentclass', arguments='scrlttr2', options=self.docoptions)
self.doc = Document(self.filename, documentclass=self.documentclass, fontenc='T1', inputenc='utf8')
self.doc.preamble.append(Command('input', latex_preamble))
self.doc.preamble.append(Command('LoadLetterOption', 'template'))
self.doc.preamble.append(Command('setkomavar', arguments='subject', extra_arguments=self.subject))
self.doc.preamble.append(Command('setkomavar', arguments='yourmail', options=self.categroy[1], extra_arguments=self.filename))
def generate_info_report():
"""
Generate a report with cover, status und last 2 lines in log for every test
"""
## Define the geometry for LaTeX files
geometry_options = {
"head": "40pt",
"margin": "0.5in",
"bottom": "0.6in",
"includeheadfoot": True
}
## Create the LaTeX object, a instance of Document Class
doc = Document(documentclass='article', geometry_options=geometry_options)
## Add cover
generate_cover2(doc)
doc.append(NewPage())
## Add status table
generate_status_tabel(doc)
doc.append(NewPage())
## Add last 2 lines in log.txt
for i in range(1, 4):
generate_info_list(doc, i)
doc.generate_pdf("RiMEA-Projekt Analyse", clean_tex=False)
def __init__(self, title):
self.title = title
self.doc = Document(title)
self.doc.packages.append(Package('geometry', options=['a4paper', 'top=2cm', 'bottom=2.5cm', 'left=2cm', 'right=2cm']))
self.doc.packages.append(Package('titlesec', options=['sf']))
self.doc.packages.append(Package('lmodern'))
self.doc.append(Command('sffamily'))
return
def make_doc(self, foirequest):
doc = Document(
lmodern=True,
geometry_options={
"a4paper": True,
"margin": "1in",
},
)
# Change font
doc.packages.append(Package('fontspec,xunicode,array'))
doc.packages.append(Package('sectsty'))
doc.preamble.append(NoEscape("\\usepackage{helvet}"))
doc.preamble.append(NoEscape("\\sectionfont{\\fontsize{12}{15}\\selectfont}"))
# Adjust description list
doc.packages.append(Package('enumitem'))
doc.preamble.append(NoEscape("\\setlist[description]{labelindent=0cm,style=multiline,leftmargin=1.5cm}"))
# Hyphenation
doc.append(NoEscape("\\lefthyphenmin=5"))
doc.append(NoEscape("\\sloppy"))
# doc.preamble.append(Command('title', foirequest.title))
# doc.preamble.append(Command('author', foirequest.get_absolute_domain_short_url()))
# doc.preamble.append(Command('date', NoEscape('\\today')))
# doc.append(NoEscape('\\maketitle'))
# Set up header and footer
header = PageStyle("header")
with header.create(Foot("L")):
header.append(italic(settings.SITE_NAME))
with header.create(Head("C")):
header.append(foirequest.title)
with header.create(Foot("R")):
header.append(str(
_('Request #{request_no}').format(request_no=foirequest.pk)))
with header.create(Foot("C")):
header.append(italic(NoEscape(r'Seite \thepage\ von \pageref{LastPage}')))
doc.preamble.append(header)
doc.change_document_style("header")
for i, message in enumerate(foirequest.messages):
last = i == len(foirequest.messages) - 1
add_message_to_doc(doc, message)
if not last:
doc.append(NewPage())
return doc
def start_doc(title, date=datetime.today().date()):
docclass = Command('documentclass', arguments=Arguments('article'), options=Options('titlepage'))
# Start LaTex Doc
doc = Document(title=title, date=date, author='Ken Payne [kenpay@]', maketitle=True, documentclass=docclass)
#doc.packages.append(Command('usepackage', options=Options('a4paper'), arguments=Arguments('geometry')))
doc.packages.append(Command('renewcommand', arguments=Arguments('\\familydefault','\sfdefault')))
doc.packages.append(Command('usepackage', arguments=Arguments('caption, setspace')))
doc.packages.append(Command('captionsetup', arguments=Arguments('font={large, stretch=1.3}')))
#doc.packages.append(Command('usepackage', arguments=Arguments('showframe')))
doc.packages.append(Command('usepackage', arguments=Arguments('geometry'), options=Options('top=1in', 'bottom=1in', 'left=1in', 'right=1in')))
doc.packages.append(Command('usepackage', arguments=Arguments('tocloft')))
doc.packages.append(Command('renewcommand', arguments=Arguments('\cftsecleader}{\cftdotfill{\cftdotsep}')))
doc.packages.append(Command('usepackage', arguments=Arguments('booktabs')))
doc.packages.append(Command('usepackage', arguments=Arguments('graphicx')))
doc.packages.append(Command('usepackage', arguments=Arguments('subcaption')))
doc.packages.append(Command('usepackage', arguments=Arguments('subcaption')))
doc.packages.append(Command('usepackage', arguments=Arguments('xcolor'), options=Options('usenames,dvipsnames')))
doc.packages.append(Command('usepackage', arguments=Arguments('fancyheadings')))
doc.packages.append("\\pagestyle{fancy}")
doc.packages.append("\\chead{\\bfseries \\textcolor{Gray}{CONFIDENTIAL}}")
doc.packages.append("\\setcounter{totalnumber}{6}")
doc.packages.append("\\usepackage{pdflscape}")
doc.packages.append("\\usepackage[colorlinks = true, linkcolor = blue, urlcolor = blue, citecolor = blue, anchorcolor = blue]{hyperref}")
#doc.packages.append(Command('extrafloats', arguments=Arguments(100)))
doc.packages.append("\\hypersetup{linktocpage}")
doc.packages.append("\\usepackage{longtable}")
doc.packages.append("\\usepackage[cc]{titlepic}")
doc.packages.append("\\titlepic{\centering\includegraphics[width=0.3\\textwidth]{aws.png}}")
doc.packages.append("\\usepackage[none]{hyphenat}")
doc.packages.append("\\usepackage[flushleft]{threeparttable}")
# ----- Doc Begins Here -----
doc.append(Command('begin', arguments=Arguments('abstract')))
doc.append("Please add campaign code \href{https://na3.salesforce.com/701500000016PTG}{EMEA-UKIR-FY15-SMART-Report Tool-Tracking} to any opportunities\
created. This helps me to asses the usefulness of the tool and to justify any time spent on it!\\\\\
\\\\\
Report generated from SMART data for given territory/territories, with the following aims:\\\\\
\\begin{enumerate}\
\\item To reduce the 'undiferentiated heavy lifting' associated with performance analysis of\
a territory. It is my experiance that similar analytics are currently run using SMART/excel, but\
depend heavily on detailed knowledge of these tools. This report aims remove this skill barrier between AM's\
and valuable territory insight, allowing more time to be spent on direct customer engagements.\
\\item To provide \\textbf{actionable} insights into customer spend behaviour by identifying lists of customers\
exhibiting behaviours of interest (e.g. significant increases, customers moving across tier thresholds etc.).\
\\end{enumerate}")
doc.append(Command('end', arguments=Arguments('abstract')))
doc.append(Command('tableofcontents'))
return doc
class TrainingDocumentWriter:
def __init__(self, title):
self.title = title
self.doc = Document(title)
self.doc.packages.append(Package('geometry', options=['a4paper', 'top=2cm', 'bottom=2.5cm', 'left=2cm', 'right=2cm']))
self.doc.packages.append(Package('titlesec', options=['sf']))
self.doc.packages.append(Package('lmodern'))
self.doc.append(Command('sffamily'))
return
def append_plot(self, pyplot, caption=''):
with self.doc.create(Plt(position='htbp')) as plot:
plot.add_plot(pyplot, width=ur'\textwidth')
if caption!='':
plot.add_caption(caption)
return
def append_section(self, section_title='', content=''):
with self.doc.create(Section(section_title)):
if content!='':
self.doc.append(content)
return
def generate_pdf(self,filename=u'', clean=True, compiler='pdflatex'):
#This is a workaround to save the generated pdf in a different directory (not in working dir)
cur_path = os.getcwd()
dirlist = filename.split('/')
os.chdir(os.path.dirname(filename)) #cd to specified directory
#Remove possible existing file extension (.pdf)
if '.' in filename:
self.doc.generate_pdf(dirlist[len(dirlist)-1].split('.')[0])
else:
self.doc.generate_pdf(dirlist[len(dirlist)-1])
os.chdir(cur_path) #cd to original working directory
return
def show_pdf(filename):
"""
Compiles a simple tex document that the matplotlib2tikz-generated figure 'filename' is embedded
in. Displays pdf.
:param filename | Name of input tex snippet (without extension)
"""
from pylatex import Document, Figure, Command, Package
document = Document()
document.packages.append(Package('pgfplots'))
with document.create(Figure(placement='ht')) as fig:
fig.append(Command("centering"))
fig.append(Command("input", "../figures/{}.tex".format(filename)))
fig.add_caption("Test printing.")
document.generate_pdf(clean=True, clean_tex=True)
from subprocess import call
call(['evince', "../figures/default_filepath.pdf"])
def generate_hr_tex(G, matchings, output_dir, stats_filename):
"""
print statistics for the resident proposing stable,
max-cardinality popular, and popular amongst max-cardinality
matchings as a tex file
:param G: graph
:param matchings: information about the matchings
"""
# create a tex file with the statistics
doc = Document('table')
# M_s = matching_algos.stable_matching_hospital_residents(graph.copy_graph(G))
# add details about the graph, |A|, |B|, and # of edges
n1, n2, m = len(G.A), len(G.B), sum(len(G.E[r]) for r in G.A)
with doc.create(Subsection('graph details')):
with doc.create(Tabular('|c|c|')) as table:
table.add_hline()
table.add_row('n1', n1)
table.add_hline()
table.add_row('n2', n1)
table.add_hline()
table.add_row('m', m)
table.add_hline()
with doc.create(Subsection('general statistics')):
with doc.create(Tabular('|c|c|c|c|')) as table:
table.add_hline()
table.add_row(('description', 'size', 'bp', 'bp ratio'))
for desc in matchings:
M = matchings[desc]
sig = signature(G, M)
msize = matching_utils.matching_size(G, M)
bp = matching_utils.unstable_pairs(G, M)
table.add_hline()
table.add_row((desc, msize, len(bp), len(bp)/(m - msize)))
table.add_hline()
# statistics w.r.t. set A
stats_for_partition(G, matchings, doc)
# statistics w.r.t. set B
# stats_for_partition(G, matchings, doc, False)
stats_abs_path = os.path.join(output_dir, stats_filename)
doc.generate_pdf(filepath=stats_abs_path, clean_tex='False')
doc.generate_tex(filepath=stats_abs_path)
def build_document(transcript):
"""
Processes a Transcript object to build a LaTeX document.
"""
# Open temporary file
doc = Document(documentclass='scrartcl', title=transcript.title,
subtitle=transcript.school,
author=transcript.student,
date=transcript.date.strftime('%d %B %Y'), temporary=True)
doc.packages.append(Package('geometry', option='margin=1.0in'))
doc.preamble.append(Command('renewcommand', argument=['\\familydefault', '\\sfdefault']))
doc.append(Command('maketitle'))
# Iterate through each transcript section
for t_section in transcript.sections:
# Create new section
s = Section(escape_latex(t_section.title))
# Add content to section
for s_line in t_section.content:
s_line = '\t'.join(s_line)
s.append(escape_latex(s_line) + ' \\\n')
# Add subsections to section
for t_subsection in t_section.subsections:
ss = Subsection(escape_latex(t_subsection.title))
num_cols = max(len(l) for l in t_subsection.content)
ss_table = Table(' l ' * num_cols)
# Add content to subsection
for ss_line in t_subsection.content:
ss_line = '\t'.join(ss_line)
if ss_line.startswith('Course Topic'):
ss_table.append('&')
ss_table.add_multicolumn(num_cols-1, 'l',
escape_latex(ss_line))
ss_table.append(r'\\')
elif not ss_line[:3].isupper() and not ss_line.startswith('Test'):
ss_table.add_multicolumn(num_cols, 'l', escape_latex(ss_line))
ss_table.append(r'\\')
else:
if ss_line.startswith('TERM'):
ss_table.add_hline()
filled = escape_latex(ss_line).split('\t')
filled += (num_cols - len(filled)) * ['']
ss_table.add_row(filled)
ss.append(ss_table)
s.append(ss)
doc.append(s)
doc.generate_pdf(clean=True)
return doc
def main(argv):
doclink = ''
outputfile = ''
try:
opts, args = getopt.getopt(argv,"hl:o:n:",["doclink=","output=","toolname="])
except getopt.GetoptError:
sys.exit(2)
global defaultname
for opt, arg in opts:
if opt == '-h':
print("paperpp.py -l <document class link> -o <outputfile> -n <name>")
sys.exit()
elif opt in ("-l", "--doclink"):
doclink = arg
elif opt in ("-n", "--toolname"):
defaultname = arg
elif opt in ("-o", "--output"):
outputfile = arg
documentcls=download_doc_class(doclink)
print("Initialize docclass:",documentcls)
paperfile = currdir+ os.sep +"paper"
macrofile = currdir+ os.sep +"macro.tex"
with open(macrofile,"w+") as f:
f.write("\\newcommand{\\toolname}{"+defaultname+"}")
name = current_user()
print("Current_user:"******".tex",paperfile+".tex.copy")
#doc.generate_pdf(paperfile)
shutil.copy2(paperfile+".tex.copy",paperfile+".tex")
os.remove(paperfile+".tex.copy")
def generate_heuristic_tex(G, matchings, output_dir, stats_filename):
"""
print statistics for the hospital proposing heuristic as a tex file
:param G: graph
:param matchings: information about the matchings
"""
# create a tex file with the statistics
doc = Document('table')
# add details about the graph, |A|, |B|, and # of edges
n1, n2, m = len(G.A), len(G.B), sum(len(G.E[r]) for r in G.A)
with doc.create(Subsection('graph details')):
with doc.create(Tabular('|c|c|')) as table:
table.add_hline()
table.add_row('n1', n1)
table.add_hline()
table.add_row('n2', n1)
table.add_hline()
table.add_row('m', m)
table.add_hline()
M_s = matching_algos.stable_matching_hospital_residents(graph.copy_graph(G))
with doc.create(Subsection('Size statistics')):
with doc.create(Tabular('|c|c|c|c|c|c|c|')) as table:
table.add_hline()
table.add_row(('description', 'size', 'bp', 'bp ratio', 'block-R',
'rank-1', 'deficiency'))
for desc in matchings:
M = matchings[desc]
sig = signature(G, M)
bp = matching_utils.unstable_pairs(G, M)
msize = matching_utils.matching_size(G, M)
table.add_hline()
table.add_row((desc, msize, len(bp), len(bp)/(m - msize),
len(blocking_residents(bp)),
sum_ranks(sig, (1,)), #sum_ranks(sig, (1, 2, 3)),
total_deficiency(G, M_s)))
table.add_hline()
stats_abs_path = os.path.join(output_dir, stats_filename)
doc.generate_pdf(filepath=stats_abs_path, clean_tex='False')
doc.generate_tex(filepath=stats_abs_path)
def test_document():
doc = Document(
default_filepath="default_filepath",
documentclass="article",
fontenc="T1",
inputenc="utf8",
lmodern=True,
data=None,
)
doc.append("Some text.")
doc.generate_tex(filepath="")
doc.generate_pdf(filepath="", clean=True)
def _upload_problem(self, problem):
"""Uploads a specified problem to imgur.
Returns:
A tuple (str, (int, int)), where str is the url, on imgur and
the tuples are the dimensions of the image (width, height).
Raises:
LatexParsingException : there was an issue parsing the document
"""
default_doc = []
# populate doc with the appropriate problem
for line in problem[0]:
# these first two statements are for wrapping the title around in a minipage which allows
# the problem to be generated on one page and doesn't invoke \newpage
if line == '\\begin{document}':
default_doc.append(NoEscape(line))
default_doc.append(NoEscape('\\begin{minipage}{\\textwidth}'))
elif line == '\\maketitle':
default_doc.append(NoEscape(line))
default_doc.append(NoEscape('\\end{minipage}'))
elif line == '\\end{itemize}':
for line2 in problem[1]:
default_doc.append(NoEscape(line2))
default_doc.append(NoEscape(line))
else:
default_doc.append(NoEscape(line))
doc_class_line = NoEscape(default_doc[0])
use_pkg_line = NoEscape(default_doc[1])
# skip twocolumn since it makes the problem look spread awfully
opts = filter(lambda pkg: pkg != 'twocolumn', doc_class_line[doc_class_line.find('[') + 1: doc_class_line.find(']')].split(','))
args = NoEscape(doc_class_line[doc_class_line.find('{') + 1: doc_class_line.find('}')])
doc = Document(documentclass=Command('documentclass', options=opts, arguments=args))
# load packages
doc.packages = [Package(i) for i in use_pkg_line[use_pkg_line.find('{') + 1: use_pkg_line.find('}')].split(',')]
# position right after \begin{document}
it = 4
while default_doc[it].strip() != '\end{document}':
doc.append(NoEscape(default_doc[it]))
it += 1
# fail safe for future problems which may not parse correctly
try:
doc.generate_pdf('default', compiler="pdflatex")
except:
raise LatexParsingException
# These are normal Linux commands that are used to convert the pdf
# file created by pylatex into a snippet
os.system("pdfcrop default.pdf")
os.system("pdftoppm default-crop.pdf|pnmtopng > default.png")
path = os.path.abspath('default.png')
uploaded_image = self._client.upload_image(path, title="LaTeX")
return uploaded_image.link, OnlineImage.get_local_image_info(path)
def test_document():
doc = Document(
default_filepath='default_filepath',
documentclass='article',
fontenc='T1',
inputenc='utf8',
lmodern=True,
data=None,
)
repr(doc)
doc.append('Some text.')
doc.generate_tex(filepath='')
doc.generate_pdf(filepath='', clean=True)
def generate_eva_report():
"""
Generate a report which contains the evacution time for every test
"""
geometry_options = {
"head": "40pt",
"margin": "0.5in",
"bottom": "0.6in",
"includeheadfoot": True
}
doc = Document(geometry_options=geometry_options)
## Define style of report
reportStyle = PageStyle("reportStyle")
with reportStyle.create(Head("R")) as left_header:
with left_header.create(MiniPage(width=NoEscape(r"0.49\textwidth"),
pos='c', align='l')) as title_wrapper:
title_wrapper.append(LargeText(bold("RiMEA-Projekt")))
title_wrapper.append(LineBreak())
title_wrapper.append(MediumText(bold("Anlyse")))
doc.preamble.append(reportStyle)
## Apply Pagestyle
doc.change_document_style("reportStyle")
## Create table
with doc.create(LongTabu("X[c] X[c]",
row_height=1.5)) as report_table:
report_table.add_row(["Test",
"evacuation time(s)"],
mapper=bold)
report_table.add_hline()
## Write the results of 3 tests in table
for i in range(1,4):
report_table.add_row(i, get_evac_time(i)[0])
doc.append(NewPage())
doc.generate_pdf("RiMEA-Projekt Evacution Analyse", clean_tex=False)
def test_document():
doc = Document(
default_filepath='default_filepath',
documentclass='article',
fontenc='T1',
inputenc='utf8',
author='',
title='',
date='',
data=None,
maketitle=False
)
doc.append('Some text.')
doc.generate_tex(filepath='')
doc.generate_pdf(filepath='', clean=True)
def __init__(self,title=None,author=None,date=None):
# 初始化
self.doc = Document()
# 载入中文ctex包
self.doc.packages.append(Package('ctex',options=['UTF8','noindent']))
self.doc.packages.append(Package('geometry', options=['tmargin=1cm','lmargin=2cm']))
# 设置标题，作者和日期
if title is not None:
self.doc.preamble.append(Command('title', title))
if author is not None:
self.doc.preamble.append(Command('author', author))
if date is not None:
self.doc.preamble.append(Command('date', date))
self.doc.append(r'\maketitle')
# 设置现在的章节
self.presentSection = deque()
# 初始化章节内容
self.content = []
def test():
doc = Document('jobname_test', title='Jobname test', maketitle=True)
doc.generate_pdf()
assert os.path.isfile('jobname_test.pdf')
os.remove('jobname_test.pdf')
folder = 'tmp_jobname'
os.makedirs(folder)
path = os.path.join(folder, 'jobname_test_dir')
doc = Document(path, title='Jobname test dir', maketitle=True)
doc.generate_pdf()
assert os.path.isfile(path + '.pdf')
filename = doc.select_filepath(os.path.join(folder, ''))
assert '' != os.path.basename(filename)
shutil.rmtree(folder)
def genenerate_tabus():
geometry_options = {
"landscape": True,
"margin": "1.5in",
"headheight": "20pt",
"headsep": "10pt",
"includeheadfoot": True
}
doc = Document(page_numbers=True, geometry_options=geometry_options)
# Generate data table with 'tight' columns
fmt = "X[r] X[r] X[r] X[r] X[r] X[r]"
with doc.create(LongTabu(fmt, spread="0pt")) as data_table:
header_row1 = ["Prov", "Num", "CurBal", "IntPay", "Total", "IntR"]
data_table.add_row(header_row1, mapper=[bold])
data_table.add_hline()
data_table.add_empty_row()
data_table.end_table_header()
data_table.add_row(["Prov", "Num", "CurBal", "IntPay", "Total",
"IntR"])
row = ["PA", "9", "$100", "%10", "$1000", "Test"]
for i in range(40):
data_table.add_row(row)
with doc.create(Center()) as centered:
with centered.create(Tabu("X[r] X[r]", spread="1in")) as data_table:
header_row1 = ["X", "Y"]
data_table.add_row(header_row1, mapper=[bold])
data_table.add_hline()
row = [randint(0, 1000), randint(0, 1000)]
for i in range(4):
data_table.add_row(row)
with doc.create(Center()) as centered:
with centered.create(Tabu("X[r] X[r]", to="4in")) as data_table:
header_row1 = ["X", "Y"]
data_table.add_row(header_row1, mapper=[bold])
data_table.add_hline()
row = [randint(0, 1000), randint(0, 1000)]
for i in range(4):
data_table.add_row(row)
doc.generate_pdf("tabus", clean_tex=False)
def description_classification(full_data_files, description_folder):
data_list = list()
for d in full_data_files:
name = d.split('/')[2].split('.')[0]
df = pd.read_csv(d,
sep='\s+',
header=None)
lines, columns = df.shape
attribute = columns - 1 # Minus one because of target
last_pos = attribute
classes = np.unique(df[last_pos])
n_classes = len(classes)
distribution_list = [len(df[df[last_pos] == c]) for c in classes]
distribution_list.sort(reverse=True)
distribution = tuple(distribution_list)
data_list.append({'Dataset': name,
'Size': lines,
'Attributes': attribute,
'Classes': n_classes,
'Class distribution': distribution})
df = pd.DataFrame(data_list)
df = df.sort_values('Size', ascending=False)
cols = ['Dataset',
'Size',
'Attributes',
'Classes',
'Class distribution']
df = df[cols]
df_copy = deepcopy(df)
df_copy['Class distribution'] = [str(value).replace(', ', ';').replace(')', '').replace('(', '')
for value in df_copy['Class distribution']]
df_copy.to_csv(os.path.join(description_folder,
'data_description.csv'),
sep=',',
header=True,
columns=['Dataset',
'Size',
'Attributes',
'Classes',
'Class distribution'],
index=False)
# # LaTeX
df = df.set_index(['Dataset'])
# Max classes per row
max_classes = np.inf
geometry_options = {
"margin": "1.00cm",
"includeheadfoot": True
}
doc = Document(page_numbers=True, geometry_options=geometry_options)
# Generate data table
with doc.create(LongTable("l l l l l")) as data_table:
data_table.add_hline()
header = ["Dataset",
"Size",
"#Attr.",
"#Classes",
"Class distribution"]
data_table.add_row(header)
data_table.add_hline()
data_table.add_hline()
for index in df.index.values:
row = [index] + df.loc[index].values.tolist()
if len(row[-1]) > max_classes:
max = max_classes
finished = False
subrow = row.copy()
# Select subtuple and removing last parenthesis
subrow[-1] = str(subrow[-1][:max]).replace(')', ',')
data_table.add_row(subrow)
while finished is False:
last_element = row[-1][max:max + max_classes]
if len(last_element) == 1:
# To string
last_element = str(last_element)
# Remove first and last parenthesis and comma
last_element = last_element[1:-2]
else:
# To string
last_element = str(last_element)
# Remove first and last parenthesis
last_element = last_element[1:-1]
max = max + max_classes
if max >= len(row[-1]):
finished = True
last_element += ')'
else:
# Remove last parenthesis or comma if len is 1
last_element = last_element[:-1]
subrow = ['', '', '', '', last_element]
data_table.add_row(subrow)
else:
data_table.add_row(row)
doc.generate_pdf(os.path.join(description_folder,
'data_description'), clean_tex=False)
class Traceability(Trace):
"""Automatically generate summary reports of the training.
Args:
save_path: Where to save the output files. Note that this will generate a new folder with the given name, into
which the report and corresponding graphics assets will be written.
extra_objects: Any extra objects which are not part of the Estimator, but which you want to capture in the
summary report. One example could be an extra pipeline which performs pre-processing.
Raises:
OSError: If graphviz is not installed.
"""
def __init__(self, save_path: str, extra_objects: Any = None):
# Verify that graphviz is available on this machine
try:
pydot.Dot.create(pydot.Dot())
except OSError:
raise OSError(
"Traceability requires that graphviz be installed. See www.graphviz.org/download for more information.")
# Verify that the system locale is functioning correctly
try:
locale.getlocale()
except ValueError:
raise OSError("Your system locale is not configured correctly. On mac this can be resolved by adding \
'export LC_ALL=en_US.UTF-8' and 'export LANG=en_US.UTF-8' to your ~/.bash_profile")
super().__init__(inputs="*", mode="!infer") # Claim wildcard inputs to get this trace sorted last
# Report assets will get saved into a folder for portability
path = os.path.normpath(save_path)
path = os.path.abspath(path)
root_dir = os.path.dirname(path)
report = os.path.basename(path) or 'report'
report = report.split('.')[0]
self.save_dir = os.path.join(root_dir, report)
self.figure_dir = os.path.join(self.save_dir, 'resources')
self.report_name = None # This will be set later by the experiment name
os.makedirs(self.save_dir, exist_ok=True)
os.makedirs(self.figure_dir, exist_ok=True)
# Other member variables
self.config_tables = []
# Extra objects will automatically get included in the report since this Trace is @traceable, so we don't need
# to do anything with them. Referencing here to stop IDEs from flagging the argument as unused and removing it.
to_list(extra_objects)
self.doc = Document()
self.log_splicer = None
def on_begin(self, data: Data) -> None:
exp_name = self.system.summary.name
if not exp_name:
raise RuntimeError("Traceability reports require an experiment name to be provided in estimator.fit()")
# Convert the experiment name to a report name (useful for saving multiple experiments into same directory)
report_name = "".join('_' if c == ' ' else c for c in exp_name
if c.isalnum() or c in (' ', '_')).rstrip().lower()
report_name = re.sub('_{2,}', '_', report_name)
self.report_name = report_name or 'report'
# Send experiment logs into a file
log_path = os.path.join(self.figure_dir, f"{report_name}.txt")
if self.system.mode != 'test':
# If not running in test mode, we need to remove any old log file since it would get appended to
with contextlib.suppress(FileNotFoundError):
os.remove(log_path)
self.log_splicer = LogSplicer(log_path)
self.log_splicer.__enter__()
# Get the initialization summary information for the experiment
self.config_tables = self.system.summary.system_config
models = self.system.network.models
n_floats = len(self.config_tables) + len(models)
self.doc = Document(geometry_options=['lmargin=2cm', 'rmargin=2cm', 'tmargin=2cm', 'bmargin=2cm'])
# Keep tables/figures in their sections
self.doc.packages.append(Package(name='placeins', options=['section']))
self.doc.preamble.append(NoEscape(r'\usetikzlibrary{positioning}'))
# Fix an issue with too many tables for LaTeX to render
self.doc.preamble.append(NoEscape(r'\maxdeadcycles=' + str(2 * n_floats + 10) + ''))
self.doc.preamble.append(NoEscape(r'\extrafloats{' + str(n_floats + 10) + '}'))
# Manipulate booktab tables so that their horizontal lines don't break
self.doc.preamble.append(NoEscape(r'\aboverulesep=0ex'))
self.doc.preamble.append(NoEscape(r'\belowrulesep=0ex'))
self.doc.preamble.append(NoEscape(r'\renewcommand{\arraystretch}{1.2}'))
self.doc.preamble.append(Command('title', exp_name))
self.doc.preamble.append(Command('author', f"FastEstimator {fe.__version__}"))
self.doc.preamble.append(Command('date', NoEscape(r'\today')))
self.doc.append(NoEscape(r'\maketitle'))
# TOC
self.doc.append(NoEscape(r'\tableofcontents'))
self.doc.append(NoEscape(r'\newpage'))
def on_end(self, data: Data) -> None:
self._document_training_graphs()
self.doc.append(NoEscape(r'\newpage'))
self._document_fe_graph()
self.doc.append(NoEscape(r'\newpage'))
self._document_init_params()
self._document_models()
self._document_sys_config()
# Need to move the tikz dependency after the xcolor package
self.doc.dumps_packages()
packages = self.doc.packages
tikz = Package(name='tikz')
packages.discard(tikz)
packages.add(tikz)
if shutil.which("latexmk") is None and shutil.which("pdflatex") is None:
# No LaTeX Compiler is available
self.doc.generate_tex(os.path.join(self.save_dir, self.report_name))
suffix = '.tex'
else:
# Force a double-compile since some compilers will struggle with TOC generation
self.doc.generate_pdf(os.path.join(self.save_dir, self.report_name), clean_tex=False, clean=False)
self.doc.generate_pdf(os.path.join(self.save_dir, self.report_name), clean_tex=False)
suffix = '.pdf'
print("FastEstimator-Traceability: Report written to {}{}".format(os.path.join(self.save_dir, self.report_name),
suffix))
self.log_splicer.__exit__()
def _document_training_graphs(self) -> None:
"""Add training graphs to the traceability document.
"""
with self.doc.create(Section("Training Graphs")):
log_path = os.path.join(self.figure_dir, f'{self.report_name}_logs.png')
visualize_logs(experiments=[self.system.summary],
save_path=log_path,
verbose=False,
ignore_metrics={'num_device', 'logging_interval'})
with self.doc.create(Figure(position='h!')) as plot:
plot.add_image(os.path.relpath(log_path, start=self.save_dir),
width=NoEscape(r'1.0\textwidth,height=0.95\textheight,keepaspectratio'))
def _document_fe_graph(self) -> None:
"""Add FE execution graphs into the traceability document.
"""
with self.doc.create(Section("FastEstimator Architecture")):
for mode in self.system.pipeline.data.keys():
scheduled_items = self.system.pipeline.get_scheduled_items(
mode) + self.system.network.get_scheduled_items(mode) + self.system.traces
signature_epochs = get_signature_epochs(scheduled_items, total_epochs=self.system.epoch_idx, mode=mode)
epochs_with_data = self.system.pipeline.get_epochs_with_data(total_epochs=self.system.epoch_idx,
mode=mode)
if set(signature_epochs) & epochs_with_data:
self.doc.append(NoEscape(r'\FloatBarrier'))
with self.doc.create(Subsection(mode.capitalize())):
for epoch in signature_epochs:
if epoch not in epochs_with_data:
continue
self.doc.append(NoEscape(r'\FloatBarrier'))
with self.doc.create(
Subsubsection(f"Epoch {epoch}",
label=Label(Marker(name=f"{mode}{epoch}", prefix="ssubsec")))):
diagram = self._draw_diagram(mode, epoch)
ltx = d2t.dot2tex(diagram.to_string(), figonly=True)
args = Arguments(**{'max width': r'\textwidth, max height=0.9\textheight'})
args.escape = False
with self.doc.create(Center()):
with self.doc.create(AdjustBox(arguments=args)) as box:
box.append(NoEscape(ltx))
def _document_init_params(self) -> None:
"""Add initialization parameters to the traceability document.
"""
from fastestimator.estimator import Estimator # Avoid circular import
with self.doc.create(Section("Parameters")):
model_ids = {
FEID(id(model))
for model in self.system.network.models if isinstance(model, (tf.keras.Model, torch.nn.Module))
}
# Locate the datasets in order to provide extra details about them later in the summary
datasets = {}
for mode in ['train', 'eval', 'test']:
objs = to_list(self.system.pipeline.data.get(mode, None))
idx = 0
while idx < len(objs):
obj = objs[idx]
if obj:
feid = FEID(id(obj))
if feid not in datasets:
datasets[feid] = ({mode}, obj)
else:
datasets[feid][0].add(mode)
if isinstance(obj, Scheduler):
objs.extend(obj.get_all_values())
idx += 1
# Parse the config tables
start = 0
start = self._loop_tables(start,
classes=(Estimator, BaseNetwork, Pipeline),
name="Base Classes",
model_ids=model_ids,
datasets=datasets)
start = self._loop_tables(start,
classes=Scheduler,
name="Schedulers",
model_ids=model_ids,
datasets=datasets)
start = self._loop_tables(start, classes=Trace, name="Traces", model_ids=model_ids, datasets=datasets)
start = self._loop_tables(start, classes=Op, name="Ops", model_ids=model_ids, datasets=datasets)
start = self._loop_tables(start,
classes=(Dataset, tf.data.Dataset),
name="Datasets",
model_ids=model_ids,
datasets=datasets)
start = self._loop_tables(start,
classes=(tf.keras.Model, torch.nn.Module),
name="Models",
model_ids=model_ids,
datasets=datasets)
start = self._loop_tables(start,
classes=types.FunctionType,
name="Functions",
model_ids=model_ids,
datasets=datasets)
start = self._loop_tables(start,
classes=(np.ndarray, tf.Tensor, tf.Variable, torch.Tensor),
name="Tensors",
model_ids=model_ids,
datasets=datasets)
self._loop_tables(start, classes=Any, name="Miscellaneous", model_ids=model_ids, datasets=datasets)
def _loop_tables(self,
start: int,
classes: Union[type, Tuple[type, ...]],
name: str,
model_ids: Set[FEID],
datasets: Dict[FEID, Tuple[Set[str], Any]]) -> int:
"""Iterate through tables grouping them into subsections.
Args:
start: What index to start searching from.
classes: What classes are acceptable for this subsection.
name: What to call this subsection.
model_ids: The ids of any known models.
datasets: A mapping like {ID: ({modes}, dataset)}. Useful for augmenting the displayed information.
Returns:
The new start index after traversing as many spaces as possible along the list of tables.
"""
stop = start
while stop < len(self.config_tables):
if classes == Any or issubclass(self.config_tables[stop].type, classes):
stop += 1
else:
break
if stop > start:
self.doc.append(NoEscape(r'\FloatBarrier'))
with self.doc.create(Subsection(name)):
self._write_tables(self.config_tables[start:stop], model_ids, datasets)
return stop
def _write_tables(self,
tables: List[FeSummaryTable],
model_ids: Set[FEID],
datasets: Dict[FEID, Tuple[Set[str], Any]]) -> None:
"""Insert a LaTeX representation of a list of tables into the current doc.
Args:
tables: The tables to write into the doc.
model_ids: The ids of any known models.
datasets: A mapping like {ID: ({modes}, dataset)}. Useful for augmenting the displayed information.
"""
for tbl in tables:
name_override = None
toc_ref = None
extra_rows = None
if tbl.fe_id in model_ids:
# Link to a later detailed model description
name_override = Hyperref(Marker(name=str(tbl.name), prefix="subsec"),
text=NoEscape(r'\textcolor{blue}{') + bold(tbl.name) + NoEscape('}'))
if tbl.fe_id in datasets:
modes, dataset = datasets[tbl.fe_id]
title = ", ".join([s.capitalize() for s in modes])
name_override = bold(f'{tbl.name} ({title})')
# Enhance the dataset summary
if isinstance(dataset, FEDataset):
extra_rows = list(dataset.summary().__getstate__().items())
for idx, (key, val) in enumerate(extra_rows):
key = f"{prettify_metric_name(key)}:"
if isinstance(val, dict) and val:
if isinstance(list(val.values())[0], (int, float, str, bool, type(None))):
val = jsonpickle.dumps(val, unpicklable=False)
else:
subtable = Tabular('l|l')
for k, v in val.items():
if hasattr(v, '__getstate__'):
v = jsonpickle.dumps(v, unpicklable=False)
subtable.add_row((k, v))
val = subtable
extra_rows[idx] = (key, val)
tbl.render_table(self.doc, name_override=name_override, toc_ref=toc_ref, extra_rows=extra_rows)
def _document_models(self) -> None:
"""Add model summaries to the traceability document.
"""
with self.doc.create(Section("Models")):
for model in humansorted(self.system.network.models, key=lambda m: m.model_name):
if not isinstance(model, (tf.keras.Model, torch.nn.Module)):
continue
self.doc.append(NoEscape(r'\FloatBarrier'))
with self.doc.create(Subsection(f"{model.model_name}")):
if isinstance(model, tf.keras.Model):
# Text Summary
summary = []
model.summary(line_length=92, print_fn=lambda x: summary.append(x))
summary = "\n".join(summary)
self.doc.append(Verbatim(summary))
with self.doc.create(Center()):
self.doc.append(HrefFEID(FEID(id(model)), model.model_name))
# Visual Summary
# noinspection PyBroadException
try:
file_path = os.path.join(self.figure_dir,
"{}_{}.pdf".format(self.report_name, model.model_name))
dot = tf.keras.utils.model_to_dot(model, show_shapes=True, expand_nested=True)
# LaTeX \maxdim is around 575cm (226 inches), so the image must have max dimension less than
# 226 inches. However, the 'size' parameter doesn't account for the whole node height, so
# set the limit lower (100 inches) to leave some wiggle room.
dot.set('size', '100')
dot.write(file_path, format='pdf')
except Exception:
file_path = None
print(
f"FastEstimator-Warn: Model {model.model_name} could not be visualized by Traceability")
elif isinstance(model, torch.nn.Module):
if hasattr(model, 'fe_input_spec'):
# Text Summary
# noinspection PyUnresolvedReferences
inputs = model.fe_input_spec.get_dummy_input()
self.doc.append(
Verbatim(
pms.summary(model.module if self.system.num_devices > 1 else model,
inputs,
print_summary=False)))
with self.doc.create(Center()):
self.doc.append(HrefFEID(FEID(id(model)), model.model_name))
# Visual Summary
# Import has to be done while matplotlib is using the Agg backend
old_backend = matplotlib.get_backend() or 'Agg'
matplotlib.use('Agg')
# noinspection PyBroadException
try:
# Fake the IPython import when user isn't running from Jupyter
sys.modules.setdefault('IPython', MagicMock())
sys.modules.setdefault('IPython.display', MagicMock())
import hiddenlayer as hl
with Suppressor():
graph = hl.build_graph(model.module if self.system.num_devices > 1 else model,
inputs)
graph = graph.build_dot()
graph.attr(rankdir='TB') # Switch it to Top-to-Bottom instead of Left-to-Right
# LaTeX \maxdim is around 575cm (226 inches), so the image must have max dimension less
# than 226 inches. However, the 'size' parameter doesn't account for the whole node
# height, so set the limit lower (100 inches) to leave some wiggle room.
graph.attr(size="100,100")
graph.attr(margin='0')
file_path = graph.render(filename="{}_{}".format(self.report_name, model.model_name),
directory=self.figure_dir,
format='pdf',
cleanup=True)
except Exception:
file_path = None
print("FastEstimator-Warn: Model {} could not be visualized by Traceability".format(
model.model_name))
finally:
matplotlib.use(old_backend)
else:
file_path = None
self.doc.append("This model was not used by the Network during training.")
if file_path:
with self.doc.create(Figure(position='ht!')) as fig:
fig.append(Label(Marker(name=str(FEID(id(model))), prefix="model")))
fig.add_image(os.path.relpath(file_path, start=self.save_dir),
width=NoEscape(r'1.0\textwidth,height=0.95\textheight,keepaspectratio'))
fig.add_caption(NoEscape(HrefFEID(FEID(id(model)), model.model_name).dumps()))
def _document_sys_config(self) -> None:
"""Add a system config summary to the traceability document.
"""
with self.doc.create(Section("System Config")):
with self.doc.create(Itemize()) as itemize:
itemize.add_item(escape_latex(f"FastEstimator {fe.__version__}"))
itemize.add_item(escape_latex(f"Python {platform.python_version()}"))
itemize.add_item(escape_latex(f"OS: {sys.platform}"))
itemize.add_item(f"Number of GPUs: {torch.cuda.device_count()}")
if fe.fe_deterministic_seed is not None:
itemize.add_item(escape_latex(f"Deterministic Seed: {fe.fe_deterministic_seed}"))
with self.doc.create(LongTable('|lr|', pos=['h!'], booktabs=True)) as tabular:
tabular.add_row((bold("Module"), bold("Version")))
tabular.add_hline()
tabular.end_table_header()
tabular.add_hline()
tabular.add_row((MultiColumn(2, align='r', data='Continued on Next Page'), ))
tabular.add_hline()
tabular.end_table_footer()
tabular.end_table_last_footer()
color = True
for name, module in humansorted(sys.modules.items(), key=lambda x: x[0]):
if "." in name:
continue # Skip sub-packages
if name.startswith("_"):
continue # Skip private packages
if isinstance(module, Base):
continue # Skip fake packages we mocked
if hasattr(module, '__version__'):
tabular.add_row((escape_latex(name), escape_latex(str(module.__version__))),
color='black!5' if color else 'white')
color = not color
elif hasattr(module, 'VERSION'):
tabular.add_row((escape_latex(name), escape_latex(str(module.VERSION))),
color='black!5' if color else 'white')
color = not color
def _draw_diagram(self, mode: str, epoch: int) -> pydot.Dot:
"""Draw a summary diagram of the FastEstimator Ops / Traces.
Args:
mode: The execution mode to summarize ('train', 'eval', 'test', or 'infer').
epoch: The epoch to summarize.
Returns:
A pydot digraph representing the execution flow.
"""
ds = self.system.pipeline.data[mode]
if isinstance(ds, Scheduler):
ds = ds.get_current_value(epoch)
pipe_ops = get_current_items(self.system.pipeline.ops, run_modes=mode, epoch=epoch) if isinstance(
ds, Dataset) else []
net_ops = get_current_items(self.system.network.ops, run_modes=mode, epoch=epoch)
traces = sort_traces(get_current_items(self.system.traces, run_modes=mode, epoch=epoch))
diagram = pydot.Dot()
diagram.set('rankdir', 'TB')
diagram.set('dpi', 300)
diagram.set_node_defaults(shape='record')
# Make the dataset the first of the pipeline ops
pipe_ops.insert(0, ds)
label_last_seen = defaultdict(lambda: str(id(ds))) # Where was this key last generated
batch_size = ""
if isinstance(ds, Dataset) and not isinstance(ds, BatchDataset):
batch_size = self.system.pipeline.batch_size
if isinstance(batch_size, Scheduler):
batch_size = batch_size.get_current_value(epoch)
if batch_size is not None:
batch_size = f" (Batch Size: {batch_size})"
self._draw_subgraph(diagram, label_last_seen, f'Pipeline{batch_size}', pipe_ops)
self._draw_subgraph(diagram, label_last_seen, 'Network', net_ops)
self._draw_subgraph(diagram, label_last_seen, 'Traces', traces)
return diagram
@staticmethod
def _draw_subgraph(diagram: pydot.Dot,
label_last_seen: DefaultDict[str, str],
subgraph_name: str,
subgraph_ops: List[Union[Op, Trace, Any]]) -> None:
"""Draw a subgraph of ops into an existing `diagram`.
Args:
diagram: The diagram to be appended to.
label_last_seen: A mapping of {data_dict_key: node_id} indicating the last node which generated the key.
subgraph_name: The name to be associated with this subgraph.
subgraph_ops: The ops to be wrapped in this subgraph.
"""
subgraph = pydot.Cluster(style='dashed', graph_name=subgraph_name)
subgraph.set('label', subgraph_name)
subgraph.set('labeljust', 'l')
for idx, op in enumerate(subgraph_ops):
node_id = str(id(op))
Traceability._add_node(subgraph, op, node_id)
if isinstance(op, (Op, Trace)):
# Need the instance check since subgraph_ops might contain a tf dataset or torch dataloader
edge_srcs = defaultdict(lambda: [])
for inp in op.inputs:
if inp == '*':
continue
edge_srcs[label_last_seen[inp]].append(inp)
for src, labels in edge_srcs.items():
diagram.add_edge(pydot.Edge(src=src, dst=node_id, label=f" {', '.join(labels)} "))
for out in op.outputs:
label_last_seen[out] = node_id
if isinstance(op, Trace) and idx > 0:
# Invisibly connect traces in order so that they aren't all just squashed horizontally into the image
diagram.add_edge(pydot.Edge(src=str(id(subgraph_ops[idx - 1])), dst=node_id, style='invis'))
diagram.add_subgraph(subgraph)
@staticmethod
def _add_node(diagram: Union[pydot.Dot, pydot.Cluster], op: Union[Op, Trace], node_id: str) -> None:
"""Draw a node onto a diagram based on a given op.
Args:
diagram: The diagram to be appended to.
op: The op (or trace) to be visualized.
node_id: The id to use as the node label.
"""
if isinstance(op, Sometimes) and op.numpy_op:
wrapper = pydot.Cluster(style='loosely dotted', graph_name=str(id(op)))
wrapper.set('label', f'Sometimes ({op.prob}):')
wrapper.set('labeljust', 'r')
Traceability._add_node(wrapper, op.numpy_op, node_id)
diagram.add_subgraph(wrapper)
elif isinstance(op, OneOf) and op.numpy_ops:
wrapper = pydot.Cluster(style='loosely dotted', graph_name=str(id(op)))
wrapper.set('label', 'One Of:')
wrapper.set('labeljust', 'r')
Traceability._add_node(wrapper, op.numpy_ops[0], node_id)
for sub_op in op.numpy_ops[1:]:
Traceability._add_node(wrapper, sub_op, str(id(sub_op)))
diagram.add_subgraph(wrapper)
else:
if isinstance(op, ModelOp):
label = f"{op.__class__.__name__} ({FEID(id(op))}): {op.model.model_name}"
model_ref = Hyperref(Marker(name=str(op.model.model_name), prefix='subsec'),
text=NoEscape(r'\textcolor{blue}{') + bold(op.model.model_name) +
NoEscape('}')).dumps()
texlbl = f"{HrefFEID(FEID(id(op)), name=op.__class__.__name__).dumps()}: {model_ref}"
else:
label = f"{op.__class__.__name__} ({FEID(id(op))})"
texlbl = HrefFEID(FEID(id(op)), name=op.__class__.__name__).dumps()
diagram.add_node(pydot.Node(node_id, label=label, texlbl=texlbl))
plt.xlabel('runs')
plt.savefig(throughput_image_dir)
# Bar chart for Average latency vs Siddhi version
plt.figure(2)
rects2 = plt.bar(ind, latency, width, color='blue')
plt.xticks(ind + width / 2, (no_of_file))
plt.ylabel('Average Latency(microseconds)')
plt.xlabel('runs')
plt.savefig(latency_image_dir)
# Report Generation
if __name__ == '__main__':
# basic document
doc = Document()
doc.preamble.append(Command('title', 'Report'))
doc.preamble.append(Command('author', 'Stream Processor Performance Testing-' + path))
doc.preamble.append(Command('date', NoEscape(r'\today')))
doc.append(NoEscape(r'\maketitle'))
doc.append(NoEscape(r'\newpage'))
# Generating summary results chart for each run
# throughput summary table and chart
with doc.create(
Section('Average Throughput During 60-180 seconds time period since the start of the benchmarking experiment')):
doc.append(NoEscape(r'\hfill \break'))
fmt = "X[r] X[r]"
def main(fname, width, *args, **kwargs):
doc = Document(fname)
doc.packages.append(Package('geometry', options=['left=2cm', 'right=2cm']))
doc.append('Introduction.')
with doc.create(Section('I am a section')):
doc.append('Take a look at this beautiful plot:')
with doc.create(Figure(position='htbp')) as plot:
plot.add_plot(width=NoEscape(width), *args, **kwargs)
plot.add_caption('I am a caption.')
doc.append('Created using matplotlib.')
doc.append('Conclusion.')
doc.generate_pdf()
"link_for_arised_issue_on_github": "https://github.com/JelteF/PyLaTeX/issues/209",
}
"""
from pylatex import Document, LargeText
from pylatex.section import Paragraph;
from pylatex.utils import bold
geometry_options = {
"head": "0.5pt",
"margin": "0.5in",
"bottom": "0.5in",
"includeheadfoot": True
}
# documnet_options = ["a4paper"] can also be used to set the paper size
doc = Document("paragraph", indent=True, geometry_options=geometry_options, document_options="a4paper");
text1 = """At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id.""";
text2 = """quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis olor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessit atibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat.""";
text3 = """Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duisaute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla ariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum""";
with doc.create(Paragraph("")):
doc.append(LargeText( bold("Dear Malinikesh,")));
with doc.create(Paragraph("Paragraph1")):
doc.append(text1);
with doc.create(Paragraph("Paragraph2")):
doc.append(text2);
def _add_string_notes(document: pylatex.Document, texts: dict,
images: dict) -> None:
document.append(
pylatex.Subsection(
title=texts["strings"]["title"],
label=False,
numbering=False,
))
document.append(
pylatex.Subsubsection(
title=texts["strings"]["subtitle0"],
label=False,
numbering=False,
))
document.append(texts["strings"]["text0"])
document.append(
pylatex.Subsubsection(
title=texts["microtonal_notation"]["title"],
label=False,
numbering=False,
))
document.append(texts["microtonal_notation"]["text0"])
document.append(_make_img(images["twelfth_tone_explanation"]))
document.append(texts["microtonal_notation"]["text1"])
for instrument in ("violin", "viola", "cello"):
document.append(_make_img(images["scale_{}".format(instrument)]))
document.append(
_make_img(
images["scale_{}_artificial_harmonics".format(instrument)]))
document.append(
pylatex.Command("hspace", arguments=[pylatex.NoEscape("5mm")]))
document.append(texts["microtonal_notation"]["text2"])
document.append(
pylatex.Subsubsection(
title=texts["strings"]["subtitle1"],
label=False,
numbering=False,
))
document.append(_make_img(images["ornamentation"], width=0.25))
document.append(texts["strings"]["text1"])
document.append(_make_img(images["glissando"], width=0.28))
document.append(texts["strings"]["text2"])
def create(self):
try:
self.status['text'] = 'Загрузка, подождите'
self.root.update()
# Настройки отступов, языка
geometry_options = {
"tmargin": "2cm",
"lmargin": "3cm",
"rmargin": "1.5cm",
"bmargin": "2cm"
}
doc = Document(geometry_options=geometry_options)
doc.packages.add(
Package('grffile',
options=['encoding', 'filenameencoding=utf8']))
doc.packages.add(Package('babel', options=['russian']))
# Вставляем логотип МИРЭА
image_filename = os.path.join(os.path.dirname(__file__),
'логотип.png')
with doc.create(Figure(position='h!')) as logo:
logo.add_image(image_filename, width='80px')
# Обложка
doc.change_length(r"\TPHorizModule", "1mm")
doc.change_length(r"\TPVertModule", "1mm")
with doc.create(MiniPage(width=r"\textwidth")) as page:
# Центральная часть обложки
with page.create(TextBlock(180, 0, 0)):
page.append(Command('centering'))
page.append('МИНОБРНАУКИ РОССИИ\n')
page.append(
'Федеральное государственное бюджетное образовательное учреждение высшего образования\n'
)
page.append(
MediumText(
bold(
'«МИРЭА - Российский Технологический Университет»\n'
)))
page.append(LargeText(bold('РТУ МИРЭА\n')))
page.append(LineBreak())
page.append(
MediumText(
bold(
'Институт комплексной безопасности и специального приборостроения\n'
)))
page.append(LineBreak())
page.append(
'Кафедра КБ-8 «Информационное Противоборство»\n')
page.append(LineBreak())
page.append(LineBreak())
page.append(LineBreak())
page.append(LargeText('Отчёт\n'))
page.append(f'{str(self.entry1.get())}\n')
# Правая часть обложки
with page.create(TextBlock(80, 88, 120)):
if self.your_var.get() == 0:
page.append('Выполнил:\n')
page.append(
f'Студент {str(self.entry2.get())} курса\n')
else:
page.append('Выполнила:\n')
page.append(
f'Студентка {str(self.entry2.get())} курса\n')
page.append(f'Группа {str(self.entry3.get())}\n')
page.append(f'Шифр {str(self.entry4.get())}\n')
page.append(f'{str(self.entry5.get())}\n')
page.append(LineBreak())
page.append(LineBreak())
if self.var.get() == 0:
page.append('Проверил:\n')
else:
page.append('Проверила:\n')
page.append(f'{str(self.entry6.get())}\n')
# Нижний колонтитул
header = PageStyle("header")
with header.create(Foot("C")):
header.append(f'Москва, {time.now().timetuple().tm_year}\n')
doc.preamble.append(header)
doc.change_document_style("header")
doc.generate_pdf("title", clean_tex=False)
self.status['text'] = 'Готово!'
except FileNotFoundError as e:
self.status['text'] = str(e)
class Resume1:
def __init__(self, name, email, number):
borders = {
"tmargin": "0.6in",
"rmargin": "0.75in",
"lmargin": "0.75in",
"bmargin": "0.6in"
}
self.doc = Document(documentclass="resume", geometry_options=borders)
self.doc.append(Command("begin", "flushleft"))
self.addCustomCommands()
self.addTitle(name, email, number)
def addCustomCommands(self):
EduEntry = UnsafeCommand('newcommand',
r'\EducationEntry',
options=1,
extra_arguments=r"""
{\bf California Polytechnic State University}
\hfill
{\em September {#1} - Present}
""")
BoldHeading = UnsafeCommand('newcommand',
r'\BoldHeading',
options=1,
extra_arguments=r"""
{\bf{#1}}
""")
FirstDatedEntry = UnsafeCommand('newcommand',
r'\FirstDatedEntry',
options=2,
extra_arguments=r"""
\text{#1}
\hfill
{\em{#2}}
""")
DatedEntry = UnsafeCommand('newcommand',
r'\DatedEntry',
options=2,
extra_arguments=r"""
\item{#1}
\hfill
{\em{#2}}
""")
self.doc.append(EduEntry)
self.doc.append(BoldHeading)
self.doc.append(DatedEntry)
self.doc.append(FirstDatedEntry)
def addTitle(self, student_name, email, number):
self.doc.preamble.append(Command("name", student_name))
self.doc.preamble.append(Command("address", f"{number} | {email}"))
def addEducation(self, year, grad, major):
self.doc.append(Command("begin", ["rSection", "Education"]))
self.doc.append(Command("EducationEntry", year))
self.doc.append(LineBreak())
self.doc.append("Bachelor of Science in " + major)
self.doc.append(LineBreak())
self.doc.append("Projected graduation date: June " + grad)
self.doc.append(Command("end", "rSection"))
""" Projects must be given as a list of tuples in the format (name, description) """
def addProjects(self, projects):
self.doc.append(Command("begin", ["rSection", "Projects"]))
for i in range(len(projects)):
self.doc.append(Command("BoldHeading", projects[i][0]))
self.doc.append(LineBreak())
self.doc.append(projects[i][1])
if i < len(projects) - 1:
self.doc.append(LineBreak())
self.doc.append(LineBreak())
self.doc.append(Command("end", "rSection"))
""" Projects must be given as a list of tuples in the format (name, date, position, description) """
def addExperience(self, jobs):
self.doc.append(Command("begin", ["rSection", "Work Experience"]))
for job in jobs:
self.doc.append(
Command("begin",
["rSubsection", job[0],
italic(job[1]), job[2], '']))
self.doc.append(Command("item", job[3]))
self.doc.append(Command("end", "rSubsection"))
self.doc.append(Command("end", "rSection"))
""" Type should be either 'Techincal' or 'Soft' """
def addSkills(self, type, skills):
self.doc.append(Command("begin", ["rSection", type + " Skills"]))
self.doc.append(", ".join(skills))
self.doc.append(Command("end", "rSection"))
""" Extracurriculars must be given as a list of tuples in the format (name, date) """
def addExtracurriculars(self, activities):
self.doc.append(
Command("begin", ["rSection", "Extracurricular Activities"]))
self.doc.append(Command("FirstDatedEntry", activities[0]))
for act in activities[1:]:
self.doc.append(Command("DatedEntry", act))
self.doc.append(Command("end", "rSection"))
def addRelevantCoursework(self, classes):
self.doc.append(Command("begin", ["rSection", "Relevant Coursework"]))
self.doc.append(Command("text", classes[0]))
for c in classes[1:]:
self.doc.append(Command("item", c))
self.doc.append(Command("end", "rSection"))
def finish(self):
self.doc.append(Command("end", "flushleft"))
cv=folds,
n_jobs=-1)
scores.append(accsespf1g(testpredict, testtarget))
print(str(clf))
print_scores(testpredict, testtarget)
# usrednanie wynikow
avgscores = avgaccsespf1g(scores)
to_decimal = print_to_latex_two_decimal(avgscores)
for i, score in enumerate(to_decimal):
rows[i].append(score)
for table, row in zip(tables, rows):
print(row)
max_v = max(row[1:])
new_row = []
for item in row:
if item == max_v:
new_row.append(bold(max_v))
else:
new_row.append(item)
table.add_row(new_row)
# zapis do pliku
doc = Document("adaboost_NB")
for i, tab, in enumerate(tables):
section = Section(sections[i])
section.append(tab)
doc.append(section)
doc.generate_tex(os.path.join(path, 'wyniki/pliki_tex/'))
doc.generate_pdf(os.path.join(path, 'wyniki/pliki_pdf/'))
def details():
if __name__ == '__main__':
image_filename = os.path.join(os.path.dirname(__file__), 'kitten.jpg')
logo_file = os.path.join(os.path.dirname(__file__),'sample-logo.png')
geometry_options = {"tmargin": "1cm", "lmargin": "3cm"}
doc = Document(geometry_options=geometry_options)
header = PageStyle("header")
with header.create(Head("R")):
header.append(simple_page_number())
with header.create(Foot("C")):
header.append("Center Footer")
first_page = PageStyle("firstpage")
with first_page.create(Head("L")) as header_left:
with header_left.create(MiniPage(width=NoEscape(r"0.49\textwidth"),pos='c')) as logo_wrapper
with doc.create(MiniPage(align='l')):
doc.append(LargeText(bold("INVESTMENT PROPERTY - BUY & HOLD")))
doc.append(LineBreak())
doc.append(MediumText(bold(" ")))
logo_wrapper.append(StandAloneGraphic(image_options="width=120px",
filename=logo_file))
with doc.create(Section('Home Adress')):
doc.append('Some regular text and some')
doc.append(italic('italic text. '))
doc.append('\nAlso some crazy characters: $&#{}')
with doc.create(Subsection('Math that is incorrect')):
doc.append(Math(data=['2*3', '=', 9]))
with doc.create(Subsection('Table of something')):
with doc.create(Tabular('rc|cl')) as table:
table.add_hline()
table.add_row((1, 2, 3, 4))
table.add_hline(1, 2)
table.add_empty_row()
table.add_row((4, 5, 6, 7))
a = np.array([[100, 10, 20]]).T
M = np.matrix([[2, 3, 4],
[0, 0, 1],
[0, 0, 2]])
with doc.create(Section('The fancy stuff')):
with doc.create(Subsection('Correct matrix equations')):
doc.append(Math(data=[Matrix(M), Matrix(a), '=', Matrix(M * a)]))
with doc.create(Subsection('Alignat math environment')):
with doc.create(Alignat(numbering=False, escape=False)) as agn:
agn.append(r'\frac{a}{b} &= 0 \\')
agn.extend([Matrix(M), Matrix(a), '&=', Matrix(M * a)])
with doc.create(Subsection('Beautiful graphs')):
with doc.create(TikZ()):
plot_options = 'height=4cm, width=6cm, grid=major'
with doc.create(Axis(options=plot_options)) as plot:
plot.append(Plot(name='model', func='-x^5 - 242'))
coordinates = [
(-4.77778, 2027.60977),
(-3.55556, 347.84069),
(-2.33333, 22.58953),
(-1.11111, -493.50066),
(0.11111, 46.66082),
(1.33333, -205.56286),
(2.55556, -341.40638),
(3.77778, -1169.24780),
(5.00000, -3269.56775),
]
plot.append(Plot(name='estimate', coordinates=coordinates))
with doc.create(Subsection('Cute kitten pictures')):
with doc.create(Figure(position='h!')) as kitten_pic:
kitten_pic.add_image(image_filename, width='120px')
kitten_pic.add_caption('Look it\'s on its back')
doc.generate_pdf('full', clean_tex=False)
def generate_header():
geometry_options = {"margin": "0.7in"}
doc = Document(geometry_options=geometry_options)
# Add document header
header = PageStyle("header")
# Create left header
with header.create(Head("L")):
header.append("__")
header.append(LineBreak())
header.append("_")
# Create center header
with header.create(Head("C")):
header.append("____")
# Create right header
with header.create(Head("R")):
header.append(simple_page_number())
# Create left footer
with header.create(Foot("L")):
header.append("Left Footer")
# Create center footer
with header.create(Foot("C")):
header.append("Center Footer")
# Create right footer
with header.create(Foot("R")):
header.append("Right Footer")
doc.preamble.append(header)
doc.change_document_style("header")
# Add Heading
with doc.create(MiniPage(align='l')):
doc.append(LargeText(bold("INVESTMENT PROPERTY - BUY & HOLD")))
doc.append(LineBreak())
doc.append(MediumText(bold(" ")))
doc.generate_pdf("header", clean_tex=False)
return print('nice')
def get_document(document_title='Report',
author='Entail AS',
fig_ext=u'.pdf',
header_logofilename='entail.pdf',
logo_image_option_header="width=250px",
workflow_ID=0):
global _fig_ext
_fig_ext = fig_ext
geometry_options = {
"head": "70pt",
"margin": "1.5cm",
"bottom": "1.5cm",
"includeheadfoot": True
}
document_options = ['a4paper']
doc = Document(geometry_options=geometry_options,
document_options=document_options)
# packages
doc.packages.append(Package('booktabs'))
doc.packages.append(Package('chngcntr'))
doc.packages.append(Package('longtable'))
doc.packages.append(Package('titlepic'))
doc.packages.append(Package('float'))
# page style
first_page = PageStyle("firstpage")
# Header image
with first_page.create(Head("L")) as header_left:
with header_left.create(
MiniPage(width=NoEscape(r"0.25\textwidth"),
pos='c')) as logo_wrapper:
logo_file = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
header_logofilename).replace('\\', '/')
logo_wrapper.append(
StandAloneGraphic(image_options="width=80px",
filename=logo_file))
# Add document title
with first_page.create(Head("R")) as right_header:
with right_header.create(
MiniPage(width=NoEscape(r"0.75\textwidth"), pos='c',
align='r')) as title_wrapper:
title_wrapper.append(LargeText(bold(document_title)))
title_wrapper.append(LineBreak())
title_wrapper.append(MediumText(bold(NoEscape(r'\today'))))
# Add footer
with first_page.create(Foot("C")) as center_footer:
center_footer.append(simple_page_number())
with first_page.create(Foot("R")) as right_footer:
with right_footer.create(
MiniPage(width=NoEscape(r"0.15\textwidth"),
pos='r')) as logo_wrapper:
logo_file = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'tailor.png').replace('\\', '/')
logo_wrapper.append(
StandAloneGraphic(image_options="width=50px",
filename=logo_file))
doc.preamble.append(first_page)
doc.change_document_style("firstpage")
doc.preamble.append(Command('title', document_title))
logo_file = os.path.join(os.path.dirname(os.path.abspath(__file__)),
header_logofilename).replace('\\', '/')
doc.preamble.append(
Command(
'titlepic',
StandAloneGraphic(image_options=logo_image_option_header,
filename=logo_file)))
# doc.preamble.append(Command('author', author))
doc.preamble.append(Command('date', NoEscape(r'\today')))
doc.preamble.append(
Command(
'hypersetup',
arguments=
'colorlinks, citecolor=black, filecolor=black, linkcolor=black, urlcolor=black',
packages=[Package('hyperref')]))
doc.preamble.append(NoEscape(r'\counterwithin{figure}{section}'))
doc.append(NoEscape(r'\maketitle'))
# Add disclaimer
doc.append(NewPage())
doc.append(NoEscape(r'\textbf{Disclaimer}'))
doc.append(NoEscape(r'\newline'))
doc.append(NoEscape(r'\vspace{0.2in}'))
temptext = f'This is in automatically generated report. '
if workflow_ID == 0:
temptext += f'The report was generated '
else:
temptext += f'The results are extracted from Workflow ID {workflow_ID} '
temptext += f'on the {datetime.datetime.now().strftime("%m/%d/%Y at %H:%M:%S")}. '
temptext += f'Errors may occur and it is the user’s responsibility to interpret the reported data '
temptext += f'with sound engineering judgement.'
doc.append(temptext)
doc.append(NewPage())
doc.append(Command('tableofcontents'))
doc.append(NewPage())
return doc
def generate_docs(config):
"""
Function used to generate two pdf:
-results.pdf: which shows all statistics about each formula with each
benchmarked method.
-summary.pdf: which count the number of times that each method is
better than another.
"""
# Let's create the documents (result & summary)
doc = Document(documentclass='standalone')
doc.packages.append(Package('amsmath'))
doc.packages.append(Package('color'))
doc.packages.append(Package('colortbl'))
doc2 = Document(documentclass='standalone')
# Declare colors in result document
doc.append(
DefineColor(arguments=Arguments('Gray', 'rgb', '0.7, 0.7, 0.7')))
doc.append(DefineColor(arguments=Arguments('Green', 'rgb', '0.4, 1, 0.4')))
doc.append(DefineColor(arguments=Arguments('Red', 'rgb', '0.8, 0, 0')))
doc.append(DefineColor(arguments=Arguments('Yelw', 'rgb', '1, 0.98, 0.4')))
doc.append(DefineColor(arguments=Arguments('Purpl', 'rgb', '1, 0.6, 1')))
# Create Table with format : True is result format, False is summary format
table = Tabular(add_fmt(len(config.l), True))
table2 = Tabular(add_fmt(len(config.l), False))
# Write everything
write_results(table, config)
write_summary(table2, config)
# Output PDF
doc.append(table)
doc2.append(table2)
doc.generate_pdf('results')
doc2.generate_pdf('summary')
def generate_latex(self):
doc = Document('ImageLatexResult')
doc.content_separator = '\n'
for i in range(len(self.lines)):
if self.lines[i].type == "large":
doc.append("\Huge")
elif self.lines[i].type == "medium":
doc.append("\LARGE")
elif self.lines[i].type == "small":
doc.append("\large")
if self.lines[i].is_centered:
doc.append(NoEscape(r'\centerline'))
elif self.lines[i].is_indented:
doc.append("\t")
doc.append(NoEscape(r'{'))
doc.content_separator = ''
for k in xrange(0, len(self.lines[i].words)):
doc.append(self.lines[i].words[k].word)
doc.content_separator = '\n'
doc.append(NoEscape(r'}'))
doc.append(NoEscape("\n"))
if self.lines[i].is_end_paragraph:
doc.append(NoEscape(r'\n'))
doc.append(NoEscape(r'\n'))
doc.append(NoEscape(r'\n'))
#if self.lines[i].is_bold:
# for k in xrange(0, len(self.lines[i].words)):
# doc.append(bold(self.lines[i].words[k].word))
# doc.append("\n")
return doc.dumps()
def generate_report(tests, program, is_loopback, calib_program, dut_host):
geometry_options = {"right": "2cm", "left": "2cm"}
fname = program.split('/')[-1] + '-tests'
try:
os.remove(fname + '.pdf')
except OSError:
pass
doc = Document(fname, geometry_options=geometry_options)
doc.append('Test results for %s\n' % program)
doc.append('Calibration method: %s\n' % "loopback" if is_loopback else calib_program)
doc.append('DUT host: %s\n' % dut_host)
sorted_tests = sorted(tests, key = lambda test: len(test.expected_path))
for i in range(len(sorted_tests)):
times = sorted(tests[i].packets[0].times)
runs = range(len(times))
plt.figure(figsize=(16,5))
plt.bar(runs, times)
plt.xlim(runs[0], runs[-1] + 1)
plt.xlabel('Run #')
plt.ylabel('Time - calibration (microseconds) ')
plt.title('Test times')
with doc.create(Section('Test %d' % (i+1))):
with doc.create(Subsection('Expected path')):
for point in tests[i].expected_path:
if 'tbl_act' in point:
continue
doc.append(str(point) + '\n')
with doc.create(Subsection('Stats (time - calibration time in microseconds)')):
doc.append('Mean: %f\n' % np.mean(times))
doc.append('Std dev: %f\n' % np.std(times))
doc.append('Median: %f\n' % np.median(times))
with doc.create(Figure(position='htbp')) as plot:
plot.add_plot(width=NoEscape(r'1\textwidth'))
plt.clf()
plt.close()
gc.collect()
doc.generate_pdf(clean_tex=True)
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Test for list structures in PyLaTeX.
# More info @ http://en.wikibooks.org/wiki/LaTeX/List_Structures
from pylatex import Document, Section, Itemize, Enumerate, Description
doc = Document()
# create a bulleted "itemize" list like the below:
# \begin{itemize}
# \item The first item
# \item The second item
# \item The third etc \ldots
# \end{itemize}
with doc.create(Section('"Itemize" list')):
with doc.create(Itemize()) as itemize:
itemize.add_item("the first item")
itemize.add_item("the second item")
itemize.add_item("the third etc")
itemize.append("\\ldots") # you can append to existing items
# create a numbered "enumerate" list like the below:
# \begin{enumerate}
# \item The first item
# \item The second item
# \item The third etc \ldots
# \end{enumerate}
parser = argparse.ArgumentParser()
parser.add_argument("datafile", help="the file used as a data source")
parser.add_argument("-l",
action="store_true",
help="display LaTeX source generated from data")
parser.add_argument("--outdir", default="./", help="output directory")
parser.add_argument("--noinc",
action="store_true",
help="do not increment revision number")
prog_args = parser.parse_args()
with open(prog_args.datafile) as f:
portfolio = yaml.safe_load(f)
doc = Document(documentclass='Resume')
with doc.create(Tabular("l")) as ntab:
ntab.add_row([Command("Huge", Command("textbf", portfolio["name"]))])
ntab.add_row([Command("Large", portfolio["title"])])
doc.append(Command("hfill"))
with doc.create(Tabular("rl")) as ctab:
contact_handles = portfolio["contact"]
for handle in contact_handles:
ctab.add_row([
handle["name"] + ": ",
TexList([
Command("hspace", "5pt"),
Command("href", [handle["url"], handle["handle"]])
])
def generate_header():
geometry_options = {"margin": "0.7in"}
doc = Document(geometry_options=geometry_options)
# Add document header
header = PageStyle("header")
# Create left header
with header.create(Head("L")):
header.append("Page date: ")
header.append(LineBreak())
header.append("R3")
# Create center header
with header.create(Head("C")):
header.append("Company")
# Create right header
with header.create(Head("R")):
header.append(simple_page_number())
# Create left footer
with header.create(Foot("L")):
header.append("Left Footer")
# Create center footer
with header.create(Foot("C")):
header.append("Center Footer")
# Create right footer
with header.create(Foot("R")):
header.append("Right Footer")
doc.preamble.append(header)
doc.change_document_style("header")
# Add Heading
with doc.create(MiniPage(align='c')):
doc.append(LargeText(bold("Title")))
doc.append(LineBreak())
doc.append(MediumText(bold("As at:")))
doc.generate_pdf("header", clean_tex=False)
def _add_keyboard_notes(document: pylatex.Document, texts: dict,
images: dict) -> None:
document.append(
pylatex.Subsection(
title=texts["keyboard"]["title"],
label=False,
numbering=False,
))
document.append(texts["keyboard"]["text0"])
document.append(pylatex.NoEscape(r"\vspace{5mm}"))
table = pylatex.Tabular(r" l | l | p{9cm} ")
# table.add_hline()
table.add_row(*tuple(
pylatex.MediumText(column_title) for column_title in (
"Bereich",
"Beschreibung der Klänge",
"verwendete Lautsprecher",
)))
for zone_idx in range(3):
table.add_hline()
table.add_row(
_make_img(images["zone_{}".format(zone_idx)],
width=0.22,
add_figure=False),
texts["keyboard"]["zone{}sound".format(zone_idx)],
texts["keyboard"]["zone{}speaker".format(zone_idx)],
)
# table.add_hline()
document.append(pylatex.Table(data=table, position="h!"))
document.append(texts["keyboard"]["text1"])
# document.append(pylatex.NoEscape(r"\vspace{3mm}"))
document.append(texts["keyboard"]["text2"])
def generate_unique():
geometry_options = {
"head": "40pt",
"margin": "0.5in",
"bottom": "0.6in",
"includeheadfoot": True
}
doc = Document(geometry_options=geometry_options)
# Generating first page style
first_page = PageStyle("firstpage")
# Header image
with first_page.create(Head("L")) as header_left:
with header_left.create(
MiniPage(width=NoEscape(r"0.49\textwidth"),
pos='c')) as logo_wrapper:
logo_file = os.path.join(os.path.dirname(__file__),
'sample-logo.jpg')
logo_wrapper.append(
StandAloneGraphic(image_options="width=120px",
filename=logo_file))
# Add document title
with first_page.create(Head("R")) as right_header:
with right_header.create(
MiniPage(width=NoEscape(r"0.49\textwidth"), pos='c',
align='r')) as title_wrapper:
title_wrapper.append(LargeText(bold("Bank Account Statement")))
title_wrapper.append(LineBreak())
title_wrapper.append(MediumText(bold("Date")))
# Add footer
with first_page.create(Foot("C")) as footer:
message = "Important message please read"
with footer.create(
Tabularx(
"X X X X",
width_argument=NoEscape(r"\textwidth"))) as footer_table:
footer_table.add_row(
[MultiColumn(4, align='l', data=TextColor("blue", message))])
footer_table.add_hline(color="blue")
footer_table.add_empty_row()
branch_address = MiniPage(width=NoEscape(r"0.25\textwidth"),
pos='t')
branch_address.append("960 - 22nd street east")
branch_address.append("\n")
branch_address.append("Saskatoon, SK")
document_details = MiniPage(width=NoEscape(r"0.25\textwidth"),
pos='t',
align='r')
document_details.append("1000")
document_details.append(LineBreak())
document_details.append(simple_page_number())
footer_table.add_row([
branch_address, branch_address, branch_address,
document_details
])
doc.preamble.append(first_page)
# End first page style
# Add customer information
with doc.create(Tabu("X[l] X[r]")) as first_page_table:
customer = MiniPage(width=NoEscape(r"0.49\textwidth"), pos='h')
customer.append("Verna Volcano")
customer.append("\n")
customer.append("For some Person")
customer.append("\n")
customer.append("Address1")
customer.append("\n")
customer.append("Address2")
customer.append("\n")
customer.append("Address3")
# Add branch information
branch = MiniPage(width=NoEscape(r"0.49\textwidth"),
pos='t!',
align='r')
branch.append("Branch no.")
branch.append(LineBreak())
branch.append(bold("1181..."))
branch.append(LineBreak())
branch.append(bold("TIB Cheque"))
first_page_table.add_row([customer, branch])
first_page_table.add_empty_row()
doc.change_document_style("firstpage")
doc.add_color(name="lightgray", model="gray", description="0.80")
# Add statement table
with doc.create(LongTabu("X[l] X[2l] X[r] X[r] X[r]",
row_height=1.5)) as data_table:
data_table.add_row(
["date", "description", "debits($)", "credits($)", "balance($)"],
mapper=bold,
color="lightgray")
data_table.add_empty_row()
data_table.add_hline()
row = ["2016-JUN-01", "Test", "$100", "$1000", "-$900"]
for i in range(30):
if (i % 2) == 0:
data_table.add_row(row, color="lightgray")
else:
data_table.add_row(row)
doc.append(NewPage())
# Add cheque images
with doc.create(LongTabu("X[c] X[c]")) as cheque_table:
cheque_file = os.path.join(os.path.dirname(__file__), 'programmer.jpg')
cheque = StandAloneGraphic(cheque_file, image_options="width=200px")
for i in range(0, 20):
cheque_table.add_row([cheque, cheque])
doc.generate_pdf("complex_report", clean_tex=False)
import os
import sys
from read_results import read_results, chunks
from pylatex import Document, LongTable, NoEscape, Command, MultiColumn, Section, Subsection
from pylatex.base_classes.command import Options
geometry_options = {"margin": "0.5cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
doc.preamble.append(NoEscape(r'\usepackage[czech]{babel}'))
doc.preamble.append(NoEscape(r'\usepackage{threeparttablex}'))
doc.preamble.append(NoEscape(r'\usepackage{pdfpages}'))
doc.preamble.append(NoEscape(r'\definecolor{Hex}{RGB}{239,239,239}'))
doc.documentclass.options = Options('10pt')
def d_generator(data_dir, vystup_dir):
os.chdir(data_dir)
data_PU = read_results('results.csv')
info_PU = read_results('raw_data_info.csv')
# Arrange data to desired shape
data_check = []
data_used = []
data_replace_p = []
data_check_p = []
data_replace_a = []
l_names = []
p_stale = []
for i in range(0, len(data_PU)):
data_used.append(data_PU[i][0])
def fill_document(doc):
"""Add a section, a subsection and some text to the document.
:param doc: the document
:type doc: :class:`pylatex.document.Document` instance
"""
with doc.create(Section('A section')):
doc.append('Some regular text and some ')
doc.append(italic('italic text. '))
with doc.create(Subsection('A subsection')):
doc.append('Also some crazy characters: $&#{}')
if __name__ == '__main__':
# Basic document
doc = Document('basic')
fill_document(doc)
doc.generate_pdf(clean_tex=False)
doc.generate_tex()
# Document with `\maketitle` command activated
doc = Document()
doc.preamble.append(Command('title', 'Awesome Title'))
doc.preamble.append(Command('author', 'Anonymous author'))
doc.preamble.append(Command('date', NoEscape(r'\today')))
doc.append(NoEscape(r'\maketitle'))
fill_document(doc)
class ExampleCommand(CommandBase):
"""
A class representing a custom LaTeX command.
This class represents a custom LaTeX command named
``exampleCommand``.
"""
_latex_name = 'exampleCommand'
packages = [Package('color')]
# Create a new document
doc = Document()
with doc.create(Section('Custom commands')):
doc.append(
NoEscape(r"""
The following is a demonstration of a custom \LaTeX{}
command with a couple of parameters.
"""))
# Define the new command
new_comm = UnsafeCommand('newcommand',
'\exampleCommand',
options=3,
extra_arguments=r'\color{#1} #2 #3 \color{black}')
doc.append(new_comm)
# Use our newly created command with different arguments
def save_latex(self,
uiObj,
Design_Check,
reportsummary,
filename,
rel_path,
Disp_2d_image,
Disp_3d_image,
module=''):
companyname = str(reportsummary["ProfileSummary"]['CompanyName'])
companylogo = str(reportsummary["ProfileSummary"]['CompanyLogo'])
groupteamname = str(reportsummary["ProfileSummary"]['Group/TeamName'])
designer = str(reportsummary["ProfileSummary"]['Designer'])
projecttitle = str(reportsummary['ProjectTitle'])
subtitle = str(reportsummary['Subtitle'])
jobnumber = str(reportsummary['JobNumber'])
client = str(reportsummary['Client'])
does_design_exist = reportsummary['does_design_exist']
osdagheader = '/ResourceFiles/images/Osdag_header_report.png'
# Add document header
geometry_options = {
"top": "5cm",
"hmargin": "2cm",
"headheight": "100pt",
"footskip": "100pt",
"bottom": "5cm"
}
doc = Document(geometry_options=geometry_options, indent=False)
doc.packages.append(Package('amsmath'))
doc.packages.append(Package('graphicx'))
doc.packages.append(Package('needspace'))
doc.append(pyl.Command('fontsize', arguments=[8, 12]))
doc.append(pyl.Command('selectfont'))
doc.add_color('OsdagGreen', 'RGB', '153,169,36')
doc.add_color('PassColor', 'RGB', '153,169,36')
doc.add_color('Red', 'RGB', '255,0,0')
doc.add_color('Green', 'RGB', '0,200,0')
doc.add_color('FailColor', 'HTML', '933A16')
header = PageStyle("header")
# Create center header
with header.create(Head("C")):
with header.create(Tabularx('|l|p{4cm}|l|X|')) as table:
table.add_hline()
# MultiColumn(4)
table.add_row((
MultiColumn(
2,
align='|c|',
data=('' if companylogo is '' else StandAloneGraphic(
image_options="height=0.95cm",
filename=companylogo))),
MultiColumn(2,
align='|c|',
data=[
'Created with',
StandAloneGraphic(
image_options="width=4.0cm,height=1cm",
filename=rel_path + osdagheader)
]),
))
table.add_hline()
table.add_row(('Company Name', companyname, 'Project Title',
projecttitle),
color='OsdagGreen')
table.add_hline()
table.add_row(
('Group/Team Name', groupteamname, 'Subtitle', subtitle),
color='OsdagGreen')
table.add_hline()
table.add_row(('Designer', designer, 'Job Number', jobnumber),
color='OsdagGreen')
table.add_hline()
table.add_row(
('Date', time.strftime("%d /%m /%Y"), 'Client', client),
color='OsdagGreen')
table.add_hline()
# Create right footer
with header.create(Foot("R")):
header.append(NoEscape(r'Page \thepage'))
#
# doc.preamble.append(header)
# doc.change_document_style("header")
# Add Heading
# with doc.create(MiniPage(align='c')):
doc.preamble.append(header)
doc.change_document_style("header")
with doc.create(Section('Input Parameters')):
with doc.create(
LongTable('|p{5cm}|p{2.5cm}|p{1.5cm}|p{3cm}|p{3.5cm}|',
row_height=1.2)) as table:
table.add_hline()
for i in uiObj:
# row_cells = ('9', MultiColumn(3, align='|c|', data='Multicolumn not on left'))
if i == "Selected Section Details" or i == KEY_DISP_ANGLE_LIST or i == KEY_DISP_TOPANGLE_LIST or i == KEY_DISP_CLEAT_ANGLE_LIST:
# if type(uiObj[i]) == list:
continue
if type(uiObj[i]) == dict:
table.add_hline()
sectiondetails = uiObj[i]
image_name = sectiondetails[KEY_DISP_SEC_PROFILE]
Img_path = '/ResourceFiles/images/' + image_name + '.png'
if (len(sectiondetails)) % 2 == 0:
# merge_rows = int(round_up(len(sectiondetails),2)/2 + 2)
merge_rows = int((len(sectiondetails) / 2)) + 2
else:
merge_rows = round_up((len(sectiondetails) / 2), 2)
if (len(sectiondetails)) % 2 == 0:
sectiondetails[''] = ''
a = list(sectiondetails.keys())
# index=0
for x in range(1, (merge_rows + 1)):
# table.add_row("Col.Det.",i,columndetails[i])
if x == 1:
table.add_row((
MultiRow(
merge_rows,
data=StandAloneGraphic(
image_options=
"width=5cm,height=5cm",
filename=rel_path + Img_path)),
MultiColumn(2, align='|c|', data=a[x]),
MultiColumn(2,
align='|c|',
data=sectiondetails[a[x]]),
))
elif x <= 4:
table.add_row((
'',
MultiColumn(2,
align='|c|',
data=NoEscape(a[x])),
MultiColumn(2,
align='|c|',
data=NoEscape(
sectiondetails[a[x]])),
))
else:
table.add_row((
'',
NoEscape(a[x]),
sectiondetails[a[x]],
NoEscape(a[merge_rows + x - 4]),
sectiondetails[a[merge_rows + x - 4]],
))
table.add_hline(2, 5)
elif uiObj[i] == "TITLE":
table.add_hline()
table.add_row((MultiColumn(
5,
align='|c|',
data=bold(i),
), ))
table.add_hline()
elif i == 'Section Size*':
table.add_hline()
table.add_row((
MultiColumn(
3,
align='|c|',
data=i,
),
MultiColumn(2,
align='|c|',
data="Ref List of Input Section"),
))
table.add_hline()
elif len(str(uiObj[i])) > 55 and type(
uiObj[i]) != pyl.math.Math:
str_len = len(str(uiObj[i]))
loop_len = round_up((str_len / 55), 1, 1)
for j in range(1, loop_len + 1):
b = 55 * j + 1
if j == 1:
table.add_row((
MultiColumn(3,
align='|c|',
data=MultiRow(loop_len,
data=i)),
MultiColumn(2,
align='|c|',
data=uiObj[i][0:b]),
))
else:
table.add_row((
MultiColumn(3,
align='|c|',
data=MultiRow(loop_len,
data="")),
MultiColumn(2,
align='|c|',
data=uiObj[i][b - 55:b]),
))
table.add_hline()
else:
table.add_hline()
table.add_row((
MultiColumn(3, align='|c|', data=NoEscape(i)),
MultiColumn(2, align='|c|', data=uiObj[i]),
))
table.add_hline()
for i in uiObj:
if i == 'Section Size*' or i == KEY_DISP_ANGLE_LIST or i == KEY_DISP_TOPANGLE_LIST or i == KEY_DISP_CLEAT_ANGLE_LIST:
with doc.create(Subsection("List of Input Section")):
# with doc.create(LongTable('|p{8cm}|p{8cm}|', row_height=1.2)) as table:
with doc.create(Tabularx('|p{4cm}|X|',
row_height=1.2)) as table:
table.add_hline()
table.add_row((
MultiColumn(
1,
align='|c|',
data=i,
),
MultiColumn(1,
align='|X|',
data=uiObj[i].strip("[]")),
))
# str_len = len(uiObj[i])
# loop_len = round_up((str_len/100),1,1)
# table.add_hline()
# for j in range(1,loop_len+1):
# b= 100*j+1
# if j ==1:
# table.add_row((MultiColumn(1, align='|c|', data=i, ),
# MultiColumn(1, align='|X|', data=uiObj[i][0:b]),))
# else:
# table.add_row((MultiColumn(1, align='|c|', data=" ", ),
# MultiColumn(1, align='|X|', data=uiObj[i][b-100:b]),))
table.add_hline()
doc.append(
pyl.Command('Needspace', arguments=NoEscape(r'10\baselineskip')))
doc.append(NewPage())
count = 0
with doc.create(Section('Design Checks')):
with doc.create(
Tabularx(
r'|>{\centering}p{12.5cm}|>{\centering\arraybackslash}X|',
row_height=1.2)) as table:
table.add_hline()
# Fail = TextColor("FailColor", bold("Fail"))
# Pass = TextColor("PassColor", bold("Pass"))
if does_design_exist != True:
table.add_row(bold('Design Status'),
color_cell("Red", bold("Fail")))
else:
table.add_row(bold('Design Status'),
color_cell("OsdagGreen", bold("Pass")))
table.add_hline()
for check in Design_Check:
if check[0] == 'SubSection':
if count >= 1:
# doc.append(NewPage())
doc.append(
pyl.Command(
'Needspace',
arguments=NoEscape(r'10\baselineskip')))
with doc.create(Subsection(check[1])):
#########################
# if uiObj== "WELDImage":
# table.add_hline()
# table.add_row((MultiColumn(5, align='|c|', data=bold(i), ),))
# table.add_hline()
# else:
#########################
with doc.create(LongTable(check[2], row_height=1.2)
) as table: # todo anjali remove
table.add_hline()
table.add_row(
('Check', 'Required', 'Provided', 'Remarks'),
color='OsdagGreen')
table.add_hline()
table.end_table_header()
table.add_hline()
count = count + 1
elif check[0] == "Selected":
if count >= 1:
# doc.append(NewPage())
doc.append(
pyl.Command(
'Needspace',
arguments=NoEscape(r'10\baselineskip')))
with doc.create(Subsection(check[1])):
with doc.create(LongTable(check[2],
row_height=1.2)) as table:
table.add_hline()
for i in uiObj:
# row_cells = ('9', MultiColumn(3, align='|c|', data='Multicolumn not on left'))
print(i)
if type(
uiObj[i]
) == dict and i == 'Selected Section Details':
table.add_hline()
sectiondetails = uiObj[i]
image_name = sectiondetails[
KEY_DISP_SEC_PROFILE]
Img_path = '/ResourceFiles/images/' + image_name + '.png'
if (len(sectiondetails)) % 2 == 0:
# merge_rows = int(round_up(len(sectiondetails),2)/2 + 2)
merge_rows = int(
round_up((len(sectiondetails) /
2), 1, 0) + 2)
else:
merge_rows = int(
round_up((len(sectiondetails) /
2), 1, 0) + 1)
print('Hi',
len(sectiondetails) / 2,
round_up(len(sectiondetails), 2) / 2,
merge_rows)
if (len(sectiondetails)) % 2 == 0:
sectiondetails[''] = ''
a = list(sectiondetails.keys())
# index=0
for x in range(1, (merge_rows + 1)):
# table.add_row("Col.Det.",i,columndetails[i])
if x == 1:
table.add_row((
MultiRow(
merge_rows,
data=StandAloneGraphic(
image_options=
"width=5cm,height=5cm",
filename=rel_path +
Img_path)),
MultiColumn(2,
align='|c|',
data=NoEscape(
a[x])),
MultiColumn(
2,
align='|c|',
data=NoEscape(
sectiondetails[a[x]])),
))
elif x <= 4:
table.add_row((
'',
MultiColumn(2,
align='|c|',
data=NoEscape(
a[x])),
MultiColumn(
2,
align='|c|',
data=sectiondetails[a[x]]),
))
else:
table.add_row((
'',
NoEscape(a[x]),
sectiondetails[a[x]],
NoEscape(a[merge_rows + x -
4]),
sectiondetails[a[merge_rows +
x - 4]],
))
table.add_hline(2, 5)
table.add_hline()
count = count + 1
else:
if check[3] == 'Fail':
table.add_row((NoEscape(check[0])), check[1], check[2],
TextColor("Red", bold(check[3])))
else:
table.add_row((NoEscape(check[0])), check[1], check[2],
TextColor("OsdagGreen", bold(check[3])))
table.add_hline()
# 2D images
if len(Disp_2d_image) != 0:
if module == KEY_DISP_BCENDPLATE or module == KEY_DISP_BB_EP_SPLICE:
if does_design_exist and sys.platform != 'darwin':
doc.append(NewPage())
weld_details = rel_path + Disp_2d_image[0]
detailing_details = rel_path + Disp_2d_image[1]
stiffener_details = rel_path + Disp_2d_image[2]
with doc.create(Section('2D Drawings (Typical)')):
with doc.create(Figure()) as image:
image.add_image(weld_details,
width=NoEscape(r'0.7\textwidth'),
placement=NoEscape(r'\centering'))
image.add_caption(
'Typical Weld Details -- Beam to End Plate Connection'
)
# doc.append(NewPage())
with doc.create(Figure()) as image_2:
image_2.add_image(
detailing_details,
width=NoEscape(r'0.7\textwidth'),
placement=NoEscape(r'\centering'))
image_2.add_caption('Typical Detailing')
# doc.append(NewPage())
with doc.create(Figure()) as image_3:
image_3.add_image(
stiffener_details,
width=NoEscape(r'0.9\textwidth'),
placement=NoEscape(r'\centering'))
image_3.add_caption('Typical Stiffener Details')
# doc.append(NewPage())
elif module == KEY_DISP_BASE_PLATE:
if does_design_exist and sys.platform != 'darwin':
doc.append(NewPage())
bp_sketch = rel_path + Disp_2d_image[0]
bp_detailing = rel_path + Disp_2d_image[1]
bp_weld = rel_path + Disp_2d_image[2]
bp_anchor = rel_path + Disp_2d_image[3]
bp_key = rel_path + Disp_2d_image[4]
with doc.create(Section('2D Drawings (Typical)')):
with doc.create(Figure()) as image_1:
image_1.add_image(
bp_sketch,
width=NoEscape(r'1.0\textwidth'),
placement=NoEscape(r'\centering'))
image_1.add_caption('Typical Base Plate Details')
# doc.append(NewPage())
with doc.create(Figure()) as image_2:
image_2.add_image(
bp_detailing,
width=NoEscape(r'1.0\textwidth'),
placement=NoEscape(r'\centering'))
image_2.add_caption('Typical Base Plate Detailing')
# doc.append(NewPage())
with doc.create(Figure()) as image_3:
image_3.add_image(
bp_weld,
width=NoEscape(r'1.0\textwidth'),
placement=NoEscape(r'\centering'))
image_3.add_caption('Typical Weld Details')
# doc.append(NewPage())
with doc.create(Figure()) as image_4:
image_4.add_image(
bp_anchor,
width=NoEscape(r'0.5\textwidth'),
placement=NoEscape(r'\centering'))
image_4.add_caption('Typical Anchor Bolt Details')
# doc.append(NewPage())
if len(Disp_2d_image[-1]) > 0:
with doc.create(Figure()) as image_5:
image_5.add_image(
bp_key,
width=NoEscape(r'0.9\textwidth'),
placement=NoEscape(r'\centering'))
image_5.add_caption(
'Typical Shear Key Details')
# doc.append(NewPage())
if does_design_exist and sys.platform != 'darwin':
doc.append(NewPage())
Disp_top_image = "/ResourceFiles/images/top.png"
Disp_side_image = "/ResourceFiles/images/side.png"
Disp_front_image = "/ResourceFiles/images/front.png"
view_3dimg_path = rel_path + Disp_3d_image
view_topimg_path = rel_path + Disp_top_image
view_sideimg_path = rel_path + Disp_side_image
view_frontimg_path = rel_path + Disp_front_image
with doc.create(Section('3D Views')):
with doc.create(
Tabularx(
r'|>{\centering}X|>{\centering\arraybackslash}X|',
row_height=1.2)) as table:
view_3dimg_path = rel_path + Disp_3d_image
view_topimg_path = rel_path + Disp_top_image
view_sideimg_path = rel_path + Disp_side_image
view_frontimg_path = rel_path + Disp_front_image
table.add_hline()
table.add_row([
StandAloneGraphic(image_options="height=4cm",
filename=view_3dimg_path),
StandAloneGraphic(image_options="height=4cm",
filename=view_topimg_path)
])
table.add_row('(a) 3D View', '(b) Top View')
table.add_hline()
table.add_row([
StandAloneGraphic(image_options="height=4cm",
filename=view_sideimg_path),
StandAloneGraphic(image_options="height=4cm",
filename=view_frontimg_path)
])
table.add_row('(c) Side View', '(d) Front View')
table.add_hline()
# with doc.create(Figure(position='h!')) as view_3D:
# view_3dimg_path = rel_path + Disp_3d_image
# # view_3D.add_image(filename=view_3dimg_path, width=NoEscape(r'\linewidth'))
#
# view_3D.add_image(filename=view_3dimg_path,width=NoEscape(r'\linewidth,height=6.5cm'))
#
# view_3D.add_caption('3D View')
with doc.create(Section('Design Log')):
doc.append(
pyl.Command('Needspace',
arguments=NoEscape(r'10\baselineskip')))
logger_msgs = reportsummary['logger_messages'].split('\n')
for msg in logger_msgs:
if ('WARNING' in msg):
colour = 'blue'
elif ('INFO' in msg):
colour = 'OsdagGreen'
elif ('ERROR' in msg):
colour = 'red'
else:
continue
doc.append(TextColor(colour, '\n' + msg))
try:
doc.generate_pdf(filename, compiler='pdflatex', clean_tex=False)
except:
pass
def make_pdf(self, jobid, filename, dirname):
"""
Makes a PDF for a given job id. It retrieves data from Prometheus HTTP API and calls make_plot() as well as make_pie() in order to make the graphs
and display resource usage to users.
Parameters
----------
jobid : integer,
Slurm job's ID
filename : string
File name to save the figure
dirname : string
directory name to save the file
"""
geometry_options = {"right": "2cm", "left": "2cm"}
fname = CWD + "pdf/" + str(jobid) + "_summary"
doc = Document(fname, geometry_options=geometry_options)
metrics = ("jobs_cpu_percent", "jobs_rss", "jobs_read_mb",
"jobs_write_mb")
doc.preamble.append(
Command("title", "Plots for job " + str(self.__jobid)))
doc.preamble.append(Command("date", NoEscape(r"\today")))
doc.append(NoEscape(r"\maketitle"))
doc.append(
"This pdf contains plots/pie charts which are representative of your job's usage of HPC resources on CC clusters"
)
doc.append(NewPage())
for item in metrics:
self.make_plot(item, filename, dirname, True)
with doc.create(Section("Plot for " + Y_LABELS[item])):
with doc.create(Figure(position="htbp")) as plot:
plot.add_plot(width=NoEscape(r"1\textwidth"))
plot.add_caption(Y_LABELS[item] + " variation with time")
if item == "jobs_cpu_percent":
doc.append(
"The dashed line on this plot shows the lowest acceptable bound for CPU usage for a job with as many cores as yours"
)
doc.append(NewPage())
plt.close()
metrics = ("jobs_user_time", "jobs_system_time")
title = [Y_LABELS[metric] for metric in metrics]
self.make_pie(metrics, filename, dirname, True)
with doc.create(Section("Pie chart for " + " vs ".join(title))):
with doc.create(Figure(position="htbp")) as plot:
plot.add_plot(width=NoEscape(r"1\textwidth"))
plot.add_caption(", ".join(title) + " proportions")
doc.append(NewPage())
plt.close()
metrics = ("jobs_cpu_time_core", )
self.make_pie(metrics, filename, dirname, True)
with doc.create(
Section("Pie chart for " + Y_LABELS[metrics[0]] +
" per core")):
with doc.create(Figure(position="htbp")) as plot:
plot.add_plot(width=NoEscape(r"1\textwidth"))
plot.add_caption(Y_LABELS[metrics[0]] + " proportions")
doc.append(NewPage())
plt.close()
doc.generate_pdf(clean_tex=False)
class ReportGenerator():
'''
- a class to generate the report (pdf only).
- uses the methods from visualization class to draw graphs.
- takes as input: path, options user selected, final model
'''
def __init__(self, X_train, y_train, target_names, path, experiments,
maximize, num_of_iter, regression, elapsed_time,
final_model_time):
# assume model is an object contains function to predict #
self.doc = Document(path)
self.experiments = experiments
# sort experiements on score
self.experiments = self.experiments.sort_values('Score Mean',
ascending=not maximize)
print '----------- Experiments -------------\n'
print[p for p in self.experiments['Learner']]
self.num_of_iter = num_of_iter
self.num_of_features = X_train.shape[1]
self.regression = regression
self.elapsed_time = elapsed_time
self.final_model_time = final_model_time
self.X_train = X_train
self.y_train = y_train
self.target_names = target_names
self.path = path
self.probabilities = np.load(
self.experiments['Path'].iloc[0])['PREDICTIONS']
if not regression:
self.predictions = np.argmax(self.probabilities, axis=1)
# function checks if the given model is ensemble #
def is_ensemble(self, s):
return (s[:2] == "es")
# function prints single model's parameters #
def print_param(self, row):
self.doc.append(self.format_dict(row[3]) + '\n')
# functions extracts the actual model name to be shown #
# in the doc from the encodded one #
def get_model_name(self, s):
ns = ''
if self.is_ensemble(s):
ns = re.sub("es", "Ensemble Selection", s)
ns = re.sub('[_]', ' ', ns)
else:
for c in s:
if c == c.upper():
ns += ' '
ns += c
return ns
#edit function print ensemble
def print_ensemble(self, row):
d = row[3] # dictionary of dictionaries(of ensembles)
cnt = 1
with self.doc.create(
Subsubsection('Ensemble Selection', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt')) # indentation
self.doc.append('Score: ' + str(row[1]) + '\n\n')
for sub_d in d:
self.doc.append('Bag: ' + str(cnt) + '\n\n')
cnt += 1
# for every ensemble print it
table = Tabular('|c|c|c|l|')
table.add_hline()
# add header of table #
table.add_row(('Learner', 'Score', 'Parameters', 'weight'))
table.add_hline()
for k in sub_d:
cur_model = self.experiments.loc[k]
data = [
cur_model[0],
round(cur_model[1], 4),
self.format_dict(cur_model[3]), sub_d[k]
]
table.add_row(data)
table.add_hline()
self.doc.append(table)
self.doc.append('\n\n\n\n')
# function prints the layer zero models of the given ensemble model
def print_ensemble_models(self, row):
# - create a sub_sub_section to easily indent #
# - subsubsection title is the ensmble name #
# - table of the ensemble models (layer 0) #
ensemble_method = row[0] # name of the ensmble method
with self.doc.create(
Subsubsection(self.get_model_name(ensemble_method),
numbering=False)):
# create table for the ensmeble models #
self.doc.append(NoEscape(r'\leftskip=40pt')) # indentation
self.doc.append('Score: ' + str(row[1]) + '\n\n')
table = Tabular('|c|c|c|l|')
table.add_hline()
# add header of table #
table.add_row(('Learner', 'Score', 'Parameters', 'weight'))
table.add_hline()
# foreach model in the ensemble add row in the table #
for k in row[3]:
cur_model = self.experiments.loc[k]
data = [
cur_model[0], cur_model[1],
self.format_dict(cur_model[3]), row[3][k]
]
table.add_row(data)
table.add_hline()
self.doc.append(table)
# function converts dictionary of parameters into a string #
def format_dict(self, d):
if type(d) == type(''):
d = eval(d)
s = ""
f = False
for k in d:
if f:
s += ", "
f = True
s += (str(k) + ":" + str(d[k]))
return s
def gen_summary(self, score):
'''
- function generates the first part of the doc the summary of the final model
- inputs are booleans to decide whether to show then in the report or not.
'''
with self.doc.create(Section('Summary', numbering=False)):
# -------- Final Model Description --------#
'''
final model:- single: learner name, parameters
- ensemble: type, models(parameters, scores)
'''
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsection('Final Model Description', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
# check if ensemble or single model from its name #
#edit
#if self.is_ensemble(self.experiments.iloc[0][0]):
# self.print_ensemble_models(self.experiments.iloc[0])
if self.experiments.iloc[0][0] == "ensembleSelection":
self.print_ensemble(self.experiments.iloc[0])
else:
model_name = self.get_model_name(
self.experiments.iloc[0][0])
self.doc.append(model_name + ": ")
self.print_param(self.experiments.iloc[0])
# ----------- Number OF iterations -----------#
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsection('Number of iterations', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
self.doc.append(str(self.num_of_iter))
# ----------- Number Of Features -------------#
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsection('Number of features', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
self.doc.append(str(self.num_of_features))
# ---------- Classification / Regression ------#
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(Subsection('Task type', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
if self.regression:
self.doc.append('Regression')
else:
self.doc.append('Classification')
'''
# ----------- Elapsed Time ------------------#
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(Subsection('Elapsed Time', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
self.doc.append(self.elapsed_time)
# --------------- final model time -------- #
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(Subsection('Final Model Time', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
self.doc.append(self.final_model_time)
'''
# function generates a table of the best models #
def draw_top_models(self, n):
'''
- functions draw a table of the top models, with theri details: name, score, parameters.
- takes the data frame of the models as input.
- print the best ensemble models, then the best single models in a table
'''
self.doc.append(NoEscape(r'\leftskip=0pt'))
with self.doc.create(
Section('Top' + ' ' + str(n) + ' ' + 'Models',
numbering=False)):
self.doc.append(NoEscape(r'\leftskip=20pt'))
single_models_table = Tabular("|c|c|c|")
single_models_table.add_hline()
single_models_table.add_row(["learner", "Score", "Parameters"])
single_models_table.add_hline()
# if ensemble print it, else append to the table
k = 0
single = 0
ens = 0
for model in self.experiments.values:
if k >= n:
break
print 'Model---\n', model[0]
#edit
if model[0] != "ensembleSelection":
#self.doc.append(NoEscape(r'\leftskip=20pt'))
#self.print_ensemble(model)
#else:
data = [model[0], model[1], self.format_dict(model[3])]
single_models_table.add_row(data)
single_models_table.add_hline()
single += 1
k += 1
if single > 0:
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsubsection('Single Models', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
self.doc.append(single_models_table)
# function generates the graphs according to user preferences #
# uses visualization class #
def gen_graphs(self, visu):
'''
function calls the graphs methods to draw from the visualization
module according to use preferences
takes as input a visualizer object
'''
# start Graphs Section in the report #
self.doc.append(NoEscape(r'\leftskip=0pt'))
with self.doc.create(Section('Graphs', numbering=False)):
# uncomment after generating predictions
if not self.regression:
# Confusion Matrix #
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsection('Confusion Matrix', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
with self.doc.create(
Figure(position='htbp')
) as conf_mat_plot: # Create new Figure in tex
# get image path from the visualizer
file_name = visu.gen_conf_mat(
target_names=self.target_names,
predictions=self.predictions,
y=self.y_train,
dpi=300)
conf_mat_plot.add_image(file_name,
width=NoEscape(r'1\textwidth'))
self.doc.append(NoEscape(r'\pagebreak')) #start new page
# ROC Curve #
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(Subsection('ROC Curve', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
with self.doc.create(
Figure(position='htbp'
)) as ROC_plot: # Create new Figure in tex
# y_tr = self.y_train
y_ts = self.y_train
file_name = visu.gen_roc_curve(
probabilities=self.probabilities,
y=y_ts,
target_names=self.target_names)
ROC_plot.add_image(file_name,
width=NoEscape(r'1.2\textwidth'))
self.doc.append(NoEscape(r'\pagebreak')) #start new page
# Feature importance #
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsection('Feature Importance', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
with self.doc.create(Figure(position='htbp')) as imp_plot:
file_name = visu.gen_feature_imp(
regression=self.regression,
X=self.X_train,
y=self.y_train)
imp_plot.add_image(file_name,
width=NoEscape(r'1.2\textwidth'))
self.doc.append(NoEscape(r'\pagebreak')) #start new page
if self.experiments.iloc[0][0] == 'ensembleSelection':
# Word Cloud #
self.doc.append(NoEscape(r'\leftskip=20pt'))
with self.doc.create(
Subsection('Models Cloud', numbering=False)):
self.doc.append(NoEscape(r'\leftskip=40pt'))
with self.doc.create(
Figure(position='htbp')) as cloud_plot:
file_name = visu.gen_word_cloud(self.experiments)
cloud_plot.add_image(file_name,
width=NoEscape(r'1.2\textwidth'))
# main function to be called to generate the report #
def generate(self):
'''
main function that generate the report and call the
functions of the report sections
'''
self.doc.packages.append(
Package('geometry', options=['tmargin=1cm', 'lmargin=0.5cm']))
# cover page #
self.doc.preamble.append(Command(
'title',
'Experiemts Report',
))
self.doc.preamble.append(Command('author', 'ATOM'))
self.doc.append(NoEscape(r'\maketitle'))
self.doc.append(NoEscape(r'\pagebreak'))
# summary #
self.gen_summary(self.experiments.iloc[0][1])
self.doc.append(NoEscape(r'\pagebreak')) #start new page
# Top N Models #
self.draw_top_models(4)
self.doc.append(NoEscape(r'\pagebreak')) #start new page
# Graphs #
visu = visualizer(save_dir=self.path)
self.gen_graphs(visu)
# generate pdf file #
self.doc.generate_pdf('example')
print 'Finished Report Generation'
def __init__(self, tex_filename):
self.doc = Document(tex_filename)
self.problems = []
class Filewriter:
unsupported_commands = {
r'\tfrac': r'\frac',
'•': r'$\cdot$',
r'$$': r'$\$'
}
@classmethod
def prep_file(cls, filename: str, header: str = ''):
with open(filename, 'w') as output:
output.write(header)
@classmethod
def write_file(cls, filename: str, content: str, mode: str = 'w'):
with open(filename, mode) as output:
output.write(content)
@classmethod
def write_pdf_from_tex(cls, tex_filename: str, pdf_filename: str = None):
assert tex_filename.endswith(
'.tex'), '"{}" is not a valid .tex file name'.format(tex_filename)
if pdf_filename is None:
pdf_filename = tex_filename[:-4]
if pdf_filename[0] == '/':
pdf_filename = pdf_filename[1:]
if pdf_filename.endswith('.pdf'):
pdf_filename = pdf_filename[:-4]
pdfl = PDFLaTeX.from_texfile(tex_filename)
pdfl.set_jobname(pdf_filename)
pdfl.create_pdf(keep_pdf_file=True)
def __init__(self, tex_filename):
self.doc = Document(tex_filename)
self.problems = []
def add_problem_to_section(self, problem: str):
for unsupported, supported in Filewriter.unsupported_commands.items():
problem = problem.replace(unsupported, supported)
self.problems.append(problem)
def initialize_doc(self, title: str, author: str, with_date: bool = True):
self.doc.packages.append(Package('amsmath')) # To enable align
self.doc.packages.append(Package('hyperref')) # To enable hyperlink
self.doc.preamble.append(Command('title', title))
self.doc.preamble.append(Command('author', author))
if with_date:
self.doc.preamble.append(Command('date', NoEscape(r'\today')))
self.doc.append(NoEscape(r'\maketitle'))
with self.doc.create(Section('Acknowledgement')):
self.doc.append(
NoEscape(
r"All the following problems are copyrighted by the \href{https://www.maa.org/}{Mathematical Association of America}'s \href{https://www.maa.org/math-competitions}{American Mathematics Competitions}."
))
def add_section(self, section_name: str):
with self.doc.create(Section(section_name)):
with self.doc.create(Enumerate()) as enum:
for problem in self.problems:
enum.add_item(NoEscape(problem))
self.problems = []
def write_tex(self):
self.doc.generate_tex()
from service.genera_seccion_sumas_aritmeticas import GeneraSumas as gs
from service.genera_seccion_restas_aritmeticas import GeneraRestas as gr
from pylatex import Document, Section, Subsection, Tabular, Math, TikZ, Axis, \
Plot, Figure, Matrix, Alignat, Enumerate
from pylatex.utils import italic
ejercicios_suma = gs(cantidad_sumas=10,
sumandos=10,
limite_superior=100,
limite_inferior=-100)
ejercicios_resta = gr(cantidad_restas=10,
sumandos=10,
limite_superior=100,
limite_inferior=-100)
geometry_options = {"tmargin": "1cm", "lmargin": "1cm"}
doc = Document(geometry_options=geometry_options)
with doc.create(Section('Aritmética ')):
doc.append('Esta es la sección destinada a aritmética.')
with doc.create(Subsection('Sumas')):
doc.append('Resuelva correctamente las siguientes sumas:')
with doc.create(Enumerate()) as enum:
for ejercicio in ejercicios_suma.ejercicios:
enum.add_item(ejercicio.__str__())
with doc.create(Subsection('Restas')):
doc.append('Resuelva correctamente las siguientes sumas:')
with doc.create(Enumerate()) as enum:
for ejercicio in ejercicios_resta.ejercicios:
enum.add_item(ejercicio.__str__())
doc.generate_pdf('/tmp/ejercicios', clean_tex=True)
dfResCOPAug = dfResCOP.loc[dfResCOP['date'] == augDate]
#Chapter 3
dfForHolStCOPOct = dfForHolStCOP.loc[dfForHolStCOP['date'] == octDate]
dfForHolFlCOPOct = dfForHolFlCOP.loc[dfForHolFlCOP['date'] == octDate]
dfForHolStUSDOct = dfForHolStUSD.loc[dfForHolStUSD['date'] == octDate]
dfForHolFlUSDOct = dfForHolFlUSD.loc[dfForHolFlUSD['date'] == octDate]
#Chapter 4
dfPortCOPJun = dfPortCOP.loc[dfPortCOP['date'] == junDate]
dfPortUSDJun = dfPortUSD.loc[dfPortUSD['date'] == junDate]
#__________________________________________________
#geometry_options = {"tmargin": "5cm"}
doc = Document(documentclass='report', document_options=['11pt, notitlepage'])
doc.preamble.append(NoEscape(r'\usepackage{appendix}'))
doc.preamble.append(NoEscape(r'\usepackage{graphicx}'))
doc.preamble.append(NoEscape(r'\usepackage{pdflscape}'))
doc.preamble.append(NoEscape(r'\usepackage[margin=1in]{geometry}'))
doc.preamble.append(NoEscape(r'\usepackage{hyperref}'))
doc.preamble.append(
NoEscape(
r'\hypersetup{colorlinks=true, linkcolor=blue, filecolor=magenta, urlcolor=cyan}'
))
doc.preamble.append(NoEscape(r'\urlstyle{same}'))
doc.preamble.append(NoEscape(r'\linespread{1.6}'))
doc.preamble.append(Command('title', 'Trounceflow Countries: Colombia'))
doc.preamble.append(Command('author', 'Michael Trounce'))
def create_pdf(recipes):
doc = Document()
doc.packages.append(Package("hyperref", options="hidelinks"))
doc.append("\\begin{titlepage}\n"
"\\centering\n"
"{\\scshape\\Huge\\textbf The Greater Book of Transmutation \\par}\n"
"\\vspace{1.5cm}\n"
"{\\scshape\\large How to make almost anything in a few easy steps \\par}\n"
"\\vspace{5.5cm}\n"
"{\\large A Procedurally Generated DIY Book \\par}\n"
"{\\large for the \href{https://github.com/dariusk/NaNoGenMo-2015}{NaNoGenMo 2015} \\par}\n"
"\\vspace{0.5cm}\n"
"{\\large by \\href{http://dragonlab.de}{Tobias Wehrum} \\par}\n"
"\\vfill\n"
"{\\scriptsize using data by: \\par}\n"
"\\vspace{0.3cm}\n"
"{\\scriptsize\\href{http://web.usf.edu/FreeAssociation}{Nelson, D. L., McEvoy, C. L., \\& Schreiber, T. A. (1998). The University of South Florida word association, rhyme, and word fragment norms}\\par}\n"
"\\vspace{0.3cm}\n"
"{\\scriptsize\\href{https://www.englishclub.com/vocabulary/nouns-uncountable-list.htm}{English Club: Uncountable Nouns List}\\par}\n"
"\\vspace{0.3cm}\n"
"{\\scriptsize\\href{http://archives.nd.edu/whitaker/dictpage.htm}{LATIN-ENGLISH DICTIONARY WORDLIST Version 1.97FC by William Whitaker}\\par}\n"
"\\vspace{0.5cm}\n"
"\\end{titlepage}\n"
"\n"
"\\setcounter{tocdepth}{1}\n"
"\\renewcommand*\\contentsname{How to make...}\n"
"\\tableofcontents\n"
"\\newpage");
for r in recipes:
r.print_to_doc(doc)
try:
os.remove("TheGreaterBookOfTransmutation.toc")
except Exception as err:
traceback.print_tb(err.__traceback__)
try:
doc.generate_pdf("TheGreaterBookOfTransmutation")
except Exception as err:
traceback.print_tb(err.__traceback__)
try:
doc.generate_tex("TheGreaterBookOfTransmutation")
except Exception as err:
traceback.print_tb(err.__traceback__)
