def __init__(self, configs,*args, **kwargs):
Renderer.__init__(self, *args, **kwargs)
#document title
self.configs = configs
self.doc_title = configs['title']
self.image_extension = configs['images_ext']
# Load dictionary with methods
for key in dir(self):
if key.startswith('do__'):
self[self.aliases[key[4:]]] = getattr(self, key)
elif key.startswith('do_'):
self[key[3:]] = getattr(self, key)
self['default-layout'] = self['document-layout'] = self.default
self.footnotes = []
self.blocks = []
#tree object
self.tree = PageTree(self.doc_title,
configs['output_path'],configs)
#parameter for list formatting
self.list_level=u''
#parameter for theorem handling
self.in_theorem=False
####### TAGS ANALYSY
#dictionary for tag usage
self.used_tags = {}
def test_imager(imager_tuple, tmpdir):
imager, ext, compiler = imager_tuple
if ext == ".svg":
kind = "vector-imager"
else:
kind = "imager"
tmpdir = Path(str(tmpdir)) # for old pythons
tex = TeX()
tex.ownerDocument.config['images'][kind] = imager
if compiler is not None:
tex.ownerDocument.config['images'][kind.replace("imager", "compiler")] = compiler
tex.input(r'''
\documentclass{article}
\AtBeginDocument{You should not be seeing this in the imager output. This
is injected into the document with \textbackslash AtBeginDocument. The actual
image is on the second page and the imager should get the images from
there.}
\begin{document}
$a + b = x$
\end{document}
''')
renderer = Renderer()
if kind == "imager":
renderer['math'] = lambda node: node.image.url
else:
renderer['math'] = lambda node: node.vectorImage.url
directory = os.getcwd()
os.chdir(str(tmpdir))
renderer.render(tex.parse())
os.chdir(directory)
outfile = tmpdir/'images'/('img-0001' + ext)
root = Path(__file__).parent
benchfile = root/'benchmarks'/"{}-{}{}".format(imager, compiler, ext)
if not benchfile.exists():
(root/'new').mkdir(parents=True, exist_ok=True)
shutil.copyfile(str(outfile), str(root/'new'/benchfile.name))
raise OSError('No benchmark file: %s' % benchfile)
diff = cmp_img(str(benchfile.absolute()), str(outfile.absolute()))
if (ext == '.svg' and diff > 0.0001) or diff > 0.01:
(root/'new').mkdir(parents=True, exist_ok=True)
shutil.copyfile(str(outfile), str(root/'new'/benchfile.name))
if ext == '.svg':
bench = benchfile.read_text().split('\n')
output = outfile.read_text()
print('SVG differences:\n','\n'.join(difflib.unified_diff(
bench, output.split('\n'), fromfile='benchmark', tofile='output')).strip())
print('Full svg:\n\n', output)
assert False, 'Differences were found:\n' + str(diff)
def __init__(self, *args, **kwargs):
Renderer.__init__(self, *args, **kwargs)
# Load dictionary with methods
for key in dir(self):
if key.startswith('do_'):
self[key[3:]] = getattr(self, key)
self['default-layout'] = self['document-layout'] = self.default
self.footnotes = []
self.blocks = []
def render(self, document):
""" Load and compile page templates """
themename = document.config['general']['theme']
# Load templates from renderer directory and parent
# renderer directories
sup = list(type(self).__mro__)
sup.reverse()
themes = []
for cls in sup:
if cls is BaseRenderer or cls is object or cls is dict:
continue
cwd = os.path.dirname(sys.modules[cls.__module__].__file__)
log.info('Importing templates from %s' % cwd)
self.importDirectory(cwd)
# Store theme location
themes.append(os.path.join(cwd, 'Themes', themename))
# Load templates configured by the environment variable
templates = os.environ.get('%sTEMPLATES' % cls.__name__, '')
for path in [
x.strip() for x in templates.split(os.pathsep)
if x.strip()
]:
log.info('Importing templates from %s' % path)
self.importDirectory(path)
themes.append(os.path.join(path, 'Themes', themename))
# Load only one theme
for theme in reversed(themes):
if os.path.isdir(theme):
log.info('Importing templates from %s' % theme)
self.importDirectory(theme)
extensions = ['.zpts', '.pts']
for e in self.engines.values():
extensions += e.ext
if document.config['general']['copy-theme-extras']:
# Copy all theme extras
cwd = os.getcwd()
os.chdir(theme)
for item in os.listdir('.'):
if os.path.isdir(item):
if not os.path.isdir(os.path.join(cwd, item)):
os.makedirs(os.path.join(cwd, item))
copytree(item, cwd, True)
elif os.path.splitext(
item)[-1].lower() not in extensions:
shutil.copy(item, os.path.join(cwd, item))
os.chdir(cwd)
break
BaseRenderer.render(self, document)
def __init__(self, *args, **kwargs):
"""Initialize the Renderer
"""
Renderer.__init__(self, *args, **kwargs)
# Load dictionary with methods
for key in vars(type(self)):
if key.startswith('do__'):
self[self.aliases[key[4:]]] = getattr(self, key)
elif key.startswith('do_'):
self[key[3:]] = getattr(self, key)
def render(self, document):
""" Load and compile page templates """
themename = document.config['general']['theme']
# Load templates from renderer directory and parent
# renderer directories
sup = list(type(self).__mro__)
sup.reverse()
themes = []
for cls in sup:
if cls is BaseRenderer or cls is object or cls is dict:
continue
cwd = os.path.dirname(sys.modules[cls.__module__].__file__)
log.info('Importing templates from %s' % cwd)
self.importDirectory(cwd)
# Store theme location
themes.append(os.path.join(cwd, 'Themes', themename))
# Load templates configured by the environment variable
templates = os.environ.get('%sTEMPLATES' % cls.__name__,'')
for path in [x.strip() for x in templates.split(os.pathsep) if x.strip()]:
log.info('Importing templates from %s' % path)
self.importDirectory(path)
themes.append(os.path.join(path, 'Themes', themename))
# Load only one theme
for theme in reversed(themes):
if os.path.isdir(theme):
log.info('Importing templates from %s' % theme)
self.importDirectory(theme)
extensions = ['.zpts','.pts']
for e in self.engines.values():
extensions += e.ext
if document.config['general']['copy-theme-extras']:
# Copy all theme extras
cwd = os.getcwd()
os.chdir(theme)
for item in os.listdir('.'):
if os.path.isdir(item):
if not os.path.isdir(os.path.join(cwd,item)):
os.makedirs(os.path.join(cwd,item))
copytree(item, cwd, True)
elif os.path.splitext(item)[-1].lower() not in extensions:
shutil.copy(item, os.path.join(cwd,item))
os.chdir(cwd)
break
BaseRenderer.render(self, document)
def render(self, document):
""" Load templates and render the document """
self.loadTemplates(document)
# Better support oversized images, if sidewaysfigure is used
for item in document:
if isinstance(item, documentclass):
if item.argSource[0] == '[':
item.argSource = '[fullpage,' + item.argSource[1:]
else:
item.argSource = '[fullpage]' + item.argSource
BaseRenderer.render(self, document)
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
# Load dictionary with methods
for key in vars(type(self)):
if key.startswith('do__'):
self[self.aliases[key[4:]]] = getattr(self, key)
elif key.startswith('do_'):
self[key[3:]] = getattr(self, key)
self['default-layout'] = self['document-layout'] = self.default
self.footnotes = []
self.blocks = []
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
# Load dictionary with methods
for key in dir(self):
if key.startswith('do__'):
self[self.aliases[key[4:]]] = getattr(self, key)
elif key.startswith('do_'):
self[key[3:]] = getattr(self, key)
self['default-layout'] = self['document-layout'] = self.default
self.footnotes = []
self.blocks = []
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
# Load dictionary with methods
for key in vars(type(self)):
if key.startswith('do__'):
self[self.aliases[key[4:]]] = getattr(self, key)
elif key.startswith('do_'):
self[key[3:]] = getattr(self, key)
self.indent = 0
self.in_func = False
self.in_cvarg = False
self.descriptions = 0
self.after_parameters = False
self.func_short_desc = ''
def processFileContent(self, document, s):
s = BaseRenderer.processFileContent(self, document, s)
# Put block level elements back in
block_re = re.compile('(\\s*)\001\\[(\\d+)@+\\]')
while 1:
m = block_re.search(s)
if not m:
break
space = ''
before = m.group(1)
if before is None:
before = ''
if '\n' in before:
spaces = before.split('\n')
space = spaces.pop()
before = '\n'.join(spaces) + '\n'
block = self.blocks[int(m.group(2))]
block = space + block.replace('\n', u'\n%s' % space)
s = block_re.sub('%s%s' % (before, block), s, 1)
# Clean up newlines
return re.sub(r'\s*\n\s*\n(\s*\n)+', r'\n\n\n', s)
def processFileContent(self, document, s):
s = BaseRenderer.processFileContent(self, document, s)
# Put block level elements back in
block_re = re.compile('(\\s*)\001\\[(\\d+)@+\\]')
while 1:
m = block_re.search(s)
if not m:
break
space = ''
before = m.group(1)
if before is None:
before = ''
if '\n' in before:
spaces = before.split('\n')
space = spaces.pop()
before = '\n'.join(spaces) + '\n'
block = self.blocks[int(m.group(2))]
block = space + block.replace('\n', u'\n%s' % space)
s = block_re.sub('%s%s' % (before, block), s, 1)
# Clean up newlines
return re.sub(r'\s*\n\s*\n(\s*\n)+', r'\n\n\n', s)
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
# Load dictionary with methods
for key in vars(type(self)):
if key.startswith("do__"):
self[self.aliases[key[4:]]] = getattr(self, key)
elif key.startswith("do_"):
self[key[3:]] = getattr(self, key)
self.indent = 0
self.in_func = False
self.in_cvarg = False
self.descriptions = 0
self.after_parameters = False
self.func_short_desc = ""
def processFileContent(self, document, s):
# process the bibliography information
s = BaseRenderer.processFileContent(self, document, s)
# Put block level elements back in
block_re = re.compile('(\\s*)\001\\[(\\d+)@+\\]')
while 1:
m = block_re.search(s)
if not m:
break
space = ''
before = m.group(1)
if before is None:
before = ''
if '\n' in before:
spaces = before.split('\n')
space = spaces.pop()
before = '\n'.join(spaces) + '\n'
block = self.blocks[int(m.group(2))]
block = space + block.replace('\n', u'\n%s' % space)
s = block_re.sub('%s%s' % (before, block), s, 1)
# Hack to allow eqref to work
s = re.sub(r'(\\eqref) ([^\s,.]+)', r'\1{\2}', s)
# Remove single spaces at beginning of lines
# Some in-line equations are not handled correctly
s1 = re.sub(r'^\s(\S)', r'\1', s, flags=re.MULTILINE)
# Clean up newlines
return re.sub(r'\s*\n\s*\n(\s*\n)+', r'\n\n\n', s1)
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
self.engines = {}
htmlexts = ['.html','.htm','.xhtml','.xhtm','.zpt']
self.registerEngine('zpt', None, htmlexts, htmltemplate)
self.registerEngine('zpt', 'xml', '.xml', xmltemplate)
self.registerEngine('tal', None, htmlexts, htmltemplate)
self.registerEngine('tal', 'xml', '.xml', xmltemplate)
self.registerEngine('html', None, htmlexts, htmltemplate)
self.registerEngine('xml', 'xml', '.xml', xmltemplate)
self.registerEngine('python', None, '.pyt', pythontemplate)
self.registerEngine('string', None, '.st', stringtemplate)
self.registerEngine('kid', None, '.kid', kidtemplate)
self.registerEngine('cheetah', None, '.che', cheetahtemplate)
self.registerEngine('genshi', None, '.gen', genshihtmltemplate)
self.registerEngine('genshi', 'xml', '.genx', genshixmltemplate)
self.registerEngine('genshi', 'text', '.gent', genshitexttemplate)
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
self.engines = {}
htmlexts = [".html", ".htm", ".xhtml", ".xhtm", ".zpt", ".pt"]
self.registerEngine("pt", None, htmlexts, htmltemplate)
self.registerEngine("zpt", None, htmlexts, htmltemplate)
self.registerEngine("zpt", "xml", ".xml", xmltemplate)
self.registerEngine("tal", None, htmlexts, htmltemplate)
self.registerEngine("tal", "xml", ".xml", xmltemplate)
self.registerEngine("html", None, htmlexts, htmltemplate)
self.registerEngine("xml", "xml", ".xml", xmltemplate)
self.registerEngine("python", None, ".pyt", pythontemplate)
self.registerEngine("string", None, ".st", stringtemplate)
self.registerEngine("kid", None, ".kid", kidtemplate)
self.registerEngine("cheetah", None, ".che", cheetahtemplate)
self.registerEngine("genshi", None, ".gen", genshihtmltemplate)
self.registerEngine("genshi", "xml", ".genx", genshixmltemplate)
self.registerEngine("genshi", "text", ".gent", genshitexttemplate)
def processFileContent(self, document, s):
s = BaseRenderer.processFileContent(self, document, s)
# Clean up newlines
s = re.sub(r'\s*\n(\s*\n)+', r'\n\n', s)
s = re.sub(r'(\s*\n)+(\.B[ld])', r'\n\2', s)
s = re.sub(r'(\.E[ld])\s*(\.B[ld])', r'\1\n\n\2', s)
s = re.sub(r'\.Ed\s*\.Bd', r'.Ed\n.Bd', s)
s = s.lstrip()
return s
def processFileContent(self, document, s):
s = BaseRenderer.processFileContent(self, document, s)
# Clean up newlines
s = re.sub(r'\s*\n(\s*\n)+', r'\n\n', s)
s = re.sub(r'(\s*\n)+(\.B[ld])', r'\n\2', s)
s = re.sub(r'(\.E[ld])\s*(\.B[ld])', r'\1\n\n\2', s)
s = re.sub(r'\.Ed\s*\.Bd', r'.Ed\n.Bd', s)
s = s.lstrip()
return s
def test_todo_disable(tmpdir):
renderer = Renderer()
def render_todo(obj):
if obj.ownerDocument.todoNotesDisable:
return "disabled"
else:
return str(obj.attributes["todo"])
renderer["todo"] = render_todo
enabled = r'''
\documentclass{article}
\usepackage{todonotes}
\begin{document}
\todo{foo}
\end{document}
'''
disabled = r'''
\documentclass{article}
\usepackage[disable]{todonotes}
\begin{document}
\todo{foo}
\end{document}
'''
with tmpdir.as_cwd():
renderer.render(TeX().input(enabled).parse())
assert Path("index").read_text().strip() == "foo"
renderer.render(TeX().input(disabled).parse())
assert Path("index").read_text().strip() == "disabled"
def processFileContent(self, document, s):
# Add width, height, and depth to images
s = re.sub(r"&(\S+)-(width|height|depth);(?:&([a-z]+);)?", self.setImageData, s)
# Convert characters >127 to entities
if document.config["files"]["escape-high-chars"]:
s = list(s)
for i, item in enumerate(s):
if ord(item) > 127:
s[i] = "&#%.3d;" % ord(item)
s = u"".join(s)
return BaseRenderer.processFileContent(self, document, s)
def processFileContent(self, document, s):
# Add width, height, and depth to images
s = re.sub(r'&(\S+)-(width|height|depth);(?:&([a-z]+);)?',
self.setImageData, s)
# Convert characters >127 to entities
if document.config['files']['escape-high-chars']:
s = list(s)
for i, item in enumerate(s):
if ord(item) > 127:
s[i] = '&#%.3d;' % ord(item)
s = ''.join(s)
return BaseRenderer.processFileContent(self, document, s)
def processFileContent(self, document, s):
# Convert characters >127 to entities
if document.config['files']['escape-high-chars']:
s = list(s)
for i, item in enumerate(s):
if ord(item) > 127:
s[i] = '&#%.3d;' % ord(item)
s = ''.join(s)
# Remove empty paragraphs
s = EMPTY_PARAGRAPH.sub(r'', s)
# Add a non-breaking space to empty table cells
s = TABLE_NBSP.sub(r'\1 \3', s)
return BaseRenderer.processFileContent(self, document, s)
def processFileContent(self, document, s):
# Add width, height, and depth to images
s = re.sub(r'&(\S+)-(width|height|depth);(?:&([a-z]+);)?',
self.setImageData, s)
# Convert characters >127 to entities
if document.config['files']['escape-high-chars']:
s = list(s)
for i, item in enumerate(s):
if ord(item) > 127:
s[i] = '&#%.3d;' % ord(item)
s = ''.join(s)
# Remove empty paragraphs
s = re.compile(r'<p>\s*</p>', re.I).sub(r'', s)
# Add a non-breaking space to empty table cells
s = re.compile(r'(<(td|th)\b[^>]*>)\s*(</\2>)', re.I).sub(r'\1 \3', s)
return BaseRenderer.processFileContent(self, document, s)
def test_imager(enable_bitmap, tmpdir):
with tmpdir.as_cwd():
tex = TeX()
tex.ownerDocument.config['images']["imager"] = "none"
tex.ownerDocument.config['images']["vector-imager"] = "pdf2svg"
tex.input(r'''
\documentclass{article}
\begin{document}
$a + b = x$
\end{document}
''')
doc = tex.parse()
renderer = Renderer()
renderer.imager = NullImager(doc)
renderer.vectorBitmap = enable_bitmap
renderer['math'] = lambda node: node.vectorImage.url
if enable_bitmap:
with pytest.raises(ValueError):
renderer.render(doc)
else:
renderer.render(doc)
latexcontent = r'''\documentclass{book}
\usepackage{latex2cnxmlmod}
\usepackage{longtable}
\begin{document}
%s
\end{document}''' % latexcontent
tex = TeX.TeX()
tex.ownerDocument.config['files']['split-level'] = -100
tex.ownerDocument.config['files']['filename'] = '%s.xml' % inputfile
tex.input(latexcontent)
document = tex.parse()
# Render the document
renderer = Renderer()
renderer['chapter'] = renderer.section
renderer['section'] = renderer.section
renderer['subsection'] = renderer.section
renderer['subsubsection'] = renderer.section
renderer['par'] = renderer.par
renderer['itemize'] = renderer.itemize
renderer['keyconcepts'] = renderer.keyconcepts
renderer['newwords'] = renderer.newwords
renderer['bgroup'] = renderer.bgroup
renderer['textbf'] = renderer.textbf
renderer['textit'] = renderer.textit
renderer['displaymath'] = renderer.displaymath
renderer['textrm'] = renderer.textrm
renderer['active::_'] = renderer.sub
renderer['center'] = renderer.center
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
def render(self, document):
""" Load templates and render the document """
BaseRenderer.render(self, document)
def textDefault(self, node):
""" Rendering method for all text nodes """
return node.replace('&','&').replace('<','<').replace('>','>')
# Instantiate a TeX processor and parse the input text
fn = sys.argv[1]
print "fn=",fn
tex = TeX()
tex.ownerDocument.config['files']['split-level'] = -100
tex.ownerDocument.config['files']['filename'] = fn+'.wiki'
tex.ownerDocument.context.importMacros({1:BOX})
tex.ownerDocument.context.importMacros({2:inlinepsfig})
tex.ownerDocument.context.importMacros({3:matrix})
tex.ownerDocument.context.importMacros({4:wikitext})
ifn = fn + '.tex'
tex.input(open(ifn).read())
document = tex.parse()
# Render the document
renderer = Renderer()
renderer.render(document)
#print document
def render(self, document):
""" Load templates and render the document """
self.loadTemplates(document)
BaseRenderer.render(self, document)
def __init__(self, *args, **kwargs):
BaseRenderer.__init__(self, *args, **kwargs)
htmlexts = ['.html','.htm','.xhtml','.xhtm','.zpt','.pt']
def __getitem__(self, key):
print "Attempting to obtain %s"%key
return BaseRenderer.__getitem__(self, key)
def test_tikz(tmpdir):
try:
tmpdir = Path(tmpdir)
except TypeError: # Fallback for older python
tmpdir = Path(str(tmpdir))
root = Path(__file__).parent
test_id = "tikz-pdf2svg-gspdfpng"
benchdir = root / "benchmarks" / test_id
newdir = root / "new" / test_id
images = ["images/img-0001.svg", "images/img-0002.svg", "images/img-0001.png", "images/img-0002.png"]
config = base_config.copy()
config['images']['vector-imager'] = 'pdf2svg'
config['images']['imager'] = 'gspdfpng'
doc = TeXDocument(config=config)
tex = TeX(doc)
tex.input(r'''
\documentclass{article}
\usepackage{tikz}
\usepackage{tikz-cd}
\begin{document}
\begin{tikzpicture}
\draw (0, 0) -- (0, 2) -- (2, 0) -- (0, 0);
\end{tikzpicture}
\begin{tikzcd}
A \ar[r, "i"] & B \ar[d, "p"] \\ & C
\end{tikzcd}
\end{document}
''')
renderer = Renderer()
def render_image(obj):
return "{}\n{}\n".format(obj.vectorImage.url, obj.image.url)
renderer["tikzpicture"] = render_image
renderer["tikzcd"] = render_image
cwd = os.getcwd()
os.chdir(str(tmpdir))
renderer.render(tex.parse())
os.chdir(cwd)
def new_file(base: str):
newfile = newdir / base
newfile.parent.mkdir(parents=True, exist_ok=True)
shutil.copy(str(tmpdir / base), str(newfile))
# Compare image output
error = False
try:
if not filecmp.cmp(str(tmpdir / "index"), str(benchdir / "index"), shallow=False):
print('Differences were found: index', file=sys.stderr)
error = True
new_file("index")
except FileNotFoundError as e:
error = True
if e.filename == str(tmpdir / "index"):
print("Missing output file: index", file=sys.stderr)
else:
print("Missing benchmark file: index", file=sys.stderr)
new_file("index")
for f in images:
if not (tmpdir / f).exists():
error = True
print('Missing output file: %s' % f, file=sys.stderr)
elif not (benchdir / f).exists():
error = True
print('Missing benchmark file: %s' % f, file=sys.stderr)
new_file(f)
diff = cmp_img(str(tmpdir / f), str(benchdir / f))
if diff > 0.0001:
error = True
print('Differences were found: {} ({})'.format(f, diff), file=sys.stderr)
new_file(f)
if error:
assert False
def render(self, document):
""" Load templates and render the document """
self.loadTemplates(document)
BaseRenderer.render(self, document)