1. Georg Brandl
  2. sphinx

Commits

Dmitry Shachnev  committed 151d405

Modernize the code now that Python 2.5 is no longer supported

- Use print function instead of print statement;
- Use new exception handling;
- Use in operator instead of has_key();
- Do not use tuple arguments in functions;
- Other miscellaneous improvements.

This is based on output of `futurize --stage1`, with some
manual corrections.

  • Participants
  • Parent commits 2f4dd49
  • Branches default

Comments (0)

Files changed (64)

File sphinx/apidoc.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 import os
 import sys
 import optparse
     """Write the output file for module/package <name>."""
     fname = path.join(opts.destdir, '%s.%s' % (name, opts.suffix))
     if opts.dryrun:
-        print 'Would create file %s.' % fname
+        print('Would create file %s.' % fname)
         return
     if not opts.force and path.isfile(fname):
-        print 'File %s already exists, skipping.' % fname
+        print('File %s already exists, skipping.' % fname)
     else:
-        print 'Creating file %s.' % fname
+        print('Creating file %s.' % fname)
         f = open(fname, 'w')
         try:
             f.write(text)
     if opts.suffix.startswith('.'):
         opts.suffix = opts.suffix[1:]
     if not path.isdir(rootpath):
-        print >>sys.stderr, '%s is not a directory.' % rootpath
+        print('%s is not a directory.' % rootpath, file=sys.stderr)
         sys.exit(1)
     if not path.isdir(opts.destdir):
         if not opts.dryrun:

File sphinx/application.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import os
 import sys
 from sphinx.util.osutil import ENOENT
 from sphinx.util.console import bold, lightgray, darkgray
 
+if hasattr(sys, 'intern'):
+    intern = sys.intern
 
 # List of all known core events. Maps name to arguments description.
 events = {
                     # this can raise if the data version doesn't fit
                     self.env.domains[domain] = self.domains[domain](self.env)
                 self.info('done')
-            except Exception, err:
+            except Exception as err:
                 if type(err) is IOError and err.errno == ENOENT:
                     self.info('not yet created')
                 else:
 
     def _init_builder(self, buildername):
         if buildername is None:
-            print >>self._status, 'No builder selected, using default: html'
+            print('No builder selected, using default: html', file=self._status)
             buildername = 'html'
         if buildername not in self.builderclasses:
             raise SphinxError('Builder name %s not registered' % buildername)
                 self.builder.build_specific(filenames)
             else:
                 self.builder.build_update()
-        except Exception, err:
+        except Exception as err:
             # delete the saved env to force a fresh build next time
             envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME)
             if path.isfile(envfile):
             return
         try:
             mod = __import__(extension, None, None, ['setup'])
-        except ImportError, err:
+        except ImportError as err:
             self.verbose('Original exception:\n' + traceback.format_exc())
             raise ExtensionError('Could not import extension %s' % extension,
                                  err)
         else:
             try:
                 mod.setup(self)
-            except VersionRequirementError, err:
+            except VersionRequirementError as err:
                 # add the extension name to the version required
                 raise VersionRequirementError(
                     'The %s extension used by this project needs at least '
         """Import an object from a 'module.name' string."""
         try:
             module, name = objname.rsplit('.', 1)
-        except ValueError, err:
+        except ValueError as err:
             raise ExtensionError('Invalid full object name %s' % objname +
                                  (source and ' (needed for %s)' % source or ''),
                                  err)
         try:
             return getattr(__import__(module, None, None, [name]), name)
-        except ImportError, err:
+        except ImportError as err:
             raise ExtensionError('Could not import %s' % module +
                                  (source and ' (needed for %s)' % source or ''),
                                  err)
-        except AttributeError, err:
+        except AttributeError as err:
             raise ExtensionError('Could not find %s' % objname +
                                  (source and ' (needed for %s)' % source or ''),
                                  err)

File sphinx/builders/devhelp.py

View file
 
         def istoctree(node):
             return isinstance(node, addnodes.compact_paragraph) and \
-                   node.has_key('toctree')
+                   'toctree' in node
 
         for node in tocdoc.traverse(istoctree):
             write_toc(node, chapters)

File sphinx/builders/epub.py

View file
         """Collect section titles, their depth in the toc and the refuri."""
         # XXX: is there a better way than checking the attribute
         # toctree-l[1-8] on the parent node?
-        if isinstance(doctree, nodes.reference) and doctree.has_key('refuri'):
+        if isinstance(doctree, nodes.reference) and 'refuri' in doctree:
             refuri = doctree['refuri']
             if refuri.startswith('http://') or refuri.startswith('https://') \
                 or refuri.startswith('irc:') or refuri.startswith('mailto:'):
                 try:
                     copyfile(path.join(self.srcdir, src),
                              path.join(self.outdir, '_images', dest))
-                except (IOError, OSError), err:
+                except (IOError, OSError) as err:
                     self.warn('cannot copy image file %r: %s' %
                               (path.join(self.srcdir, src), err))
                 continue
                     img = img.resize((nw, nh), Image.BICUBIC)
             try:
                 img.save(path.join(self.outdir, '_images', dest))
-            except (IOError, OSError), err:
+            except (IOError, OSError) as err:
                 self.warn('cannot write image file %r: %s' %
                           (path.join(self.srcdir, src), err))
 
         fn = path.join(outdir, outname)
         try:
             os.mkdir(path.dirname(fn))
-        except OSError, err:
+        except OSError as err:
             if err.errno != EEXIST:
                 raise
         f = codecs.open(path.join(outdir, outname), 'w', 'utf-8')

File sphinx/builders/gettext.py

View file
         for textdomain, catalog in self.status_iterator(
                 self.catalogs.iteritems(), "writing message catalogs... ",
                 darkgreen, len(self.catalogs),
-                lambda (textdomain, _): textdomain):
+                lambda textdomain__: textdomain__[0]):
             # noop if config.gettext_compact is set
             ensuredir(path.join(self.outdir, path.dirname(textdomain)))
 

File sphinx/builders/html.py

View file
                 try:
                     copyfile(path.join(self.srcdir, src),
                              path.join(self.outdir, '_images', dest))
-                except Exception, err:
+                except Exception as err:
                     self.warn('cannot copy image file %r: %s' %
                               (path.join(self.srcdir, src), err))
 
                 try:
                     copyfile(path.join(self.srcdir, src),
                              path.join(self.outdir, '_downloads', dest))
-                except Exception, err:
+                except Exception as err:
                     self.warn('cannot copy downloadable file %r: %s' %
                               (path.join(self.srcdir, src), err))
 
                 f.write(output)
             finally:
                 f.close()
-        except (IOError, OSError), err:
+        except (IOError, OSError) as err:
             self.warn("error writing file %s: %s" % (outfilename, err))
         if self.copysource and ctx.get('sourcename'):
             # copy the source file for the "show source" link

File sphinx/builders/htmlhelp.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import os
 import codecs
         f = self.open_file(outdir, outname+'.stp')
         try:
             for word in sorted(stopwords):
-                print >>f, word
+                print(word, file=f)
         finally:
             f.close()
 
                 for fn in files:
                     if (staticdir and not fn.endswith('.js')) or \
                            fn.endswith('.html'):
-                        print >>f, path.join(root, fn)[olen:].replace(os.sep,
-                                                                      '\\')
+                        print(path.join(root, fn)[olen:].replace(os.sep, '\\'),
+                              file=f)
         finally:
             f.close()
 
                         write_toc(subnode, ullevel)
             def istoctree(node):
                 return isinstance(node, addnodes.compact_paragraph) and \
-                       node.has_key('toctree')
+                       'toctree' in node
             for node in tocdoc.traverse(istoctree):
                 write_toc(node)
             f.write(contents_footer)

File sphinx/builders/linkcheck.py

View file
                         req = HeadRequest(req_url)
                         f = opener.open(req, **kwargs)
                         f.close()
-                    except HTTPError, err:
+                    except HTTPError as err:
                         if err.code != 405:
                             raise
                         # retry with GET if that fails, some servers
                         f = opener.open(req, **kwargs)
                         f.close()
 
-            except Exception, err:
+            except Exception as err:
                 self.broken[uri] = str(err)
                 return 'broken', str(err), 0
             if f.url.rstrip('/') == req_url.rstrip('/'):

File sphinx/builders/qthelp.py

View file
                                                   prune_toctrees=False)
         istoctree = lambda node: (
                         isinstance(node, addnodes.compact_paragraph)
-                            and node.has_key('toctree'))
+                            and 'toctree' in node)
         sections = []
         for node in tocdoc.traverse(istoctree):
             sections.extend(self.write_toc(node))

File sphinx/builders/texinfo.py

View file
                 mkfile.write(TEXINFO_MAKEFILE)
             finally:
                 mkfile.close()
-        except (IOError, OSError), err:
+        except (IOError, OSError) as err:
             self.warn("error writing file %s: %s" % (fn, err))
         self.info(' done')

File sphinx/builders/text.py

View file
                 f.write(self.writer.output)
             finally:
                 f.close()
-        except (IOError, OSError), err:
+        except (IOError, OSError) as err:
             self.warn("error writing file %s: %s" % (outfilename, err))
 
     def finish(self):

File sphinx/builders/xml.py

View file
                 f.write(self.writer.output)
             finally:
                 f.close()
-        except (IOError, OSError), err:
+        except (IOError, OSError) as err:
             self.warn("error writing file %s: %s" % (outfilename, err))
 
     def finish(self):

File sphinx/cmdline.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import os
 import sys
 
 def usage(argv, msg=None):
     if msg:
-        print >>sys.stderr, msg
-        print >>sys.stderr
-    print >>sys.stderr, """\
+        print(msg, file=sys.stderr)
+        print(file=sys.stderr)
+    print("""\
 Sphinx v%s
 Usage: %s [options] sourcedir outdir [filenames...]
 
 ^^^^^^^^^^^^^^^^
 -h, --help  show this help and exit
 --version   show version information and exit
-""" % (__version__, argv[0])
+""" % (__version__, argv[0]), file=sys.stderr)
 
 
 def main(argv):
         allopts = set(opt[0] for opt in opts)
         if '-h' in allopts or '--help' in allopts:
             usage(argv)
-            print >>sys.stderr
-            print >>sys.stderr, 'For more information, see '\
-                '<http://sphinx-doc.org/>.'
+            print(file=sys.stderr)
+            print('For more information, see <http://sphinx-doc.org/>.',
+                  file=sys.stderr)
             return 0
         if '--version' in allopts:
-            print 'Sphinx (sphinx-build) %s' %  __version__
+            print('Sphinx (sphinx-build) %s' %  __version__)
             return 0
         srcdir = confdir = abspath(args[0])
         if not path.isdir(srcdir):
-            print >>sys.stderr, 'Error: Cannot find source directory `%s\'.' % (
-                                srcdir,)
+            print('Error: Cannot find source directory `%s\'.' % srcdir,
+                  file=sys.stderr)
             return 1
         if not path.isfile(path.join(srcdir, 'conf.py')) and \
                '-c' not in allopts and '-C' not in allopts:
-            print >>sys.stderr, ('Error: Source directory doesn\'t '
-                                 'contain conf.py file.')
+            print('Error: Source directory doesn\'t contain conf.py file.',
+                  file=sys.stderr)
             return 1
         outdir = abspath(args[1])
-    except getopt.error, err:
+    except getopt.error as err:
         usage(argv, 'Error: %s' % err)
         return 1
     except IndexError:
         usage(argv, 'Error: Insufficient arguments.')
         return 1
     except UnicodeError:
-        print >>sys.stderr, (
+        print(
             'Error: Multibyte filename not supported on this filesystem '
-            'encoding (%r).' % fs_encoding)
+            'encoding (%r).' % fs_encoding, file=sys.stderr)
         return 1
 
     filenames = args[2:]
     err = 0
     for filename in filenames:
         if not path.isfile(filename):
-            print >>sys.stderr, 'Error: Cannot find file %r.' % filename
+            print('Error: Cannot find file %r.' % filename, file=sys.stderr)
             err = 1
     if err:
         return 1
         elif opt == '-c':
             confdir = abspath(val)
             if not path.isfile(path.join(confdir, 'conf.py')):
-                print >>sys.stderr, ('Error: Configuration directory '
-                                     'doesn\'t contain conf.py file.')
+                print('Error: Configuration directory doesn\'t contain conf.py file.',
+                      file=sys.stderr)
                 return 1
         elif opt == '-C':
             confdir = None
             try:
                 key, val = val.split('=')
             except ValueError:
-                print >>sys.stderr, ('Error: -D option argument must be '
-                                     'in the form name=value.')
+                print('Error: -D option argument must be in the form name=value.',
+                      file=sys.stderr)
                 return 1
             if likely_encoding and isinstance(val, bytes):
                 try:
             try:
                 key, val = val.split('=')
             except ValueError:
-                print >>sys.stderr, ('Error: -A option argument must be '
-                                     'in the form name=value.')
+                print('Error: -A option argument must be in the form name=value.',
+                      file=sys.stderr)
                 return 1
             try:
                 val = int(val)
             try:
                 parallel = int(val)
             except ValueError:
-                print >>sys.stderr, ('Error: -j option argument must be an '
-                                     'integer.')
+                print('Error: -j option argument must be an integer.',
+                      file=sys.stderr)
                 return 1
 
     if warning and warnfile:
 
     if not path.isdir(outdir):
         if status:
-            print >>status, 'Making output directory...'
+            print('Making output directory...', file=status)
         os.makedirs(outdir)
 
     app = None
                      warningiserror, tags, verbosity, parallel)
         app.build(force_all, filenames)
         return app.statuscode
-    except (Exception, KeyboardInterrupt), err:
+    except (Exception, KeyboardInterrupt) as err:
         if use_pdb:
             import pdb
-            print >>error, red('Exception occurred while building, '
-                               'starting debugger:')
+            print(red('Exception occurred while building, starting debugger:'),
+                  file=error)
             traceback.print_exc()
             pdb.post_mortem(sys.exc_info()[2])
         else:
-            print >>error
+            print(file=error)
             if show_traceback:
                 traceback.print_exc(None, error)
-                print >>error
+                print(file=error)
             if isinstance(err, KeyboardInterrupt):
-                print >>error, 'interrupted!'
+                print('interrupted!', file=error)
             elif isinstance(err, SystemMessage):
-                print >>error, red('reST markup error:')
-                print >>error, terminal_safe(err.args[0])
+                print(red('reST markup error:'), file=error)
+                print(terminal_safe(err.args[0]), file=error)
             elif isinstance(err, SphinxError):
-                print >>error, red('%s:' % err.category)
-                print >>error, terminal_safe(unicode(err))
+                print(red('%s:' % err.category), file=error)
+                print(terminal_safe(unicode(err)), file=error)
             else:
-                print >>error, red('Exception occurred:')
-                print >>error, format_exception_cut_frames().rstrip()
+                print(red('Exception occurred:'), file=error)
+                print(format_exception_cut_frames().rstrip(), file=error)
                 tbpath = save_traceback(app)
-                print >>error, red('The full traceback has been saved '
-                                   'in %s, if you want to report the '
-                                   'issue to the developers.' % tbpath)
-                print >>error, ('Please also report this if it was a user '
-                                'error, so that a better error message '
-                                'can be provided next time.')
-                print >>error, (
-                    'Either send bugs to the mailing list at '
-                    '<http://groups.google.com/group/sphinx-users/>,\n'
-                    'or report them in the tracker at '
-                    '<http://bitbucket.org/birkenfeld/sphinx/issues/>. Thanks!')
+                print(red('The full traceback has been saved in %s, if you '
+                          'want to report the issue to the developers.' % tbpath),
+                      file=error)
+                print('Please also report this if it was a user error, so '
+                      'that a better error message can be provided next time.',
+                      file=error)
+                print('Either send bugs to the mailing list at '
+                      '<http://groups.google.com/group/sphinx-users/>,\n'
+                      'or report them in the tracker at '
+                      '<http://bitbucket.org/birkenfeld/sphinx/issues/>. Thanks!',
+                      file=error)
             return 1

File sphinx/config.py

View file
                 os.chdir(dirname)
                 try:
                     execfile_(filename, config)
-                except SyntaxError, err:
+                except SyntaxError as err:
                     raise ConfigError(CONFIG_SYNTAX_ERROR % err)
             finally:
                 os.chdir(olddir)

File sphinx/directives/code.py

View file
             except Exception:
                 linenothreshold = 10
         else:
-            linenothreshold = sys.maxint
+            linenothreshold = sys.maxsize
         return [addnodes.highlightlang(lang=self.arguments[0].strip(),
                                        linenothreshold=linenothreshold)]
 
             try:
                 nlines = len(self.content)
                 hl_lines = [x+1 for x in parselinenos(linespec, nlines)]
-            except ValueError, err:
+            except ValueError as err:
                 document = self.state.document
                 return [document.reporter.warning(str(err), line=self.lineno)]
         else:
         if linespec is not None:
             try:
                 linelist = parselinenos(linespec, len(lines))
-            except ValueError, err:
+            except ValueError as err:
                 return [document.reporter.warning(str(err), line=self.lineno)]
             # just ignore nonexisting lines
             nlines = len(lines)
         if linespec:
             try:
                 hl_lines = [x+1 for x in parselinenos(linespec, len(lines))]
-            except ValueError, err:
+            except ValueError as err:
                 return [document.reporter.warning(str(err), line=self.lineno)]
         else:
             hl_lines = None

File sphinx/domains/c.py

View file
 
     def _parse_type(self, node, ctype):
         # add cross-ref nodes for all words
-        for part in filter(None, wsplit_re.split(ctype)):
+        for part in [_f for _f in wsplit_re.split(ctype) if _f]:
             tnode = nodes.Text(part, part)
             if part[0] in string.ascii_letters+'_' and \
                    part not in self.stopwords:

File sphinx/domains/cpp.py

View file
         try:
             rv = self.parse_definition(parser)
             parser.assert_end()
-        except DefinitionError, e:
+        except DefinitionError as e:
             self.state_machine.reporter.warning(e.description, line=self.lineno)
             raise ValueError
         self.describe_signature(signode, rv)
             try:
                 prefix = parser.parse_type()
                 parser.assert_end()
-            except DefinitionError, e:
+            except DefinitionError as e:
                 self.state_machine.reporter.warning(e.description,
                                                     line=self.lineno)
             else:

File sphinx/domains/std.py

View file
             if labelid is None:
                 continue
             node = document.ids[labelid]
-            if name.isdigit() or node.has_key('refuri') or \
+            if name.isdigit() or 'refuri' in node or \
                    node.tagname.startswith('desc_'):
                 # ignore footnote labels, labels automatically generated from a
                 # link and object descriptions

File sphinx/environment.py

View file
         try:
             pub.publish()
             doctree = pub.document
-        except UnicodeError, err:
+        except UnicodeError as err:
             raise SphinxError(str(err))
 
         # post-processing
                                 imgtype = imghdr.what(f)
                             finally:
                                 f.close()
-                        except (OSError, IOError), err:
+                        except (OSError, IOError) as err:
                             self.warn_node('image file %s not readable: %s' %
                                            (filename, err), node)
                         if imgtype:
         longtitlenode = titlenode
         # explicit title set with title directive; use this only for
         # the <title> tag in HTML output
-        if document.has_key('title'):
+        if 'title' in document:
             longtitlenode = nodes.title()
             longtitlenode += nodes.Text(document['title'])
         # look for first section title and use that as the title
         for node in doctree.traverse(addnodes.only):
             try:
                 ret = builder.tags.eval_condition(node['expr'])
-            except Exception, err:
+            except Exception as err:
                 self.warn_node('exception while evaluating only '
                                'directive expression: %s' % err, node)
                 node.replace_self(node.children or nodes.comment())
                         add_entry(first, _('see also %s') % second, link=False)
                     else:
                         self.warn(fn, 'unknown index entry type %r' % type)
-                except ValueError, err:
+                except ValueError as err:
                     self.warn(fn, str(err))
 
         # sort the index entries; put all symbols at the front, even those

File sphinx/ext/autodoc.py

View file
             # try to introspect the signature
             try:
                 args = self.format_args()
-            except Exception, err:
+            except Exception as err:
                 self.directive.warn('error while formatting arguments for '
                                     '%s: %s' % (self.fullname, err))
                 args = None
             # parse right now, to get PycodeErrors on parsing (results will
             # be cached anyway)
             self.analyzer.find_attr_docs()
-        except PycodeError, err:
+        except PycodeError as err:
             self.env.app.debug('[autodoc] module analyzer failed: %s', err)
             # no source file -- e.g. for builtin and C modules
             self.analyzer = None
             ret = ClassLevelDocumenter.import_object(self)
             if isinstance(self.object, classmethod) or \
                    (isinstance(self.object, MethodType) and
-                    self.object.im_self is not None):
+                    self.object.__self__ is not None):
                 self.directivetype = 'classmethod'
                 # document class and static members before ordinary ones
                 self.member_order = self.member_order - 1
         try:
             self.genopt = Options(assemble_option_dict(
                 self.options.items(), doc_class.option_spec))
-        except (KeyError, ValueError, TypeError), err:
+        except (KeyError, ValueError, TypeError) as err:
             # an option is either unknown or has a wrong type
             msg = self.reporter.error('An option to %s is either unknown or '
                                       'has an invalid value: %s' % (self.name, err),

File sphinx/ext/autosummary/__init__.py

View file
             return obj, parent
         else:
             return sys.modules[modname], None
-    except (ValueError, ImportError, AttributeError, KeyError), e:
+    except (ValueError, ImportError, AttributeError, KeyError) as e:
         raise ImportError(*e.args)
 
 

File sphinx/ext/autosummary/generate.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import os
 import re
                               template_dir=options.templates)
 
 def _simple_info(msg):
-    print msg
+    print(msg)
 
 def _simple_warn(msg):
-    print >> sys.stderr, 'WARNING: ' + msg
+    print('WARNING: ' + msg, file=sys.stderr)
 
 # -- Generating output ---------------------------------------------------------
 
 
         try:
             name, obj, parent = import_by_name(name)
-        except ImportError, e:
+        except ImportError as e:
             warn('[autosummary] failed to import %r: %s' % (name, e))
             continue
 
         return find_autosummary_in_lines(lines, module=name, filename=filename)
     except AttributeError:
         pass
-    except ImportError, e:
-        print "Failed to import '%s': %s" % (name, e)
+    except ImportError as e:
+        print("Failed to import '%s': %s" % (name, e))
     return []
 
 def find_autosummary_in_lines(lines, module=None, filename=None):

File sphinx/ext/coverage.py

View file
 
             try:
                 mod = __import__(mod_name, fromlist=['foo'])
-            except ImportError, err:
+            except ImportError as err:
                 self.warn('module %s could not be imported: %s' %
                           (mod_name, err))
                 self.py_undoc[mod_name] = {'error': err}

File sphinx/ext/doctest.py

View file
         if self.config.doctest_test_doctest_blocks:
             def condition(node):
                 return (isinstance(node, (nodes.literal_block, nodes.comment))
-                        and node.has_key('testnodetype')) or \
+                        and 'testnodetype' in node) or \
                        isinstance(node, nodes.doctest_block)
         else:
             def condition(node):
                 return isinstance(node, (nodes.literal_block, nodes.comment)) \
-                        and node.has_key('testnodetype')
+                        and 'testnodetype' in node
         for node in doctree.traverse(condition):
-            source = node.has_key('test') and node['test'] or node.astext()
+            source = 'test' in node and node['test'] or node.astext()
             if not source:
                 self.warn('no code/output in %s block at %s:%s' %
                           (node.get('testnodetype', 'doctest'),

File sphinx/ext/graphviz.py

View file
         dot_args.extend(['-Tcmapx', '-o%s.map' % outfn])
     try:
         p = Popen(dot_args, stdout=PIPE, stdin=PIPE, stderr=PIPE)
-    except OSError, err:
+    except OSError as err:
         if err.errno != ENOENT:   # No such file or directory
             raise
         self.builder.warn('dot command %r cannot be run (needed for graphviz '
         # Graphviz may close standard input when an error occurs,
         # resulting in a broken pipe on communicate()
         stdout, stderr = p.communicate(code)
-    except (OSError, IOError), err:
+    except (OSError, IOError) as err:
         if err.errno not in (EPIPE, EINVAL):
             raise
         # in this case, read the standard output and standard error streams
             raise GraphvizError("graphviz_output_format must be one of 'png', "
                                 "'svg', but is %r" % format)
         fname, outfn = render_dot(self, code, options, format, prefix)
-    except GraphvizError, exc:
+    except GraphvizError as exc:
         self.builder.warn('dot code %r: ' % code + str(exc))
         raise nodes.SkipNode
 
 def render_dot_latex(self, node, code, options, prefix='graphviz'):
     try:
         fname, outfn = render_dot(self, code, options, 'pdf', prefix)
-    except GraphvizError, exc:
+    except GraphvizError as exc:
         self.builder.warn('dot code %r: ' % code + str(exc))
         raise nodes.SkipNode
 
 def render_dot_texinfo(self, node, code, options, prefix='graphviz'):
     try:
         fname, outfn = render_dot(self, code, options, 'png', prefix)
-    except GraphvizError, exc:
+    except GraphvizError as exc:
         self.builder.warn('dot code %r: ' % code + str(exc))
         raise nodes.SkipNode
     if fname is not None:

File sphinx/ext/ifconfig.py

View file
     for node in doctree.traverse(ifconfig):
         try:
             res = eval(node['expr'], ns)
-        except Exception, err:
+        except Exception as err:
             # handle exceptions in a clean fashion
             from traceback import format_exception_only
             msg = ''.join(format_exception_only(err.__class__, err))

File sphinx/ext/inheritance_diagram.py

View file
                 class_names, env.temp_data.get('py:module'),
                 parts=node['parts'],
                 private_bases='private-bases' in self.options)
-        except InheritanceException, err:
+        except InheritanceException as err:
             return [node.document.reporter.warning(err.args[0],
                                                    line=self.lineno)]
 

File sphinx/ext/intersphinx.py

View file
             f = urllib2.urlopen(inv)
         else:
             f = open(path.join(app.srcdir, inv), 'rb')
-    except Exception, err:
+    except Exception as err:
         app.warn('intersphinx inventory %r not fetchable due to '
                  '%s: %s' % (inv, err.__class__, err))
         return
         except ValueError:
             f.close()
             raise ValueError('unknown or unsupported inventory version')
-    except Exception, err:
+    except Exception as err:
         app.warn('intersphinx inventory %r not readable due to '
                  '%s: %s' % (inv, err.__class__.__name__, err))
     else:

File sphinx/ext/pngmath.py

View file
     try:
         try:
             p = Popen(ltx_args, stdout=PIPE, stderr=PIPE)
-        except OSError, err:
+        except OSError as err:
             if err.errno != ENOENT:   # No such file or directory
                 raise
             self.builder.warn('LaTeX command %r cannot be run (needed for math '
     dvipng_args.append(path.join(tempdir, 'math.dvi'))
     try:
         p = Popen(dvipng_args, stdout=PIPE, stderr=PIPE)
-    except OSError, err:
+    except OSError as err:
         if err.errno != ENOENT:   # No such file or directory
             raise
         self.builder.warn('dvipng command %r cannot be run (needed for math '
 def html_visit_math(self, node):
     try:
         fname, depth = render_math(self, '$'+node['latex']+'$')
-    except MathExtError, exc:
+    except MathExtError as exc:
         msg = unicode(exc)
         sm = nodes.system_message(msg, type='WARNING', level=2,
                                   backrefs=[], source=node['latex'])
         latex = wrap_displaymath(node['latex'], None)
     try:
         fname, depth = render_math(self, latex)
-    except MathExtError, exc:
+    except MathExtError as exc:
         sm = nodes.system_message(str(exc), type='WARNING', level=2,
                                   backrefs=[], source=node['latex'])
         sm.walkabout(self)

File sphinx/pycode/__init__.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import sys
 from os import path
             return cls.cache['file', filename]
         try:
             fileobj = open(filename, 'rb')
-        except Exception, err:
+        except Exception as err:
             raise PycodeError('error opening %r' % filename, err)
         obj = cls(fileobj, modname, filename)
         cls.cache['file', filename] = obj
                 obj = cls.for_string(source, modname)
             else:
                 obj = cls.for_file(source, modname)
-        except PycodeError, err:
+        except PycodeError as err:
             cls.cache['module', modname] = err
             raise
         cls.cache['module', modname] = obj
             return
         try:
             self.tokens = list(tokenize.generate_tokens(self.source.readline))
-        except tokenize.TokenError, err:
+        except tokenize.TokenError as err:
             raise PycodeError('tokenizing failed', err)
         self.source.close()
 
         self.tokenize()
         try:
             self.parsetree = pydriver.parse_tokens(self.tokens)
-        except parse.ParseError, err:
+        except parse.ParseError as err:
             raise PycodeError('parsing failed', err)
 
     def find_attr_docs(self, scope=''):
     pprint.pprint(ma.find_tags())
     x3 = time.time()
     #print nodes.nice_repr(ma.parsetree, number2name)
-    print "tokenizing %.4f, parsing %.4f, finding %.4f" % (x1-x0, x2-x1, x3-x2)
+    print("tokenizing %.4f, parsing %.4f, finding %.4f" % (x1-x0, x2-x1, x3-x2))

File sphinx/pycode/pgen2/driver.py

View file
             logger.info("Writing grammar tables to %s", gp)
             try:
                 g.dump(gp)
-            except IOError, e:
+            except IOError as e:
                 logger.info("Writing failed:"+str(e))
     else:
         g = grammar.Grammar()

File sphinx/pycode/pgen2/grammar.py

View file
 fallback token code OP, but the parser needs the actual token code.
 
 """
+from __future__ import print_function
 
 # Python imports
 import pickle
     def report(self):
         """Dump the grammar tables to standard output, for debugging."""
         from pprint import pprint
-        print "s2n"
+        print("s2n")
         pprint(self.symbol2number)
-        print "n2s"
+        print("n2s")
         pprint(self.number2symbol)
-        print "states"
+        print("states")
         pprint(self.states)
-        print "dfas"
+        print("dfas")
         pprint(self.dfas)
-        print "labels"
+        print("labels")
         pprint(self.labels)
-        print "start", self.start
+        print("start", self.start)
 
 
 # Map from operator to number (since tokenize doesn't do this)

File sphinx/pycode/pgen2/literals.py

View file
 # Extended to handle raw and unicode literals by Georg Brandl.
 
 """Safely evaluate Python string literals without using eval()."""
+from __future__ import print_function
 
 import re
 
         s = repr(c)
         e = evalString(s)
         if e != c:
-            print i, c, s, e
+            print(i, c, s, e)
 
 
 if __name__ == "__main__":

File sphinx/pycode/pgen2/pgen.py

View file
 # Licensed to PSF under a Contributor Agreement.
 
 # Pgen imports
+from __future__ import print_function
 from sphinx.pycode.pgen2 import grammar, token, tokenize
 
 class PgenGrammar(grammar.Grammar):
         return states # List of DFAState instances; first one is start
 
     def dump_nfa(self, name, start, finish):
-        print "Dump of NFA for", name
+        print("Dump of NFA for", name)
         todo = [start]
         for i, state in enumerate(todo):
-            print "  State", i, state is finish and "(final)" or ""
+            print("  State", i, state is finish and "(final)" or "")
             for label, next in state.arcs:
                 if next in todo:
                     j = todo.index(next)
                     j = len(todo)
                     todo.append(next)
                 if label is None:
-                    print "    -> %d" % j
+                    print("    -> %d" % j)
                 else:
-                    print "    %s -> %d" % (label, j)
+                    print("    %s -> %d" % (label, j))
 
     def dump_dfa(self, name, dfa):
-        print "Dump of DFA for", name
+        print("Dump of DFA for", name)
         for i, state in enumerate(dfa):
-            print "  State", i, state.isfinal and "(final)" or ""
+            print("  State", i, state.isfinal and "(final)" or "")
             for label, next in state.arcs.iteritems():
-                print "    %s -> %d" % (label, dfa.index(next))
+                print("    %s -> %d" % (label, dfa.index(next)))
 
     def simplify_dfa(self, dfa):
         # This is not theoretically optimal, but works well enough.

File sphinx/pycode/pgen2/tokenize.py

View file
 function to which the 5 fields described above are passed as 5 arguments,
 each time a new token is found."""
 
+from __future__ import print_function
+
 __author__ = 'Ka-Ping Yee <ping@lfw.org>'
 __credits__ = \
     'GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip Montanaro'
 def printtoken(type, token, scell, ecell, line): # for testing
     srow, scol = scell
     erow, ecol = ecell
-    print "%d,%d-%d,%d:\t%s\t%s" % \
-        (srow, scol, erow, ecol, tok_name[type], repr(token))
+    print("%d,%d-%d,%d:\t%s\t%s" %
+          (srow, scol, erow, ecol, tok_name[type], repr(token)))
 
 def tokenize(readline, tokeneater=printtoken):
     """

File sphinx/quickstart.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import sys, os, time, re
 from os import path
                 if TERM_ENCODING:
                     prompt = prompt.encode(TERM_ENCODING)
                 else:
-                    print turquoise('* Note: non-ASCII default value provided '
+                    print(turquoise('* Note: non-ASCII default value provided '
                                     'and terminal encoding unknown -- assuming '
-                                    'UTF-8 or Latin-1.')
+                                    'UTF-8 or Latin-1.'))
                     try:
                         prompt = prompt.encode('utf-8')
                     except UnicodeEncodeError:
                 if TERM_ENCODING:
                     x = x.decode(TERM_ENCODING)
                 else:
-                    print turquoise('* Note: non-ASCII characters entered '
+                    print(turquoise('* Note: non-ASCII characters entered '
                                     'and terminal encoding unknown -- assuming '
-                                    'UTF-8 or Latin-1.')
+                                    'UTF-8 or Latin-1.'))
                     try:
                         x = x.decode('utf-8')
                     except UnicodeDecodeError:
                         x = x.decode('latin1')
         try:
             x = validator(x)
-        except ValidationError, err:
-            print red('* ' + str(err))
+        except ValidationError as err:
+            print(red('* ' + str(err)))
             continue
         break
     d[key] = x
     * batchfile: make command file
     """
 
-    print bold('Welcome to the Sphinx %s quickstart utility.') % __version__
-    print '''
+    print(bold('Welcome to the Sphinx %s quickstart utility.') % __version__)
+    print('''
 Please enter values for the following settings (just press Enter to
-accept a default value, if one is given in brackets).'''
+accept a default value, if one is given in brackets).''')
 
     if 'path' in d:
-        print bold('''
-Selected root path: %s''' % d['path'])
+        print(bold('''
+Selected root path: %s''' % d['path']))
     else:
-        print '''
-Enter the root path for documentation.'''
+        print('''
+Enter the root path for documentation.''')
         do_prompt(d, 'path', 'Root path for the documentation', '.', is_path)
 
     while path.isfile(path.join(d['path'], 'conf.py')) or \
           path.isfile(path.join(d['path'], 'source', 'conf.py')):
-        print
-        print bold('Error: an existing conf.py has been found in the '
-                   'selected root path.')
-        print 'sphinx-quickstart will not overwrite existing Sphinx projects.'
-        print
+        print()
+        print(bold('Error: an existing conf.py has been found in the '
+                   'selected root path.'))
+        print('sphinx-quickstart will not overwrite existing Sphinx projects.')
+        print()
         do_prompt(d, 'path', 'Please enter a new root path (or just Enter '
                   'to exit)', '', is_path)
         if not d['path']:
             sys.exit(1)
 
     if 'sep' not in d:
-        print '''
+        print('''
 You have two options for placing the build directory for Sphinx output.
 Either, you use a directory "_build" within the root path, or you separate
-"source" and "build" directories within the root path.'''
+"source" and "build" directories within the root path.''')
         do_prompt(d, 'sep', 'Separate source and build directories (y/n)', 'n',
                   boolean)
 
     if 'dot' not in d:
-        print '''
+        print('''
 Inside the root directory, two more directories will be created; "_templates"
 for custom HTML templates and "_static" for custom stylesheets and other static
-files. You can enter another prefix (such as ".") to replace the underscore.'''
+files. You can enter another prefix (such as ".") to replace the underscore.''')
         do_prompt(d, 'dot', 'Name prefix for templates and static dir', '_', ok)
 
     if 'project' not in d:
-        print '''
-The project name will occur in several places in the built documentation.'''
+        print('''
+The project name will occur in several places in the built documentation.''')
         do_prompt(d, 'project', 'Project name')
     if 'author' not in d:
         do_prompt(d, 'author', 'Author name(s)')
 
     if 'version' not in d:
-        print '''
+        print('''
 Sphinx has the notion of a "version" and a "release" for the
 software. Each version can have multiple releases. For example, for
 Python the version is something like 2.5 or 3.0, while the release is
 something like 2.5.1 or 3.0a1.  If you don't need this dual structure,
-just set both to the same value.'''
+just set both to the same value.''')
         do_prompt(d, 'version', 'Project version')
     if 'release' not in d:
         do_prompt(d, 'release', 'Project release', d['version'])
 
     if 'language' not in d:
-        print '''
+        print('''
 If the documents are to be written in a language other than English,
 you can select a language here by its language code. Sphinx will then
 translate text that it generates into that language.
 
 For a list of supported codes, see
-http://sphinx-doc.org/config.html#confval-language.'''
+http://sphinx-doc.org/config.html#confval-language.''')
         do_prompt(d, 'language', 'Project language', 'en')
         if d['language'] == 'en':
             d['language'] = None
 
     if 'suffix' not in d:
-        print '''
+        print('''
 The file name suffix for source files. Commonly, this is either ".txt"
-or ".rst".  Only files with this suffix are considered documents.'''
+or ".rst".  Only files with this suffix are considered documents.''')
         do_prompt(d, 'suffix', 'Source file suffix', '.rst', suffix)
 
     if 'master' not in d:
-        print '''
+        print('''
 One document is special in that it is considered the top node of the
 "contents tree", that is, it is the root of the hierarchical structure
 of the documents. Normally, this is "index", but if your "index"
-document is a custom template, you can also set this to another filename.'''
+document is a custom template, you can also set this to another filename.''')
         do_prompt(d, 'master', 'Name of your master document (without suffix)',
                   'index')
 
     while path.isfile(path.join(d['path'], d['master']+d['suffix'])) or \
           path.isfile(path.join(d['path'], 'source', d['master']+d['suffix'])):
-        print
-        print bold('Error: the master file %s has already been found in the '
-                   'selected root path.' % (d['master']+d['suffix']))
-        print 'sphinx-quickstart will not overwrite the existing file.'
-        print
+        print()
+        print(bold('Error: the master file %s has already been found in the '
+                   'selected root path.' % (d['master']+d['suffix'])))
+        print('sphinx-quickstart will not overwrite the existing file.')
+        print()
         do_prompt(d, 'master', 'Please enter a new file name, or rename the '
                   'existing file and press Enter', d['master'])
 
     if 'epub' not in d:
-        print '''
-Sphinx can also add configuration for epub output:'''
+        print('''
+Sphinx can also add configuration for epub output:''')
         do_prompt(d, 'epub', 'Do you want to use the epub builder (y/n)',
                   'n', boolean)
 
     if 'ext_autodoc' not in d:
-        print '''
-Please indicate if you want to use one of the following Sphinx extensions:'''
+        print('''
+Please indicate if you want to use one of the following Sphinx extensions:''')
         do_prompt(d, 'ext_autodoc', 'autodoc: automatically insert docstrings '
                   'from modules (y/n)', 'n', boolean)
     if 'ext_doctest' not in d:
         do_prompt(d, 'ext_mathjax', 'mathjax: include math, rendered in the '
                   'browser by MathJax (y/n)', 'n', boolean)
     if d['ext_pngmath'] and d['ext_mathjax']:
-        print '''Note: pngmath and mathjax cannot be enabled at the same time.
-pngmath has been deselected.'''
+        print('''Note: pngmath and mathjax cannot be enabled at the same time.
+pngmath has been deselected.''')
     if 'ext_ifconfig' not in d:
         do_prompt(d, 'ext_ifconfig', 'ifconfig: conditional inclusion of '
                   'content based on config values (y/n)', 'n', boolean)
                   'code of documented Python objects (y/n)', 'n', boolean)
 
     if 'makefile' not in d:
-        print '''
+        print('''
 A Makefile and a Windows command file can be generated for you so that you
 only have to run e.g. `make html' instead of invoking sphinx-build
-directly.'''
+directly.''')
         do_prompt(d, 'makefile', 'Create Makefile? (y/n)', 'y', boolean)
     if 'batchfile' not in d:
         do_prompt(d, 'batchfile', 'Create Windows command file? (y/n)',
                   'y', boolean)
-    print
+    print()
 
 
 def generate(d, overwrite=True, silent=False):
 
     def write_file(fpath, content, newline=None):
         if overwrite or not path.isfile(fpath):
-            print 'Creating file %s.' % fpath
+            print('Creating file %s.' % fpath)
             f = open(fpath, 'wt', encoding='utf-8', newline=newline)
             try:
                 f.write(content)
             finally:
                 f.close()
         else:
-            print 'File %s already exists, skipping.' % fpath
+            print('File %s already exists, skipping.' % fpath)
 
     conf_text = QUICKSTART_CONF % d
     if d['epub']:
 
     if silent:
         return
-    print
-    print bold('Finished: An initial directory structure has been created.')
-    print '''
+    print()
+    print(bold('Finished: An initial directory structure has been created.'))
+    print('''
 You should now populate your master file %s and create other documentation
 source files. ''' % masterfile + ((d['makefile'] or d['batchfile']) and '''\
 Use the Makefile to build the docs, like so:
    sphinx-build -b builder %s %s
 ''' % (srcdir, builddir)) + '''\
 where "builder" is one of the supported builders, e.g. html, latex or linkcheck.
-'''
+''')
 
 
 def main(argv=sys.argv):
 
     d = {}
     if len(argv) > 3:
-        print 'Usage: sphinx-quickstart [root]'
+        print('Usage: sphinx-quickstart [root]')
         sys.exit(1)
     elif len(argv) == 2:
         d['path'] = argv[1]
     try:
         ask_user(d)
     except (KeyboardInterrupt, EOFError):
-        print
-        print '[Interrupted.]'
+        print()
+        print('[Interrupted.]')
         return
     generate(d)

File sphinx/setup_command.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import sys
 import os
 
         try:
             app.build(force_all=self.all_files)
-        except Exception, err:
+        except Exception as err:
             from docutils.utils import SystemMessage
             if isinstance(err, SystemMessage):
-                print >>sys.stderr, darkred('reST markup error:')
-                print >>sys.stderr, err.args[0].encode('ascii',
-                                                       'backslashreplace')
+                print(darkred('reST markup error:'), file=sys.stderr)
+                print(err.args[0].encode('ascii',
+                                                       'backslashreplace'), file=sys.stderr)
             else:
                 raise
 

File sphinx/transforms.py

View file
         for node in self.document.traverse(nodes.target):
             if not node['ids']:
                 continue
-            if (node.has_key('ismod') and
+            if ('ismod' in node and
                 node.parent.__class__ is nodes.section and
                 # index 0 is the section title node
                 node.parent.index(node) == 1):

File sphinx/util/__init__.py

View file
     if modname not in sys.modules:
         try:
             __import__(modname)
-        except Exception, err:
+        except Exception as err:
             raise PycodeError('error importing %r' % modname, err)
     mod = sys.modules[modname]
     filename = getattr(mod, '__file__', None)
     if loader and getattr(loader, 'get_filename', None):
         try:
             filename = loader.get_filename(modname)
-        except Exception, err:
+        except Exception as err:
             raise PycodeError('error getting filename for %r' % filename, err)
     if filename is None and loader:
         try:
             return 'string', loader.get_source(modname)
-        except Exception, err:
+        except Exception as err:
             raise PycodeError('error getting source for %r' % modname, err)
     if filename is None:
         raise PycodeError('no source found for module %r' % modname)

File sphinx/util/docfields.py

View file
             if is_typefield:
                 # filter out only inline nodes; others will result in invalid
                 # markup being written out
-                content = filter(
-                    lambda n: isinstance(n, nodes.Inline) or
-                              isinstance(n, nodes.Text),
-                    content)
+                content = [n for n in content if isinstance(n, nodes.Inline) or
+                              isinstance(n, nodes.Text)]
                 if content:
                     types.setdefault(typename, {})[fieldarg] = content
                 continue

File sphinx/util/docstrings.py

View file
     """
     lines = s.expandtabs().splitlines()
     # Find minimum indentation of any non-blank lines after ignored lines.
-    margin = sys.maxint
+    margin = sys.maxsize
     for line in lines[ignore:]:
         content = len(line.lstrip())
         if content:
     for i in range(ignore):
         if i < len(lines):
             lines[i] = lines[i].lstrip()
-    if margin < sys.maxint:
+    if margin < sys.maxsize:
         for i in range(ignore, len(lines)): lines[i] = lines[i][margin:]
     # Remove any leading blank lines.
     while lines and not lines[0]:

File sphinx/util/inspect.py

View file
     def getargspec(func):
         """Like inspect.getargspec but supports functools.partial as well."""
         if inspect.ismethod(func):
-            func = func.im_func
+            func = func.__func__
         parts = 0, ()
         if type(func) is partial:
             keywords = func.keywords
             func = func.func
         if not inspect.isfunction(func):
             raise TypeError('%r is not a Python function' % func)
-        args, varargs, varkw = inspect.getargs(func.func_code)
-        func_defaults = func.func_defaults
+        args, varargs, varkw = inspect.getargs(func.__code__)
+        func_defaults = func.__defaults__
         if func_defaults is None:
             func_defaults = []
         else:

File sphinx/util/matching.py

View file
     if pat not in _pat_cache:
         _pat_cache[pat] = re.compile(_translate_pattern(pat))
     match = _pat_cache[pat].match
-    return filter(match, names)
+    return list(filter(match, names))

File sphinx/util/osutil.py

View file
     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+from __future__ import print_function
 
 import os
 import re
     """Ensure that a path exists."""
     try:
         os.makedirs(path)
-    except OSError, err:
+    except OSError as err:
         # 0 for Jython/Win32
         if err.errno not in [0, EEXIST]:
             raise
         try:
             fullpath = path.join(top, name)
         except UnicodeError:
-            print >>sys.stderr, (
-                '%s:: ERROR: non-ASCII filename not supported on this '
-                'filesystem encoding %r, skipped.' % (name, fs_encoding))
+            print('%s:: ERROR: non-ASCII filename not supported on this '
+                  'filesystem encoding %r, skipped.' % (name, fs_encoding),
+                  file=sys.stderr)
             continue
         if path.isdir(fullpath):
             dirs.append(name)

File sphinx/util/pycompat.py

View file
         source = refactoring_tool._read_python_source(filepath)[0]
         try:
             tree = refactoring_tool.refactor_string(source, 'conf.py')
-        except ParseError, err:
+        except ParseError as err:
             # do not propagate lib2to3 exceptions
             lineno, offset = err.context[1]
             # try to match ParseError details with SyntaxError details

File sphinx/writers/html.py

View file
         self.no_smarty = 0
         self.builder = builder
         self.highlightlang = builder.config.highlight_language
-        self.highlightlinenothreshold = sys.maxint
+        self.highlightlinenothreshold = sys.maxsize
         self.protect_literal_text = 0
         self.permalink_text = builder.config.html_add_permalinks
         # support backwards-compatible setting to a bool
         linenos = node.rawsource.count('\n') >= \
                   self.highlightlinenothreshold - 1
         highlight_args = node.get('highlight_args', {})
-        if node.has_key('language'):
+        if 'language' in node:
             # code-block directives
             lang = node['language']
             highlight_args['force'] = True
-        if node.has_key('linenos'):
+        if 'linenos' in node:
             linenos = node['linenos']
         def warner(msg):
             self.builder.warn(msg, (self.builder.current_docname, node.line))
         if node['uri'].lower().endswith('svg') or \
            node['uri'].lower().endswith('svgz'):
             atts = {'src': node['uri']}
-            if node.has_key('width'):
+            if 'width' in node:
                 atts['width'] = node['width']
-            if node.has_key('height'):
+            if 'height' in node:
                 atts['height'] = node['height']
-            if node.has_key('alt'):
+            if 'alt' in node:
                 atts['alt'] = node['alt']
-            if node.has_key('align'):
+            if 'align' in node:
                 self.body.append('<div align="%s" class="align-%s">' %
                                  (node['align'], node['align']))
                 self.context.append('</div>\n')
             self.body.append(self.emptytag(node, 'img', '', **atts))
             return
 
-        if node.has_key('scale'):
+        if 'scale' in node:
             # Try to figure out image height and width.  Docutils does that too,
             # but it tries the final file name, which does not necessarily exist
             # yet at the time the HTML file is written.
-            if Image and not (node.has_key('width')
-                              and node.has_key('height')):
+            if Image and not ('width' in node
+                              and 'height' in node):
                 try:
                     im = Image.open(os.path.join(self.builder.srcdir, olduri))
                 except (IOError, # Source image can't be found or opened
                         UnicodeError):  # PIL doesn't like Unicode paths.
                     pass
                 else:
-                    if not node.has_key('width'):
+                    if 'width' not in node:
                         node['width'] = str(im.size[0])
-                    if not node.has_key('height'):
+                    if 'height' not in node:
                         node['height'] = str(im.size[1])
                     del im
         BaseTranslator.visit_image(self, node)

File sphinx/writers/latex.py

View file
         # the second item is the default for the master file and can be changed
         # by .. highlight:: directive in the master file
         self.hlsettingstack = 2 * [[builder.config.highlight_language,
-                                    sys.maxint]]
+                                    sys.maxsize]]
         self.footnotestack = []
         self.curfilestack = []
         self.handled_abbrs = set()
                 else:
                     self.builder.warn(
                         'unknown index entry type %s found' % type)
-            except ValueError, err:
+            except ValueError as err:
                 self.builder.warn(str(err))
         raise nodes.SkipNode
 

File sphinx/writers/texinfo.py

View file
     def visit_reference(self, node):
         # an xref's target is displayed in Info so we ignore a few
         # cases for the sake of appearance
-        if isinstance(node.parent, (nodes.title, addnodes.desc_type,)):
+        if isinstance(node.parent, (nodes.title, addnodes.desc_type)):
             return
         if isinstance(node[0], nodes.image):
             return

File sphinx/writers/text.py

View file
         pass
 
     def visit_entry(self, node):
-        if node.has_key('morerows') or node.has_key('morecols'):
+        if 'morerows' in node or 'morecols' in node:
             raise NotImplementedError('Column or row spanning cells are '
                                       'not implemented.')
         self.new_state(0)

File tests/coverage.py

View file
 
 Coverage data is saved in the file .coverage by default.  Set the
 COVERAGE_FILE environment variable to save it somewhere else."""
+from __future__ import print_function
 
 __version__ = "2.85.20080914"    # see detailed history at the end of this file.
 
 import string
 import symbol
 import sys
+import atexit
 import threading
 import token
 import types
                 return 0
             # If this line is excluded, or suite_spots maps this line to
             # another line that is exlcuded, then we're excluded.
-            elif self.excluded.has_key(lineno) or \
-                 self.suite_spots.has_key(lineno) and \
-                 self.excluded.has_key(self.suite_spots[lineno][1]):
+            elif lineno in self.excluded or \
+                 lineno in self.suite_spots and \
+                 self.suite_spots[lineno][1] in self.excluded:
                 return 0
             # Otherwise, this is an executable line.
             else:
         lastprev = self.getLastLine(prevsuite)
         firstelse = self.getFirstLine(suite)
         for l in range(lastprev+1, firstelse):
-            if self.suite_spots.has_key(l):
-                self.doSuite(None, suite, exclude=self.excluded.has_key(l))
+            if l in self.suite_spots:
+                self.doSuite(None, suite, exclude=l in self.excluded)
                 break
         else:
             self.doSuite(None, suite)
 
     def help(self, error=None):     #pragma: no cover
         if error:
-            print error
-            print
-        print __doc__
+            print(error)
+            print()
+        print(__doc__)
         sys.exit(1)
 
     def command_line(self, argv, help_fn=None):
         long_opts = optmap.values()
         options, args = getopt.getopt(argv, short_opts, long_opts)
         for o, a in options:
-            if optmap.has_key(o):
+            if o in optmap:
                 settings[optmap[o]] = 1
-            elif optmap.has_key(o + ':'):
+            elif o + ':' in optmap:
                 settings[optmap[o + ':']] = a
             elif o[2:] in long_opts:
                 settings[o[2:]] = 1
             self.start()
             import __main__
             sys.path[0] = os.path.dirname(sys.argv[0])
-            execfile(sys.argv[0], __main__.__dict__)
+            exec(compile(open(sys.argv[0]).read(), sys.argv[0], 'exec'), __main__.__dict__)
         if settings.get('collect'):
             self.collect()
         if not args:
             import marshal
             cexecuted = marshal.load(cache)
             cache.close()
-            if isinstance(cexecuted, types.DictType):
+            if isinstance(cexecuted, dict):
                 return cexecuted
             else:
                 return {}
 
     def merge_data(self, new_data):
         for file_name, file_data in new_data.items():
-            if self.cexecuted.has_key(file_name):
+            if file_name in self.cexecuted:
                 self.merge_file_data(self.cexecuted[file_name], file_data)
             else:
                 self.cexecuted[file_name] = file_data
 
     def merge_file_data(self, cache_data, new_data):
         for line_number in new_data.keys():
-            if not cache_data.has_key(line_number):
+            if line_number not in cache_data:
                 cache_data[line_number] = new_data[line_number]
 
     def abs_file(self, filename):
     # normalized case).  See [GDR 2001-12-04b, 3.3].
 
     def canonical_filename(self, filename):
-        if not self.canonical_filename_cache.has_key(filename):
+        if filename not in self.canonical_filename_cache:
             f = filename
             if os.path.isabs(f) and not os.path.exists(f):
                 if not self.get_zip_data(f):
                 # Can't do anything useful with exec'd strings, so skip them.
                 continue
             f = self.canonical_filename(filename)
-            if not self.cexecuted.has_key(f):
+            if f not in self.cexecuted:
                 self.cexecuted[f] = {}
             self.cexecuted[f][lineno] = 1
         self.c = {}
     # statements that cross lines.
 
     def analyze_morf(self, morf):
-        if self.analysis_cache.has_key(morf):
+        if morf in self.analysis_cache:
             return self.analysis_cache[morf]
         filename = self.morf_filename(morf)
         ext = os.path.splitext(filename)[1]
             lines, excluded_lines, line_map = self.find_executable_statements(
                 source, exclude=self.exclude_re
                 )
-        except SyntaxError, synerr:
+        except SyntaxError as synerr:
             raise CoverageException(
                 "Couldn't parse '%s' as Python source: '%s' at line %d" %
                     (filename, synerr.msg, synerr.lineno)
     def analysis2(self, morf):
         filename, statements, excluded, line_map = self.analyze_morf(morf)
         self.canonicalize_filenames()
-        if not self.cexecuted.has_key(filename):
+        if filename not in self.cexecuted:
             self.cexecuted[filename] = {}
         missing = []
         for line in statements:
             lines = line_map.get(line, [line, line])
             for l in range(lines[0], lines[1]+1):
-                if self.cexecuted[filename].has_key(l):
+                if l in self.cexecuted[filename]:
                     break
             else:
                 missing.append(line)
 
     def report(self, morfs, show_missing=1, ignore_errors=0, file=None,
                omit_prefixes=[]):
-        if not isinstance(morfs, types.ListType):
+        if not isinstance(morfs, list):
             morfs = [morfs]
         # On windows, the shell doesn't expand wildcards.  Do it here.
         globbed = []
             fmt_coverage = fmt_coverage + "   %s"
         if not file:
             file = sys.stdout
-        print >>file, header
-        print >>file, "-" * len(header)
+        print(header, file=file)
+        print("-" * len(header), file=file)
         total_statements = 0
         total_executed = 0
         for morf in morfs:
                 args = (name, n, m, pc)
                 if show_missing:
                     args = args + (readable,)
-                print >>file, fmt_coverage % args
+                print(fmt_coverage % args, file=file)
                 total_statements = total_statements + n
                 total_executed = total_executed + m
             except KeyboardInterrupt:                       #pragma: no cover
             except:
                 if not ignore_errors:
                     typ, msg = sys.exc_info()[:2]
-                    print >>file, fmt_err % (name, typ, msg)
+                    print(fmt_err % (name, typ, msg), file=file)
         if len(morfs) > 1:
-            print >>file, "-" * len(header)
+            print("-" * len(header), file=file)
             if total_statements > 0:
                 pc = 100.0 * total_executed / total_statements
             else:
             args = ("TOTAL", total_statements, total_executed, pc)
             if show_missing:
                 args = args + ("",)
-            print >>file, fmt_coverage % args
+            print(fmt_coverage % args, file=file)
 
     # annotate(morfs, ignore_errors).
 
 def annotate_file(*args, **kw):
     return the_coverage.annotate_file(*args, **kw)
 
-# Save coverage data when Python exits.  (The atexit module wasn't
-# introduced until Python 2.0, so use sys.exitfunc when it's not
-# available.)
-try:
-    import atexit
-    atexit.register(the_coverage.save)
-except ImportError:
-    sys.exitfunc = the_coverage.save
+atexit.register(the_coverage.save)
 
 def main():
     the_coverage.command_line(sys.argv[1:])

File tests/etree13/ElementTree.py

View file
 # --------------------------------------------------------------------
 
 from __future__ import generators
+from __future__ import absolute_import
 
 __all__ = [
     # public symbols
         return result
 
 try:
-    import ElementPath
+    from . import ElementPath
 except ImportError:
     # FIXME: issue warning in this case?
     ElementPath = _SimpleElementPath()
     def feed(self, data):
         try:
             self._parser.Parse(data, 0)
-        except self._error, v:
+        except self._error as v:
             self._raiseerror(v)
 
     ##
     def close(self):
         try:
             self._parser.Parse("", 1) # end of data
-        except self._error, v:
+        except self._error as v:
             self._raiseerror(v)
         tree = self.target.close()
         del self.target, self._parser # get rid of circular references

File tests/etree13/HTMLTreeBuilder.py

View file
+from __future__ import absolute_import
 #
 # ElementTree
 # $Id$
 import re, string, sys
 import mimetools, StringIO
 
-import ElementTree
+from . import ElementTree
 
 AUTOCLOSE = "p", "li", "tr", "th", "td", "head", "body"
 IGNOREEND = "img", "hr", "meta", "link", "br"

File tests/path.py