def dumps(self):
"""Represent the plot as a string in LaTeX syntax.
:return:
:rtype: str
"""
string = Command('addplot', options=self.options).dumps()
if self.coordinates is not None:
string += ' coordinates {\n'
if self.error_bar is None:
for x, y in self.coordinates:
# ie: "(x,y)"
string += '(' + str(x) + ',' + str(y) + ')\n'
else:
for (x, y), (e_x, e_y) in zip(self.coordinates,
self.error_bar):
# ie: "(x,y) +- (e_x,e_y)"
string += '(' + str(x) + ',' + str(y) + \
') +- (' + str(e_x) + ',' + str(e_y) + ')\n'
string += '};\n\n'
elif self.func is not None:
string += '{' + self.func + '};\n\n'
if self.name is not None:
string += Command('addlegendentry', self.name).dumps()
super().dumps()
return string
def change_thickness(self, element, thickness):
r"""Change line thickness.
Changes the thickness of the line under/over the header/footer
to the specified thickness.
Args
----
element: str
the name of the element to change thickness for: header, footer
thickness: float
the thickness to set the line to
"""
if element == "header":
self.data.append(
Command("renewcommand",
arguments=[
NoEscape(r"\headrulewidth"),
str(thickness) + 'pt'
]))
elif element == "footer":
self.data.append(
Command("renewcommand",
arguments=[
NoEscape(r"\footrulewidth"),
str(thickness) + 'pt'
]))
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 append(self, keys):
if isinstance(keys, list):
for key in keys:
self.args.append(r"{}".format(key))
self.args.append(Command("quad"))
else:
self.args.append(r"{}".format(keys))
self.args.append(Command("quad"))
self.set()
def add_item(self, isChecked, s):
"""Add an item to the list.
Args
----
isChecked: boolean
Description of the item.
s: str or `~.LatexObject`
The item itself.
"""
if isChecked == True:
self.append(Command('CorrectChoice'))
else:
self.append(Command('choice'))
self.append(s)
def notes(doc):
doc.append(Command('newgeometry', 'top=1in,bottom=1in'))
with doc.create(Section('Modeling Notes')):
with doc.create(Subsection('Tax-Calculator')):
doc.append(tax_calculator_string)
with doc.create(Subsection('Modeling Assumptions')):
doc.append(modeling_assumptions_string)
def __init__(self, data=None, options=None):
packages = [
Package('pgfplots'),
Command('pgfplotsset', 'compat=newest')
]
super().__init__(data=data, options=options, packages=packages)
def generate_preview(perturbed_fonts):
document = PdfGenerator.setup_document()
for perturbed_font in perturbed_fonts:
document.append(Command('setmainfont', arguments=NoEscape(perturbed_font)))
document.append(string.ascii_lowercase + string.ascii_uppercase)
document.append("\n")
return document
def algorithm(name, inp=None, out=None, core=None, label=None):
al = Algorithm()
al.caption(name)
alc = al.algorithmic(inp, out)
if core is not None:
if label is not None:
core.pre_append(Command("floatname", arguments=("algorithm", label[0])))
core.global_define([r"\algorithmicrequire", r"\algorithmicensure"],
[f"\\textbf{{{label[1]}:}}", f"\\textbf{{{label[2]}:}}"], True)
return al, alc
def __init__(self, *params, data=None):
# Disable escaping for now
old_escape = LatexObject.escape
LatexObject.escape = False
command_name = self.__class__.__name__.lower()
args = list(signature(self.definition).parameters.keys())
num_args = len(args)
if len(params) != num_args:
raise ValueError(f'Expected {num_args} parameters from '
f'definition, but got {len(params)}.')
if data is not None:
if not set(data.keys()).issubset(set(self.data.keys())):
raise KeyError('Data contains invalid keys')
self.data.update(data)
if hasattr(self, 'packages'):
NewCommand.packages |= self.packages
if hasattr(self, 'provide_commands'):
NewCommand.provide_commands |= self.provide_commands
if hasattr(self, 'provide_lengths'):
NewCommand.provide_lengths |= self.provide_lengths
# Bind values from __init__ args to self before calling definition
for name, p in zip(args, params):
setattr(self, f'__{name}', p)
definition = self.definition(*params)
if isinstance(definition, (list, tuple)):
definition = ''.join([
NoEscape(x.dumps()) if hasattr(x, 'dumps') else str(x)
for x in definition
])
elif hasattr(definition, 'dumps'):
definition = definition.dumps()
definition = NoEscape(definition)
if command_name not in NewCommand.commands:
args_str = None if num_args == 0 else NoEscape(f'{num_args}')
registry_command = Command(
'renewcommand' if self.renew else 'newcommand',
arguments=Command(command_name),
options=args_str,
extra_arguments=definition,
)
NewCommand.commands[command_name] = registry_command
super(NewCommand, self).__init__(arguments=params)
LatexObject.escape = old_escape
def setup_document(letterspace=25):
document = Document(document_options='a4paper', geometry_options={'left': '10mm', 'top': '10mm'},
lmodern=False, inputenc=None,
page_numbers=False, indent=False)
# Add Font integration and glyph spacing.
document.packages.append(Package('fontspec'))
document.packages.append(Command('defaultfontfeatures', arguments=f"LetterSpace={letterspace}"))
return document
def dumps(self):
# note: most of the following was copied from the pyLaTeX library so
# in order to fix a logic error at the end of the function.
content = self.dumps_content()
if not content.strip() and self.omit_if_empty:
return ""
string = ""
start = Command(self.latex_name,
arguments=self.arguments,
options=self.options)
string += start.dumps()
if content != "":
string += "{{ \n {} \n}}".format(content)
return string
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 dumps(self):
"""Represent the section as a string in LaTeX syntax.
:return:
"""
if not self.numbering:
num = '*'
else:
num = ''
string = Command(self.latex_name + num, self.title).dumps()
if self.label is not None:
string += '%\n' + self.label.dumps()
string += '%\n' + self.dumps_content()
return string
def __init__(self, *args, **kwargs):
preamble = self.create_preamble()
body = self.create_body()
self.packages |= NewCommand.packages
super(DocumentBase, self).__init__(*args, **kwargs)
# 1. newcommands 2. preamble 3. Body
for p in NewCommand.provide_commands:
self.preamble.append(
Command('providecommand', [NoEscape(rf'\{p}'), '']))
for length in NewCommand.provide_lengths:
self.preamble.append(NewLength(length))
self.preamble += preamble
self += body
for c in NewCommand.commands.values():
self.preamble.append(c)
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)
r'\\rotatebox{90}{\\textbf{\1}}', lines[i])
lines[i] = re.sub(r'(\\textbf{family})', r'\\rotatebox{45}{\\textbf{\1}}',
lines[i])
#lines[i] = re.sub(r'(\bX\b)', r'\\ding{51}', lines[i]) # tick
lines[i] = re.sub(r'(\bX\b)', r'\\ding{54}', lines[i])
print lines[i]
with open(outfile, 'w') as f:
f.write('\n'.join(lines))
import pylatex as pl
from pylatex.utils import italic, NoEscape
from pylatex.package import Package
from pylatex.base_classes import Command
import os
doc = pl.Document('basic')
doc.documentclass = Command(
'documentclass',
options=['12pt', 'landscape'],
arguments=['standalone'],
)
doc.packages.append(Package('array'))
doc.packages.append(Package('graphicx'))
doc.packages.append(Package('booktabs'))
doc.packages.append(Package('multirow'))
doc.packages.append(Package('pifont'))
doc.append(NoEscape('\n'.join(lines)))
doc.generate_pdf(os.path.splitext(outfile)[0] + '_standalone', clean_tex=True)
def caption(self, s):
self.append(Command('caption', s))
def add_state(self, s):
self.append(Command('State', s)) # *(2)占格，!占一整行
def author(doc):
doc.append(NoEscape(r'\noindent\\'))
doc.append(Command('textbf', paper_author + ' '))
doc.append(paper_bio)
def add_packages(doc):
"""
Add packages to the LaTeX file.
"""
doc.preamble.append(Command('usepackage', 'xcolor'))
doc.preamble.append(Command('usepackage', 'hyperref'))
doc.preamble.append(Command('usepackage', 'xcolor'))
doc.preamble.append(Command('usepackage', 'enumitem'))
doc.preamble.append(Command('usepackage', 'titling'))
doc.preamble.append(Command('usepackage', 'graphicx'))
doc.preamble.append(Command('usepackage', 'sectsty'))
doc.preamble.append(Command('usepackage', 'titlesec'))
doc.preamble.append(Command('usepackage', 'setspace'))
doc.preamble.append(Command('usepackage', 'tikz'))
doc.preamble.append(Command('usepackage', 'calc'))
doc.preamble.append(Command('usetikzlibrary', 'calc'))
doc.preamble.append(Command('renewcommand', NoEscape(r'\rmdefault}{phv')))
doc.preamble.append(Command('renewcommand', NoEscape(r'\sfdefault}{phv')))
doc.preamble.append(Command('sectionfont', NoEscape(r'\fontsize{12}{15}\selectfont')))
doc.preamble.append(Command('titlespacing*', NoEscape(r'\section}{0pt}{0.5\baselineskip}{0.5\baselineskip')))
def add_task(self, s):
self.append(Command('task')) # *(2)占格，!占一整行
self.append(s)
