"init", "repr", "str", "lt", "le", "eq", "ne", "gt", "ge", "cmp", "hash",

"nonzero", "unicode", "getattr", "setattr", "get", "set", "call", "len",

"getitem", "setitem", "iter", "reversed", "contains", "add", "sub", "mul",

"floordiv", "mod", "divmod", "pow", "lshift", "rshift", "and", "xor", "or",

"div", "truediv", "neg", "pos", "abs", "invert", "complex", "int", "float",

SIMPLE: method_match_simple,

SUBSTRING: method_match_substring,

FUZZY: method_match_fuzzy

"""Describes different completion types"""

def __init__(self, shown_before_tab=True, mode=SIMPLE):

self._shown_before_tab = shown_before_tab

self.method_match = MODES_MAP[mode]

def matches(self, cursor_offset, line, **kwargs):

"""Returns a list of possible matches given a line and cursor, or None

raise NotImplementedError

def locate(self, cursor_offset, line):

"""Returns a Linepart namedtuple instance or None given cursor and line

raise NotImplementedError

def format(self, word):

return word

def substitute(self, cursor_offset, line, match):

"""Returns a cursor offset and line with match swapped in"""

lpart = self.locate(cursor_offset, line)

offset = lpart.start + len(match)

changed_line = line[:lpart.start] + match + line[lpart.end:]

return offset, changed_line

@property

def shown_before_tab(self):

"""Whether suggestions should be shown before the user hits tab, or only

"""Returns combined matches from several completers"""

def __init__(self, completers, mode=SIMPLE):

if not completers:

raise ValueError(

"CumulativeCompleter requires at least one completer")

self._completers = completers

super(CumulativeCompleter, self).__init__(True, mode)

def locate(self, current_offset, line):

return self._completers[0].locate(current_offset, line)

def format(self, word):

return self._completers[0].format(word)

def matches(self, cursor_offset, line, **kwargs):

return_value = None

all_matches = set()

for completer in self._completers:

matches = completer.matches(cursor_offset=cursor_offset,

line=line,

**kwargs)

if matches is not None:

all_matches.update(matches)

return_value = all_matches

def matches(self, cursor_offset, line, **kwargs):

return importcompletion.complete(cursor_offset, line)

def locate(self, current_offset, line):

return lineparts.current_word(current_offset, line)

def format(self, word):

def __init__(self, mode=SIMPLE):

super(FilenameCompletion, self).__init__(False, mode)

if sys.version_info[:2] >= (3, 4):

def safe_glob(self, pathname):

return glob.iglob(glob.escape(pathname) + '*')

else:

def safe_glob(self, pathname):

try:

return glob.glob(pathname + '*')

except re.error:

# see #491

return tuple()

def matches(self, cursor_offset, line, **kwargs):

cs = lineparts.current_string(cursor_offset, line)

if cs is None:

return None

matches = set()

username = cs.word.split(os.path.sep, 1)[0]

user_dir = os.path.expanduser(username)

for filename in self.safe_glob(os.path.expanduser(cs.word)):

if os.path.isdir(filename):

filename += os.path.sep

if cs.word.startswith('~'):

filename = username + filename[len(user_dir):]

matches.add(filename)

return matches

def locate(self, current_offset, line):

return lineparts.current_string(current_offset, line)

def format(self, filename):

filename.rstrip(os.sep).rsplit(os.sep)[-1]

if os.sep in filename[:-1]:

return filename[filename.rindex(os.sep, 0, -1)+1:]

else:

attr_matches_re = LazyReCompile(r"(\w+(\.\w+)*)\.(\w*)")

def matches(self, cursor_offset, line, **kwargs):

if 'locals_' not in kwargs:

return None

locals_ = kwargs['locals_']

r = self.locate(cursor_offset, line)

if r is None:

return None

if locals_ is None:

locals_ = __main__.__dict__

assert '.' in r.word

for i in range(1, len(r.word) + 1):

if r.word[-i] == '[':

i -= 1

break

methodtext = r.word[-i:]

matches = set(''.join([r.word[:-i], m])

for m in self.attr_matches(methodtext, locals_))

# TODO add open paren for methods via _callable_prefix (or decide not

# to) unless the first character is a _ filter out all attributes

# starting with a _

if r.word.split('.')[-1].startswith('__'):

pass

elif r.word.split('.')[-1].startswith('_'):

matches = set(match for match in matches

if not match.split('.')[-1].startswith('__'))

else:

matches = set(match for match in matches

if not match.split('.')[-1].startswith('_'))

return matches

def locate(self, current_offset, line):

return lineparts.current_dotted_attribute(current_offset, line)

def format(self, word):

return after_last_dot(word)

def attr_matches(self, text, namespace):

"""Taken from rlcompleter.py and bent to my will.

# Gna, Py 2.6's rlcompleter searches for __call__ inside the

# instance instead of the type, so we monkeypatch to prevent

# side-effects (__getattr__/__getattribute__)

m = self.attr_matches_re.match(text)

if not m:

return []

expr, attr = m.group(1, 3)

if expr.isdigit():

# Special case: float literal, using attrs here will result in

# a SyntaxError

return []

try:

obj = safe_eval(expr, namespace)

except EvaluationError:

return []

with inspection.AttrCleaner(obj):

matches = self.attr_lookup(obj, expr, attr)

return matches

def attr_lookup(self, obj, expr, attr):

"""Second half of original attr_matches method factored out so it can

words = self.list_attributes(obj)

if hasattr(obj, '__class__'):

words.append('__class__')

words = words + rlcompleter.get_class_members(obj.__class__)

if not isinstance(obj.__class__, abc.ABCMeta):

try:

words.remove('__abstractmethods__')

except ValueError:

pass

if not py3 and isinstance(obj, (InstanceType, ClassType)):

# Account for the __dict__ in an old-style class.

words.append('__dict__')

matches = []

n = len(attr)

for word in words:

if self.method_match(word, n, attr) and word != "__builtins__":

matches.append("%s.%s" % (expr, word))

return matches

if py3:

def list_attributes(self, obj):

return dir(obj)

else:

def list_attributes(self, obj):

if isinstance(obj, InstanceType):

try:

return dir(obj)

except Exception:

# This is a case where we can not prevent user code from

# running. We return a default list attributes on error

# instead. (#536)

return ['__doc__', '__module__']

else:

def __init__(self, shown_before_tab=True, mode=SIMPLE):

self._shown_before_tab = shown_before_tab

self.completer = AttrCompletion(mode=mode)

def matches(self, cursor_offset, line, **kwargs):

if 'locals_' not in kwargs:

return None

locals_ = kwargs['locals_']

full = self.locate(cursor_offset, line)

if full is None:

return None

arr = lineparts.current_indexed_member_access_identifier(

cursor_offset, line)

index = lineparts.current_indexed_member_access_identifier_with_index(

cursor_offset, line)

member = lineparts.current_indexed_member_access_member(

cursor_offset, line)

try:

obj = safe_eval(arr.word, locals_)

except EvaluationError:

return None

if type(obj) not in (list, tuple) + string_types:

# then is may be unsafe to do attribute lookup on it

return None

try:

locals_['temp_val_from_array'] = safe_eval(index.word, locals_)

except (EvaluationError, IndexError):

return None

temp_line = line.replace(index.word, 'temp_val_from_array.')

matches = self.completer.matches(len(temp_line), temp_line, **kwargs)

if matches is None:

return None

matches_with_correct_name = \

set(match.replace('temp_val_from_array.', index.word+'.')

for match in matches if match[20:].startswith(member.word))

del locals_['temp_val_from_array']

return matches_with_correct_name

def locate(self, current_offset, line):

a = lineparts.current_indexed_member_access(current_offset, line)

return a

def format(self, match):

def matches(self, cursor_offset, line, **kwargs):

if 'locals_' not in kwargs:

return None

locals_ = kwargs['locals_']

r = self.locate(cursor_offset, line)

if r is None:

return None

_, _, dexpr = lineparts.current_dict(cursor_offset, line)

try:

obj = safe_eval(dexpr, locals_)

except EvaluationError:

return None

if isinstance(obj, dict) and obj.keys():

matches = set("{0!r}]".format(k) for k in obj.keys()

if repr(k).startswith(r.word))

return matches if matches else None

else:

return None

def locate(self, current_offset, line):

return lineparts.current_dict_key(current_offset, line)

def format(self, match):

def matches(self, cursor_offset, line, **kwargs):

if 'current_block' not in kwargs:

return None

current_block = kwargs['current_block']

r = self.locate(cursor_offset, line)

if r is None:

return None

if 'class' not in current_block:

return None

return set(name for name in MAGIC_METHODS if name.startswith(r.word))

def locate(self, current_offset, line):

def matches(self, cursor_offset, line, **kwargs):

"""Compute matches when text is a simple name.

if 'locals_' not in kwargs:

return None

locals_ = kwargs['locals_']

r = self.locate(cursor_offset, line)

if r is None:

return None

matches = set()

n = len(r.word)

for word in KEYWORDS:

if self.method_match(word, n, r.word):

matches.add(word)

for nspace in (builtins.__dict__, locals_):

for word, val in iteritems(nspace):

word = try_decode(word, 'ascii')

# if identifier isn't ascii, don't complete (syntax error)

if word is None:

continue

if (self.method_match(word, n, r.word) and

word != "__builtins__"):

matches.add(_callable_postfix(val, word))

return matches if matches else None

def locate(self, current_offset, line):

def matches(self, cursor_offset, line, **kwargs):

if 'argspec' not in kwargs:

return None

argspec = kwargs['argspec']

if not argspec:

return None

r = self.locate(cursor_offset, line)

if r is None:

return None

if argspec:

matches = set(name + '=' for name in argspec[1][0]

if isinstance(name, string_types) and

name.startswith(r.word))

if py3:

matches.update(name + '=' for name in argspec[1][4]

if name.startswith(r.word))

return matches if matches else None

def locate(self, current_offset, line):

def matches(self, cursor_offset, line, **kwargs):

r = self.locate(cursor_offset, line)

if r is None:

return None

attrs = dir('')

if not py3:

# decode attributes

attrs = (att.decode('ascii') for att in attrs)

matches = set(att for att in attrs if att.startswith(r.word))

if not r.word.startswith('_'):

return set(match for match in matches if not match.startswith('_'))

return matches

def locate(self, current_offset, line):

def matches(self, cursor_offset, line, **kwargs):

if 'history' not in kwargs:

return None

history = kwargs['history']

if not lineparts.current_word(cursor_offset, line):

return None

history = '\n'.join(history) + '\n' + line

try:

script = jedi.Script(history, len(history.splitlines()),

cursor_offset, 'fake.py')

completions = script.completions()

except (jedi.NotFoundError, IndexError, KeyError):

# IndexError for #483

# KeyError for #544

self._orig_start = None

return None

if completions:

diff = len(completions[0].name) - len(completions[0].complete)

self._orig_start = cursor_offset - diff

else:

self._orig_start = None

return None

first_letter = line[self._orig_start:self._orig_start+1]

matches = [c.name for c in completions]

if any(not m.lower().startswith(matches[0][0].lower())

for m in matches):

# Too general - giving completions starting with multiple

# letters

return None

else:

# case-sensitive matches only

return set(m for m in matches if m.startswith(first_letter))

def locate(self, cursor_offset, line):

start = self._orig_start

end = cursor_offset

def matches(self, cursor_offset, line, **kwargs):

if 'current_block' not in kwargs or 'history' not in kwargs:

return None

current_block = kwargs['current_block']

history = kwargs['history']

if '\n' in current_block:

assert cursor_offset <= len(line), "%r %r" % (cursor_offset,

line)

results = super(MultilineJediCompletion,

self).matches(cursor_offset, line,

history=history)

return results

else:

"""Returns a list of matches and an applicable completer

for completer in completers:

try:

matches = completer.matches(cursor_offset, line, **kwargs)

except Exception as e:

# Instead of crashing the UI, log exceptions from autocompleters.

logger = logging.getLogger(__name__)

logger.debug(

'Completer {} failed with unhandled exception: {}'.format(

completer, e))

continue

if matches is not None:

return sorted(matches), (completer if matches else None)

return (

DictKeyCompletion(mode=mode),

StringLiteralAttrCompletion(mode=mode),

ImportCompletion(mode=mode),

FilenameCompletion(mode=mode),

MagicMethodCompletion(mode=mode),

MultilineJediCompletion(mode=mode),

CumulativeCompleter((GlobalCompletion(mode=mode),

ParameterNameCompletion(mode=mode)),

mode=mode),

ArrayItemMembersCompletion(mode=mode),

AttrCompletion(mode=mode),

"""Not all that safe, just catches some errors"""

try:

return eval(expr, namespace)

except (NameError, AttributeError, SyntaxError):

# If debugging safe_eval, raise this!

# raise

"""rlcompleter's _callable_postfix done right."""

with inspection.AttrCleaner(value):

if inspection.is_callable(value):

word += '('