# encoding: utf-8

"""Tests for the IPython tab-completion machinery."""

# Copyright (c) IPython Development Team.

# Distributed under the terms of the Modified BSD License.

import os

import pytest

import sys

import textwrap

import types

import unittest

import random

from importlib.metadata import version

from contextlib import contextmanager

from traitlets.config.loader import Config

from IPython import get_ipython

from IPython.core import completer

from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory

from IPython.utils.generics import complete_object

from IPython.testing import decorators as dec

from IPython.core.latex_symbols import latex_symbols

from IPython.core.completer import (

Completion,

provisionalcompleter,

match_dict_keys,

_deduplicate_completions,

_match_number_in_dict_key_prefix,

completion_matcher,

SimpleCompletion,

CompletionContext,

_unicode_name_compute,

_UNICODE_RANGES,

)

from packaging.version import parse

@contextmanager

def jedi_status(status: bool):

completer = get_ipython().Completer

try:

old = completer.use_jedi

completer.use_jedi = status

yield

finally:

completer.use_jedi = old

# -----------------------------------------------------------------------------

# Test functions

# -----------------------------------------------------------------------------

def recompute_unicode_ranges():

"""

utility to recompute the largest unicode range without any characters

use to recompute the gap in the global _UNICODE_RANGES of completer.py

"""

import itertools

import unicodedata

valid = []

for c in range(0, 0x10FFFF + 1):

try:

unicodedata.name(chr(c))

except ValueError:

continue

valid.append(c)

def ranges(i):

for a, b in itertools.groupby(enumerate(i), lambda pair: pair[1] - pair[0]):

b = list(b)

yield b[0][1], b[-1][1]

rg = list(ranges(valid))

lens = []

gap_lens = []

_pstart, pstop = 0, 0

for start, stop in rg:

lens.append(stop - start)

gap_lens.append(

(

start - pstop,

hex(pstop + 1),

hex(start),

f"{round((start - pstop)/0xe01f0*100)}%",

)

)

_pstart, pstop = start, stop

return sorted(gap_lens)[-1]

def test_unicode_range():

"""

Test that the ranges we test for unicode names give the same number of

results than testing the full length.

"""

expected_list = _unicode_name_compute([(0, 0x110000)])

test = _unicode_name_compute(_UNICODE_RANGES)

len_exp = len(expected_list)

len_test = len(test)

# do not inline the len() or on error pytest will try to print the 130 000 +

# elements.

message = None

if len_exp != len_test or len_exp > 131808:

size, start, stop, prct = recompute_unicode_ranges()

message = f"""_UNICODE_RANGES likely wrong and need updating. This is

likely due to a new release of Python. We've find that the biggest gap

in unicode characters has reduces in size to be {size} characters

({prct}), from {start}, to {stop}. In completer.py likely update to

_UNICODE_RANGES = [(32, {start}), ({stop}, 0xe01f0)]

And update the assertion below to use

len_exp <= {len_exp}

"""

assert len_exp == len_test, message

# fail if new unicode symbols have been added.

assert len_exp <= 153626, message

@contextmanager

def greedy_completion():

ip = get_ipython()

greedy_original = ip.Completer.greedy

try:

ip.Completer.greedy = True

yield

finally:

ip.Completer.greedy = greedy_original

@contextmanager

def evaluation_policy(evaluation: str, **overrides):

ip = get_ipython()

evaluation_original = ip.Completer.evaluation

overrides_original = ip.Completer.policy_overrides

try:

ip.Completer.evaluation = evaluation

ip.Completer.policy_overrides = overrides

yield

finally:

ip.Completer.evaluation = evaluation_original

ip.Completer.policy_overrides = overrides_original

@contextmanager

def custom_matchers(matchers):

ip = get_ipython()

try:

ip.Completer.custom_matchers.extend(matchers)

yield

finally:

ip.Completer.custom_matchers.clear()

if sys.platform == "win32":

pairs = [

("abc", "abc"),

(" abc", '" abc"'),

("a bc", '"a bc"'),

("a bc", '"a bc"'),

(" bc", '" bc"'),

]

else:

pairs = [

("abc", "abc"),

(" abc", r"\ abc"),

("a bc", r"a\ bc"),

("a bc", r"a\ \ bc"),

(" bc", r"\ \ bc"),

# On posix, we also protect parens and other special characters.

("a(bc", r"a\(bc"),

("a)bc", r"a\)bc"),

("a( )bc", r"a\(\ \)bc"),

("a[1]bc", r"a\[1\]bc"),

("a{1}bc", r"a\{1\}bc"),

("a#bc", r"a\#bc"),

("a?bc", r"a\?bc"),

("a=bc", r"a\=bc"),

("a\\bc", r"a\\bc"),

("a|bc", r"a\|bc"),

("a;bc", r"a\;bc"),

("a:bc", r"a\:bc"),

("a'bc", r"a\'bc"),

("a*bc", r"a\*bc"),

('a"bc', r"a\"bc"),

("a^bc", r"a\^bc"),

("a&bc", r"a\&bc"),

]

@pytest.mark.parametrize("s1,expected", pairs)

def test_protect_filename(s1, expected):

assert completer.protect_filename(s1) == expected

def check_line_split(splitter, test_specs):

for part1, part2, split in test_specs:

cursor_pos = len(part1)

line = part1 + part2

out = splitter.split_line(line, cursor_pos)

assert out == split

def test_line_split():

"""Basic line splitter test with default specs."""

sp = completer.CompletionSplitter()

# The format of the test specs is: part1, part2, expected answer. Parts 1

# and 2 are joined into the 'line' sent to the splitter, as if the cursor

# was at the end of part1. So an empty part2 represents someone hitting

# tab at the end of the line, the most common case.

t = [

("run some/script", "", "some/script"),

("run scripts/er", "ror.py foo", "scripts/er"),

("echo $HOM", "", "HOM"),

("print sys.pa", "", "sys.pa"),

("print(sys.pa", "", "sys.pa"),

("execfile('scripts/er", "", "scripts/er"),

("a[x.", "", "x."),

("a[x.", "y", "x."),

('cd "some_file/', "", "some_file/"),

]

check_line_split(sp, t)

# Ensure splitting works OK with unicode by re-running the tests with

# all inputs turned into unicode

check_line_split(sp, [map(str, p) for p in t])

class NamedInstanceClass:

instances = {}

def __init__(self, name):

self.instances[name] = self

@classmethod

def _ipython_key_completions_(cls):

return cls.instances.keys()

class KeyCompletable:

def __init__(self, things=()):

self.things = things

def _ipython_key_completions_(self):

return list(self.things)

class TestCompleter(unittest.TestCase):

def setUp(self):

"""

We want to silence all PendingDeprecationWarning when testing the completer

"""

self._assertwarns = self.assertWarns(PendingDeprecationWarning)

self._assertwarns.__enter__()

def tearDown(self):

try:

self._assertwarns.__exit__(None, None, None)

except AssertionError:

pass

def test_custom_completion_error(self):

"""Test that errors from custom attribute completers are silenced."""

ip = get_ipython()

class A:

pass

ip.user_ns["x"] = A()

@complete_object.register(A)

def complete_A(a, existing_completions):

raise TypeError("this should be silenced")

ip.complete("x.")

def test_custom_completion_ordering(self):

"""Test that errors from custom attribute completers are silenced."""

ip = get_ipython()

_, matches = ip.complete("in")

assert matches.index("input") < matches.index("int")

def complete_example(a):

return ["example2", "example1"]

ip.Completer.custom_completers.add_re("ex*", complete_example)

_, matches = ip.complete("ex")

assert matches.index("example2") < matches.index("example1")

def test_unicode_completions(self):

ip = get_ipython()

# Some strings that trigger different types of completion. Check them both

# in str and unicode forms

s = ["ru", "%ru", "cd /", "floa", "float(x)/"]

for t in s + list(map(str, s)):

# We don't need to check exact completion values (they may change

# depending on the state of the namespace, but at least no exceptions

# should be thrown and the return value should be a pair of text, list

# values.

text, matches = ip.complete(t)

self.assertIsInstance(text, str)

self.assertIsInstance(matches, list)

def test_latex_completions(self):

ip = get_ipython()

# Test some random unicode symbols

keys = random.sample(sorted(latex_symbols), 10)

for k in keys:

text, matches = ip.complete(k)

self.assertEqual(text, k)

self.assertEqual(matches, [latex_symbols[k]])

# Test a more complex line

text, matches = ip.complete("print(\\alpha")

self.assertEqual(text, "\\alpha")

self.assertEqual(matches[0], latex_symbols["\\alpha"])

# Test multiple matching latex symbols

text, matches = ip.complete("\\al")

self.assertIn("\\alpha", matches)

self.assertIn("\\aleph", matches)

def test_latex_no_results(self):

"""

forward latex should really return nothing in either field if nothing is found.

"""

ip = get_ipython()

text, matches = ip.Completer.latex_matches("\\really_i_should_match_nothing")

self.assertEqual(text, "")

self.assertEqual(matches, ())

def test_back_latex_completion(self):

ip = get_ipython()

# do not return more than 1 matches for \beta, only the latex one.

name, matches = ip.complete("\\β")

self.assertEqual(matches, ["\\beta"])

def test_back_unicode_completion(self):

ip = get_ipython()

name, matches = ip.complete("\\Ⅴ")

self.assertEqual(matches, ["\\ROMAN NUMERAL FIVE"])

def test_forward_unicode_completion(self):

ip = get_ipython()

name, matches = ip.complete("\\ROMAN NUMERAL FIVE")

self.assertEqual(matches, ["Ⅴ"]) # This is not a V

self.assertEqual(matches, ["\u2164"]) # same as above but explicit.

def test_delim_setting(self):

sp = completer.CompletionSplitter()

sp.delims = " "

self.assertEqual(sp.delims, " ")

self.assertEqual(sp._delim_expr, r"[\ ]")

def test_spaces(self):

"""Test with only spaces as split chars."""

sp = completer.CompletionSplitter()

sp.delims = " "

t = [("foo", "", "foo"), ("run foo", "", "foo"), ("run foo", "bar", "foo")]

check_line_split(sp, t)

def test_has_open_quotes1(self):

for s in ["'", "'''", "'hi' '"]:

self.assertEqual(completer.has_open_quotes(s), "'")

def test_has_open_quotes2(self):

for s in ['"', '"""', '"hi" "']:

self.assertEqual(completer.has_open_quotes(s), '"')

def test_has_open_quotes3(self):

for s in ["''", "''' '''", "'hi' 'ipython'"]:

self.assertFalse(completer.has_open_quotes(s))

def test_has_open_quotes4(self):

for s in ['""', '""" """', '"hi" "ipython"']:

self.assertFalse(completer.has_open_quotes(s))

@pytest.mark.xfail(

sys.platform == "win32", reason="abspath completions fail on Windows"

)

def test_abspath_file_completions(self):

ip = get_ipython()

with TemporaryDirectory() as tmpdir:

prefix = os.path.join(tmpdir, "foo")

suffixes = ["1", "2"]

names = [prefix + s for s in suffixes]

for n in names:

open(n, "w", encoding="utf-8").close()

# Check simple completion

c = ip.complete(prefix)[1]

self.assertEqual(c, names)

# Now check with a function call

cmd = 'a = f("%s' % prefix

c = ip.complete(prefix, cmd)[1]

comp = [prefix + s for s in suffixes]

self.assertEqual(c, comp)

def test_local_file_completions(self):

ip = get_ipython()

with TemporaryWorkingDirectory():

prefix = "./foo"

suffixes = ["1", "2"]

names = [prefix + s for s in suffixes]

for n in names:

open(n, "w", encoding="utf-8").close()

# Check simple completion

c = ip.complete(prefix)[1]

self.assertEqual(c, names)

test_cases = {

"function call": 'a = f("',

"shell bang": "!ls ",

"ls magic": r"%ls ",

"alias ls": "ls ",

}

for name, code in test_cases.items():

cmd = f"{code}{prefix}"

c = ip.complete(prefix, cmd)[1]

comp = {prefix + s for s in suffixes}

self.assertTrue(comp.issubset(set(c)), msg=f"completes in {name}")

def test_quoted_file_completions(self):

ip = get_ipython()

def _(text):

return ip.Completer._complete(

cursor_line=0, cursor_pos=len(text), full_text=text

)["IPCompleter.file_matcher"]["completions"]

with TemporaryWorkingDirectory():

name = "foo'bar"

open(name, "w", encoding="utf-8").close()

# Don't escape Windows

escaped = name if sys.platform == "win32" else "foo\\'bar"

# Single quote matches embedded single quote

c = _("open('foo")[0]

self.assertEqual(c.text, escaped)

# Double quote requires no escape

c = _('open("foo')[0]

self.assertEqual(c.text, name)

# No quote requires an escape

c = _("%ls foo")[0]

self.assertEqual(c.text, escaped)

@pytest.mark.xfail(

sys.version_info.releaselevel in ("alpha",),

reason="Parso does not yet parse 3.13",

)

def test_all_completions_dups(self):

"""

Make sure the output of `IPCompleter.all_completions` does not have

duplicated prefixes.

"""

ip = get_ipython()

c = ip.Completer

ip.ex("class TestClass():\n\ta=1\n\ta1=2")

for jedi_status in [True, False]:

with provisionalcompleter():

ip.Completer.use_jedi = jedi_status

matches = c.all_completions("TestCl")

assert matches == ["TestClass"], (jedi_status, matches)

matches = c.all_completions("TestClass.")

assert len(matches) > 2, (jedi_status, matches)

matches = c.all_completions("TestClass.a")

if jedi_status:

assert matches == ["TestClass.a", "TestClass.a1"], jedi_status

else:

assert matches == [".a", ".a1"], jedi_status

@pytest.mark.xfail(

sys.version_info.releaselevel in ("alpha",),

reason="Parso does not yet parse 3.13",

)

def test_jedi(self):

"""

A couple of issue we had with Jedi

"""

ip = get_ipython()

def _test_complete(reason, s, comp, start=None, end=None):

l = len(s)

start = start if start is not None else l

end = end if end is not None else l

with provisionalcompleter():

ip.Completer.use_jedi = True

completions = set(ip.Completer.completions(s, l))

ip.Completer.use_jedi = False

assert Completion(start, end, comp) in completions, reason

def _test_not_complete(reason, s, comp):

l = len(s)

with provisionalcompleter():

ip.Completer.use_jedi = True

completions = set(ip.Completer.completions(s, l))

ip.Completer.use_jedi = False

assert Completion(l, l, comp) not in completions, reason

import jedi

jedi_version = tuple(int(i) for i in jedi.__version__.split(".")[:3])

if jedi_version > (0, 10):

_test_complete("jedi >0.9 should complete and not crash", "a=1;a.", "real")

_test_complete("can infer first argument", 'a=(1,"foo");a[0].', "real")

_test_complete("can infer second argument", 'a=(1,"foo");a[1].', "capitalize")

_test_complete("cover duplicate completions", "im", "import", 0, 2)

_test_not_complete("does not mix types", 'a=(1,"foo");a[0].', "capitalize")

@pytest.mark.xfail(

sys.version_info.releaselevel in ("alpha",),

reason="Parso does not yet parse 3.13",

)

def test_completion_have_signature(self):

"""

Lets make sure jedi is capable of pulling out the signature of the function we are completing.

"""

ip = get_ipython()

with provisionalcompleter():

ip.Completer.use_jedi = True

completions = ip.Completer.completions("ope", 3)

c = next(completions) # should be `open`

ip.Completer.use_jedi = False

assert "file" in c.signature, "Signature of function was not found by completer"

assert (

"encoding" in c.signature

), "Signature of function was not found by completer"

@pytest.mark.xfail(

sys.version_info.releaselevel in ("alpha",),

reason="Parso does not yet parse 3.13",

)

def test_completions_have_type(self):

"""

Lets make sure matchers provide completion type.

"""

ip = get_ipython()

with provisionalcompleter():

ip.Completer.use_jedi = False

completions = ip.Completer.completions("%tim", 3)

c = next(completions) # should be `%time` or similar

assert c.type == "magic", "Type of magic was not assigned by completer"

@pytest.mark.xfail(

parse(version("jedi")) <= parse("0.18.0"),

reason="Known failure on jedi<=0.18.0",

strict=True,

)

def test_deduplicate_completions(self):

"""

Test that completions are correctly deduplicated (even if ranges are not the same)

"""

ip = get_ipython()

ip.ex(

textwrap.dedent(

"""

class Z:

zoo = 1

"""

)

)

with provisionalcompleter():

ip.Completer.use_jedi = True

l = list(

_deduplicate_completions("Z.z", ip.Completer.completions("Z.z", 3))

)

ip.Completer.use_jedi = False

assert len(l) == 1, "Completions (Z.z<tab>) correctly deduplicate: %s " % l

assert l[0].text == "zoo" # and not `it.accumulate`

@pytest.mark.xfail(

sys.version_info.releaselevel in ("alpha",),

reason="Parso does not yet parse 3.13",

)

def test_greedy_completions(self):

"""

Test the capability of the Greedy completer.

Most of the test here does not really show off the greedy completer, for proof

each of the text below now pass with Jedi. The greedy completer is capable of more.

See the :any:`test_dict_key_completion_contexts`

"""

ip = get_ipython()

ip.ex("a=list(range(5))")

ip.ex("b,c = 1, 1.2")

ip.ex("d = {'a b': str}")

ip.ex("x=y='a'")

_, c = ip.complete(".", line="a[0].")

self.assertFalse(".real" in c, "Shouldn't have completed on a[0]: %s" % c)

def _(line, cursor_pos, expect, message, completion):

with greedy_completion(), provisionalcompleter():

ip.Completer.use_jedi = False

_, c = ip.complete(".", line=line, cursor_pos=cursor_pos)

self.assertIn(expect, c, message % c)

ip.Completer.use_jedi = True

with provisionalcompleter():

completions = ip.Completer.completions(line, cursor_pos)

self.assertIn(completion, list(completions))

with provisionalcompleter():

_(

"a[0].",

5,

".real",

"Should have completed on a[0].: %s",

Completion(5, 5, "real"),

)

_(

"a[0].r",

6,

".real",

"Should have completed on a[0].r: %s",

Completion(5, 6, "real"),

)

_(

"a[0].from_",

10,

".from_bytes",

"Should have completed on a[0].from_: %s",

Completion(5, 10, "from_bytes"),

)

_(

"assert str.star",

14,

".startswith",

"Should have completed on `assert str.star`: %s",

Completion(11, 14, "startswith"),

)

_(

"d['a b'].str",

12,

".strip",

"Should have completed on `d['a b'].str`: %s",

Completion(9, 12, "strip"),

)

_(

"a.app",

4,

".append",

"Should have completed on `a.app`: %s",

Completion(2, 4, "append"),

)

_(

"x.upper() == y.",

15,

".upper",

"Should have completed on `x.upper() == y.`: %s",

Completion(15, 15, "upper"),

)

_(

"(x.upper() == y.",

16,

".upper",

"Should have completed on `(x.upper() == y.`: %s",

Completion(16, 16, "upper"),

)

_(

"(x.upper() == y).",

17,

".bit_length",

"Should have completed on `(x.upper() == y).`: %s",

Completion(17, 17, "bit_length"),

)

_(

"{'==', 'abc'}.",

14,

".add",

"Should have completed on `{'==', 'abc'}.`: %s",

Completion(14, 14, "add"),

)

_(

"b + c.",

6,

".hex",

"Should have completed on `b + c.`: %s",

Completion(6, 6, "hex"),

)

def test_omit__names(self):

# also happens to test IPCompleter as a configurable

ip = get_ipython()

ip._hidden_attr = 1

ip._x = {}

c = ip.Completer

ip.ex("ip=get_ipython()")

cfg = Config()

cfg.IPCompleter.omit__names = 0

c.update_config(cfg)

with provisionalcompleter():

c.use_jedi = False

s, matches = c.complete("ip.")

self.assertIn(".__str__", matches)

self.assertIn("._hidden_attr", matches)

# c.use_jedi = True

# completions = set(c.completions('ip.', 3))

# self.assertIn(Completion(3, 3, '__str__'), completions)

# self.assertIn(Completion(3,3, "_hidden_attr"), completions)

cfg = Config()

cfg.IPCompleter.omit__names = 1

c.update_config(cfg)

with provisionalcompleter():

c.use_jedi = False

s, matches = c.complete("ip.")

self.assertNotIn(".__str__", matches)

# self.assertIn('ip._hidden_attr', matches)

# c.use_jedi = True

# completions = set(c.completions('ip.', 3))

# self.assertNotIn(Completion(3,3,'__str__'), completions)

# self.assertIn(Completion(3,3, "_hidden_attr"), completions)

cfg = Config()

cfg.IPCompleter.omit__names = 2

c.update_config(cfg)

with provisionalcompleter():

c.use_jedi = False

s, matches = c.complete("ip.")

self.assertNotIn(".__str__", matches)

self.assertNotIn("._hidden_attr", matches)

# c.use_jedi = True

# completions = set(c.completions('ip.', 3))

# self.assertNotIn(Completion(3,3,'__str__'), completions)

# self.assertNotIn(Completion(3,3, "_hidden_attr"), completions)

with provisionalcompleter():

c.use_jedi = False

s, matches = c.complete("ip._x.")

self.assertIn(".keys", matches)

# c.use_jedi = True

# completions = set(c.completions('ip._x.', 6))

# self.assertIn(Completion(6,6, "keys"), completions)

del ip._hidden_attr

del ip._x

def test_limit_to__all__False_ok(self):

"""

Limit to all is deprecated, once we remove it this test can go away.

"""

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

ip.ex("class D: x=24")

ip.ex("d=D()")

cfg = Config()

cfg.IPCompleter.limit_to__all__ = False

c.update_config(cfg)

s, matches = c.complete("d.")

self.assertIn(".x", matches)

def test_get__all__entries_ok(self):

class A:

__all__ = ["x", 1]

words = completer.get__all__entries(A())

self.assertEqual(words, ["x"])

def test_get__all__entries_no__all__ok(self):

class A:

pass

words = completer.get__all__entries(A())

self.assertEqual(words, [])

def test_completes_globals_as_args_of_methods(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

ip.ex("long_variable_name = 1")

ip.ex("a = []")

s, matches = c.complete(None, "a.sort(lo")

self.assertIn("long_variable_name", matches)

def test_completes_attributes_in_fstring_expressions(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

class CustomClass:

def method_one(self):

pass

ip.user_ns["custom_obj"] = CustomClass()

# Test completion inside f-string expressions

s, matches = c.complete(None, "f'{custom_obj.meth")

self.assertIn(".method_one", matches)

def test_completes_in_dict_expressions(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

ip.ex("class Test: pass")

ip.ex("test_obj = Test()")

ip.ex("test_obj.attribute = 'value'")

# Test completion in dictionary expressions

s, matches = c.complete(None, "d = {'key': test_obj.attr")

self.assertIn(".attribute", matches)

# Test global completion in dictionary expressions with dots

s, matches = c.complete(None, "d = {'k.e.y': Te")

self.assertIn("Test", matches)

def test_func_kw_completions(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

ip.ex("def myfunc(a=1,b=2): return a+b")

s, matches = c.complete(None, "myfunc(1,b")

self.assertIn("b=", matches)

# Simulate completing with cursor right after b (pos==10):

s, matches = c.complete(None, "myfunc(1,b)", 10)

self.assertIn("b=", matches)

s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b')

self.assertIn("b=", matches)

# builtin function

s, matches = c.complete(None, "min(k, k")

self.assertIn("key=", matches)

def test_default_arguments_from_docstring(self):

ip = get_ipython()

c = ip.Completer

kwd = c._default_arguments_from_docstring("min(iterable[, key=func]) -> value")

self.assertEqual(kwd, ["key"])

# with cython type etc

kwd = c._default_arguments_from_docstring(

"Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"

)

self.assertEqual(kwd, ["ncall", "resume", "nsplit"])

# white spaces

kwd = c._default_arguments_from_docstring(

"\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"

)

self.assertEqual(kwd, ["ncall", "resume", "nsplit"])

def test_line_magics(self):

ip = get_ipython()

c = ip.Completer

s, matches = c.complete(None, "lsmag")

self.assertIn("%lsmagic", matches)

s, matches = c.complete(None, "%lsmag")

self.assertIn("%lsmagic", matches)

def test_cell_magics(self):

from IPython.core.magic import register_cell_magic

@register_cell_magic

def _foo_cellm(line, cell):

pass

ip = get_ipython()

c = ip.Completer

s, matches = c.complete(None, "_foo_ce")

self.assertIn("%%_foo_cellm", matches)

s, matches = c.complete(None, "%%_foo_ce")

self.assertIn("%%_foo_cellm", matches)

def test_line_cell_magics(self):

from IPython.core.magic import register_line_cell_magic

@register_line_cell_magic

def _bar_cellm(line, cell):

pass

ip = get_ipython()

c = ip.Completer

# The policy here is trickier, see comments in completion code. The

# returned values depend on whether the user passes %% or not explicitly,

# and this will show a difference if the same name is both a line and cell

# magic.

s, matches = c.complete(None, "_bar_ce")

self.assertIn("%_bar_cellm", matches)

self.assertIn("%%_bar_cellm", matches)

s, matches = c.complete(None, "%_bar_ce")

self.assertIn("%_bar_cellm", matches)

self.assertIn("%%_bar_cellm", matches)

s, matches = c.complete(None, "%%_bar_ce")

self.assertNotIn("%_bar_cellm", matches)

self.assertIn("%%_bar_cellm", matches)

def test_line_magics_with_code_argument(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

# attribute completion

text, matches = c.complete("%timeit -n 2 -r 1 float.as_integer")

self.assertEqual(matches, [".as_integer_ratio"])

text, matches = c.complete("%debug --breakpoint test float.as_integer")

self.assertEqual(matches, [".as_integer_ratio"])

text, matches = c.complete("%time --no-raise-error float.as_integer")

self.assertEqual(matches, [".as_integer_ratio"])

text, matches = c.complete("%prun -l 0.5 -r float.as_integer")

self.assertEqual(matches, [".as_integer_ratio"])

# implicit magics

text, matches = c.complete("timeit -n 2 -r 1 float.as_integer")

self.assertEqual(matches, [".as_integer_ratio"])

# built-ins completion

text, matches = c.complete("%timeit -n 2 -r 1 flo")

self.assertEqual(matches, ["float"])

# dict completion

text, matches = c.complete("%timeit -n 2 -r 1 {'my_key': 1}['my")

self.assertEqual(matches, ["my_key"])

# invalid arguments - should not throw

text, matches = c.complete("%timeit -n 2 -r 1 -invalid float.as_integer")

self.assertEqual(matches, [])

text, matches = c.complete("%debug --invalid float.as_integer")

self.assertEqual(matches, [])

def test_line_magics_with_code_argument_shadowing(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

# shadow

ip.run_cell("timeit = 1")

# should not suggest on implict magic when shadowed

text, matches = c.complete("timeit -n 2 -r 1 flo")

self.assertEqual(matches, [])

# should suggest on explicit magic

text, matches = c.complete("%timeit -n 2 -r 1 flo")

self.assertEqual(matches, ["float"])

# remove shadow

del ip.user_ns["timeit"]

# should suggest on implicit magic after shadow removal

text, matches = c.complete("timeit -n 2 -r 1 flo")

self.assertEqual(matches, ["float"])

def test_magic_completion_order(self):

ip = get_ipython()

c = ip.Completer

# Test ordering of line and cell magics.

text, matches = c.complete("timeit")

self.assertEqual(matches, ["%timeit", "%%timeit"])

def test_magic_completion_shadowing(self):

ip = get_ipython()

c = ip.Completer

c.use_jedi = False

# Before importing matplotlib, %matplotlib magic should be the only option.

text, matches = c.complete("mat")

self.assertEqual(matches, ["%matplotlib"])

# The newly introduced name should shadow the magic.

ip.run_cell("matplotlib = 1")

text, matches = c.complete("mat")

self.assertEqual(matches, ["matplotlib"])

# After removing matplotlib from namespace, the magic should again be

# the only option.

del ip.user_ns["matplotlib"]

text, matches = c.complete("mat")

self.assertEqual(matches, ["%matplotlib"])