def test_omit__names():
# 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():
s,matches = c.complete('ip.')
completions = set(c.completions('ip.', 3))
nt.assert_in('ip.__str__', matches)
nt.assert_in(Completion(3, 3, '__str__'), completions)
nt.assert_in('ip._hidden_attr', matches)
nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
cfg = Config()
cfg.IPCompleter.omit__names = 1
c.update_config(cfg)
with provisionalcompleter():
s,matches = c.complete('ip.')
completions = set(c.completions('ip.', 3))
nt.assert_not_in('ip.__str__', matches)
nt.assert_not_in(Completion(3,3,'__str__'), completions)
# nt.assert_in('ip._hidden_attr', matches)
nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
cfg = Config()
cfg.IPCompleter.omit__names = 2
c.update_config(cfg)
with provisionalcompleter():
s,matches = c.complete('ip.')
completions = set(c.completions('ip.', 3))
nt.assert_not_in('ip.__str__', matches)
nt.assert_not_in(Completion(3,3,'__str__'), completions)
nt.assert_not_in('ip._hidden_attr', matches)
nt.assert_not_in(Completion(3,3, "_hidden_attr"), completions)
with provisionalcompleter():
s,matches = c.complete('ip._x.')
completions = set(c.completions('ip._x.', 6))
nt.assert_in('ip._x.keys', matches)
nt.assert_in(Completion(6,6, "keys"), completions)
del ip._hidden_attr
del ip._x
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():
completions = set(ip.Completer.completions(s, l))
assert_in(Completion(start, end, comp), 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_not_in(Completion(l, l, comp), completions, reason)
def test_greedy_completions():
"""
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))')
_,c = ip.complete('.',line='a[0].')
nt.assert_false('.real' in c,
"Shouldn't have completed on a[0]: %s"%c)
with greedy_completion(), provisionalcompleter():
def _(line, cursor_pos, expect, message, completion):
ip.Completer.use_jedi = False
_,c = ip.complete('.', line=line, cursor_pos=cursor_pos)
nt.assert_in(expect, c, message % c)
ip.Completer.use_jedi = True
with provisionalcompleter():
completions = ip.Completer.completions(line, cursor_pos)
nt.assert_in(completion, completions)
yield _, 'a[0].', 5, 'a[0].real', "Should have completed on a[0].: %s", Completion(5,5, 'real')
yield _, 'a[0].r', 6, 'a[0].real', "Should have completed on a[0].r: %s", Completion(5,6, 'real')
if sys.version_info > (3, 4):
yield _, 'a[0].from_', 10, 'a[0].from_bytes', "Should have completed on a[0].from_: %s", Completion(5, 10, 'from_bytes')
def _(line, cursor_pos, expect, message, completion):
ip.Completer.use_jedi = False
_,c = ip.complete('.', line=line, cursor_pos=cursor_pos)
nt.assert_in(expect, c, message % c)
ip.Completer.use_jedi = True
with provisionalcompleter():
completions = ip.Completer.completions(line, cursor_pos)
nt.assert_in(completion, completions)
def test_tab_complete_warning(self, ip):
# GH 16409
pytest.importorskip('IPython', minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; df = pd.DataFrame()"
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter('ignore'):
list(ip.Completer.completions('df.', 1))
def test_tab_complete_warning(self, ip):
# https://github.com/pandas-dev/pandas/issues/16409
pytest.importorskip('IPython', minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; df = pd.DataFrame()"
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter('ignore'):
list(ip.Completer.completions('df.', 1))
def test_tab_complete_warning(self, ip):
# GH 16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; df = pd.DataFrame()"
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter("ignore"):
list(ip.Completer.completions("df.", 1))
def test_tab_complete_warning(self, ip):
# https://github.com/pandas-dev/pandas/issues/16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; s = pd.Series()"
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter("ignore"):
list(ip.Completer.completions("s.", 1))
def test_tab_complete_warning(self, ip):
# https://github.com/pandas-dev/pandas/issues/16409
pytest.importorskip('IPython', minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; s = pd.Series()"
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter('ignore'):
list(ip.Completer.completions('s.', 1))
def test_completion_have_signature():
"""
Lets make sure jedi is capable of pulling out the signature of the function we are completing.
"""
ip = get_ipython()
with provisionalcompleter():
completions = ip.Completer.completions('ope', 3)
c = next(completions) # should be `open`
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"
def test_completion_have_signature():
"""
Lets make sure jedi is capable of pulling out the signature of the function we are completing.
"""
ip = get_ipython()
with provisionalcompleter():
completions = ip.Completer.completions('ope', 3)
c = next(completions) # should be `open`
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"
def test_tab_complete_ipython6_warning(ip):
from IPython.core.completer import provisionalcompleter
code = dedent("""\
import pandas.util.testing as tm
s = tm.makeTimeSeries()
rs = s.resample("D")
""")
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter('ignore'):
list(ip.Completer.completions('rs.', 1))
def test_tab_complete_ipython6_warning(ip):
from IPython.core.completer import provisionalcompleter
code = dedent("""\
import pandas.util.testing as tm
s = tm.makeTimeSeries()
rs = s.resample("D")
""")
ip.run_code(code)
with tm.assert_produces_warning(None):
with provisionalcompleter('ignore'):
list(ip.Completer.completions('rs.', 1))
async def test_tab_complete_warning(self, ip):
# https://github.com/pandas-dev/pandas/issues/16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; c = Categorical([])"
await ip.run_code(code)
# GH 31324 newer jedi version raises Deprecation warning;
# appears resolved 2021-02-02
with tm.assert_produces_warning(None):
with provisionalcompleter("ignore"):
list(ip.Completer.completions("c.", 1))
def test_deduplicate_completions():
"""
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():
l = list(_deduplicate_completions('Z.z', ip.Completer.completions('Z.z', 3)))
assert len(l) == 1, 'Completions (Z.z<tab>) correctly deduplicate: %s ' % l
assert l[0].text == 'zoo' # and not `it.accumulate`
def get_completions(self, document, complete_event):
if not document.current_line.strip():
return
# Some bits of our completion system may print stuff (e.g. if a module
# is imported). This context manager ensures that doesn't interfere with
# the prompt.
with self.patch_stdout(), provisionalcompleter():
body = document.text
cursor_row = document.cursor_position_row
cursor_col = document.cursor_position_col
cursor_position = document.cursor_position
offset = cursor_to_position(body, cursor_row, cursor_col)
yield from self._get_completions(body, offset, cursor_position, self.ipy_completer)
def test_deduplicate_completions():
"""
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():
l = list(_deduplicate_completions('Z.z', ip.Completer.completions('Z.z', 3)))
assert len(l) == 1, 'Completions (Z.z<tab>) correctly deduplicate: %s ' % l
assert l[0].text == 'zoo' # and not `it.accumulate`
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))")
_, 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, completions)
with provisionalcompleter():
_(
"a[0].",
5,
"a[0].real",
"Should have completed on a[0].: %s",
Completion(5, 5, "real"),
)
_(
"a[0].r",
6,
"a[0].real",
"Should have completed on a[0].r: %s",
Completion(5, 6, "real"),
)
_(
"a[0].from_",
10,
"a[0].from_bytes",
"Should have completed on a[0].from_: %s",
Completion(5, 10, "from_bytes"),
)
def get_completions(self, document, complete_event):
if not document.current_line.strip():
return
# Some bits of our completion system may print stuff (e.g. if a module
# is imported). This context manager ensures that doesn't interfere with
# the prompt.
with patch_stdout(), provisionalcompleter():
body = document.text
cursor_row = document.cursor_position_row
cursor_col = document.cursor_position_col
cursor_position = document.cursor_position
offset = cursor_to_position(body, cursor_row, cursor_col)
yield from self._get_completions(body, offset, cursor_position, self.ipy_completer)
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"
def _experimental_do_complete(self, code, cursor_pos):
"""
Experimental completions from IPython, using livy completion.
"""
code = code.strip()
if cursor_pos is None:
cursor_pos = len(code)
matches = []
with provisionalcompleter():
session_name = self.spark_controller.generate_livy_session_name(id(self))
endpoint = build_endpoint(self.session_language)
session_info_list = self.spark_controller.get_all_sessions_endpoint(endpoint)
session_id = None
for session in session_info_list:
if session.session_name == session_name:
session_id = session.id
if session_id:
# Only complete the cursor_line
cursor_line, cursor_column = position_to_cursor(code, cursor_pos)
lines = code.split("\n")
completion_line = lines[cursor_line]
before_lines = lines[:cursor_line]
if len(lines) > 1 and cursor_line > 0:
real_cursor_pos = cursor_pos - len("\n".join(before_lines)) - 1
else:
real_cursor_pos = cursor_pos
http_client = self.spark_controller._http_client(endpoint)
kind = conf.get_livy_kind(self.session_language)
res_completions = http_client.post_completion(session_id, kind, completion_line, real_cursor_pos)
matches = res_completions.get("candidates", [])
if matches:
s = self.__get_cursor_start(code, cursor_pos, matches[0])
else:
s = cursor_pos
res = {
'matches': matches,
'cursor_end': cursor_pos,
'cursor_start': s,
'metadata': {},
'status': 'ok'
}
return res
async def test_tab_complete_ipython6_warning(ip):
from IPython.core.completer import provisionalcompleter
code = dedent("""\
import pandas._testing as tm
s = tm.makeTimeSeries()
rs = s.resample("D")
""")
await ip.run_code(code)
# GH 31324 newer jedi version raises Deprecation warning;
# appears resolved 2021-02-02
with tm.assert_produces_warning(None):
with provisionalcompleter("ignore"):
list(ip.Completer.completions("rs.", 1))
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")
assert matches == ['TestClass.a', 'TestClass.a1'], jedi_status
async def test_tab_complete_warning(self, ip, frame_or_series):
# GH 16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
if frame_or_series is DataFrame:
code = "from pandas import DataFrame; obj = DataFrame()"
else:
code = "from pandas import Series; obj = Series(dtype=object)"
await ip.run_code(code)
# GH 31324 newer jedi version raises Deprecation warning;
# appears resolved 2021-02-02
with tm.assert_produces_warning(None):
with provisionalcompleter("ignore"):
list(ip.Completer.completions("obj.", 1))
async def test_tab_complete_warning(self, ip):
# https://github.com/pandas-dev/pandas/issues/16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; c = Categorical([])"
await ip.run_code(code)
# GH 31324 newer jedi version raises Deprecation warning
import jedi
if jedi.__version__ < "0.16.0":
warning = tm.assert_produces_warning(None)
else:
warning = tm.assert_produces_warning(DeprecationWarning,
check_stacklevel=False)
with warning:
with provisionalcompleter("ignore"):
list(ip.Completer.completions("c.", 1))
async def test_tab_complete_warning(self, ip):
# https://github.com/pandas-dev/pandas/issues/16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "import pandas as pd; s = pd.Series()"
await ip.run_code(code)
# TODO: remove it when Ipython updates
# GH 33567, jedi version raises Deprecation warning in Ipython
import jedi
if jedi.__version__ < "0.17.0":
warning = tm.assert_produces_warning(None)
else:
warning = tm.assert_produces_warning(DeprecationWarning,
check_stacklevel=False)
with warning:
with provisionalcompleter("ignore"):
list(ip.Completer.completions("s.", 1))
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`
async def test_tab_complete_warning(self, ip):
# GH 16409
pytest.importorskip("IPython", minversion="6.0.0")
from IPython.core.completer import provisionalcompleter
code = "from pandas import DataFrame; df = DataFrame()"
await ip.run_code(code)
# TODO: remove it when Ipython updates
# GH 33567, jedi version raises Deprecation warning in Ipython
import jedi
if jedi.__version__ < "0.17.0":
warning = tm.assert_produces_warning(None)
else:
warning = tm.assert_produces_warning(DeprecationWarning,
check_stacklevel=False)
with warning:
with provisionalcompleter("ignore"):
list(ip.Completer.completions("df.", 1))
async def test_tab_complete_ipython6_warning(ip):
from IPython.core.completer import provisionalcompleter
code = dedent("""\
import pandas._testing as tm
s = tm.makeTimeSeries()
rs = s.resample("D")
""")
await ip.run_code(code)
# TODO: remove it when Ipython updates
# GH 33567, jedi version raises Deprecation warning in Ipython
import jedi
if jedi.__version__ < "0.17.0":
warning = tm.assert_produces_warning(None)
else:
warning = tm.assert_produces_warning(DeprecationWarning,
check_stacklevel=False)
with warning:
with provisionalcompleter("ignore"):
list(ip.Completer.completions("rs.", 1))
def _experimental_do_complete(self, code, cursor_pos):
"""
Experimental completions from IPython, using Jedi.
"""
if cursor_pos is None:
cursor_pos = len(code)
with provisionalcompleter():
raw_completions = self.shell.Completer.completions(
code, cursor_pos)
completions = list(rectify_completions(code, raw_completions))
comps = []
for comp in completions:
comps.append(
dict(
start=comp.start,
end=comp.end,
text=comp.text,
type=comp.type,
))
if completions:
s = completions[0].start
e = completions[0].end
matches = [c.text for c in completions]
else:
s = cursor_pos
e = cursor_pos
matches = []
return {
'matches': matches,
'cursor_end': e,
'cursor_start': s,
'metadata': {
_EXPERIMENTAL_KEY_NAME: comps
},
'status': 'ok'
}
def get_completions(self, document, complete_event):
if not document.current_line.strip():
return
# Some bits of our completion system may print stuff (e.g. if a module
# is imported). This context manager ensures that doesn't interfere with
# the prompt.
with patch_stdout(), provisionalcompleter():
body = document.text
cursor_row = document.cursor_position_row
cursor_col = document.cursor_position_col
cursor_position = document.cursor_position
offset = cursor_to_position(body, cursor_row, cursor_col)
try:
yield from self._get_completions(body, offset, cursor_position,
self.ipy_completer)
except Exception as e:
try:
exc_type, exc_value, exc_tb = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_tb)
except AttributeError:
print('Unrecoverable Error in completions')
def test_simple_completion(
greedy_jedi_config_type: GreedyJediConfigType,
completion_type: CompletionType,
rt_data: Union[FastArray, Dataset, Categorical, Struct],
):
ip = get_ipython()
ip.user_ns["d"] = rt_data
completions: list
text = get_completion_text(completion_type)
with provisionalcompleter():
if greedy_jedi_config_type == GreedyJediConfigType.GREEDY_JEDI:
with greedy_completion():
with jedi_completion():
completions = list(
ip.Completer.completions(text, len(text)))
elif greedy_jedi_config_type == GreedyJediConfigType.GREEDY:
with greedy_completion():
completions = list(ip.Completer.completions(text, len(text)))
elif greedy_jedi_config_type == GreedyJediConfigType.JEDI:
with jedi_completion():
completions = list(ip.Completer.completions(text, len(text)))
elif greedy_jedi_config_type == GreedyJediConfigType.NEITHER:
completions = list(ip.Completer.completions(text, len(text)))
else:
raise ValueError(
"test_simple_completion: could not handle greedy_jedi_config_type {} of type {}"
.format(greedy_jedi_config_type,
type(greedy_jedi_config_type)))
matches = [completion.text for completion in completions]
if isinstance(rt_data, Categorical):
rt_data = rt_data.categories()
if _get_key_names(rt_data):
for key in rt_data.keys():
assert True, key in matches
def _test_not_complete(reason, s, comp):
l = len(s)
with provisionalcompleter():
completions = set(ip.Completer.completions(s, l))
assert_not_in(Completion(l, l, comp), completions, reason)
def _(line, cursor_pos, expect, message, completion):
_, c = ip.complete('.', line=line, cursor_pos=cursor_pos)
with provisionalcompleter():
completions = ip.Completer.completions(line, cursor_pos)
nt.assert_in(expect, c, message % c)
nt.assert_in(completion, completions)
def test_omit__names():
# 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.')
nt.assert_in('ip.__str__', matches)
nt.assert_in('ip._hidden_attr', matches)
# c.use_jedi = True
# completions = set(c.completions('ip.', 3))
# nt.assert_in(Completion(3, 3, '__str__'), completions)
# nt.assert_in(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.')
nt.assert_not_in('ip.__str__', matches)
# nt.assert_in('ip._hidden_attr', matches)
# c.use_jedi = True
# completions = set(c.completions('ip.', 3))
# nt.assert_not_in(Completion(3,3,'__str__'), completions)
# nt.assert_in(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.')
nt.assert_not_in('ip.__str__', matches)
nt.assert_not_in('ip._hidden_attr', matches)
# c.use_jedi = True
# completions = set(c.completions('ip.', 3))
# nt.assert_not_in(Completion(3,3,'__str__'), completions)
# nt.assert_not_in(Completion(3,3, "_hidden_attr"), completions)
with provisionalcompleter():
c.use_jedi = False
s,matches = c.complete('ip._x.')
nt.assert_in('ip._x.keys', matches)
# c.use_jedi = True
# completions = set(c.completions('ip._x.', 6))
# nt.assert_in(Completion(6,6, "keys"), completions)
del ip._hidden_attr
del ip._x
def _test_not_complete(reason, s, comp):
l = len(s)
with provisionalcompleter():
completions = set(ip.Completer.completions(s, l))
assert_not_in(Completion(l, l, comp), completions, reason)