def __init__(self,
document,
docstring_linker=None,
directory=None,
docindex=None,
context=None):
# Set the document's settings.
if self.settings is None:
settings = OptionParser([LaTeXWriter()]).get_default_values()
settings.output_encoding = 'utf-8'
# This forces eg \EpydocUserSection rather than
# \EpydocUserSEction*:
settings.use_latex_toc = True
self.__class__.settings = settings
document.settings = self.settings
LaTeXTranslator.__init__(self, document)
self._linker = docstring_linker
self._directory = directory
self._docindex = docindex
self._context = context
# Use custom section names.
self.d_class = _EpydocDocumentClass()
def run(self):
env = self.state.document.settings.env
baseurl = env.config.rss_baseurl
assert baseurl, "rss_baseurl must be defined in your config.py"
source = self.state_machine.input_lines.source(self.lineno - self.state_machine.input_offset - 1)
rss_doc = utils.new_document(b("<rss>"), self.state.document.settings)
Parser().parse("\n".join(self.content), rss_doc)
rst_suffix = env.config.source_suffix
path = os.path.relpath(source, env.srcdir).replace(rst_suffix, ".html")
builder = env.app.builder
docwriter = HTMLWriter(self)
docsettings = OptionParser(defaults=env.settings, components=(docwriter,)).get_default_values()
docsettings.compact_lists = bool(env.config.html_compact_lists)
dest = os.path.join(env.app.outdir, os_path(env.docname) + ".rss")
pageurl = "%s/%s" % (baseurl, path)
with open(dest, "w") as rss:
title = self.options.get("title", "")
description = self.options.get("description", None)
rss.write('<?xml version="1.0" encoding="ISO-8859-1" ?>\n')
rss.write('<rss version="2.0">\n')
rss.write("<channel>\n")
rss.write("<title>%s</title>\n" % cgi.escape(title))
rss.write("<link>%s</link>\n" % pageurl)
if description:
rss.write("<description>%s</description>\n" % cgi.escape(description))
for child in rss_doc.children:
if not isinstance(child, nodes.section):
continue
title_index = child.first_child_matching_class(nodes.title)
if title_index is None:
continue
node = nodes.paragraph()
node.extend(child.children[title_index + 1 :])
sec_doc = utils.new_document(b("<rss-section>"), docsettings)
sec_doc.append(node)
visitor = RssTranslator(builder, sec_doc)
sec_doc.walkabout(visitor)
title = child.children[title_index].astext()
sectionurl = "%s#%s" % (pageurl, child.get("ids")[0])
description = "".join(visitor.body)
rss.write("<item>\n")
rss.write("<title>%s</title>\n" % cgi.escape(title))
rss.write("<link>%s</link>\n" % sectionurl)
rss.write("<description><![CDATA[%s]]></description>\n" % description)
rss.write("</item>\n")
rss.write("</channel>\n")
rss.write("</rss>\n")
return []
def _get_document_settings(self):
"""Get settings for the docutils components."""
components = (self.parser, self.reader)
defaults = dict(read_config_files=False,
report_level=5,
halt_level=10,
warning_stream=False)
opt_parser = OptionParser(components=components, defaults=defaults)
return opt_parser.get_default_values()
def parseRst(filename):
'''Load a text file and use the .rst parser to build a docutils node tree.'''
settings = OptionParser(components=(Parser, )).get_default_values()
settings.input_encoding = 'utf8' # This does not work, old version of docutils?
source = open(filename).read()
parser = Parser()
doc = docutils.utils.new_document('slides.rst', settings)
parser.parse(source, doc)
return doc
def setup():
global _parser, _settings
_parser = Parser()
_settings = OptionParser().get_default_values()
_settings.tab_width = 8
_settings.pep_references = False
_settings.rfc_references = False
app = FakeSphinx()
plantuml.setup(app)
def setup():
global _parser, _settings
_parser = Parser()
_settings = OptionParser().get_default_values()
_settings.tab_width = 8
_settings.pep_references = False
_settings.rfc_references = False
app = FakeSphinx()
sadisp.setup(app)
def write(self, *ignored):
self.init_document_data()
for entry in self.document_data:
docname, targetname, title, author = entry[:4]
targetname += '.texi'
direntry = description = category = ''
if len(entry) > 6:
direntry, description, category = entry[4:7]
toctree_only = False
if len(entry) > 7:
toctree_only = entry[7]
destination = FileOutput(
destination_path=path.join(self.outdir, targetname),
encoding='utf-8')
self.info("processing " + targetname + "... ", nonl=1)
doctree = self.assemble_doctree(docname, toctree_only,
appendices=(self.config.texinfo_appendices or []))
self.info("writing... ", nonl=1)
self.post_process_images(doctree)
docwriter = TexinfoWriter(self)
settings = OptionParser(
defaults=self.env.settings,
components=(docwriter,)).get_default_values()
settings.author = author
settings.title = title
settings.texinfo_filename = targetname[:-5] + '.info'
settings.texinfo_elements = self.config.texinfo_elements
settings.texinfo_dir_entry = direntry or ''
settings.texinfo_dir_category = category or ''
settings.texinfo_dir_description = description or ''
settings.docname = docname
doctree.settings = settings
docwriter.write(doctree, destination)
self.info("done")
def load_rst(filename):
# use the docutils option parser to get defaults for our efforts
opts = OptionParser(components=(Parser, ))
defaults = opts.get_default_values()
# shut up the warnings
defaults.warning_stream = StringIO()
doc = new_document(filename, defaults)
with open(filename) as f:
Parser().parse(f.read(), doc)
return doc
def find_autoasdf_directives(env, filename):
parser = RSTParser()
settings = OptionParser(components=(RSTParser, )).get_default_values()
settings.env = env
document = new_document(filename, settings)
with open(filename) as ff:
parser.parse(ff.read(), document)
return [
x.children[0].astext() for x in document.traverse()
if isinstance(x, schema_def)
]
def main():
# process cmdline arguments:
inputFile, outputFile, outputFormat, optargs = getArgs()
settings = OptionParser(components=(Parser, )).get_default_values()
settings.debug = optargs['debug']
parser = Parser()
input = inputFile.read()
document = new_document(inputFile.name, settings)
parser.parse(input, document)
output = format(outputFormat, input, document, optargs)
outputFile.write(output)
if optargs['attributes']:
import pprint
pprint.pprint(document.__dict__)
def main():
# process cmdline arguments:
inputFile, outputFile, outputFormat, optargs = getArgs()
settings = OptionParser(components=(Parser,)).get_default_values()
settings.debug = optargs['debug']
parser = Parser()
input = inputFile.read()
document = new_document(inputFile.name, settings)
parser.parse(input, document)
output = format(outputFormat, input, document, optargs)
outputFile.write(output)
if optargs['attributes']:
import pprint
pprint.pprint(document.__dict__)
def get_settings(): settings = OptionParser().get_default_values() ## parser settings settings.tab_width = 2 settings.pep_references = None settings.rfc_references = None ## html settinfgs settings.xml_declaration = None settings.stylesheet = None settings.stylesheet_path = None settings.initial_header_level = 1 settings.math_output = "X" settings.template = Writer.default_template_path return settings
def _write_html(document) -> str:
builder = _get_builder()
destination = StringOutput(encoding="utf-8")
docwriter = HTMLWriter(builder)
docsettings = OptionParser(defaults=builder.env.settings,
components=(docwriter, ),
read_config_files=True).get_default_values()
docsettings.compact_lists = True
document.settings = docsettings
docwriter.write(document, destination)
docwriter.assemble_parts()
return docwriter.parts["body"]
def write(self, *ignored):
self.init_document_data()
for entry in self.document_data:
docname, targetname, title, author = entry[:4]
targetname += '.texi'
direntry = description = category = ''
if len(entry) > 6:
direntry, description, category = entry[4:7]
toctree_only = False
if len(entry) > 7:
toctree_only = entry[7]
destination = FileOutput(destination_path=path.join(
self.outdir, targetname),
encoding='utf-8')
self.info("processing " + targetname + "... ", nonl=1)
doctree = self.assemble_doctree(
docname,
toctree_only,
appendices=(self.config.texinfo_appendices or []))
self.info("writing... ", nonl=1)
# Add an Index section
if self.config.texinfo_domain_indices:
doctree.append(
nodes.section(
'',
nodes.title(_("Index"),
nodes.Text(_('Index'), _('Index'))),
nodes.raw('@printindex ge\n',
nodes.Text('@printindex ge\n',
'@printindex ge\n'),
format="texinfo")))
self.post_process_images(doctree)
docwriter = TexinfoWriter(self)
settings = OptionParser(
defaults=self.env.settings,
components=(docwriter, )).get_default_values()
settings.author = author
settings.title = title
settings.texinfo_filename = targetname[:-5] + '.info'
settings.texinfo_elements = self.config.texinfo_elements
settings.texinfo_dir_entry = direntry or ''
settings.texinfo_dir_category = category or ''
settings.texinfo_dir_description = description or ''
settings.docname = docname
doctree.settings = settings
docwriter.write(doctree, destination)
self.info("done")
def test_help_text():
"""Test retrieving settings help text."""
from docutils.frontend import OptionParser
stream = io.StringIO()
OptionParser(components=(Parser, )).print_help(stream)
assert "MyST options" in stream.getvalue()
def __init__(self, document, docstring_linker):
# Set the document's settings.
if self.settings is None:
settings = OptionParser([LaTeXWriter()]).get_default_values()
settings.output_encoding = 'utf-8'
self.__class__.settings = settings
document.settings = self.settings
LaTeXTranslator.__init__(self, document)
self._linker = docstring_linker
# Start at section level 3. (Unfortunately, we now have to
# set a private variable to make this work; perhaps the standard
# latex translator should grow an official way to spell this?)
self.section_level = 3
self._section_number = [0]*self.section_level
def _generate_preview(self, page_id, contents):
"""
Generate a preview for suggested changes.
"""
handle, pathname = tempfile.mkstemp()
os.write(handle, contents.encode('utf-8'))
os.close(handle)
warning_stream = StringIO.StringIO()
env2 = copy.deepcopy(self.env)
destination = StringOutput(encoding='utf-8')
builder = MockBuilder()
builder.config = env2.config
writer = HTMLWriter(builder)
doctree = env2.read_doc(page_id, pathname, save_parsed=False)
doctree = env2.get_and_resolve_doctree(page_id + '.rst', builder,
doctree)
doctree.settings = OptionParser(
defaults=env2.settings,
components=(writer, )).get_default_values()
doctree.reporter = Reporter(page_id + '.rst',
2,
4,
stream=warning_stream)
output = writer.write(doctree, destination)
writer.assemble_parts()
return writer.parts['fragment']
def write(self, *ignored):
super(CustomLaTeXBuilder, self).write(*ignored)
backup_translator = sphinx.writers.latex.LaTeXTranslator
sphinx.writers.latex.LaTeXTranslator = CustomLaTeXTranslator
backup_doc = sphinx.writers.latex.BEGIN_DOC
sphinx.writers.latex.BEGIN_DOC = ''
# output these as include files
for docname in ['abstract', 'dedication', 'acknowledgements']:
destination = FileOutput(destination_path=os.path.join(
self.outdir, '%s.inc' % docname),
encoding='utf-8')
docwriter = LaTeXWriter(self)
doctree = self.env.get_doctree(docname)
docsettings = OptionParser(
defaults=self.env.settings,
components=(docwriter, )).get_default_values()
doctree.settings = docsettings
docwriter.write(doctree, destination)
sphinx.writers.latex.LaTeXTranslator = backup_translator
sphinx.writers.latex.BEGIN_DOC = backup_doc
def parse_document(input_filename):
with open(input_filename, 'r') as f:
option_parser = OptionParser(components=(Parser, ), )
default_settings = option_parser.get_default_values()
settings = default_settings.copy()
settings.update({
'report_level': 100,
}, option_parser)
document = new_document(input_filename, settings)
parser = Parser()
parser.parse(f.read(), document)
return document
def renderList(l, markDownHelp, settings=None):
"""
Given a list of reStructuredText or MarkDown sections, return a docutils node list
"""
if len(l) == 0:
return []
if markDownHelp:
from sphinxarg.markdown import parseMarkDownBlock
return parseMarkDownBlock('\n\n'.join(l) + '\n')
else:
all_children = []
for element in l:
if isinstance(element, str):
if settings is None:
settings = OptionParser(
components=(Parser, )).get_default_values()
document = new_document(None, settings)
Parser().parse(element + '\n', document)
all_children += document.children
elif isinstance(element, (nodes.definition, nodes.description)):
all_children += element
else:
assert False, element
return all_children
def __init__(self, document, docstring_linker):
# Set the document's settings.
if self.settings is None:
settings = OptionParser([LaTeXWriter()]).get_default_values()
settings.output_encoding = 'utf-8'
self.__class__.settings = settings
document.settings = self.settings
LaTeXTranslator.__init__(self, document)
self._linker = docstring_linker
# Start at section level 3. (Unfortunately, we now have to
# set a private variable to make this work; perhaps the standard
# latex translator should grow an official way to spell this?)
self.section_level = 3
self._section_number = [0]*self.section_level
def write(self, *ignored):
docwriter = LaTeXWriter(self)
docsettings = OptionParser(
defaults=self.env.settings,
components=(docwriter,)).get_default_values()
self.init_document_data()
for entry in self.document_data:
docname, targetname, title, author, docclass = entry[:5]
toctree_only = False
if len(entry) > 5:
toctree_only = entry[5]
destination = FileOutput(
destination_path=path.join(self.outdir, targetname),
encoding='utf-8')
self.info("processing " + targetname + "... ", nonl=1)
doctree = self.assemble_doctree(docname, toctree_only,
appendices=((docclass != 'howto') and
self.config.latex_appendices or []))
self.post_process_images(doctree)
self.info("writing... ", nonl=1)
doctree.settings = docsettings
doctree.settings.author = author
doctree.settings.title = title
doctree.settings.docname = docname
doctree.settings.docclass = docclass
docwriter.write(doctree, destination)
self.info("done")
def write(self, *ignored):
# type: (Any) -> None
docwriter = ManualPageWriter(self)
docsettings = OptionParser(
defaults=self.env.settings,
components=(docwriter,),
read_config_files=True).get_default_values() # type: Any
logger.info(bold(__('writing... ')), nonl=True)
for info in self.config.man_pages:
docname, name, description, authors, section = info
if docname not in self.env.all_docs:
logger.warning(__('"man_pages" config value references unknown '
'document %s'), docname)
continue
if isinstance(authors, str):
if authors:
authors = [authors]
else:
authors = []
docsettings.title = name
docsettings.subtitle = description
docsettings.authors = authors
docsettings.section = section
targetname = '%s.%s' % (name, section)
logger.info(darkgreen(targetname) + ' { ', nonl=True)
destination = FileOutput(
destination_path=path.join(self.outdir, targetname),
encoding='utf-8')
tree = self.env.get_doctree(docname)
docnames = set() # type: Set[str]
largetree = inline_all_toctrees(self, docnames, docname, tree,
darkgreen, [docname])
largetree.settings = docsettings
logger.info('} ', nonl=True)
self.env.resolve_references(largetree, docname, self)
# remove pending_xref nodes
for pendingnode in largetree.traverse(addnodes.pending_xref):
pendingnode.replace_self(pendingnode.children)
docwriter.write(largetree, destination)
logger.info('')
def run(self):
"""Run the directive."""
stream = io.StringIO()
OptionParser(
components=(DocutilsParser, ),
usage="myst-docutils-<writer> [options] [<source> [<destination>]]",
).print_help(stream)
return [nodes.literal_block("", stream.getvalue())]
def __init__(self, document):
# Copied from epydoc.markup.restructuredtext._EpydocHTMLTranslator
if self.settings is None:
settings = OptionParser([HTMLWriter()]).get_default_values()
self.__class__.settings = settings
document.settings = self.settings
HTMLTranslator.__init__(self, document)
def get_attr_types(docstring):
parser = Parser()
default_settings = OptionParser(components=(Parser,)).get_default_values()
document = new_document('test_data', default_settings)
parser.parse(docstring, document)
visitor = AttrVisitor(document)
document.walk(visitor)
return visitor.args, visitor.returns
def write_latex_document(self, latex_document_node,
all_latex_document_nodes):
output_filename = latex_document_node["multilatex-filename"]
variables = latex_document_node["multilatex-variables"]
content = latex_document_node["multilatex-content"]
options = latex_document_node["multilatex-options"]
docname = latex_document_node["multilatex-docname"]
doctree = latex_document_node["multilatex-doctree"]
if not output_filename.endswith(".tex"):
output_filename += ".tex"
self.info("processing {0}...".format(output_filename), nonl=1)
# for node in doctree.traverse(latex_document):
# node.parent.remove(node)
# parent_node = latex_document_node.parent
# parent_node.remove(latex_document_node)
self.post_process_images(doctree)
self.info("writing...", nonl=1)
docwriter = LaTeXWriter(self)
option_parser = OptionParser(
defaults=self.env.settings,
components=(docwriter,),
read_config_files=True)
doctree.settings = option_parser.get_default_values()
settings = doctree.settings
settings.contentsname = None
settings.docname = docname
for name, value in options.items():
setattr(settings, name, value)
settings.multilatex_options = options
settings.multilatex_variables = variables
settings.multilatex_content = content
settings.multilatex_output_filename = output_filename
settings.multilatex_all_latex_document_nodes = all_latex_document_nodes
destination = FileOutput(
destination_path=os.path.join(self.outdir, output_filename),
encoding="utf-8")
docwriter.write(doctree, destination)
self.info("done")
def parse_rst(rst_string):
parser = Parser()
for name, class_ in []: # Add custom directives here
directives.register(name, class_)
settings = OptionParser(components=(Parser, )).get_default_values()
document = new_document("test", settings)
parser.parse(rst_string, document)
document = parser.document
return document
def build_markup(self):
"""Build markup"""
from docutils.readers import Reader
internal_rst = self.prepare_rst()
self.info("Changelog code:\n%s" % internal_rst)
internal_rst_fh = StringInput(source=internal_rst)
reader = Reader(parser_name='rst')
option_parser = OptionParser()
settings = option_parser.get_default_values()
settings.update(
dict(tab_width=3,
pep_references=False,
rfc_references=False,
file_insertion_enabled=True), option_parser)
document = reader.read(internal_rst_fh, reader.parser, settings)
return document.children
def write_latex_document(self, latex_document_node,
all_latex_document_nodes):
output_filename = latex_document_node["multilatex-filename"]
variables = latex_document_node["multilatex-variables"]
content = latex_document_node["multilatex-content"]
options = latex_document_node["multilatex-options"]
docname = latex_document_node["multilatex-docname"]
doctree = latex_document_node["multilatex-doctree"]
if not output_filename.endswith(".tex"):
output_filename += ".tex"
self.info("processing {0}...".format(output_filename), nonl=1)
# for node in doctree.traverse(latex_document):
# node.parent.remove(node)
# parent_node = latex_document_node.parent
# parent_node.remove(latex_document_node)
self.post_process_images(doctree)
self.info("writing...", nonl=1)
docwriter = LaTeXWriter(self)
option_parser = OptionParser(defaults=self.env.settings,
components=(docwriter, ),
read_config_files=True)
doctree.settings = option_parser.get_default_values()
settings = doctree.settings
settings.contentsname = None
settings.docname = docname
for name, value in options.items():
setattr(settings, name, value)
settings.multilatex_options = options
settings.multilatex_variables = variables
settings.multilatex_content = content
settings.multilatex_output_filename = output_filename
settings.multilatex_all_latex_document_nodes = all_latex_document_nodes
destination = FileOutput(destination_path=os.path.join(
self.outdir, output_filename),
encoding="utf-8")
docwriter.write(doctree, destination)
self.info("done")
def walk(p):
d2 = new_document(
p.pageName(),
OptionParser(components=(Parser, )).get_default_values())
Parser().parse(p.text(), d2)
d += d2.traverse()
for c in page.childrenNesting():
c = p.pageWithName(c)
walk(c)
c.delete()
def _parse_file(self, file: Path):
settings = OptionParser(components=(Parser, )).get_default_values()
parser = Parser()
document = new_document(str(file), settings)
with file.open() as f:
input = f.read()
directives.register_directive("test", TestDirective)
parser.parse(input, document)
return document
def parse_rst(self, text: str) -> docutils.nodes.document:
parser = sphinx.parsers.RSTParser()
parser.set_application(self.env.app)
settings = OptionParser(
defaults=self.env.settings, components=(sphinx.parsers.RSTParser,), read_config_files=True
).get_default_values()
document = docutils.utils.new_document("<rst-doc>", settings=settings)
parser.parse(text, document)
return document
def __init__(self):
self.settings = OptionParser(
components=(rst.Parser, )).get_default_values()
self.depth = 0
self.doc = ""
self.name = ""
self.attributes = {}
self.parameters = []
self.state = []
def _lint_docutils(source, fpath, Parser, traceback):
from io import StringIO
from docutils.utils import new_document
from docutils.frontend import OptionParser
from docutils.utils import Reporter
from .docutils import JsErrorPrinter
parser = Parser()
settings = OptionParser(components=(Parser, )).get_default_values()
settings.traceback = traceback
observer = JsErrorPrinter(StringIO(), settings)
document = new_document(fpath, settings)
document.reporter.report_level = 0 # Report all messages
document.reporter.halt_level = Reporter.SEVERE_LEVEL + 1 # Do not exit early
document.reporter.stream = False # Disable textual reporting
document.reporter.attach_observer(observer)
parser.parse(source, document)
return observer.stream.getvalue()
def _get_document(self, content):
settings = OptionParser(components=(Parser, )).get_default_values()
directives.register_directive("test-block", TestBlockDirective)
directives.register_directive("code-block", CodeBlockDirective)
parser = Parser()
source = str(self.source) if self.source else "lira-unknown-source"
document = new_document(source, settings)
parser.parse(content, document)
return document
def __init__(self, document: docutils.nodes.document,
docstring_linker: DocstringLinker):
self._linker = docstring_linker
# Set the document's settings.
if self.settings is None:
settings = OptionParser([HTMLWriter()]).get_default_values()
self.__class__.settings = settings
document.settings = self.settings
super().__init__(document)
def __init__(self, document, docstring_linker):
self._linker = docstring_linker
# Set the document's settings.
if self.settings is None:
settings = OptionParser([HTMLWriter()]).get_default_values()
self.__class__.settings = settings
document.settings = self.settings
# Call the parent constructor.
HTMLTranslator.__init__(self, document)
def __init__(self, document, docstring_linker=None, directory=None,
docindex=None, context=None):
# Set the document's settings.
if self.settings is None:
settings = OptionParser([LaTeXWriter()]).get_default_values()
settings.output_encoding = 'utf-8'
# This forces eg \EpydocUserSection rather than
# \EpydocUserSEction*:
settings.use_latex_toc = True
self.__class__.settings = settings
document.settings = self.settings
LaTeXTranslator.__init__(self, document)
self._linker = docstring_linker
self._directory = directory
self._docindex = docindex
self._context = context
# Use custom section names.
self.d_class = _EpydocDocumentClass()
def parse_testplan(source, parsed, is_spec,check_errors=False):
register_testplan_directives()
oldstderr = sys.stderr
docutils_out = StringIO.StringIO()
# sys.stderr = docutils_out
valid = True
reader_class=docutils.readers.get_reader_class("standalone")
reader=reader_class(None,"rst")
option_parser = OptionParser(
components=(reader.parser, reader),
defaults=[], read_config_files=1,
usage="", description="")
settings = option_parser.get_default_values()
# try:
reader.source = source
reader.settings = settings
reader.input = reader.source.read()
reader.document = doc = reader.new_document()
doc.parsed = parsed
doc.check_errors = check_errors
reader.parser.parse(reader.input, doc)
doc.current_source = doc.current_line = None
parsed = doc.parsed
# except:
# valid = False
# parsed = None
sys.stderr = oldstderr
err_msg = docutils_out.getvalue()
if 'feature' in parsed:
for f in parsed['feature']:
try:
f.from_spec
except:
f.from_spec = is_spec
return (valid and err_msg.find("ERROR") == -1), err_msg, parsed
def write(self, *ignored):
# type: (Any) -> None
self.init_document_data()
for entry in self.document_data:
docname, targetname, title, author = entry[:4]
targetname += '.texi'
direntry = description = category = ''
if len(entry) > 6:
direntry, description, category = entry[4:7]
toctree_only = False
if len(entry) > 7:
toctree_only = entry[7]
destination = FileOutput(
destination_path=path.join(self.outdir, targetname),
encoding='utf-8')
with progress_message(__("processing %s") % targetname):
appendices = self.config.texinfo_appendices or []
doctree = self.assemble_doctree(docname, toctree_only, appendices=appendices)
with progress_message(__("writing")):
self.post_process_images(doctree)
docwriter = TexinfoWriter(self)
settings = OptionParser(
defaults=self.env.settings,
components=(docwriter,),
read_config_files=True).get_default_values() # type: Any
settings.author = author
settings.title = title
settings.texinfo_filename = targetname[:-5] + '.info'
settings.texinfo_elements = self.config.texinfo_elements
settings.texinfo_dir_entry = direntry or ''
settings.texinfo_dir_category = category or ''
settings.texinfo_dir_description = description or ''
settings.docname = docname
doctree.settings = settings
docwriter.write(doctree, destination)
self.copy_image_files(targetname[:-5])
def write(self, *ignored):
# type: (Any) -> None
docwriter = LaTeXWriter(self)
docsettings = OptionParser(
defaults=self.env.settings,
components=(docwriter,),
read_config_files=True).get_default_values() # type: Any
self.init_document_data()
self.write_stylesheet()
for entry in self.document_data:
docname, targetname, title, author, docclass = entry[:5]
toctree_only = False
if len(entry) > 5:
toctree_only = entry[5]
destination = SphinxFileOutput(destination_path=path.join(self.outdir, targetname),
encoding='utf-8', overwrite_if_changed=True)
logger.info(__("processing %s..."), targetname, nonl=1)
toctrees = self.env.get_doctree(docname).traverse(addnodes.toctree)
if toctrees:
if toctrees[0].get('maxdepth') > 0:
tocdepth = toctrees[0].get('maxdepth')
else:
tocdepth = None
else:
tocdepth = None
doctree = self.assemble_doctree(
docname, toctree_only,
appendices=((docclass != 'howto') and self.config.latex_appendices or []))
doctree['tocdepth'] = tocdepth
self.apply_transforms(doctree)
self.post_process_images(doctree)
self.update_doc_context(title, author)
logger.info(__("writing... "), nonl=1)
docsettings.author = author
docsettings.title = title
docsettings.contentsname = self.get_contentsname(docname)
docsettings.docname = docname
docsettings.docclass = docclass
doctree.settings = docsettings
docwriter.write(doctree, destination)
logger.info("done")
def run(self):
env = self.state.document.settings.env
baseurl = env.config.rss_baseurl
assert baseurl, 'rss_baseurl must be defined in your config.py'
source = self.state_machine.input_lines.source(
self.lineno - self.state_machine.input_offset - 1)
rss_doc = utils.new_document('<rss>', self.state.document.settings)
Parser().parse('\n'.join(self.content), rss_doc)
path = os.path.relpath(source, env.srcdir)
suffixes = env.config.source_suffix
# retain backwards compatibility with sphinx < 1.3
if isinstance(suffixes, basestring):
suffixes = [suffixes]
for suffix in suffixes:
if path.endswith(suffix):
path = '%s.html' % path[:-len(suffix)]
break
builder = env.app.builder
docwriter = HTMLWriter(self)
docsettings = OptionParser(
defaults=env.settings,
components=(docwriter,)).get_default_values()
docsettings.compact_lists = bool(env.config.html_compact_lists)
dest = os.path.join(env.app.outdir, os_path(env.docname) + '.rss')
pageurl = '%s/%s' % (baseurl, path)
with open(dest, 'w') as rss:
title = self.options.get('title', '')
description = self.options.get('description', None)
rss.write('<?xml version="1.0" encoding="ISO-8859-1" ?>\n')
rss.write('<rss version="2.0">\n')
rss.write('<channel>\n')
rss.write('<title>%s</title>\n' % cgi.escape(title))
rss.write('<link>%s</link>\n' % pageurl)
if description:
rss.write('<description>%s</description>\n' % cgi.escape(description))
for child in rss_doc.children:
if not isinstance(child, nodes.section):
continue
title_index = child.first_child_matching_class(nodes.title)
if title_index is None:
continue
node = nodes.paragraph()
node.extend(child.children[title_index + 1:])
sec_doc = utils.new_document('<rss-section>', docsettings)
sec_doc.append(node)
visitor = RssTranslator(builder, sec_doc)
sec_doc.walkabout(visitor)
title = child.children[title_index].astext()
sectionurl = '%s#%s' % (pageurl, child.get('ids')[0])
description = ''.join(visitor.body)
rss.write('<item>\n')
rss.write('<title>%s</title>\n' % cgi.escape(title))
rss.write('<link>%s</link>\n' % sectionurl)
rss.write('<description><![CDATA[%s]]></description>\n' % description)
rss.write('</item>\n')
rss.write('</channel>\n')
rss.write('</rss>\n')
return []
__docformat__ = 'reStructuredText'
import sys
from package import parse_package_or_module
import transform
from docutils.writers.html4css1 import Writer
from docutils.frontend import OptionParser
usage = '%prog [options] [<package-directory> | <python-file> [html-file]]'
description = ('Generates .html documentation for the given Python package'
' or module.')
writer = Writer()
option_parser = OptionParser(components=[writer],
usage=usage,description=description)
settings = option_parser.parse_args(sys.argv[1:])
source_path = settings._source
target_path = settings._destination
nodes = parse_package_or_module(source_path)
# That then needs converting to a docutils tree
document = transform.make_document(nodes,settings)
# And *that* wants converting to the appropriate output format
try:
target = open(target_path,"w")
writer.write(document,target)
