Merge pull request #10021 from ivanov/remove-sys-version-checks

Remove sys version checks

tools/tests/embed/embed_flufl.py

@@ -0,0 +1,5 b''
+"""This tests that future compiler flags are passed to the embedded IPython."""
+from __future__ import barry_as_FLUFL
+from IPython import embed
+embed(banner1='', header='check 1 <> 2 == True')
+embed(banner1='', header='check 1 <> 2 cause SyntaxError', compile_flags=0)

IPython/__init__.py

@@ -18,7 +18,6 b' http://ipython.org'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import absolute_import
 
 import os
 import sys

IPython/core/compilerop.py

@@ -25,7 +25,6 b' Authors'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
 import __future__

IPython/core/completer.py

@@ -13,7 +13,6 b' upstream and were accepted as of Python 2.3,'
 # Some of this code originated from rlcompleter in the Python standard library
 # Copyright (C) 2001 Python Software Foundation, www.python.org
 
-from __future__ import print_function
 
 import __main__
 import glob

IPython/core/completerlib.py

@@ -14,7 +14,6 b' These are all loaded by default by IPython.'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
 import glob

IPython/core/crashhandler.py

@@ -18,7 +18,6 b' Authors:'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 import os
 import sys

IPython/core/debugger.py

@@ -24,7 +24,6 b' http://www.python.org/2.2.3/license.html"""'
 #
 #
 #*****************************************************************************
-from __future__ import print_function
 
 import bdb
 import functools
@@ -604,7 +603,6 b' class Pdb(OldPdb, object):'
                       ('Globals', self.curframe.f_globals)]
         self.shell.find_line_magic('psource')(arg, namespaces=namespaces)
 
-    if sys.version_info > (3, ):
         def do_where(self, arg):
             """w(here)
             Print a stack trace, with the most recent frame at the bottom.

IPython/core/display.py

@@ -4,7 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 try:
     from base64 import encodebytes as base64_encode

IPython/core/displayhook.py

@@ -7,7 +7,6 b' This defines a callable class that IPython uses for `sys.displayhook`.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import sys
 import io as _io

IPython/core/displaypub.py

@@ -15,7 +15,6 b' spec.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import sys
 

IPython/core/events.py

@@ -12,7 +12,6 b' events and the arguments which will be passed to them.'
 
    This API is experimental in IPython 2.0, and may be revised in future versions.
 """
-from __future__ import print_function
 
 class EventManager(object):
     """Manage a collection of events and a sequence of callbacks for each.

IPython/core/history.py

@@ -3,7 +3,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import atexit
 import datetime

IPython/core/historyapp.py

@@ -4,7 +4,6 b' An application for managing IPython history.'
 
 To be invoked as the `ipython history` subcommand.
 """
-from __future__ import print_function
 
 import os
 import sqlite3

IPython/core/interactiveshell.py

@@ -10,7 +10,6 b''
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-from __future__ import absolute_import, print_function
 
 import __future__
 import abc
@@ -57,7 +56,7 b' from IPython.core.payload import PayloadManager'
 from IPython.core.prefilter import PrefilterManager
 from IPython.core.profiledir import ProfileDir
 from IPython.core.usage import default_banner
-from IPython.testing.skipdoctest import skip_doctest_py2, skip_doctest
+from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import PyColorize
 from IPython.utils import io
 from IPython.utils import py3compat
@@ -187,10 +186,7 b' class ExecutionResult(object):'
             raise self.error_in_exec
 
     def __repr__(self):
-        if sys.version_info > (3,):
             name = self.__class__.__qualname__
-        else:
-            name = self.__class__.__name__
         return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s result=%s>' %\
                 (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.result))
 
@@ -1922,7 +1918,6 b' class InteractiveShell(SingletonConfigurable):'
         self.set_hook('complete_command', reset_completer, str_key = '%reset')
 
 
-    @skip_doctest_py2
     def complete(self, text, line=None, cursor_pos=None):
         """Return the completed text and a list of completions.
 

IPython/core/logger.py

@@ -1,6 +1,5 b''
 """Logger class for IPython's logging facilities.
 """
-from __future__ import print_function
 
 #*****************************************************************************
 #       Copyright (C) 2001 Janko Hauser <[e-mail]> and

IPython/core/magic.py

@@ -1,7 +1,6 b''
 # encoding: utf-8
 """Magic functions for InteractiveShell.
 """
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2001 Janko Hauser <[e-mail]> and

IPython/core/magics/auto.py

@@ -1,7 +1,5 b''
 """Implementation of magic functions that control various automatic behaviors.
 """
-from __future__ import print_function
-from __future__ import absolute_import
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/basic.py

@@ -1,7 +1,5 b''
 """Implementation of basic magic functions."""
 
-from __future__ import print_function
-from __future__ import absolute_import
 
 import argparse
 import io

IPython/core/magics/code.py

@@ -1,7 +1,5 b''
 """Implementation of code management magic functions.
 """
-from __future__ import print_function
-from __future__ import absolute_import
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/config.py

@@ -1,7 +1,5 b''
 """Implementation of configuration-related magic functions.
 """
-from __future__ import print_function
-from __future__ import absolute_import
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/execution.py

@@ -4,8 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
-from __future__ import absolute_import
 
 import ast
 import bdb

IPython/core/magics/extension.py

@@ -1,6 +1,5 b''
 """Implementation of magic functions for the extension machinery.
 """
-from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/history.py

@@ -11,7 +11,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib
 import os

IPython/core/magics/namespace.py

@@ -1,6 +1,5 b''
 """Implementation of namespace-related magic functions.
 """
-from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/osm.py

@@ -3,7 +3,6 b''
 Note: this module is named 'osm' instead of 'os' to avoid a collision with the
 builtin.
 """
-from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/pylab.py

@@ -1,6 +1,5 b''
 """Implementation of magic functions for matplotlib/pylab support.
 """
-from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #

IPython/core/magics/script.py

@@ -1,5 +1,4 b''
 """Magic functions for running cells in various scripts."""
-from __future__ import print_function
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.

IPython/core/oinspect.py

@@ -10,8 +10,6 b' reference the name under which an object is being read.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
-
 __all__ = ['Inspector','InspectColors']
 
 # stdlib modules
@@ -31,7 +29,7 b' except ImportError:'
 # IPython's own
 from IPython.core import page
 from IPython.lib.pretty import pretty
-from IPython.testing.skipdoctest import skip_doctest_py3
+from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import PyColorize
 from IPython.utils import openpy
 from IPython.utils import py3compat
@@ -437,7 +435,7 b' class Inspector(Colorable):'
             print(header,self.format(output), end=' ')
 
     # In Python 3, all classes are new-style, so they all have __init__.
-    @skip_doctest_py3
+    @skip_doctest
     def pdoc(self, obj, oname='', formatter=None):
         """Print the docstring for any object.
 

IPython/core/page.py

@@ -13,7 +13,6 b' rid of that dependency, we could move it there.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import os
 import re

IPython/core/profileapp.py

@@ -9,7 +9,6 b' Authors:'
 * Min RK
 
 """
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team

IPython/core/pylabtools.py

@@ -1,6 +1,5 b''
 # -*- coding: utf-8 -*-
 """Pylab (matplotlib) support utilities."""
-from __future__ import print_function
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.

IPython/core/shellapp.py

@@ -7,9 +7,6 b' launch InteractiveShell instances, load extensions, etc.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import absolute_import
-from __future__ import print_function
-
 import glob
 import os
 import sys

IPython/core/tests/nonascii.py

@@ -1,5 +1,4 b''
 # coding: iso-8859-5
 # (Unlikely to be the default encoding for most testers.)
 # ������������������� <- Cyrillic characters
-from __future__ import unicode_literals
 u = '����'

IPython/core/tests/print_argv.py

@@ -1,3 +1,2 b''
-from __future__ import print_function
 import sys
 print(sys.argv[1:])

IPython/core/tests/refbug.py

@@ -12,7 +12,6 b' This script is meant to be called by other parts of the test suite that call it'
 via %run as if it were executed interactively by the user. As of 2011-05-29,
 test_run.py calls it.
 """
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 # Module imports

IPython/core/tests/tclass.py

@@ -2,7 +2,6 b''
 
 See test_run for details."""
 
-from __future__ import print_function
 
 import sys
 

IPython/core/tests/test_compilerop.py

@@ -12,7 +12,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
 import linecache

IPython/core/tests/test_completer.py

@@ -155,7 +155,6 b' def test_latex_completions():'
 
 
 
[e-mail](sys.version_info[0] >= 3, 'This test only apply on python3')
 def test_back_latex_completion():
     ip = get_ipython()
 
@@ -164,7 +163,6 b' def test_back_latex_completion():'
     nt.assert_equal(len(matches), 1)
     nt.assert_equal(matches[0], '\\beta')
 
[e-mail](sys.version_info[0] >= 3, 'This test only apply on python3')
 def test_back_unicode_completion():
     ip = get_ipython()
     
@@ -173,7 +171,6 b' def test_back_unicode_completion():'
     nt.assert_equal(matches[0], '\\ROMAN NUMERAL FIVE')
 
 
[e-mail](sys.version_info[0] >= 3, 'This test only apply on python3')
 def test_forward_unicode_completion():
     ip = get_ipython()
     
@@ -181,7 +178,6 b' def test_forward_unicode_completion():'
     nt.assert_equal(len(matches), 1)
     nt.assert_equal(matches[0], 'Ⅴ')
 
[e-mail](sys.version_info[0] >= 3, 'This test only apply on python3')
 @dec.knownfailureif(sys.platform == 'win32', 'Fails if there is a C:\\j... path')
 def test_no_ascii_back_completion():
     ip = get_ipython()
@@ -588,7 +584,6 b' def test_dict_key_completion_contexts():'
 
 
 
[e-mail](sys.version_info[0] >= 3, 'This test only applies in Py>=3')
 def test_dict_key_completion_bytes():
     """Test handling of bytes in dict key completion"""
     ip = get_ipython()
@@ -618,68 +613,6 b' def test_dict_key_completion_bytes():'
         nt.assert_not_in("abd", matches)
 
 
[e-mail](sys.version_info[0] < 3, 'This test only applies in Py<3')
-def test_dict_key_completion_unicode_py2():
-    """Test handling of unicode in dict key completion"""
-    ip = get_ipython()
-    complete = ip.Completer.complete
-
-    ip.user_ns['d'] = {u'abc': None,
-                       u'a\u05d0b': None}
-
-    _, matches = complete(line_buffer="d[")
-    nt.assert_in("u'abc'", matches)
-    nt.assert_in("u'a\\u05d0b'", matches)
-
-    _, matches = complete(line_buffer="d['a")
-    nt.assert_in("abc", matches)
-    nt.assert_not_in("a\\u05d0b", matches)
-
-    _, matches = complete(line_buffer="d[u'a")
-    nt.assert_in("abc", matches)
-    nt.assert_in("a\\u05d0b", matches)
-
-    _, matches = complete(line_buffer="d[U'a")
-    nt.assert_in("abc", matches)
-    nt.assert_in("a\\u05d0b", matches)
-
-    # query using escape
-    if sys.platform != 'win32':
-        # Known failure on Windows
-        _, matches = complete(line_buffer=u"d[u'a\\u05d0")
-        nt.assert_in("u05d0b", matches)  # tokenized after \\
-
-    # query using character
-    _, matches = complete(line_buffer=u"d[u'a\u05d0")
-    nt.assert_in(u"a\u05d0b", matches)
-    
-    with greedy_completion():
-        _, matches = complete(line_buffer="d[")
-        nt.assert_in("d[u'abc']", matches)
-        nt.assert_in("d[u'a\\u05d0b']", matches)
-
-        _, matches = complete(line_buffer="d['a")
-        nt.assert_in("d['abc']", matches)
-        nt.assert_not_in("d[u'a\\u05d0b']", matches)
-
-        _, matches = complete(line_buffer="d[u'a")
-        nt.assert_in("d[u'abc']", matches)
-        nt.assert_in("d[u'a\\u05d0b']", matches)
-
-        _, matches = complete(line_buffer="d[U'a")
-        nt.assert_in("d[U'abc']", matches)
-        nt.assert_in("d[U'a\\u05d0b']", matches)
-
-        # query using escape
-        _, matches = complete(line_buffer=u"d[u'a\\u05d0")
-        nt.assert_in("d[u'a\\u05d0b']", matches)  # tokenized after \\
-
-        # query using character
-        _, matches = complete(line_buffer=u"d[u'a\u05d0")
-        nt.assert_in(u"d[u'a\u05d0b']", matches)
-
-
[e-mail](sys.version_info[0] >= 3, 'This test only applies in Py>=3')
 def test_dict_key_completion_unicode_py3():
     """Test handling of unicode in dict key completion"""
     ip = get_ipython()

IPython/core/tests/test_completerlib.py

@@ -2,7 +2,6 b''
 """Tests for completerlib.
 
 """
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 # Imports

IPython/core/tests/test_debugger.py

@@ -1,6 +1,5 b''
 """Tests for debugging machinery.
 """
-from __future__ import print_function
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.

IPython/core/tests/test_hooks.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Tests for CommandChainDispatcher."""
 
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 # Imports

IPython/core/tests/test_inputsplitter.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Tests for the inputsplitter module."""
 
-from __future__ import print_function
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.

IPython/core/tests/test_interactiveshell.py

@@ -143,26 +143,14 b' class InteractiveShellTestCase(unittest.TestCase):'
 
     def test_future_flags(self):
         """Check that future flags are used for parsing code (gh-777)"""
-        ip.run_cell('from __future__ import print_function')
+        ip.run_cell('from __future__ import barry_as_FLUFL')
         try:
-            ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
+            ip.run_cell('prfunc_return_val = 1 <> 2')
             assert 'prfunc_return_val' in ip.user_ns
         finally:
             # Reset compiler flags so we don't mess up other tests.
             ip.compile.reset_compiler_flags()
 
-    def test_future_unicode(self):
-        """Check that unicode_literals is imported from __future__ (gh #786)"""
-        try:
-            ip.run_cell(u'byte_str = "a"')
-            assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
-            ip.run_cell('from __future__ import unicode_literals')
-            ip.run_cell(u'unicode_str = "a"')
-            assert isinstance(ip.user_ns['unicode_str'], unicode_type) # strings literals are now unicode
-        finally:
-            # Reset compiler flags so we don't mess up other tests.
-            ip.compile.reset_compiler_flags()
-    
     def test_can_pickle(self):
         "Can we pickle objects defined interactively (GH-29)"
         ip = get_ipython()
@@ -338,19 +326,6 b' class InteractiveShellTestCase(unittest.TestCase):'
         finally:
             trap.hook = save_hook
 
-    @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
-    def test_print_softspace(self):
-        """Verify that softspace is handled correctly when executing multiple
-        statements.
-
-        In [1]: print 1; print 2
-        1
-        2
-
-        In [2]: print 1,; print 2
-        1 2
-        """
-        
     def test_ofind_line_magic(self):
         from IPython.core.magic import register_line_magic
         
@@ -466,22 +441,6 b' class InteractiveShellTestCase(unittest.TestCase):'
             # Reset the custom exception hook
             ip.set_custom_exc((), None)
     
-    @skipif(sys.version_info[0] >= 3, "no differences with __future__ in py3")
-    def test_future_environment(self):
-        "Can we run code with & without the shell's __future__ imports?"
-        ip.run_cell("from __future__ import division")
-        ip.run_cell("a = 1/2", shell_futures=True)
-        self.assertEqual(ip.user_ns['a'], 0.5)
-        ip.run_cell("b = 1/2", shell_futures=False)
-        self.assertEqual(ip.user_ns['b'], 0)
-        
-        ip.compile.reset_compiler_flags()
-        # This shouldn't leak to the shell's compiler
-        ip.run_cell("from __future__ import division \nc=1/2", shell_futures=False)
-        self.assertEqual(ip.user_ns['c'], 0.5)
-        ip.run_cell("d = 1/2", shell_futures=True)
-        self.assertEqual(ip.user_ns['d'], 0)
-
     def test_mktempfile(self):
         filename = ip.mktempfile()
         # Check that we can open the file again on Windows
@@ -509,9 +468,6 b' class InteractiveShellTestCase(unittest.TestCase):'
             raise DerivedInterrupt("foo")
         except KeyboardInterrupt:
             msg = ip.get_exception_only()
-        if sys.version_info[0] <= 2:
-            self.assertEqual(msg, 'DerivedInterrupt: foo\n')
-        else:
             self.assertEqual(msg, 'IPython.core.tests.test_interactiveshell.DerivedInterrupt: foo\n')
 
     def test_inspect_text(self):

IPython/core/tests/test_magic.py

@@ -3,7 +3,6 b''
 
 Needs to be run by nose (to make ipython session available).
 """
-from __future__ import absolute_import
 
 import io
 import os
@@ -377,18 +376,6 b' def test_time3():'
                     "run = 0\n"
                     "run += 1")
 
[e-mail](sys.version_info[0] >= 3, "no differences with __future__ in py3")
-def test_time_futures():
-    "Test %time with __future__ environments"
-    ip = get_ipython()
-    ip.autocall = 0
-    ip.run_cell("from __future__ import division")
-    with tt.AssertPrints('0.25'):
-        ip.run_line_magic('time', 'print(1/4)')
-    ip.compile.reset_compiler_flags()
-    with tt.AssertNotPrints('0.25'):
-        ip.run_line_magic('time', 'print(1/4)')
-
 def test_doctest_mode():
     "Toggle doctest_mode twice, it should be a no-op and run without error"
     _ip.magic('doctest_mode')
@@ -573,17 +560,6 b' def test_timeit_return_quiet():'
         res = _ip.run_line_magic('timeit', '-n1 -r1 -q -o 1')
     assert (res is not None)
 
[e-mail](sys.version_info[0] >= 3, "no differences with __future__ in py3")
-def test_timeit_futures():
-    "Test %timeit with __future__ environments"
-    ip = get_ipython()
-    ip.run_cell("from __future__ import division")
-    with tt.AssertPrints('0.25'):
-        ip.run_line_magic('timeit', '-n1 -r1 print(1/4)')
-    ip.compile.reset_compiler_flags()
-    with tt.AssertNotPrints('0.25'):
-        ip.run_line_magic('timeit', '-n1 -r1 print(1/4)')
-
 @dec.skipif(execution.profile is None)
 def test_prun_special_syntax():
     "Test %%prun with IPython special syntax"

IPython/core/tests/test_magic_terminal.py

@@ -2,7 +2,6 b''
 
 Needs to be run by nose (to make ipython session available).
 """
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 # Imports
@@ -57,8 +56,6 b' def check_cpaste(code, should_fail=False):'
     finally:
         sys.stdin = stdin_save
 
-PY31 = sys.version_info[:2] == (3,1)
-
 def test_cpaste():
     """Test cpaste magic"""
 
@@ -77,14 +74,9 b' def test_cpaste():'
                       ],
 
              'fail': ["1 + runf()",
+                      "++ runf()",
              ]}
     
-    # I don't know why this is failing specifically on Python 3.1. I've
-    # checked it manually interactively, but we don't care enough about 3.1
-    # to spend time fiddling with the tests, so we just skip it.
-    if not PY31:
-        tests['fail'].append("++ runf()")
-
     ip.user_ns['runf'] = runf
 
     for code in tests['pass']:

IPython/core/tests/test_oinspect.py

@@ -4,7 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import os
 import re
@@ -40,7 +39,7 b' ip = get_ipython()'
 # defined, if any code is inserted above, the following line will need to be
 # updated.  Do NOT insert any whitespace between the next line and the function
 # definition below.
-THIS_LINE_NUMBER = 43  # Put here the actual number of this line
+THIS_LINE_NUMBER = 42  # Put here the actual number of this line
 
 from unittest import TestCase
 
@@ -275,7 +274,6 b' def test_info():'
     nt.assert_equal(i['type_name'], 'type')
     expted_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
     nt.assert_equal(i['base_class'], expted_class)
-    if sys.version_info > (3,):
         nt.assert_regex(i['string_form'], "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>")
     fname = __file__
     if fname.endswith(".pyc"):

IPython/core/tests/test_profile.py

@@ -15,7 +15,6 b' Authors'
 * MinRK
 
 """
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 # Imports

IPython/core/tests/test_pylabtools.py

@@ -4,7 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 from io import UnsupportedOperation, BytesIO
 

IPython/core/tests/test_run.py

@@ -11,7 +11,6 b' and we do so in a common test_magic file.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import absolute_import
 
 
 import functools

IPython/core/tests/test_ultratb.py

@@ -313,7 +313,6 b' def r3o2():'
 #----------------------------------------------------------------------------
 
 # module testing (minimal)
-if sys.version_info > (3,):
     def test_handlers():
         def spam(c, d_e):
             (d, e) = d_e

IPython/core/ultratb.py

@@ -88,9 +88,6 b' Inheritance diagram:'
 # the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from __future__ import print_function
 
 import dis
 import inspect

IPython/extensions/autoreload.py

@@ -87,7 +87,6 b' Some of the known remaining caveats are:'
 
 - C extension modules cannot be reloaded, and so cannot be autoreloaded.
 """
-from __future__ import print_function
 
 skip_doctest = True
 

IPython/extensions/storemagic.py

@@ -9,7 +9,6 b' To automatically restore stored variables at startup, add this to your'
 
   c.StoreMagics.autorestore = True
 """
-from __future__ import print_function
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.

IPython/lib/backgroundjobs.py

@@ -21,7 +21,6 b' separate implementation).'
 An example notebook is provided in our documentation illustrating interactive
 use of the system.
 """
-from __future__ import print_function
 
 #*****************************************************************************
 #       Copyright (C) 2005-2006 Fernando Perez <[e-mail]>

IPython/lib/deepreload.py

@@ -25,7 +25,6 b' A reference to the original :func:`python:reload` is stored in this module as'
 This code is almost entirely based on knee.py, which is a Python
 re-implementation of hierarchical module import.
 """
-from __future__ import print_function
 #*****************************************************************************
 #       Copyright (C) 2001 Nathaniel Gray <[e-mail]>
 #

IPython/lib/demo.py

@@ -170,7 +170,6 b' The following is a very simple example of a valid demo file.'
     ################### END EXAMPLE DEMO <ex_demo.py> ############################
 """
 
-from __future__ import unicode_literals
 
 #*****************************************************************************
 #     Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
@@ -179,7 +178,6 b' from __future__ import unicode_literals'
 #  the file COPYING, distributed as part of this software.
 #
 #*****************************************************************************
-from __future__ import print_function
 
 import os
 import re

IPython/lib/editorhooks.py

@@ -4,7 +4,6 b' They should honor the line number argument, at least.'
 
 Contributions are *very* welcome.
 """
-from __future__ import print_function
 
 import os
 import pipes

IPython/lib/inputhookglut.py

@@ -2,7 +2,6 b''
 """
 GLUT Inputhook support functions
 """
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team

IPython/lib/pretty.py

@@ -77,7 +77,6 b' Inheritance diagram:'
             Portions (c) 2009 by Robert Kern.
 :license: BSD License.
 """
-from __future__ import print_function
 from contextlib import contextmanager
 import sys
 import types

IPython/lib/tests/test_backgroundjobs.py

@@ -11,7 +11,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
 import time

IPython/lib/tests/test_display.py

@@ -12,7 +12,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 from tempfile import NamedTemporaryFile, mkdtemp
 from os.path import split, join as pjoin, dirname
 

IPython/lib/tests/test_pretty.py

@@ -4,7 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 from collections import Counter, defaultdict, deque, OrderedDict
 import types, string
@@ -12,14 +11,9 b' import types, string'
 import nose.tools as nt
 
 from IPython.lib import pretty
-from IPython.testing.decorators import (skip_without, py2_only, py3_only)
+from IPython.testing.decorators import skip_without
                                         
-from IPython.utils.py3compat import PY3, unicode_to_str
-
-if PY3:
     from io import StringIO
-else:
-    from StringIO import StringIO
 
 
 class MyList(object):
@@ -245,7 +239,7 b' def test_metaclass_repr():'
 
 def test_unicode_repr():
     u = u"üniçodé"
-    ustr = unicode_to_str(u)
+    ustr = u
     
     class C(object):
         def __repr__(self):
@@ -276,83 +270,6 b' def test_basic_class():'
     nt.assert_true(type_pprint_wrapper.called)
 
 
-# This is only run on Python 2 because in Python 3 the language prevents you
-# from setting a non-unicode value for __qualname__ on a metaclass, and it
-# doesn't respect the descriptor protocol if you subclass unicode and implement
-# __get__.
-@py2_only
-def test_fallback_to__name__on_type():
-    # Test that we correctly repr types that have non-string values for
-    # __qualname__ by falling back to __name__
-
-    class Type(object):
-        __qualname__ = 5
-
-    # Test repring of the type.
-    stream = StringIO()
-    printer = pretty.RepresentationPrinter(stream)
-
-    printer.pretty(Type)
-    printer.flush()
-    output = stream.getvalue()
-
-    # If __qualname__ is malformed, we should fall back to __name__.
-    expected = '.'.join([__name__, Type.__name__])
-    nt.assert_equal(output, expected)
-
-    # Clear stream buffer.
-    stream.buf = ''
-
-    # Test repring of an instance of the type.
-    instance = Type()
-    printer.pretty(instance)
-    printer.flush()
-    output = stream.getvalue()
-
-    # Should look like:
-    # <IPython.lib.tests.test_pretty.Type at 0x7f7658ae07d0>
-    prefix = '<' + '.'.join([__name__, Type.__name__]) + ' at 0x'
-    nt.assert_true(output.startswith(prefix))
-
-
-@py2_only
-def test_fail_gracefully_on_bogus__qualname__and__name__():
-    # Test that we correctly repr types that have non-string values for both
-    # __qualname__ and __name__
-
-    class Meta(type):
-        __name__ = 5
-
-    class Type(object):
-        __metaclass__ = Meta
-        __qualname__ = 5
-
-    stream = StringIO()
-    printer = pretty.RepresentationPrinter(stream)
-
-    printer.pretty(Type)
-    printer.flush()
-    output = stream.getvalue()
-
-    # If we can't find __name__ or __qualname__ just use a sentinel string.
-    expected = '.'.join([__name__, '<unknown type>'])
-    nt.assert_equal(output, expected)
-
-    # Clear stream buffer.
-    stream.buf = ''
-
-    # Test repring of an instance of the type.
-    instance = Type()
-    printer.pretty(instance)
-    printer.flush()
-    output = stream.getvalue()
-
-    # Should look like:
-    # <IPython.lib.tests.test_pretty.<unknown type> at 0x7f7658ae07d0>
-    prefix = '<' + '.'.join([__name__, '<unknown type>']) + ' at 0x'
-    nt.assert_true(output.startswith(prefix))
-
-
 def test_collections_defaultdict():
     # Create defaultdicts with cycles
     a = defaultdict()
@@ -441,7 +358,6 b' def test_collections_counter():'
     for obj, expected in cases:
         nt.assert_equal(pretty.pretty(obj), expected)
 
-@py3_only
 def test_mappingproxy():
     MP = types.MappingProxyType
     underlying_dict = {}

IPython/sphinxext/ipython_directive.py

@@ -119,7 +119,6 b' Authors'
 - VáclavŠmilauer <eudoxos-AT-arcig.cz>: Prompt generalizations.
 - Skipper Seabold, refactoring, cleanups, pure python addition
 """
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 # Imports

IPython/terminal/embed.py

@@ -5,8 +5,6 b' An embedded IPython shell.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import with_statement
-from __future__ import print_function
 
 import sys
 import warnings

IPython/terminal/interactiveshell.py

@@ -1,5 +1,4 b''
 """IPython terminal interface using prompt_toolkit"""
-from __future__ import print_function
 
 import os
 import sys

IPython/terminal/ipapp.py

@@ -8,8 +8,6 b' line :command:`ipython` program.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import absolute_import
-from __future__ import print_function
 
 import logging
 import os

IPython/terminal/magics.py

@@ -3,7 +3,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 from logging import error
 import os

IPython/terminal/prompts.py

@@ -1,5 +1,4 b''
 """Terminal input and output prompts."""
-from __future__ import print_function
 
 from pygments.token import Token
 import sys

IPython/terminal/pt_inputhooks/glut.py

@@ -1,6 +1,5 b''
 """GLUT Input hook for interactive use with prompt_toolkit
 """
-from __future__ import print_function
 
 
 # GLUT is quite an old library and it is difficult to ensure proper

IPython/terminal/pt_inputhooks/gtk.py

@@ -35,7 +35,6 b' PyGTK input hook for prompt_toolkit.'
 Listens on the pipe prompt_toolkit sets up for a notification that it should
 return control to the terminal event loop.
 """
-from __future__ import absolute_import
 
 import gtk, gobject
 

IPython/terminal/pt_inputhooks/pyglet.py

@@ -1,6 +1,5 b''
 """Enable pyglet to be used interacively with prompt_toolkit
 """
-from __future__ import absolute_import
 
 import os
 import sys

IPython/terminal/pt_inputhooks/wx.py

@@ -1,6 +1,5 b''
 """Enable wxPython to be used interacively in prompt_toolkit
 """
-from __future__ import absolute_import
 
 import sys
 import signal

IPython/terminal/tests/test_embed.py

@@ -24,7 +24,6 b' from IPython.testing.decorators import skip_win32'
 
 
 _sample_embed = b"""
-from __future__ import print_function
 import IPython
 
 a = 3
@@ -74,8 +73,6 b' def test_nest_embed():'
     child = pexpect.spawn(sys.executable, ['-m', 'IPython', '--colors=nocolor'],
                           env=env)
     child.expect(ipy_prompt)
-    child.sendline("from __future__ import print_function")
-    child.expect(ipy_prompt)
     child.sendline("import IPython")
     child.expect(ipy_prompt)
     child.sendline("ip0 = get_ipython()")

IPython/testing/decorators.py

@@ -334,12 +334,6 b" skipif_not_sympy = skip_without('sympy')"
 
 skip_known_failure = knownfailureif(True,'This test is known to fail')
 
-known_failure_py3 = knownfailureif(sys.version_info[0] >= 3, 
-                                    'This test is known to fail on Python 3.')
-
-py2_only = skipif(PY3, "This test only runs on Python 2.")
-py3_only = skipif(PY2, "This test only runs on Python 3.")
-
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions
 null_deco = lambda f: f

IPython/testing/globalipapp.py

@@ -5,8 +5,6 b" modifications IPython makes to system behavior don't send the doctest machinery"
 into a fit.  This code should be considered a gross hack, but it gets the job
 done.
 """
-from __future__ import absolute_import
-from __future__ import print_function
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.

IPython/testing/iptest.py

@@ -17,7 +17,6 b' itself from the command line. There are two ways of running this script:'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import glob
 from io import BytesIO
@@ -45,7 +44,6 b' pjoin = path.join'
 
 # Enable printing all warnings raise by IPython's modules
 warnings.filterwarnings('ignore', message='.*Matplotlib is building the font cache.*', category=UserWarning, module='.*')
-if sys.version_info > (3,0):
     warnings.filterwarnings('error', message='.*', category=ResourceWarning, module='.*')
 warnings.filterwarnings('error', message=".*{'config': True}.*", category=DeprecationWarning, module='IPy.*')
 warnings.filterwarnings('default', message='.*', category=Warning, module='IPy.*')

IPython/testing/iptestcontroller.py

@@ -9,7 +9,6 b' test suite.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import argparse
 import json

IPython/testing/ipunittest.py

@@ -22,7 +22,6 b' Authors'
 - Fernando Perez <[e-mail]>
 """
 
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  The IPython Development Team

IPython/testing/plugin/dtexample.py

@@ -3,7 +3,6 b''
 This file just contains doctests both using plain python and IPython prompts.
 All tests should be loaded by nose.
 """
-from __future__ import print_function
 
 def pyfunc():
     """Some pure python tests...

IPython/testing/plugin/iptest.py

@@ -1,7 +1,6 b''
 #!/usr/bin/env python
 """Nose-based test runner.
 """
-from __future__ import print_function
 
 from nose.core import main
 from nose.plugins.builtin import plugins

IPython/testing/plugin/show_refs.py

@@ -2,7 +2,6 b''
 
 This is used by a companion test case.
 """
-from __future__ import print_function
 
 import gc
 

IPython/testing/plugin/simple.py

@@ -3,7 +3,6 b''
 This file just contains doctests both using plain python and IPython prompts.
 All tests should be loaded by nose.
 """
-from __future__ import print_function
 
 def pyfunc():
     """Some pure python tests...

IPython/testing/plugin/simplevars.py

@@ -1,3 +1,2 b''
-from __future__ import print_function
 x = 1
 print('x is:',x)

IPython/testing/skipdoctest.py

@@ -1,26 +1,13 b''
-"""Decorators marks that a doctest should be skipped, for both python 2 and 3.
+"""Decorators marks that a doctest should be skipped.
 
 The IPython.testing.decorators module triggers various extra imports, including
 numpy and sympy if they're present. Since this decorator is used in core parts
 of IPython, it's in a separate module so that running IPython doesn't trigger
 those imports."""
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (C) IPython Development Team
+# Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-
-#-----------------------------------------------------------------------------
-# Decorators
-#-----------------------------------------------------------------------------
 
 def skip_doctest(f):
     """Decorator - mark a function or method for skipping its doctest.
@@ -30,14 +17,3 b' def skip_doctest(f):'
     etc."""
     f.skip_doctest = True
     return f
-
-
-def skip_doctest_py3(f):
-    """Decorator - skip the doctest under Python 3."""
-    f.skip_doctest = (sys.version_info[0] >= 3)
-    return f
-
-def skip_doctest_py2(f):
-    """Decorator - skip the doctest under Python 3."""
-    f.skip_doctest = (sys.version_info[0] < 3)
-    return f

IPython/testing/tests/test_decorators.py

@@ -1,6 +1,5 b''
 """Tests for the decorators we've created for IPython.
 """
-from __future__ import print_function
 
 # Module imports
 # Std lib

IPython/testing/tests/test_tools.py

@@ -13,8 +13,6 b' Tests for testing.tools'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import with_statement
-from __future__ import print_function
 
 import os
 import unittest
@@ -110,8 +108,7 b' class Test_ipexec_validate(unittest.TestCase, tt.TempFileMixin):'
     def test_exception_path(self):
         """Test exception path in exception_validate.
         """
-        self.mktmp("from __future__ import print_function\n"
-                   "import sys\n"
+        self.mktmp("import sys\n"
                    "print('A')\n"
                    "print('B')\n"
                    "print('C', file=sys.stderr)\n"
@@ -123,8 +120,7 b' class Test_ipexec_validate(unittest.TestCase, tt.TempFileMixin):'
     def test_exception_path2(self):
         """Test exception path in exception_validate, expecting windows line endings.
         """
-        self.mktmp("from __future__ import print_function\n"
-                   "import sys\n"
+        self.mktmp("import sys\n"
                    "print('A')\n"
                    "print('B')\n"
                    "print('C', file=sys.stderr)\n"

IPython/testing/tools.py

@@ -5,7 +5,6 b' Authors'
 - Fernando Perez <[e-mail]>
 """
 
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009 The IPython Development Team

IPython/utils/PyColorize.py

@@ -28,9 +28,6 b' It shows how to use the built-in keyword, token and tokenize modules to'
 scan Python source code and re-emit it with no changes to its original
 formatting (which is the hard part).
 """
-from __future__ import print_function
-from __future__ import absolute_import
-from __future__ import unicode_literals
 
 __all__ = ['ANSICodeColors','Parser']
 

IPython/utils/_process_posix.py

@@ -13,7 +13,6 b' This file is only meant to be imported by process.py, not by end-users.'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib
 import errno

IPython/utils/_process_win32.py

@@ -13,7 +13,6 b' This file is only meant to be imported by process.py, not by end-users.'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # stdlib
 import os

IPython/utils/_process_win32_controller.py

@@ -10,7 +10,6 b' This file is meant to be used by process.py'
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-from __future__ import print_function
 
 # stdlib
 import os, sys, threading

IPython/utils/_signatures.py

@@ -16,7 +16,6 b' modified to be compatible with Python 2.7 and 3.2+.'
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-from __future__ import absolute_import, division, print_function
 import itertools
 import functools
 import re

IPython/utils/capture.py

@@ -4,7 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function, absolute_import
 
 import sys
 

IPython/utils/colorable.py

@@ -4,7 +4,6 b''
 # Distributed under the terms of the BSD License.  The full license is in
 # the file COPYING, distributed as part of this software.
 #*****************************************************************************
-from __future__ import absolute_import
 
 """
 Color managing related utilities

IPython/utils/eventful.py

@@ -1,4 +1,3 b''
-from __future__ import absolute_import
 
 from warnings import warn
 

IPython/utils/frame.py

@@ -2,7 +2,6 b''
 """
 Utilities for working with stack frames.
 """
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team

IPython/utils/io.py

@@ -6,8 +6,6 b' IO related utilities.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
-from __future__ import absolute_import
 
 
 import atexit

IPython/utils/log.py

@@ -1,4 +1,3 b''
-from __future__ import absolute_import
 
 from warnings import warn
 

IPython/utils/module_paths.py

@@ -23,7 +23,6 b' path to module and not an open file object as well.'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
 import imp

IPython/utils/openpy.py

@@ -4,7 +4,6 b' as per PEP 263.'
 
 Much of the code is taken from the tokenize module in Python 3.2.
 """
-from __future__ import absolute_import
 
 import io
 from io import TextIOWrapper, BytesIO

IPython/utils/process.py

@@ -6,7 +6,6 b' Utilities for working with external processes.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import os
 import sys

IPython/utils/tempdir.py

@@ -2,7 +2,6 b''
 
 This is copied from the stdlib and will be standard in Python 3.2 and onwards.
 """
-from __future__ import print_function
 
 import os as _os
 import warnings as _warnings

IPython/utils/tests/test_capture.py

@@ -12,7 +12,6 b''
 # Imports
 #-----------------------------------------------------------------------------
 
-from __future__ import print_function
 
 import sys
 

IPython/utils/tests/test_io.py

@@ -4,8 +4,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
-from __future__ import absolute_import
 
 import io as stdlib_io
 import os.path

IPython/utils/tests/test_module_paths.py

@@ -12,7 +12,6 b''
 # Imports
 #-----------------------------------------------------------------------------
 
-from __future__ import with_statement
 
 import os
 import shutil

IPython/utils/tests/test_process.py

@@ -93,8 +93,7 b' def test_arg_split_win32():'
 class SubProcessTestCase(TestCase, tt.TempFileMixin):
     def setUp(self):
         """Make a valid python temp file."""
-        lines = ["from __future__ import print_function",
-                 "import sys",
+        lines = [ "import sys",
                  "print('on stdout', end='', file=sys.stdout)",
                  "print('on stderr', end='', file=sys.stderr)",
                  "sys.stdout.flush()",

IPython/utils/tests/test_text.py

@@ -1,6 +1,5 b''
 # encoding: utf-8
 """Tests for IPython.utils.text"""
-from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team

IPython/utils/text.py

@@ -7,7 +7,6 b' Inheritance diagram:'
 .. inheritance-diagram:: IPython.utils.text
    :parts: 3
 """
-from __future__ import absolute_import
 
 import os
 import re
@@ -20,7 +19,6 b' except ImportError:'
     # Python 2 backport
     from pathlib2 import Path
 
-from IPython.testing.skipdoctest import skip_doctest_py3, skip_doctest
 from IPython.utils import py3compat
 
 # datetime.strftime date format for ipython
@@ -517,7 +515,6 b' class EvalFormatter(Formatter):'
 # inside [], so EvalFormatter can handle slicing. Once we only support 3.4 and
 # above, it should be possible to remove FullEvalFormatter.
 
-@skip_doctest_py3
 class FullEvalFormatter(Formatter):
     """A String Formatter that allows evaluation of simple expressions.
     
@@ -533,13 +530,13 b' class FullEvalFormatter(Formatter):'
 
         In [1]: f = FullEvalFormatter()
         In [2]: f.format('{n//4}', n=8)
-        Out[2]: u'2'
+        Out[2]: '2'
 
         In [3]: f.format('{list(range(5))[2:4]}')
-        Out[3]: u'[2, 3]'
+        Out[3]: '[2, 3]'
 
         In [4]: f.format('{3*2}')
-        Out[4]: u'6'
+        Out[4]: '6'
     """
     # copied from Formatter._vformat with minor changes to allow eval
     # and replace the format_spec code with slicing
@@ -574,7 +571,6 b' class FullEvalFormatter(Formatter):'
         return u''.join(py3compat.cast_unicode(s) for s in result)
 
 
-@skip_doctest_py3
 class DollarFormatter(FullEvalFormatter):
     """Formatter allowing Itpl style $foo replacement, for names and attribute
     access only. Standard {foo} replacement also works, and allows full
@@ -586,13 +582,13 b' class DollarFormatter(FullEvalFormatter):'
 
         In [1]: f = DollarFormatter()
         In [2]: f.format('{n//4}', n=8)
-        Out[2]: u'2'
+        Out[2]: '2'
 
         In [3]: f.format('23 * 76 is $result', result=23*76)
-        Out[3]: u'23 * 76 is 1748'
+        Out[3]: '23 * 76 is 1748'
 
         In [4]: f.format('$a or {b}', a=1, b=2)
-        Out[4]: u'1 or 2'
+        Out[4]: '1 or 2'
     """
     _dollar_pattern = re.compile("(.*?)\$(\$?[\w\.]+)")
     def parse(self, fmt_string):

IPython/utils/tokenize2.py

@@ -1,9 +1,594 b''
-"""Load our patched versions of tokenize.
+"""Patched version of standard library tokenize, to deal with various bugs.
+
+Based on Python 3.2 code.
+
+Patches:
+
+- Gareth Rees' patch for Python issue #12691 (untokenizing)
+  - Except we don't encode the output of untokenize
+  - Python 2 compatible syntax, so that it can be byte-compiled at installation
+- Newlines in comments and blank lines should be either NL or NEWLINE, depending
+  on whether they are in a multi-line statement. Filed as Python issue #17061.
+- Export generate_tokens & TokenError
+- u and rb literals are allowed under Python 3.3 and above.
+
+------------------------------------------------------------------------------
+Tokenization help for Python programs.
+
+tokenize(readline) is a generator that breaks a stream of bytes into
+Python tokens.  It decodes the bytes according to PEP-0263 for
+determining source file encoding.
+
+It accepts a readline-like method which is called repeatedly to get the
+next line of input (or b"" for EOF).  It generates 5-tuples with these
+members:
+
+    the token type (see token.py)
+    the token (a string)
+    the starting (row, column) indices of the token (a 2-tuple of ints)
+    the ending (row, column) indices of the token (a 2-tuple of ints)
+    the original line (string)
+
+It is designed to match the working of the Python tokenizer exactly, except
+that it produces COMMENT tokens for comments and gives type OP for all
+operators.  Additionally, all token lists start with an ENCODING token
+which tells you which encoding was used to decode the bytes stream.
 """
 
+__author__ = 'Ka-Ping Yee <[e-mail]>'
+__credits__ = ('GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, '
+               'Skip Montanaro, Raymond Hettinger, Trent Nelson, '
+               'Michael Foord')
+import builtins
+import re
 import sys
+from token import *
+from codecs import lookup, BOM_UTF8
+import collections
+from io import TextIOWrapper
+cookie_re = re.compile("coding[:=]\s*([-\w.]+)")
+
+import token
+__all__ = token.__all__ + ["COMMENT", "tokenize", "detect_encoding",
+                           "NL", "untokenize", "ENCODING", "TokenInfo"]
+del token
+
+__all__ += ["generate_tokens", "TokenError"]
+
+COMMENT = N_TOKENS
+tok_name[COMMENT] = 'COMMENT'
+NL = N_TOKENS + 1
+tok_name[NL] = 'NL'
+ENCODING = N_TOKENS + 2
+tok_name[ENCODING] = 'ENCODING'
+N_TOKENS += 3
+
+class TokenInfo(collections.namedtuple('TokenInfo', 'type string start end line')):
+    def __repr__(self):
+        annotated_type = '%d (%s)' % (self.type, tok_name[self.type])
+        return ('TokenInfo(type=%s, string=%r, start=%r, end=%r, line=%r)' %
+                self._replace(type=annotated_type))
+
+def group(*choices): return '(' + '|'.join(choices) + ')'
+def any(*choices): return group(*choices) + '*'
+def maybe(*choices): return group(*choices) + '?'
+
+# Note: we use unicode matching for names ("\w") but ascii matching for
+# number literals.
+Whitespace = r'[ \f\t]*'
+Comment = r'#[^\r\n]*'
+Ignore = Whitespace + any(r'\\\r?\n' + Whitespace) + maybe(Comment)
+Name = r'\w+'
+
+Hexnumber = r'0[xX][0-9a-fA-F]+'
+Binnumber = r'0[bB][01]+'
+Octnumber = r'0[oO][0-7]+'
+Decnumber = r'(?:0+|[1-9][0-9]*)'
+Intnumber = group(Hexnumber, Binnumber, Octnumber, Decnumber)
+Exponent = r'[eE][-+]?[0-9]+'
+Pointfloat = group(r'[0-9]+\.[0-9]*', r'\.[0-9]+') + maybe(Exponent)
+Expfloat = r'[0-9]+' + Exponent
+Floatnumber = group(Pointfloat, Expfloat)
+Imagnumber = group(r'[0-9]+[jJ]', Floatnumber + r'[jJ]')
+Number = group(Imagnumber, Floatnumber, Intnumber)
+
+if sys.version_info.minor >= 3:
+    StringPrefix = r'(?:[bB][rR]?|[rR][bB]?|[uU])?'
+else:
+    StringPrefix = r'(?:[bB]?[rR]?)?'
+
+# Tail end of ' string.
+Single = r"[^'\\]*(?:\\.[^'\\]*)*'"
+# Tail end of " string.
+Double = r'[^"\\]*(?:\\.[^"\\]*)*"'
+# Tail end of ''' string.
+Single3 = r"[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''"
+# Tail end of """ string.
+Double3 = r'[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""'
+Triple = group(StringPrefix + "'''", StringPrefix + '"""')
+# Single-line ' or " string.
+String = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*'",
+               StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*"')
+
+# Because of leftmost-then-longest match semantics, be sure to put the
+# longest operators first (e.g., if = came before ==, == would get
+# recognized as two instances of =).
+Operator = group(r"\*\*=?", r">>=?", r"<<=?", r"!=",
+                 r"//=?", r"->",
+                 r"[+\-*/%&|^=<>]=?",
+                 r"~")
+
+Bracket = '[][(){}]'
+Special = group(r'\r?\n', r'\.\.\.', r'[:;.,@]')
+Funny = group(Operator, Bracket, Special)
+
+PlainToken = group(Number, Funny, String, Name)
+Token = Ignore + PlainToken
+
+# First (or only) line of ' or " string.
+ContStr = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*" +
+                group("'", r'\\\r?\n'),
+                StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*' +
+                group('"', r'\\\r?\n'))
+PseudoExtras = group(r'\\\r?\n', Comment, Triple)
+PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name)
+
+def _compile(expr):
+    return re.compile(expr, re.UNICODE)
+
+tokenprog, pseudoprog, single3prog, double3prog = map(
+    _compile, (Token, PseudoToken, Single3, Double3))
+endprogs = {"'": _compile(Single), '"': _compile(Double),
+            "'''": single3prog, '"""': double3prog,
+            "r'''": single3prog, 'r"""': double3prog,
+            "b'''": single3prog, 'b"""': double3prog,
+            "R'''": single3prog, 'R"""': double3prog,
+            "B'''": single3prog, 'B"""': double3prog,
+            "br'''": single3prog, 'br"""': double3prog,
+            "bR'''": single3prog, 'bR"""': double3prog,
+            "Br'''": single3prog, 'Br"""': double3prog,
+            "BR'''": single3prog, 'BR"""': double3prog,
+            'r': None, 'R': None, 'b': None, 'B': None}
+
+triple_quoted = {}
+for t in ("'''", '"""',
+          "r'''", 'r"""', "R'''", 'R"""',
+          "b'''", 'b"""', "B'''", 'B"""',
+          "br'''", 'br"""', "Br'''", 'Br"""',
+          "bR'''", 'bR"""', "BR'''", 'BR"""'):
+    triple_quoted[t] = t
+single_quoted = {}
+for t in ("'", '"',
+          "r'", 'r"', "R'", 'R"',
+          "b'", 'b"', "B'", 'B"',
+          "br'", 'br"', "Br'", 'Br"',
+          "bR'", 'bR"', "BR'", 'BR"' ):
+    single_quoted[t] = t
+
+if sys.version_info.minor >= 3:
+    # Python 3.3
+    for _prefix in ['rb', 'rB', 'Rb', 'RB', 'u', 'U']:
+        _t2 = _prefix+'"""'
+        endprogs[_t2] = double3prog
+        triple_quoted[_t2] = _t2
+        _t1 = _prefix + "'''"
+        endprogs[_t1] = single3prog
+        triple_quoted[_t1] = _t1
+        single_quoted[_prefix+'"'] = _prefix+'"'
+        single_quoted[_prefix+"'"] = _prefix+"'"
+    del _prefix, _t2, _t1
+    endprogs['u'] = None
+    endprogs['U'] = None
+
+del _compile
+
+tabsize = 8
+
+class TokenError(Exception): pass
+
+class StopTokenizing(Exception): pass
+
+
+class Untokenizer:
+
+    def __init__(self):
+        self.tokens = []
+        self.prev_row = 1
+        self.prev_col = 0
+        self.encoding = 'utf-8'
+
+    def add_whitespace(self, tok_type, start):
+        row, col = start
+        assert row >= self.prev_row
+        col_offset = col - self.prev_col
+        if col_offset > 0:
+            self.tokens.append(" " * col_offset)
+        elif row > self.prev_row and tok_type not in (NEWLINE, NL, ENDMARKER):
+            # Line was backslash-continued.
+            self.tokens.append(" ")
+
+    def untokenize(self, tokens):
+        iterable = iter(tokens)
+        for t in iterable:
+            if len(t) == 2:
+                self.compat(t, iterable)
+                break
+            tok_type, token, start, end = t[:4]
+            if tok_type == ENCODING:
+                self.encoding = token
+                continue
+            self.add_whitespace(tok_type, start)
+            self.tokens.append(token)
+            self.prev_row, self.prev_col = end
+            if tok_type in (NEWLINE, NL):
+                self.prev_row += 1
+                self.prev_col = 0
+        return "".join(self.tokens)
+
+    def compat(self, token, iterable):
+        # This import is here to avoid problems when the itertools
+        # module is not built yet and tokenize is imported.
+        from itertools import chain
+        startline = False
+        prevstring = False
+        indents = []
+        toks_append = self.tokens.append
+
+        for tok in chain([token], iterable):
+            toknum, tokval = tok[:2]
+            if toknum == ENCODING:
+                self.encoding = tokval
+                continue
+
+            if toknum in (NAME, NUMBER):
+                tokval += ' '
+
+            # Insert a space between two consecutive strings
+            if toknum == STRING:
+                if prevstring:
+                    tokval = ' ' + tokval
+                prevstring = True
+            else:
+                prevstring = False
+
+            if toknum == INDENT:
+                indents.append(tokval)
+                continue
+            elif toknum == DEDENT:
+                indents.pop()
+                continue
+            elif toknum in (NEWLINE, NL):
+                startline = True
+            elif startline and indents:
+                toks_append(indents[-1])
+                startline = False
+            toks_append(tokval)
+
+
+def untokenize(tokens):
+    """
+    Convert ``tokens`` (an iterable) back into Python source code. Return
+    a bytes object, encoded using the encoding specified by the last
+    ENCODING token in ``tokens``, or UTF-8 if no ENCODING token is found.
+
+    The result is guaranteed to tokenize back to match the input so that
+    the conversion is lossless and round-trips are assured.  The
+    guarantee applies only to the token type and token string as the
+    spacing between tokens (column positions) may change.
+
+    :func:`untokenize` has two modes. If the input tokens are sequences
+    of length 2 (``type``, ``string``) then spaces are added as necessary to
+    preserve the round-trip property.
+
+    If the input tokens are sequences of length 4 or more (``type``,
+    ``string``, ``start``, ``end``), as returned by :func:`tokenize`, then
+    spaces are added so that each token appears in the result at the
+    position indicated by ``start`` and ``end``, if possible.
+    """
+    return Untokenizer().untokenize(tokens)
+
+
+def _get_normal_name(orig_enc):
+    """Imitates get_normal_name in tokenizer.c."""
+    # Only care about the first 12 characters.
+    enc = orig_enc[:12].lower().replace("_", "-")
+    if enc == "utf-8" or enc.startswith("utf-8-"):
+        return "utf-8"
+    if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \
+       enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):
+        return "iso-8859-1"
+    return orig_enc
+
+def detect_encoding(readline):
+    """
+    The detect_encoding() function is used to detect the encoding that should
+    be used to decode a Python source file.  It requires one argment, readline,
+    in the same way as the tokenize() generator.
+
+    It will call readline a maximum of twice, and return the encoding used
+    (as a string) and a list of any lines (left as bytes) it has read in.
+
+    It detects the encoding from the presence of a utf-8 bom or an encoding
+    cookie as specified in pep-0263.  If both a bom and a cookie are present,
+    but disagree, a SyntaxError will be raised.  If the encoding cookie is an
+    invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
+    'utf-8-sig' is returned.
+
+    If no encoding is specified, then the default of 'utf-8' will be returned.
+    """
+    bom_found = False
+    encoding = None
+    default = 'utf-8'
+    def read_or_stop():
+        try:
+            return readline()
+        except StopIteration:
+            return b''
+
+    def find_cookie(line):
+        try:
+            # Decode as UTF-8. Either the line is an encoding declaration,
+            # in which case it should be pure ASCII, or it must be UTF-8
+            # per default encoding.
+            line_string = line.decode('utf-8')
+        except UnicodeDecodeError:
+            raise SyntaxError("invalid or missing encoding declaration")
+
+        matches = cookie_re.findall(line_string)
+        if not matches:
+            return None
+        encoding = _get_normal_name(matches[0])
+        try:
+            codec = lookup(encoding)
+        except LookupError:
+            # This behaviour mimics the Python interpreter
+            raise SyntaxError("unknown encoding: " + encoding)
+
+        if bom_found:
+            if encoding != 'utf-8':
+                # This behaviour mimics the Python interpreter
+                raise SyntaxError('encoding problem: utf-8')
+            encoding += '-sig'
+        return encoding
+
+    first = read_or_stop()
+    if first.startswith(BOM_UTF8):
+        bom_found = True
+        first = first[3:]
+        default = 'utf-8-sig'
+    if not first:
+        return default, []
+
+    encoding = find_cookie(first)
+    if encoding:
+        return encoding, [first]
+
+    second = read_or_stop()
+    if not second:
+        return default, [first]
+
+    encoding = find_cookie(second)
+    if encoding:
+        return encoding, [first, second]
+
+    return default, [first, second]
+
+
+def open(filename):
+    """Open a file in read only mode using the encoding detected by
+    detect_encoding().
+    """
+    buffer = builtins.open(filename, 'rb')
+    encoding, lines = detect_encoding(buffer.readline)
+    buffer.seek(0)
+    text = TextIOWrapper(buffer, encoding, line_buffering=True)
+    text.mode = 'r'
+    return text
+
+
+def tokenize(readline):
+    """
+    The tokenize() generator requires one argment, readline, which
+    must be a callable object which provides the same interface as the
+    readline() method of built-in file objects.  Each call to the function
+    should return one line of input as bytes.  Alternately, readline
+    can be a callable function terminating with StopIteration:
+        readline = open(myfile, 'rb').__next__  # Example of alternate readline
+
+    The generator produces 5-tuples with these members: the token type; the
+    token string; a 2-tuple (srow, scol) of ints specifying the row and
+    column where the token begins in the source; a 2-tuple (erow, ecol) of
+    ints specifying the row and column where the token ends in the source;
+    and the line on which the token was found.  The line passed is the
+    logical line; continuation lines are included.
 
-if sys.version_info[0] >= 3:
-    from ._tokenize_py3 import *
+    The first token sequence will always be an ENCODING token
+    which tells you which encoding was used to decode the bytes stream.
+    """
+    # This import is here to avoid problems when the itertools module is not
+    # built yet and tokenize is imported.
+    from itertools import chain, repeat
+    encoding, consumed = detect_encoding(readline)
+    rl_gen = iter(readline, b"")
+    empty = repeat(b"")
+    return _tokenize(chain(consumed, rl_gen, empty).__next__, encoding)
+
+
+def _tokenize(readline, encoding):
+    lnum = parenlev = continued = 0
+    numchars = '0123456789'
+    contstr, needcont = '', 0
+    contline = None
+    indents = [0]
+
+    if encoding is not None:
+        if encoding == "utf-8-sig":
+            # BOM will already have been stripped.
+            encoding = "utf-8"
+        yield TokenInfo(ENCODING, encoding, (0, 0), (0, 0), '')
+    while True:             # loop over lines in stream
+        try:
+            line = readline()
+        except StopIteration:
+            line = b''
+
+        if encoding is not None:
+            line = line.decode(encoding)
+        lnum += 1
+        pos, max = 0, len(line)
+
+        if contstr:                            # continued string
+            if not line:
+                raise TokenError("EOF in multi-line string", strstart)
+            endmatch = endprog.match(line)
+            if endmatch:
+                pos = end = endmatch.end(0)
+                yield TokenInfo(STRING, contstr + line[:end],
+                       strstart, (lnum, end), contline + line)
+                contstr, needcont = '', 0
+                contline = None
+            elif needcont and line[-2:] != '\\\n' and line[-3:] != '\\\r\n':
+                yield TokenInfo(ERRORTOKEN, contstr + line,
+                           strstart, (lnum, len(line)), contline)
+                contstr = ''
+                contline = None
+                continue
+            else:
+                contstr = contstr + line
+                contline = contline + line
+                continue
+
+        elif parenlev == 0 and not continued:  # new statement
+            if not line: break
+            column = 0
+            while pos < max:                   # measure leading whitespace
+                if line[pos] == ' ':
+                    column += 1
+                elif line[pos] == '\t':
+                    column = (column//tabsize + 1)*tabsize
+                elif line[pos] == '\f':
+                    column = 0
+                else:
+                    break
+                pos += 1
+            if pos == max:
+                break
+
+            if line[pos] in '#\r\n':           # skip comments or blank lines
+                if line[pos] == '#':
+                    comment_token = line[pos:].rstrip('\r\n')
+                    nl_pos = pos + len(comment_token)
+                    yield TokenInfo(COMMENT, comment_token,
+                           (lnum, pos), (lnum, pos + len(comment_token)), line)
+                    yield TokenInfo(NEWLINE, line[nl_pos:],
+                           (lnum, nl_pos), (lnum, len(line)), line)
+                else:
+                    yield TokenInfo(NEWLINE, line[pos:],
+                           (lnum, pos), (lnum, len(line)), line)
+                continue
+
+            if column > indents[-1]:           # count indents or dedents
+                indents.append(column)
+                yield TokenInfo(INDENT, line[:pos], (lnum, 0), (lnum, pos), line)
+            while column < indents[-1]:
+                if column not in indents:
+                    raise IndentationError(
+                        "unindent does not match any outer indentation level",
+                        ("<tokenize>", lnum, pos, line))
+                indents = indents[:-1]
+                yield TokenInfo(DEDENT, '', (lnum, pos), (lnum, pos), line)
+
+        else:                                  # continued statement
+            if not line:
+                raise TokenError("EOF in multi-line statement", (lnum, 0))
+            continued = 0
+
+        while pos < max:
+            pseudomatch = pseudoprog.match(line, pos)
+            if pseudomatch:                                # scan for tokens
+                start, end = pseudomatch.span(1)
+                spos, epos, pos = (lnum, start), (lnum, end), end
+                token, initial = line[start:end], line[start]
+
+                if (initial in numchars or                  # ordinary number
+                    (initial == '.' and token != '.' and token != '...')):
+                    yield TokenInfo(NUMBER, token, spos, epos, line)
+                elif initial in '\r\n':
+                    yield TokenInfo(NL if parenlev > 0 else NEWLINE,
+                           token, spos, epos, line)
+                elif initial == '#':
+                    assert not token.endswith("\n")
+                    yield TokenInfo(COMMENT, token, spos, epos, line)
+                elif token in triple_quoted:
+                    endprog = endprogs[token]
+                    endmatch = endprog.match(line, pos)
+                    if endmatch:                           # all on one line
+                        pos = endmatch.end(0)
+                        token = line[start:pos]
+                        yield TokenInfo(STRING, token, spos, (lnum, pos), line)
+                    else:
+                        strstart = (lnum, start)           # multiple lines
+                        contstr = line[start:]
+                        contline = line
+                        break
+                elif initial in single_quoted or \
+                    token[:2] in single_quoted or \
+                    token[:3] in single_quoted:
+                    if token[-1] == '\n':                  # continued string
+                        strstart = (lnum, start)
+                        endprog = (endprogs[initial] or endprogs[token[1]] or
+                                   endprogs[token[2]])
+                        contstr, needcont = line[start:], 1
+                        contline = line
+                        break
+                    else:                                  # ordinary string
+                        yield TokenInfo(STRING, token, spos, epos, line)
+                elif initial.isidentifier():               # ordinary name
+                    yield TokenInfo(NAME, token, spos, epos, line)
+                elif initial == '\\':                      # continued stmt
+                    continued = 1
+                else:
+                    if initial in '([{':
+                        parenlev += 1
+                    elif initial in ')]}':
+                        parenlev -= 1
+                    yield TokenInfo(OP, token, spos, epos, line)
+            else:
+                yield TokenInfo(ERRORTOKEN, line[pos],
+                           (lnum, pos), (lnum, pos+1), line)
+                pos += 1
+
+    for indent in indents[1:]:                 # pop remaining indent levels
+        yield TokenInfo(DEDENT, '', (lnum, 0), (lnum, 0), '')
+    yield TokenInfo(ENDMARKER, '', (lnum, 0), (lnum, 0), '')
+
+
+# An undocumented, backwards compatible, API for all the places in the standard
+# library that expect to be able to use tokenize with strings
+def generate_tokens(readline):
+    return _tokenize(readline, None)
+
+if __name__ == "__main__":
+    # Quick sanity check
+    s = b'''def parseline(self, line):
+            """Parse the line into a command name and a string containing
+            the arguments.  Returns a tuple containing (command, args, line).
+            'command' and 'args' may be None if the line couldn't be parsed.
+            """
+            line = line.strip()
+            if not line:
+                return None, None, line
+            elif line[0] == '?':
+                line = 'help ' + line[1:]
+            elif line[0] == '!':
+                if hasattr(self, 'do_shell'):
+                    line = 'shell ' + line[1:]
 else:
-    from ._tokenize_py2 import *
+                    return None, None, line
+            i, n = 0, len(line)
+            while i < n and line[i] in self.identchars: i = i+1
+            cmd, arg = line[:i], line[i:].strip()
+            return cmd, arg, line
+    '''
+    for tok in tokenize(iter(s.splitlines()).__next__):
+        print(tok)

IPython/utils/tokenutil.py

@@ -3,7 +3,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import absolute_import, print_function
 
 from collections import namedtuple
 from io import StringIO

IPython/utils/traitlets.py

@@ -1,4 +1,3 b''
-from __future__ import absolute_import
 
 from warnings import warn
 

docs/sphinxext/apigen.py

@@ -17,7 +17,6 b' NOTE: this is a modified version of a script originally shipped with the'
 PyMVPA project, which we've adapted for NIPY use.  PyMVPA is an MIT-licensed
 project."""
 
-from __future__ import print_function
 
 # Stdlib imports
 import ast

examples/Embedding/embed_class_long.py

@@ -8,7 +8,6 b' embedding which you can cut and paste in your code once you understand how'
 things work.
 
 The code in this file is deliberately extra-verbose, meant for learning."""
-from __future__ import print_function
 
 # The basics to get you going:
 

examples/IPython Kernel/example-demo.py

@@ -8,7 +8,6 b' resuming execution later.'
 
 This is a unicode test, åäö
 """
-from __future__ import print_function
 
 print('Hello, welcome to an interactive IPython demo.')
 print('Executing this block should require confirmation before proceeding,')

scripts/ipython_win_post_install.py

@@ -5,7 +5,6 b' http://docs.python.org/2/distutils/builtdist.html#the-postinstallation-script'
 
 """
 
-from __future__ import print_function
 
 import os
 import sys

setup.py

@@ -41,8 +41,6 b' See IPython `README.rst` file for more information:'
     print(error, file=sys.stderr)
     sys.exit(1)
 
-PY3 = (sys.version_info[0] >= 3)
-
 # At least we're on the python version we need, move on.
 
 #-------------------------------------------------------------------------------

setupbase.py

@@ -12,7 +12,6 b' This includes:'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from __future__ import print_function
 
 import re
 import os

tools/backport_pr.py

@@ -26,7 +26,6 b' of that repo.'
 
 """
 
-from __future__ import print_function
 
 import os
 import re

tools/check_sources.py

@@ -8,7 +8,6 b' Usage:'
 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

tools/gen_latex_symbols.py

@@ -9,7 +9,6 b''
 # 
 # The original mapping of latex symbols to unicode comes from the `latex_symbols.jl` files from Julia.
 
-from __future__ import print_function
 import os, sys
 
 if not sys.version_info[0] == 3:

tools/gh_api.py

@@ -1,5 +1,4 b''
 """Functions for Github API requests."""
-from __future__ import print_function
 
 try:
     input = raw_input

tools/git-mpr.py

@@ -7,7 +7,6 b' Usage:'
 Type `git mpr -h` for details.
 """
 
-from __future__ import print_function
 
 import io, os
 import argparse

tools/github_stats.py

@@ -9,7 +9,6 b' To generate a report for IPython 2.0, run:'
 # Imports
 #-----------------------------------------------------------------------------
 
-from __future__ import print_function
 
 import codecs
 import sys
@@ -114,9 +113,6 b' if __name__ == "__main__":'
     print("DEPRECATE: backport_pr.py is deprecated and is is now recommended"
           "to install `ghpro` from PyPI.", file=sys.stderr)
 
-    # deal with unicode
-    if sys.version_info < (3,):
-        sys.stdout = codecs.getwriter('utf8')(sys.stdout)
     
     # Whether to add reST urls for all issues in printout.
     show_urls = True

tools/test_pr.py

@@ -7,7 +7,6 b' Python, and posts the results to Gist if any tests fail.'
 Usage:
     python test_pr.py 1657
 """
-from __future__ import print_function
 
 import errno
 from glob import glob

tools/tests/embed/embed_no_flufl.py

@@ -1,6 +1,6 b''
 """This tests that future compiler flags are passed to the embedded IPython."""
 from IPython import embed
 import __future__
-embed(banner1='', header='check 1/2 == 0 in Python 2')
-embed(banner1='', header='check 1/2 == 0.5 in Python 2',
-      compile_flags=__future__.division.compiler_flag)
+embed(banner1='', header='check 1 <> 2 cause SyntaxError')
+embed(banner1='', header='check 1 <> 2 == True',
+      compile_flags=__future__.barry_as_FLUFL.compiler_flag)

tools/toollib.py

@@ -1,6 +1,5 b''
 """Various utilities common to IPython release and maintenance tools.
 """
-from __future__ import print_function
 
 # Library imports
 import os