def add_node(self, node, **kwds):
self.debug('[app] adding node: %r', (node, kwds))
if not kwds.pop('override', False) and \
hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
self.warn('while setting up extension %s: node class %r is '
'already registered, its visitors will be overridden' %
(self._setting_up_extension, node.__name__))
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
translator = self._translators.get(key)
if translator is not None:
pass
elif key == 'html':
from sphinx.writers.html import HTMLTranslator as translator
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator as translator
elif key == 'text':
from sphinx.writers.text import TextTranslator as translator
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator \
as translator
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator \
as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' + node.__name__, depart)
def add_node(self, node, **kwds):
self.debug('[app] adding node: %r', (node, kwds))
nodes._add_node_class_names([node.__name__])
for key, val in kwds.iteritems():
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
if key == 'html':
from sphinx.writers.html import HTMLTranslator as translator
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator as translator
elif key == 'text':
from sphinx.writers.text import TextTranslator as translator
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator \
as translator
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator \
as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' + node.__name__, depart)
def add_node(self, node, **kwds):
self.debug('[app] adding node: %r', (node, kwds))
if not kwds.pop('override', False) and \
hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
self.warn('while setting up extension %s: node class %r is '
'already registered, its visitors will be overridden' %
(self._setting_up_extension, node.__name__))
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
translator = self._translators.get(key)
if translator is not None:
pass
elif key == 'html':
from sphinx.writers.html import HTMLTranslator as translator
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator as translator
elif key == 'text':
from sphinx.writers.text import TextTranslator as translator
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator \
as translator
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator \
as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_'+node.__name__, visit)
if depart:
setattr(translator, 'depart_'+node.__name__, depart)
def add_node(self, node, **kwds):
self.debug("[app] adding node: %r", (node, kwds))
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError("Value for key %r must be a " "(visit, depart) function tuple" % key)
translator = self._translators.get(key)
if translator is not None:
pass
elif key == "html":
from sphinx.writers.html import HTMLTranslator as translator
elif key == "latex":
from sphinx.writers.latex import LaTeXTranslator as translator
elif key == "text":
from sphinx.writers.text import TextTranslator as translator
elif key == "man":
from sphinx.writers.manpage import ManualPageTranslator as translator
elif key == "texinfo":
from sphinx.writers.texinfo import TexinfoTranslator as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, "visit_" + node.__name__, visit)
if depart:
setattr(translator, "depart_" + node.__name__, depart)
def add_node(self, node, **kwds):
self.debug('[app] adding node: %r', (node, kwds))
nodes._add_node_class_names([node.__name__])
for key, val in kwds.iteritems():
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
if key == 'html':
from sphinx.writers.html import HTMLTranslator as translator
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator as translator
elif key == 'text':
from sphinx.writers.text import TextTranslator as translator
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator \
as translator
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator \
as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_'+node.__name__, visit)
if depart:
setattr(translator, 'depart_'+node.__name__, depart)
def add_node(self, node, **kwds):
self.debug("[app] adding node: %r", (node, kwds))
if not kwds.pop("override", False) and hasattr(nodes.GenericNodeVisitor, "visit_" + node.__name__):
self.warn(
"while setting up extension %s: node class %r is "
"already registered, its visitors will be overridden" % (self._setting_up_extension, node.__name__)
)
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError("Value for key %r must be a " "(visit, depart) function tuple" % key)
translator = self._translators.get(key)
if translator is not None:
pass
elif key == "html":
from sphinx.writers.html import HTMLTranslator as translator
elif key == "latex":
from sphinx.writers.latex import LaTeXTranslator as translator
elif key == "text":
from sphinx.writers.text import TextTranslator as translator
elif key == "man":
from sphinx.writers.manpage import ManualPageTranslator as translator
elif key == "texinfo":
from sphinx.writers.texinfo import TexinfoTranslator as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, "visit_" + node.__name__, visit)
if depart:
setattr(translator, "depart_" + node.__name__, depart)
def install_node_class_names():
node_class_names = []
for name, var in globals().items():
if type(var) is types.ClassType and issubclass(var, PythonStructural) and name.lower() == name:
node_class_names.append(var.tagname or name)
# Register the new node names with GenericNodeVisitor and
# SpecificNodeVisitor:
nodes._add_node_class_names(node_class_names)
def add_node(node_name, visit_function=None, depart_function=None):
"""Register a Docutils node class.
"""
nodes._add_node_class_names([node_name])
if visit_function is not None:
setattr(docutils.writers._html_base.HTMLTranslator, 'visit_' + node_name, visit_function)
if depart_function is not None:
setattr(docutils.writers._html_base.HTMLTranslator, 'depart_' + node_name, depart_function)
def register_node(node: "Type[Element]") -> None:
"""Register a node to docutils.
This modifies global state of some visitors. So it is better to use this
inside ``docutils_namespace()`` to prevent side-effects.
"""
if not hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
nodes._add_node_class_names([node.__name__]) # type: ignore
additional_nodes.add(node)
def install_node_class_names():
node_class_names = []
for name, var in globals().items():
if (type(var) is types.ClassType
and issubclass(var, PythonStructural) \
and name.lower() == name):
node_class_names.append(var.tagname or name)
# Register the new node names with GenericNodeVisitor and
# SpecificNodeVisitor:
nodes._add_node_class_names(node_class_names)
def register_node(node):
# type: (nodes.Node) -> None
"""Register a node to docutils.
This modifies global state of some visitors. So it is better to use this
inside ``docutils_namespace()`` to prevent side-effects.
"""
if not hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
nodes._add_node_class_names([node.__name__])
additional_nodes.add(node)
def add_node(node, **kwds):
nodes._add_node_class_names([node.__name__])
for key, val in kwds.items():
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
assert key == 'html', 'accept html only'
setattr(RST2RevealTranslator, 'visit_'+node.__name__, visit)
setattr(RST2RevealTranslator, 'depart_'+node.__name__, depart)
def add_node(node, **kwds):
nodes._add_node_class_names([node.__name__])
for key, val in kwds.items():
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
assert key == 'html', 'accept html only'
setattr(RST2RevealTranslator, 'visit_' + node.__name__, visit)
setattr(RST2RevealTranslator, 'depart_' + node.__name__, depart)
def register_pylatest_nodes():
"""
Register custom pylatest nodes for test step and resutl sections.
These custom nodes are used to wrap content of pylatest directives into div
or span elements.
"""
nodes._add_node_class_names(pylatest.xdocutils.nodes.node_class_names)
for node_name in pylatest.xdocutils.nodes.node_class_names:
visit_func_name = "visit_" + node_name
depart_func_name = "depart_" + node_name
setattr(HTMLTranslator, visit_func_name,
getattr(pylatest.xdocutils.htmltranslator, visit_func_name))
setattr(HTMLTranslator, depart_func_name,
getattr(pylatest.xdocutils.htmltranslator, depart_func_name))
def register_pylatest_nodes():
"""
Register (actually inject, this is kind of a hack) custom pylatest nodes
into html4css1.HTMLTranslator. These custom nodes are used to wrap content
of pylatest directives into div or span elements.
"""
nodes._add_node_class_names(pylatest.xdocutils.nodes.node_class_names)
for node_name in pylatest.xdocutils.nodes.node_class_names:
visit_func_name = "visit_" + node_name
depart_func_name = "depart_" + node_name
setattr(HTMLTranslator, visit_func_name,
getattr(pylatest.xdocutils.htmltranslator, visit_func_name))
setattr(HTMLTranslator, depart_func_name,
getattr(pylatest.xdocutils.htmltranslator, depart_func_name))
def add_node(self, node, **kwds):
# type: (nodes.Node, Any) -> None
logger.debug('[app] adding node: %r', (node, kwds))
if not kwds.pop('override', False) and \
hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
logger.warning(__(
'while setting up extension %s: node class %r is '
'already registered, its visitors will be overridden'),
self._setting_up_extension,
node.__name__,
type='app',
subtype='add_node')
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError(
__('Value for key %r must be a '
'(visit, depart) function tuple') % key)
translator = self.registry.translators.get(key)
translators = []
if translator is not None:
translators.append(translator)
elif key == 'html':
from sphinx.writers.html import HTMLTranslator
translators.append(HTMLTranslator)
if is_html5_writer_available():
from sphinx.writers.html5 import HTML5Translator
translators.append(HTML5Translator)
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator
translators.append(LaTeXTranslator)
elif key == 'text':
from sphinx.writers.text import TextTranslator
translators.append(TextTranslator)
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator
translators.append(ManualPageTranslator)
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator
translators.append(TexinfoTranslator)
for translator in translators:
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' + node.__name__, depart)
def add_node(self, node, **kwds):
"""
See :epkg:`class Sphinx`.
"""
# type: (nodes.Node, Any) -> None
nodes._add_node_class_names([node.__name__])
for key, val in kwds.items():
if not isinstance(val, tuple):
continue
visit, depart = val
translator = self.writer.app.registry.translators.get(key)
translators = []
if translator is not None:
translators.append(translator)
elif key == 'html':
from sphinx.writers.html import HTMLTranslator
translators.append(HTMLTranslator)
if is_html5_writer_available():
from sphinx.writers.html5 import HTML5Translator
translators.append(HTML5Translator)
elif key == 'latex':
try:
from sphinx.writers.latex import LaTeXTranslator
except ImportError:
# Since sphinx 1.7.3 (circular reference).
import sphinx.builders.latex.transforms
from sphinx.writers.latex import LaTeXTranslator
translators.append(LaTeXTranslator)
elif key == 'text':
from sphinx.writers.text import TextTranslator
translators.append(TextTranslator)
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator
translators.append(ManualPageTranslator)
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator
translators.append(TexinfoTranslator)
for translator in translators:
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' +
node.__name__, depart)
def add_node(self, node, **kwds):
# type: (nodes.Node, Any) -> None
logger.debug('[app] adding node: %r', (node, kwds))
if not kwds.pop('override', False) and \
hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
logger.warning(__('while setting up extension %s: node class %r is '
'already registered, its visitors will be overridden'),
self._setting_up_extension, node.__name__,
type='app', subtype='add_node')
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError(__('Value for key %r must be a '
'(visit, depart) function tuple') % key)
translator = self.registry.translators.get(key)
translators = []
if translator is not None:
translators.append(translator)
elif key == 'html':
from sphinx.writers.html import HTMLTranslator
translators.append(HTMLTranslator)
if is_html5_writer_available():
from sphinx.writers.html5 import HTML5Translator
translators.append(HTML5Translator)
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator
translators.append(LaTeXTranslator)
elif key == 'text':
from sphinx.writers.text import TextTranslator
translators.append(TextTranslator)
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator
translators.append(ManualPageTranslator)
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator
translators.append(TexinfoTranslator)
for translator in translators:
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' + node.__name__, depart)
def add_node(self, node, **kwds):
nodes._add_node_class_names([node.__name__])
for key, val in kwds.iteritems():
try:
visit, depart = val
except ValueError:
raise ExtensionError('Value for key %r must be a (visit, depart) '
'function tuple' % key)
if key == 'html':
from sphinx.htmlwriter import HTMLTranslator as translator
elif key == 'latex':
from sphinx.latexwriter import LaTeXTranslator as translator
elif key == 'text':
from sphinx.textwriter import TextTranslator as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_'+node.__name__, visit)
if depart:
setattr(translator, 'depart_'+node.__name__, depart)
def add_node(node, **kwds):
"""add_node from Sphinx
"""
nodes._add_node_class_names([node.__name__])
for key, val in list(kwds.items()):
try:
visit, depart = val
except ValueError:
raise ValueError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
if key == 'html':
from docutils.writers.html4css1 import HTMLTranslator as translator
elif key == 'latex':
from docutils.writers.latex2e import LaTeXTranslator as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' + node.__name__, depart)
def add_node(node, **kwds):
"""add_node from Sphinx
"""
nodes._add_node_class_names([node.__name__])
for key, val in kwds.iteritems():
try:
visit, depart = val
except ValueError:
raise ValueError('Value for key %r must be a '
'(visit, depart) function tuple' % key)
if key == 'html':
from docutils.writers.html4css1 import HTMLTranslator as translator
elif key == 'latex':
from docutils.writers.latex2e import LaTeXTranslator as translator
else:
# ignore invalid keys for compatibility
continue
setattr(translator, 'visit_'+node.__name__, visit)
if depart:
setattr(translator, 'depart_'+node.__name__, depart)
def init(settings):
"""Initialise and load the docutils extensions.
"""
directives.register_directive('sourcecode', Pygments)
directives.register_directive('youtube', YouTube)
directives.register_directive('quiz', Quiz)
directives.register_directive('quiz-question', QuizQuestion)
directives.register_directive('show-hide', ShowHideBlock)
roles.register_local_role('asset', asset_ref_role)
roles.register_local_role('crossref', crossref_role)
roles.register_local_role('style', inline_css_role)
for _, aliases, _, _ in get_all_lexers():
for alias in aliases:
roles.register_local_role('code-%s' % (alias),
inline_pygments_role)
nodes._add_node_class_names([HtmlElementBlock.__name__])
setattr(HTMLTranslator, 'visit_%s' % HtmlElementBlock.__name__,
visit_htmlelementblock)
setattr(HTMLTranslator, 'depart_%s' % HtmlElementBlock.__name__,
depart_htmlelementblock)
class toctree(nodes.General, nodes.Element):
pass
# centered
class centered(nodes.Part, nodes.Element):
pass
# pending xref
class pending_xref(nodes.Element):
pass
# compact paragraph -- never makes a <p>
class compact_paragraph(nodes.paragraph):
pass
# sets the highlighting language for literal blocks
class highlightlang(nodes.Element):
pass
# make them known to docutils. this is needed, because the HTMl writer
# will choke at some point if these are not added
nodes._add_node_class_names("""index desc desc_content desc_signature
desc_classname desc_name desc_parameterlist desc_parameter desc_optional
centered versionmodified seealso productionlist production toctree
pending_xref compact_paragraph highlightlang""".split())
self.body.append(self.starttag(node, 'abbr', '', **attrs))
def depart_abbreviation(self, node):
self.body.append('</abbr>')
def visit_kbd(self, node):
self.body.append(self.starttag(node, 'kbd', ''))
def depart_kbd(self, node):
self.body.append('</kbd>')
class kbd(nodes.Inline, nodes.TextElement):
"""Node for kbd element"""
nodes._add_node_class_names('kbd')
def inline_roles(role, raw, text, *args):
if role == 'kbd':
return [kbd('kbd', text)], []
elif role == 'var':
return [nodes.literal('var', text)], []
roles.register_local_role('kbd', inline_roles)
roles.register_local_role('var', inline_roles)
# FIXME: this has to be lowercase for some reason
class abbreviation(nodes.Inline, nodes.TextElement):
"""Node for abbreviations with explanations."""
nodes._add_node_class_names('abbreviation')
from docutils import nodes as basenodes class Abbreviation(basenodes.Inline, basenodes.TextElement): pass class Url(basenodes.Inline, basenodes.TextElement): pass class File(basenodes.Inline, basenodes.TextElement): pass class Command(basenodes.Inline, basenodes.TextElement): pass basenodes._add_node_class_names(["Abbreviation", "Url", "File", "Command"])
pass
# module declaration
class module(nodes.Element):
pass
# start of a file, used in the LaTeX builder only
class start_of_file(nodes.Element):
pass
# tabular column specification, used for the LaTeX writer
class tabular_col_spec(nodes.Element):
pass
# meta directive -- same as docutils' standard meta node, but pickleable
class meta(nodes.Special, nodes.PreBibliographic, nodes.Element):
pass
# make them known to docutils. this is needed, because the HTML writer
# will choke at some point if these are not added
nodes._add_node_class_names("""index desc desc_content desc_signature desc_type
desc_addname desc_name desc_parameterlist desc_parameter desc_optional
centered versionmodified seealso productionlist production toctree
pending_xref compact_paragraph highlightlang literal_emphasis
glossary acks module start_of_file tabular_col_spec meta""".split())
# Allow breaks at whitespace:
self.body.append(token)
else:
# Protect runs of multiple spaces; the last space can wrap:
self.body.append(' ' * (len(token) - 1) + ' ')
self.body.append('</code>')
# Content already processed:
raise nodes.SkipNode
def depart_literal(self, node):
# skipped unless literal element is from "code" role:
self.body.append('</code>')
class kbd(nodes.Inline, nodes.TextElement):
"""Node for kbd element"""
def inline_roles(role, raw, text, *args):
if role == 'kbd':
return [kbd('kbd', text)], []
nodes._add_node_class_names('kbd')
roles.register_local_role('kbd', inline_roles)
if __name__ == '__main__':
import sys
parts = publish_parts(writer=Writer(), source=open(sys.argv[1]).read())
print(parts['html_body'])
def add_node(self, node, **kwds):
# type: (nodes.Node, Any) -> None
"""Register a Docutils node class.
This is necessary for Docutils internals. It may also be used in the
future to validate nodes in the parsed documents.
Node visitor functions for the Sphinx HTML, LaTeX, text and manpage
writers can be given as keyword arguments: the keyword should be one or
more of ``'html'``, ``'latex'``, ``'text'``, ``'man'``, ``'texinfo'``
or any other supported translators, the value a 2-tuple of ``(visit,
depart)`` methods. ``depart`` can be ``None`` if the ``visit``
function raises :exc:`docutils.nodes.SkipNode`. Example:
.. code-block:: python
class math(docutils.nodes.Element): pass
def visit_math_html(self, node):
self.body.append(self.starttag(node, 'math'))
def depart_math_html(self, node):
self.body.append('</math>')
app.add_node(math, html=(visit_math_html, depart_math_html))
Obviously, translators for which you don't specify visitor methods will
choke on the node when encountered in a document to translate.
.. versionchanged:: 0.5
Added the support for keyword arguments giving visit functions.
"""
logger.debug('[app] adding node: %r', (node, kwds))
if not kwds.pop('override', False) and \
hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
logger.warning(__('while setting up extension %s: node class %r is '
'already registered, its visitors will be overridden'),
self._setting_up_extension, node.__name__,
type='app', subtype='add_node')
nodes._add_node_class_names([node.__name__])
for key, val in iteritems(kwds):
try:
visit, depart = val
except ValueError:
raise ExtensionError(__('Value for key %r must be a '
'(visit, depart) function tuple') % key)
translator = self.registry.translators.get(key)
translators = []
if translator is not None:
translators.append(translator)
elif key == 'html':
from sphinx.writers.html import HTMLTranslator
translators.append(HTMLTranslator)
if is_html5_writer_available():
from sphinx.writers.html5 import HTML5Translator
translators.append(HTML5Translator)
elif key == 'latex':
from sphinx.writers.latex import LaTeXTranslator
translators.append(LaTeXTranslator)
elif key == 'text':
from sphinx.writers.text import TextTranslator
translators.append(TextTranslator)
elif key == 'man':
from sphinx.writers.manpage import ManualPageTranslator
translators.append(ManualPageTranslator)
elif key == 'texinfo':
from sphinx.writers.texinfo import TexinfoTranslator
translators.append(TexinfoTranslator)
for translator in translators:
setattr(translator, 'visit_' + node.__name__, visit)
if depart:
setattr(translator, 'depart_' + node.__name__, depart)
def setup():
'add support for math to docutils'
nodes._add_node_class_names(['math', 'displaymath', 'eqref'])
roles.register_local_role('math', math_role)
roles.register_local_role('eq', eq_role)
directives.register_directive('math', directive_dwim(MathDirective2))
self.body.append(self.starttag(node, 'abbr', '', **attrs))
def depart_abbreviation(self, node):
self.body.append('</abbr>')
def visit_kbd(self, node):
self.body.append(self.starttag(node, 'kbd', ''))
def depart_kbd(self, node):
self.body.append('</kbd>')
class kbd(nodes.Inline, nodes.TextElement):
"""Node for kbd element"""
nodes._add_node_class_names('kbd')
def inline_roles(role, raw, text, *args):
if role == 'kbd':
return [kbd('kbd', text)], []
elif role == 'var':
return [nodes.literal('var', text)], []
roles.register_local_role('kbd', inline_roles)
roles.register_local_role('var', inline_roles)
# FIXME: this has to be lowercase for some reason
class abbreviation(nodes.Inline, nodes.TextElement):
pass
class source(nodes.General, nodes.Inline, nodes.Element):
pass
class video(nodes.image):
pass
class track(nodes.General, nodes.Inline, nodes.Element):
pass
nodes._add_node_class_names(('audio', 'source', 'video', 'track'))
"""
Create base class 'Media'.
This is the parent class to the Audio, Video and Image directives.
"""
class Media(
Directive
): # just define shared options and useful functions. Doesn't actually create nodes.
messages = []
contraindications = ('align', 'height', 'scale', 'width', 'no_fullscreen')
crossorigin = True
def style_check(arg):
if arg and arg.strip():
class compact_paragraph(nodes.paragraph): pass
# for the ACKS list
class acks(nodes.Element): pass
# sets the highlighting language for literal blocks
class highlightlang(nodes.Element): pass
# like emphasis, but doesn't apply further text processors, e.g. smartypants
class literal_emphasis(nodes.emphasis): pass
# glossary
class glossary(nodes.Element): pass
# module declaration
class module(nodes.Element): pass
# start of a file, used in the LaTeX builder only
class start_of_file(nodes.Element): pass
# tabular column specification, used for the LaTeX writer
class tabular_col_spec(nodes.Element): pass
# make them known to docutils. this is needed, because the HTML writer
# will choke at some point if these are not added
nodes._add_node_class_names("""index desc desc_content desc_signature desc_type
desc_addname desc_name desc_parameterlist desc_parameter desc_optional
centered versionmodified seealso productionlist production toctree
pending_xref compact_paragraph highlightlang literal_emphasis
glossary acks module start_of_file tabular_col_spec""".split())
def add_node(self, node):
nodes._add_node_class_names([node.__name__])
# Assume image paths are relative to the container
for node in doctree.traverse(condition=nodes.image):
reference = get_reference(node['uri'].encode('utf_8'))
# Skip external
if is_external(reference):
continue
# Strip the view
path = reference.path
if path[-1][0] == ';':
path = path[:-1]
# Resolve absolute path
resource = parent.get_resource(path, soft=True)
if resource is not None:
node['uri'] = str(resource.abspath)
return doctree
def get_book(self):
doctree = self.get_doctree()
return doctree.next_node(condition=nodes.book)
# Register dummy book directive for ODT export
nodes._add_node_class_names(['book'])
nodes.book = book
register_directive('book', Book)
labels['book'] = ''
def add_node(node, **kwds):
nodes._add_node_class_names([node.__name__])
def add_node(node, **kwds):
nodes._add_node_class_names([node.__name__])
def setup():
'add support for math to docutils'
nodes._add_node_class_names(['math', 'displaymath', 'eqref'])
roles.register_local_role('math', math_role)
roles.register_local_role('eq', eq_role)
directives.register_directive('math', directive_dwim(MathDirective2))
class download_reference(nodes.reference):
"""Node for download references, similar to pending_xref."""
class literal_emphasis(nodes.emphasis):
"""Node that behaves like `emphasis`, but further text processors are not
applied (e.g. smartypants for HTML output).
"""
class literal_strong(nodes.strong):
"""Node that behaves like `strong`, but further text processors are not
applied (e.g. smartypants for HTML output).
"""
class abbreviation(nodes.Inline, nodes.TextElement):
"""Node for abbreviations with explanations."""
class termsep(nodes.Structural, nodes.Element):
"""Separates two terms within a <term> node."""
# make the new nodes known to docutils; needed because the HTML writer will
# choke at some point if these are not added
nodes._add_node_class_names(k for k in globals().keys()
if k != 'nodes' and k[0] != '_')
information about all documents.
These nodes are resolved before writing output, in
BuildEnvironment.resolve_references.
"""
class download_reference(nodes.reference):
"""Node for download references, similar to pending_xref."""
class literal_emphasis(nodes.emphasis):
"""Node that behaves like `emphasis`, but further text processors are not
applied (e.g. smartypants for HTML output).
"""
class literal_strong(nodes.strong):
"""Node that behaves like `strong`, but further text processors are not
applied (e.g. smartypants for HTML output).
"""
class abbreviation(nodes.Inline, nodes.TextElement):
"""Node for abbreviations with explanations."""
class termsep(nodes.Structural, nodes.Element):
"""Separates two terms within a <term> node."""
# make the new nodes known to docutils; needed because the HTML writer will
# choke at some point if these are not added
nodes._add_node_class_names(k for k in globals().keys()
if k != 'nodes' and k[0] != '_')
class versionmodified(nodes.Admonition, nodes.TextElement): pass
# seealso
class seealso(nodes.Admonition, nodes.Element): pass
# productionlist
class productionlist(nodes.Admonition, nodes.Element): pass
class production(nodes.Part, nodes.Inline, nodes.TextElement): pass
# toc tree
class toctree(nodes.General, nodes.Element): pass
# centered
class centered(nodes.Part, nodes.Element): pass
# pending xref
class pending_xref(nodes.Element): pass
# compact paragraph -- never makes a <p>
class compact_paragraph(nodes.paragraph): pass
# sets the highlighting language for literal blocks
class highlightlang(nodes.Element): pass
# make them known to docutils. this is needed, because the HTMl writer
# will choke at some point if these are not added
nodes._add_node_class_names("""index desc desc_content desc_signature
desc_classname desc_name desc_parameterlist desc_parameter desc_optional
centered versionmodified seealso productionlist production toctree
pending_xref compact_paragraph highlightlang""".split())
generic_docroles = sroles.generic_docroles
specific_docroles = sroles.specific_docroles
for rolename, nodeclass in generic_docroles.items():
generic = roles.GenericRole(rolename, nodeclass)
role = roles.CustomRole(rolename, generic, {'classes': [rolename]})
roles.register_local_role(rolename, role)
for rolename, func in specific_docroles.items():
roles.register_local_role(rolename, func)
print [k for k in dir(addnodes) if k != 'nodes' and k[0] != '_']
nodes._add_node_class_names(k for k in dir(addnodes) if k != 'nodes' and k[0] != '_')
def dummy_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
return [], []
def test():
register_sphinx_support()
writer = MyWriter()
fname = os.path.join(os.path.dirname(__file__), '..', 'README.rst')
output = core.publish_file(source_path=fname, writer=writer)
print output
