def patch(self, out_filename=None):
"""Apply patches and write changes to specified file.
Args:
out_filename: Output filename. If not set then input one is used.
"""
in_ = FileInput(source_path=self._filename, encoding=self._encoding)
content = in_.read()
content = self._patcher.patch(content)
content = '\n'.join(content)
out = FileOutput(destination_path=out_filename or self._filename,
encoding=self._encoding)
out.write(content)
def run(args):
"""The main function."""
sources = []
if args.debug:
from mjstat.testdata import TEST_INPUT
sources.append(StringInput(source=TEST_INPUT))
else:
# XXX
if isinstance(args.input, (list, tuple)):
sources.extend(
FileInput(source_path=i, encoding='sjis', mode='r')
for i in args.input)
else:
sources.append(
FileInput(source_path=args.input, encoding='sjis', mode='r'))
parser = MJScoreParser()
reader = MJScoreReader()
game_data_list = tuple(reader.read(i, parser, args) for i in sources)
game_data = merge_games(game_data_list)
apply_transforms(game_data)
writer = MJScoreWriter()
writer.write(game_data, FileOutput(None))
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 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 build_finished(app, exception):
if exception is not None:
return
builder = app.builder
output_full_name = os.path.join(
builder.outdir,
'schedule.ics',
)
output_dir_name = os.path.dirname(output_full_name)
if not os.path.exists(output_dir_name):
os.makedirs(output_dir_name)
destination = FileOutput(
destination_path=output_full_name,
encoding='utf-8',
)
LOG.info('generating {}'.format(output_full_name))
destination.write(_global_calendar.to_ical())
def write(self, *ignored):
self.init_document_data()
if self.config.pdf_verbosity > 1:
rst2pdf.log.log.setLevel(logging.DEBUG)
elif self.config.pdf_verbosity > 0:
rst2pdf.log.log.setLevel(logging.INFO)
for entry in self.document_data:
try:
docname, targetname, title, author = entry[:4]
# Custom options per document
if len(entry)>4 and isinstance(entry[4],dict):
opts=entry[4]
else:
opts={}
self.info("processing " + targetname + "... ", nonl=1)
class dummy:
extensions=self.config.pdf_extensions
createpdf.add_extensions(dummy())
self.page_template=opts.get('pdf_page_template',self.config.pdf_page_template)
docwriter = PDFWriter(self,
stylesheets=opts.get('pdf_stylesheets',self.config.pdf_stylesheets),
language=opts.get('pdf_language',self.config.pdf_language),
breaklevel=opts.get('pdf_break_level',self.config.pdf_break_level),
breakside=opts.get('pdf_breakside',self.config.pdf_breakside),
fontpath=opts.get('pdf_font_path',self.config.pdf_font_path),
fitmode=opts.get('pdf_fit_mode',self.config.pdf_fit_mode),
compressed=opts.get('pdf_compressed',self.config.pdf_compressed),
inline_footnotes=opts.get('pdf_inline_footnotes',self.config.pdf_inline_footnotes),
splittables=opts.get('pdf_splittables',self.config.pdf_splittables),
default_dpi=opts.get('pdf_default_dpi',self.config.pdf_default_dpi),
page_template=self.page_template,
invariant=opts.get('pdf_invariant',self.config.pdf_invariant),
srcdir=self.srcdir,
config=self.config
)
tgt_file = path.join(self.outdir, targetname + self.out_suffix)
destination = FileOutput(destination=open(tgt_file,'wb'), encoding='utf-8')
doctree = self.assemble_doctree(docname,title,author,
appendices=opts.get('pdf_appendices', self.config.pdf_appendices) or [])
doctree.settings.author=author
doctree.settings.title=title
self.info("done")
self.info("writing " + targetname + "... ", nonl=1)
docwriter.write(doctree, destination)
self.info("done")
except Exception, e:
rst2pdf.log.log.error(str(e))
print_exc()
self.info(red("FAILED"))
def write(self, data):
# type: (unicode) -> unicode
if (self.destination_path and self.autoclose and 'b' not in self.mode and
self.overwrite_if_changed and os.path.exists(self.destination_path)):
with codecs.open(self.destination_path, encoding=self.encoding) as f:
# skip writing: content not changed
if f.read() == data:
return data
return FileOutput.write(self, data)
def write(self, data):
# type: (unicode) -> unicode
if (self.destination_path and self.autoclose and 'b' not in self.mode and
self.overwrite_if_changed and os.path.exists(self.destination_path)):
with open(self.destination_path, encoding=self.encoding) as f: # type: ignore
# skip writing: content not changed
if f.read() == data:
return data
return FileOutput.write(self, data)
def write(self, *ignored):
if self.config.man_pages:
# build manpages from config.man_pages as usual
ManualPageBuilder.write(self, *ignored)
logger.info(bold("scan master tree for kernel-doc man-pages ... ") + darkgreen("{"), nonl=True)
master_tree = self.env.get_doctree(self.config.master_doc)
master_tree = inline_all_toctrees(
self, set(), self.config.master_doc, master_tree, darkgreen, [self.config.master_doc])
logger.info(darkgreen("}"))
man_nodes = master_tree.traverse(condition=self.is_manpage)
if not man_nodes and not self.config.man_pages:
logger.warn('no "man_pages" config value nor manual section found; no manual pages '
'will be written')
return
logger.info(bold('START writing man pages ... '), nonl=True)
for man_parent in man_nodes:
doc_tree = self.get_partial_document(man_parent)
Section2Manpage(doc_tree).apply()
if not doc_tree.man_info["authors"] and self.config.author:
doc_tree.man_info["authors"].append(self.config.author)
doc_writer = ManualPageWriter(self)
doc_settings = OptionParser(
defaults = self.env.settings
, components = (doc_writer,)
, read_config_files = True
, ).get_default_values()
doc_settings.__dict__.update(doc_tree.man_info)
doc_tree.settings = doc_settings
targetname = '%s.%s' % (doc_tree.man_info.title, doc_tree.man_info.section)
if doc_tree.man_info.decl_type in [
"struct", "enum", "union", "typedef"]:
targetname = "%s_%s" % (doc_tree.man_info.decl_type, targetname)
destination = FileOutput(
destination_path = path.join(self.outdir, targetname)
, encoding='utf-8')
logger.info(darkgreen(targetname) + " ", nonl=True)
self.env.resolve_references(doc_tree, doc_tree.man_info.manpage, self)
# remove pending_xref nodes
for pendingnode in doc_tree.traverse(addnodes.pending_xref):
pendingnode.replace_self(pendingnode.children)
doc_writer.write(doc_tree, destination)
logger.info("END writing man pages.")
def set_output(self, output_file):
"""
Set the output file and clear the list of already added
dependencies.
`output_file` must be a string. The specified file is
immediately overwritten.
If output_file is '-', the output will be written to stdout.
If it is None, no file output is done when calling add().
"""
self.list = []
if output_file:
if output_file == '-':
of = None
else:
of = output_file
self.file = FileOutput(destination_path=of,
encoding='utf8', autoclose=False)
else:
self.file = None
def write(self, *ignored: Any) -> None:
docwriter = ManualPageWriter(self)
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
# DeprecationWarning: The frontend.OptionParser class will be replaced
# by a subclass of argparse.ArgumentParser in Docutils 0.21 or later.
docsettings: Any = OptionParser(
defaults=self.env.settings,
components=(docwriter, ),
read_config_files=True).get_default_values()
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
if self.config.man_make_section_directory:
dirname = 'man%s' % section
ensuredir(path.join(self.outdir, dirname))
targetname = '%s/%s.%s' % (dirname, name, section)
else:
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[str] = set()
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.findall(addnodes.pending_xref):
pendingnode.replace_self(pendingnode.children)
docwriter.write(largetree, destination)
def write(self, *ignored: Any) -> None:
docwriter = ManualPageWriter(self)
docsettings = OptionParser(
defaults=self.env.settings,
components=(docwriter, ),
read_config_files=True).get_default_values() # type: Any
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
if self.config.man_make_section_directory:
ensuredir(path.join(self.outdir, str(section)))
targetname = '%s/%s.%s' % (section, name, section)
else:
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)
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 write_doc(self, docname, doctree):
"""
"""
html_file_suffix = self.get_builder_config("file_suffix", "html")
if html_file_suffix is not None:
self.out_suffix = html_file_suffix
docfile = docname + self.out_suffix
destination = FileOutput(
destination_path = os.path.join(self.outdir, docfile),
encoding = "utf-8"
)
doctree.settings = self.docsettings
self.docwriter.write(doctree, destination)
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()
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 = FileOutput(destination_path=path.join(
self.outdir, targetname),
encoding='utf-8')
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)
logger.info(__("writing... "), nonl=1)
doctree.settings = docsettings
doctree.settings.author = author
doctree.settings.title = title
doctree.settings.contentsname = self.get_contentsname(docname)
doctree.settings.docname = docname
doctree.settings.docclass = docclass
docwriter.write(doctree, destination)
logger.info("done")
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 write(self, *ignored: 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)
with warnings.catch_warnings():
warnings.filterwarnings('ignore',
category=DeprecationWarning)
# DeprecationWarning: The frontend.OptionParser class will be replaced
# by a subclass of argparse.ArgumentParser in Docutils 0.21 or later.
settings: Any = OptionParser(
defaults=self.env.settings,
components=(docwriter, ),
read_config_files=True).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.copy_image_files(targetname[:-5])
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()
logger.info(bold('writing... '), nonl=True)
for info in self.config.man_pages:
docname, name, description, authors, section = info
if isinstance(authors, string_types):
if authors:
authors = [authors]
else:
authors = []
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[unicode]
largetree = inline_all_toctrees(self, docnames, docname, tree,
darkgreen, [docname])
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)
largetree.settings = docsettings
largetree.settings.title = name
largetree.settings.subtitle = description
largetree.settings.authors = authors
largetree.settings.section = section
docwriter.write(largetree, destination)
logger.info('')
def write_doc(self, docCfg): # pylint: disable=W0221
"""Where you actually write something to the filesystem.
"""
self.info("processing " + docCfg.targetname + "... ", nonl=1)
# The argument doctree are covered by the self.assemble_doctree
# method. The docCfg is shipped in the writer.document.docCfg
doctree = self.assemble_doctree(docCfg)
doctree.docCfg = docCfg
self.post_process_images(doctree)
self.info("writing... ", nonl=1)
outFile = FileOutput(destination_path=path.join(
self.outdir, docCfg.targetname),
encoding='utf-8')
writer = self.writerClass(self)
writer.write(doctree, outFile)
self.info("done")
def set_output(self, output_file):
"""
Set the output file and clear the list of already added
dependencies.
`output_file` must be a string. The specified file is
immediately overwritten.
If output_file is '-', the output will be written to stdout.
If it is None, no file output is done when calling add().
"""
self.list = []
if output_file:
if output_file == '-':
of = None
else:
of = output_file
self.file = FileOutput(destination_path=of,
encoding='utf8', autoclose=False)
else:
self.file = None
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])
class DependencyList(object):
"""
List of dependencies, with file recording support.
Note that the output file is not automatically closed. You have
to explicitly call the close() method.
"""
def __init__(self, output_file=None, dependencies=[]):
"""
Initialize the dependency list, automatically setting the
output file to `output_file` (see `set_output()`) and adding
all supplied dependencies.
"""
self.set_output(output_file)
for i in dependencies:
self.add(i)
def set_output(self, output_file):
"""
Set the output file and clear the list of already added
dependencies.
`output_file` must be a string. The specified file is
immediately overwritten.
If output_file is '-', the output will be written to stdout.
If it is None, no file output is done when calling add().
"""
self.list = []
if output_file:
if output_file == '-':
of = None
else:
of = output_file
self.file = FileOutput(destination_path=of,
encoding='utf8', autoclose=False)
else:
self.file = None
def add(self, *filenames):
"""
If the dependency `filename` has not already been added,
append it to self.list and print it to self.file if self.file
is not None.
"""
for filename in filenames:
if not filename in self.list:
self.list.append(filename)
if self.file is not None:
self.file.write(filename+'\n')
def close(self):
"""
Close the output file.
"""
self.file.close()
self.file = None
def __repr__(self):
try:
output_file = self.file.name
except AttributeError:
output_file = None
return '%s(%r, %s)' % (self.__class__.__name__, output_file, self.list)
def __init__(self, **kwargs):
# type: (Any) -> None
self.overwrite_if_changed = kwargs.pop('overwrite_if_changed', False)
FileOutput.__init__(self, **kwargs)
def doctree_resolved(app, doctree, docname):
builder = app.builder
for node in doctree.traverse(PendingICS):
series_name = node._series_name
data = node._data
LOG.info('building {} calendar'.format(series_name))
cal = icalendar.Calendar()
cal.add('prodid', '-//releases.openstack.org//EN')
cal.add('X-WR-CALNAME', '{} schedule'.format(series_name))
for week in data['cycle']:
if not week.get('name'):
continue
event = icalendar.Event()
summary = []
for item in week.get('x-project', []):
try:
# Look up the cross-reference name to get the
# section, then get the title from the first child
# node.
title = doctree.ids[item].children[0].astext()
except Exception as e:
# NOTE(dhellmann): Catching "Exception" is a bit
# ugly, but given the complexity of the expression
# above there are a bunch of ways things might
# fail.
LOG.info('could not get title for {}: {}'.format(item, e))
title = item
summary.append(title)
if summary:
summary_text = ' (' + '; '.join(summary) + ')'
else:
summary_text = ''
event.add(
'summary',
'{} {}{}'.format(series_name.title(), week['name'],
summary_text),
)
event.add('dtstamp', node.last_update)
event.add('uid', '%s-%s' % (series_name, week.get('name')))
start = datetime.datetime.strptime(week['start'], '%Y-%m-%d')
event.add('dtstart', icalendar.vDate(start.date()))
# NOTE(dhellmann): ical assumes a time of midnight, so in
# order to have the event span the final day of the week
# we have to add an extra day.
raw_end = datetime.datetime.strptime(week['end'], '%Y-%m-%d')
end = raw_end + datetime.timedelta(days=1)
event.add('dtend', icalendar.vDate(end.date()))
# Look up the cross-reference name to get the
# section, then add the full description to the
# text.
description = [
_format_description(doctree.ids[item])
for item in week.get('x-project', []) if item in doctree.ids
]
if description:
event.add('description', '\n\n'.join(description))
cal.add_component(event)
_global_calendar.add_component(event)
output_full_name = os.path.join(
builder.outdir,
docname + '.ics',
)
output_dir_name = os.path.dirname(output_full_name)
if not os.path.exists(output_dir_name):
os.makedirs(output_dir_name)
destination = FileOutput(
destination_path=output_full_name,
encoding='utf-8',
)
LOG.info('generating {}'.format(output_full_name))
destination.write(cal.to_ical())
# Remove the node that the writer won't understand.
node.parent.replace(node, [])
class DependencyList(object):
"""
List of dependencies, with file recording support.
Note that the output file is not automatically closed. You have
to explicitly call the close() method.
"""
def __init__(self, output_file=None, dependencies=[]):
"""
Initialize the dependency list, automatically setting the
output file to `output_file` (see `set_output()`) and adding
all supplied dependencies.
"""
self.set_output(output_file)
for i in dependencies:
self.add(i)
def set_output(self, output_file):
"""
Set the output file and clear the list of already added
dependencies.
`output_file` must be a string. The specified file is
immediately overwritten.
If output_file is '-', the output will be written to stdout.
If it is None, no file output is done when calling add().
"""
self.list = []
if output_file:
if output_file == '-':
of = None
else:
of = output_file
self.file = FileOutput(destination_path=of,
encoding='utf8',
autoclose=False)
else:
self.file = None
def add(self, *filenames):
"""
If the dependency `filename` has not already been added,
append it to self.list and print it to self.file if self.file
is not None.
"""
for filename in filenames:
if not filename in self.list:
self.list.append(filename)
if self.file is not None:
self.file.write(filename + '\n')
def close(self):
"""
Close the output file.
"""
self.file.close()
self.file = None
def __repr__(self):
try:
output_file = self.file.name
except AttributeError:
output_file = None
return '%s(%r, %s)' % (self.__class__.__name__, output_file, self.list)
def write(self, *ignored):
self.init_document_data()
if self.config.pdf_verbosity > 1:
log.setLevel(logging.DEBUG)
elif self.config.pdf_verbosity > 0:
log.setLevel(logging.INFO)
for entry in self.document_data:
try:
docname, targetname, title, author = entry[:4]
# Custom options per document
if len(entry)>4 and isinstance(entry[4],dict):
opts=entry[4]
else:
opts={}
self.spinx_logger.info("processing " + targetname + "... ")
self.opts = opts
class dummy:
extensions=self.config.pdf_extensions
createpdf.add_extensions(dummy())
self.page_template=opts.get('pdf_page_template',self.config.pdf_page_template)
docwriter = PDFWriter(self,
stylesheets=opts.get('pdf_stylesheets',self.config.pdf_stylesheets),
language=opts.get('pdf_language',self.config.pdf_language),
breaklevel=opts.get('pdf_break_level',self.config.pdf_break_level),
breakside=opts.get('pdf_breakside',self.config.pdf_breakside),
fontpath=opts.get('pdf_font_path',self.config.pdf_font_path),
fitmode=opts.get('pdf_fit_mode',self.config.pdf_fit_mode),
compressed=opts.get('pdf_compressed',self.config.pdf_compressed),
inline_footnotes=opts.get('pdf_inline_footnotes',self.config.pdf_inline_footnotes),
splittables=opts.get('pdf_splittables',self.config.pdf_splittables),
repeat_table_rows=opts.get('pdf_repeat_table_rows',self.config.pdf_repeat_table_rows),
default_dpi=opts.get('pdf_default_dpi',self.config.pdf_default_dpi),
page_template=self.page_template,
invariant=opts.get('pdf_invariant',self.config.pdf_invariant),
real_footnotes=opts.get('pdf_real_footnotes',self.config.pdf_real_footnotes),
use_toc=opts.get('pdf_use_toc',self.config.pdf_use_toc),
toc_depth=opts.get('pdf_toc_depth',self.config.pdf_toc_depth),
use_coverpage=opts.get('pdf_use_coverpage',self.config.pdf_use_coverpage),
use_numbered_links=opts.get('pdf_use_numbered_links',self.config.pdf_use_numbered_links),
fit_background_mode=opts.get('pdf_fit_background_mode',self.config.pdf_fit_background_mode),
baseurl=opts.get('pdf_baseurl',self.config.pdf_baseurl),
section_header_depth=opts.get('section_header_depth',self.config.section_header_depth),
srcdir=self.srcdir,
style_path=opts.get('pdf_style_path', self.config.pdf_style_path),
config=self.config,
)
tgt_file = path.join(self.outdir, targetname + self.out_suffix)
destination = FileOutput(destination=open(tgt_file,'wb'), encoding='utf-8')
doctree = self.assemble_doctree(docname,title,author,
appendices=opts.get('pdf_appendices', self.config.pdf_appendices) or [])
doctree.settings.author=author
doctree.settings.title=title
self.spinx_logger.info("done")
self.spinx_logger.info("writing " + targetname + "... ")
docwriter.write(doctree, destination)
self.spinx_logger.info("done")
except Exception as e:
log.exception(e)
self.spinx_logger.info(red("FAILED"))
def __init__(self, **kwargs):
# type: (Any) -> None
self.overwrite_if_changed = kwargs.pop('overwrite_if_changed', False)
FileOutput.__init__(self, **kwargs)
def onIconDoubleClick(tag, keywords):
c = keywords.get("c")
p = keywords.get("p")
# g.trace(c)
if not c or not p:
return
applyConfiguration(c)
config.tag = tag
h = p.headString().strip()
if g.match_word(h, 0, "@rst"):
if len(h) > 5:
fname = h[5:]
ext = os.path.splitext(fname)[1].lower()
if ext in ('.htm', '.html', '.tex'):
#@ << write rST as HTML/LaTeX >>
#@+node:ekr.20040331071319.4:<< write rST as HTML/LaTeX >>
try:
import docutils
except:
g.es('HTML/LaTeX generation requires docutils')
return
else:
import docutils.parsers.rst
from docutils.core import Publisher
from docutils.io import StringOutput, StringInput, FileOutput, FileInput
import StringIO
# Set the writer and encoding for the converted file
if ext in ('.html', '.htm'):
writer = 'html'
enc = "utf-8"
else:
writer = 'latex'
enc = "iso-8859-1"
syntax = False
if writer == 'html':
try:
import SilverCity
#@ << define code-block >>
#@+node:ekr.20040331071319.5:<< define code-block >>
def code_block(name, arguments, options, content,
lineno, content_offset, block_text,
state, state_machine):
"""Create a code-block directive for docutils."""
# See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252170
language = arguments[0]
module = getattr(SilverCity, language)
generator = getattr(module,
language + "HTMLGenerator")
io = StringIO.StringIO()
generator().generate_html(io, '\n'.join(content))
html = '<div class="code-block">\n%s\n</div>\n' % io.getvalue(
)
raw = docutils.nodes.raw(
'', html, format='html'
) #(self, rawsource='', text='', *children, **attributes):
return [raw]
# These are documented at http://docutils.sourceforge.net/spec/howto/rst-directives.html.
code_block.arguments = (
1, # Number of required arguments.
0, # Number of optional arguments.
0
) # True if final argument may contain whitespace.
# A mapping from option name to conversion function.
code_block.options = {
'language': docutils.parsers.rst.directives.
unchanged # Return the text argument, unchanged
}
code_block.content = 1 # True if content is allowed.
# Register the directive with docutils.
docutils.parsers.rst.directives.register_directive(
'code-block', code_block)
config.do_replace_code_blocks = False
#@nonl
#@-node:ekr.20040331071319.5:<< define code-block >>
#@nl
syntax = True
except ImportError:
g.es(
'SilverCity not present so no syntax highlighting')
#@ << define alternate code block implementation>>
#@+node:bwmulder.20050326114320: << define alternate code block implementation>>
# Don't know what to do here: Can someone make a suggestion?
#import docutils.parsers.rst.directives.admonitions
#import docutils.parsers.rst.directives.body
# docutils.parsers.rst.directives._directives['code-block'] = docutils.parsers.rst.directives.body.block
# docutils.parsers.rst.directives.register_directive('code-block', docutils.parsers.rst.directives.admonitions.admonition)
#docutils.parsers.rst.directives._directives['code-block'] = docutils.parsers.rst.directives.body.pull_quote
# g.es("Registered some alternate implementation for code-block directive")
config.do_replace_code_blocks = config.rst2_replace_code_blocks
#@-node:bwmulder.20050326114320: << define alternate code block implementation>>
#@nl
if config.rst2file:
rstFileName = os.path.splitext(fname)[0] + ".txt"
rstFile = file(rstFileName, "w")
g.es("Using %s as rst file" % rstFileName)
else:
rstFile = StringIO.StringIO()
config.current_file = fname
writeTreeAsRst(rstFile, fname, p, c, syntax=syntax)
if config.rst2file:
rstFile.close()
else:
rstText = rstFile.getvalue()
# This code snipped has been taken from code contributed by Paul Paterson 2002-12-05.
pub = Publisher()
if config.rst2file:
pub.source = FileInput(source_path=rstFileName)
pub.destination = FileOutput(destination_path=fname,
encoding='unicode')
else:
pub.source = StringInput(source=rstText)
pub.destination = StringOutput(pub.settings, encoding=enc)
pub.set_reader('standalone', None, 'restructuredtext')
pub.set_writer(writer)
output = pub.publish(argv=[''])
if config.rst2file:
pass
else:
convertedFile = file(fname, 'w')
convertedFile.write(output)
convertedFile.close()
rstFile.close()
writeFullFileName(fname)
return http_support_main(tag, fname)
#@-node:ekr.20040331071319.4:<< write rST as HTML/LaTeX >>
#@nl
else:
#@ << write rST file >>
#@+node:ekr.20040331071319.6:<< write rST file >>
rstFile = file(fname, 'w')
writeTreeAsRst(rstFile, fname, p, c)
rstFile.close()
writeFullFileName(fname)
#@nonl
#@-node:ekr.20040331071319.6:<< write rST file >>
#@nl
else:
# if the headline only contains @rst then open the node and its parent in text editor
# this works for me but needs to be generalized and should probably be a component
# of the open_with plugin.
if 0:
c.openWith(("os.startfile", None, ".txt"))
c.selectVnode(p.parent())
c.openWith(("os.startfile", None, ".tp"))
def __set__(self, instance, value, *args, **kwargs):
if isinstance(value, str):
destination = FileOutput(destination_path=os.path.abspath(value))
else:
destination = StringOutput(encoding='unicode')
super().__set__(instance, destination)
