IPython/core/completer.py

"""Word completion for IPython.

This module is a 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.

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.
"""

#*****************************************************************************
#
# Since this file is essentially a minimally modified copy of the rlcompleter
# module which is part of the standard Python distribution, I assume that the
# proper procedure is to maintain its copyright as belonging to the Python
# Software Foundation (in addition to my own, for all new code).
#
#       Copyright (C) 2008-2010 IPython Development Team
#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
#       Copyright (C) 2001 Python Software Foundation, www.python.org
#
#  Distributed under the terms of the BSD License.  The full license is in
#  the file COPYING, distributed as part of this software.
#
#*****************************************************************************

#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------

import __builtin__
import __main__
import glob
import inspect
import itertools
import keyword
import os
import re
import shlex
import sys

from IPython.core.error import TryNext
from IPython.core.prefilter import ESC_MAGIC
from IPython.utils import generics
from IPython.utils.frame import debugx
from IPython.utils.dir2 import dir2
import IPython.utils.rlineimpl as readline

#-----------------------------------------------------------------------------
# Globals
#-----------------------------------------------------------------------------

# Public API
__all__ = ['Completer','IPCompleter']

if sys.platform == 'win32':
    PROTECTABLES = ' '
else:
    PROTECTABLES = ' ()'

#-----------------------------------------------------------------------------
# Main functions and classes
#-----------------------------------------------------------------------------

def protect_filename(s):
    """Escape a string to protect certain characters."""
    
    return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
                    for ch in s])


def single_dir_expand(matches):
    "Recursively expand match lists containing a single dir."

    if len(matches) == 1 and os.path.isdir(matches[0]):
        # Takes care of links to directories also.  Use '/'
        # explicitly, even under Windows, so that name completions
        # don't end up escaped.
        d = matches[0]
        if d[-1] in ['/','\\']:
            d = d[:-1]

        subdirs = os.listdir(d)
        if subdirs:
            matches = [ (d + '/' + p) for p in subdirs]
            return single_dir_expand(matches)
        else:
            return matches
    else:
        return matches

class Bunch: pass

class Completer:
    def __init__(self,namespace=None,global_namespace=None):
        """Create a new completer for the command line.

        Completer([namespace,global_namespace]) -> completer instance.

        If unspecified, the default namespace where completions are performed
        is __main__ (technically, __main__.__dict__). Namespaces should be
        given as dictionaries.

        An optional second namespace can be given.  This allows the completer
        to handle cases where both the local and global scopes need to be
        distinguished.

        Completer instances should be used as the completion mechanism of
        readline via the set_completer() call:

        readline.set_completer(Completer(my_namespace).complete)
        """

        # Don't bind to namespace quite yet, but flag whether the user wants a
        # specific namespace or to use __main__.__dict__. This will allow us
        # to bind to __main__.__dict__ at completion time, not now.
        if namespace is None:
            self.use_main_ns = 1
        else:
            self.use_main_ns = 0
            self.namespace = namespace

        # The global namespace, if given, can be bound directly
        if global_namespace is None:
            self.global_namespace = {}
        else:
            self.global_namespace = global_namespace

    def complete(self, text, state):
        """Return the next possible completion for 'text'.

        This is called successively with state == 0, 1, 2, ... until it
        returns None.  The completion should begin with 'text'.

        """
        if self.use_main_ns:
            self.namespace = __main__.__dict__
            
        if state == 0:
            if "." in text:
                self.matches = self.attr_matches(text)
            else:
                self.matches = self.global_matches(text)
        try:
            return self.matches[state]
        except IndexError:
            return None

    def global_matches(self, text):
        """Compute matches when text is a simple name.

        Return a list of all keywords, built-in functions and names currently
        defined in self.namespace or self.global_namespace that match.

        """
        #print 'Completer->global_matches, txt=%r' % text # dbg
        matches = []
        match_append = matches.append
        n = len(text)
        for lst in [keyword.kwlist,
                    __builtin__.__dict__.keys(),
                    self.namespace.keys(),
                    self.global_namespace.keys()]:
            for word in lst:
                if word[:n] == text and word != "__builtins__":
                    match_append(word)
        return matches

    def attr_matches(self, text):
        """Compute matches when text contains a dot.

        Assuming the text is of the form NAME.NAME....[NAME], and is
        evaluatable in self.namespace or self.global_namespace, it will be
        evaluated and its attributes (as revealed by dir()) are used as
        possible completions.  (For class instances, class members are are
        also considered.)

        WARNING: this can still invoke arbitrary C code, if an object
        with a __getattr__ hook is evaluated.

        """

        #print 'Completer->attr_matches, txt=%r' % text # dbg
        # Another option, seems to work great. Catches things like ''.<tab>
        m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)

        if not m:
            return []
        
        expr, attr = m.group(1, 3)
        try:
            obj = eval(expr, self.namespace)
        except:
            try:
                obj = eval(expr, self.global_namespace)
            except:
                return []

        words = dir2(obj)
        
        try:
            words = generics.complete_object(obj, words)
        except TryNext:
            pass
        # Build match list to return
        n = len(attr)
        res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
        return res


class IPCompleter(Completer):
    """Extension of the completer class with IPython-specific features"""

    def __init__(self,shell,namespace=None,global_namespace=None,
                 omit__names=0,alias_table=None):
        """IPCompleter() -> completer

        Return a completer object suitable for use by the readline library
        via readline.set_completer().

        Inputs:

        - shell: a pointer to the ipython shell itself.  This is needed
        because this completer knows about magic functions, and those can
        only be accessed via the ipython instance.

        - namespace: an optional dict where completions are performed.

        - global_namespace: secondary optional dict for completions, to
        handle cases (such as IPython embedded inside functions) where
        both Python scopes are visible.

        - The optional omit__names parameter sets the completer to omit the
        'magic' names (__magicname__) for python objects unless the text
        to be completed explicitly starts with one or more underscores.

        - If alias_table is supplied, it should be a dictionary of aliases
        to complete. """

        Completer.__init__(self,namespace,global_namespace)

        self.magic_escape = ESC_MAGIC
        self.readline = readline
        delims = self.readline.get_completer_delims()
        delims = delims.replace(self.magic_escape,'')
        self.readline.set_completer_delims(delims)
        self.get_line_buffer = self.readline.get_line_buffer
        self.get_endidx = self.readline.get_endidx
        self.omit__names = omit__names
        self.merge_completions = shell.readline_merge_completions
        self.shell = shell.shell
        if alias_table is None:
            alias_table = {}
        self.alias_table = alias_table
        # Regexp to split filenames with spaces in them
        self.space_name_re = re.compile(r'([^\\] )')
        # Hold a local ref. to glob.glob for speed
        self.glob = glob.glob

        # Determine if we are running on 'dumb' terminals, like (X)Emacs
        # buffers, to avoid completion problems.
        term = os.environ.get('TERM','xterm')
        self.dumb_terminal = term in ['dumb','emacs']
        
        # Special handling of backslashes needed in win32 platforms
        if sys.platform == "win32":
            self.clean_glob = self._clean_glob_win32
        else:
            self.clean_glob = self._clean_glob

        # All active matcher routines for completion
        self.matchers = [self.python_matches,
                         self.file_matches,
                         self.magic_matches,
                         self.alias_matches,
                         self.python_func_kw_matches]
    
    # Code contributed by Alex Schmolck, for ipython/emacs integration
    def all_completions(self, text):
        """Return all possible completions for the benefit of emacs."""

        completions = []
        comp_append = completions.append
        try:
            for i in xrange(sys.maxint):
                res = self.complete(text, i, text)
                if not res:
                    break
                comp_append(res)
        #XXX workaround for ``notDefined.<tab>``
        except NameError:
            pass
        return completions
    # /end Alex Schmolck code.

    def _clean_glob(self,text):
        return self.glob("%s*" % text)

    def _clean_glob_win32(self,text):
        return [f.replace("\\","/")
                for f in self.glob("%s*" % text)]            

    def file_matches(self, text):
        """Match filenames, expanding ~USER type strings.

        Most of the seemingly convoluted logic in this completer is an
        attempt to handle filenames with spaces in them.  And yet it's not
        quite perfect, because Python's readline doesn't expose all of the
        GNU readline details needed for this to be done correctly.

        For a filename with a space in it, the printed completions will be
        only the parts after what's already been typed (instead of the
        full completions, as is normally done).  I don't think with the
        current (as of Python 2.3) Python readline it's possible to do
        better."""

        #print 'Completer->file_matches: <%s>' % text # dbg

        # chars that require escaping with backslash - i.e. chars
        # that readline treats incorrectly as delimiters, but we
        # don't want to treat as delimiters in filename matching
        # when escaped with backslash

        if text.startswith('!'):
            text = text[1:]
            text_prefix = '!'
        else:
            text_prefix = ''
            
        lbuf = self.lbuf
        open_quotes = 0  # track strings with open quotes
        try:
            lsplit = shlex.split(lbuf)[-1]
        except ValueError:
            # typically an unmatched ", or backslash without escaped char.
            if lbuf.count('"')==1:
                open_quotes = 1
                lsplit = lbuf.split('"')[-1]
            elif lbuf.count("'")==1:
                open_quotes = 1
                lsplit = lbuf.split("'")[-1]
            else:
                return []
        except IndexError:
            # tab pressed on empty line
            lsplit = ""

        if lsplit != protect_filename(lsplit):
            # if protectables are found, do matching on the whole escaped
            # name
            has_protectables = 1
            text0,text = text,lsplit
        else:
            has_protectables = 0
            text = os.path.expanduser(text)

        if text == "":
            return [text_prefix + protect_filename(f) for f in self.glob("*")]

        m0 = self.clean_glob(text.replace('\\',''))
        if has_protectables:
            # If we had protectables, we need to revert our changes to the
            # beginning of filename so that we don't double-write the part
            # of the filename we have so far
            len_lsplit = len(lsplit)
            matches = [text_prefix + text0 + 
                       protect_filename(f[len_lsplit:]) for f in m0]
        else:
            if open_quotes:
                # if we have a string with an open quote, we don't need to
                # protect the names at all (and we _shouldn't_, as it
                # would cause bugs when the filesystem call is made).
                matches = m0
            else:
                matches = [text_prefix + 
                           protect_filename(f) for f in m0]

        #print 'mm',matches  # dbg
        return single_dir_expand(matches)

    def magic_matches(self, text):
        """Match magics"""
        #print 'Completer->magic_matches:',text,'lb',self.lbuf # dbg
        # Get all shell magics now rather than statically, so magics loaded at
        # runtime show up too
        magics = self.shell.lsmagic()
        pre = self.magic_escape
        baretext = text.lstrip(pre)
        return [ pre+m for m in magics if m.startswith(baretext)]

    def alias_matches(self, text):
        """Match internal system aliases"""        
        #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
        
        # if we are not in the first 'item', alias matching 
        # doesn't make sense - unless we are starting with 'sudo' command.
        if ' ' in self.lbuf.lstrip() and \
               not self.lbuf.lstrip().startswith('sudo'):
            return []
        text = os.path.expanduser(text)
        aliases =  self.alias_table.keys()
        if text == "":
            return aliases
        else:
            return [alias for alias in aliases if alias.startswith(text)]

    def python_matches(self,text):
        """Match attributes or global python names"""

        #print 'Completer->python_matches, txt=%r' % text # dbg
        if "." in text:
            try:
                matches = self.attr_matches(text)
                if text.endswith('.') and self.omit__names:
                    if self.omit__names == 1:
                        # true if txt is _not_ a __ name, false otherwise:
                        no__name = (lambda txt:
                                    re.match(r'.*\.__.*?__',txt) is None)
                    else:
                        # true if txt is _not_ a _ name, false otherwise:
                        no__name = (lambda txt:
                                    re.match(r'.*\._.*?',txt) is None)
                    matches = filter(no__name, matches)
            except NameError:
                # catches <undefined attributes>.<tab>
                matches = []
        else:
            matches = self.global_matches(text)

        return matches

    def _default_arguments(self, obj):
        """Return the list of default arguments of obj if it is callable,
        or empty list otherwise."""

        if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
            # for classes, check for __init__,__new__
            if inspect.isclass(obj):
                obj = (getattr(obj,'__init__',None) or
                       getattr(obj,'__new__',None))
            # for all others, check if they are __call__able
            elif hasattr(obj, '__call__'):
                obj = obj.__call__
            # XXX: is there a way to handle the builtins ?
        try:
            args,_,_1,defaults = inspect.getargspec(obj)
            if defaults:
                return args[-len(defaults):]
        except TypeError: pass
        return []

    def python_func_kw_matches(self,text):
        """Match named parameters (kwargs) of the last open function"""

        if "." in text: # a parameter cannot be dotted
            return []
        try: regexp = self.__funcParamsRegex
        except AttributeError:
            regexp = self.__funcParamsRegex = re.compile(r'''
                '.*?' |    # single quoted strings or
                ".*?" |    # double quoted strings or
                \w+   |    # identifier
                \S         # other characters
                ''', re.VERBOSE | re.DOTALL)
        # 1. find the nearest identifier that comes before an unclosed
        # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
        tokens = regexp.findall(self.get_line_buffer())
        tokens.reverse()
        iterTokens = iter(tokens); openPar = 0
        for token in iterTokens:
            if token == ')':
                openPar -= 1
            elif token == '(':
                openPar += 1
                if openPar > 0:
                    # found the last unclosed parenthesis
                    break
        else:
            return []
        # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
        ids = []
        isId = re.compile(r'\w+$').match
        while True:
            try:
                ids.append(iterTokens.next())
                if not isId(ids[-1]):
                    ids.pop(); break
                if not iterTokens.next() == '.':
                    break
            except StopIteration:
                break
        # lookup the candidate callable matches either using global_matches
        # or attr_matches for dotted names
        if len(ids) == 1:
            callableMatches = self.global_matches(ids[0])
        else:
            callableMatches = self.attr_matches('.'.join(ids[::-1]))
        argMatches = []
        for callableMatch in callableMatches:
            try:
                namedArgs = self._default_arguments(eval(callableMatch,
                                                         self.namespace))
            except:
                continue
            for namedArg in namedArgs:
                if namedArg.startswith(text):
                    argMatches.append("%s=" %namedArg)
        return argMatches

    def dispatch_custom_completer(self,text):
        #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
        line = self.full_lbuf        
        if not line.strip():
            return None

        event = Bunch()
        event.line = line
        event.symbol = text
        cmd = line.split(None,1)[0]
        event.command = cmd
        #print "\ncustom:{%s]\n" % event # dbg
        
        # for foo etc, try also to find completer for %foo
        if not cmd.startswith(self.magic_escape):
            try_magic = self.custom_completers.s_matches(
              self.magic_escape + cmd)            
        else:
            try_magic = []        
        
        for c in itertools.chain(self.custom_completers.s_matches(cmd),
                                 try_magic,
                                 self.custom_completers.flat_matches(self.lbuf)):
            #print "try",c # dbg
            try:
                res = c(event)
                # first, try case sensitive match
                withcase = [r for r in res if r.startswith(text)]
                if withcase:
                    return withcase
                # if none, then case insensitive ones are ok too
                text_low = text.lower()
                return [r for r in res if r.lower().startswith(text_low)]
            except TryNext:
                pass
            
        return None
               
    def complete(self, text, state, line_buffer=None):
        """Return the next possible completion for 'text'.

        This is called successively with state == 0, 1, 2, ... until it
        returns None.  The completion should begin with 'text'.

        :Keywords:
        - line_buffer: string
        If not given, the completer attempts to obtain the current line buffer
        via readline.  This keyword allows clients which are requesting for
        text completions in non-readline contexts to inform the completer of
        the entire text.
        """

        #print '\n*** COMPLETE: <%s> (%s)' % (text,state)  # 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 line_buffer is None:
            self.full_lbuf = self.get_line_buffer()
        else:
            self.full_lbuf = line_buffer
            
        if not (self.dumb_terminal or self.full_lbuf.strip()):
            self.readline.insert_text('\t')
            return None
        
        magic_escape = self.magic_escape

        self.lbuf = self.full_lbuf[:self.get_endidx()]

        try:
            if text.startswith('~'):
                text = os.path.expanduser(text)
            if state == 0:
                custom_res = self.dispatch_custom_completer(text)
                if custom_res is not None:
                    # did custom completers produce something?
                    self.matches = custom_res
                else:
                    # Extend the list of completions with the results of each
                    # matcher, so we return results to the user from all
                    # namespaces.
                    if self.merge_completions:
                        self.matches = []
                        for matcher in self.matchers:
                            self.matches.extend(matcher(text))
                    else:
                        for matcher in self.matchers:
                            self.matches = matcher(text)
                            if self.matches:
                                break
                    self.matches = list(set(self.matches))
            try:
                #print "MATCH: %r" % self.matches[state] # dbg
                return self.matches[state]
            except IndexError:
                return None
        except:
            #from IPython.core.ultratb import AutoFormattedTB; # dbg
            #tb=AutoFormattedTB('Verbose');tb() #dbg
            
            # If completion fails, don't annoy the user.
            return None