[Python-modules-commits] [basemap] 11/19: add the matplotlib sphinxext directory into doc, needed to build
Sandro Tosi
morph at moszumanska.debian.org
Wed Jan 24 03:51:35 UTC 2018
This is an automated email from the git hooks/post-receive script.
morph pushed a commit to branch master
in repository basemap.
commit d05917bf1b4cbe12a21300d90c28c38760cb2d17
Author: Sandro Tosi <morph at debian.org>
Date: Thu Oct 8 08:29:11 2015 -0700
add the matplotlib sphinxext directory into doc, needed to build
documentaion
Forwarded: not-needed
Patch-Name: install_matplotlib_sphinxext
---
doc/sphinxext/gen_gallery.py | 124 ++++++++
doc/sphinxext/gen_rst.py | 158 ++++++++++
doc/sphinxext/inheritance_diagram.py | 407 ++++++++++++++++++++++++++
doc/sphinxext/math_symbol_table.py | 159 ++++++++++
doc/sphinxext/mathml.py | 552 +++++++++++++++++++++++++++++++++++
5 files changed, 1400 insertions(+)
diff --git a/doc/sphinxext/gen_gallery.py b/doc/sphinxext/gen_gallery.py
new file mode 100644
index 0000000..d47df8a
--- /dev/null
+++ b/doc/sphinxext/gen_gallery.py
@@ -0,0 +1,124 @@
+# generate a thumbnail gallery of examples
+template = """\
+{%% extends "layout.html" %%}
+{%% set title = "Thumbnail gallery" %%}
+
+
+{%% block body %%}
+
+<h3>Click on any image to see full size image and source code</h3>
+<br/>
+
+%s
+{%% endblock %%}
+"""
+
+import os, glob, re, sys, warnings
+import matplotlib.image as image
+
+multiimage = re.compile('(.*)_\d\d')
+
+def make_thumbnail(args):
+ image.thumbnail(args[0], args[1], 0.3)
+
+def out_of_date(original, derived):
+ return (not os.path.exists(derived) or
+ os.stat(derived).st_mtime < os.stat(original).st_mtime)
+
+def gen_gallery(app, doctree):
+ if app.builder.name != 'html':
+ return
+
+ outdir = app.builder.outdir
+ rootdir = 'plot_directive/mpl_examples'
+
+ # images we want to skip for the gallery because they are an unusual
+ # size that doesn't layout well in a table, or because they may be
+ # redundant with other images or uninteresting
+ skips = set([
+ 'mathtext_examples',
+ 'matshow_02',
+ 'matshow_03',
+ 'matplotlib_icon',
+ ])
+
+ data = []
+ thumbnails = {}
+
+ for subdir in ('api', 'pylab_examples', 'mplot3d', 'widgets', 'axes_grid' ):
+ origdir = os.path.join('build', rootdir, subdir)
+ thumbdir = os.path.join(outdir, rootdir, subdir, 'thumbnails')
+ if not os.path.exists(thumbdir):
+ os.makedirs(thumbdir)
+
+ for filename in sorted(glob.glob(os.path.join(origdir, '*.png'))):
+ if filename.endswith("hires.png"):
+ continue
+
+ path, filename = os.path.split(filename)
+ basename, ext = os.path.splitext(filename)
+ if basename in skips:
+ continue
+
+ # Create thumbnails based on images in tmpdir, and place
+ # them within the build tree
+ orig_path = str(os.path.join(origdir, filename))
+ thumb_path = str(os.path.join(thumbdir, filename))
+ if out_of_date(orig_path, thumb_path) or True:
+ thumbnails[orig_path] = thumb_path
+
+ m = multiimage.match(basename)
+ if m is None:
+ pyfile = '%s.py'%basename
+ else:
+ basename = m.group(1)
+ pyfile = '%s.py'%basename
+
+ data.append((subdir, basename,
+ os.path.join(rootdir, subdir, 'thumbnails', filename)))
+
+ link_template = """\
+ <a href="%s"><img src="%s" border="0" alt="%s"/></a>
+ """
+
+ if len(data) == 0:
+ warnings.warn("No thumbnails were found")
+
+ rows = []
+ for (subdir, basename, thumbfile) in data:
+ if thumbfile is not None:
+ link = 'examples/%s/%s.html'%(subdir, basename)
+ rows.append(link_template%(link, thumbfile, basename))
+
+ # Only write out the file if the contents have actually changed.
+ # Otherwise, this triggers a full rebuild of the docs
+ content = template%'\n'.join(rows)
+ gallery_path = os.path.join(app.builder.srcdir, '_templates', 'gallery.html')
+ if os.path.exists(gallery_path):
+ fh = file(gallery_path, 'r')
+ regenerate = fh.read() != content
+ fh.close()
+ else:
+ regenerate = True
+ if regenerate:
+ fh = file(gallery_path, 'w')
+ fh.write(content)
+ fh.close()
+
+ try:
+ import multiprocessing
+ app.builder.info("generating thumbnails... ", nonl=True)
+ pool = multiprocessing.Pool()
+ pool.map(make_thumbnail, thumbnails.iteritems())
+ pool.close()
+ pool.join()
+ app.builder.info("done")
+
+ except ImportError:
+ for key in app.builder.status_iterator(
+ thumbnails.iterkeys(), "generating thumbnails... ",
+ length=len(thumbnails)):
+ image.thumbnail(key, thumbnails[key], 0.3)
+
+def setup(app):
+ app.connect('env-updated', gen_gallery)
diff --git a/doc/sphinxext/gen_rst.py b/doc/sphinxext/gen_rst.py
new file mode 100644
index 0000000..94418ac
--- /dev/null
+++ b/doc/sphinxext/gen_rst.py
@@ -0,0 +1,158 @@
+"""
+generate the rst files for the examples by iterating over the pylab examples
+"""
+import os, glob
+
+import os
+import re
+import sys
+fileList = []
+
+def out_of_date(original, derived):
+ """
+ Returns True if derivative is out-of-date wrt original,
+ both of which are full file paths.
+
+ TODO: this check isn't adequate in some cases. Eg, if we discover
+ a bug when building the examples, the original and derived will be
+ unchanged but we still want to force a rebuild.
+ """
+ return (not os.path.exists(derived) or
+ os.stat(derived).st_mtime < os.stat(original).st_mtime)
+
+noplot_regex = re.compile(r"#\s*-\*-\s*noplot\s*-\*-")
+
+def generate_example_rst(app):
+ rootdir = os.path.join(app.builder.srcdir, 'mpl_examples')
+ exampledir = os.path.join(app.builder.srcdir, 'examples')
+ if not os.path.exists(exampledir):
+ os.makedirs(exampledir)
+
+ datad = {}
+ for root, subFolders, files in os.walk(rootdir):
+ for fname in files:
+ if ( fname.startswith('.') or fname.startswith('#') or fname.startswith('_') or
+ fname.find('.svn')>=0 or not fname.endswith('.py') ):
+ continue
+
+ fullpath = os.path.join(root,fname)
+ contents = file(fullpath).read()
+ # indent
+ relpath = os.path.split(root)[-1]
+ datad.setdefault(relpath, []).append((fullpath, fname, contents))
+
+ subdirs = datad.keys()
+ subdirs.sort()
+
+ fhindex = file(os.path.join(exampledir, 'index.rst'), 'w')
+ fhindex.write("""\
+.. _examples-index:
+
+####################
+Matplotlib Examples
+####################
+
+.. htmlonly::
+
+ :Release: |version|
+ :Date: |today|
+
+.. toctree::
+ :maxdepth: 2
+
+""")
+
+ for subdir in subdirs:
+ rstdir = os.path.join(exampledir, subdir)
+ if not os.path.exists(rstdir):
+ os.makedirs(rstdir)
+
+ outputdir = os.path.join(app.builder.outdir, 'examples')
+ if not os.path.exists(outputdir):
+ os.makedirs(outputdir)
+
+ outputdir = os.path.join(outputdir, subdir)
+ if not os.path.exists(outputdir):
+ os.makedirs(outputdir)
+
+ subdirIndexFile = os.path.join(rstdir, 'index.rst')
+ fhsubdirIndex = file(subdirIndexFile, 'w')
+ fhindex.write(' %s/index.rst\n\n'%subdir)
+
+ fhsubdirIndex.write("""\
+.. _%s-examples-index:
+
+##############################################
+%s Examples
+##############################################
+
+.. htmlonly::
+
+ :Release: |version|
+ :Date: |today|
+
+.. toctree::
+ :maxdepth: 1
+
+"""%(subdir, subdir))
+
+ sys.stdout.write(subdir + ", ")
+ sys.stdout.flush()
+
+ data = datad[subdir]
+ data.sort()
+
+ for fullpath, fname, contents in data:
+ basename, ext = os.path.splitext(fname)
+ outputfile = os.path.join(outputdir, fname)
+ #thumbfile = os.path.join(thumb_dir, '%s.png'%basename)
+ #print ' static_dir=%s, basename=%s, fullpath=%s, fname=%s, thumb_dir=%s, thumbfile=%s'%(static_dir, basename, fullpath, fname, thumb_dir, thumbfile)
+
+ rstfile = '%s.rst'%basename
+ outrstfile = os.path.join(rstdir, rstfile)
+
+ fhsubdirIndex.write(' %s\n'%rstfile)
+
+ if not out_of_date(fullpath, outrstfile):
+ continue
+
+ fh = file(outrstfile, 'w')
+ fh.write('.. _%s-%s:\n\n'%(subdir, basename))
+ title = '%s example code: %s'%(subdir, fname)
+ #title = '<img src=%s> %s example code: %s'%(thumbfile, subdir, fname)
+
+
+ fh.write(title + '\n')
+ fh.write('='*len(title) + '\n\n')
+
+ do_plot = (subdir in ('api',
+ 'pylab_examples',
+ 'units',
+ 'mplot3d',
+ 'axes_grid',
+ ) and
+ not noplot_regex.search(contents))
+
+ if do_plot:
+ fh.write("\n\n.. plot:: %s\n\n::\n\n" % fullpath)
+ else:
+ fh.write("[`source code <%s>`_]\n\n::\n\n" % fname)
+ fhstatic = file(outputfile, 'w')
+ fhstatic.write(contents)
+ fhstatic.close()
+
+ # indent the contents
+ contents = '\n'.join([' %s'%row.rstrip() for row in contents.split('\n')])
+ fh.write(contents)
+
+ fh.write('\n\nKeywords: python, matplotlib, pylab, example, codex (see :ref:`how-to-search-examples`)')
+ fh.close()
+
+ fhsubdirIndex.close()
+
+ fhindex.close()
+
+ print
+
+def setup(app):
+ app.connect('builder-inited', generate_example_rst)
diff --git a/doc/sphinxext/inheritance_diagram.py b/doc/sphinxext/inheritance_diagram.py
new file mode 100644
index 0000000..407fc13
--- /dev/null
+++ b/doc/sphinxext/inheritance_diagram.py
@@ -0,0 +1,407 @@
+"""
+Defines a docutils directive for inserting inheritance diagrams.
+
+Provide the directive with one or more classes or modules (separated
+by whitespace). For modules, all of the classes in that module will
+be used.
+
+Example::
+
+ Given the following classes:
+
+ class A: pass
+ class B(A): pass
+ class C(A): pass
+ class D(B, C): pass
+ class E(B): pass
+
+ .. inheritance-diagram: D E
+
+ Produces a graph like the following:
+
+ A
+ / \
+ B C
+ / \ /
+ E D
+
+The graph is inserted as a PNG+image map into HTML and a PDF in
+LaTeX.
+"""
+
+import inspect
+import os
+import re
+import subprocess
+try:
+ from hashlib import md5
+except ImportError:
+ from md5 import md5
+
+from docutils.nodes import Body, Element
+from docutils.parsers.rst import directives
+from sphinx.roles import xfileref_role
+
+def my_import(name):
+ """Module importer - taken from the python documentation.
+
+ This function allows importing names with dots in them."""
+
+ mod = __import__(name)
+ components = name.split('.')
+ for comp in components[1:]:
+ mod = getattr(mod, comp)
+ return mod
+
+class DotException(Exception):
+ pass
+
+class InheritanceGraph(object):
+ """
+ Given a list of classes, determines the set of classes that
+ they inherit from all the way to the root "object", and then
+ is able to generate a graphviz dot graph from them.
+ """
+ def __init__(self, class_names, show_builtins=False):
+ """
+ *class_names* is a list of child classes to show bases from.
+
+ If *show_builtins* is True, then Python builtins will be shown
+ in the graph.
+ """
+ self.class_names = class_names
+ self.classes = self._import_classes(class_names)
+ self.all_classes = self._all_classes(self.classes)
+ if len(self.all_classes) == 0:
+ raise ValueError("No classes found for inheritance diagram")
+ self.show_builtins = show_builtins
+
+ py_sig_re = re.compile(r'''^([\w.]*\.)? # class names
+ (\w+) \s* $ # optionally arguments
+ ''', re.VERBOSE)
+
+ def _import_class_or_module(self, name):
+ """
+ Import a class using its fully-qualified *name*.
+ """
+ try:
+ path, base = self.py_sig_re.match(name).groups()
+ except:
+ raise ValueError(
+ "Invalid class or module '%s' specified for inheritance diagram" % name)
+ fullname = (path or '') + base
+ path = (path and path.rstrip('.'))
+ if not path:
+ path = base
+ try:
+ module = __import__(path, None, None, [])
+ # We must do an import of the fully qualified name. Otherwise if a
+ # subpackage 'a.b' is requested where 'import a' does NOT provide
+ # 'a.b' automatically, then 'a.b' will not be found below. This
+ # second call will force the equivalent of 'import a.b' to happen
+ # after the top-level import above.
+ my_import(fullname)
+
+ except ImportError:
+ raise ValueError(
+ "Could not import class or module '%s' specified for inheritance diagram" % name)
+
+ try:
+ todoc = module
+ for comp in fullname.split('.')[1:]:
+ todoc = getattr(todoc, comp)
+ except AttributeError:
+ raise ValueError(
+ "Could not find class or module '%s' specified for inheritance diagram" % name)
+
+ # If a class, just return it
+ if inspect.isclass(todoc):
+ return [todoc]
+ elif inspect.ismodule(todoc):
+ classes = []
+ for cls in todoc.__dict__.values():
+ if inspect.isclass(cls) and cls.__module__ == todoc.__name__:
+ classes.append(cls)
+ return classes
+ raise ValueError(
+ "'%s' does not resolve to a class or module" % name)
+
+ def _import_classes(self, class_names):
+ """
+ Import a list of classes.
+ """
+ classes = []
+ for name in class_names:
+ classes.extend(self._import_class_or_module(name))
+ return classes
+
+ def _all_classes(self, classes):
+ """
+ Return a list of all classes that are ancestors of *classes*.
+ """
+ all_classes = {}
+
+ def recurse(cls):
+ all_classes[cls] = None
+ for c in cls.__bases__:
+ if c not in all_classes:
+ recurse(c)
+
+ for cls in classes:
+ recurse(cls)
+
+ return all_classes.keys()
+
+ def class_name(self, cls, parts=0):
+ """
+ Given a class object, return a fully-qualified name. This
+ works for things I've tested in matplotlib so far, but may not
+ be completely general.
+ """
+ module = cls.__module__
+ if module == '__builtin__':
+ fullname = cls.__name__
+ else:
+ fullname = "%s.%s" % (module, cls.__name__)
+ if parts == 0:
+ return fullname
+ name_parts = fullname.split('.')
+ return '.'.join(name_parts[-parts:])
+
+ def get_all_class_names(self):
+ """
+ Get all of the class names involved in the graph.
+ """
+ return [self.class_name(x) for x in self.all_classes]
+
+ # These are the default options for graphviz
+ default_graph_options = {
+ "rankdir": "LR",
+ "size": '"8.0, 12.0"'
+ }
+ default_node_options = {
+ "shape": "box",
+ "fontsize": 10,
+ "height": 0.25,
+ "fontname": "Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",
+ "style": '"setlinewidth(0.5)"'
+ }
+ default_edge_options = {
+ "arrowsize": 0.5,
+ "style": '"setlinewidth(0.5)"'
+ }
+
+ def _format_node_options(self, options):
+ return ','.join(["%s=%s" % x for x in options.items()])
+ def _format_graph_options(self, options):
+ return ''.join(["%s=%s;\n" % x for x in options.items()])
+
+ def generate_dot(self, fd, name, parts=0, urls={},
+ graph_options={}, node_options={},
+ edge_options={}):
+ """
+ Generate a graphviz dot graph from the classes that
+ were passed in to __init__.
+
+ *fd* is a Python file-like object to write to.
+
+ *name* is the name of the graph
+
+ *urls* is a dictionary mapping class names to http urls
+
+ *graph_options*, *node_options*, *edge_options* are
+ dictionaries containing key/value pairs to pass on as graphviz
+ properties.
+ """
+ g_options = self.default_graph_options.copy()
+ g_options.update(graph_options)
+ n_options = self.default_node_options.copy()
+ n_options.update(node_options)
+ e_options = self.default_edge_options.copy()
+ e_options.update(edge_options)
+
+ fd.write('digraph %s {\n' % name)
+ fd.write(self._format_graph_options(g_options))
+
+ for cls in self.all_classes:
+ if not self.show_builtins and cls in __builtins__.values():
+ continue
+
+ name = self.class_name(cls, parts)
+
+ # Write the node
+ this_node_options = n_options.copy()
+ url = urls.get(self.class_name(cls))
+ if url is not None:
+ this_node_options['URL'] = '"%s"' % url
+ fd.write(' "%s" [%s];\n' %
+ (name, self._format_node_options(this_node_options)))
+
+ # Write the edges
+ for base in cls.__bases__:
+ if not self.show_builtins and base in __builtins__.values():
+ continue
+
+ base_name = self.class_name(base, parts)
+ fd.write(' "%s" -> "%s" [%s];\n' %
+ (base_name, name,
+ self._format_node_options(e_options)))
+ fd.write('}\n')
+
+ def run_dot(self, args, name, parts=0, urls={},
+ graph_options={}, node_options={}, edge_options={}):
+ """
+ Run graphviz 'dot' over this graph, returning whatever 'dot'
+ writes to stdout.
+
+ *args* will be passed along as commandline arguments.
+
+ *name* is the name of the graph
+
+ *urls* is a dictionary mapping class names to http urls
+
+ Raises DotException for any of the many os and
+ installation-related errors that may occur.
+ """
+ try:
+ dot = subprocess.Popen(['dot'] + list(args),
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ close_fds=True)
+ except OSError:
+ raise DotException("Could not execute 'dot'. Are you sure you have 'graphviz' installed?")
+ except ValueError:
+ raise DotException("'dot' called with invalid arguments")
+ except:
+ raise DotException("Unexpected error calling 'dot'")
+
+ self.generate_dot(dot.stdin, name, parts, urls, graph_options,
+ node_options, edge_options)
+ dot.stdin.close()
+ result = dot.stdout.read()
+ returncode = dot.wait()
+ if returncode != 0:
+ raise DotException("'dot' returned the errorcode %d" % returncode)
+ return result
+
+class inheritance_diagram(Body, Element):
+ """
+ A docutils node to use as a placeholder for the inheritance
+ diagram.
+ """
+ pass
+
+def inheritance_diagram_directive(name, arguments, options, content, lineno,
+ content_offset, block_text, state,
+ state_machine):
+ """
+ Run when the inheritance_diagram directive is first encountered.
+ """
+ node = inheritance_diagram()
+
+ class_names = arguments
+
+ # Create a graph starting with the list of classes
+ graph = InheritanceGraph(class_names)
+
+ # Create xref nodes for each target of the graph's image map and
+ # add them to the doc tree so that Sphinx can resolve the
+ # references to real URLs later. These nodes will eventually be
+ # removed from the doctree after we're done with them.
+ for name in graph.get_all_class_names():
+ refnodes, x = xfileref_role(
+ 'class', ':class:`%s`' % name, name, 0, state)
+ node.extend(refnodes)
+ # Store the graph object so we can use it to generate the
+ # dot file later
+ node['graph'] = graph
+ # Store the original content for use as a hash
+ node['parts'] = options.get('parts', 0)
+ node['content'] = " ".join(class_names)
+ return [node]
+
+def get_graph_hash(node):
+ return md5(node['content'] + str(node['parts'])).hexdigest()[-10:]
+
+def html_output_graph(self, node):
+ """
+ Output the graph for HTML. This will insert a PNG with clickable
+ image map.
+ """
+ graph = node['graph']
+ parts = node['parts']
+
+ graph_hash = get_graph_hash(node)
+ name = "inheritance%s" % graph_hash
+ path = '_images'
+ dest_path = os.path.join(setup.app.builder.outdir, path)
+ if not os.path.exists(dest_path):
+ os.makedirs(dest_path)
+ png_path = os.path.join(dest_path, name + ".png")
+ path = setup.app.builder.imgpath
+
+ # Create a mapping from fully-qualified class names to URLs.
+ urls = {}
+ for child in node:
+ if child.get('refuri') is not None:
+ urls[child['reftitle']] = child.get('refuri')
+ elif child.get('refid') is not None:
+ urls[child['reftitle']] = '#' + child.get('refid')
+
+ # These arguments to dot will save a PNG file to disk and write
+ # an HTML image map to stdout.
+ image_map = graph.run_dot(['-Tpng', '-o%s' % png_path, '-Tcmapx'],
+ name, parts, urls)
+ return ('<img src="%s/%s.png" usemap="#%s" class="inheritance"/>%s' %
+ (path, name, name, image_map))
+
+def latex_output_graph(self, node):
+ """
+ Output the graph for LaTeX. This will insert a PDF.
+ """
+ graph = node['graph']
+ parts = node['parts']
+
+ graph_hash = get_graph_hash(node)
+ name = "inheritance%s" % graph_hash
+ dest_path = os.path.abspath(os.path.join(setup.app.builder.outdir, '_images'))
+ if not os.path.exists(dest_path):
+ os.makedirs(dest_path)
+ pdf_path = os.path.abspath(os.path.join(dest_path, name + ".pdf"))
+
+ graph.run_dot(['-Tpdf', '-o%s' % pdf_path],
+ name, parts, graph_options={'size': '"6.0,6.0"'})
+ return '\n\\includegraphics{%s}\n\n' % pdf_path
+
+def visit_inheritance_diagram(inner_func):
+ """
+ This is just a wrapper around html/latex_output_graph to make it
+ easier to handle errors and insert warnings.
+ """
+ def visitor(self, node):
+ try:
+ content = inner_func(self, node)
+ except DotException, e:
+ # Insert the exception as a warning in the document
+ warning = self.document.reporter.warning(str(e), line=node.line)
+ warning.parent = node
+ node.children = [warning]
+ else:
+ source = self.document.attributes['source']
+ self.body.append(content)
+ node.children = []
+ return visitor
+
+def do_nothing(self, node):
+ pass
+
+def setup(app):
+ setup.app = app
+ setup.confdir = app.confdir
+
+ app.add_node(
+ inheritance_diagram,
+ latex=(visit_inheritance_diagram(latex_output_graph), do_nothing),
+ html=(visit_inheritance_diagram(html_output_graph), do_nothing))
+ app.add_directive(
+ 'inheritance-diagram', inheritance_diagram_directive,
+ False, (1, 100, 0), parts = directives.nonnegative_int)
diff --git a/doc/sphinxext/math_symbol_table.py b/doc/sphinxext/math_symbol_table.py
new file mode 100644
index 0000000..6a11ec0
--- /dev/null
+++ b/doc/sphinxext/math_symbol_table.py
@@ -0,0 +1,159 @@
+symbols = [
+ ["Lower-case Greek",
+ 5,
+ r"""\alpha \beta \gamma \chi \delta \epsilon \eta \iota \kappa
+ \lambda \mu \nu \omega \phi \pi \psi \rho \sigma \tau \theta
+ \upsilon \xi \zeta \digamma \varepsilon \varkappa \varphi
+ \varpi \varrho \varsigma \vartheta"""],
+ ["Upper-case Greek",
+ 6,
+ r"""\Delta \Gamma \Lambda \Omega \Phi \Pi \Psi \Sigma \Theta
+ \Upsilon \Xi \mho \nabla"""],
+ ["Hebrew",
+ 4,
+ r"""\aleph \beth \daleth \gimel"""],
+ ["Delimiters",
+ 6,
+ r"""| \{ \lfloor / \Uparrow \llcorner \vert \} \rfloor \backslash
+ \uparrow \lrcorner \| \langle \lceil [ \Downarrow \ulcorner
+ \Vert \rangle \rceil ] \downarrow \urcorner"""],
+ ["Big symbols",
+ 5,
+ r"""\bigcap \bigcup \bigodot \bigoplus \bigotimes \biguplus
+ \bigvee \bigwedge \coprod \oint \prod \sum \int"""],
+ ["Standard function names",
+ 4,
+ r"""\arccos \csc \ker \min \arcsin \deg \lg \Pr \arctan \det \lim
+ \gcd \ln \sup \cot \hom \log \tan \coth \inf \max \tanh
+ \sec \arg \dim \liminf \sin \cos \exp \limsup \sinh \cosh"""],
+ ["Binary operation and relation symbols",
+ 3,
+ r"""\ast \pm \slash \cap \star \mp \cup \cdot \uplus
+ \triangleleft \circ \odot \sqcap \triangleright \bullet \ominus
+ \sqcup \bigcirc \oplus \wedge \diamond \oslash \vee
+ \bigtriangledown \times \otimes \dag \bigtriangleup \div \wr
+ \ddag \barwedge \veebar \boxplus \curlywedge \curlyvee \boxminus
+ \Cap \Cup \boxtimes \bot \top \dotplus \boxdot \intercal
+ \rightthreetimes \divideontimes \leftthreetimes \equiv \leq \geq
+ \perp \cong \prec \succ \mid \neq \preceq \succeq \parallel \sim
+ \ll \gg \bowtie \simeq \subset \supset \Join \approx \subseteq
+ \supseteq \ltimes \asymp \sqsubset \sqsupset \rtimes \doteq
+ \sqsubseteq \sqsupseteq \smile \propto \dashv \vdash \frown
+ \models \in \ni \notin \approxeq \leqq \geqq \lessgtr \leqslant
+ \geqslant \lesseqgtr \backsim \lessapprox \gtrapprox \lesseqqgtr
+ \backsimeq \lll \ggg \gtreqqless \triangleq \lessdot \gtrdot
+ \gtreqless \circeq \lesssim \gtrsim \gtrless \bumpeq \eqslantless
+ \eqslantgtr \backepsilon \Bumpeq \precsim \succsim \between
+ \doteqdot \precapprox \succapprox \pitchfork \Subset \Supset
+ \fallingdotseq \subseteqq \supseteqq \risingdotseq \sqsubset
+ \sqsupset \varpropto \preccurlyeq \succcurlyeq \Vdash \therefore
+ \curlyeqprec \curlyeqsucc \vDash \because \blacktriangleleft
+ \blacktriangleright \Vvdash \eqcirc \trianglelefteq
+ \trianglerighteq \neq \vartriangleleft \vartriangleright \ncong
+ \nleq \ngeq \nsubseteq \nmid \nsupseteq \nparallel \nless \ngtr
+ \nprec \nsucc \subsetneq \nsim \supsetneq \nVDash \precnapprox
+ \succnapprox \subsetneqq \nvDash \precnsim \succnsim \supsetneqq
+ \nvdash \lnapprox \gnapprox \ntriangleleft \ntrianglelefteq
+ \lneqq \gneqq \ntriangleright \lnsim \gnsim \ntrianglerighteq
+ \coloneq \eqsim \nequiv \napprox \nsupset \doublebarwedge \nVdash
+ \Doteq \nsubset \eqcolon \ne
+ """],
+ ["Arrow symbols",
+ 2,
+ r"""\leftarrow \longleftarrow \uparrow \Leftarrow \Longleftarrow
+ \Uparrow \rightarrow \longrightarrow \downarrow \Rightarrow
+ \Longrightarrow \Downarrow \leftrightarrow \updownarrow
+ \longleftrightarrow \updownarrow \Leftrightarrow
+ \Longleftrightarrow \Updownarrow \mapsto \longmapsto \nearrow
+ \hookleftarrow \hookrightarrow \searrow \leftharpoonup
+ \rightharpoonup \swarrow \leftharpoondown \rightharpoondown
+ \nwarrow \rightleftharpoons \leadsto \dashrightarrow
+ \dashleftarrow \leftleftarrows \leftrightarrows \Lleftarrow
+ \Rrightarrow \twoheadleftarrow \leftarrowtail \looparrowleft
+ \leftrightharpoons \curvearrowleft \circlearrowleft \Lsh
+ \upuparrows \upharpoonleft \downharpoonleft \multimap
+ \leftrightsquigarrow \rightrightarrows \rightleftarrows
+ \rightrightarrows \rightleftarrows \twoheadrightarrow
+ \rightarrowtail \looparrowright \rightleftharpoons
+ \curvearrowright \circlearrowright \Rsh \downdownarrows
+ \upharpoonright \downharpoonright \rightsquigarrow \nleftarrow
+ \nrightarrow \nLeftarrow \nRightarrow \nleftrightarrow
+ \nLeftrightarrow \to \Swarrow \Searrow \Nwarrow \Nearrow
+ \leftsquigarrow
+ """],
+ ["Miscellaneous symbols",
+ 3,
+ r"""\neg \infty \forall \wp \exists \bigstar \angle \partial
+ \nexists \measuredangle \eth \emptyset \sphericalangle \clubsuit
+ \varnothing \complement \diamondsuit \imath \Finv \triangledown
+ \heartsuit \jmath \Game \spadesuit \ell \hbar \vartriangle \cdots
+ \hslash \vdots \blacksquare \ldots \blacktriangle \ddots \sharp
+ \prime \blacktriangledown \Im \flat \backprime \Re \natural
+ \circledS \P \copyright \ss \circledR \S \yen \AA \checkmark \$
+ \iiint \iint \iint \oiiint"""]
+]
+
+def run(state_machine):
+ def get_n(n, l):
+ part = []
+ for x in l:
+ part.append(x)
+ if len(part) == n:
+ yield part
+ part = []
+ yield part
+
+ lines = []
+ for category, columns, syms in symbols:
+ syms = syms.split()
+ syms.sort()
+ lines.append("**%s**" % category)
+ lines.append('')
+ max_width = 0
+ for sym in syms:
+ max_width = max(max_width, len(sym))
+ max_width = max_width * 2 + 16
+ header = " " + (('=' * max_width) + ' ') * columns
+ format = '%%%ds' % max_width
+ for chunk in get_n(20, get_n(columns, syms)):
+ lines.append(header)
+ for part in chunk:
+ line = []
+ for sym in part:
+ line.append(format % (":math:`%s` ``%s``" % (sym, sym)))
+ lines.append(" " + " ".join(line))
+ lines.append(header)
+ lines.append('')
+
+ state_machine.insert_input(lines, "Symbol table")
+ return []
+
+def math_symbol_table_directive(name, arguments, options, content, lineno,
+ content_offset, block_text, state, state_machine):
+ return run(state_machine)
+
+def setup(app):
+ app.add_directive(
+ 'math_symbol_table', math_symbol_table_directive,
+ False, (0, 1, 0))
+
+if __name__ == "__main__":
+ # Do some verification of the tables
+ from matplotlib import _mathtext_data
+
+ print "SYMBOLS NOT IN STIX:"
+ all_symbols = {}
+ for category, columns, syms in symbols:
+ if category == "Standard Function Names":
+ continue
+ syms = syms.split()
+ for sym in syms:
+ if len(sym) > 1:
+ all_symbols[sym[1:]] = None
+ if sym[1:] not in _mathtext_data.tex2uni:
+ print sym
+
+ print "SYMBOLS NOT IN TABLE:"
+ for sym in _mathtext_data.tex2uni:
+ if sym not in all_symbols:
+ print sym
diff --git a/doc/sphinxext/mathml.py b/doc/sphinxext/mathml.py
new file mode 100644
index 0000000..098abd4
--- /dev/null
+++ b/doc/sphinxext/mathml.py
@@ -0,0 +1,552 @@
+from docutils import nodes
+from docutils.writers.html4css1 import HTMLTranslator
+from sphinx.latexwriter import LaTeXTranslator
+
+# Define LaTeX math node:
+class latex_math(nodes.General, nodes.Element):
+ pass
+
+def math_role(role, rawtext, text, lineno, inliner,
+ options={}, content=[]):
+ i = rawtext.find('`')
+ latex = rawtext[i+1:-1]
+ try:
+ mathml_tree = parse_latex_math(latex, inline=True)
+ except SyntaxError, msg:
+ msg = inliner.reporter.error(msg, line=lineno)
+ prb = inliner.problematic(rawtext, rawtext, msg)
+ return [prb], [msg]
+ node = latex_math(rawtext)
+ node['latex'] = latex
+ node['mathml_tree'] = mathml_tree
+ return [node], []
+
+
+try:
+ from docutils.parsers.rst import Directive
+except ImportError:
+ # Register directive the old way:
+ from docutils.parsers.rst.directives import _directives
+ def math_directive(name, arguments, options, content, lineno,
+ content_offset, block_text, state, state_machine):
+ latex = ''.join(content)
+ try:
+ mathml_tree = parse_latex_math(latex, inline=False)
+ except SyntaxError, msg:
+ error = state_machine.reporter.error(
+ msg, nodes.literal_block(block_text, block_text), line=lineno)
+ return [error]
+ node = latex_math(block_text)
+ node['latex'] = latex
+ node['mathml_tree'] = mathml_tree
+ return [node]
+ math_directive.arguments = None
+ math_directive.options = {}
+ math_directive.content = 1
+ _directives['math'] = math_directive
+else:
+ class math_directive(Directive):
+ has_content = True
+ def run(self):
+ latex = ' '.join(self.content)
+ try:
+ mathml_tree = parse_latex_math(latex, inline=False)
+ except SyntaxError, msg:
+ error = self.state_machine.reporter.error(
+ msg, nodes.literal_block(self.block_text, self.block_text),
+ line=self.lineno)
+ return [error]
+ node = latex_math(self.block_text)
+ node['latex'] = latex
+ node['mathml_tree'] = mathml_tree
+ return [node]
+ from docutils.parsers.rst import directives
+ directives.register_directive('math', math_directive)
+
+def setup(app):
+ app.add_node(latex_math)
+ app.add_role('math', math_role)
+
+ # Add visit/depart methods to HTML-Translator:
+ def visit_latex_math_html(self, node):
+ mathml = ''.join(node['mathml_tree'].xml())
+ self.body.append(mathml)
+ def depart_latex_math_html(self, node):
+ pass
+ HTMLTranslator.visit_latex_math = visit_latex_math_html
+ HTMLTranslator.depart_latex_math = depart_latex_math_html
+
+ # Add visit/depart methods to LaTeX-Translator:
+ def visit_latex_math_latex(self, node):
+ inline = isinstance(node.parent, nodes.TextElement)
+ if inline:
+ self.body.append('$%s$' % node['latex'])
+ else:
+ self.body.extend(['\\begin{equation}',
+ node['latex'],
+ '\\end{equation}'])
+ def depart_latex_math_latex(self, node):
+ pass
+ LaTeXTranslator.visit_latex_math = visit_latex_math_latex
+ LaTeXTranslator.depart_latex_math = depart_latex_math_latex
+
+
+# LaTeX to MathML translation stuff:
+class math:
+ """Base class for MathML elements."""
+
+ nchildren = 1000000
+ """Required number of children"""
+
+ def __init__(self, children=None, inline=None):
+ """math([children]) -> MathML element
+
+ children can be one child or a list of children."""
+
... 447 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/basemap.git
More information about the Python-modules-commits
mailing list