Merge pull request #9685 from Carreau/no-rl-2

Remove readline , Pass II

IPython/core/completer.py

@@ -1,50 +1,10 b''
 # encoding: utf-8
 """Word completion for IPython.
 
-This module is a fork of the rlcompleter module in the Python standard
+This module started as fork of the rlcompleter module in the Python standard
 library.  The original enhancements made to rlcompleter have been sent
-upstream and were accepted as of Python 2.3, but we need a lot more
-functionality specific to IPython, so this module will continue to live as an
-IPython-specific utility.
+upstream and were accepted as of Python 2.3,
 
-Original rlcompleter documentation:
-
-This requires the latest extension to the readline module (the
-completes keywords, built-ins and globals in __main__; when completing
-NAME.NAME..., it evaluates (!) the expression up to the last dot and
-completes its attributes.
-
-It's very cool to do "import string" type "string.", hit the
-completion key (twice), and see the list of names defined by the
-string module!
-
-Tip: to use the tab key as the completion key, call
-
-    readline.parse_and_bind("tab: complete")
-
-Notes:
-
-- Exceptions raised by the completer function are *ignored* (and
-  generally cause the completion to fail).  This is a feature -- since
-  readline sets the tty device in raw (or cbreak) mode, printing a
-  traceback wouldn't work well without some complicated hoopla to save,
-  reset and restore the tty state.
-
-- The evaluation of the NAME.NAME... form may cause arbitrary
-  application defined code to be executed if an object with a
-  ``__getattr__`` hook is found.  Since it is the responsibility of the
-  application (or the user) to enable this feature, I consider this an
-  acceptable risk.  More complicated expressions (e.g. function calls or
-  indexing operations) are *not* evaluated.
-
-- GNU readline is also used by the built-in functions input() and
-  raw_input(), and thus these also benefit/suffer from the completer
-  features.  Clearly an interactive application can benefit by
-  specifying its own completer function and using raw_input() for all
-  its input.
-
-- When the original stdin is not a tty device, GNU readline is never
-  used, and this module (and the readline module) are silently inactive.
 """
 
 # Copyright (c) IPython Development Team.
@@ -1252,66 +1212,3 b' class IPCompleter(Completer):'
         self.matches = sorted(set(self.matches), key=completions_sorting_key)
 
         return text, self.matches
-
-    def rlcomplete(self, text, state):
-        """Return the state-th possible completion for 'text'.
-
-        This is called successively with state == 0, 1, 2, ... until it
-        returns None.  The completion should begin with 'text'.
-
-        Parameters
-        ----------
-          text : string
-            Text to perform the completion on.
-
-          state : int
-            Counter used by readline.
-        """
-        if state==0:
-
-            self.line_buffer = line_buffer = self.readline.get_line_buffer()
-            cursor_pos = self.readline.get_endidx()
-
-            #io.rprint("\nRLCOMPLETE: %r %r %r" %
-            #          (text, line_buffer, cursor_pos) ) # dbg
-
-            # if there is only a tab on a line with only whitespace, instead of
-            # the mostly useless 'do you want to see all million completions'
-            # message, just do the right thing and give the user his tab!
-            # Incidentally, this enables pasting of tabbed text from an editor
-            # (as long as autoindent is off).
-
-            # It should be noted that at least pyreadline still shows file
-            # completions - is there a way around it?
-
-            # don't apply this on 'dumb' terminals, such as emacs buffers, so
-            # we don't interfere with their own tab-completion mechanism.
-            if not (self.dumb_terminal or line_buffer.strip()):
-                self.readline.insert_text('\t')
-                sys.stdout.flush()
-                return None
-
-            # Note: debugging exceptions that may occur in completion is very
-            # tricky, because readline unconditionally silences them.  So if
-            # during development you suspect a bug in the completion code, turn
-            # this flag on temporarily by uncommenting the second form (don't
-            # flip the value in the first line, as the '# dbg' marker can be
-            # automatically detected and is used elsewhere).
-            DEBUG = False
-            #DEBUG = True # dbg
-            if DEBUG:
-                try:
-                    self.complete(text, line_buffer, cursor_pos)
-                except:
-                    import traceback; traceback.print_exc()
-            else:
-                # The normal production version is here
-
-                # This method computes the self.matches array
-                self.complete(text, line_buffer, cursor_pos)
-
-        try:
-            return self.matches[state]
-        except IndexError:
-            return None
-

IPython/core/interactiveshell.py

@@ -62,7 +62,6 b' from IPython.utils import PyColorize'
 from IPython.utils import io
 from IPython.utils import py3compat
 from IPython.utils import openpy
-from IPython.utils.contexts import NoOpContext
 from IPython.utils.decorators import undoc
 from IPython.utils.io import ask_yes_no
 from IPython.utils.ipstruct import Struct
@@ -343,9 +342,6 b' class InteractiveShell(SingletonConfigurable):'
         Automatically call the pdb debugger after every exception.
         """
     ).tag(config=True)
-    multiline_history = Bool(sys.platform != 'win32',
-        help="Save multi-line entries as one entry in readline history"
-    ).tag(config=True)
     display_page = Bool(False,
         help="""If True, anything that would be passed to the pager
         will be displayed as regular output instead."""
@@ -387,40 +383,10 b' class InteractiveShell(SingletonConfigurable):'
     history_load_length = Integer(1000, help=
         """
         The number of saved history entries to be loaded
-        into the readline buffer at startup.
+        into the history buffer at startup.
         """
     ).tag(config=True)
 
-    # The readline stuff will eventually be moved to the terminal subclass
-    # but for now, we can't do that as readline is welded in everywhere.
-    readline_use = Bool(True).tag(config=True)
-    readline_remove_delims = Unicode('-/~').tag(config=True)
-    readline_delims = Unicode() # set by init_readline()
-    # don't use \M- bindings by default, because they
-    # conflict with 8-bit encodings. See gh-58,gh-88
-    readline_parse_and_bind = List([
-            'tab: complete',
-            '"\C-l": clear-screen',
-            'set show-all-if-ambiguous on',
-            '"\C-o": tab-insert',
-            '"\C-r": reverse-search-history',
-            '"\C-s": forward-search-history',
-            '"\C-p": history-search-backward',
-            '"\C-n": history-search-forward',
-            '"\e[A": history-search-backward',
-            '"\e[B": history-search-forward',
-            '"\C-k": kill-line',
-            '"\C-u": unix-line-discard',
-        ]).tag(config=True)
-    
-    _custom_readline_config = False
-    
-    @observe('readline_parse_and_bind')
-    def _readline_parse_and_bind_changed(self, change):
-        # notice that readline config is customized
-        # indicates that it should have higher priority than inputrc
-        self._custom_readline_config = True
-    
     ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
                                   default_value='last_expr',
                                   help="""
@@ -607,9 +573,6 b' class InteractiveShell(SingletonConfigurable):'
         self.tempfiles = []
         self.tempdirs = []
 
-        # Keep track of readline usage (later set by init_readline)
-        self.has_readline = False
-
         # keep track of where we started running (mainly for crash post-mortem)
         # This is not being used anywhere currently.
         self.starting_dir = py3compat.getcwd()
@@ -692,11 +655,8 b' class InteractiveShell(SingletonConfigurable):'
         # override sys.stdout and sys.stderr themselves, you need to do that
         # *before* instantiating this class, because io holds onto
         # references to the underlying streams.
-        if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
-            io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
-        else:
-            io.stdout = io.IOStream(sys.stdout)
-            io.stderr = io.IOStream(sys.stderr)
+        io.stdout = io.IOStream(sys.stdout)
+        io.stderr = io.IOStream(sys.stderr)
 
     def init_prompts(self):
         # Set system prompts, so that scripts can decide if they are running
@@ -1017,9 +977,7 b' class InteractiveShell(SingletonConfigurable):'
             error('No traceback has been produced, nothing to debug.')
             return
 
-
-        with self.readline_no_record:
-            self.InteractiveTB.debugger(force=True)
+        self.InteractiveTB.debugger(force=True)
 
     #-------------------------------------------------------------------------
     # Things related to IPython's various namespaces
@@ -1921,11 +1879,12 b' class InteractiveShell(SingletonConfigurable):'
     #-------------------------------------------------------------------------
 
     def init_readline(self):
-        """Moved to terminal subclass, here only to simplify the init logic."""
-        self.readline = None
+        """DEPRECATED
+        
+        Moved to terminal subclass, here only to simplify the init logic."""
         # Set a number of methods that depend on readline to be no-op
-        self.readline_no_record = NoOpContext()
-        self.set_readline_completer = no_op
+        warnings.warn('`init_readline` is no-op since IPython 5.0 and is Deprecated',
+                DeprecationWarning, stacklevel=2)
         self.set_custom_completer = no_op
 
     @skip_doctest
@@ -1962,7 +1921,7 b' class InteractiveShell(SingletonConfigurable):'
         self.Completer = IPCompleter(shell=self,
                                      namespace=self.user_ns,
                                      global_namespace=self.user_global_ns,
-                                     use_readline=self.has_readline,
+                                     use_readline=False,
                                      parent=self,
                                      )
         self.configurables.append(self.Completer)

IPython/core/magics/execution.py

@@ -705,55 +705,54 b' python-profiler package from non-free.""")'
 
         try:
             stats = None
-            with self.shell.readline_no_record:
-                if 'p' in opts:
-                    stats = self._run_with_profiler(code, opts, code_ns)
+            if 'p' in opts:
+                stats = self._run_with_profiler(code, opts, code_ns)
+            else:
+                if 'd' in opts:
+                    bp_file, bp_line = parse_breakpoint(
+                        opts.get('b', ['1'])[0], filename)
+                    self._run_with_debugger(
+                        code, code_ns, filename, bp_line, bp_file)
                 else:
-                    if 'd' in opts:
-                        bp_file, bp_line = parse_breakpoint(
-                            opts.get('b', ['1'])[0], filename)
-                        self._run_with_debugger(
-                            code, code_ns, filename, bp_line, bp_file)
+                    if 'm' in opts:
+                        def run():
+                            self.shell.safe_run_module(modulename, prog_ns)
                     else:
-                        if 'm' in opts:
-                            def run():
-                                self.shell.safe_run_module(modulename, prog_ns)
-                        else:
-                            if runner is None:
-                                runner = self.default_runner
-                            if runner is None:
-                                runner = self.shell.safe_execfile
-
-                            def run():
-                                runner(filename, prog_ns, prog_ns,
-                                       exit_ignore=exit_ignore)
-
-                        if 't' in opts:
-                            # timed execution
-                            try:
-                                nruns = int(opts['N'][0])
-                                if nruns < 1:
-                                    error('Number of runs must be >=1')
-                                    return
-                            except (KeyError):
-                                nruns = 1
-                            self._run_with_timing(run, nruns)
-                        else:
-                            # regular execution
-                            run()
-
-                if 'i' in opts:
-                    self.shell.user_ns['__name__'] = __name__save
-                else:
-                    # update IPython interactive namespace
+                        if runner is None:
+                            runner = self.default_runner
+                        if runner is None:
+                            runner = self.shell.safe_execfile
+
+                        def run():
+                            runner(filename, prog_ns, prog_ns,
+                                    exit_ignore=exit_ignore)
+
+                    if 't' in opts:
+                        # timed execution
+                        try:
+                            nruns = int(opts['N'][0])
+                            if nruns < 1:
+                                error('Number of runs must be >=1')
+                                return
+                        except (KeyError):
+                            nruns = 1
+                        self._run_with_timing(run, nruns)
+                    else:
+                        # regular execution
+                        run()
+
+            if 'i' in opts:
+                self.shell.user_ns['__name__'] = __name__save
+            else:
+                # update IPython interactive namespace
 
-                    # Some forms of read errors on the file may mean the
-                    # __name__ key was never set; using pop we don't have to
-                    # worry about a possible KeyError.
-                    prog_ns.pop('__name__', None)
+                # Some forms of read errors on the file may mean the
+                # __name__ key was never set; using pop we don't have to
+                # worry about a possible KeyError.
+                prog_ns.pop('__name__', None)
 
-                    with preserve_keys(self.shell.user_ns, '__file__'):
-                        self.shell.user_ns.update(prog_ns)
+                with preserve_keys(self.shell.user_ns, '__file__'):
+                    self.shell.user_ns.update(prog_ns)
         finally:
             # It's a bit of a mystery why, but __builtins__ can change from
             # being a module to becoming a dict missing some key data after

IPython/core/shellapp.py

@@ -343,12 +343,6 b' class InteractiveShellApp(Configurable):'
             except:
                 self.log.warning("Unknown error in handling PYTHONSTARTUP file %s:", python_startup)
                 self.shell.showtraceback()
-            finally:
-                # Many PYTHONSTARTUP files set up the readline completions,
-                # but this is often at odds with IPython's own completions.
-                # Do not allow PYTHONSTARTUP to set up readline.
-                if self.shell.has_readline:
-                    self.shell.set_readline_completer()
         
         startup_files += glob.glob(os.path.join(startup_dir, '*.py'))
         startup_files += glob.glob(os.path.join(startup_dir, '*.ipy'))

IPython/core/ultratb.py

@@ -115,7 +115,6 b' from inspect import getsourcefile, getfile, getmodule, \\'
     ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode
 
 # IPython's own modules
-# Modified pdb which doesn't damage IPython's readline handling
 from IPython import get_ipython
 from IPython.core import debugger
 from IPython.core.display_trap import DisplayTrap

IPython/core/usage.py

@@ -109,12 +109,9 b' MAIN FEATURES'
   variable names, and show you a list of the possible completions if there's
   no unambiguous one. It will also complete filenames in the current directory.
 
-  This feature requires the readline and rlcomplete modules, so it won't work
-  if your Python lacks readline support (such as under Windows).
+* Search previous command history in two ways:
 
-* Search previous command history in two ways (also requires readline):
-
-  - Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to
+  - Start typing, and then use Ctrl-p (previous, up) and Ctrl-n (next,down) to
     search through only the history items that match what you've typed so
     far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like
     normal arrow keys.
@@ -123,7 +120,7 b' MAIN FEATURES'
     your history for lines that match what you've typed so far, completing as
     much as it can.
 
-  - %hist: search history by index (this does *not* require readline).
+  - %hist: search history by index.
 
 * Persistent command history across sessions.
 
@@ -255,7 +252,6 b' MAIN FEATURES'
 interactive_usage_min =  """\
 An enhanced console for Python.
 Some of its features are:
-- Readline support if the readline library is present.
 - Tab completion in the local namespace.
 - Logging of input, see command-line options.
 - System shell escape via ! , eg !ls.

IPython/terminal/embed.py

@@ -140,9 +140,6 b' class InteractiveShellEmbed(TerminalInteractiveShell):'
         if dummy or (dummy != 0 and self.dummy_mode):
             return
 
-        if self.has_readline:
-            self.set_readline_completer()
-
         # self.banner is auto computed
         if header:
             self.old_banner2 = self.banner2

IPython/utils/contexts.py

@@ -2,6 +2,8 b''
 """Miscellaneous context managers.
 """
 
+import warnings
+
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
@@ -59,6 +61,14 b' class preserve_keys(object):'
 
 
 class NoOpContext(object):
-    """Context manager that does nothing."""
+    """
+    Deprecated
+    
+    Context manager that does nothing."""
+
+    def __init__(self):
+        warnings.warn("""NoOpContext is deprecated since IPython 5.0 """,
+                                            DeprecationWarning, stacklevel=2)
+
     def __enter__(self): pass
     def __exit__(self, type, value, traceback): pass

setup.py

@@ -220,20 +220,8 b" if not any(arg.startswith('bdist') for arg in sys.argv):"
 
     if sys.platform == 'darwin':
         install_requires.extend(['appnope'])
-        have_readline = False
-        try:
-            import readline
-        except ImportError:
-            pass
-        else:
-            if 'libedit' not in readline.__doc__:
-                have_readline = True
-        if not have_readline:
-            install_requires.extend(['gnureadline'])
-
-    if sys.platform.startswith('win'):
-        extras_require['terminal'].append('pyreadline>=2.0')
-    else:
+
+    if not sys.platform.startswith('win'):
         install_requires.append('pexpect')
 
     # workaround pypa/setuptools#147, where setuptools misspells