def entry_point(source, use_proxy=False): from docutils.core import publish_string if use_proxy: return publish_string(source, writer_name="codeplex", writer=Writer(translator=TranslatorWithProxy)) return publish_string(source, writer_name="codeplex", writer=Writer(translator=CodePlexTranslator))
def showDocs(self): """ Display info from filter design file and docstring """ if hasattr(fb.filObj,'info'): if self.chkRichText.isChecked(): self.txtFiltInfoBox.setText(publish_string( self.cleanDoc(fb.filObj.info), writer_name='html', settings_overrides={'output_encoding': 'unicode'})) else: self.txtFiltInfoBox.setText(textwrap.dedent(fb.filObj.info)) else: self.txtFiltInfoBox.setText("") if self.chkDocstring.isChecked() and hasattr(fb.filObj,'info_doc'): if self.chkRichText.isChecked(): self.txtFiltInfoBox.append( '<hr /><b>Python module docstring:</b>\n') for doc in fb.filObj.info_doc: self.txtFiltInfoBox.append(publish_string( self.cleanDoc(doc), writer_name='html', settings_overrides = {'output_encoding': 'unicode'})) else: self.txtFiltInfoBox.append('\nPython module docstring:\n') for doc in fb.filObj.info_doc: self.txtFiltInfoBox.append(self.cleanDoc(doc)) # self.txtFiltInfoBox.textCursor().setPosition(pos) # no effect self.txtFiltInfoBox.moveCursor(QtGui.QTextCursor.Start)
def _show_doc(self): """ Display info from filter design file and docstring """ if hasattr(ff.fil_inst,'info'): if self.chkRichText.isChecked(): self.txtFiltInfoBox.setText(publish_string( self._clean_doc(ff.fil_inst.info), writer_name='html', settings_overrides={'output_encoding': 'unicode'})) else: self.txtFiltInfoBox.setText(textwrap.dedent(ff.fil_inst.info)) else: self.txtFiltInfoBox.setText("") if self.chkDocstring.isChecked() and hasattr(ff.fil_inst,'info_doc'): if self.chkRichText.isChecked(): self.txtFiltInfoBox.append( '<hr /><b>Python module docstring:</b>\n') for doc in ff.fil_inst.info_doc: self.txtFiltInfoBox.append(publish_string( self._clean_doc(doc), writer_name='html', settings_overrides = {'output_encoding': 'unicode'})) else: self.txtFiltInfoBox.append('\nPython module docstring:\n') for doc in ff.fil_inst.info_doc: self.txtFiltInfoBox.append(self._clean_doc(doc)) self.txtFiltInfoBox.moveCursor(QTextCursor.Start)
def parse_docstring(docstring, errors, **options): writer = _DocumentPseudoWriter() reader = _EpydocReader(errors) # Outputs errors to the list. publish_string(docstring, writer=writer, reader=reader, settings_overrides={'report_level': 10000, 'halt_level': 10000, 'warning_stream': None}) return MyParsedRstDocstring(writer.document)
def do(self, source): writer = Writer() core.publish_string(source, writer=writer) meta = Meta() meta.title = ''.join(writer.title) meta.slug = None meta.labels = [] meta.subtitle = ''.join(writer.subtitle) meta.footer = ''.join(writer.footer) return ''.join(writer.body), meta
def html_string(text): """ Converts the strng from restructuredText to HTML and prepends the CSS string. """ try: return __CSS + publish_string( text, writer_name="html", settings_overrides={'report_level': 'quiet'}, ) except TypeError: return __CSS + publish_string(text, writer_name="html")
def test_README_as_PyPi_landing_page(self): from docutils import core as dcore long_desc = subprocess.check_output( 'python setup.py --long-description'.split(), cwd=proj_path) self.assertIsNotNone(long_desc, 'Long_desc is null!') with patch('sys.exit'): dcore.publish_string(long_desc, enable_exit_status=False, settings_overrides={ # see `docutils.frontend` for more. 'halt_level': 2 # 2=WARN, 1=INFO })
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 main(): benchmarks = {} # Run all of the performance comparisons. print tests modules = MODULE_LIST for testname, method in tests.iteritems(): benchmarks[testname] = {} results = [None for module in modules] for i, module in enumerate(modules): print 'module', module # We pre-compile the pattern, because that's # what people do. current_re[0] = module.compile(method.pattern) try: results[i] = method(current_re[0], **method.data) except: results[i] = -1 # Run a test. t = Timer("test(current_re[0],**test.data)", setup_code % testname) try: benchmarks[testname][module.__name__] = (t.timeit(method.num_runs), method.__doc__.strip(), method.pattern, method.num_runs) except: benchmarks[testname][module.__name__] = (-1, method.__doc__.strip(), method.pattern, method.num_runs) for i in xrange(len(results)): print >> sys.stderr, 'result', modules[i], results[i] for i in range(len(results) - 1): if results[i] != results[i + 1]: print >> sys.stderr, modules[i], results[i] print >> sys.stderr, modules[i+1], results[i+1] #raise ValueError("re2 output is not the same as re output: %s" % testname) print >> sys.stderr, "re2 output is not the same as re output: %s" % testname txt = benchmarks_to_ReST(benchmarks, modules) from docutils.core import publish_string print publish_string(txt, writer_name='html') print txt
def convert_rest_to_wp(restFile): 'convert ReST to WP html using docutils, rst2wp' from docutils.core import publish_string import rst2wp from xml.etree.ElementTree import XML ifile = file(restFile) # read our restructured text rest = ifile.read() ifile.close() xhtml = publish_string(rest, writer_name='xml') x = XML(xhtml) # parse the XML text title = x.find('title').text #extract its title writer = rst2wp.Writer() html = publish_string(rest, writer=writer) # convert to wordpress return title,html
def rst_file_to_html(file_path): with open(settings.PROJECT_PATH + "/" + file_path) as f: content = f.readlines() a_line = "".join(content) html = core.publish_string(source=a_line, writer_name="html") html = html[html.find("<body>") + 6 : html.find("</body>")].strip() return html
def test_patch(writer): """Verify that patching docutils works as expected.""" TEST_SOURCE = """` Hello `role`:norole: .. nodirective:: """ rv = 0 problems = [] exc = None # patch and use lenient docutils try: try: patch_docutils() except Exception, exc: problems.append("error during library patching") raise try: out = publish_string(TEST_SOURCE, writer=writer, settings_spec=LenientSettingsSpecs) except Exception, exc: problems.append("error while running patched docutils") raise
def publish_xml_cmdline (in_path = None, in_string = None, out_path = None, settings_overrides=None ): try: import locale locale.setlocale(locale.LC_ALL, '') except: pass from docutils.core import default_description, default_usage, publish_file, publish_string import docutils.core description = ('Generates Docutils-native XML from standalone ' 'reStructuredText sources. ' + default_description) if not in_path and not in_string: raise TypeError('publish_xml_cmdlind() must have either "in_path" or "in_string" as parameters') if in_path: out_string = publish_file(source_path= in_path, destination_path=out_path, settings_overrides = settings_overrides, writer_name='xml') elif in_string: out_string = publish_string(source= in_string, destination_path=out_path, settings_overrides = settings_overrides, writer_name='xml') return out_string
def convert_rest_html(source, source_path, stylesheet=None, encoding='latin1'): from py.__.rest import directive """ return html latin1-encoded document for the given input. source a ReST-string sourcepath where to look for includes (basically) stylesheet path (to be used if any) """ from docutils.core import publish_string directive.set_backend_and_register_directives("html") kwargs = { 'stylesheet' : stylesheet, 'stylesheet_path': None, 'traceback' : 1, 'embed_stylesheet': 0, 'output_encoding' : encoding, #'halt' : 0, # 'info', 'halt_level' : 2, } # docutils uses os.getcwd() :-( source_path = os.path.abspath(str(source_path)) prevdir = os.getcwd() try: #os.chdir(os.path.dirname(source_path)) return publish_string(source, source_path, writer_name='html', settings_overrides=kwargs) finally: os.chdir(prevdir)
def save(self, *args, **kwargs): # Update the Project's URIs docutils_settings = getattr(settings, "RESTRUCTUREDTEXT_FILTER_SETTINGS", {}) docutils_settings.update({"warning_stream": os.devnull}) try: html_string = publish_string(source=smart_str(self.description), writer_name="html4css1", settings_overrides=docutils_settings) if html_string.strip(): html = lxml.html.fromstring(html_string) for link in html.xpath("//a/@href"): try: if any(urlparse.urlparse(link)[:5]): PackageURI.objects.get_or_create(package=self.package, uri=link) except ValueError: pass except Exception: # @@@ We Swallow Exceptions here, but it's the best way that I can think of atm. pass super(Release, self).save(*args, **kwargs) _current_show_install_command = self.show_install_command if self.classifiers.filter(trove="Framework :: Plone").exists(): self.show_install_command = False else: self.show_install_command = True if _current_show_install_command != self.show_install_command: super(Release, self).save(*args, **kwargs)
def __init__(self, dirpath, parent=None): self.parent = parent self.dirpath = dirpath self.dirname = os.path.split(self.dirpath)[-1] self.children = [] self.path = self.parent and '%s%s/' % (self.parent.path, self.dirname) \ or '/' self.root = self while self.root.parent: self.root = self.root.parent # Get reST as XML rstfilepath = os.path.join(self.dirpath, POST_NAME) rstfile = codecs.open(rstfilepath, encoding='utf-8') self.rst = unicode(rstfile.read()) rstfile.close() xmlstring = publish_string(self.rst, writer_name='xml') self.xml = etree.parse(StringIO(xmlstring), Directory.parser) # Get metadata for this post self.title = self.xml.xpath('title/text()')[0] # todo: tags, date and other metadat that might be used in navigation # Add to the XML site structure attributes = { 'path': self.path, 'title': self.title,} self.element = etree.Element('directory', **attributes) if self.parent: parent.element.append(self.element) # Recurse self.find_children()
def rst2html(rst, theme=None, opts=None): r"""Render rst string and returns the HTML rendered string Quite straitghtforward at first view: >>> rst = '=====\nTitle\n=====\n\ntest\n====\ntext' >>> print rst2html(rst).strip() # doctest: +ELLIPSIS <h1...>Title</h1> <h2...>test</h2> <p>text</p> Notice how this is HTML part that must be included in a complete HTML document. """ rst_opts = default_rst_opts.copy() if opts: rst_opts.update(opts) default_template_name = 'template.txt' rst_opts['template'] = os.path.join(os.path.dirname(__file__), default_template_name) out = publish_string(rst, writer_name='html', settings_overrides=rst_opts) return out
def format_post_from_string(body, initial_header_level=4): """Returns a tuple containing the title and an HTML string for the post body. """ try: html = publish_string( body, writer_name='html', settings_overrides={'initial_header_level': initial_header_level, 'generator': False, 'traceback': True, 'syntax_highlight': 'short', }, ) if not html: raise ValueError('No HTML produced by docutils') except Exception as err: raise RuntimeError('Could not convert input file to HTML: %s' % err) # Pull out the body of the HTML to make the blog post, # removing the H1 element with the title. d = PyQuery(html, parser='html') title = d('body').find('h1:first').html() d('body').find('h1:first').remove() content = d('body').html() return title, content
def process_rst (filename, body): "Parse 'body' as RST and convert it to HTML" output_file = StringIO.StringIO() settings = { 'input_encoding': 'utf-8', 'output_encoding': 'utf-8', # cloak email addresses to reduce spam 'cloak_email_addresses': 1, # Forbid file inclusion 'file_insertion_enabled': False, # remove reST comments from output HTML: 'strip_comments': True, } body = core.publish_string( reader_name='standalone', parser_name='restructuredtext', writer=WeblogWriter(), writer_name='html', source_path=filename, source=body, destination_path=filename, settings=None, settings_overrides=settings) # Return a Unicode string. body = unicode(body, 'utf-8') return body
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 _get_desc(self, cr, uid, ids, field_name=None, arg=None, context=None): res = dict.fromkeys(ids, "") for module in self.browse(cr, uid, ids, context=context): path = get_module_resource(module.name, "static/description/index.html") if path: with tools.file_open(path, "rb") as desc_file: doc = desc_file.read() html = lxml.html.document_fromstring(doc) for element, attribute, link, pos in html.iterlinks(): if ( element.get("src") and not "//" in element.get("src") and not "static/" in element.get("src") ): element.set("src", "/%s/static/description/%s" % (module.name, element.get("src"))) res[module.id] = html_sanitize(lxml.html.tostring(html)) else: overrides = { "embed_stylesheet": False, "doctitle_xform": False, "output_encoding": "unicode", "xml_declaration": False, } output = publish_string( source=module.description or "", settings_overrides=overrides, writer=MyWriter() ) res[module.id] = html_sanitize(output) return res
def _get_html_description(self, cr, uid, ids, name, arg, context=None): res = {}.fromkeys(ids, '') for product in self.browse(cr, uid, ids, context): overrides = dict(embed_stylesheet=False, doctitle_xform=False, output_encoding='unicode') output = publish_string(source=product.description, settings_overrides=overrides, writer=MyWriter()) res[product.id] = output return res
def _get_desc(self, cr, uid, ids, field_name=None, arg=None, context=None): res = dict.fromkeys(ids, '') for module in self.browse(cr, uid, ids, context=context): overrides = dict(embed_stylesheet=False, doctitle_xform=False, output_encoding='unicode') output = publish_string(source=module.description, settings_overrides=overrides, writer=MyWriter()) res[module.id] = output return res
def test_output(self): """Check that parsing input files provides the expected output files. """ input_filenames = glob(os.path.join(self.fixtures_dir, '*-input.txt')) if not input_filenames: self.fail('No fixtures found') for input_filename in input_filenames: with open(input_filename) as input_file: input_str = input_file.read() real_output = publish_string(source=input_str, writer_name='rst2rst') output_filename = input_filename.replace('input.txt', 'output.txt') output_filename = os.path.join(self.fixtures_dir, output_filename) with open(output_filename) as output_file: theoric_output = output_file.read() if real_output != theoric_output: theoric_output = theoric_output.replace('\n', '\\n\n') real_output = real_output.replace('\n', '\\n\n') diff = [] real_output_lines = real_output.splitlines(True) theoric_output_lines = theoric_output.splitlines(True) for line in unified_diff(real_output_lines, theoric_output_lines): diff.append(line) diff = ''.join(diff) msg = "Content generated from %s differs from content at %s" \ "\nDiff:\n%s" % ( input_filename, output_filename, diff ) self.fail(msg)
def convert_rest_html(source, source_path, stylesheet=None, encoding="latin1"): """ return html latin1-encoded document for the given input. source a ReST-string sourcepath where to look for includes (basically) stylesheet path (to be used if any) """ from docutils.core import publish_string kwargs = { "stylesheet": stylesheet, "stylesheet_path": None, "traceback": 1, "embed_stylesheet": 0, "output_encoding": encoding, #'halt' : 0, # 'info', "halt_level": 2, } # docutils uses os.getcwd() :-( source_path = os.path.abspath(str(source_path)) prevdir = os.getcwd() try: # os.chdir(os.path.dirname(source_path)) return publish_string(source, source_path, writer_name="html", settings_overrides=kwargs) finally: os.chdir(prevdir)
def rst2html(rst, header_level=3): """ Converts ReStructured Text `rst` to a block of HTML for incorporation into another HTML file -- so it strips html/head/body tags. Use higher `header_level` values if you already have <h1> in the destination HTML. """ # Make a custom template for rst2thml that does not insert the # html/head/body tags. tmp = tempfile.mktemp() fout = open(tmp, 'w') fout.write(dedent( ''' %(body_pre_docinfo)s %(body)s ''')) fout.close() settings_overrides = { 'template': tmp, 'initial_header_level': header_level, 'doctitle_xform': False, 'strip_classes': 'simple', } return publish_string( rst, writer_name='html', settings_overrides=settings_overrides )
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 rst2html(rst, theme=None, opts=None, body_only=False): rst_opts = default_rst_opts.copy() rst_opts['warning_stream'] = StringIO() if body_only: out = publish_parts(rst, writer_name='html', settings_overrides=rst_opts)['html_body'] rst_opts['warning_stream'].seek(0) warnings = rst_opts['warning_stream'].read() return out, warnings if opts: rst_opts.update(opts) rst_opts['template'] = os.path.join(THEMES, 'template.txt') stylesheets = ['basic.css'] if theme: stylesheets.append('%s/%s.css' % (theme, theme)) rst_opts['stylesheet'] = ','.join([J(THEMES, p) for p in stylesheets]) out = publish_string(rst, writer_name='html', settings_overrides=rst_opts) rst_opts['warning_stream'].seek(0) warnings = rst_opts['warning_stream'].read() return out, warnings
def make_message(rc, to, subject='', body='', attachments=()): """Creates an email following the approriate format. The body kwarg may be a string of restructured text. Attachements is a list of filenames to attach. """ msg = MIMEMultipart('alternative') plain = MIMEText(body, 'plain') msg.attach(plain) if publish_string is not None: html = publish_string(body, writer_name='html', settings_overrides={'output_encoding': 'unicode'}) html = MIMEText(html, 'html') msg.attach(html) if attachments: text = msg msg = MIMEMultipart('mixed') msg.attach(text) for attachment in attachments: _, ext = os.path.splitext(attachment) att = ATTACHERS[ext](attachment) att.add_header('content-disposition', 'attachment', filename=os.path.basename(attachment)) msg.attach(att) msg['Subject'] = subject msg['From'] = rc.email['from'] msg['To'] = to return (to, msg.as_string())
def classes(format, destpath, classnames): for c in classnames: output_filename = os.path.join(destpath, c + '.' + format) module_name, classname = c.rsplit('.', 1) mod = importlib.import_module(module_name) klass = getattr(mod, classname) #try: with open(output_filename, 'w') as output: tmp = io.StringIO() tmp.write("#" * len(klass.__name__)) tmp.write("\n") tmp.write(klass.__name__) tmp.write('\n') tmp.write("#" * len(klass.__name__)) tmp.write("\n\n") tmp.write(str(napoleon.GoogleDocstring(klass.__doc__))) tmp.write('\n\n') builder = SchemaHelpBuilder(klass.schema, fmt=format) tmp.write(builder.rst) if format == 'html': output.write(publish_string(tmp.getvalue(), writer_name='html', settings_overrides={"stylesheet_path": "sondra/css/flasky.css"}).decode('utf-8')) elif format == 'rst': output.write(tmp.getvalue()) logging.info("Wrote {0} to {1}".format(c, output_filename))
def post(self): if publish_string is None: raise web.HTTPError(503, u'docutils not available') body = self.request.body.strip() source = body # template_path=os.path.join(os.path.dirname(__file__), u'templates', u'rst_template.html') defaults = { 'file_insertion_enabled': 0, 'raw_enabled': 0, '_disable_config': 1, 'stylesheet_path': 0 # 'template': template_path } try: html = publish_string(source, writer_name='html', settings_overrides=defaults) except: raise web.HTTPError(400, u'Invalid RST') print html self.set_header('Content-Type', 'text/html') self.finish(html)
def _get_desc(self, cr, uid, ids, field_name=None, arg=None, context=None): res = dict.fromkeys(ids, '') for module in self.browse(cr, uid, ids, context=context): path = get_module_resource(module.name, 'static/description/index.html') if path: with tools.file_open(path, 'rb') as desc_file: doc = desc_file.read() html = lxml.html.document_fromstring(doc) for element, attribute, link, pos in html.iterlinks(): if element.get('src') and not '//' in element.get('src') and not 'static/' in element.get('src'): element.set('src', "/%s/static/description/%s" % (module.name, element.get('src'))) res[module.id] = lxml.html.tostring(html) else: overrides = { 'embed_stylesheet': False, 'doctitle_xform': False, 'output_encoding': 'unicode', 'xml_declaration': False, } output = publish_string(source=module.description or '', settings_overrides=overrides, writer=MyWriter()) res[module.id] = output return res
def _render_rst_to_jinja_templating(course, page_path, content): cache_pages = syllabus.get_config()["caching"]["cache_pages"] toc = syllabus.get_toc(course) print_mode = session.get("print_mode", False) # look if we have a cached version of this content if cache_pages and toc.has_cached_content(content, print_mode): with open(safe_join(syllabus.get_pages_path(course), content.cached_path(print_mode)), "r") as f: rendered = f.read() else: # render the content with open(safe_join(syllabus.get_pages_path(course), page_path), "r") as f: rendered = publish_string(f.read(), writer_name='html', settings_overrides=default_rst_opts) if cache_pages: # cache the content if needed if type(content) is Page: parent = toc.get_parent_of(content) os.makedirs(safe_join(toc.cached_path(print_mode), parent.path if parent is not None else ""), exist_ok=True) else: os.makedirs(safe_join(toc.cached_path(print_mode), content.path), exist_ok=True) with open(safe_join(syllabus.get_pages_path(course), content.cached_path(print_mode)), "w") as cached_content: cached_content.write(rendered) return rendered
def test_full_build_http_store(self): source = dedent(""" .. smtimage:: foo :digest: 0123456789abcdef :align: center """) config = dedent(""" [general] sumatra_record_store: http://smt.example.com/ sumatra_project: MyProject sumatra_link_icon: icon_info.png """) with open("docutils.conf", "w") as fp: fp.write(config) output = publish_string(source, writer_name='pseudoxml') self.assertEqual( "\n" + output, dedent(""" <document source="<string>"> <reference refuri="http://smt.example.com/MyProject/foo/"> <image align="center" alt="Data file generated by computation foo" digest="0123456789abcdef" uri="smt_images/bar.jpg"> """))
def main(): ## pub = core.Publisher(writer=OOwriter.Writer()) ## pub.set_reader('standalone', None, 'restructuredtext') ## settings = pub.get_settings() ## pub.source = io.FileInput(settings, source_path=sys.argv[1]) ## pub.destination = io.StringOutput(settings) ## content = pub.publish() source = file(sys.argv[1]).read() content = core.publish_string(source, writer=OOwriter.Writer()) xml_manifest_list = [ ('content.xml', content), ('styles.xml', OOtext.styles) ] xml_entries = [] for docname, _ in xml_manifest_list: xml_entries.append(OOtext.m_xml_format % docname) image_manifest_list = OOtext.pictures image_entries = [] for name, format in image_manifest_list: image_entries.append(format) manifest = OOtext.manifest % ('\n '.join(image_entries), '\n '.join(xml_entries)) xml_manifest_list.append(('META-INF/manifest.xml', manifest)) zip = zipfile.ZipFile(sys.argv[2], "w") for docname, contents in xml_manifest_list: zinfo = zipfile.ZipInfo(docname) zip.writestr(zinfo, contents) for name, format in image_manifest_list: zip.write(name, 'Pictures/' + name) zip.close()
def parse(self, input_data, reason): if not RstParser.extensions_registered: # need to do this only once... directives.register_directive('intro', IntroDirective) for extension in self.app.markup_extensions: if extension.is_block_level: directives.register_directive( extension.name, make_extension_directive(self.app, extension)) else: roles.register_local_role(extension.name, make_extension_role(extension)) RstParser.extensions_registered = True settings_overrides = { 'file_insertion_enabled': False, 'parsing_reason': reason, } rv = publish_string(source=input_data, writer=ZemlWriter(), settings_overrides=settings_overrides) if reason == 'comment': rv = sanitize(rv) return rv
def docs(): """ Prepare documentation. """ import re from docutils.core import publish_string settings = dict( datestamp='%Y-%m-%d', generator=True, strict=True, toc_backlinks=None, cloak_email_addresses=True, initial_header_level=3, stylesheet_path='doc/style.css', ) rst = open('readme.txt').read() html = publish_string(rst, writer_name='html4css1', settings_overrides=settings) html = re.sub('<col.*>\n', '', html) html = re.sub('</colgroup>', '', html) open('index.html', 'w').write(html) return
def rst_to_html( s ): """Convert a blob of reStructuredText to HTML""" log = logging.getLogger( "docutils" ) if docutils_core is None: raise Exception("Attempted to use rst_to_html but docutils unavailable.") class FakeStream( object ): def write( self, str ): if len( str ) > 0 and not str.isspace(): log.warning( str ) settings_overrides = { "embed_stylesheet": False, "template": os.path.join(os.path.dirname(__file__), "docutils_template.txt"), "warning_stream": FakeStream(), "doctitle_xform": False, # without option, very different rendering depending on # number of sections in help content. } return unicodify( docutils_core.publish_string( s, writer=docutils_html4css1.Writer(), settings_overrides=settings_overrides ) )
def format_docs(rst): # store full html output to html variable writer = Writer() html = publish_string(source=rst, writer=writer, writer_name='html', settings_overrides={ 'link': 'link', 'top': 'top' }) # disable system message in html, no in stderr parts = publish_parts(source=rst, writer=writer, writer_name='html', settings_overrides={'report_level': 5}) # store only html body body = parts['html_title'] + parts['body'] + parts['html_line'] + \ parts['html_footnotes'] + parts['html_citations'] + \ parts['html_hyperlinks'] return body
def gen_man_page(self, name, rst): from docutils.writers import manpage from docutils.core import publish_string from docutils.nodes import inline from docutils.parsers.rst import roles def issue(name, rawtext, text, lineno, inliner, options={}, content=[]): return [inline(rawtext, '#' + text)], [] roles.register_local_role('issue', issue) # We give the source_path so that docutils can find relative includes # as-if the document where located in the docs/ directory. man_page = publish_string(source=rst, source_path='docs/%s.rst' % name, writer=manpage.Writer()) with open('docs/man/%s.1' % name, 'wb') as fd: fd.write(man_page)
def reST_to_html(s): """ Convert ReST-formatted string `s` into HTML. Output is intended for uploading to UCSC configuration pages, so this uses a whitelist approach for HTML tags. """ html = publish_string( source=s, writer_name='html', settings=None, settings_overrides={'embed_stylesheet': False}, ) safe = bleach.ALLOWED_TAGS + [ 'p', 'img', 'pre', 'tt', 'a', 'h1', 'h2', 'h3', 'h4' ] attributes = { 'img': ['alt', 'src'], 'a': ['href'], } return bleach.clean(html, tags=safe, strip=True, attributes=attributes)
def code_to_html_string( # See code_str_. code_str, # A file-like object where warnings and errors will be written, or None to # send them to stderr. warning_stream=None, # See `options <options>`. **options): rest = code_to_rest_string(code_str, **options) # `docutils # <http://docutils.sourceforge.net/docs/user/tools.html#rst2html-py>`_ # converts reST to HTML. html = core.publish_string( rest, writer_name="html", settings_overrides={ # Include our custom css file: provide the path to the default css and # then to our css. The style sheet dirs must include docutils defaults. "stylesheet_path": ",".join(Writer.default_stylesheets + ["CodeChat.css"]), "stylesheet_dirs": Writer.default_stylesheet_dirs + html_static_path(), # Make sure to use Unicode everywhere. "output_encoding": "unicode", "input_encoding": "unicode", # Don't stop processing, no matter what. "halt_level": 5, # Capture errors to a string and return it. "warning_stream": warning_stream, }, ) return html
def _gen_docutils_html(source, fpath, webpage_style, no_header, html_assets, traceback, Parser, Reader): from docutils.core import publish_string from .docutils import HtmlTranslator, HtmlWriter # The encoding/decoding dance below happens because setting output_encoding # to "unicode" causes reST to generate a bad <meta> tag, and setting # input_encoding to "unicode" breaks the ‘.. include’ directive. html_assets.extend(HtmlTranslator.JS + HtmlTranslator.CSS) settings_overrides = { 'traceback': traceback, 'embed_stylesheet': False, 'stylesheet_path': None, 'stylesheet_dirs': [], 'no_header': no_header, 'webpage_style': webpage_style, 'input_encoding': 'utf-8', 'output_encoding': 'utf-8' } parser = Parser() return publish_string(source=source.encode("utf-8"), source_path=fpath, destination_path=None, reader=Reader(parser), reader_name=None, parser=parser, parser_name=None, writer=HtmlWriter(), writer_name=None, settings=None, settings_spec=None, settings_overrides=settings_overrides, config_section=None, enable_exit_status=True).decode("utf-8")
def code_to_html_string( # See code_str_. code_str, # A file-like object where warnings and errors will be written, or None to # send them to stderr. warning_stream=None, # See `options <options>`. **options): rest = code_to_rest_string(code_str, **options) # `docutils # <http://docutils.sourceforge.net/docs/user/tools.html#rst2html-py>`_ # converts reST to HTML. html = core.publish_string( rest, writer_name='html', settings_overrides={ # Include our custom css file: provide the path to the default css and # then to our css. The style sheet dirs must include docutils defaults. 'stylesheet_path': ','.join(Writer.default_stylesheets + ['CodeChat.css']), 'stylesheet_dirs': Writer.default_stylesheet_dirs + [os.path.join(os.path.dirname(__file__), 'template')], # Make sure to use Unicode everywhere. 'output_encoding': 'unicode', 'input_encoding': 'unicode', # Don't stop processing, no matter what. 'halt_level': 5, # Capture errors to a string and return it. 'warning_stream': warning_stream }) return html
def save_table_to_file(table_data, errors, group_name, metric_type, file_extension): """ Saves a group results table or overall results table to a given file type. @param table_data :: the results table @param errors :: whether to use observational errors @param group_name :: name of this group of problems (example 'NIST "lower difficulty"', or 'Neutron data') @param metric_type :: the test type of the table data (e.g. runtime, accuracy) @param file_extension :: the file type extension (e.g. html) """ file_name = ('comparison_{weighted}_{version}_{metric_type}_{group_name}.' .format(weighted=weighted_suffix_string(errors), version=BENCHMARK_VERSION_STR, metric_type=metric_type, group_name=group_name)) if file_extension == 'html': rst_content = '.. include:: ' + str(os.path.join(SCRIPT_DIR, 'color_definitions.txt')) rst_content += '\n' + table_data table_data = publish_string(rst_content, writer_name='html') with open(file_name + file_extension, 'w') as tbl_file: print(table_data, file=tbl_file) print('Saved {file_name}{extension} to {working_directory}'. format(file_name=file_name, extension=file_extension, working_directory=WORKING_DIR))
def upload(fname, space, parent_id): """Upload documentation for CMake module ``fname`` as child of page with id ``parent_id``.""" pagename = path.splitext(path.basename(fname))[0] rst = '\n'.join(extract(fname)) if not rst: return log.debug('=' * 79) log.info('Uploading %s', pagename) log.debug('=' * 79) log.debug('rST') log.debug('-' * 79) log.debug(rst) log.debug('-' * 79) log.debug('Confluence') log.debug('-' * 79) cwiki = publish_string(rst, writer=confluence.Writer()) log.debug(cwiki) page = { 'type': 'page', 'title': pagename, 'space': { 'key': space }, 'body': { 'storage': { 'value': cwiki, 'representation': 'wiki' } }, 'ancestors': [{ 'type': 'page', 'id': parent_id }] } create_or_update(page, space)
def rst2latex(rst_string, no_preamble=True, allow_latex=True): """ Calls docutils' engine to convert a rst string to a LaTeX file. """ overrides = { 'output_encoding': 'utf-8', 'initial_header_level': 3, 'no_doc_title': True, 'use_latex_citations': True, 'use_latex_footnotes': True } if allow_latex: rst_string = u'''.. role:: math(raw) :format: latex \n\n''' + rst_string tex_string = docCore.publish_string(source=rst_string, writer_name='latex2e', settings_overrides=overrides) if no_preamble: extract_document = \ re.compile(r'.*\\begin\{document\}(.*)\\end\{document\}', re.DOTALL) matches = extract_document.match(tex_string) tex_string = matches.groups()[0] return tex_string
def rst2htmlcode(rst_text, theme=None, settings={}): # register graphviz directive directives.register_directive('dot', docutils_graphviz.Graphviz) output = None try: overrides = {} mathjax = settings.get('mathjax') if mathjax: overrides['math_output'] = ' '.join(['MathJax', mathjax]) del settings['mathjax'] overrides.update(default_overrides) overrides.update(settings) overrides.update(get_theme_settings(theme)) logger.debug(overrides) output = publish_string( rst_text, writer_name='html5', settings_overrides=overrides, ) except Exception as err: logger.error(err) output = str(err) return output
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] if s == ns: return s ns = publish_string( ns, writer=html_fragment_writer).decode('utf-8').rstrip('\r\n') if '<p>' not in ns: return '' ns = ns.split('<p>', 1)[1] ns = ns[:ns.rfind('</p>')] return jinja2.Markup(ns)
def _get_desc(self): for module in self: if not module.name: module.description_html = False continue path = modules.get_module_resource(module.name, 'static/description/index.html') if path: with tools.file_open(path, 'rb') as desc_file: doc = desc_file.read() html = lxml.html.document_fromstring(doc) for element, attribute, link, pos in html.iterlinks(): if element.get('src') and not '//' in element.get('src') and not 'static/' in element.get('src'): element.set('src', "/%s/static/description/%s" % (module.name, element.get('src'))) module.description_html = tools.html_sanitize(lxml.html.tostring(html)) else: overrides = { 'embed_stylesheet': False, 'doctitle_xform': False, 'output_encoding': 'unicode', 'xml_declaration': False, 'file_insertion_enabled': False, } output = publish_string(source=module.description if not module.application and module.description else '', settings_overrides=overrides, writer=MyWriter()) module.description_html = tools.html_sanitize(output)
def parse_rst(): inpt = request.form["rst"] out = publish_string(inpt, writer_name='html') return out
from __future__ import absolute_import from __future__ import print_function import glob, os, sys try: from docutils.core import publish_string except: print('*** Install docutils to convert README.rst') sys.exit(0) if not os.path.isfile('README.rst'): print('*** README.rst file not found in %s' % os.getcwd()) sys.exit() if (sys.version_info > (3,0)): html_string=publish_string(open('README.rst').read(),writer_name='html', settings_overrides={'output_encoding': 'unicode'}) else: html_string=publish_string(open('README.rst').read(),writer_name='html') make_files = glob.glob("Makefile") f_files = glob.glob("*.f") + glob.glob("*.f90") py_files = glob.glob("*.py") m_files = glob.glob("*.m") ipynb_files = glob.glob("*.ipynb") out_dirs = glob.glob("_out*") # not currently listed on html page plot_dirs = glob.glob("_plots") # for gallery -- want only main _plots #plot_dirs = glob.glob("_plot*") # might want to list other plot directories make_text = "\n" for f in make_files:
def execute(hdf, text, env): def do_trac(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): return trac(env, name, arguments, options, content, lineno, content_offset, block_text, state, state_machine) def do_trac_role(name, rawtext, text, lineno, inliner, options={}, content=[]): return trac_role(env, name, rawtext, text, lineno, inliner, options, content) # 1 required arg, 1 optional arg, spaces allowed in last arg do_trac.arguments = (1,1,1) do_trac.options = None do_trac.content = None rst.directives.register_directive('trac', do_trac) rst.roles.register_local_role('trac', do_trac_role) # The code_block could is taken from the leo plugin rst2 def code_block(name,arguments,options,content,lineno,content_offset,block_text,state,state_machine): """Create a code-block directive for docutils. Usage: .. code-block:: language If the language can be syntax highlighted it will be.""" from trac.WikiFormatter import Formatter language = arguments[0] code_processor = None if Formatter.builtin_processors.has_key(language): code_processor = Formatter.builtin_processors[language] else: code_processor = Formatter.builtin_processors['default'] html = code_processor(hdf, '\n'.join(content), env) raw = 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' : rst.directives.unchanged # Return the text argument, unchanged } code_block.content = 1 # True if content is allowed. # Register the directive with docutils. rst.directives.register_directive('code-block',code_block) _inliner = rst.states.Inliner() _parser = rst.Parser(inliner = _inliner) html = publish_string(text, writer_name = 'html', parser = _parser, settings_overrides = {'halt_level':6}) return html[html.find('<body>')+6:html.find('</body>')].strip()
def rst2html(data): """Converts a reStructuredText into its HTML """ if not data: return '' return core.publish_string(data, writer=_FragmentWriter())
pass def visit_graphviz(self,node): self.body.append('Graphviz: ') def depart_graphviz(self,node): pass def visit_container(self,node): self.body.append('[stem]\n') self.body.append('++++') def depart_container(self,node): self.body.append('++++') if __name__ == "__main__": """ To test the writer """ from docutils.core import publish_string filename = sys.argv[-1] print('Converting: '+ filename) f_in = open(filename, 'rb') rtf = publish_string(f_in.read(), writer=AsciiDocWriter()) f_in.close() filename = filename+'.adoc' f_out = open(filename, 'wb') f_out.write(rtf) print('Converted file: ' + filename) f_out.close()
def reST_to_html(s): return core.publish_string(s, writer=html_fragment_writer)
if previous_end < len(text): yield ('text', text[previous_end:]) if __name__ == "__main__": import locale try: locale.setlocale(locale.LC_ALL, '') except: pass from docutils.core import publish_string docstring_html = publish_string(__doc__, writer_name='html') print(docstring_html) # Unit test output goes out stderr. import unittest sp = smartyPants class TestSmartypantsAllAttributes(unittest.TestCase): # the default attribute is "1", which means "all". def test_dates(self): self.assertEqual(sp("1440-80's"), "1440-80’s") self.assertEqual(sp("1440-'80s"), "1440-‘80s") self.assertEqual(sp("1440---'80s"), "1440–‘80s") self.assertEqual(sp("1960s"), "1960s") # no effect.
def rst_to_html(string): result = core.publish_string(string, writer=NoHeaderHTMLWriter()) return mark_safe(result.decode('utf-8'))
section_node.append(line_node) return [section_node] directives.register_directive('mydirective', MyCustomDirective) if __name__ == '__main__': reStructuredText_source = """===================== Custom directive test ===================== Some text .. mydirective:: MyArgument1 test test :option1: My value for option 1 :option2: 42 my directive's content block goes here multi line is ok My directive should have run now. """ # Since the directive was registered already, it should get used when # the parser runs when it encounters the ``.. mydirective::`` text. html_output = publish_string(source=reStructuredText_source, writer=html5_polyglot.Writer()) #print(html_output.decode('utf8'))
def test_wordml( input_string ): overrides = { 'template' : '../template.xml' } parts = core.publish_string( input_string, writer_name='docutils_wordml', settings_overrides=overrides ) print parts