def __init__(self, data=None, options=None):
packages = [
Package('pgfplots'),
Package('compat=newest', base='pgfplotsset')
]
super().__init__('axis', data=data, options=options, packages=packages)
class Algorithm(Environment):
packages = [
Package("algorithm"),
Package("algpseudocode"),
Package("amsmath")
]
def __init__(self, enumeration_symbol=None, *, options=None, **kwargs):
self._enumeration_symbol = enumeration_symbol
if enumeration_symbol is not None:
if options is not None:
options = Options(options)
else:
options = Options()
super().__init__(options=options, **kwargs)
def caption(self, s):
self.append(Command('caption', s))
def algorithmic(self, inp=None, out=None):
alg = Algorithmic(options="1")
if inp is not None:
alg.append(Command('Require', inp))
if out is not None:
alg.append(Command('Ensure', out))
self.append(alg)
return alg
def __init__(self, name=None, func=None, coordinates=None, options=None):
self.name = name
self.func = func
self.coordinates = coordinates
self.options = options
packages = [
Package('pgfplots'),
Package('compat=newest', base='pgfplotsset')
]
super().__init__(packages=packages)
def __init__(self):
document_options = ['a4paper', '10pt']
geometry_options = {"textwidth": "162mm", "textheight": "240mm"}
super().__init__(geometry_options=geometry_options,
document_options=document_options)
self.packages.append(Package('babel', 'brazilian'))
self.packages.append(Package('helvet'))
# \renewcommand{\familydefault}{\sfdefault}
self.packages.append(
Command("renewcommand",
arguments=[
NoEscape(r"\familydefault"),
NoEscape(r"\sfdefault")
]))
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 addReferences(self, font, spacing, size, item_spacing):
"""
This function can randomly insert a batch of references
with randomly choiced font, size and line spacing
"""
self.doc.append(UnsafeCommand('balance',
packages=[Package('balance')]))
item_spacing = str(spacing * float(item_spacing))
item_spacing = item_spacing + 'ex'
refs = self.getReferences(font)
mode = random.choice([1, 2])
with self.doc.create(SPACING(arguments=spacing)):
self.doc.append(Command(size))
if mode == 1:
with self.doc.create(THEBIBLIOGRAPHY(arguments='99')):
self.doc.append(
UnsafeCommand('addtolength',
'\itemsep',
extra_arguments=item_spacing))
for ref in refs:
ref = '\\bibitem{ref}' + ref
self.doc.append(ref)
else:
i = 0
with self.doc.create(Section('References', numbering=False)):
for ref in refs:
i += 1
ref = '{[}' + str(i) + '{]}' + ref
self.doc.append(NoEscape(ref))
self.doc.append(Command('clearpage'))
class Avm(Environment):
"""
A class representing a custom LaTeX environment.
"""
_latex_name = 'avm'
packages = [Package('avm')]
def __init__(self, matrix, name='', mtype='p', alignment=None):
self.mtype = mtype
self.matrix = matrix
self.alignment = alignment
self.name = name
super().__init__(packages=[Package('amsmath')])
def __init__(self, data=None, options=None):
packages = [
Package('pgfplots'),
Command('pgfplotsset', 'compat=newest')
]
super().__init__(data=data, options=options, packages=packages)
def generate_report(project):
file_path = "projects/{0}/{0}".format(project.id)
# Basic document
geometry_options = {"head": "40pt", "margin": "1in", "bottom": "1in"}
doc = Document(default_filepath=file_path,
geometry_options=geometry_options)
doc.packages.append(Package('listings'))
doc.packages.append(Package('color'))
doc.append(
NoEscape(r'''\definecolor{codegreen}{rgb}{0,0.6,0}
\definecolor{codegray}{rgb}{0.5,0.5,0.5}
\definecolor{codepurple}{rgb}{0.58,0,0.82}
\definecolor{backcolour}{rgb}{0,0,0}
\definecolor{mycolor}{rgb}{1,1,1}
\lstdefinestyle{mystyle}{
backgroundcolor=\color{backcolour},
commentstyle=\color{codegreen},
keywordstyle=\color{magenta},
numberstyle=\tiny\color{codegray},
stringstyle=\color{codepurple},
basicstyle=\footnotesize\color{mycolor},
breakatwhitespace=false,
breaklines=true,
captionpos=b,
keepspaces=true,
numbers=left,
numbersep=5pt,
showspaces=false,
showstringspaces=false,
showtabs=false,
tabsize=2,
inputencoding=latin1
}
\lstset{style=mystyle}
'''))
doc.preamble.append(Command('title', project.name))
doc.preamble.append(Command('author', 'Anonymous author'))
doc.preamble.append(Command('date', NoEscape(r'\today')))
doc.append(NoEscape(r'\maketitle'))
for finding in project.findings:
add_finding(doc, finding)
# fill_document(doc)
doc.generate_tex()
class MyFigure(Environment):
"""
A class to generate a figure environment across two rows
will also be used for asserting equations
"""
_latex_name = 'figure*'
packages = [Package('stfloats')]
escape = False
content_separator = "\n"
def __init__(self, data=None):
"""
:param data:
:type data: list
"""
packages = [Package('tikz')]
super().__init__(data=data, packages=packages)
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')]
class ExampleEnvironment(Environment):
"""
A class representing a custom LaTeX environment.
This class represents a custom LaTeX environment named
``exampleEnvironment``.
"""
_latex_name = 'exampleEnvironment'
packages = [Package('mdframed')]
def begin_pdf(self):
geometry_options = {
"tmargin": "1cm",
"lmargin": "1cm",
"landscape": True
}
self.doc = Document(geometry_options=geometry_options)
self.doc.packages.append(Package('float'))
return self.doc
def __init__(self, quantity, format_cb=None):
import numpy as np
self.quantity = quantity
if format_cb is None:
magnitude_str = np.array_str(quantity.magnitude)
else:
magnitude_str = format_cb(quantity.magnitude)
unit_str = _dimensionality_to_siunitx(quantity.dimensionality)
super().__init__(command='SI',
arguments=(magnitude_str, unit_str),
packages=[Package('siunitx')])
class PseudoCodeEnv(Environment):
packages = [Package("algpseudocode")]
def __init__(self,
command,
name,
args=None,
enumeration_symbol=None,
*,
options=None,
**kwargs):
self._enumeration_symbol = enumeration_symbol
if enumeration_symbol is not None:
if options is not None:
options = Options(options)
else:
options = Options()
super().__init__(options=options, **kwargs)
self.command = command
self.name = name
self.args = args
def dumps(self):
"""Represent the function as a string in LaTeX syntax.
Returns
-------
str
A LaTeX string representing the function.
"""
content = self.dumps_content()
if not content.strip() and self.omit_if_empty:
return ''
string = ''
if self.args is not None:
begin = Command(self.command, arguments=(self.name, self.args))
else:
begin = Command(self.command, arguments=self.name)
string += begin.dumps() + self.content_separator
string += content + self.content_separator
string += Command('End' + self.command).dumps()
return string
def add_state(self, s):
self.append(Command('State', s)) # *(2)占格，!占一整行
def __init__(self,
filename='default_filename',
documentclass='article',
fontenc='T1',
inputenc='utf8',
author=None,
title=None,
date=None,
data=None):
self.filename = filename
self.documentclass = documentclass
fontenc = Package('fontenc', option=fontenc)
inputenc = Package('inputenc', option=inputenc)
packages = [fontenc, inputenc, Package('lmodern')]
if title is not None:
packages.append(Package(title, base='title'))
if author is not None:
packages.append(Package(author, base='author'))
if date is not None:
packages.append(Package(date, base='date'))
super().__init__(data, packages=packages)
def __init__(self, data=None, options=None):
"""
:param data:
:param options:
:type data: list
:type options: str or list or :class:`parameters.Options` instance
"""
packages = [
Package('pgfplots'),
Command('pgfplotsset', 'compat=newest')
]
super().__init__(data=data, options=options, packages=packages)
def generateExam(self):
doc = Document('basic')
doc.documentclass = Command(
'documentclass',
options=['12pt'],
arguments=['exam'],
)
doc.packages.append(Package('amsmath'))
doc.preamble.append(Command('pagestyle', 'headandfoot'))
doc.preamble.append(
Command(
'firstpageheader',
NoEscape(
r"""%s : %s \\ \today}{}{Name: \underline{\hspace{2.5in}}"""
% (self.course, self.subject))))
doc.append(
Command(
'center',
Command(
'fbox',
Command('fbox', 'NO CALCULATORS OR EXTERNAL RESOURCES'))))
doc.append(Command('begin', 'questions'))
for mcq in self.mcqs:
doc.append(NoEscape(r'\question ' + mcq.prompt))
doc.append(Command('begin', 'checkboxes'))
for ans in mcq.answers:
doc.append(Command('choice', ans))
for frq in self.frqs:
doc.append(NoEscape(r'\question ' + NoEscape(frq.prompt)))
doc.append(Command('vspace', frq.spacing + 'in'))
doc.append(Command('end', 'questions'))
big_code = pyqrcode.create(np.array_str(self.answerKey), mode='binary')
big_code.png('code.png')
with doc.create(Figure(position='b!')) as code:
code.add_image('code.png', width='50px')
doc.generate_pdf(clean_tex=False, compiler='pdfLaTeX')
doc.generate_tex()
class Algorithmic(Environment):
packages = [Package("algorithmicx")]
def __init__(self, enumeration_symbol=None, *, options=None, **kwargs):
self._enumeration_symbol = enumeration_symbol
if enumeration_symbol is not None:
if options is not None:
options = Options(options)
else:
options = Options()
super().__init__(options=options, **kwargs)
def caption(self, s):
self.append(Command('caption', s))
def __init__(self,
name=None,
func=None,
coordinates=None,
error_bar=None,
options=None):
self.name = name
self.func = func
self.coordinates = coordinates
self.error_bar = error_bar
self.options = options
packages = [
Package('pgfplots'),
Command('pgfplotsset', 'compat=newest')
]
super().__init__(packages=packages)
class MiniBox(CommandBase):
"""
A class representing a custom LaTeX command.
"""
_latex_name = 'minibox'
packages = [Package('minibox')]
content = "\n"
def __init__(self, framed=False):
if framed:
super().__init__(options=Options("frame", "pad=4pt", "rule=0.1pt"))
else:
super().__init__(options=Options("pad=4pt", "rule=0pt"))
def CompileContent(self):
"""
"""
self.arguments = Arguments(NoEscape(self.content.replace("#", r"\#")))
class Tasks(Environment):
"""A class to wrap LaTeX's tasks environment."""
packages = [Package('tasks')]
def __init__(self, enumeration_symbol=None, *, options=None, **kwargs):
self._enumeration_symbol = enumeration_symbol
if enumeration_symbol is not None:
if options is not None:
options = Options(options)
else:
options = Options()
super().__init__(options=options, **kwargs)
def add_task(self, s):
self.append(Command('task')) # *(2)占格，!占一整行
self.append(s)
def __init__(self, matrix, name='', mtype='p', alignment=None):
"""
:param matrix:
:param name:
:param mtype:
:param alignment:
:type matrix: :class:`numpy.matrix` instance
:type name: str
:type mtype: str
:type alignment: str
"""
self.mtype = mtype
self.matrix = matrix
self.alignment = alignment
self.name = name
super().__init__(packages=[Package('amsmath')])
def add_multirow(self,
size,
align,
content,
hlines=True,
cells=None,
escape=False):
"""
Add a multirow of height size to the table, with cell content content
"""
self.append(r'\multirow{%d}{%s}{%s}' % (size, align, content))
self.packages.add(Package('multirow'))
if cells is not None:
for i, row in enumerate(cells):
if hlines and i:
self.add_hline(2)
self.append('&')
self.add_row(row)
else:
for i in range(size):
self.add_empty_row()
def __init__(self, name=None, func=None, coordinates=None, options=None):
"""
:param name:
:param func:
:param coordinates:
:param options:
:type name: str
:type func: str
:type coordinates: list
:type options: str or list or :class:`parameters.Options` instance
"""
self.name = name
self.func = func
self.coordinates = coordinates
self.options = options
packages = [
Package('pgfplots'),
Command('pgfplotsset', 'compat=newest')
]
super().__init__(packages=packages)
}]
if __name__ == '__main__':
if prompt(mode)['mode'] == 'Create':
header = prompt(headerQuestions, style=style)
# Basic document
doc = Document('basic')
doc.documentclass = Command(
'documentclass',
options=['12pt'],
arguments=['exam'],
)
doc.packages.append(Package('amsmath'))
doc.preamble.append(Command('pagestyle', 'headandfoot'))
doc.preamble.append(
Command(
'firstpageheader',
NoEscape(
r"""%s : %s \\ \today}{}{Name: \underline{\hspace{2.5in}}"""
% (header['course'], header['material']))))
doc.append(
Command(
'center',
Command(
'fbox',
Command('fbox', 'NO CALCULATORS OR EXTERNAL RESOURCES'))))
doc.append(Command('begin', 'questions'))
def generate_latex_document(trackers: List[Tracker],
sequences: List[Sequence],
results,
storage: Storage,
build=False,
multipart=True):
order_marks = {1: "first", 2: "second", 3: "third"}
def format_cell(value, order):
cell = format_value(value)
if order in order_marks:
cell = Command(order_marks[order], cell)
return cell
logger = logging.getLogger("vot")
table_header, table_data, table_order = extract_measures_table(
trackers, results)
plots = extract_plots(trackers, results)
doc = Document(page_numbers=True)
doc.preamble.append(Package('pgf'))
doc.preamble.append(Package('xcolor'))
doc.preamble.append(Package('fullpage'))
doc.preamble.append(NoEscape(read_resource("commands.tex")))
doc.preamble.append(
UnsafeCommand('newcommand',
r'\first',
options=1,
extra_arguments=r'{\color{red} #1 }'))
doc.preamble.append(
UnsafeCommand('newcommand',
r'\second',
options=1,
extra_arguments=r'{\color{green} #1 }'))
doc.preamble.append(
UnsafeCommand('newcommand',
r'\third',
options=1,
extra_arguments=r'{\color{blue} #1 }'))
if multipart:
container = Chunk()
generate_symbols(container, trackers)
with storage.write("symbols.tex") as out:
container.dump(out)
doc.preamble.append(Command("input", "symbols.tex"))
else:
generate_symbols(doc.preamble, trackers)
doc.preamble.append(Command('title', 'VOT report'))
doc.preamble.append(
Command('author', 'Toolkit version ' + toolkit_version()))
doc.preamble.append(Command('date', datetime.datetime.now().isoformat()))
doc.append(NoEscape(r'\maketitle'))
if len(table_header[2]) == 0:
logger.debug("No measures found, skipping table")
else:
# Generate data table
with doc.create(LongTable("l " *
(len(table_header[2]) + 1))) as data_table:
data_table.add_hline()
data_table.add_row([" "] + [
MultiColumn(c[1], data=c[0].identifier)
for c in merge_repeats(table_header[0])
])
data_table.add_hline()
data_table.add_row([" "] + [
MultiColumn(c[1], data=c[0].title)
for c in merge_repeats(table_header[1])
])
data_table.add_hline()
data_table.add_row(
["Tracker"] +
[" " + c.abbreviation + " " for c in table_header[2]])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for tracker, data in table_data.items():
data_table.add_row([
UnsafeCommand("Tracker",
[tracker.reference, TRACKER_GROUP])
] + [
format_cell(x,
order[tracker] if not order is None else None)
for x, order in zip(data, table_order)
])
for experiment, experiment_plots in plots.items():
if len(experiment_plots) == 0:
continue
doc.append(Section("Experiment " + experiment.identifier))
for title, plot in experiment_plots:
with doc.create(Figure(position='htbp')) as container:
if multipart:
plot_name = plot.identifier + ".pdf"
with storage.write(plot_name, binary=True) as out:
plot.save(out, "PDF")
container.add_image(plot_name)
else:
container.append(insert_figure(plot))
container.add_caption(title)
if build:
temp = tempfile.mktemp()
logger.debug("Generating to tempourary output %s", temp)
doc.generate_pdf(temp, clean_tex=True)
storage.copy(temp + ".pdf", "report.pdf")
else:
with storage.write("report.tex") as out:
doc.dump(out)
class ParacolEnvironment(Environment):
_latex_name = 'paracol'
packages = [Package('paracol')]