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 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 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 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 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 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 [[email protected]]', 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

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:",name)
	doc = Document(author=name,date='',title='Paper Title',maketitle=True, default_filepath=paperfile, documentclass=documentcls)
	doc.preamble.append(Command('input', arguments='macro.tex'))

	doc = add_package(doc)
	doc = add_paperprefix(doc)
	doc = add_text(doc)
	doc.generate_tex(paperfile)
	shutil.copy2(paperfile+".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)