def publishPage(self,key): src = self.pages[key].rst pubpath = os.path.join(rootpath,"public",key) try: os.makedirs(os.path.split(pubpath)[0]) except: pass # Soft reset traveler.features.reset() writer = Writer() writer.translator_class = HTMLTranslatorForLegalResourceRegistry keylst = key.split("/") upset = [".."] * (len(keylst)-1) css = os.path.sep.join(upset + ["screen.css"]) octicons = os.path.sep.join(upset + ["bower_components/octicons/octicons/octicons.css"]) options = { "stylesheet": octicons + "," + css, "stylesheet_path": None, "embed_stylesheet": False, "footnote_backlinks": True, "input_encoding": "utf-8" } src = src + '\n.. raw:: html\n\n </div>\n' html = publish_string(src, reader=None, reader_name='standalone', writer=writer, settings_overrides=options) if self.writePages: codecs.open(pubpath, "w+", "utf-8").write(html)
def check_valid_RST(myString, use_mathjax=False): """ Checks to see whether the input string is valid reStructuredText_. :param str myString: the candidate reStructuredText_ input. :param bool use_mathjax: if ``True``, then use MathJax_ for math formulae. Default is ``False``. :returns: ``True`` if valid, otherwise ``False``. :rtype: bool .. seealso:: :py:meth:`convert_string_RST <nprstuff.npremail.convert_string_RST>`. .. _MathJax: https://www.mathjax.org """ overrides = { 'input_encoding': 'unicode', 'doctitle_xform': True, 'initial_header_level': 1 } if use_mathjax: overrides['math_output'] = 'mathjax' htmlwriter = Writer() htmlwriter.translator_class = MyHTMLTranslator parts = core.publish_parts(source=myString, source_path=None, destination_path=None, writer_name='html', writer=htmlwriter, settings_overrides=overrides) body = parts['body'] html = BeautifulSoup(body, 'lxml') error_messages = html.find_all('p', {'class': 'system-message-title'}) return len(error_messages) == 0
def main(): """ Parses the given ReST file or the redirected string input and returns the HTML body. Usage: rest2html < README.rst rest2html README.rst """ try: text = codecs.open(sys.argv[1], 'r', 'utf-8').read() except IOError: # given filename could not be found return '' except IndexError: # no filename given text = sys.stdin.read() writer = Writer() writer.translator_class = GitHubHTMLTranslator parts = publish_parts(text, writer=writer, settings_overrides=SETTINGS) if 'html_body' in parts: html = parts['html_body'] # publish_parts() in python 2.x return dict values as Unicode type # in py3k Unicode is unavailable and values are of str type if isinstance(html, str): return html else: return html.encode('utf-8') return ''
def index(): flask.url_for('static', filename='github.css') flask.url_for('static', filename='semantic-1.2.0/semantic.css') flask.url_for('static', filename='semantic-1.2.0/semantic.js') flask.url_for('static', filename='qubes.css') input_filename = '/home/user/w/qubes-tools/NOTES.rst' # sys.argv.append('NOTES.rst') try: #text = codecs.open(sys.argv[1], 'r', 'utf-8').read() #with open(input_filename, "r", 'utf-8') as source: with open(input_filename, "r") as source: text = source.read().encode('utf-8') except IOError: # given filename could not be found return '' except IndexError: # no filename given text = sys.stdin.read() writer = Writer() writer.translator_class = rest2html.GitHubHTMLTranslator parts = docutils.core.publish_parts(text, writer=writer, settings_overrides=rest2html.SETTINGS) if 'html_body' in parts: print parts['html_body'] html = flask.Markup(parts['html_body']) # publish_parts() in python 2.x return dict values as Unicode type # in py3k Unicode is unavailable and values are of str type if isinstance(html, str): return flask.render_template('index.html', html=html) else: return flask.render_template('index.html', html=html.encode('utf-8')) return flask.render_template('index.html', html='')
def main(): # Create a writer to deal with the generic element we may have created. writer = Writer() writer.translator_class = MyTranslator description = ( 'Generates (X)HTML documents from standalone reStructuredText ' 'sources. Be forgiving against unknown elements. ' + default_description) # the parser processes the settings too late: we want to decide earlier if # we are running or testing. if ('--test-patch' in sys.argv and not ('-h' in sys.argv or '--help' in sys.argv)): return test_patch(writer) else: # Make docutils lenient. patch_docutils() overrides = { # If Pygments is missing, code-block directives are swallowed # with Docutils >= 0.9. 'syntax_highlight': 'none', # not available on Docutils < 0.8 so can't pass as an option 'math_output': 'HTML', } publish_cmdline(writer=writer, description=description, settings_spec=LenientSettingsSpecs, settings_overrides=overrides) return 0
def rst_to_html(rst_string, settings=None): """Convert a string written in reStructuredText to an HTML string. :param rst_string: A string that holds the contents of a reStructuredText document. :param settings: Optional. A dictionary which overrides the default settings. For a list of the possible keys and values, see http://docutils.sourceforge.net/docs/user/config.html. To log the values used, pass in ``'dump_settings': 'yes'``. """ writer = Writer() writer.translator_class = HTMLTranslator if settings is None: settings = { # Include a time/datestamp in the document footer. 'datestamp': '%Y-%m-%d %H:%M UTC', # Recognize and link to standalone PEP references (like "PEP 258"). 'pep_references': 1, # Do not report any system messages. 'report_level': 'none', # Recognize and link to standalone RFC references (like "RFC 822"). 'rfc_references': 1, } return core.publish_string(rst_string, writer=writer, settings_overrides=settings)
def __init__(self): core.Publisher.__init__(self) self.set_reader('standalone', None, 'restructuredtext') writer = Writer() # we don't want HTML headers in our writer writer.translator_class = NoHeaderHTMLTranslator self.writer = writer # go with the defaults self.get_settings() self.settings.xml_declaration = "" # this is needed, but doesn't seem to do anything self.settings._destination = '' # use no stylesheet self.settings.stylesheet = '' self.settings.stylesheet_path = '' self.settings.embed_stylesheet = False # don't break if we get errors self.settings.halt_level = 6 # remember warnings self.warnings = ''
def rst2html(rst): from docutils.core import publish_string from docutils.writers.html4css1 import Writer, HTMLTranslator class xia2HTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) def visit_table(self, node): self.context.append(self.compact_p) self.compact_p = True classes = " ".join(["docutils", self.settings.table_style]).strip() self.body.append( self.starttag(node, "table", CLASS=classes, border="0")) def write_colspecs(self): self.colspecs = [] xia2_root_dir = os.path.dirname(xia2.__file__) args = { "stylesheet_path": os.path.join(xia2_root_dir, "css", "voidspace.css") } w = Writer() w.translator_class = xia2HTMLTranslator return publish_string(rst, writer=w, settings=None, settings_overrides=args)
def rst2html(rst): from docutils.core import publish_string from docutils.writers.html4css1 import Writer,HTMLTranslator class xia2HTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) def visit_table(self, node): self.context.append(self.compact_p) self.compact_p = True classes = ' '.join(['docutils', self.settings.table_style]).strip() self.body.append( self.starttag(node, 'table', CLASS=classes, border="0")) def write_colspecs(self): self.colspecs = [] xia2_root_dir = libtbx.env.find_in_repositories("xia2", optional=False) args = { 'stylesheet_path': os.path.join(xia2_root_dir, 'css', 'voidspace.css') } w = Writer() w.translator_class = xia2HTMLTranslator return publish_string(rst, writer=w, settings=None, settings_overrides=args)
def publishPage(self, key): src = self.pages[key].rst pubpath = os.path.join(rootpath, "public", key) try: os.makedirs(os.path.split(pubpath)[0]) except: pass # Soft reset traveler.features.reset() writer = Writer() writer.translator_class = HTMLTranslatorForLegalResourceRegistry keylst = key.split("/") upset = [".."] * (len(keylst) - 1) css = os.path.sep.join(upset + ["screen.css"]) octicons = os.path.sep.join( upset + ["bower_components/octicons/octicons/octicons.css"]) options = { "stylesheet": octicons + "," + css, "stylesheet_path": None, "embed_stylesheet": False, "footnote_backlinks": True, "input_encoding": "utf-8" } src = src + '\n.. raw:: html\n\n </div>\n' html = publish_string(src, reader=None, reader_name='standalone', writer=writer, settings_overrides=options) if self.writePages: codecs.open(pubpath, "w+", "utf-8").write(html)
def convert_string_RST(myString, use_mathjax=False): """ Converts a valid reStructuredText_ input string into rich HTML. :param str myString: the candidate reStructuredText_ input. :param bool use_mathjax: if ``True``, then use MathJax_ for math formulae. Default is ``False``. :returns: If the input string is valid reStructuredText_, returns the rich HTML as a :py:class:`string <str>`. Otherwise emits a :py:meth:`logging error message <logging.error>` and returns ``None``. :rtype: str .. seealso:: :py:meth:`check_valid_RST <nprstuff.npremail.check_valid_RST>`. """ if not check_valid_RST(myString): logging.error("Error, could not convert %s into RST." % myString) return None overrides = { 'input_encoding': 'unicode', 'doctitle_xform': True, 'initial_header_level': 1 } if use_mathjax: overrides['math_output'] = 'mathjax' htmlwriter = Writer() htmlwriter.translator_class = MyHTMLTranslator parts = core.publish_parts(source=myString, source_path=None, destination_path=None, writer_name='html', writer=htmlwriter, settings_overrides=overrides) html_body = parts['whole'] html = BeautifulSoup(html_body, 'lxml') return html.prettify()
def render_rst(rst_filename): class HTMLFragmentTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) self.head_prefix = ['', '', '', '', ''] self.body_prefix = [] self.body_suffix = [] self.stylesheet = [] def astext(self): return ''.join(self.body) html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator def rest_to_html(s): result = core.publish_string(s, writer=html_fragment_writer) result = result.decode('utf8') root = lxml.html.fromstring(result) nodes = root.xpath('//div[@class="document"]') assert len(nodes) == 1 return lxml.html.tostring(nodes[0], encoding=str) if not rst_filename: return u'' elif rst_filename.endswith('.rst'): fn = os.path.join(os.path.dirname(__file__), 'content', rst_filename) if not os.path.exists(fn): raise IOError('RST file {} not found'.format(fn)) with open(fn) as fp: rst_data = fp.read() return rest_to_html(rst_data) else: return rest_to_html(rst_filename)
def render(raw: str, stream: Optional[IO[str]] = None, **kwargs: Any) -> Optional[str]: if stream is None: # Use a io.StringIO as the warning stream to prevent warnings from # being printed to sys.stderr. stream = io.StringIO() settings = SETTINGS.copy() settings["warning_stream"] = stream writer = Writer() writer.translator_class = ReadMeHTMLTranslator try: parts = publish_parts(raw, writer=writer, settings_overrides=settings) except SystemMessage: rendered = None else: rendered = parts.get("docinfo", "") + parts.get("fragment", "") if rendered: return clean(rendered) else: # If the warnings stream is empty, docutils had none, so add ours. if not stream.tell(): stream.write("No content rendered from RST source.") return None
def rst2html(rst): from docutils.core import publish_string from docutils.writers.html4css1 import Writer, HTMLTranslator class xia2HTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) def visit_table(self, node): self.context.append(self.compact_p) self.compact_p = True classes = ' '.join(['docutils', self.settings.table_style]).strip() self.body.append( self.starttag(node, 'table', CLASS=classes, border="0")) def write_colspecs(self): self.colspecs = [] xia2_root_dir = libtbx.env.find_in_repositories("xia2", optional=False) args = { 'stylesheet_path': os.path.join(xia2_root_dir, 'css', 'voidspace.css') } w = Writer() w.translator_class = xia2HTMLTranslator return publish_string(rst, writer=w, settings=None, settings_overrides=args)
def getPublicCmsReSTWriter(): global _PublicCmsReSTWriter, _PublicReSTTranslator if not _PublicCmsReSTWriter: _PublicCmsReSTWriter = Writer() _PublicCmsReSTWriter.translator_class = _PublicReSTTranslator return _PublicCmsReSTWriter
def test_docutils(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") # from https://gist.github.com/mastbaum/2655700 import docutils.core from docutils.nodes import TextElement, Inline from docutils.parsers.rst import Directive, directives from docutils.writers.html4css1 import Writer, HTMLTranslator class foo(Inline, TextElement): pass class Foo(Directive): required_arguments = 1 optional_arguments = 0 has_content = True def run(self): thenode = foo(text=self.arguments[0]) return [thenode] class MyHTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) def visit_foo(self, node): self.body.append(self.starttag( node, 'span', '', style='background:red')) self.body.append("<!--foo-->") def depart_foo(self, node): self.body.append('<!--foo--></span>') directives.register_directive('foo', Foo) html_writer = Writer() html_writer.translator_class = MyHTMLTranslator rest_text = ''' this is a test ============== it is only a test .. foo:: whee '''.replace(" ", "") bhtml = docutils.core.publish_string( source=rest_text, writer=html_writer) typstr = str # unicode# html = typstr(bhtml, encoding="utf8") if "<!--foo-->" not in html: raise Exception(html)
def convert_string_fragment(string): """ Converts a string of reST text into an html fragment (ie no <header>, <body>, etc tags). """ html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator return core.publish_string(_fix_indent(string), writer = html_fragment_writer, # Suppress output of warnings in html settings_overrides={'report_level':'5'})
def form_example(self, ctx): form = formal.Form() form.addField('restString', formal.String(required=True), widgetFactory=formal.ReSTTextArea) if docutilsAvailable: w = Writer() w.translator_class = CustomisedHTMLTranslator form.addField('customRestString', formal.String(required=True), formal.widgetFactory(formal.ReSTTextArea, restWriter=w)) form.addAction(self.submitted) return form
def convert_string_fragment(string): """ Converts a string of reST text into an html fragment (ie no <header>, <body>, etc tags). """ html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator return core.publish_string( _fix_indent(string), writer=html_fragment_writer, # Suppress output of warnings in html settings_overrides={'report_level': '5'})
def form_example(self, ctx): form = formal.Form() form.addField('restString', formal.String(required=True), widgetFactory=formal.ReSTTextArea) if docutilsAvailable: w = Writer() w.translator_class = CustomisedHTMLTranslator form.addField( 'customRestString', formal.String(required=True), formal.widgetFactory(formal.ReSTTextArea, restWriter=w)) form.addAction(self.submitted) return form
def renderHtml(string): class NoHeaderHTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) self.head_prefix = ['', '', '', '', ''] self.body_prefix = [] self.body_suffix = [] self.stylesheet = [] w = Writer() w.translator_class = NoHeaderHTMLTranslator r = Reader() return core.publish_string(string, writer=w, reader=r)
def restructured_to_html(s): """ Convert RST string to HTML string. """ if not s: return s html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator #html = docutils.core.publish_string(s, writer=html_fragment_writer) parts = docutils.core.publish_parts(source=s, writer_name='html') return parts['body_pre_docinfo']+parts['fragment']
def test_docutils(self): # from https://gist.github.com/mastbaum/2655700 import docutils.core from docutils.nodes import TextElement, Inline from docutils.parsers.rst import Directive from docutils.writers.html4css1 import Writer, HTMLTranslator class foo(Inline, TextElement): pass class Foo(Directive): required_arguments = 1 optional_arguments = 0 has_content = True def run(self): thenode = foo(text=self.arguments[0]) return [thenode] class MyHTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) def visit_foo(self, node): self.body.append( self.starttag(node, 'span', '', style='background:red')) self.body.append("<!--foo-->") def depart_foo(self, node): self.body.append('<!--foo--></span>') directives.register_directive('foo', Foo) html_writer = Writer() html_writer.translator_class = MyHTMLTranslator rest_text = ''' this is a test ============== it is only a test .. foo:: whee '''.replace(" ", "") bhtml = docutils.core.publish_string(source=rest_text, writer=html_writer) typstr = str # unicode# html = typstr(bhtml, encoding="utf8") if "<!--foo-->" not in html: raise Exception(html)
def about(request, template="about.html"): """ Convert the README file into HTML. """ from docutils.core import publish_string from docutils.writers.html4css1 import Writer, HTMLTranslator writer = Writer() writer.translator_class = HTMLTranslator with open(join(settings.PROJECT_ROOT, "README.rst"), "r") as f: about = publish_string(f.read(), writer=writer) with open(join(settings.PROJECT_ROOT, "LICENSE"), "r") as f: license = publish_string(f.read(), writer=writer) context = {"about": about, "license": license} return render(request, template, context)
def render(self, request, text, settings_overrides={}): overrides = { 'halt_level': 6, 'input_encoding': 'unicode', 'output_encoding': 'unicode', 'initial_header_level': 3, } overrides.update(settings_overrides) writer = Writer() writer.translator_class = Translator html = docutils.core.publish_string( text, writer=writer, settings_overrides=overrides, ) return html
def render(raw): # Use a io.StringIO as the warning stream to prevent warnings from being # printed to sys.stderr. settings = SETTINGS.copy() settings["warning_stream"] = io.StringIO() writer = Writer() writer.translator_class = ReadMeHTMLTranslator try: parts = publish_parts(raw, writer=writer, settings_overrides=settings) except SystemMessage: rendered = None else: rendered = parts.get("fragment") return clean(rendered or raw), bool(rendered)
def render(self, settings_overrides={}): # default settings for the renderer overrides = { 'halt_level': 6, 'input_encoding': 'unicode', 'output_encoding': 'unicode', 'initial_header_level': 3, } overrides.update(settings_overrides) writer = Writer() writer.translator_class = HTMLTranslator html = docutils.core.publish_file( source_path=self.context, writer=writer, settings_overrides=overrides, ) return html
def render(self): settings_overrides = { 'halt_level': 6, 'input_encoding': 'utf8', 'output_encoding': 'utf8', 'initial_header_level': 2, # don't try to include the stylesheet (docutils gets hiccups) 'stylesheet_path': '', } writer = Writer() writer.translator_class = ZopeTranslator html = docutils.core.publish_string( self.content, writer=writer, settings_overrides=settings_overrides, ) return html
def render(self, text, **kwargs): settings_overrides = { "cloak_email_addresses": True, "file_insertion_enabled": False, "raw_enabled": False, "strip_comments": True, "doctitle_xform": False, "report_level": 5, "syntax_highlight": "none", "math_output": "latex", "input_encoding": "utf-8", "output_encoding": "utf-8", } writer = Writer() writer.translator_class = GitHubHTMLTranslator output = publish_parts(text, writer=writer, settings_overrides=settings_overrides) if "html_body" in output: return output["html_body"] return ""
def rst_to_html(rst_string, settings=None): """Convert a string written in reStructuredText to an HTML string. :param rst_string: A string that holds the contents of a reStructuredText document. :param settings: Optional. A dictionary which overrides the default settings. For a list of the possible keys and values, see http://docutils.sourceforge.net/docs/user/config.html. To log the values used, pass in ``'dump_settings': 'yes'``. """ writer = Writer() writer.translator_class = HTMLTranslator if settings is None: document = core.publish_string(rst_string, writer=writer, settings_overrides=SETTINGS) return str(document, "utf-8")
def render(self, text, **kwargs): settings_overrides = { 'cloak_email_addresses': True, 'file_insertion_enabled': False, 'raw_enabled': False, 'strip_comments': True, 'doctitle_xform': False, 'report_level': 5, 'syntax_highlight': 'none', 'math_output': 'latex', 'input_encoding': 'utf-8', 'output_encoding': 'utf-8' } writer = Writer() writer.translator_class = GitHubHTMLTranslator output = publish_parts( text, writer=writer, settings_overrides=settings_overrides ) if 'html_body' in output: return output['html_body'] return ''
def render(raw, stream=None, **kwargs): if stream is None: # Use a io.StringIO as the warning stream to prevent warnings from # being printed to sys.stderr. stream = io.StringIO() settings = SETTINGS.copy() settings["warning_stream"] = stream writer = Writer() writer.translator_class = ReadMeHTMLTranslator try: parts = publish_parts(raw, writer=writer, settings_overrides=settings) except SystemMessage: rendered = None else: rendered = parts.get("docinfo", "") + parts.get("fragment", "") if rendered: return clean(rendered) else: return None
def render(raw, stream=None): if stream is None: # Use a io.StringIO as the warning stream to prevent warnings from # being printed to sys.stderr. stream = io.StringIO() settings = SETTINGS.copy() settings["warning_stream"] = stream writer = Writer() writer.translator_class = ReadMeHTMLTranslator try: parts = publish_parts(raw, writer=writer, settings_overrides=settings) except SystemMessage: rendered = None else: rendered = parts.get("fragment") if rendered: return clean(rendered) else: return None
def render(self): r"""See zope.app.interfaces.renderer.IHTMLRenderer Let's make sure that inputted unicode stays as unicode: >>> renderer = ReStructuredTextToHTMLRenderer(u'b\xc3h', None) >>> renderer.render() u'<p>b\xc3h</p>\n' """ settings_overrides = { 'halt_level': 6, 'input_encoding': 'unicode', 'output_encoding': 'unicode', 'initial_header_level': 3 } writer = Writer() writer.translator_class = ZopeTranslator html = docutils.core.publish_string( self.context, writer=writer, settings_overrides=settings_overrides, ) return html
def main(): # Create a writer to deal with the generic element we may have created. writer = Writer() writer.translator_class = MyTranslator description = ( 'Generates (X)HTML documents from standalone reStructuredText ' 'sources. Be forgiving against unknown elements. ' + default_description) # the parser processes the settings too late: we want to decide earlier if # we are running or testing. if ('--test-patch' in sys.argv and not ('-h' in sys.argv or '--help' in sys.argv)): return test_patch(writer) else: # Make docutils lenient. patch_docutils() publish_cmdline(writer=writer, description=description, settings_spec=LenientSettingsSpecs) return 0
def render(self, text, **kwargs): settings_overrides = { 'cloak_email_addresses': True, 'file_insertion_enabled': False, 'raw_enabled': False, 'strip_comments': True, 'doctitle_xform': False, 'report_level': 5, 'syntax_highlight': 'none', 'math_output': 'MathJax', 'input_encoding': 'utf-8', 'output_encoding': 'utf-8', 'stylesheet_dirs': [os.path.normpath(os.path.join(docutils_dir, Writer.default_stylesheet))], 'template': os.path.normpath(os.path.join(docutils_dir, Writer.default_template)) } writer = Writer() writer.translator_class = GitHubHTMLTranslator output = publish_parts( text, writer=writer, settings_overrides=settings_overrides ) if 'html_body' in output: return output['html_body'] return ''
def render(self, text, **kwargs): settings_overrides = { 'cloak_email_addresses': True, 'file_insertion_enabled': False, 'raw_enabled': False, 'strip_comments': True, 'doctitle_xform': False, 'report_level': 5, 'syntax_highlight': 'short', 'math_output': 'latex', 'input_encoding': 'utf-8', 'output_encoding': 'utf-8', 'stylesheet_dirs': [os.path.normpath(os.path.join(docutils_dir, Writer.default_stylesheet))], 'template': os.path.normpath(os.path.join(docutils_dir, Writer.default_template)) } writer = Writer() writer.translator_class = GitHubHTMLTranslator output = publish_parts( text, writer=writer, settings_overrides=settings_overrides ) if 'html_body' in output: return output['html_body'] return ''
PKGINFO = False try: from docutils import core from docutils.writers.html4css1 import Writer,HTMLTranslator class NoHeaderHTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) self.head_prefix = ['','','','',''] self.body_prefix = [] self.body_suffix = [] self.stylesheet = [] _w = Writer() _w.translator_class = NoHeaderHTMLTranslator RESTIFY=True except: RESTIFY = False import math if sys.version_info > (3,): long = int class Size( long ): """ define a size class to allow custom formatting Implements a format specifier of S for the size class - which displays a human readable in b, kb, Mb etc """ def __format__(self, fmt): if fmt == "" or fmt[-1] != "S": if fmt[-1].tolower() in ['b','c','d','o','x','n','e','f','g','%']:
import os.path from django.conf import settings from django.template.defaultfilters import slugify from docutils.core import publish_string from docutils.writers.html4css1 import Writer, HTMLTranslator import mezzanine from mezzanine.utils.importing import path_for_import # Convert the overview documentation page from RST to HTML. writer = Writer() writer.translator_class = HTMLTranslator try: path = os.path.join(path_for_import("mezzanine"), "..", "docs", "overview.rst") with open(path, "r") as f: data = f.read() path = os.path.join(path_for_import("mezzanine"), "..", "README.rst") with open(path, "r") as f: data = data.replace(".. include:: ../README.rst", f.read()) except IOError: OVERVIEW = "" else: OVERVIEW = publish_string(data, writer=writer) # Grab the list items inside a blockquote after each title, and # assign them to variables for the homepage. project_context = {"version": mezzanine.__version__} for section in ("Sites Using Mezzanine", "Quotes", "Features"):
and atts['href'].startswith('mailto:')): atts['href'] = self.cloak_mailto(atts['href']) self.in_mailto = 1 atts['class'] += ' external' else: assert node.has_key('refid'), \ 'References must have "refuri" or "refid" attribute.' atts['href'] = self.document.settings.url + '#' + node['refid'] atts['class'] += ' internal' if not isinstance(node.parent, nodes.TextElement): assert len(node) == 1 and isinstance(node[0], nodes.image) atts['class'] += ' image-reference' self.body.append(self.starttag(node, 'a', '', **atts)) g_writer = Writer() g_writer.translator_class = SummaryTranslator def init_publisher(): from docutils.core import Publisher from docutils.io import StringOutput p = Publisher(destination_class=StringOutput,writer=g_writer) p.get_settings() p.set_components('standalone', 'restructuredtext', 'html') p.set_destination(None, None) return p def load_articles(inputfile=sys.stdin): src_dir = 'src/' filename_reg = re.compile(r'^(\d+-\d+-\d+)_(.*)') for fullname in inputfile.readlines(): fullname = fullname.strip()
class my_Writer(Writer): def translate(self): self.visitor = visitor = self.translator_class(self.document) self.document.walkabout(visitor) for attr in self.visitor_attributes: #cur_attr = getattr(visitor, attr) #print(attr + '=' + str(cur_attr)) setattr(self, attr, getattr(visitor, attr)) #pdb.set_trace() self.output = self.apply_template() self.output = ''.join(self.body) #here is the template: #u'%(head_prefix)s\n%(head)s\n%(stylesheet)s\n%(body_prefix)s\n%(body_pre_docinfo)s\n%(docinfo)s\n%(body)s\n%(body_suffix)s\n' _w = Writer() _w.translator_class = MyHTMLTranslator#NoHeaderHTMLTranslator _w2 = Writer() _w2.translator_class = NoHeaderHTMLTranslator _w0 = my_Writer() _w0.translator_class = NoHeaderHTMLTranslator0 def reSTify(string): return core.publish_string(string,writer=_w)
def html(self, input_text): from docutils import core from docutils.writers.html4css1 import Writer writer = Writer() writer.translator_class = self.translator_class return core.publish_string(input_text, writer=writer)
class HTMLFragmentTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) self.head_prefix = ['', '', '', '', ''] self.body_prefix = [] self.body_suffix = [] self.stylesheet = [] def astext(self): return ''.join(self.body) html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator def locale_(plugin_id, s): # Search the plugin that's rendering the template for the requested locale if plugin_id == 'prism': ns = prism.settings.PRISM_LOCALE[s] else: plugin = prism.get_plugin(plugin_id) if plugin is None: prism.output('Unknown plugin ID. Offender: %s' % plugin_id) return s ns = plugin.locale[s]
def render(raw): settings = { # Cloaking email addresses provides a small amount of additional # privacy protection for email addresses inside of a chunk of ReST. "cloak_email_addresses": True, # Prevent a lone top level heading from being promoted to document # title, and thus second level headings from being promoted to top # level. "doctitle_xform": True, # Set our initial header level "initial_header_level": 2, # Prevent local files from being included into the rendered output. # This is a security concern because people can insert files # that are part of the system, such as /etc/passwd. "file_insertion_enabled": False, # Halt rendering and throw an exception if there was any errors or # warnings from docutils. "halt_level": 2, # Output math blocks as LaTeX that can be interpreted by MathJax for # a prettier display of Math formulas. "math_output": "MathJax", # Disable raw html as enabling it is a security risk, we do not want # people to be able to include any old HTML in the final output. "raw_enabled": False, # Disable all system messages from being reported. "report_level": 5, # Use typographic quotes, and transform --, ---, and ... into their # typographic counterparts. "smart_quotes": True, # Strip all comments from the rendered output. "strip_comments": True, # Use the short form of syntax highlighting so that the generated # Pygments CSS can be used to style the output. "syntax_highlight": "short", # Use a io.StringIO as the warning stream to prevent warnings from # being printed to sys.stderr. "warning_stream": io.StringIO(), } writer = Writer() writer.translator_class = HTMLTranslator try: parts = publish_parts(raw, writer=writer, settings_overrides=settings, ) except SystemMessage as exc: raise ValueError(exc.message) rendered = parts.get("fragment") if rendered is None: raise ValueError("There was no rendered value") return rendered
from docutils import core from docutils.writers.html4css1 import Writer, HTMLTranslator class NoHeaderHTMLTranslator(HTMLTranslator): def __init__(self, document): HTMLTranslator.__init__(self, document) self.head_prefix = ['', '', '', '', ''] self.body_prefix = [] self.body_suffix = [] #~ self.stylesheet = [] _w = Writer() _w.translator_class = NoHeaderHTMLTranslator def rest_to_html(string): return core.publish_string(string, writer=_w) def test1(): test = """ Test example of reST__ document. __ http://docutils.sf.net/rst.html - item 1 - item 2 - item 3
def rst_to_html(rst): html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLTranslator return docutils.core.publish_string(rst, writer=html_fragment_writer)
def main(): """Parses command-line arguments for an input file, then processes it using PyCite.""" writer = Writer() writer.translator_class = HTMLTranslator reader = Reader() publish_cmdline(reader=reader, writer=writer)
# keyword arguments (attributes) are turned into html tag key/value # pairs, e.g. `{'style':'background:red'} => 'style="background:red"'` self.body.append( self.starttag(node, 'span', '', style='background:red')) def depart_foo(self, node): self.body.append('</span>') # register the directive, telling docutils to apply `Foo` when the parser # encounters a `foo` directives.register_directive('foo', Foo) # create a `Writer` and set phasers to `MyHTMLTranslator` html_writer = Writer() html_writer.translator_class = MyHTMLTranslator rest_text = \ '''this is a test ============== it is only a test .. foo:: whee ''' # use the writer to turn some ReST text into a string of HTML html = docutils.core.publish_string(source=rest_text, writer=html_writer) print html # write a webpage (or serve it, or whatever)
from reST-formatted docstrings """ def __init__(self, document): super().__init__(document) self.body_prefix = [] self.body_suffix = [] def visit_bullet_list(self, node): self.context.append((self.compact_simple, self.compact_p)) self.compact_p = None self.compact_simple = self.is_compactable(node) self.body.append(self.starttag(node, 'ul', CLASS='docstring')) DOCSTRING_WRITER = Writer() DOCSTRING_WRITER.translator_class = NoHeaderHTMLTranslator @register.filter def safe_docstring_display(docstring): """ Utility function to htmlize reST-formatted documentation in browsable api. """ docstring = cleandoc(docstring) return publish_parts(docstring, writer=DOCSTRING_WRITER)['html_body'] @register.filter def urlize_links_and_mails(text): """Utility function for decorating api links in browsable api.
def rst_to_html(text): """Convert reStructured text to html.""" w = Writer() w.translator_class = NoHeaderHTMLTranslator return core.publish_string(text, writer=w)
from docutils import core from docutils.writers.html4css1 import Writer,HTMLTranslator class HTMLFragmentTranslator( HTMLTranslator ): def __init__( self, document ): HTMLTranslator.__init__( self, document ) self.head_prefix = ['','','','',''] self.body_prefix = [] self.body_suffix = [] self.stylesheet = [] def astext(self): return ''.join(self.body) html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator def reST_to_html( s ): return core.publish_string( s, writer = html_fragment_writer )
def reSTify(string): _w = Writer() _w.translator_class = NoHeaderHTMLTranslator return core.publish_string(string, writer=_w)
def gen_folder(): project_root = os.path.normpath(os.path.join(__file__, '..', '..')) codebase = os.path.join(project_root, 'server', 'codebase') configs = ( { 'source': os.path.join(codebase, 'docpie'), 'target': os.path.join(project_root, 'build', 'static', 'docpie'), }, { 'source': os.path.join(codebase, 'docpie.wiki'), 'target': os.path.join(project_root, 'build', 'static', 'docpie-wiki'), }, ) fenced_code_re = re.compile( r'(?P<indent>\s+)```(?P<lang>[\w\ \-_]*)(?P<content>.*?)\ +```', re.DOTALL) for config in configs: source_folder = config['source'] target_folder = config['target'] if not os.path.isdir(target_folder): os.makedirs(target_folder) _dirpath, _dirnames, filenames = next(os.walk(source_folder)) for filename in filenames: print('processing {}'.format(filename)) filebase, fileext = os.path.splitext(filename) fileext_lower = fileext.lower() if fileext_lower == '.md': filetype = 'md' elif fileext_lower == '.rst': filetype = 'rst' else: continue with open(os.path.join(source_folder, filename), 'r', encoding='utf-8') as f: content_raw = f.read() if '```' in content_raw: # middle_parts = [] # content_parts = content_raw.split('```') # # first_part = content_parts.pop(0) # last_part = content_parts.pop(-1) # for content, codepart in zip(content_parts[::2], content_parts[1::2]): # middle_parts.append(content) # # print(codepart) # code_parts = codepart.splitlines() # language = code_parts.pop(0) # code_rejoined = textwrap.dedent('\n'.join(code_parts)).replace('\n','<br />').rstrip() # # middle_parts.append(""" # <div class="codehilite"> # <pre class="language-{lang}"><code>{content}</code></pre> # </div> # """.format(lang=language, content=code_rejoined) # ) # content = '\n'.join(middle_parts) + last_part content = fenced_code_re.sub( lambda matchobj: """ {indent}<div class="codehilite"><pre class="language-{lang}"><code>{content}</code></pre></div> """.format(lang=matchobj.groupdict()['lang'], indent=matchobj.groupdict()['indent'].replace( '\n', ''), content=html.escape( textwrap.dedent(matchobj.groupdict()['content']) .rstrip())[1:]).replace('\n', '<br />'), content_raw) # print(content) # assert False else: content = content_raw if filetype == 'md': if filebase == 'Usage-Format': # content = content.replace('\\<argument\\>', '<argument>') content_body = content.split('\n\n', 1)[1].replace( '\\<argument\\>', '<argument>') content = '[TOC]\n\n' + content_body html_content = markdown.markdown( content, extensions=[ 'markdown.extensions.fenced_code', 'markdown.extensions.footnotes', 'markdown.extensions.codehilite', 'markdown.extensions.toc', ]) # html_content = content # html = markdown2.markdown(content, extras=[ # 'toc', # 'fenced-code-blocks', # 'footnotes', # ]) elif filetype == 'rst': html_fragment_writer = Writer() html_fragment_writer.translator_class = HTMLFragmentTranslator html_content = core.publish_string( content, writer=html_fragment_writer).decode('utf-8') if filebase in ('Home', '_Sidebar'): html_content = re.sub( '\\[\\[(.*?)\\]\\]', lambda matchobj: '<a href="/document/{link}">{linkname}</a>'.format( link=matchobj.group(1).replace(' ', '-'), linkname=matchobj.group(1)), html_content) soup = BeautifulSoup(html_content, 'html5lib') for link in soup.find_all('a'): href = link.get('href') if href and (href.startswith('http://') or href.startswith('https://')): url_obj = urlparse(href) if url_obj.hostname in ('docpie.comes.today', 'docpie.notexists.top'): url = urlunparse(('', '', url_obj.path, url_obj.params, url_obj.query, url_obj.fragment)) link['href'] = url for pre in soup.find_all('pre'): # break inner_pre = pre.decode_contents() pre_class = pre.get('class') or [] inner_break = inner_pre.replace('\n', '<br />') pre_soup = BeautifulSoup( '<pre class="{classes}">{content}</pre>'.format( classes=' '.join(pre_class), content=inner_break), 'html5lib') pre.replace_with(pre_soup.find('pre')) body = soup.body.decode_contents() target_filename = filebase + '.html' logger.info('saving %s', target_filename) with open(os.path.join(target_folder, target_filename), 'w', encoding='utf-8') as t: t.write(body)
import os.path from docutils.core import publish_string from docutils.writers.html4css1 import Writer,HTMLTranslator import mezzanine from mezzanine.utils.importing import path_for_import # Convert the README file from RST to HTML. writer = Writer() writer.translator_class = HTMLTranslator path = os.path.join(path_for_import("mezzanine"), "..", "README.rst") try: with open(path, "r") as f: data = f.read() except IOError: README = "" else: README = publish_string(data, writer=writer) # Grab the list items inside a blockquote after each title, and # assign them to variables for the homepage. project_context = {"version": mezzanine.__version__} for section in ("Sites Using Mezzanine", "Quotes", "Features"): items = README.split("<h2>%s</h2>" % section)[1] \ .split("<li>", 1)[1].split("</li>\n</ul>")[0] \ .split("</li>\n<li>") project_context[section.split()[0].lower()] = items
def __init__(self, document): HTMLTranslator.__init__(self, document) self.head = "" self.head_prefix = ['', '', '', '', ''] self.body_prefix = [] self.body_suffix = [] self.stylesheet = [] def visit_document(self, node): pass def depart_document(self, node): self.fragment = self.body _w = Writer() _w.translator_class = CleanedHTMLTranslator def get_html_from_rst(rst): return core.publish_string(rst, writer=_w) def get_html_from_md(md): return misaka.html(md) _bbcode_markup = postmarkup.create() def get_html_from_bbcode(bbcode): return _bbcode_markup(bbcode)