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')]