Merge pull request #10135 from srinivasreddy/dead_code

remove python2 specific code

IPython/core/oinspect.py

@@ -35,7 +35,7 b' from IPython.utils.path import compress_user'
 from IPython.utils.text import indent
 from IPython.utils.wildcard import list_namespace
 from IPython.utils.coloransi import TermColors, ColorScheme, ColorSchemeTable
-from IPython.utils.py3compat import cast_unicode, PY3
+from IPython.utils.py3compat import cast_unicode
 from IPython.utils.colorable import Colorable
 from IPython.utils.decorators import undoc
 
@@ -216,7 +216,7 b' def getargspec(obj):'
     if safe_hasattr(obj, '__call__') and not is_simple_callable(obj):
         obj = obj.__call__
 
-    return inspect.getfullargspec(obj) if PY3 else inspect.getargspec(obj)
+    return inspect.getfullargspec(obj)
 
 
 def format_argspec(argspec):
@@ -403,8 +403,7 b' class Inspector(Colorable):'
 
         if inspect.isclass(obj):
             header = self.__head('Class constructor information:\n')
-        elif (not py3compat.PY3) and type(obj) is types.InstanceType:
-            obj = obj.__call__
+
 
         output = self._getdef(obj,oname)
         if output is None:
@@ -636,13 +635,7 b' class Inspector(Colorable):'
             # General Python objects
             append_field(_mime, 'Signature', 'definition', code_formatter)
             append_field(_mime, 'Call signature', 'call_def', code_formatter)
-            
             append_field(_mime, 'Type', 'type_name')
-
-            # Base class for old-style instances
-            if (not py3compat.PY3) and isinstance(obj, types.InstanceType) and info['base_class']:
-                append_field(_mime, 'Base Class', 'base_class')
-
             append_field(_mime, 'String form', 'string_form')
 
             # Namespace

IPython/core/tests/test_compilerop.py

@@ -51,7 +51,7 b' def test_cache():'
 def setUp():
     # Check we're in a proper Python 2 environment (some imports, such
     # as GTK, can change the default encoding, which can hide bugs.)
-    nt.assert_equal(sys.getdefaultencoding(), "utf-8" if py3compat.PY3 else "ascii")
+    nt.assert_equal(sys.getdefaultencoding(), "utf-8")
 
 def test_cache_unicode():
     cp = compilerop.CachingCompiler()

IPython/core/tests/test_history.py

@@ -22,7 +22,7 b' from IPython.core.history import HistoryManager, extract_hist_ranges'
 from IPython.utils import py3compat
 
 def setUp():
-    nt.assert_equal(sys.getdefaultencoding(), "utf-8" if py3compat.PY3 else "ascii")
+    nt.assert_equal(sys.getdefaultencoding(), "utf-8")
 
 def test_history():
     ip = get_ipython()

IPython/core/tests/test_interactiveshell.py

@@ -17,6 +17,7 b' import sys'
 import tempfile
 import unittest
 from unittest import mock
+from io import StringIO
 
 from os.path import join
 
@@ -30,12 +31,6 b' from IPython.testing.decorators import ('
 from IPython.testing import tools as tt
 from IPython.utils.process import find_cmd
 from IPython.utils import py3compat
-from IPython.utils.py3compat import PY3
-
-if PY3:
-    from io import StringIO
-else:
-    from StringIO import StringIO
 
 #-----------------------------------------------------------------------------
 # Globals

IPython/core/tests/test_magic.py

@@ -9,12 +9,8 b' import os'
 import sys
 import warnings
 from unittest import TestCase
-
-try:
-    from importlib import invalidate_caches   # Required from Python 3.3
-except ImportError:
-    def invalidate_caches():
-        pass
+from importlib import invalidate_caches
+from io import StringIO
 
 import nose.tools as nt
 
@@ -32,10 +28,6 b' from IPython.utils.io import capture_output'
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.process import find_cmd
 
-if py3compat.PY3:
-    from io import StringIO
-else:
-    from StringIO import StringIO
 
 
 _ip = get_ipython()

IPython/core/tests/test_magic_terminal.py

@@ -8,17 +8,12 b' Needs to be run by nose (to make ipython session available).'
 #-----------------------------------------------------------------------------
 
 import sys
+from io import StringIO
 from unittest import TestCase
 
 import nose.tools as nt
 
 from IPython.testing import tools as tt
-from IPython.utils.py3compat import PY3
-
-if PY3:
-    from io import StringIO
-else:
-    from StringIO import StringIO
 
 #-----------------------------------------------------------------------------
 # Globals

IPython/core/tests/test_oinspect.py

@@ -227,8 +227,7 b' def test_info():'
     nt.assert_equal(i['docstring'], Call.__doc__)
     nt.assert_equal(i['source'], None)
     nt.assert_true(i['isclass'])
-    _self_py2 = '' if py3compat.PY3 else 'self, '
-    nt.assert_equal(i['init_definition'], "Call(%sx, y=1)" % _self_py2)
+    nt.assert_equal(i['init_definition'], "Call(x, y=1)")
     nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
 
     i = inspector.info(Call, detail_level=1)
@@ -244,15 +243,6 b' def test_info():'
     nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
     nt.assert_equal(i['call_docstring'], Call.__call__.__doc__)
 
-    # Test old-style classes, which for example may not have an __init__ method.
-    if not py3compat.PY3:
-        i = inspector.info(OldStyle)
-        nt.assert_equal(i['type_name'], 'classobj')
-
-        i = inspector.info(OldStyle())
-        nt.assert_equal(i['type_name'], 'instance')
-        nt.assert_equal(i['docstring'], OldStyle.__doc__)
-
 def test_class_signature():
     info = inspector.info(HasSignature, 'HasSignature')
     nt.assert_equal(info['init_definition'], "HasSignature(test)")

IPython/core/tests/test_ultratb.py

@@ -16,7 +16,6 b' from IPython.testing import tools as tt'
 from IPython.testing.decorators import onlyif_unicode_paths
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.tempdir import TemporaryDirectory
-from IPython.utils.py3compat import PY3
 
 ip = get_ipython()
 
@@ -226,20 +225,17 b' except Exception:'
     """
 
     def test_direct_cause_error(self):
-        if PY3:
-            with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
-                ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
+        with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
+            ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
 
     def test_exception_during_handling_error(self):
-        if PY3:
-            with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
-                ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
+        with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
+            ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
 
     def test_suppress_exception_chaining(self):
-        if PY3:
-            with tt.AssertNotPrints("ZeroDivisionError"), \
-                    tt.AssertPrints("ValueError", suppress=False):
-                ip.run_cell(self.SUPPRESS_CHAINING_CODE)
+        with tt.AssertNotPrints("ZeroDivisionError"), \
+             tt.AssertPrints("ValueError", suppress=False):
+            ip.run_cell(self.SUPPRESS_CHAINING_CODE)
 
 
 class RecursionTest(unittest.TestCase):

IPython/extensions/autoreload.py

@@ -260,12 +260,9 b' class ModuleReloader(object):'
 # superreload
 #------------------------------------------------------------------------------
 
-if PY3:
-    func_attrs = ['__code__', '__defaults__', '__doc__',
-                  '__closure__', '__globals__', '__dict__']
-else:
-    func_attrs = ['func_code', 'func_defaults', 'func_doc',
-                  'func_closure', 'func_globals', 'func_dict']
+
+func_attrs = ['__code__', '__defaults__', '__doc__',
+              '__closure__', '__globals__', '__dict__']
 
 
 def update_function(old, new):
@@ -320,18 +317,9 b' UPDATE_RULES = ['
     (lambda a, b: isinstance2(a, b, property),
      update_property),
 ]
-
-
-if PY3:
-    UPDATE_RULES.extend([(lambda a, b: isinstance2(a, b, types.MethodType),
-                          lambda a, b: update_function(a.__func__, b.__func__)),
-                        ])
-else:
-    UPDATE_RULES.extend([(lambda a, b: isinstance2(a, b, types.ClassType),
-                          update_class),
-                         (lambda a, b: isinstance2(a, b, types.MethodType),
-                          lambda a, b: update_function(a.__func__, b.__func__)),
-                        ])
+UPDATE_RULES.extend([(lambda a, b: isinstance2(a, b, types.MethodType),
+                      lambda a, b: update_function(a.__func__, b.__func__)),
+])
 
 
 def update_generic(a, b):

IPython/extensions/tests/test_autoreload.py

@@ -18,18 +18,13 b' import tempfile'
 import shutil
 import random
 import time
+from io import StringIO
 
 import nose.tools as nt
 import IPython.testing.tools as tt
 
 from IPython.extensions.autoreload import AutoreloadMagics
 from IPython.core.events import EventManager, pre_run_cell
-from IPython.utils.py3compat import PY3
-
-if PY3:
-    from io import StringIO
-else:
-    from StringIO import StringIO
 
 #-----------------------------------------------------------------------------
 # Test fixture

IPython/lib/latextools.py

@@ -15,7 +15,7 b' from IPython.utils.process import find_cmd, FindCmdError'
 from traitlets.config import get_config
 from traitlets.config.configurable import SingletonConfigurable
 from traitlets import List, Bool, Unicode
-from IPython.utils.py3compat import cast_unicode, cast_unicode_py2 as u, PY3
+from IPython.utils.py3compat import cast_unicode, cast_unicode_py2 as u
 
 
 class LaTeXTool(SingletonConfigurable):

IPython/lib/pretty.py

@@ -84,7 +84,7 b' import re'
 import datetime
 from collections import deque
 
-from IPython.utils.py3compat import PY3, PYPY, cast_unicode
+from IPython.utils.py3compat import PYPY, cast_unicode
 from IPython.utils.encoding import get_stream_enc
 
 from io import StringIO
@@ -108,15 +108,7 b' def _safe_getattr(obj, attr, default=None):'
     except Exception:
         return default
 
-if PY3:
-    CUnicodeIO = StringIO
-else:
-    class CUnicodeIO(StringIO):
-        """StringIO that casts str to unicode on Python 2"""
-        def write(self, text):
-            return super(CUnicodeIO, self).write(
-                cast_unicode(text, encoding=get_stream_enc(sys.stdout)))
-
+CUnicodeIO = StringIO
 
 def pretty(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
     """

IPython/sphinxext/ipython_directive.py

@@ -133,7 +133,7 b' import tempfile'
 import ast
 import warnings
 import shutil
-
+from io import StringIO
 
 # Third-party
 from docutils.parsers.rst import directives
@@ -144,12 +144,6 b' from traitlets.config import Config'
 from IPython import InteractiveShell
 from IPython.core.profiledir import ProfileDir
 from IPython.utils import io
-from IPython.utils.py3compat import PY3
-
-if PY3:
-    from io import StringIO
-else:
-    from StringIO import StringIO
 
 #-----------------------------------------------------------------------------
 # Globals

IPython/terminal/interactiveshell.py

@@ -7,7 +7,7 b' from warnings import warn'
 
 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
 from IPython.utils import io
-from IPython.utils.py3compat import PY3, cast_unicode_py2, input
+from IPython.utils.py3compat import cast_unicode_py2, input
 from IPython.utils.terminal import toggle_set_term_title, set_term_title
 from IPython.utils.process import abbrev_cwd
 from traitlets import Bool, Unicode, Dict, Integer, observe, Instance, Type, default, Enum, Union
@@ -59,10 +59,7 b' _style_overrides_linux = {'
 
 def get_default_editor():
     try:
-        ed = os.environ['EDITOR']
-        if not PY3:
-            ed = ed.decode()
-        return ed
+        return os.environ['EDITOR']
     except KeyError:
         pass
     except UnicodeError:
@@ -345,26 +342,7 b' class TerminalInteractiveShell(InteractiveShell):'
             return
 
         import win_unicode_console
-
-        if PY3:
-            win_unicode_console.enable()
-        else:
-            # https://github.com/ipython/ipython/issues/9768
-            from win_unicode_console.streams import (TextStreamWrapper,
-                                 stdout_text_transcoded, stderr_text_transcoded)
-
-            class LenientStrStreamWrapper(TextStreamWrapper):
-                def write(self, s):
-                    if isinstance(s, bytes):
-                        s = s.decode(self.encoding, 'replace')
-
-                    self.base.write(s)
-
-            stdout_text_str = LenientStrStreamWrapper(stdout_text_transcoded)
-            stderr_text_str = LenientStrStreamWrapper(stderr_text_transcoded)
-
-            win_unicode_console.enable(stdout=stdout_text_str,
-                                       stderr=stderr_text_str)
+        win_unicode_console.enable()
 
     def init_io(self):
         if sys.platform not in {'win32', 'cli'}:

IPython/terminal/pt_inputhooks/tk.py

@@ -40,13 +40,8 b' will fix it for Tk.)'
 """
 import time
 
-from IPython.utils.py3compat import PY3
-
 import _tkinter
-if PY3:
-    import tkinter
-else:
-    import Tkinter as tkinter  # Python 2
+import tkinter
 
 def inputhook(inputhook_context):
     """

IPython/testing/decorators.py

@@ -49,7 +49,7 b' from .ipunittest import ipdoctest, ipdocstring'
 from IPython.external.decorators import *
 
 # For onlyif_cmd_exists decorator
-from IPython.utils.py3compat import which, PY2, PY3, PYPY
+from IPython.utils.py3compat import which
 
 #-----------------------------------------------------------------------------
 # Classes and functions

IPython/testing/plugin/ipdoctest.py

@@ -26,6 +26,7 b' import os'
 import re
 import sys
 from importlib import import_module
+from io import StringIO
 
 from testpath import modified_env
 
@@ -45,12 +46,7 b' from nose.plugins import doctests, Plugin'
 from nose.util import anyp, tolist
 
 # Our own imports
-from IPython.utils.py3compat import builtin_mod, PY3
-
-if PY3:
-    from io import StringIO
-else:
-    from StringIO import StringIO
+from IPython.utils.py3compat import builtin_mod
 
 #-----------------------------------------------------------------------------
 # Module globals and other constants

IPython/testing/tools.py

@@ -322,15 +322,7 b' def check_pairs(func, pairs):'
         assert out == expected, pair_fail_msg.format(name, inp, expected, out)
 
 
-if py3compat.PY3:
-    MyStringIO = StringIO
-else:
-    # In Python 2, stdout/stderr can have either bytes or unicode written to them,
-    # so we need a class that can handle both.
-    class MyStringIO(StringIO):
-        def write(self, s):
-            s = py3compat.cast_unicode(s, encoding=DEFAULT_ENCODING)
-            super(MyStringIO, self).write(s)
+MyStringIO = StringIO
 
 _re_type = type(re.compile(r''))
 

IPython/utils/tests/test_path.py

@@ -13,6 +13,7 b' import warnings'
 from contextlib import contextmanager
 from unittest.mock import patch
 from os.path import join, abspath, split
+from imp import reload
 
 from nose import SkipTest, with_setup
 import nose.tools as nt
@@ -29,27 +30,19 b' from IPython.utils.tempdir import TemporaryDirectory'
 
 # Platform-dependent imports
 try:
-    import winreg as wreg  # Py 3
+    import winreg as wreg  
 except ImportError:
+    #Fake _winreg module on non-windows platforms
+    import types
+    wr_name = "winreg"
+    sys.modules[wr_name] = types.ModuleType(wr_name)
     try:
-        import _winreg as wreg  # Py 2
+        import winreg as wreg
     except ImportError:
-        #Fake _winreg module on none windows platforms
-        import types
-        wr_name = "winreg" if py3compat.PY3 else "_winreg"
-        sys.modules[wr_name] = types.ModuleType(wr_name)
-        try:
-            import winreg as wreg
-        except ImportError:
-            import _winreg as wreg
+        import _winreg as wreg
         #Add entries that needs to be stubbed by the testing code
         (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
 
-try:
-    reload
-except NameError:   # Python 3
-    from imp import reload
-
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------