python3 syntax fixes on various scripts

revealed by running tools/build_relese

docs/gh-pages.py

@@ -1,133 +1,135
 #!/usr/bin/env python
 """Script to commit the doc build outputs into the github-pages repo.
 
 Use:
 
   gh-pages.py [tag]
 
 If no tag is given, the current output of 'git describe' is used.  If given,
 that is how the resulting directory will be named.
 
 In practice, you should use either actual clean tags from a current build or
 something like 'current' as a stable URL for the most current version of the """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
+from __future__ import print_function
+
 import os
 import shutil
 import sys
 from os import chdir as cd
 from os.path import join as pjoin
 
 from subprocess import Popen, PIPE, CalledProcessError, check_call
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 pages_dir = 'gh-pages'
 html_dir = 'build/html'
 pdf_dir = 'build/latex'
 pages_repo = '[e-mail]:ipython/ipython-doc.git'
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 def sh(cmd):
     """Execute command in a subshell, return status code."""
     return check_call(cmd, shell=True)
 
 
 def sh2(cmd):
     """Execute command in a subshell, return stdout.
 
     Stderr is unbuffered from the subshell.x"""
     p = Popen(cmd, stdout=PIPE, shell=True)
     out = p.communicate()[0]
     retcode = p.returncode
     if retcode:
         raise CalledProcessError(retcode, cmd)
     else:
         return out.rstrip()
 
 
 def sh3(cmd):
     """Execute command in a subshell, return stdout, stderr
 
     If anything appears in stderr, print it out to sys.stderr"""
     p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
     out, err = p.communicate()
     retcode = p.returncode
     if retcode:
         raise CalledProcessError(retcode, cmd)
     else:
         return out.rstrip(), err.rstrip()
 
 
 def init_repo(path):
     """clone the gh-pages repo if we haven't already."""
     sh("git clone %s %s"%(pages_repo, path))
     here = os.getcwdu()
     cd(path)
     sh('git checkout gh-pages')
     cd(here)
 
 #-----------------------------------------------------------------------------
 # Script starts
 #-----------------------------------------------------------------------------
 if __name__ == '__main__':
     # The tag can be given as a positional argument
     try:
         tag = sys.argv[1]
     except IndexError:
         tag = "dev"
     
     startdir = os.getcwdu()
     if not os.path.exists(pages_dir):
         # init the repo
         init_repo(pages_dir)
     else:
         # ensure up-to-date before operating
         cd(pages_dir)
         sh('git checkout gh-pages')
         sh('git pull')
         cd(startdir)
 
     dest = pjoin(pages_dir, tag)
 
     # don't `make html` here, because gh-pages already depends on html in Makefile
     # sh('make html')
     if tag != 'dev':
         # only build pdf for non-dev targets
         #sh2('make pdf')
         pass
 
     # This is pretty unforgiving: we unconditionally nuke the destination
     # directory, and then copy the html tree in there
     shutil.rmtree(dest, ignore_errors=True)
     shutil.copytree(html_dir, dest)
     if tag != 'dev':
         #shutil.copy(pjoin(pdf_dir, 'ipython.pdf'), pjoin(dest, 'ipython.pdf'))
         pass
 
     try:
         cd(pages_dir)
         branch = sh2('git rev-parse --abbrev-ref HEAD').strip()
         if branch != 'gh-pages':
             e = 'On %r, git branch is %r, MUST be "gh-pages"' % (pages_dir,
                                                                  branch)
             raise RuntimeError(e)
 
         sh('git add -A %s' % tag)
         sh('git commit -m"Updated doc release: %s"' % tag)
-        print
-        print 'Most recent 3 commits:'
+        print()
+        print('Most recent 3 commits:')
         sys.stdout.flush()
         sh('git --no-pager log --oneline HEAD~3..')
     finally:
         cd(startdir)
 
-    print
-    print 'Now verify the build in: %r' % dest
-    print "If everything looks good, 'git push'"
+    print()
+    print('Now verify the build in: %r' % dest)
+    print("If everything looks good, 'git push'")

docs/source/conf.py

@@ -1,253 +1,253
 # -*- coding: utf-8 -*-
 #
 # IPython documentation build configuration file.
 
 # NOTE: This file has been edited manually from the auto-generated one from
 # sphinx.  Do NOT delete and re-generate.  If any changes from sphinx are
 # needed, generate a scratch one and merge by hand any new fields needed.
 
 #
 # This file is execfile()d with the current directory set to its containing dir.
 #
 # The contents of this file are pickled, so don't put values in the namespace
 # that aren't pickleable (module imports are okay, they're removed automatically).
 #
 # All configuration values have a default value; values that are commented out
 # serve to show the default value.
 
 import sys, os
 
 ON_RTD = os.environ.get('READTHEDOCS', None) == 'True'
 
 if ON_RTD:
     # Mock the presence of matplotlib, which we don't have on RTD
     # see
     # http://read-the-docs.readthedocs.org/en/latest/faq.html
     tags.add('rtd')
     
 # If your extensions are in another directory, add it here. If the directory
 # is relative to the documentation root, use os.path.abspath to make it
 # absolute, like shown here.
 sys.path.insert(0, os.path.abspath('../sphinxext'))
 
 # We load the ipython release info into a dict by explicit execution
 iprelease = {}
 execfile('../../IPython/core/release.py',iprelease)
 
 # General configuration
 # ---------------------
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
     'matplotlib.sphinxext.mathmpl',
     'matplotlib.sphinxext.only_directives',
     'matplotlib.sphinxext.plot_directive',
     'sphinx.ext.autodoc',
     'sphinx.ext.autosummary',
     'sphinx.ext.doctest',
     'sphinx.ext.inheritance_diagram',
     'sphinx.ext.intersphinx',
     'IPython.sphinxext.ipython_console_highlighting',
     'IPython.sphinxext.ipython_directive',
     'numpydoc',  # to preprocess docstrings
     'github',  # for easy GitHub links
     'magics',
 ]
 
 if ON_RTD:
     # Remove extensions not currently supported on RTD
     extensions.remove('matplotlib.sphinxext.only_directives')
     extensions.remove('matplotlib.sphinxext.mathmpl')
     extensions.remove('matplotlib.sphinxext.plot_directive')
     extensions.remove('IPython.sphinxext.ipython_directive')
     extensions.remove('IPython.sphinxext.ipython_console_highlighting')
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 
 # The suffix of source filenames.
 source_suffix = '.rst'
 
 if iprelease['_version_extra'] == 'dev':
     rst_prolog = """
     .. note::
 
         This documentation is for a development version of IPython. There may be
         significant differences from the latest stable release.
 
     """
 
 # The master toctree document.
 master_doc = 'index'
 
 # General substitutions.
 project = 'IPython'
 copyright = 'The IPython Development Team'
 
 # ghissue config
 github_project_url = "https://github.com/ipython/ipython"
 
 # numpydoc config
 numpydoc_show_class_members = False # Otherwise Sphinx emits thousands of warnings
 numpydoc_class_members_toctree = False
 
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.
 #
 # The full version, including alpha/beta/rc tags.
 release = "%s" % iprelease['version']
 # Just the X.Y.Z part, no '-dev'
 version = iprelease['version'].split('-', 1)[0]
 
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
 #today = ''
 # Else, today_fmt is used as the format for a strftime call.
 today_fmt = '%B %d, %Y'
 
 # List of documents that shouldn't be included in the build.
 #unused_docs = []
 
 # Exclude these glob-style patterns when looking for source files. They are
 # relative to the source/ directory.
 exclude_patterns = ['whatsnew/pr']
 
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
 #add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
 #add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
 #show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
 pygments_style = 'sphinx'
 
 # Set the default role so we can use `foo` instead of ``foo``
 default_role = 'literal'
 
 # Options for HTML output
 # -----------------------
 
 # The style sheet to use for HTML and HTML Help pages. A file of that name
 # must exist either in Sphinx' static/ path, or in one of the custom paths
 # given in html_static_path.
 html_style = 'default.css'
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
 #html_title = None
 
 # The name of an image file (within the static path) to place at the top of
 # the sidebar.
 #html_logo = None
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
 html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
 #html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
 #html_sidebars = {}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
 html_additional_pages = {
     'interactive/htmlnotebook': 'notebook_redirect.html',
     'interactive/notebook': 'notebook_redirect.html',
     'interactive/nbconvert': 'notebook_redirect.html',
     'interactive/public_server': 'notebook_redirect.html',
 }
 
 # If false, no module index is generated.
 #html_use_modindex = True
 
 # If true, the reST sources are included in the HTML build as _sources/<name>.
 #html_copy_source = True
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
 #html_use_opensearch = ''
 
 # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
 #html_file_suffix = ''
 
 # Output file base name for HTML help builder.
 htmlhelp_basename = 'ipythondoc'
 
 intersphinx_mapping = {'python': ('http://docs.python.org/2/', None),
                        'rpy2': ('http://rpy.sourceforge.net/rpy2/doc-2.4/html/', None)}
 
 # Options for LaTeX output
 # ------------------------
 
 # The paper size ('letter' or 'a4').
 latex_paper_size = 'letter'
 
 # The font size ('10pt', '11pt' or '12pt').
 latex_font_size = '11pt'
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, document class [howto/manual]).
 
 latex_documents = [
     ('index', 'ipython.tex', 'IPython Documentation',
-     ur"""The IPython Development Team""", 'manual', True),
+     u"""The IPython Development Team""", 'manual', True),
     ('parallel/winhpc_index', 'winhpc_whitepaper.tex',
      'Using IPython on Windows HPC Server 2008',
-     ur"Brian E. Granger", 'manual', True)
+     u"Brian E. Granger", 'manual', True)
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
 #latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
 #latex_use_parts = False
 
 # Additional stuff for the LaTeX preamble.
 #latex_preamble = ''
 
 # Documents to append as an appendix to all manuals.
 #latex_appendices = []
 
 # If false, no module index is generated.
 latex_use_modindex = True
 
 
 # Options for texinfo output
 # --------------------------
 
 texinfo_documents = [
   (master_doc, 'ipython', 'IPython Documentation',
    'The IPython Development Team',
    'IPython',
    'IPython Documentation',
    'Programming',
    1),
 ]
 
 modindex_common_prefix = ['IPython.']
 
 
 # Cleanup
 # -------
 # delete release info to avoid pickling errors from sphinx
 
 del iprelease

examples/Parallel Computing/interengine/bintree_script.py

@@ -1,87 +1,88
 #!/usr/bin/env python
 """
 Script for setting up and using [all]reduce with a binary-tree engine interconnect.
 
 usage: `python bintree_script.py`
 
 This spanning tree strategy ensures that a single node node mailbox will never 
 receive more that 2 messages at once. This is very important to scale to large 
 clusters (e.g. 1000 nodes) since if you have many incoming messages of a couple 
 of megabytes you might saturate the network interface of a single node and 
 potentially its memory buffers if the messages are not consumed in a streamed 
 manner.
 
 Note that the AllReduce scheme implemented with the spanning tree strategy 
 impose the aggregation function to be commutative and distributive. It might 
 not be the case if you implement the naive gather / reduce / broadcast strategy 
 where you can reorder the partial data before performing the reduce.
 """
+from __future__ import print_function
 
 from IPython.parallel import Client, Reference
 
 
 # connect client and create views
 rc = Client()
 rc.block=True
 ids = rc.ids
 
 root_id = ids[0]
 root = rc[root_id]
 
 view = rc[:]
 
 # run bintree.py script defining bintree functions, etc.
-execfile('bintree.py')
+exec(compile(open('bintree.py').read(), 'bintree.py', 'exec'))
 
 # generate binary tree of parents
 btree = bintree(ids)
 
-print "setting up binary tree interconnect:"
+print("setting up binary tree interconnect:")
 print_bintree(btree)
 
 view.run('bintree.py')
 view.scatter('id', ids, flatten=True)
 view['root_id'] = root_id
 
 # create the Communicator objects on the engines
 view.execute('com = BinaryTreeCommunicator(id, root = id==root_id )')
 pub_url = root.apply_sync(lambda : com.pub_url)
 
 # gather the connection information into a dict
 ar = view.apply_async(lambda : com.info)
 peers = ar.get_dict()
 # this is a dict, keyed by engine ID, of the connection info for the EngineCommunicators
 
 # connect the engines to each other:
 def connect(com, peers, tree, pub_url, root_id):
     """this function will be called on the engines"""
     com.connect(peers, tree, pub_url, root_id)
 
 view.apply_sync(connect, Reference('com'), peers, btree, pub_url, root_id)
 
 # functions that can be used for reductions
 # max and min builtins can be used as well
 def add(a,b):
     """cumulative sum reduction"""
     return a+b
 
 def mul(a,b):
     """cumulative product reduction"""
     return a*b
 
 view['add'] = add
 view['mul'] = mul
 
 # scatter some data
-data = range(1000)
+data = list(range(1000))
 view.scatter('data', data)
 
 # perform cumulative sum via allreduce
 view.execute("data_sum = com.allreduce(add, data, flat=False)")
-print "allreduce sum of data on all engines:", view['data_sum']
+print("allreduce sum of data on all engines:", view['data_sum'])
 
 # perform cumulative sum *without* final broadcast
 # when not broadcasting with allreduce, the final result resides on the root node:
 view.execute("ids_sum = com.reduce(add, id, flat=True)")
-print "reduce sum of engine ids (not broadcast):", root['ids_sum']
-print "partial result on each engine:", view['ids_sum']
+print("reduce sum of engine ids (not broadcast):", root['ids_sum'])
+print("partial result on each engine:", view['ids_sum'])

examples/Parallel Computing/wave2D/parallelwave-mpi.py

@@ -1,205 +1,205
 #!/usr/bin/env python
 """
 A simple python program of solving a 2D wave equation in parallel.
 Domain partitioning and inter-processor communication
 are done by an object of class MPIRectPartitioner2D
 (which is a subclass of RectPartitioner2D and uses MPI via mpi4py)
 
 An example of running the program is (8 processors, 4x2 partition,
 400x100 grid cells)::
 
    $ ipcluster start --engines=MPIExec -n 8 # start 8 engines with mpiexec
    $ python parallelwave-mpi.py --grid 400 100 --partition 4 2
 
 See also parallelwave-mpi, which runs the same program, but uses MPI
 (via mpi4py) for the inter-engine communication.
 
 Authors
 -------
 
  * Xing Cai
  * Min Ragan-Kelley
 
 """
 
 import sys
 import time
 
 from numpy import exp, zeros, newaxis, sqrt
 
 from IPython.external import argparse
 from IPython.parallel import Client, Reference
 
 def setup_partitioner(index, num_procs, gnum_cells, parts):
     """create a partitioner in the engine namespace"""
     global partitioner
     p = MPIRectPartitioner2D(my_id=index, num_procs=num_procs)
     p.redim(global_num_cells=gnum_cells, num_parts=parts)
     p.prepare_communication()
     # put the partitioner into the global namespace:
     partitioner=p
 
 def setup_solver(*args, **kwargs):
     """create a WaveSolver in the engine namespace"""
     global solver
     solver = WaveSolver(*args, **kwargs)
 
 def wave_saver(u, x, y, t):
     """save the wave log"""
     global u_hist
     global t_hist
     t_hist.append(t)
     u_hist.append(1.0*u)
 
 
 # main program:
 if __name__ == '__main__':
 
     parser = argparse.ArgumentParser()
     paa = parser.add_argument
     paa('--grid', '-g',
         type=int, nargs=2, default=[100,100], dest='grid',
         help="Cells in the grid, e.g. --grid 100 200")
     paa('--partition', '-p',
         type=int, nargs=2, default=None,
         help="Process partition grid, e.g. --partition 4 2 for 4x2")
     paa('-c',
         type=float, default=1.,
         help="Wave speed (I think)")
     paa('-Ly',
         type=float, default=1.,
         help="system size (in y)")
     paa('-Lx',
         type=float, default=1.,
         help="system size (in x)")
     paa('-t', '--tstop',
         type=float, default=1.,
         help="Time units to run")
     paa('--profile',
         type=unicode, default=u'default',
         help="Specify the ipcluster profile for the client to connect to.")
     paa('--save',
         action='store_true',
         help="Add this flag to save the time/wave history during the run.")
     paa('--scalar',
         action='store_true',
         help="Also run with scalar interior implementation, to see vector speedup.")
 
     ns = parser.parse_args()
     # set up arguments
     grid = ns.grid
     partition = ns.partition
     Lx = ns.Lx
     Ly = ns.Ly
     c = ns.c
     tstop = ns.tstop
     if ns.save:
         user_action = wave_saver
     else:
         user_action = None
 
     num_cells = 1.0*(grid[0]-1)*(grid[1]-1)
     final_test = True
 
     # create the Client
     rc = Client(profile=ns.profile)
     num_procs = len(rc.ids)
 
     if partition is None:
         partition = [1,num_procs]
 
     assert partition[0]*partition[1] == num_procs, "can't map partition %s to %i engines"%(partition, num_procs)
 
     view = rc[:]
-    print "Running %s system on %s processes until %f"%(grid, partition, tstop)
+    print("Running %s system on %s processes until %f" % (grid, partition, tstop))
 
     # functions defining initial/boundary/source conditions
     def I(x,y):
         from numpy import exp
         return 1.5*exp(-100*((x-0.5)**2+(y-0.5)**2))
     def f(x,y,t):
         return 0.0
         # from numpy import exp,sin
         # return 10*exp(-(x - sin(100*t))**2)
     def bc(x,y,t):
         return 0.0
 
     # initial imports, setup rank
     view.execute('\n'.join([
     "from mpi4py import MPI",
     "import numpy",
     "mpi = MPI.COMM_WORLD",
     "my_id = MPI.COMM_WORLD.Get_rank()"]), block=True)
 
     # initialize t_hist/u_hist for saving the state at each step (optional)
     view['t_hist'] = []
     view['u_hist'] = []
 
     # set vector/scalar implementation details
     impl = {}
     impl['ic'] = 'vectorized'
     impl['inner'] = 'scalar'
     impl['bc'] = 'vectorized'
 
     # execute some files so that the classes we need will be defined on the engines:
     view.run('RectPartitioner.py')
     view.run('wavesolver.py')
 
     # setup remote partitioner
     # note that Reference means that the argument passed to setup_partitioner will be the
     # object named 'my_id' in the engine's namespace
     view.apply_sync(setup_partitioner, Reference('my_id'), num_procs, grid, partition)
     # wait for initial communication to complete
     view.execute('mpi.barrier()')
     # setup remote solvers
     view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
 
     # lambda for calling solver.solve:
     _solve = lambda *args, **kwargs: solver.solve(*args, **kwargs)
 
     if ns.scalar:
         impl['inner'] = 'scalar'
         # run first with element-wise Python operations for each cell
         t0 = time.time()
         ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test, user_action=user_action)
         if final_test:
             # this sum is performed element-wise as results finish
             s = sum(ar)
             # the L2 norm (RMS) of the result:
             norm = sqrt(s/num_cells)
         else:
             norm = -1
         t1 = time.time()
-        print 'scalar inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
+        print('scalar inner-version, Wtime=%g, norm=%g' % (t1-t0, norm))
 
     impl['inner'] = 'vectorized'
     # setup new solvers
     view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
     view.execute('mpi.barrier()')
 
     # run again with numpy vectorized inner-implementation
     t0 = time.time()
     ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test, user_action=user_action)
     if final_test:
         # this sum is performed element-wise as results finish
         s = sum(ar)
         # the L2 norm (RMS) of the result:
         norm = sqrt(s/num_cells)
     else:
         norm = -1
     t1 = time.time()
-    print 'vector inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
+    print('vector inner-version, Wtime=%g, norm=%g' % (t1-t0, norm))
 
     # if ns.save is True, then u_hist stores the history of u as a list
     # If the partion scheme is Nx1, then u can be reconstructed via 'gather':
     if ns.save and partition[-1] == 1:
         import matplotlib.pyplot as plt
         view.execute('u_last=u_hist[-1]')
         # map mpi IDs to IPython IDs, which may not match
         ranks = view['my_id']
         targets = range(len(ranks))
         for idx in range(len(ranks)):
             targets[idx] = ranks.index(idx)
         u_last = rc[targets].gather('u_last', block=True)
         plt.pcolor(u_last)
         plt.show()

tools/build_release

@@ -1,28 +1,28
 #!/usr/bin/env python
 """IPython release build script.
 """
 
 import os
 from shutil import rmtree
 
 from toollib import *
 
 # Get main ipython dir, this will raise if it doesn't pass some checks
 ipdir = get_ipdir()
 cd(ipdir)
 
 # Load release info
-execfile(pjoin('IPython', 'core', 'release.py'))
+execfile(pjoin('IPython', 'core', 'release.py'), globals())
 
 # Check that everything compiles
 compile_tree()
 
 # Cleanup
 for d in ['build', 'dist', pjoin('docs', 'build'), pjoin('docs', 'dist'),
           pjoin('docs', 'source', 'api', 'generated')]:
     if os.path.isdir(d):
         rmtree(d)
 
 # Build source and binary distros
 sh(sdists)
 sh(wheels)

tools/check_sources.py

@@ -1,54 +1,55
 #!/usr/bin/env python
 """Utility to look for hard tabs and \r characters in all sources.
 
 Usage:
 
 ./check_sources.py
 
 It prints summaries and if chosen, line-by-line info of where \\t or \\r
 characters can be found in our source tree.
 """
+from __future__ import print_function
 
 # Config
 # If true, all lines that have tabs are printed, with line number
 full_report_tabs = True
 # If true, all lines that have tabs are printed, with line number
 full_report_rets = False
 
 # Code begins
 from IPython.external.path import path
 
 rets = []
 tabs = []
 
 for f in path('..').walkfiles('*.py'):
     errs = ''
     cont = f.bytes()
     if '\t' in cont:
         errs+='t'
         tabs.append(f)
 
     if '\r' in cont:
         errs+='r'
         rets.append(f)
         
     if errs:
-        print "%3s" % errs, f
+        print("%3s" % errs, f)
 
     if 't' in errs and full_report_tabs:
         for ln,line in enumerate(f.lines()):
             if '\t' in line:
-                print 'TAB:',ln,':',line,
+                print('TAB:',ln,':',line, end=' ')
 
     if 'r' in errs and full_report_rets:
         for ln,line in enumerate(open(f.abspath(),'rb')):
             if '\r' in line:
-                print 'RET:',ln,':',line,
+                print('RET:',ln,':',line, end=' ')
 
 # Summary at the end, to call cleanup tools if necessary
 if tabs:
-    print 'Hard tabs found. These can be cleaned with untabify:'
-    for f in tabs: print f,
+    print('Hard tabs found. These can be cleaned with untabify:')
+    for f in tabs: print(f, end=' ')
 if rets:
-    print 'Carriage returns (\\r) found in:'
-    for f in rets: print f,
+    print('Carriage returns (\\r) found in:')
+    for f in rets: print(f, end=' ')