Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

1 files changed, 548 insertions, 548 deletions

diff --git a/contrib/python/ipython/py2/IPython/lib/inputhook.py b/contrib/python/ipython/py2/IPython/lib/inputhook.py
index e6e8f2dbbc..38ccda8831 100644
--- a/contrib/python/ipython/py2/IPython/lib/inputhook.py
+++ b/contrib/python/ipython/py2/IPython/lib/inputhook.py
@@ -1,666 +1,666 @@
-# coding: utf-8
-"""
+# coding: utf-8 
+""" 
 Deprecated since IPython 5.0
 
-Inputhook management for GUI event loop integration.
-"""
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License.
-
-try:
-    import ctypes
-except ImportError:
-    ctypes = None
-except SystemError: # IronPython issue, 2/8/2014
-    ctypes = None
-import os
-import platform
-import sys
-from distutils.version import LooseVersion as V
-
+Inputhook management for GUI event loop integration. 
+""" 
+ 
+# Copyright (c) IPython Development Team. 
+# Distributed under the terms of the Modified BSD License. 
+ 
+try: 
+    import ctypes 
+except ImportError: 
+    ctypes = None 
+except SystemError: # IronPython issue, 2/8/2014 
+    ctypes = None 
+import os 
+import platform 
+import sys 
+from distutils.version import LooseVersion as V 
+ 
 from warnings import warn
-
+ 
 
 warn("`IPython.lib.inputhook` is deprecated since IPython 5.0 and will be removed in future versions.",
         DeprecationWarning, stacklevel=2)
 
 
-#-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-# Constants for identifying the GUI toolkits.
-GUI_WX = 'wx'
-GUI_QT = 'qt'
-GUI_QT4 = 'qt4'
-GUI_GTK = 'gtk'
-GUI_TK = 'tk'
-GUI_OSX = 'osx'
-GUI_GLUT = 'glut'
-GUI_PYGLET = 'pyglet'
-GUI_GTK3 = 'gtk3'
-GUI_NONE = 'none' # i.e. disable
-
-#-----------------------------------------------------------------------------
-# Utilities
-#-----------------------------------------------------------------------------
-
-def _stdin_ready_posix():
-    """Return True if there's something to read on stdin (posix version)."""
-    infds, outfds, erfds = select.select([sys.stdin],[],[],0)
-    return bool(infds)
-
-def _stdin_ready_nt():
-    """Return True if there's something to read on stdin (nt version)."""
-    return msvcrt.kbhit()
-
-def _stdin_ready_other():
-    """Return True, assuming there's something to read on stdin."""
-    return True
-
-def _use_appnope():
-    """Should we use appnope for dealing with OS X app nap?
-
-    Checks if we are on OS X 10.9 or greater.
-    """
-    return sys.platform == 'darwin' and V(platform.mac_ver()[0]) >= V('10.9')
-
-def _ignore_CTRL_C_posix():
-    """Ignore CTRL+C (SIGINT)."""
-    signal.signal(signal.SIGINT, signal.SIG_IGN)
-
-def _allow_CTRL_C_posix():
-    """Take CTRL+C into account (SIGINT)."""
-    signal.signal(signal.SIGINT, signal.default_int_handler)
-
-def _ignore_CTRL_C_other():
-    """Ignore CTRL+C (not implemented)."""
-    pass
-
-def _allow_CTRL_C_other():
-    """Take CTRL+C into account (not implemented)."""
-    pass
-
-if os.name == 'posix':
-    import select
-    import signal
-    stdin_ready = _stdin_ready_posix
-    ignore_CTRL_C = _ignore_CTRL_C_posix
-    allow_CTRL_C = _allow_CTRL_C_posix
-elif os.name == 'nt':
-    import msvcrt
-    stdin_ready = _stdin_ready_nt
-    ignore_CTRL_C = _ignore_CTRL_C_other
-    allow_CTRL_C = _allow_CTRL_C_other
-else:
-    stdin_ready = _stdin_ready_other
-    ignore_CTRL_C = _ignore_CTRL_C_other
-    allow_CTRL_C = _allow_CTRL_C_other
-
-
-#-----------------------------------------------------------------------------
-# Main InputHookManager class
-#-----------------------------------------------------------------------------
-
-
-class InputHookManager(object):
+#----------------------------------------------------------------------------- 
+# Constants 
+#----------------------------------------------------------------------------- 
+ 
+# Constants for identifying the GUI toolkits. 
+GUI_WX = 'wx' 
+GUI_QT = 'qt' 
+GUI_QT4 = 'qt4' 
+GUI_GTK = 'gtk' 
+GUI_TK = 'tk' 
+GUI_OSX = 'osx' 
+GUI_GLUT = 'glut' 
+GUI_PYGLET = 'pyglet' 
+GUI_GTK3 = 'gtk3' 
+GUI_NONE = 'none' # i.e. disable 
+ 
+#----------------------------------------------------------------------------- 
+# Utilities 
+#----------------------------------------------------------------------------- 
+ 
+def _stdin_ready_posix(): 
+    """Return True if there's something to read on stdin (posix version).""" 
+    infds, outfds, erfds = select.select([sys.stdin],[],[],0) 
+    return bool(infds) 
+ 
+def _stdin_ready_nt(): 
+    """Return True if there's something to read on stdin (nt version).""" 
+    return msvcrt.kbhit() 
+ 
+def _stdin_ready_other(): 
+    """Return True, assuming there's something to read on stdin.""" 
+    return True 
+ 
+def _use_appnope(): 
+    """Should we use appnope for dealing with OS X app nap? 
+ 
+    Checks if we are on OS X 10.9 or greater. 
+    """ 
+    return sys.platform == 'darwin' and V(platform.mac_ver()[0]) >= V('10.9') 
+ 
+def _ignore_CTRL_C_posix(): 
+    """Ignore CTRL+C (SIGINT).""" 
+    signal.signal(signal.SIGINT, signal.SIG_IGN) 
+ 
+def _allow_CTRL_C_posix(): 
+    """Take CTRL+C into account (SIGINT).""" 
+    signal.signal(signal.SIGINT, signal.default_int_handler) 
+ 
+def _ignore_CTRL_C_other(): 
+    """Ignore CTRL+C (not implemented).""" 
+    pass 
+ 
+def _allow_CTRL_C_other(): 
+    """Take CTRL+C into account (not implemented).""" 
+    pass 
+ 
+if os.name == 'posix': 
+    import select 
+    import signal 
+    stdin_ready = _stdin_ready_posix 
+    ignore_CTRL_C = _ignore_CTRL_C_posix 
+    allow_CTRL_C = _allow_CTRL_C_posix 
+elif os.name == 'nt': 
+    import msvcrt 
+    stdin_ready = _stdin_ready_nt 
+    ignore_CTRL_C = _ignore_CTRL_C_other 
+    allow_CTRL_C = _allow_CTRL_C_other 
+else: 
+    stdin_ready = _stdin_ready_other 
+    ignore_CTRL_C = _ignore_CTRL_C_other 
+    allow_CTRL_C = _allow_CTRL_C_other 
+ 
+ 
+#----------------------------------------------------------------------------- 
+# Main InputHookManager class 
+#----------------------------------------------------------------------------- 
+ 
+ 
+class InputHookManager(object): 
     """DEPRECATED since IPython 5.0
-
+ 
     Manage PyOS_InputHook for different GUI toolkits.
 
-    This class installs various hooks under ``PyOSInputHook`` to handle
-    GUI event loop integration.
-    """
-    
-    def __init__(self):
-        if ctypes is None:
-            warn("IPython GUI event loop requires ctypes, %gui will not be available")
-        else:
-            self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int)
-        self.guihooks = {}
-        self.aliases = {}
-        self.apps = {}
-        self._reset()
-
-    def _reset(self):
-        self._callback_pyfunctype = None
-        self._callback = None
-        self._installed = False
-        self._current_gui = None
-
-    def get_pyos_inputhook(self):
+    This class installs various hooks under ``PyOSInputHook`` to handle 
+    GUI event loop integration. 
+    """ 
+     
+    def __init__(self): 
+        if ctypes is None: 
+            warn("IPython GUI event loop requires ctypes, %gui will not be available") 
+        else: 
+            self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int) 
+        self.guihooks = {} 
+        self.aliases = {} 
+        self.apps = {} 
+        self._reset() 
+ 
+    def _reset(self): 
+        self._callback_pyfunctype = None 
+        self._callback = None 
+        self._installed = False 
+        self._current_gui = None 
+ 
+    def get_pyos_inputhook(self): 
         """DEPRECATED since IPython 5.0
 
         Return the current PyOS_InputHook as a ctypes.c_void_p."""
         warn("`get_pyos_inputhook` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        return ctypes.c_void_p.in_dll(ctypes.pythonapi,"PyOS_InputHook")
-
-    def get_pyos_inputhook_as_func(self):
+        return ctypes.c_void_p.in_dll(ctypes.pythonapi,"PyOS_InputHook") 
+ 
+    def get_pyos_inputhook_as_func(self): 
         """DEPRECATED since IPython 5.0
 
         Return the current PyOS_InputHook as a ctypes.PYFUNCYPE."""
         warn("`get_pyos_inputhook_as_func` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        return self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook")
-
-    def set_inputhook(self, callback):
+        return self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook") 
+ 
+    def set_inputhook(self, callback): 
         """DEPRECATED since IPython 5.0
 
         Set PyOS_InputHook to callback and return the previous one."""
-        # On platforms with 'readline' support, it's all too likely to
-        # have a KeyboardInterrupt signal delivered *even before* an
-        # initial ``try:`` clause in the callback can be executed, so
-        # we need to disable CTRL+C in this situation.
-        ignore_CTRL_C()
-        self._callback = callback
-        self._callback_pyfunctype = self.PYFUNC(callback)
-        pyos_inputhook_ptr = self.get_pyos_inputhook()
-        original = self.get_pyos_inputhook_as_func()
-        pyos_inputhook_ptr.value = \
-            ctypes.cast(self._callback_pyfunctype, ctypes.c_void_p).value
-        self._installed = True
-        return original
-
-    def clear_inputhook(self, app=None):
+        # On platforms with 'readline' support, it's all too likely to 
+        # have a KeyboardInterrupt signal delivered *even before* an 
+        # initial ``try:`` clause in the callback can be executed, so 
+        # we need to disable CTRL+C in this situation. 
+        ignore_CTRL_C() 
+        self._callback = callback 
+        self._callback_pyfunctype = self.PYFUNC(callback) 
+        pyos_inputhook_ptr = self.get_pyos_inputhook() 
+        original = self.get_pyos_inputhook_as_func() 
+        pyos_inputhook_ptr.value = \ 
+            ctypes.cast(self._callback_pyfunctype, ctypes.c_void_p).value 
+        self._installed = True 
+        return original 
+ 
+    def clear_inputhook(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Set PyOS_InputHook to NULL and return the previous one.
 
-        Parameters
-        ----------
-        app : optional, ignored
-          This parameter is allowed only so that clear_inputhook() can be
-          called with a similar interface as all the ``enable_*`` methods.  But
-          the actual value of the parameter is ignored.  This uniform interface
-          makes it easier to have user-level entry points in the main IPython
-          app like :meth:`enable_gui`."""
+        Parameters 
+        ---------- 
+        app : optional, ignored 
+          This parameter is allowed only so that clear_inputhook() can be 
+          called with a similar interface as all the ``enable_*`` methods.  But 
+          the actual value of the parameter is ignored.  This uniform interface 
+          makes it easier to have user-level entry points in the main IPython 
+          app like :meth:`enable_gui`.""" 
         warn("`clear_inputhook` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        pyos_inputhook_ptr = self.get_pyos_inputhook()
-        original = self.get_pyos_inputhook_as_func()
-        pyos_inputhook_ptr.value = ctypes.c_void_p(None).value
-        allow_CTRL_C()
-        self._reset()
-        return original
-
-    def clear_app_refs(self, gui=None):
+        pyos_inputhook_ptr = self.get_pyos_inputhook() 
+        original = self.get_pyos_inputhook_as_func() 
+        pyos_inputhook_ptr.value = ctypes.c_void_p(None).value 
+        allow_CTRL_C() 
+        self._reset() 
+        return original 
+ 
+    def clear_app_refs(self, gui=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Clear IPython's internal reference to an application instance.
 
-        Whenever we create an app for a user on qt4 or wx, we hold a
-        reference to the app.  This is needed because in some cases bad things
-        can happen if a user doesn't hold a reference themselves.  This
-        method is provided to clear the references we are holding.
-
-        Parameters
-        ----------
-        gui : None or str
-            If None, clear all app references.  If ('wx', 'qt4') clear
-            the app for that toolkit.  References are not held for gtk or tk
-            as those toolkits don't have the notion of an app.
-        """
+        Whenever we create an app for a user on qt4 or wx, we hold a 
+        reference to the app.  This is needed because in some cases bad things 
+        can happen if a user doesn't hold a reference themselves.  This 
+        method is provided to clear the references we are holding. 
+ 
+        Parameters 
+        ---------- 
+        gui : None or str 
+            If None, clear all app references.  If ('wx', 'qt4') clear 
+            the app for that toolkit.  References are not held for gtk or tk 
+            as those toolkits don't have the notion of an app. 
+        """ 
         warn("`clear_app_refs` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        if gui is None:
-            self.apps = {}
-        elif gui in self.apps:
-            del self.apps[gui]
-
-    def register(self, toolkitname, *aliases):
+        if gui is None: 
+            self.apps = {} 
+        elif gui in self.apps: 
+            del self.apps[gui] 
+ 
+    def register(self, toolkitname, *aliases): 
         """DEPRECATED since IPython 5.0
 
         Register a class to provide the event loop for a given GUI.
-        
-        This is intended to be used as a class decorator. It should be passed
-        the names with which to register this GUI integration. The classes
-        themselves should subclass :class:`InputHookBase`.
-        
-        ::
-        
-            @inputhook_manager.register('qt')
-            class QtInputHook(InputHookBase):
-                def enable(self, app=None):
-                    ...
-        """
+         
+        This is intended to be used as a class decorator. It should be passed 
+        the names with which to register this GUI integration. The classes 
+        themselves should subclass :class:`InputHookBase`. 
+         
+        :: 
+         
+            @inputhook_manager.register('qt') 
+            class QtInputHook(InputHookBase): 
+                def enable(self, app=None): 
+                    ... 
+        """ 
         warn("`register` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        def decorator(cls):
-            if ctypes is not None:
-                inst = cls(self)
-                self.guihooks[toolkitname] = inst
-                for a in aliases:
-                    self.aliases[a] = toolkitname
-            return cls
-        return decorator
-
-    def current_gui(self):
+        def decorator(cls): 
+            if ctypes is not None: 
+                inst = cls(self) 
+                self.guihooks[toolkitname] = inst 
+                for a in aliases: 
+                    self.aliases[a] = toolkitname 
+            return cls 
+        return decorator 
+ 
+    def current_gui(self): 
         """DEPRECATED since IPython 5.0
 
         Return a string indicating the currently active GUI or None."""
         warn("`current_gui` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        return self._current_gui
-
-    def enable_gui(self, gui=None, app=None):
+        return self._current_gui 
+ 
+    def enable_gui(self, gui=None, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Switch amongst GUI input hooks by name.
 
-        This is a higher level method than :meth:`set_inputhook` - it uses the
-        GUI name to look up a registered object which enables the input hook
-        for that GUI.
-
-        Parameters
-        ----------
-        gui : optional, string or None
-          If None (or 'none'), clears input hook, otherwise it must be one
-          of the recognized GUI names (see ``GUI_*`` constants in module).
-
-        app : optional, existing application object.
-          For toolkits that have the concept of a global app, you can supply an
-          existing one.  If not given, the toolkit will be probed for one, and if
-          none is found, a new one will be created.  Note that GTK does not have
-          this concept, and passing an app if ``gui=="GTK"`` will raise an error.
-
-        Returns
-        -------
-        The output of the underlying gui switch routine, typically the actual
-        PyOS_InputHook wrapper object or the GUI toolkit app created, if there was
-        one.
-        """
+        This is a higher level method than :meth:`set_inputhook` - it uses the 
+        GUI name to look up a registered object which enables the input hook 
+        for that GUI. 
+ 
+        Parameters 
+        ---------- 
+        gui : optional, string or None 
+          If None (or 'none'), clears input hook, otherwise it must be one 
+          of the recognized GUI names (see ``GUI_*`` constants in module). 
+ 
+        app : optional, existing application object. 
+          For toolkits that have the concept of a global app, you can supply an 
+          existing one.  If not given, the toolkit will be probed for one, and if 
+          none is found, a new one will be created.  Note that GTK does not have 
+          this concept, and passing an app if ``gui=="GTK"`` will raise an error. 
+ 
+        Returns 
+        ------- 
+        The output of the underlying gui switch routine, typically the actual 
+        PyOS_InputHook wrapper object or the GUI toolkit app created, if there was 
+        one. 
+        """ 
         warn("`enable_gui` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        if gui in (None, GUI_NONE):
-            return self.disable_gui()
-        
-        if gui in self.aliases:
-            return self.enable_gui(self.aliases[gui], app)
-        
-        try:
-            gui_hook = self.guihooks[gui]
-        except KeyError:
-            e = "Invalid GUI request {!r}, valid ones are: {}"
-            raise ValueError(e.format(gui, ', '.join(self.guihooks)))
-        self._current_gui = gui
-
-        app = gui_hook.enable(app)
-        if app is not None:
-            app._in_event_loop = True
+        if gui in (None, GUI_NONE): 
+            return self.disable_gui() 
+         
+        if gui in self.aliases: 
+            return self.enable_gui(self.aliases[gui], app) 
+         
+        try: 
+            gui_hook = self.guihooks[gui] 
+        except KeyError: 
+            e = "Invalid GUI request {!r}, valid ones are: {}" 
+            raise ValueError(e.format(gui, ', '.join(self.guihooks))) 
+        self._current_gui = gui 
+ 
+        app = gui_hook.enable(app) 
+        if app is not None: 
+            app._in_event_loop = True 
             self.apps[gui] = app
-        return app
-
-    def disable_gui(self):
+        return app 
+ 
+    def disable_gui(self): 
         """DEPRECATED since IPython 5.0
 
         Disable GUI event loop integration.
-        
-        If an application was registered, this sets its ``_in_event_loop``
-        attribute to False. It then calls :meth:`clear_inputhook`.
-        """
+         
+        If an application was registered, this sets its ``_in_event_loop`` 
+        attribute to False. It then calls :meth:`clear_inputhook`. 
+        """ 
         warn("`disable_gui` is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        gui = self._current_gui
-        if gui in self.apps:
-            self.apps[gui]._in_event_loop = False
-        return self.clear_inputhook()
-
-class InputHookBase(object):
+        gui = self._current_gui 
+        if gui in self.apps: 
+            self.apps[gui]._in_event_loop = False 
+        return self.clear_inputhook() 
+ 
+class InputHookBase(object): 
     """DEPRECATED since IPython 5.0
 
     Base class for input hooks for specific toolkits.
-    
-    Subclasses should define an :meth:`enable` method with one argument, ``app``,
-    which will either be an instance of the toolkit's application class, or None.
-    They may also define a :meth:`disable` method with no arguments.
-    """
-    def __init__(self, manager):
-        self.manager = manager
-
-    def disable(self):
-        pass
-
-inputhook_manager = InputHookManager()
-
-@inputhook_manager.register('osx')
-class NullInputHook(InputHookBase):
+     
+    Subclasses should define an :meth:`enable` method with one argument, ``app``, 
+    which will either be an instance of the toolkit's application class, or None. 
+    They may also define a :meth:`disable` method with no arguments. 
+    """ 
+    def __init__(self, manager): 
+        self.manager = manager 
+ 
+    def disable(self): 
+        pass 
+ 
+inputhook_manager = InputHookManager() 
+ 
+@inputhook_manager.register('osx') 
+class NullInputHook(InputHookBase): 
     """DEPRECATED since IPython 5.0
 
     A null inputhook that doesn't need to do anything"""
-    def enable(self, app=None):
+    def enable(self, app=None): 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-
-@inputhook_manager.register('wx')
-class WxInputHook(InputHookBase):
-    def enable(self, app=None):
+ 
+@inputhook_manager.register('wx') 
+class WxInputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Enable event loop integration with wxPython.
 
-        Parameters
-        ----------
-        app : WX Application, optional.
-            Running application to use.  If not given, we probe WX for an
-            existing application object, and create a new one if none is found.
-
-        Notes
-        -----
-        This methods sets the ``PyOS_InputHook`` for wxPython, which allows
-        the wxPython to integrate with terminal based applications like
-        IPython.
-
-        If ``app`` is not given we probe for an existing one, and return it if
-        found.  If no existing app is found, we create an :class:`wx.App` as
-        follows::
-
-            import wx
-            app = wx.App(redirect=False, clearSigInt=False)
-        """
+        Parameters 
+        ---------- 
+        app : WX Application, optional. 
+            Running application to use.  If not given, we probe WX for an 
+            existing application object, and create a new one if none is found. 
+ 
+        Notes 
+        ----- 
+        This methods sets the ``PyOS_InputHook`` for wxPython, which allows 
+        the wxPython to integrate with terminal based applications like 
+        IPython. 
+ 
+        If ``app`` is not given we probe for an existing one, and return it if 
+        found.  If no existing app is found, we create an :class:`wx.App` as 
+        follows:: 
+ 
+            import wx 
+            app = wx.App(redirect=False, clearSigInt=False) 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        import wx
-        
-        wx_version = V(wx.__version__).version
-        
-        if wx_version < [2, 8]:
-            raise ValueError("requires wxPython >= 2.8, but you have %s" % wx.__version__)
-        
-        from IPython.lib.inputhookwx import inputhook_wx
-        self.manager.set_inputhook(inputhook_wx)
-        if _use_appnope():
-            from appnope import nope
-            nope()
-
-        import wx
-        if app is None:
-            app = wx.GetApp()
-        if app is None:
-            app = wx.App(redirect=False, clearSigInt=False)
-
-        return app
-
-    def disable(self):
+        import wx 
+         
+        wx_version = V(wx.__version__).version 
+         
+        if wx_version < [2, 8]: 
+            raise ValueError("requires wxPython >= 2.8, but you have %s" % wx.__version__) 
+         
+        from IPython.lib.inputhookwx import inputhook_wx 
+        self.manager.set_inputhook(inputhook_wx) 
+        if _use_appnope(): 
+            from appnope import nope 
+            nope() 
+ 
+        import wx 
+        if app is None: 
+            app = wx.GetApp() 
+        if app is None: 
+            app = wx.App(redirect=False, clearSigInt=False) 
+ 
+        return app 
+ 
+    def disable(self): 
         """DEPRECATED since IPython 5.0
-
+ 
         Disable event loop integration with wxPython.
 
-        This restores appnapp on OS X
-        """
+        This restores appnapp on OS X 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        if _use_appnope():
-            from appnope import nap
-            nap()
-
-@inputhook_manager.register('qt', 'qt4')
-class Qt4InputHook(InputHookBase):
-    def enable(self, app=None):
+        if _use_appnope(): 
+            from appnope import nap 
+            nap() 
+ 
+@inputhook_manager.register('qt', 'qt4') 
+class Qt4InputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
 
         Enable event loop integration with PyQt4.
-        
-        Parameters
-        ----------
-        app : Qt Application, optional.
-            Running application to use.  If not given, we probe Qt for an
-            existing application object, and create a new one if none is found.
-
-        Notes
-        -----
-        This methods sets the PyOS_InputHook for PyQt4, which allows
-        the PyQt4 to integrate with terminal based applications like
-        IPython.
-
-        If ``app`` is not given we probe for an existing one, and return it if
-        found.  If no existing app is found, we create an :class:`QApplication`
-        as follows::
-
-            from PyQt4 import QtCore
-            app = QtGui.QApplication(sys.argv)
-        """
+         
+        Parameters 
+        ---------- 
+        app : Qt Application, optional. 
+            Running application to use.  If not given, we probe Qt for an 
+            existing application object, and create a new one if none is found. 
+ 
+        Notes 
+        ----- 
+        This methods sets the PyOS_InputHook for PyQt4, which allows 
+        the PyQt4 to integrate with terminal based applications like 
+        IPython. 
+ 
+        If ``app`` is not given we probe for an existing one, and return it if 
+        found.  If no existing app is found, we create an :class:`QApplication` 
+        as follows:: 
+ 
+            from PyQt4 import QtCore 
+            app = QtGui.QApplication(sys.argv) 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        from IPython.lib.inputhookqt4 import create_inputhook_qt4
-        app, inputhook_qt4 = create_inputhook_qt4(self.manager, app)
-        self.manager.set_inputhook(inputhook_qt4)
-        if _use_appnope():
-            from appnope import nope
-            nope()
-
-        return app
-
-    def disable_qt4(self):
+        from IPython.lib.inputhookqt4 import create_inputhook_qt4 
+        app, inputhook_qt4 = create_inputhook_qt4(self.manager, app) 
+        self.manager.set_inputhook(inputhook_qt4) 
+        if _use_appnope(): 
+            from appnope import nope 
+            nope() 
+ 
+        return app 
+ 
+    def disable_qt4(self): 
         """DEPRECATED since IPython 5.0
-
+ 
         Disable event loop integration with PyQt4.
 
-        This restores appnapp on OS X
-        """
+        This restores appnapp on OS X 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        if _use_appnope():
-            from appnope import nap
-            nap()
-
-
-@inputhook_manager.register('qt5')
-class Qt5InputHook(Qt4InputHook):
-    def enable(self, app=None):
+        if _use_appnope(): 
+            from appnope import nap 
+            nap() 
+ 
+ 
+@inputhook_manager.register('qt5') 
+class Qt5InputHook(Qt4InputHook): 
+    def enable(self, app=None): 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        os.environ['QT_API'] = 'pyqt5'
-        return Qt4InputHook.enable(self, app)
-
-
-@inputhook_manager.register('gtk')
-class GtkInputHook(InputHookBase):
-    def enable(self, app=None):
+        os.environ['QT_API'] = 'pyqt5' 
+        return Qt4InputHook.enable(self, app) 
+ 
+ 
+@inputhook_manager.register('gtk') 
+class GtkInputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Enable event loop integration with PyGTK.
 
-        Parameters
-        ----------
-        app : ignored
-           Ignored, it's only a placeholder to keep the call signature of all
-           gui activation methods consistent, which simplifies the logic of
-           supporting magics.
-
-        Notes
-        -----
-        This methods sets the PyOS_InputHook for PyGTK, which allows
-        the PyGTK to integrate with terminal based applications like
-        IPython.
-        """
+        Parameters 
+        ---------- 
+        app : ignored 
+           Ignored, it's only a placeholder to keep the call signature of all 
+           gui activation methods consistent, which simplifies the logic of 
+           supporting magics. 
+ 
+        Notes 
+        ----- 
+        This methods sets the PyOS_InputHook for PyGTK, which allows 
+        the PyGTK to integrate with terminal based applications like 
+        IPython. 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        import gtk
-        try:
-            gtk.set_interactive(True)
-        except AttributeError:
-            # For older versions of gtk, use our own ctypes version
-            from IPython.lib.inputhookgtk import inputhook_gtk
-            self.manager.set_inputhook(inputhook_gtk)
-
-
-@inputhook_manager.register('tk')
-class TkInputHook(InputHookBase):
-    def enable(self, app=None):
+        import gtk 
+        try: 
+            gtk.set_interactive(True) 
+        except AttributeError: 
+            # For older versions of gtk, use our own ctypes version 
+            from IPython.lib.inputhookgtk import inputhook_gtk 
+            self.manager.set_inputhook(inputhook_gtk) 
+ 
+ 
+@inputhook_manager.register('tk') 
+class TkInputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Enable event loop integration with Tk.
 
-        Parameters
-        ----------
-        app : toplevel :class:`Tkinter.Tk` widget, optional.
-            Running toplevel widget to use.  If not given, we probe Tk for an
-            existing one, and create a new one if none is found.
-
-        Notes
-        -----
-        If you have already created a :class:`Tkinter.Tk` object, the only
-        thing done by this method is to register with the
-        :class:`InputHookManager`, since creating that object automatically
-        sets ``PyOS_InputHook``.
-        """
+        Parameters 
+        ---------- 
+        app : toplevel :class:`Tkinter.Tk` widget, optional. 
+            Running toplevel widget to use.  If not given, we probe Tk for an 
+            existing one, and create a new one if none is found. 
+ 
+        Notes 
+        ----- 
+        If you have already created a :class:`Tkinter.Tk` object, the only 
+        thing done by this method is to register with the 
+        :class:`InputHookManager`, since creating that object automatically 
+        sets ``PyOS_InputHook``. 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        if app is None:
-            try:
-                from tkinter import Tk  # Py 3
-            except ImportError:
-                from Tkinter import Tk  # Py 2
-            app = Tk()
-            app.withdraw()
-            self.manager.apps[GUI_TK] = app
-            return app
-
-
-@inputhook_manager.register('glut')
-class GlutInputHook(InputHookBase):
-    def enable(self, app=None):
+        if app is None: 
+            try: 
+                from tkinter import Tk  # Py 3 
+            except ImportError: 
+                from Tkinter import Tk  # Py 2 
+            app = Tk() 
+            app.withdraw() 
+            self.manager.apps[GUI_TK] = app 
+            return app 
+ 
+ 
+@inputhook_manager.register('glut') 
+class GlutInputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Enable event loop integration with GLUT.
 
-        Parameters
-        ----------
-
-        app : ignored
-            Ignored, it's only a placeholder to keep the call signature of all
-            gui activation methods consistent, which simplifies the logic of
-            supporting magics.
-
-        Notes
-        -----
-
-        This methods sets the PyOS_InputHook for GLUT, which allows the GLUT to
-        integrate with terminal based applications like IPython. Due to GLUT
-        limitations, it is currently not possible to start the event loop
-        without first creating a window. You should thus not create another
-        window but use instead the created one. See 'gui-glut.py' in the
-        docs/examples/lib directory.
-        
-        The default screen mode is set to:
-        glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH
-        """
+        Parameters 
+        ---------- 
+ 
+        app : ignored 
+            Ignored, it's only a placeholder to keep the call signature of all 
+            gui activation methods consistent, which simplifies the logic of 
+            supporting magics. 
+ 
+        Notes 
+        ----- 
+ 
+        This methods sets the PyOS_InputHook for GLUT, which allows the GLUT to 
+        integrate with terminal based applications like IPython. Due to GLUT 
+        limitations, it is currently not possible to start the event loop 
+        without first creating a window. You should thus not create another 
+        window but use instead the created one. See 'gui-glut.py' in the 
+        docs/examples/lib directory. 
+         
+        The default screen mode is set to: 
+        glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-
-        import OpenGL.GLUT as glut
-        from IPython.lib.inputhookglut import glut_display_mode, \
-                                              glut_close, glut_display, \
-                                              glut_idle, inputhook_glut
-
-        if GUI_GLUT not in self.manager.apps:
-            glut.glutInit( sys.argv )
-            glut.glutInitDisplayMode( glut_display_mode )
-            # This is specific to freeglut
-            if bool(glut.glutSetOption):
-                glut.glutSetOption( glut.GLUT_ACTION_ON_WINDOW_CLOSE,
-                                    glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS )
-            glut.glutCreateWindow( sys.argv[0] )
-            glut.glutReshapeWindow( 1, 1 )
-            glut.glutHideWindow( )
-            glut.glutWMCloseFunc( glut_close )
-            glut.glutDisplayFunc( glut_display )
-            glut.glutIdleFunc( glut_idle )
-        else:
-            glut.glutWMCloseFunc( glut_close )
-            glut.glutDisplayFunc( glut_display )
-            glut.glutIdleFunc( glut_idle)
-        self.manager.set_inputhook( inputhook_glut )
-
-
-    def disable(self):
+ 
+        import OpenGL.GLUT as glut 
+        from IPython.lib.inputhookglut import glut_display_mode, \ 
+                                              glut_close, glut_display, \ 
+                                              glut_idle, inputhook_glut 
+ 
+        if GUI_GLUT not in self.manager.apps: 
+            glut.glutInit( sys.argv ) 
+            glut.glutInitDisplayMode( glut_display_mode ) 
+            # This is specific to freeglut 
+            if bool(glut.glutSetOption): 
+                glut.glutSetOption( glut.GLUT_ACTION_ON_WINDOW_CLOSE, 
+                                    glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS ) 
+            glut.glutCreateWindow( sys.argv[0] ) 
+            glut.glutReshapeWindow( 1, 1 ) 
+            glut.glutHideWindow( ) 
+            glut.glutWMCloseFunc( glut_close ) 
+            glut.glutDisplayFunc( glut_display ) 
+            glut.glutIdleFunc( glut_idle ) 
+        else: 
+            glut.glutWMCloseFunc( glut_close ) 
+            glut.glutDisplayFunc( glut_display ) 
+            glut.glutIdleFunc( glut_idle) 
+        self.manager.set_inputhook( inputhook_glut ) 
+ 
+ 
+    def disable(self): 
         """DEPRECATED since IPython 5.0
 
         Disable event loop integration with glut.
-        
-        This sets PyOS_InputHook to NULL and set the display function to a
-        dummy one and set the timer to a dummy timer that will be triggered
-        very far in the future.
-        """
+         
+        This sets PyOS_InputHook to NULL and set the display function to a 
+        dummy one and set the timer to a dummy timer that will be triggered 
+        very far in the future. 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        import OpenGL.GLUT as glut
-        from glut_support import glutMainLoopEvent
-
-        glut.glutHideWindow() # This is an event to be processed below
-        glutMainLoopEvent()
-        super(GlutInputHook, self).disable()
-
-@inputhook_manager.register('pyglet')
-class PygletInputHook(InputHookBase):
-    def enable(self, app=None):
+        import OpenGL.GLUT as glut 
+        from glut_support import glutMainLoopEvent 
+ 
+        glut.glutHideWindow() # This is an event to be processed below 
+        glutMainLoopEvent() 
+        super(GlutInputHook, self).disable() 
+ 
+@inputhook_manager.register('pyglet') 
+class PygletInputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Enable event loop integration with pyglet.
 
-        Parameters
-        ----------
-        app : ignored
-           Ignored, it's only a placeholder to keep the call signature of all
-           gui activation methods consistent, which simplifies the logic of
-           supporting magics.
-
-        Notes
-        -----
-        This methods sets the ``PyOS_InputHook`` for pyglet, which allows
-        pyglet to integrate with terminal based applications like
-        IPython.
-
-        """
+        Parameters 
+        ---------- 
+        app : ignored 
+           Ignored, it's only a placeholder to keep the call signature of all 
+           gui activation methods consistent, which simplifies the logic of 
+           supporting magics. 
+ 
+        Notes 
+        ----- 
+        This methods sets the ``PyOS_InputHook`` for pyglet, which allows 
+        pyglet to integrate with terminal based applications like 
+        IPython. 
+ 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        from IPython.lib.inputhookpyglet import inputhook_pyglet
-        self.manager.set_inputhook(inputhook_pyglet)
-        return app
-
-
-@inputhook_manager.register('gtk3')
-class Gtk3InputHook(InputHookBase):
-    def enable(self, app=None):
+        from IPython.lib.inputhookpyglet import inputhook_pyglet 
+        self.manager.set_inputhook(inputhook_pyglet) 
+        return app 
+ 
+ 
+@inputhook_manager.register('gtk3') 
+class Gtk3InputHook(InputHookBase): 
+    def enable(self, app=None): 
         """DEPRECATED since IPython 5.0
-
+ 
         Enable event loop integration with Gtk3 (gir bindings).
 
-        Parameters
-        ----------
-        app : ignored
-           Ignored, it's only a placeholder to keep the call signature of all
-           gui activation methods consistent, which simplifies the logic of
-           supporting magics.
-
-        Notes
-        -----
-        This methods sets the PyOS_InputHook for Gtk3, which allows
-        the Gtk3 to integrate with terminal based applications like
-        IPython.
-        """
+        Parameters 
+        ---------- 
+        app : ignored 
+           Ignored, it's only a placeholder to keep the call signature of all 
+           gui activation methods consistent, which simplifies the logic of 
+           supporting magics. 
+ 
+        Notes 
+        ----- 
+        This methods sets the PyOS_InputHook for Gtk3, which allows 
+        the Gtk3 to integrate with terminal based applications like 
+        IPython. 
+        """ 
         warn("This function is deprecated since IPython 5.0 and will be removed in future versions.",
                 DeprecationWarning, stacklevel=2)
-        from IPython.lib.inputhookgtk3 import inputhook_gtk3
-        self.manager.set_inputhook(inputhook_gtk3)
-
-
-clear_inputhook = inputhook_manager.clear_inputhook
-set_inputhook = inputhook_manager.set_inputhook
-current_gui = inputhook_manager.current_gui
-clear_app_refs = inputhook_manager.clear_app_refs
-enable_gui = inputhook_manager.enable_gui
-disable_gui = inputhook_manager.disable_gui
-register = inputhook_manager.register
-guis = inputhook_manager.guihooks
-
-
-def _deprecated_disable():
+        from IPython.lib.inputhookgtk3 import inputhook_gtk3 
+        self.manager.set_inputhook(inputhook_gtk3) 
+ 
+ 
+clear_inputhook = inputhook_manager.clear_inputhook 
+set_inputhook = inputhook_manager.set_inputhook 
+current_gui = inputhook_manager.current_gui 
+clear_app_refs = inputhook_manager.clear_app_refs 
+enable_gui = inputhook_manager.enable_gui 
+disable_gui = inputhook_manager.disable_gui 
+register = inputhook_manager.register 
+guis = inputhook_manager.guihooks 
+ 
+ 
+def _deprecated_disable(): 
     warn("This function is deprecated since IPython 4.0 use disable_gui() instead",
             DeprecationWarning, stacklevel=2)
-    inputhook_manager.disable_gui()
+    inputhook_manager.disable_gui() 
     
-disable_wx = disable_qt4 = disable_gtk = disable_gtk3 = disable_glut = \
-        disable_pyglet = disable_osx = _deprecated_disable
+disable_wx = disable_qt4 = disable_gtk = disable_gtk3 = disable_glut = \ 
+        disable_pyglet = disable_osx = _deprecated_disable