def process(self):
if self.output.lower() == 'latex':
formatter = LatexFormatter(
linenos=True if self.linenos else False,
linenostart=self.linenostart if self.linenostart else 1,
)
elif self.output.lower() == 'html':
formatter = HtmlFormatter(
linenos=self.linenos if self.linenos else False,
linenostart=self.linenostart if self.linenostart else 1,
noclasses=True if self.noclasses else False,
)
else:
# THROW ERROR
pass
if self.language:
lexer = get_lexer_by_name(self.language)
elif self.content:
lexer = guess_lexer(self.content)
else:pass
if self.output == 'latex' and self.preamble:
return '\usepackage{fancyvrb}\n\usepackage{color}\n\usepackage[latin1]{inputenc}\n' +\
formatter.get_style_defs()
elif self.output == 'html' and self.preamble:
return formatter.get_style_defs()
else:
pass
return highlight(self.content, lexer, formatter)
def __init__(self, source=None):
PwebTexPygmentsFormatter.__init__(self, source)
from pygments.formatters import LatexFormatter
x = LatexFormatter()
self.header = ("""\\documentclass[a4paper,11pt,final]{article}
\\usepackage{fancyvrb, color, graphicx, hyperref, ,amsmath, url}
\\usepackage{palatino}
\\usepackage[a4paper,text={16.5cm,25.2cm},centering]{geometry}
\\hypersetup
{ pdfauthor = {Pweave},
pdftitle={Published from %s},
colorlinks=TRUE,
linkcolor=black,
citecolor=blue,
urlcolor=blue
}
\\setlength{\parindent}{0pt}
\\setlength{\parskip}{1.2ex}
%% fix for pandoc 1.14
\\providecommand{\\tightlist}{%%
\\setlength{\\itemsep}{0pt}\\setlength{\\parskip}{0pt}}
%s
""") % (self.source, x.get_style_defs())
self.footer = r"\end{document}"
def __init__(self, source=None):
PwebTexPygmentsFormatter.__init__(self, source)
from pygments.formatters import LatexFormatter
x = LatexFormatter()
self.header = ("""\\documentclass[a4paper,11pt,final]{article}
\\usepackage{fancyvrb, color, graphicx, hyperref, ,amsmath, url}
\\usepackage{palatino}
\\usepackage[a4paper,text={16.5cm,25.2cm},centering]{geometry}
\\hypersetup
{ pdfauthor = {Pweave},
pdftitle={Published from %s},
colorlinks=TRUE,
linkcolor=black,
citecolor=blue,
urlcolor=blue
}
\\setlength{\parindent}{0pt}
\\setlength{\parskip}{1.2ex}
%% fix for pandoc 1.14
\\providecommand{\\tightlist}{%%
\\setlength{\\itemsep}{0pt}\\setlength{\\parskip}{0pt}}
%s
""") % (self.source, x.get_style_defs())
self.footer = r"\end{document}"
def process_note(notefile):
fn = LatexClass(notefile)
fn.parse_note();
formatter = LatexFormatter()
defs = formatter.get_style_defs()
out = fn.template['article'].replace('~article.title', fn.title).replace('~article.content', (fn.note).encode('utf-8')).replace('~article.defs', str(defs)).replace('~article.date', str(fn.date))
with open(notefile.split('.')[0] + '.tex', "w") as fout:
fout.write(out)
def extract_algorithms(ps_infile, env):
"""
Вытаскиваем части кода-алгоритмы
"""
import pygments
from pygments.lexers import get_lexer_by_name
from pygments.formatters import LatexFormatter
algorithm_regexp = re.compile(
r"(?ms)\#ALGORITHM\s+(?P<name>[a-zA-z-0-9]+)\s*(?P<code>.+?)\s*\#ENDALGORITHM")
hideline_regexps = [re.compile(r"(?m)^.*\#hide *\n"), re.compile(r"(?m)\n.*\#hide *") ]
ls = ut.file2string(ps_infile)
for algorithm in algorithm_regexp.finditer(ls):
algfilename = lib.get_target(ps_infile, algorithm.group('name')+".py")
texfilename = lib.get_target(ps_infile, algorithm.group('name')+".tex")
#lf = open(algfilename, 'w')
code = algorithm.group('code')
for r in hideline_regexps:
code = re.sub(r, "", code)
#code = lib.utf8anyway(code)
#lf.write(code)
#lf.close()
#tempblock = os.path.join(tempfile.gettempdir(), tempfile.gettempprefix())
#ls = ''.join([env.project_db['paths']['python'],
# r'\scripts\pygmentize -f latex -l python ',
# ' -o "%(tempblock)s" "%(algfilename)s" ' % vars() ])
#os.system(ls)
lexer = get_lexer_by_name('python')
code = ut.unicodeanyway(code)
latex_tokens = pygments.lex(code, lexer)
# sblock = ut.file2string(tempblock)
# from pygments.formatters import LatexFormatter
latex_formatter = LatexFormatter(texcomments = True)
latex = pygments.format(latex_tokens, latex_formatter)
stexblock = r"""
\documentclass{minimal}
\usepackage{xecyr}
\XeTeXdefaultencoding "utf-8"
\XeTeXinputencoding "utf-8"
\defaultfontfeatures{Mapping=tex-text}
\setmonofont{Consolas}
\usepackage{color}
\usepackage{fancyvrb}
\usepackage[russian,english]{babel}
""" + latex_formatter.get_style_defs() + r"""
\begin{document}
""" + latex + r"""
\end{document}
"""
ut.string2file(stexblock, texfilename, encoding='utf-8')
def latex_syntax_highlight(body, language='text',
verboptions=("frame=single,framerule=0.2pt,"
"framesep=5pt,xleftmargin=15pt")):
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import LatexFormatter
lexer = get_lexer_by_name(language)
formatter = LatexFormatter(linenos=True, verboptions=verboptions)
return "{}\n{}".format(formatter.get_style_defs(),
highlight(body, lexer, formatter))
def latex_syntax_highlight_file(filename, language='text',
verboptions=("frame=single,framerule=0.2pt,"
"framesep=5pt,xleftmargin=15pt")):
with open(filename.strip()) as f:
body = f.read()
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import LatexFormatter
lexer = get_lexer_by_name(language)
formatter = LatexFormatter(linenos=True, verboptions=verboptions)
return "{}\n{}".format(formatter.get_style_defs(),
highlight(body, lexer, formatter).replace('[[', '[{}[').replace(']]', ']{}]'))
def latex_output(filenames, outfile, style, fontpkg, pagebreak):
if not outfile:
outfile = "output.tex"
lines_wrapped = 0
formatter = LatexFormatter(linenos=False, style=style)
output = open(outfile, "w")
output.write(latex_preamble % fontpkg)
output.write(formatter.get_style_defs())
for filename in filenames:
output.write("\\hrule\n")
output.write("\\section*{" + filename + "}\n")
lexer = get_lexer_for_filename(filename)
F = open(filename, "r")
result = highlight(F.read(), lexer, formatter, output)
F.close()
if pagebreak:
output.write("\\pagebreak")
output.write("\end{document}")
if lines_wrapped > 0:
print "(wrapped " + str(lines_wrapped) + " lines)"
output.close()
def generate_sty(self, style='default'):
formatter = LatexFormatter(style=style)
return formatter.get_style_defs()
def create_tex_file(filenames, working_dir):
all_files = glob(join(escape(working_dir), '**', '*'), recursive=True)
relevant_files = list(filter(lambda x: basename(x) in filenames,
all_files))
if not relevant_files:
return None, None
else:
print(f"Found files: {relevant_files}")
scoring = create_grading(relevant_files)
print(scoring)
pprint(scoring.file_points)
formatter = LatexFormatter(style='friendly',
title="This is a title",
linenos=True,
escapeinside="xx",
titel="This is a title",
verboptions="fontsize=\\scriptsize")
doctext = []
doctext.append(r'''\documentclass[10pt]{article}
\usepackage{geometry}
\geometry{
a4paper,
right=10mm,
bottom=15mm,
left=10mm,
top=10mm,
}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{minted}
\setlength{\parindent}{0cm}
\renewcommand{\familydefault}{\sfdefault}
''')
doctext.append(formatter.get_style_defs())
doctext.append(r"""
\begin{document}""")
doctext.append(
jinja2.Template(r"""
\section*{Scoring}
{% for file, scoring in file_points.items() %}
\paragraph{ {{file}}: {{scoring.scored_points}} / {{scoring.max_points}} }
\begin{itemize}
{% for task in scoring.tasks %}
\item {{ task[0] }}: {{task[1]}} / {{task[2]}}
{% endfor %}
\end{itemize}
{% endfor %}
\paragraph{ Total: {{scored_points}} / {{total_points}} }
""").render(scoring.__dict__))
for filename in relevant_files:
with open(filename, 'r', encoding="utf-8", errors="ignore") as f:
code = f.read()
doctext.append(f"\\section*{{{basename(filename)}}}")
doctext.append(highlight(code, CustomJavaLexer(), formatter))
doctext.append(r"\end{document}")
return '\n'.join(doctext), scoring
def pygments_sty(self):
formatter = LatexFormatter(style=self.setting('style'))
return formatter.get_style_defs()
def pygments_sty(self):
formatter = LatexFormatter(style=self.setting('style'))
return formatter.get_style_defs()
def generate_sty(self, style='default'):
formatter = LatexFormatter(style=style)
return formatter.get_style_defs()
class CamlTexFileWriter(object):
"""
Wrapper class to manage listings in OCaml.
"""
def __init__(self, filepath, style='default', prompt=None):
self.formatter = LatexFormatter(style=style)
self.prompt = prompt
self.fname = filepath
self.fpointer = open(filepath, 'w')
def write_styles(self):
"""
Make it so that the OCaml looks
pretty, by outputting the appropriate
code formatting styles.
"""
self.fpointer.write('\n\\usepackage{fancyvrb,color}\n')
self.fpointer.write(self.formatter.get_style_defs())
def write_tex(self, line):
"""
Return a line of LaTeX to the file.
"""
self.fpointer.write(line)
return True
def write_ocaml(self, ml_block):
self.fpointer.write(highlight(ml_block, OL, self.formatter))
self.fpointer.flush()
def write_ocaml_with_evals(self, ml_statements):
def clean(s):
splitted = s.split(';;\n')
if len(splitted) > 1:
stmnt = splitted[0] + ';;'
evaled = splitted[1].strip()
return stmnt + '\n' + evaled
else:
return s
statements = [clean(mls) for mls in ml_statements]
self.write_ocaml_statements(statements)
def write_ocaml_statements(self, statements):
"""
Write stylized OCaml to the output file,
styling with pygments at the same time.
"""
if self.prompt:
statements = ["{} {}".format(self.prompt, s) for s in statements]
self.write_ocaml("\n".join(statements))
return True
def close(self):
"""Close the file writer"""
self.fpointer.close()
def __repr__(self):
return "<CamlWriter {}>".format(self.fname)
if __name__ == "__main__":
parser = argparse.ArgumentParser(prog="golatex")
parser.add_argument("file", type=str)
parser.add_argument("-p", "--preamble", action="store_true")
parser.add_argument("-l", "--language", type=str, default=None)
parser.add_argument("-s", "--style", type=str, default="onehalf")
args = parser.parse_args()
with open(args.file, "r") as f:
code = f.read()
lexer = (get_lexer_by_name(args.language)
if args.language else guess_lexer_for_filename(args.file, code))
lexer.add_filter(VisibleWhitespaceFilter(tabs=" ", tabsize=2))
style = get_style_by_name(args.style)
formatter = LatexFormatter(style=style)
if args.preamble:
print("% =========================")
print("% Put this in your preamble")
print("% =========================")
print(formatter.get_style_defs().strip())
print(
"----------------------------------------------------------------\n"
)
highlighted = highlight(code, lexer, formatter).strip().split("\n")
print("\n".join(highlighted[1:len(highlighted) - 1]))
