fix more exeptions

2to3 makes a better job than regexp

docs/sphinxext/docscrape.py

@@ -1,497 +1,497 b''
 """Extract reference documentation from the NumPy source tree.
 
 """
 
 import inspect
 import textwrap
 import re
 import pydoc
 from StringIO import StringIO
 from warnings import warn
 
 class Reader(object):
     """A line-based string reader.
 
     """
     def __init__(self, data):
         """
         Parameters
         ----------
         data : str
            String with lines separated by '\n'.
 
         """
         if isinstance(data,list):
             self._str = data
         else:
             self._str = data.split('\n') # store string as list of lines
 
         self.reset()
 
     def __getitem__(self, n):
         return self._str[n]
 
     def reset(self):
         self._l = 0 # current line nr
 
     def read(self):
         if not self.eof():
             out = self[self._l]
             self._l += 1
             return out
         else:
             return ''
 
     def seek_next_non_empty_line(self):
         for l in self[self._l:]:
             if l.strip():
                 break
             else:
                 self._l += 1
 
     def eof(self):
         return self._l >= len(self._str)
 
     def read_to_condition(self, condition_func):
         start = self._l
         for line in self[start:]:
             if condition_func(line):
                 return self[start:self._l]
             self._l += 1
             if self.eof():
                 return self[start:self._l+1]
         return []
 
     def read_to_next_empty_line(self):
         self.seek_next_non_empty_line()
         def is_empty(line):
             return not line.strip()
         return self.read_to_condition(is_empty)
 
     def read_to_next_unindented_line(self):
         def is_unindented(line):
             return (line.strip() and (len(line.lstrip()) == len(line)))
         return self.read_to_condition(is_unindented)
 
     def peek(self,n=0):
         if self._l + n < len(self._str):
             return self[self._l + n]
         else:
             return ''
 
     def is_empty(self):
         return not ''.join(self._str).strip()
 
 
 class NumpyDocString(object):
     def __init__(self,docstring):
         docstring = textwrap.dedent(docstring).split('\n')
 
         self._doc = Reader(docstring)
         self._parsed_data = {
             'Signature': '',
             'Summary': [''],
             'Extended Summary': [],
             'Parameters': [],
             'Returns': [],
             'Raises': [],
             'Warns': [],
             'Other Parameters': [],
             'Attributes': [],
             'Methods': [],
             'See Also': [],
             'Notes': [],
             'Warnings': [],
             'References': '',
             'Examples': '',
             'index': {}
             }
 
         self._parse()
 
     def __getitem__(self,key):
         return self._parsed_data[key]
 
     def __setitem__(self,key,val):
         if not self._parsed_data.has_key(key):
             warn("Unknown section %s" % key)
         else:
             self._parsed_data[key] = val
 
     def _is_at_section(self):
         self._doc.seek_next_non_empty_line()
 
         if self._doc.eof():
             return False
 
         l1 = self._doc.peek().strip()  # e.g. Parameters
 
         if l1.startswith('.. index::'):
             return True
 
         l2 = self._doc.peek(1).strip() #    ---------- or ==========
         return l2.startswith('-'*len(l1)) or l2.startswith('='*len(l1))
 
     def _strip(self,doc):
         i = 0
         j = 0
         for i,line in enumerate(doc):
             if line.strip(): break
 
         for j,line in enumerate(doc[::-1]):
             if line.strip(): break
 
         return doc[i:len(doc)-j]
 
     def _read_to_next_section(self):
         section = self._doc.read_to_next_empty_line()
 
         while not self._is_at_section() and not self._doc.eof():
             if not self._doc.peek(-1).strip(): # previous line was empty
                 section += ['']
 
             section += self._doc.read_to_next_empty_line()
 
         return section
 
     def _read_sections(self):
         while not self._doc.eof():
             data = self._read_to_next_section()
             name = data[0].strip()
 
             if name.startswith('..'): # index section
                 yield name, data[1:]
             elif len(data) < 2:
                 yield StopIteration
             else:
                 yield name, self._strip(data[2:])
 
     def _parse_param_list(self,content):
         r = Reader(content)
         params = []
         while not r.eof():
             header = r.read().strip()
             if ' : ' in header:
                 arg_name, arg_type = header.split(' : ')[:2]
             else:
                 arg_name, arg_type = header, ''
 
             desc = r.read_to_next_unindented_line()
             desc = dedent_lines(desc)
 
             params.append((arg_name,arg_type,desc))
 
         return params
 
     
     _name_rgx = re.compile(r"^\s*(:(?P<role>\w+):`(?P<name>[a-zA-Z0-9_.-]+)`|"
                            r" (?P<name2>[a-zA-Z0-9_.-]+))\s*", re.X)
     def _parse_see_also(self, content):
         """
         func_name : Descriptive text
             continued text
         another_func_name : Descriptive text
         func_name1, func_name2, :meth:`func_name`, func_name3
 
         """
         items = []
 
         def parse_item_name(text):
             """Match ':role:`name`' or 'name'"""
             m = self._name_rgx.match(text)
             if m:
                 g = m.groups()
                 if g[1] is None:
                     return g[3], None
                 else:
                     return g[2], g[1]
             raise ValueError("%s is not a item name" % text)
 
         def push_item(name, rest):
             if not name:
                 return
             name, role = parse_item_name(name)
             items.append((name, list(rest), role))
             del rest[:]
 
         current_func = None
         rest = []
         
         for line in content:
             if not line.strip(): continue
 
             m = self._name_rgx.match(line)
             if m and line[m.end():].strip().startswith(':'):
                 push_item(current_func, rest)
                 current_func, line = line[:m.end()], line[m.end():]
                 rest = [line.split(':', 1)[1].strip()]
                 if not rest[0]:
                     rest = []
             elif not line.startswith(' '):
                 push_item(current_func, rest)
                 current_func = None
                 if ',' in line:
                     for func in line.split(','):
                         push_item(func, [])
                 elif line.strip():
                     current_func = line
             elif current_func is not None:
                 rest.append(line.strip())
         push_item(current_func, rest)
         return items
 
     def _parse_index(self, section, content):
         """
         .. index: default
            :refguide: something, else, and more
 
         """
         def strip_each_in(lst):
             return [s.strip() for s in lst]
 
         out = {}
         section = section.split('::')
         if len(section) > 1:
             out['default'] = strip_each_in(section[1].split(','))[0]
         for line in content:
             line = line.split(':')
             if len(line) > 2:
                 out[line[1]] = strip_each_in(line[2].split(','))
         return out
     
     def _parse_summary(self):
         """Grab signature (if given) and summary"""
         if self._is_at_section():
             return
 
         summary = self._doc.read_to_next_empty_line()
         summary_str = " ".join([s.strip() for s in summary]).strip()
         if re.compile('^([\w., ]+=)?\s*[\w\.]+\(.*\)$').match(summary_str):
             self['Signature'] = summary_str
             if not self._is_at_section():
                 self['Summary'] = self._doc.read_to_next_empty_line()
         else:
             self['Summary'] = summary
 
         if not self._is_at_section():
             self['Extended Summary'] = self._read_to_next_section()
     
     def _parse(self):
         self._doc.reset()
         self._parse_summary()
 
         for (section,content) in self._read_sections():
             if not section.startswith('..'):
                 section = ' '.join([s.capitalize() for s in section.split(' ')])
             if section in ('Parameters', 'Attributes', 'Methods',
                            'Returns', 'Raises', 'Warns'):
                 self[section] = self._parse_param_list(content)
             elif section.startswith('.. index::'):
                 self['index'] = self._parse_index(section, content)
             elif section == 'See Also':
                 self['See Also'] = self._parse_see_also(content)
             else:
                 self[section] = content
 
     # string conversion routines
 
     def _str_header(self, name, symbol='-'):
         return [name, len(name)*symbol]
 
     def _str_indent(self, doc, indent=4):
         out = []
         for line in doc:
             out += [' '*indent + line]
         return out
 
     def _str_signature(self):
         if self['Signature']:
             return [self['Signature'].replace('*','\*')] + ['']
         else:
             return ['']
 
     def _str_summary(self):
         if self['Summary']:
             return self['Summary'] + ['']
         else:
             return []
 
     def _str_extended_summary(self):
         if self['Extended Summary']:
             return self['Extended Summary'] + ['']
         else:
             return []
 
     def _str_param_list(self, name):
         out = []
         if self[name]:
             out += self._str_header(name)
             for param,param_type,desc in self[name]:
                 out += ['%s : %s' % (param, param_type)]
                 out += self._str_indent(desc)
             out += ['']
         return out
 
     def _str_section(self, name):
         out = []
         if self[name]:
             out += self._str_header(name)
             out += self[name]
             out += ['']
         return out
 
     def _str_see_also(self, func_role):
         if not self['See Also']: return []
         out = []
         out += self._str_header("See Also")
         last_had_desc = True
         for func, desc, role in self['See Also']:
             if role:
                 link = ':%s:`%s`' % (role, func)
             elif func_role:
                 link = ':%s:`%s`' % (func_role, func)
             else:
                 link = "`%s`_" % func
             if desc or last_had_desc:
                 out += ['']
                 out += [link]
             else:
                 out[-1] += ", %s" % link
             if desc:
                 out += self._str_indent([' '.join(desc)])
                 last_had_desc = True
             else:
                 last_had_desc = False
         out += ['']
         return out
 
     def _str_index(self):
         idx = self['index']
         out = []
         out += ['.. index:: %s' % idx.get('default','')]
         for section, references in idx.iteritems():
             if section == 'default':
                 continue
             out += ['   :%s: %s' % (section, ', '.join(references))]
         return out
 
     def __str__(self, func_role=''):
         out = []
         out += self._str_signature()
         out += self._str_summary()
         out += self._str_extended_summary()
         for param_list in ('Parameters','Returns','Raises'):
             out += self._str_param_list(param_list)
         out += self._str_section('Warnings')
         out += self._str_see_also(func_role)
         for s in ('Notes','References','Examples'):
             out += self._str_section(s)
         out += self._str_index()
         return '\n'.join(out)
 
 
 def indent(str,indent=4):
     indent_str = ' '*indent
     if str is None:
         return indent_str
     lines = str.split('\n')
     return '\n'.join(indent_str + l for l in lines)
 
 def dedent_lines(lines):
     """Deindent a list of lines maximally"""
     return textwrap.dedent("\n".join(lines)).split("\n")
 
 def header(text, style='-'):
     return text + '\n' + style*len(text) + '\n'
 
 
 class FunctionDoc(NumpyDocString):
     def __init__(self, func, role='func', doc=None):
         self._f = func
         self._role = role # e.g. "func" or "meth"
         if doc is None:
             doc = inspect.getdoc(func) or ''
         try:
             NumpyDocString.__init__(self, doc)
-        except ValueError, e:
+        except ValueError as e:
             print '*'*78
             print "ERROR: '%s' while parsing `%s`" % (e, self._f)
             print '*'*78
             #print "Docstring follows:"
             #print doclines
             #print '='*78
 
         if not self['Signature']:
             func, func_name = self.get_func()
             try:
                 # try to read signature
                 argspec = inspect.getargspec(func)
                 argspec = inspect.formatargspec(*argspec)
                 argspec = argspec.replace('*','\*')
                 signature = '%s%s' % (func_name, argspec)
-            except TypeError, e:
+            except TypeError as e:
                 signature = '%s()' % func_name
             self['Signature'] = signature
 
     def get_func(self):
         func_name = getattr(self._f, '__name__', self.__class__.__name__)
         if inspect.isclass(self._f):
             func = getattr(self._f, '__call__', self._f.__init__)
         else:
             func = self._f
         return func, func_name
             
     def __str__(self):
         out = ''
 
         func, func_name = self.get_func()
         signature = self['Signature'].replace('*', '\*')
 
         roles = {'func': 'function',
                  'meth': 'method'}
 
         if self._role:
             if not roles.has_key(self._role):
                 print "Warning: invalid role %s" % self._role
             out += '.. %s:: %s\n    \n\n' % (roles.get(self._role,''),
                                              func_name)
 
         out += super(FunctionDoc, self).__str__(func_role=self._role)
         return out
 
 
 class ClassDoc(NumpyDocString):
     def __init__(self,cls,modulename='',func_doc=FunctionDoc,doc=None):
         if not inspect.isclass(cls):
             raise ValueError("Initialise using a class. Got %r" % cls)
         self._cls = cls
 
         if modulename and not modulename.endswith('.'):
             modulename += '.'
         self._mod = modulename
         self._name = cls.__name__
         self._func_doc = func_doc
 
         if doc is None:
             doc = pydoc.getdoc(cls)
 
         NumpyDocString.__init__(self, doc)
 
     @property
     def methods(self):
         return [name for name,func in inspect.getmembers(self._cls)
                 if not name.startswith('_') and callable(func)]
 
     def __str__(self):
         out = ''
         out += super(ClassDoc, self).__str__()
         out += "\n\n"
 
         #for m in self.methods:
         #    print "Parsing `%s`" % m
         #    out += str(self._func_doc(getattr(self._cls,m), 'meth')) + '\n\n'
         #    out += '.. index::\n   single: %s; %s\n\n' % (self._name, m)
 
         return out
 
 

docs/sphinxext/github.py

@@ -1,155 +1,155 b''
 """Define text roles for GitHub
 
 * ghissue - Issue
 * ghpull - Pull Request
 * ghuser - User
 
 Adapted from bitbucket example here:
 https://bitbucket.org/birkenfeld/sphinx-contrib/src/tip/bitbucket/sphinxcontrib/bitbucket.py
 
 Authors
 -------
 
 * Doug Hellmann
 * Min RK
 """
 #
 # Original Copyright (c) 2010 Doug Hellmann.  All rights reserved.
 #
 
 from docutils import nodes, utils
 from docutils.parsers.rst.roles import set_classes
 
 def make_link_node(rawtext, app, type, slug, options):
     """Create a link to a github resource.
 
     :param rawtext: Text being replaced with link node.
     :param app: Sphinx application context
     :param type: Link type (issues, changeset, etc.)
     :param slug: ID of the thing to link to
     :param options: Options dictionary passed to role func.
     """
 
     try:
         base = app.config.github_project_url
         if not base:
             raise AttributeError
         if not base.endswith('/'):
             base += '/'
-    except AttributeError, err:
+    except AttributeError as err:
         raise ValueError('github_project_url configuration value is not set (%s)' % str(err))
 
     ref = base + type + '/' + slug + '/'
     set_classes(options)
     prefix = "#"
     if type == 'pull':
         prefix = "PR " + prefix
     node = nodes.reference(rawtext, prefix + utils.unescape(slug), refuri=ref,
                            **options)
     return node
 
 def ghissue_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
     """Link to a GitHub issue.
 
     Returns 2 part tuple containing list of nodes to insert into the
     document and a list of system messages.  Both are allowed to be
     empty.
 
     :param name: The role name used in the document.
     :param rawtext: The entire markup snippet, with role.
     :param text: The text marked with the role.
     :param lineno: The line number where rawtext appears in the input.
     :param inliner: The inliner instance that called us.
     :param options: Directive options for customization.
     :param content: The directive content for customization.
     """
 
     try:
         issue_num = int(text)
         if issue_num <= 0:
             raise ValueError
     except ValueError:
         msg = inliner.reporter.error(
             'GitHub issue number must be a number greater than or equal to 1; '
             '"%s" is invalid.' % text, line=lineno)
         prb = inliner.problematic(rawtext, rawtext, msg)
         return [prb], [msg]
     app = inliner.document.settings.env.app
     #app.info('issue %r' % text)
     if 'pull' in name.lower():
         category = 'pull'
     elif 'issue' in name.lower():
         category = 'issues'
     else:
         msg = inliner.reporter.error(
             'GitHub roles include "ghpull" and "ghissue", '
             '"%s" is invalid.' % name, line=lineno)
         prb = inliner.problematic(rawtext, rawtext, msg)
         return [prb], [msg]
     node = make_link_node(rawtext, app, category, str(issue_num), options)
     return [node], []
 
 def ghuser_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
     """Link to a GitHub user.
 
     Returns 2 part tuple containing list of nodes to insert into the
     document and a list of system messages.  Both are allowed to be
     empty.
 
     :param name: The role name used in the document.
     :param rawtext: The entire markup snippet, with role.
     :param text: The text marked with the role.
     :param lineno: The line number where rawtext appears in the input.
     :param inliner: The inliner instance that called us.
     :param options: Directive options for customization.
     :param content: The directive content for customization.
     """
     app = inliner.document.settings.env.app
     #app.info('user link %r' % text)
     ref = 'https://www.github.com/' + text
     node = nodes.reference(rawtext, text, refuri=ref, **options)
     return [node], []
 
 def ghcommit_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
     """Link to a GitHub commit.
 
     Returns 2 part tuple containing list of nodes to insert into the
     document and a list of system messages.  Both are allowed to be
     empty.
 
     :param name: The role name used in the document.
     :param rawtext: The entire markup snippet, with role.
     :param text: The text marked with the role.
     :param lineno: The line number where rawtext appears in the input.
     :param inliner: The inliner instance that called us.
     :param options: Directive options for customization.
     :param content: The directive content for customization.
     """
     app = inliner.document.settings.env.app
     #app.info('user link %r' % text)
     try:
         base = app.config.github_project_url
         if not base:
             raise AttributeError
         if not base.endswith('/'):
             base += '/'
-    except AttributeError, err:
+    except AttributeError as err:
         raise ValueError('github_project_url configuration value is not set (%s)' % str(err))
 
     ref = base + text
     node = nodes.reference(rawtext, text[:6], refuri=ref, **options)
     return [node], []
 
 
 def setup(app):
     """Install the plugin.
     
     :param app: Sphinx application context.
     """
     app.info('Initializing GitHub plugin')
     app.add_role('ghissue', ghissue_role)
     app.add_role('ghpull', ghissue_role)
     app.add_role('ghuser', ghuser_role)
     app.add_role('ghcommit', ghcommit_role)
     app.add_config_value('github_project_url', None, 'env')
     return

docs/sphinxext/inheritance_diagram.py

@@ -1,407 +1,407 b''
 """
 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:
+        except DotException as 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)