##// END OF EJS Templates
Do not shadow explicit magic completion....
Matthias Bussonnier -
Show More
@@ -1,2020 +1,2034 b''
1 """Completion for IPython.
1 """Completion for IPython.
2
2
3 This module started as fork of the rlcompleter module in the Python standard
3 This module started as fork of the rlcompleter module in the Python standard
4 library. The original enhancements made to rlcompleter have been sent
4 library. The original enhancements made to rlcompleter have been sent
5 upstream and were accepted as of Python 2.3,
5 upstream and were accepted as of Python 2.3,
6
6
7 This module now support a wide variety of completion mechanism both available
7 This module now support a wide variety of completion mechanism both available
8 for normal classic Python code, as well as completer for IPython specific
8 for normal classic Python code, as well as completer for IPython specific
9 Syntax like magics.
9 Syntax like magics.
10
10
11 Latex and Unicode completion
11 Latex and Unicode completion
12 ============================
12 ============================
13
13
14 IPython and compatible frontends not only can complete your code, but can help
14 IPython and compatible frontends not only can complete your code, but can help
15 you to input a wide range of characters. In particular we allow you to insert
15 you to input a wide range of characters. In particular we allow you to insert
16 a unicode character using the tab completion mechanism.
16 a unicode character using the tab completion mechanism.
17
17
18 Forward latex/unicode completion
18 Forward latex/unicode completion
19 --------------------------------
19 --------------------------------
20
20
21 Forward completion allows you to easily type a unicode character using its latex
21 Forward completion allows you to easily type a unicode character using its latex
22 name, or unicode long description. To do so type a backslash follow by the
22 name, or unicode long description. To do so type a backslash follow by the
23 relevant name and press tab:
23 relevant name and press tab:
24
24
25
25
26 Using latex completion:
26 Using latex completion:
27
27
28 .. code::
28 .. code::
29
29
30 \\alpha<tab>
30 \\alpha<tab>
31 Ξ±
31 Ξ±
32
32
33 or using unicode completion:
33 or using unicode completion:
34
34
35
35
36 .. code::
36 .. code::
37
37
38 \\greek small letter alpha<tab>
38 \\greek small letter alpha<tab>
39 Ξ±
39 Ξ±
40
40
41
41
42 Only valid Python identifiers will complete. Combining characters (like arrow or
42 Only valid Python identifiers will complete. Combining characters (like arrow or
43 dots) are also available, unlike latex they need to be put after the their
43 dots) are also available, unlike latex they need to be put after the their
44 counterpart that is to say, `F\\\\vec<tab>` is correct, not `\\\\vec<tab>F`.
44 counterpart that is to say, `F\\\\vec<tab>` is correct, not `\\\\vec<tab>F`.
45
45
46 Some browsers are known to display combining characters incorrectly.
46 Some browsers are known to display combining characters incorrectly.
47
47
48 Backward latex completion
48 Backward latex completion
49 -------------------------
49 -------------------------
50
50
51 It is sometime challenging to know how to type a character, if you are using
51 It is sometime challenging to know how to type a character, if you are using
52 IPython, or any compatible frontend you can prepend backslash to the character
52 IPython, or any compatible frontend you can prepend backslash to the character
53 and press `<tab>` to expand it to its latex form.
53 and press `<tab>` to expand it to its latex form.
54
54
55 .. code::
55 .. code::
56
56
57 \\Ξ±<tab>
57 \\Ξ±<tab>
58 \\alpha
58 \\alpha
59
59
60
60
61 Both forward and backward completions can be deactivated by setting the
61 Both forward and backward completions can be deactivated by setting the
62 ``Completer.backslash_combining_completions`` option to ``False``.
62 ``Completer.backslash_combining_completions`` option to ``False``.
63
63
64
64
65 Experimental
65 Experimental
66 ============
66 ============
67
67
68 Starting with IPython 6.0, this module can make use of the Jedi library to
68 Starting with IPython 6.0, this module can make use of the Jedi library to
69 generate completions both using static analysis of the code, and dynamically
69 generate completions both using static analysis of the code, and dynamically
70 inspecting multiple namespaces. The APIs attached to this new mechanism is
70 inspecting multiple namespaces. The APIs attached to this new mechanism is
71 unstable and will raise unless use in an :any:`provisionalcompleter` context
71 unstable and will raise unless use in an :any:`provisionalcompleter` context
72 manager.
72 manager.
73
73
74 You will find that the following are experimental:
74 You will find that the following are experimental:
75
75
76 - :any:`provisionalcompleter`
76 - :any:`provisionalcompleter`
77 - :any:`IPCompleter.completions`
77 - :any:`IPCompleter.completions`
78 - :any:`Completion`
78 - :any:`Completion`
79 - :any:`rectify_completions`
79 - :any:`rectify_completions`
80
80
81 .. note::
81 .. note::
82
82
83 better name for :any:`rectify_completions` ?
83 better name for :any:`rectify_completions` ?
84
84
85 We welcome any feedback on these new API, and we also encourage you to try this
85 We welcome any feedback on these new API, and we also encourage you to try this
86 module in debug mode (start IPython with ``--Completer.debug=True``) in order
86 module in debug mode (start IPython with ``--Completer.debug=True``) in order
87 to have extra logging information is :any:`jedi` is crashing, or if current
87 to have extra logging information is :any:`jedi` is crashing, or if current
88 IPython completer pending deprecations are returning results not yet handled
88 IPython completer pending deprecations are returning results not yet handled
89 by :any:`jedi`
89 by :any:`jedi`
90
90
91 Using Jedi for tab completion allow snippets like the following to work without
91 Using Jedi for tab completion allow snippets like the following to work without
92 having to execute any code:
92 having to execute any code:
93
93
94 >>> myvar = ['hello', 42]
94 >>> myvar = ['hello', 42]
95 ... myvar[1].bi<tab>
95 ... myvar[1].bi<tab>
96
96
97 Tab completion will be able to infer that ``myvar[1]`` is a real number without
97 Tab completion will be able to infer that ``myvar[1]`` is a real number without
98 executing any code unlike the previously available ``IPCompleter.greedy``
98 executing any code unlike the previously available ``IPCompleter.greedy``
99 option.
99 option.
100
100
101 Be sure to update :any:`jedi` to the latest stable version or to try the
101 Be sure to update :any:`jedi` to the latest stable version or to try the
102 current development version to get better completions.
102 current development version to get better completions.
103 """
103 """
104
104
105
105
106 # Copyright (c) IPython Development Team.
106 # Copyright (c) IPython Development Team.
107 # Distributed under the terms of the Modified BSD License.
107 # Distributed under the terms of the Modified BSD License.
108 #
108 #
109 # Some of this code originated from rlcompleter in the Python standard library
109 # Some of this code originated from rlcompleter in the Python standard library
110 # Copyright (C) 2001 Python Software Foundation, www.python.org
110 # Copyright (C) 2001 Python Software Foundation, www.python.org
111
111
112
112
113 import __main__
113 import __main__
114 import builtins as builtin_mod
114 import builtins as builtin_mod
115 import glob
115 import glob
116 import time
116 import time
117 import inspect
117 import inspect
118 import itertools
118 import itertools
119 import keyword
119 import keyword
120 import os
120 import os
121 import re
121 import re
122 import sys
122 import sys
123 import unicodedata
123 import unicodedata
124 import string
124 import string
125 import warnings
125 import warnings
126
126
127 from contextlib import contextmanager
127 from contextlib import contextmanager
128 from importlib import import_module
128 from importlib import import_module
129 from typing import Iterator, List, Tuple, Iterable, Union
129 from typing import Iterator, List, Tuple, Iterable, Union
130 from types import SimpleNamespace
130 from types import SimpleNamespace
131
131
132 from traitlets.config.configurable import Configurable
132 from traitlets.config.configurable import Configurable
133 from IPython.core.error import TryNext
133 from IPython.core.error import TryNext
134 from IPython.core.inputsplitter import ESC_MAGIC
134 from IPython.core.inputsplitter import ESC_MAGIC
135 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
135 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
136 from IPython.core.oinspect import InspectColors
136 from IPython.core.oinspect import InspectColors
137 from IPython.utils import generics
137 from IPython.utils import generics
138 from IPython.utils.dir2 import dir2, get_real_method
138 from IPython.utils.dir2 import dir2, get_real_method
139 from IPython.utils.process import arg_split
139 from IPython.utils.process import arg_split
140 from traitlets import Bool, Enum, observe, Int
140 from traitlets import Bool, Enum, observe, Int
141
141
142 # skip module docstests
142 # skip module docstests
143 skip_doctest = True
143 skip_doctest = True
144
144
145 try:
145 try:
146 import jedi
146 import jedi
147 import jedi.api.helpers
147 import jedi.api.helpers
148 import jedi.api.classes
148 import jedi.api.classes
149 JEDI_INSTALLED = True
149 JEDI_INSTALLED = True
150 except ImportError:
150 except ImportError:
151 JEDI_INSTALLED = False
151 JEDI_INSTALLED = False
152 #-----------------------------------------------------------------------------
152 #-----------------------------------------------------------------------------
153 # Globals
153 # Globals
154 #-----------------------------------------------------------------------------
154 #-----------------------------------------------------------------------------
155
155
156 # Public API
156 # Public API
157 __all__ = ['Completer','IPCompleter']
157 __all__ = ['Completer','IPCompleter']
158
158
159 if sys.platform == 'win32':
159 if sys.platform == 'win32':
160 PROTECTABLES = ' '
160 PROTECTABLES = ' '
161 else:
161 else:
162 PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
162 PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
163
163
164 # Protect against returning an enormous number of completions which the frontend
164 # Protect against returning an enormous number of completions which the frontend
165 # may have trouble processing.
165 # may have trouble processing.
166 MATCHES_LIMIT = 500
166 MATCHES_LIMIT = 500
167
167
168 _deprecation_readline_sentinel = object()
168 _deprecation_readline_sentinel = object()
169
169
170
170
171 class ProvisionalCompleterWarning(FutureWarning):
171 class ProvisionalCompleterWarning(FutureWarning):
172 """
172 """
173 Exception raise by an experimental feature in this module.
173 Exception raise by an experimental feature in this module.
174
174
175 Wrap code in :any:`provisionalcompleter` context manager if you
175 Wrap code in :any:`provisionalcompleter` context manager if you
176 are certain you want to use an unstable feature.
176 are certain you want to use an unstable feature.
177 """
177 """
178 pass
178 pass
179
179
180 warnings.filterwarnings('error', category=ProvisionalCompleterWarning)
180 warnings.filterwarnings('error', category=ProvisionalCompleterWarning)
181
181
182 @contextmanager
182 @contextmanager
183 def provisionalcompleter(action='ignore'):
183 def provisionalcompleter(action='ignore'):
184 """
184 """
185
185
186
186
187 This contest manager has to be used in any place where unstable completer
187 This contest manager has to be used in any place where unstable completer
188 behavior and API may be called.
188 behavior and API may be called.
189
189
190 >>> with provisionalcompleter():
190 >>> with provisionalcompleter():
191 ... completer.do_experimetal_things() # works
191 ... completer.do_experimetal_things() # works
192
192
193 >>> completer.do_experimental_things() # raises.
193 >>> completer.do_experimental_things() # raises.
194
194
195 .. note:: Unstable
195 .. note:: Unstable
196
196
197 By using this context manager you agree that the API in use may change
197 By using this context manager you agree that the API in use may change
198 without warning, and that you won't complain if they do so.
198 without warning, and that you won't complain if they do so.
199
199
200 You also understand that if the API is not to you liking you should report
200 You also understand that if the API is not to you liking you should report
201 a bug to explain your use case upstream and improve the API and will loose
201 a bug to explain your use case upstream and improve the API and will loose
202 credibility if you complain after the API is make stable.
202 credibility if you complain after the API is make stable.
203
203
204 We'll be happy to get your feedback , feature request and improvement on
204 We'll be happy to get your feedback , feature request and improvement on
205 any of the unstable APIs !
205 any of the unstable APIs !
206 """
206 """
207 with warnings.catch_warnings():
207 with warnings.catch_warnings():
208 warnings.filterwarnings(action, category=ProvisionalCompleterWarning)
208 warnings.filterwarnings(action, category=ProvisionalCompleterWarning)
209 yield
209 yield
210
210
211
211
212 def has_open_quotes(s):
212 def has_open_quotes(s):
213 """Return whether a string has open quotes.
213 """Return whether a string has open quotes.
214
214
215 This simply counts whether the number of quote characters of either type in
215 This simply counts whether the number of quote characters of either type in
216 the string is odd.
216 the string is odd.
217
217
218 Returns
218 Returns
219 -------
219 -------
220 If there is an open quote, the quote character is returned. Else, return
220 If there is an open quote, the quote character is returned. Else, return
221 False.
221 False.
222 """
222 """
223 # We check " first, then ', so complex cases with nested quotes will get
223 # We check " first, then ', so complex cases with nested quotes will get
224 # the " to take precedence.
224 # the " to take precedence.
225 if s.count('"') % 2:
225 if s.count('"') % 2:
226 return '"'
226 return '"'
227 elif s.count("'") % 2:
227 elif s.count("'") % 2:
228 return "'"
228 return "'"
229 else:
229 else:
230 return False
230 return False
231
231
232
232
233 def protect_filename(s, protectables=PROTECTABLES):
233 def protect_filename(s, protectables=PROTECTABLES):
234 """Escape a string to protect certain characters."""
234 """Escape a string to protect certain characters."""
235 if set(s) & set(protectables):
235 if set(s) & set(protectables):
236 if sys.platform == "win32":
236 if sys.platform == "win32":
237 return '"' + s + '"'
237 return '"' + s + '"'
238 else:
238 else:
239 return "".join(("\\" + c if c in protectables else c) for c in s)
239 return "".join(("\\" + c if c in protectables else c) for c in s)
240 else:
240 else:
241 return s
241 return s
242
242
243
243
244 def expand_user(path:str) -> Tuple[str, bool, str]:
244 def expand_user(path:str) -> Tuple[str, bool, str]:
245 """Expand ``~``-style usernames in strings.
245 """Expand ``~``-style usernames in strings.
246
246
247 This is similar to :func:`os.path.expanduser`, but it computes and returns
247 This is similar to :func:`os.path.expanduser`, but it computes and returns
248 extra information that will be useful if the input was being used in
248 extra information that will be useful if the input was being used in
249 computing completions, and you wish to return the completions with the
249 computing completions, and you wish to return the completions with the
250 original '~' instead of its expanded value.
250 original '~' instead of its expanded value.
251
251
252 Parameters
252 Parameters
253 ----------
253 ----------
254 path : str
254 path : str
255 String to be expanded. If no ~ is present, the output is the same as the
255 String to be expanded. If no ~ is present, the output is the same as the
256 input.
256 input.
257
257
258 Returns
258 Returns
259 -------
259 -------
260 newpath : str
260 newpath : str
261 Result of ~ expansion in the input path.
261 Result of ~ expansion in the input path.
262 tilde_expand : bool
262 tilde_expand : bool
263 Whether any expansion was performed or not.
263 Whether any expansion was performed or not.
264 tilde_val : str
264 tilde_val : str
265 The value that ~ was replaced with.
265 The value that ~ was replaced with.
266 """
266 """
267 # Default values
267 # Default values
268 tilde_expand = False
268 tilde_expand = False
269 tilde_val = ''
269 tilde_val = ''
270 newpath = path
270 newpath = path
271
271
272 if path.startswith('~'):
272 if path.startswith('~'):
273 tilde_expand = True
273 tilde_expand = True
274 rest = len(path)-1
274 rest = len(path)-1
275 newpath = os.path.expanduser(path)
275 newpath = os.path.expanduser(path)
276 if rest:
276 if rest:
277 tilde_val = newpath[:-rest]
277 tilde_val = newpath[:-rest]
278 else:
278 else:
279 tilde_val = newpath
279 tilde_val = newpath
280
280
281 return newpath, tilde_expand, tilde_val
281 return newpath, tilde_expand, tilde_val
282
282
283
283
284 def compress_user(path:str, tilde_expand:bool, tilde_val:str) -> str:
284 def compress_user(path:str, tilde_expand:bool, tilde_val:str) -> str:
285 """Does the opposite of expand_user, with its outputs.
285 """Does the opposite of expand_user, with its outputs.
286 """
286 """
287 if tilde_expand:
287 if tilde_expand:
288 return path.replace(tilde_val, '~')
288 return path.replace(tilde_val, '~')
289 else:
289 else:
290 return path
290 return path
291
291
292
292
293 def completions_sorting_key(word):
293 def completions_sorting_key(word):
294 """key for sorting completions
294 """key for sorting completions
295
295
296 This does several things:
296 This does several things:
297
297
298 - Demote any completions starting with underscores to the end
298 - Demote any completions starting with underscores to the end
299 - Insert any %magic and %%cellmagic completions in the alphabetical order
299 - Insert any %magic and %%cellmagic completions in the alphabetical order
300 by their name
300 by their name
301 """
301 """
302 prio1, prio2 = 0, 0
302 prio1, prio2 = 0, 0
303
303
304 if word.startswith('__'):
304 if word.startswith('__'):
305 prio1 = 2
305 prio1 = 2
306 elif word.startswith('_'):
306 elif word.startswith('_'):
307 prio1 = 1
307 prio1 = 1
308
308
309 if word.endswith('='):
309 if word.endswith('='):
310 prio1 = -1
310 prio1 = -1
311
311
312 if word.startswith('%%'):
312 if word.startswith('%%'):
313 # If there's another % in there, this is something else, so leave it alone
313 # If there's another % in there, this is something else, so leave it alone
314 if not "%" in word[2:]:
314 if not "%" in word[2:]:
315 word = word[2:]
315 word = word[2:]
316 prio2 = 2
316 prio2 = 2
317 elif word.startswith('%'):
317 elif word.startswith('%'):
318 if not "%" in word[1:]:
318 if not "%" in word[1:]:
319 word = word[1:]
319 word = word[1:]
320 prio2 = 1
320 prio2 = 1
321
321
322 return prio1, word, prio2
322 return prio1, word, prio2
323
323
324
324
325 class _FakeJediCompletion:
325 class _FakeJediCompletion:
326 """
326 """
327 This is a workaround to communicate to the UI that Jedi has crashed and to
327 This is a workaround to communicate to the UI that Jedi has crashed and to
328 report a bug. Will be used only id :any:`IPCompleter.debug` is set to true.
328 report a bug. Will be used only id :any:`IPCompleter.debug` is set to true.
329
329
330 Added in IPython 6.0 so should likely be removed for 7.0
330 Added in IPython 6.0 so should likely be removed for 7.0
331
331
332 """
332 """
333
333
334 def __init__(self, name):
334 def __init__(self, name):
335
335
336 self.name = name
336 self.name = name
337 self.complete = name
337 self.complete = name
338 self.type = 'crashed'
338 self.type = 'crashed'
339 self.name_with_symbols = name
339 self.name_with_symbols = name
340 self.signature = ''
340 self.signature = ''
341 self._origin = 'fake'
341 self._origin = 'fake'
342
342
343 def __repr__(self):
343 def __repr__(self):
344 return '<Fake completion object jedi has crashed>'
344 return '<Fake completion object jedi has crashed>'
345
345
346
346
347 class Completion:
347 class Completion:
348 """
348 """
349 Completion object used and return by IPython completers.
349 Completion object used and return by IPython completers.
350
350
351 .. warning:: Unstable
351 .. warning:: Unstable
352
352
353 This function is unstable, API may change without warning.
353 This function is unstable, API may change without warning.
354 It will also raise unless use in proper context manager.
354 It will also raise unless use in proper context manager.
355
355
356 This act as a middle ground :any:`Completion` object between the
356 This act as a middle ground :any:`Completion` object between the
357 :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
357 :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
358 object. While Jedi need a lot of information about evaluator and how the
358 object. While Jedi need a lot of information about evaluator and how the
359 code should be ran/inspected, PromptToolkit (and other frontend) mostly
359 code should be ran/inspected, PromptToolkit (and other frontend) mostly
360 need user facing information.
360 need user facing information.
361
361
362 - Which range should be replaced replaced by what.
362 - Which range should be replaced replaced by what.
363 - Some metadata (like completion type), or meta informations to displayed to
363 - Some metadata (like completion type), or meta informations to displayed to
364 the use user.
364 the use user.
365
365
366 For debugging purpose we can also store the origin of the completion (``jedi``,
366 For debugging purpose we can also store the origin of the completion (``jedi``,
367 ``IPython.python_matches``, ``IPython.magics_matches``...).
367 ``IPython.python_matches``, ``IPython.magics_matches``...).
368 """
368 """
369
369
370 __slots__ = ['start', 'end', 'text', 'type', 'signature', '_origin']
370 __slots__ = ['start', 'end', 'text', 'type', 'signature', '_origin']
371
371
372 def __init__(self, start: int, end: int, text: str, *, type: str=None, _origin='', signature='') -> None:
372 def __init__(self, start: int, end: int, text: str, *, type: str=None, _origin='', signature='') -> None:
373 warnings.warn("``Completion`` is a provisional API (as of IPython 6.0). "
373 warnings.warn("``Completion`` is a provisional API (as of IPython 6.0). "
374 "It may change without warnings. "
374 "It may change without warnings. "
375 "Use in corresponding context manager.",
375 "Use in corresponding context manager.",
376 category=ProvisionalCompleterWarning, stacklevel=2)
376 category=ProvisionalCompleterWarning, stacklevel=2)
377
377
378 self.start = start
378 self.start = start
379 self.end = end
379 self.end = end
380 self.text = text
380 self.text = text
381 self.type = type
381 self.type = type
382 self.signature = signature
382 self.signature = signature
383 self._origin = _origin
383 self._origin = _origin
384
384
385 def __repr__(self):
385 def __repr__(self):
386 return '<Completion start=%s end=%s text=%r type=%r, signature=%r,>' % \
386 return '<Completion start=%s end=%s text=%r type=%r, signature=%r,>' % \
387 (self.start, self.end, self.text, self.type or '?', self.signature or '?')
387 (self.start, self.end, self.text, self.type or '?', self.signature or '?')
388
388
389 def __eq__(self, other)->Bool:
389 def __eq__(self, other)->Bool:
390 """
390 """
391 Equality and hash do not hash the type (as some completer may not be
391 Equality and hash do not hash the type (as some completer may not be
392 able to infer the type), but are use to (partially) de-duplicate
392 able to infer the type), but are use to (partially) de-duplicate
393 completion.
393 completion.
394
394
395 Completely de-duplicating completion is a bit tricker that just
395 Completely de-duplicating completion is a bit tricker that just
396 comparing as it depends on surrounding text, which Completions are not
396 comparing as it depends on surrounding text, which Completions are not
397 aware of.
397 aware of.
398 """
398 """
399 return self.start == other.start and \
399 return self.start == other.start and \
400 self.end == other.end and \
400 self.end == other.end and \
401 self.text == other.text
401 self.text == other.text
402
402
403 def __hash__(self):
403 def __hash__(self):
404 return hash((self.start, self.end, self.text))
404 return hash((self.start, self.end, self.text))
405
405
406
406
407 _IC = Iterable[Completion]
407 _IC = Iterable[Completion]
408
408
409
409
410 def _deduplicate_completions(text: str, completions: _IC)-> _IC:
410 def _deduplicate_completions(text: str, completions: _IC)-> _IC:
411 """
411 """
412 Deduplicate a set of completions.
412 Deduplicate a set of completions.
413
413
414 .. warning:: Unstable
414 .. warning:: Unstable
415
415
416 This function is unstable, API may change without warning.
416 This function is unstable, API may change without warning.
417
417
418 Parameters
418 Parameters
419 ----------
419 ----------
420 text: str
420 text: str
421 text that should be completed.
421 text that should be completed.
422 completions: Iterator[Completion]
422 completions: Iterator[Completion]
423 iterator over the completions to deduplicate
423 iterator over the completions to deduplicate
424
424
425 Yields
425 Yields
426 ------
426 ------
427 `Completions` objects
427 `Completions` objects
428
428
429
429
430 Completions coming from multiple sources, may be different but end up having
430 Completions coming from multiple sources, may be different but end up having
431 the same effect when applied to ``text``. If this is the case, this will
431 the same effect when applied to ``text``. If this is the case, this will
432 consider completions as equal and only emit the first encountered.
432 consider completions as equal and only emit the first encountered.
433
433
434 Not folded in `completions()` yet for debugging purpose, and to detect when
434 Not folded in `completions()` yet for debugging purpose, and to detect when
435 the IPython completer does return things that Jedi does not, but should be
435 the IPython completer does return things that Jedi does not, but should be
436 at some point.
436 at some point.
437 """
437 """
438 completions = list(completions)
438 completions = list(completions)
439 if not completions:
439 if not completions:
440 return
440 return
441
441
442 new_start = min(c.start for c in completions)
442 new_start = min(c.start for c in completions)
443 new_end = max(c.end for c in completions)
443 new_end = max(c.end for c in completions)
444
444
445 seen = set()
445 seen = set()
446 for c in completions:
446 for c in completions:
447 new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
447 new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
448 if new_text not in seen:
448 if new_text not in seen:
449 yield c
449 yield c
450 seen.add(new_text)
450 seen.add(new_text)
451
451
452
452
453 def rectify_completions(text: str, completions: _IC, *, _debug=False)->_IC:
453 def rectify_completions(text: str, completions: _IC, *, _debug=False)->_IC:
454 """
454 """
455 Rectify a set of completions to all have the same ``start`` and ``end``
455 Rectify a set of completions to all have the same ``start`` and ``end``
456
456
457 .. warning:: Unstable
457 .. warning:: Unstable
458
458
459 This function is unstable, API may change without warning.
459 This function is unstable, API may change without warning.
460 It will also raise unless use in proper context manager.
460 It will also raise unless use in proper context manager.
461
461
462 Parameters
462 Parameters
463 ----------
463 ----------
464 text: str
464 text: str
465 text that should be completed.
465 text that should be completed.
466 completions: Iterator[Completion]
466 completions: Iterator[Completion]
467 iterator over the completions to rectify
467 iterator over the completions to rectify
468
468
469
469
470 :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
470 :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
471 the Jupyter Protocol requires them to behave like so. This will readjust
471 the Jupyter Protocol requires them to behave like so. This will readjust
472 the completion to have the same ``start`` and ``end`` by padding both
472 the completion to have the same ``start`` and ``end`` by padding both
473 extremities with surrounding text.
473 extremities with surrounding text.
474
474
475 During stabilisation should support a ``_debug`` option to log which
475 During stabilisation should support a ``_debug`` option to log which
476 completion are return by the IPython completer and not found in Jedi in
476 completion are return by the IPython completer and not found in Jedi in
477 order to make upstream bug report.
477 order to make upstream bug report.
478 """
478 """
479 warnings.warn("`rectify_completions` is a provisional API (as of IPython 6.0). "
479 warnings.warn("`rectify_completions` is a provisional API (as of IPython 6.0). "
480 "It may change without warnings. "
480 "It may change without warnings. "
481 "Use in corresponding context manager.",
481 "Use in corresponding context manager.",
482 category=ProvisionalCompleterWarning, stacklevel=2)
482 category=ProvisionalCompleterWarning, stacklevel=2)
483
483
484 completions = list(completions)
484 completions = list(completions)
485 if not completions:
485 if not completions:
486 return
486 return
487 starts = (c.start for c in completions)
487 starts = (c.start for c in completions)
488 ends = (c.end for c in completions)
488 ends = (c.end for c in completions)
489
489
490 new_start = min(starts)
490 new_start = min(starts)
491 new_end = max(ends)
491 new_end = max(ends)
492
492
493 seen_jedi = set()
493 seen_jedi = set()
494 seen_python_matches = set()
494 seen_python_matches = set()
495 for c in completions:
495 for c in completions:
496 new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
496 new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
497 if c._origin == 'jedi':
497 if c._origin == 'jedi':
498 seen_jedi.add(new_text)
498 seen_jedi.add(new_text)
499 elif c._origin == 'IPCompleter.python_matches':
499 elif c._origin == 'IPCompleter.python_matches':
500 seen_python_matches.add(new_text)
500 seen_python_matches.add(new_text)
501 yield Completion(new_start, new_end, new_text, type=c.type, _origin=c._origin, signature=c.signature)
501 yield Completion(new_start, new_end, new_text, type=c.type, _origin=c._origin, signature=c.signature)
502 diff = seen_python_matches.difference(seen_jedi)
502 diff = seen_python_matches.difference(seen_jedi)
503 if diff and _debug:
503 if diff and _debug:
504 print('IPython.python matches have extras:', diff)
504 print('IPython.python matches have extras:', diff)
505
505
506
506
507 if sys.platform == 'win32':
507 if sys.platform == 'win32':
508 DELIMS = ' \t\n`!@#$^&*()=+[{]}|;\'",<>?'
508 DELIMS = ' \t\n`!@#$^&*()=+[{]}|;\'",<>?'
509 else:
509 else:
510 DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
510 DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
511
511
512 GREEDY_DELIMS = ' =\r\n'
512 GREEDY_DELIMS = ' =\r\n'
513
513
514
514
515 class CompletionSplitter(object):
515 class CompletionSplitter(object):
516 """An object to split an input line in a manner similar to readline.
516 """An object to split an input line in a manner similar to readline.
517
517
518 By having our own implementation, we can expose readline-like completion in
518 By having our own implementation, we can expose readline-like completion in
519 a uniform manner to all frontends. This object only needs to be given the
519 a uniform manner to all frontends. This object only needs to be given the
520 line of text to be split and the cursor position on said line, and it
520 line of text to be split and the cursor position on said line, and it
521 returns the 'word' to be completed on at the cursor after splitting the
521 returns the 'word' to be completed on at the cursor after splitting the
522 entire line.
522 entire line.
523
523
524 What characters are used as splitting delimiters can be controlled by
524 What characters are used as splitting delimiters can be controlled by
525 setting the ``delims`` attribute (this is a property that internally
525 setting the ``delims`` attribute (this is a property that internally
526 automatically builds the necessary regular expression)"""
526 automatically builds the necessary regular expression)"""
527
527
528 # Private interface
528 # Private interface
529
529
530 # A string of delimiter characters. The default value makes sense for
530 # A string of delimiter characters. The default value makes sense for
531 # IPython's most typical usage patterns.
531 # IPython's most typical usage patterns.
532 _delims = DELIMS
532 _delims = DELIMS
533
533
534 # The expression (a normal string) to be compiled into a regular expression
534 # The expression (a normal string) to be compiled into a regular expression
535 # for actual splitting. We store it as an attribute mostly for ease of
535 # for actual splitting. We store it as an attribute mostly for ease of
536 # debugging, since this type of code can be so tricky to debug.
536 # debugging, since this type of code can be so tricky to debug.
537 _delim_expr = None
537 _delim_expr = None
538
538
539 # The regular expression that does the actual splitting
539 # The regular expression that does the actual splitting
540 _delim_re = None
540 _delim_re = None
541
541
542 def __init__(self, delims=None):
542 def __init__(self, delims=None):
543 delims = CompletionSplitter._delims if delims is None else delims
543 delims = CompletionSplitter._delims if delims is None else delims
544 self.delims = delims
544 self.delims = delims
545
545
546 @property
546 @property
547 def delims(self):
547 def delims(self):
548 """Return the string of delimiter characters."""
548 """Return the string of delimiter characters."""
549 return self._delims
549 return self._delims
550
550
551 @delims.setter
551 @delims.setter
552 def delims(self, delims):
552 def delims(self, delims):
553 """Set the delimiters for line splitting."""
553 """Set the delimiters for line splitting."""
554 expr = '[' + ''.join('\\'+ c for c in delims) + ']'
554 expr = '[' + ''.join('\\'+ c for c in delims) + ']'
555 self._delim_re = re.compile(expr)
555 self._delim_re = re.compile(expr)
556 self._delims = delims
556 self._delims = delims
557 self._delim_expr = expr
557 self._delim_expr = expr
558
558
559 def split_line(self, line, cursor_pos=None):
559 def split_line(self, line, cursor_pos=None):
560 """Split a line of text with a cursor at the given position.
560 """Split a line of text with a cursor at the given position.
561 """
561 """
562 l = line if cursor_pos is None else line[:cursor_pos]
562 l = line if cursor_pos is None else line[:cursor_pos]
563 return self._delim_re.split(l)[-1]
563 return self._delim_re.split(l)[-1]
564
564
565
565
566
566
567 class Completer(Configurable):
567 class Completer(Configurable):
568
568
569 greedy = Bool(False,
569 greedy = Bool(False,
570 help="""Activate greedy completion
570 help="""Activate greedy completion
571 PENDING DEPRECTION. this is now mostly taken care of with Jedi.
571 PENDING DEPRECTION. this is now mostly taken care of with Jedi.
572
572
573 This will enable completion on elements of lists, results of function calls, etc.,
573 This will enable completion on elements of lists, results of function calls, etc.,
574 but can be unsafe because the code is actually evaluated on TAB.
574 but can be unsafe because the code is actually evaluated on TAB.
575 """
575 """
576 ).tag(config=True)
576 ).tag(config=True)
577
577
578 use_jedi = Bool(default_value=JEDI_INSTALLED,
578 use_jedi = Bool(default_value=JEDI_INSTALLED,
579 help="Experimental: Use Jedi to generate autocompletions. "
579 help="Experimental: Use Jedi to generate autocompletions. "
580 "Default to True if jedi is installed").tag(config=True)
580 "Default to True if jedi is installed").tag(config=True)
581
581
582 jedi_compute_type_timeout = Int(default_value=400,
582 jedi_compute_type_timeout = Int(default_value=400,
583 help="""Experimental: restrict time (in milliseconds) during which Jedi can compute types.
583 help="""Experimental: restrict time (in milliseconds) during which Jedi can compute types.
584 Set to 0 to stop computing types. Non-zero value lower than 100ms may hurt
584 Set to 0 to stop computing types. Non-zero value lower than 100ms may hurt
585 performance by preventing jedi to build its cache.
585 performance by preventing jedi to build its cache.
586 """).tag(config=True)
586 """).tag(config=True)
587
587
588 debug = Bool(default_value=False,
588 debug = Bool(default_value=False,
589 help='Enable debug for the Completer. Mostly print extra '
589 help='Enable debug for the Completer. Mostly print extra '
590 'information for experimental jedi integration.')\
590 'information for experimental jedi integration.')\
591 .tag(config=True)
591 .tag(config=True)
592
592
593 backslash_combining_completions = Bool(True,
593 backslash_combining_completions = Bool(True,
594 help="Enable unicode completions, e.g. \\alpha<tab> . "
594 help="Enable unicode completions, e.g. \\alpha<tab> . "
595 "Includes completion of latex commands, unicode names, and expanding "
595 "Includes completion of latex commands, unicode names, and expanding "
596 "unicode characters back to latex commands.").tag(config=True)
596 "unicode characters back to latex commands.").tag(config=True)
597
597
598
598
599
599
600 def __init__(self, namespace=None, global_namespace=None, **kwargs):
600 def __init__(self, namespace=None, global_namespace=None, **kwargs):
601 """Create a new completer for the command line.
601 """Create a new completer for the command line.
602
602
603 Completer(namespace=ns, global_namespace=ns2) -> completer instance.
603 Completer(namespace=ns, global_namespace=ns2) -> completer instance.
604
604
605 If unspecified, the default namespace where completions are performed
605 If unspecified, the default namespace where completions are performed
606 is __main__ (technically, __main__.__dict__). Namespaces should be
606 is __main__ (technically, __main__.__dict__). Namespaces should be
607 given as dictionaries.
607 given as dictionaries.
608
608
609 An optional second namespace can be given. This allows the completer
609 An optional second namespace can be given. This allows the completer
610 to handle cases where both the local and global scopes need to be
610 to handle cases where both the local and global scopes need to be
611 distinguished.
611 distinguished.
612 """
612 """
613
613
614 # Don't bind to namespace quite yet, but flag whether the user wants a
614 # Don't bind to namespace quite yet, but flag whether the user wants a
615 # specific namespace or to use __main__.__dict__. This will allow us
615 # specific namespace or to use __main__.__dict__. This will allow us
616 # to bind to __main__.__dict__ at completion time, not now.
616 # to bind to __main__.__dict__ at completion time, not now.
617 if namespace is None:
617 if namespace is None:
618 self.use_main_ns = True
618 self.use_main_ns = True
619 else:
619 else:
620 self.use_main_ns = False
620 self.use_main_ns = False
621 self.namespace = namespace
621 self.namespace = namespace
622
622
623 # The global namespace, if given, can be bound directly
623 # The global namespace, if given, can be bound directly
624 if global_namespace is None:
624 if global_namespace is None:
625 self.global_namespace = {}
625 self.global_namespace = {}
626 else:
626 else:
627 self.global_namespace = global_namespace
627 self.global_namespace = global_namespace
628
628
629 super(Completer, self).__init__(**kwargs)
629 super(Completer, self).__init__(**kwargs)
630
630
631 def complete(self, text, state):
631 def complete(self, text, state):
632 """Return the next possible completion for 'text'.
632 """Return the next possible completion for 'text'.
633
633
634 This is called successively with state == 0, 1, 2, ... until it
634 This is called successively with state == 0, 1, 2, ... until it
635 returns None. The completion should begin with 'text'.
635 returns None. The completion should begin with 'text'.
636
636
637 """
637 """
638 if self.use_main_ns:
638 if self.use_main_ns:
639 self.namespace = __main__.__dict__
639 self.namespace = __main__.__dict__
640
640
641 if state == 0:
641 if state == 0:
642 if "." in text:
642 if "." in text:
643 self.matches = self.attr_matches(text)
643 self.matches = self.attr_matches(text)
644 else:
644 else:
645 self.matches = self.global_matches(text)
645 self.matches = self.global_matches(text)
646 try:
646 try:
647 return self.matches[state]
647 return self.matches[state]
648 except IndexError:
648 except IndexError:
649 return None
649 return None
650
650
651 def global_matches(self, text):
651 def global_matches(self, text):
652 """Compute matches when text is a simple name.
652 """Compute matches when text is a simple name.
653
653
654 Return a list of all keywords, built-in functions and names currently
654 Return a list of all keywords, built-in functions and names currently
655 defined in self.namespace or self.global_namespace that match.
655 defined in self.namespace or self.global_namespace that match.
656
656
657 """
657 """
658 matches = []
658 matches = []
659 match_append = matches.append
659 match_append = matches.append
660 n = len(text)
660 n = len(text)
661 for lst in [keyword.kwlist,
661 for lst in [keyword.kwlist,
662 builtin_mod.__dict__.keys(),
662 builtin_mod.__dict__.keys(),
663 self.namespace.keys(),
663 self.namespace.keys(),
664 self.global_namespace.keys()]:
664 self.global_namespace.keys()]:
665 for word in lst:
665 for word in lst:
666 if word[:n] == text and word != "__builtins__":
666 if word[:n] == text and word != "__builtins__":
667 match_append(word)
667 match_append(word)
668
668
669 snake_case_re = re.compile(r"[^_]+(_[^_]+)+?\Z")
669 snake_case_re = re.compile(r"[^_]+(_[^_]+)+?\Z")
670 for lst in [self.namespace.keys(),
670 for lst in [self.namespace.keys(),
671 self.global_namespace.keys()]:
671 self.global_namespace.keys()]:
672 shortened = {"_".join([sub[0] for sub in word.split('_')]) : word
672 shortened = {"_".join([sub[0] for sub in word.split('_')]) : word
673 for word in lst if snake_case_re.match(word)}
673 for word in lst if snake_case_re.match(word)}
674 for word in shortened.keys():
674 for word in shortened.keys():
675 if word[:n] == text and word != "__builtins__":
675 if word[:n] == text and word != "__builtins__":
676 match_append(shortened[word])
676 match_append(shortened[word])
677 return matches
677 return matches
678
678
679 def attr_matches(self, text):
679 def attr_matches(self, text):
680 """Compute matches when text contains a dot.
680 """Compute matches when text contains a dot.
681
681
682 Assuming the text is of the form NAME.NAME....[NAME], and is
682 Assuming the text is of the form NAME.NAME....[NAME], and is
683 evaluatable in self.namespace or self.global_namespace, it will be
683 evaluatable in self.namespace or self.global_namespace, it will be
684 evaluated and its attributes (as revealed by dir()) are used as
684 evaluated and its attributes (as revealed by dir()) are used as
685 possible completions. (For class instances, class members are are
685 possible completions. (For class instances, class members are are
686 also considered.)
686 also considered.)
687
687
688 WARNING: this can still invoke arbitrary C code, if an object
688 WARNING: this can still invoke arbitrary C code, if an object
689 with a __getattr__ hook is evaluated.
689 with a __getattr__ hook is evaluated.
690
690
691 """
691 """
692
692
693 # Another option, seems to work great. Catches things like ''.<tab>
693 # Another option, seems to work great. Catches things like ''.<tab>
694 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
694 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
695
695
696 if m:
696 if m:
697 expr, attr = m.group(1, 3)
697 expr, attr = m.group(1, 3)
698 elif self.greedy:
698 elif self.greedy:
699 m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
699 m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
700 if not m2:
700 if not m2:
701 return []
701 return []
702 expr, attr = m2.group(1,2)
702 expr, attr = m2.group(1,2)
703 else:
703 else:
704 return []
704 return []
705
705
706 try:
706 try:
707 obj = eval(expr, self.namespace)
707 obj = eval(expr, self.namespace)
708 except:
708 except:
709 try:
709 try:
710 obj = eval(expr, self.global_namespace)
710 obj = eval(expr, self.global_namespace)
711 except:
711 except:
712 return []
712 return []
713
713
714 if self.limit_to__all__ and hasattr(obj, '__all__'):
714 if self.limit_to__all__ and hasattr(obj, '__all__'):
715 words = get__all__entries(obj)
715 words = get__all__entries(obj)
716 else:
716 else:
717 words = dir2(obj)
717 words = dir2(obj)
718
718
719 try:
719 try:
720 words = generics.complete_object(obj, words)
720 words = generics.complete_object(obj, words)
721 except TryNext:
721 except TryNext:
722 pass
722 pass
723 except AssertionError:
723 except AssertionError:
724 raise
724 raise
725 except Exception:
725 except Exception:
726 # Silence errors from completion function
726 # Silence errors from completion function
727 #raise # dbg
727 #raise # dbg
728 pass
728 pass
729 # Build match list to return
729 # Build match list to return
730 n = len(attr)
730 n = len(attr)
731 return [u"%s.%s" % (expr, w) for w in words if w[:n] == attr ]
731 return [u"%s.%s" % (expr, w) for w in words if w[:n] == attr ]
732
732
733
733
734 def get__all__entries(obj):
734 def get__all__entries(obj):
735 """returns the strings in the __all__ attribute"""
735 """returns the strings in the __all__ attribute"""
736 try:
736 try:
737 words = getattr(obj, '__all__')
737 words = getattr(obj, '__all__')
738 except:
738 except:
739 return []
739 return []
740
740
741 return [w for w in words if isinstance(w, str)]
741 return [w for w in words if isinstance(w, str)]
742
742
743
743
744 def match_dict_keys(keys: List[str], prefix: str, delims: str):
744 def match_dict_keys(keys: List[str], prefix: str, delims: str):
745 """Used by dict_key_matches, matching the prefix to a list of keys
745 """Used by dict_key_matches, matching the prefix to a list of keys
746
746
747 Parameters
747 Parameters
748 ==========
748 ==========
749 keys:
749 keys:
750 list of keys in dictionary currently being completed.
750 list of keys in dictionary currently being completed.
751 prefix:
751 prefix:
752 Part of the text already typed by the user. e.g. `mydict[b'fo`
752 Part of the text already typed by the user. e.g. `mydict[b'fo`
753 delims:
753 delims:
754 String of delimiters to consider when finding the current key.
754 String of delimiters to consider when finding the current key.
755
755
756 Returns
756 Returns
757 =======
757 =======
758
758
759 A tuple of three elements: ``quote``, ``token_start``, ``matched``, with
759 A tuple of three elements: ``quote``, ``token_start``, ``matched``, with
760 ``quote`` being the quote that need to be used to close current string.
760 ``quote`` being the quote that need to be used to close current string.
761 ``token_start`` the position where the replacement should start occurring,
761 ``token_start`` the position where the replacement should start occurring,
762 ``matches`` a list of replacement/completion
762 ``matches`` a list of replacement/completion
763
763
764 """
764 """
765 if not prefix:
765 if not prefix:
766 return None, 0, [repr(k) for k in keys
766 return None, 0, [repr(k) for k in keys
767 if isinstance(k, (str, bytes))]
767 if isinstance(k, (str, bytes))]
768 quote_match = re.search('["\']', prefix)
768 quote_match = re.search('["\']', prefix)
769 quote = quote_match.group()
769 quote = quote_match.group()
770 try:
770 try:
771 prefix_str = eval(prefix + quote, {})
771 prefix_str = eval(prefix + quote, {})
772 except Exception:
772 except Exception:
773 return None, 0, []
773 return None, 0, []
774
774
775 pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
775 pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
776 token_match = re.search(pattern, prefix, re.UNICODE)
776 token_match = re.search(pattern, prefix, re.UNICODE)
777 token_start = token_match.start()
777 token_start = token_match.start()
778 token_prefix = token_match.group()
778 token_prefix = token_match.group()
779
779
780 matched = []
780 matched = []
781 for key in keys:
781 for key in keys:
782 try:
782 try:
783 if not key.startswith(prefix_str):
783 if not key.startswith(prefix_str):
784 continue
784 continue
785 except (AttributeError, TypeError, UnicodeError):
785 except (AttributeError, TypeError, UnicodeError):
786 # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
786 # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
787 continue
787 continue
788
788
789 # reformat remainder of key to begin with prefix
789 # reformat remainder of key to begin with prefix
790 rem = key[len(prefix_str):]
790 rem = key[len(prefix_str):]
791 # force repr wrapped in '
791 # force repr wrapped in '
792 rem_repr = repr(rem + '"') if isinstance(rem, str) else repr(rem + b'"')
792 rem_repr = repr(rem + '"') if isinstance(rem, str) else repr(rem + b'"')
793 if rem_repr.startswith('u') and prefix[0] not in 'uU':
793 if rem_repr.startswith('u') and prefix[0] not in 'uU':
794 # Found key is unicode, but prefix is Py2 string.
794 # Found key is unicode, but prefix is Py2 string.
795 # Therefore attempt to interpret key as string.
795 # Therefore attempt to interpret key as string.
796 try:
796 try:
797 rem_repr = repr(rem.encode('ascii') + '"')
797 rem_repr = repr(rem.encode('ascii') + '"')
798 except UnicodeEncodeError:
798 except UnicodeEncodeError:
799 continue
799 continue
800
800
801 rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
801 rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
802 if quote == '"':
802 if quote == '"':
803 # The entered prefix is quoted with ",
803 # The entered prefix is quoted with ",
804 # but the match is quoted with '.
804 # but the match is quoted with '.
805 # A contained " hence needs escaping for comparison:
805 # A contained " hence needs escaping for comparison:
806 rem_repr = rem_repr.replace('"', '\\"')
806 rem_repr = rem_repr.replace('"', '\\"')
807
807
808 # then reinsert prefix from start of token
808 # then reinsert prefix from start of token
809 matched.append('%s%s' % (token_prefix, rem_repr))
809 matched.append('%s%s' % (token_prefix, rem_repr))
810 return quote, token_start, matched
810 return quote, token_start, matched
811
811
812
812
813 def cursor_to_position(text:str, line:int, column:int)->int:
813 def cursor_to_position(text:str, line:int, column:int)->int:
814 """
814 """
815
815
816 Convert the (line,column) position of the cursor in text to an offset in a
816 Convert the (line,column) position of the cursor in text to an offset in a
817 string.
817 string.
818
818
819 Parameters
819 Parameters
820 ----------
820 ----------
821
821
822 text : str
822 text : str
823 The text in which to calculate the cursor offset
823 The text in which to calculate the cursor offset
824 line : int
824 line : int
825 Line of the cursor; 0-indexed
825 Line of the cursor; 0-indexed
826 column : int
826 column : int
827 Column of the cursor 0-indexed
827 Column of the cursor 0-indexed
828
828
829 Return
829 Return
830 ------
830 ------
831 Position of the cursor in ``text``, 0-indexed.
831 Position of the cursor in ``text``, 0-indexed.
832
832
833 See Also
833 See Also
834 --------
834 --------
835 position_to_cursor: reciprocal of this function
835 position_to_cursor: reciprocal of this function
836
836
837 """
837 """
838 lines = text.split('\n')
838 lines = text.split('\n')
839 assert line <= len(lines), '{} <= {}'.format(str(line), str(len(lines)))
839 assert line <= len(lines), '{} <= {}'.format(str(line), str(len(lines)))
840
840
841 return sum(len(l) + 1 for l in lines[:line]) + column
841 return sum(len(l) + 1 for l in lines[:line]) + column
842
842
843 def position_to_cursor(text:str, offset:int)->Tuple[int, int]:
843 def position_to_cursor(text:str, offset:int)->Tuple[int, int]:
844 """
844 """
845 Convert the position of the cursor in text (0 indexed) to a line
845 Convert the position of the cursor in text (0 indexed) to a line
846 number(0-indexed) and a column number (0-indexed) pair
846 number(0-indexed) and a column number (0-indexed) pair
847
847
848 Position should be a valid position in ``text``.
848 Position should be a valid position in ``text``.
849
849
850 Parameters
850 Parameters
851 ----------
851 ----------
852
852
853 text : str
853 text : str
854 The text in which to calculate the cursor offset
854 The text in which to calculate the cursor offset
855 offset : int
855 offset : int
856 Position of the cursor in ``text``, 0-indexed.
856 Position of the cursor in ``text``, 0-indexed.
857
857
858 Return
858 Return
859 ------
859 ------
860 (line, column) : (int, int)
860 (line, column) : (int, int)
861 Line of the cursor; 0-indexed, column of the cursor 0-indexed
861 Line of the cursor; 0-indexed, column of the cursor 0-indexed
862
862
863
863
864 See Also
864 See Also
865 --------
865 --------
866 cursor_to_position : reciprocal of this function
866 cursor_to_position : reciprocal of this function
867
867
868
868
869 """
869 """
870
870
871 assert 0 < offset <= len(text) , "0 < %s <= %s" % (offset , len(text))
871 assert 0 < offset <= len(text) , "0 < %s <= %s" % (offset , len(text))
872
872
873 before = text[:offset]
873 before = text[:offset]
874 blines = before.split('\n') # ! splitnes trim trailing \n
874 blines = before.split('\n') # ! splitnes trim trailing \n
875 line = before.count('\n')
875 line = before.count('\n')
876 col = len(blines[-1])
876 col = len(blines[-1])
877 return line, col
877 return line, col
878
878
879
879
880 def _safe_isinstance(obj, module, class_name):
880 def _safe_isinstance(obj, module, class_name):
881 """Checks if obj is an instance of module.class_name if loaded
881 """Checks if obj is an instance of module.class_name if loaded
882 """
882 """
883 return (module in sys.modules and
883 return (module in sys.modules and
884 isinstance(obj, getattr(import_module(module), class_name)))
884 isinstance(obj, getattr(import_module(module), class_name)))
885
885
886
886
887 def back_unicode_name_matches(text):
887 def back_unicode_name_matches(text):
888 u"""Match unicode characters back to unicode name
888 u"""Match unicode characters back to unicode name
889
889
890 This does ``β˜ƒ`` -> ``\\snowman``
890 This does ``β˜ƒ`` -> ``\\snowman``
891
891
892 Note that snowman is not a valid python3 combining character but will be expanded.
892 Note that snowman is not a valid python3 combining character but will be expanded.
893 Though it will not recombine back to the snowman character by the completion machinery.
893 Though it will not recombine back to the snowman character by the completion machinery.
894
894
895 This will not either back-complete standard sequences like \\n, \\b ...
895 This will not either back-complete standard sequences like \\n, \\b ...
896
896
897 Used on Python 3 only.
897 Used on Python 3 only.
898 """
898 """
899 if len(text)<2:
899 if len(text)<2:
900 return u'', ()
900 return u'', ()
901 maybe_slash = text[-2]
901 maybe_slash = text[-2]
902 if maybe_slash != '\\':
902 if maybe_slash != '\\':
903 return u'', ()
903 return u'', ()
904
904
905 char = text[-1]
905 char = text[-1]
906 # no expand on quote for completion in strings.
906 # no expand on quote for completion in strings.
907 # nor backcomplete standard ascii keys
907 # nor backcomplete standard ascii keys
908 if char in string.ascii_letters or char in ['"',"'"]:
908 if char in string.ascii_letters or char in ['"',"'"]:
909 return u'', ()
909 return u'', ()
910 try :
910 try :
911 unic = unicodedata.name(char)
911 unic = unicodedata.name(char)
912 return '\\'+char,['\\'+unic]
912 return '\\'+char,['\\'+unic]
913 except KeyError:
913 except KeyError:
914 pass
914 pass
915 return u'', ()
915 return u'', ()
916
916
917 def back_latex_name_matches(text:str):
917 def back_latex_name_matches(text:str):
918 """Match latex characters back to unicode name
918 """Match latex characters back to unicode name
919
919
920 This does ``\\β„΅`` -> ``\\aleph``
920 This does ``\\β„΅`` -> ``\\aleph``
921
921
922 Used on Python 3 only.
922 Used on Python 3 only.
923 """
923 """
924 if len(text)<2:
924 if len(text)<2:
925 return u'', ()
925 return u'', ()
926 maybe_slash = text[-2]
926 maybe_slash = text[-2]
927 if maybe_slash != '\\':
927 if maybe_slash != '\\':
928 return u'', ()
928 return u'', ()
929
929
930
930
931 char = text[-1]
931 char = text[-1]
932 # no expand on quote for completion in strings.
932 # no expand on quote for completion in strings.
933 # nor backcomplete standard ascii keys
933 # nor backcomplete standard ascii keys
934 if char in string.ascii_letters or char in ['"',"'"]:
934 if char in string.ascii_letters or char in ['"',"'"]:
935 return u'', ()
935 return u'', ()
936 try :
936 try :
937 latex = reverse_latex_symbol[char]
937 latex = reverse_latex_symbol[char]
938 # '\\' replace the \ as well
938 # '\\' replace the \ as well
939 return '\\'+char,[latex]
939 return '\\'+char,[latex]
940 except KeyError:
940 except KeyError:
941 pass
941 pass
942 return u'', ()
942 return u'', ()
943
943
944
944
945 def _formatparamchildren(parameter) -> str:
945 def _formatparamchildren(parameter) -> str:
946 """
946 """
947 Get parameter name and value from Jedi Private API
947 Get parameter name and value from Jedi Private API
948
948
949 Jedi does not expose a simple way to get `param=value` from its API.
949 Jedi does not expose a simple way to get `param=value` from its API.
950
950
951 Prameter
951 Prameter
952 ========
952 ========
953
953
954 parameter:
954 parameter:
955 Jedi's function `Param`
955 Jedi's function `Param`
956
956
957 Returns
957 Returns
958 =======
958 =======
959
959
960 A string like 'a', 'b=1', '*args', '**kwargs'
960 A string like 'a', 'b=1', '*args', '**kwargs'
961
961
962
962
963 """
963 """
964 description = parameter.description
964 description = parameter.description
965 if not description.startswith('param '):
965 if not description.startswith('param '):
966 raise ValueError('Jedi function parameter description have change format.'
966 raise ValueError('Jedi function parameter description have change format.'
967 'Expected "param ...", found %r".' % description)
967 'Expected "param ...", found %r".' % description)
968 return description[6:]
968 return description[6:]
969
969
970 def _make_signature(completion)-> str:
970 def _make_signature(completion)-> str:
971 """
971 """
972 Make the signature from a jedi completion
972 Make the signature from a jedi completion
973
973
974 Parameter
974 Parameter
975 =========
975 =========
976
976
977 completion: jedi.Completion
977 completion: jedi.Completion
978 object does not complete a function type
978 object does not complete a function type
979
979
980 Returns
980 Returns
981 =======
981 =======
982
982
983 a string consisting of the function signature, with the parenthesis but
983 a string consisting of the function signature, with the parenthesis but
984 without the function name. example:
984 without the function name. example:
985 `(a, *args, b=1, **kwargs)`
985 `(a, *args, b=1, **kwargs)`
986
986
987 """
987 """
988
988
989 return '(%s)'% ', '.join([f for f in (_formatparamchildren(p) for p in completion.params) if f])
989 return '(%s)'% ', '.join([f for f in (_formatparamchildren(p) for p in completion.params) if f])
990
990
991 class IPCompleter(Completer):
991 class IPCompleter(Completer):
992 """Extension of the completer class with IPython-specific features"""
992 """Extension of the completer class with IPython-specific features"""
993
993
994 @observe('greedy')
994 @observe('greedy')
995 def _greedy_changed(self, change):
995 def _greedy_changed(self, change):
996 """update the splitter and readline delims when greedy is changed"""
996 """update the splitter and readline delims when greedy is changed"""
997 if change['new']:
997 if change['new']:
998 self.splitter.delims = GREEDY_DELIMS
998 self.splitter.delims = GREEDY_DELIMS
999 else:
999 else:
1000 self.splitter.delims = DELIMS
1000 self.splitter.delims = DELIMS
1001
1001
1002 merge_completions = Bool(True,
1002 merge_completions = Bool(True,
1003 help="""Whether to merge completion results into a single list
1003 help="""Whether to merge completion results into a single list
1004
1004
1005 If False, only the completion results from the first non-empty
1005 If False, only the completion results from the first non-empty
1006 completer will be returned.
1006 completer will be returned.
1007 """
1007 """
1008 ).tag(config=True)
1008 ).tag(config=True)
1009 omit__names = Enum((0,1,2), default_value=2,
1009 omit__names = Enum((0,1,2), default_value=2,
1010 help="""Instruct the completer to omit private method names
1010 help="""Instruct the completer to omit private method names
1011
1011
1012 Specifically, when completing on ``object.<tab>``.
1012 Specifically, when completing on ``object.<tab>``.
1013
1013
1014 When 2 [default]: all names that start with '_' will be excluded.
1014 When 2 [default]: all names that start with '_' will be excluded.
1015
1015
1016 When 1: all 'magic' names (``__foo__``) will be excluded.
1016 When 1: all 'magic' names (``__foo__``) will be excluded.
1017
1017
1018 When 0: nothing will be excluded.
1018 When 0: nothing will be excluded.
1019 """
1019 """
1020 ).tag(config=True)
1020 ).tag(config=True)
1021 limit_to__all__ = Bool(False,
1021 limit_to__all__ = Bool(False,
1022 help="""
1022 help="""
1023 DEPRECATED as of version 5.0.
1023 DEPRECATED as of version 5.0.
1024
1024
1025 Instruct the completer to use __all__ for the completion
1025 Instruct the completer to use __all__ for the completion
1026
1026
1027 Specifically, when completing on ``object.<tab>``.
1027 Specifically, when completing on ``object.<tab>``.
1028
1028
1029 When True: only those names in obj.__all__ will be included.
1029 When True: only those names in obj.__all__ will be included.
1030
1030
1031 When False [default]: the __all__ attribute is ignored
1031 When False [default]: the __all__ attribute is ignored
1032 """,
1032 """,
1033 ).tag(config=True)
1033 ).tag(config=True)
1034
1034
1035 @observe('limit_to__all__')
1035 @observe('limit_to__all__')
1036 def _limit_to_all_changed(self, change):
1036 def _limit_to_all_changed(self, change):
1037 warnings.warn('`IPython.core.IPCompleter.limit_to__all__` configuration '
1037 warnings.warn('`IPython.core.IPCompleter.limit_to__all__` configuration '
1038 'value has been deprecated since IPython 5.0, will be made to have '
1038 'value has been deprecated since IPython 5.0, will be made to have '
1039 'no effects and then removed in future version of IPython.',
1039 'no effects and then removed in future version of IPython.',
1040 UserWarning)
1040 UserWarning)
1041
1041
1042 def __init__(self, shell=None, namespace=None, global_namespace=None,
1042 def __init__(self, shell=None, namespace=None, global_namespace=None,
1043 use_readline=_deprecation_readline_sentinel, config=None, **kwargs):
1043 use_readline=_deprecation_readline_sentinel, config=None, **kwargs):
1044 """IPCompleter() -> completer
1044 """IPCompleter() -> completer
1045
1045
1046 Return a completer object.
1046 Return a completer object.
1047
1047
1048 Parameters
1048 Parameters
1049 ----------
1049 ----------
1050
1050
1051 shell
1051 shell
1052 a pointer to the ipython shell itself. This is needed
1052 a pointer to the ipython shell itself. This is needed
1053 because this completer knows about magic functions, and those can
1053 because this completer knows about magic functions, and those can
1054 only be accessed via the ipython instance.
1054 only be accessed via the ipython instance.
1055
1055
1056 namespace : dict, optional
1056 namespace : dict, optional
1057 an optional dict where completions are performed.
1057 an optional dict where completions are performed.
1058
1058
1059 global_namespace : dict, optional
1059 global_namespace : dict, optional
1060 secondary optional dict for completions, to
1060 secondary optional dict for completions, to
1061 handle cases (such as IPython embedded inside functions) where
1061 handle cases (such as IPython embedded inside functions) where
1062 both Python scopes are visible.
1062 both Python scopes are visible.
1063
1063
1064 use_readline : bool, optional
1064 use_readline : bool, optional
1065 DEPRECATED, ignored since IPython 6.0, will have no effects
1065 DEPRECATED, ignored since IPython 6.0, will have no effects
1066 """
1066 """
1067
1067
1068 self.magic_escape = ESC_MAGIC
1068 self.magic_escape = ESC_MAGIC
1069 self.splitter = CompletionSplitter()
1069 self.splitter = CompletionSplitter()
1070
1070
1071 if use_readline is not _deprecation_readline_sentinel:
1071 if use_readline is not _deprecation_readline_sentinel:
1072 warnings.warn('The `use_readline` parameter is deprecated and ignored since IPython 6.0.',
1072 warnings.warn('The `use_readline` parameter is deprecated and ignored since IPython 6.0.',
1073 DeprecationWarning, stacklevel=2)
1073 DeprecationWarning, stacklevel=2)
1074
1074
1075 # _greedy_changed() depends on splitter and readline being defined:
1075 # _greedy_changed() depends on splitter and readline being defined:
1076 Completer.__init__(self, namespace=namespace, global_namespace=global_namespace,
1076 Completer.__init__(self, namespace=namespace, global_namespace=global_namespace,
1077 config=config, **kwargs)
1077 config=config, **kwargs)
1078
1078
1079 # List where completion matches will be stored
1079 # List where completion matches will be stored
1080 self.matches = []
1080 self.matches = []
1081 self.shell = shell
1081 self.shell = shell
1082 # Regexp to split filenames with spaces in them
1082 # Regexp to split filenames with spaces in them
1083 self.space_name_re = re.compile(r'([^\\] )')
1083 self.space_name_re = re.compile(r'([^\\] )')
1084 # Hold a local ref. to glob.glob for speed
1084 # Hold a local ref. to glob.glob for speed
1085 self.glob = glob.glob
1085 self.glob = glob.glob
1086
1086
1087 # Determine if we are running on 'dumb' terminals, like (X)Emacs
1087 # Determine if we are running on 'dumb' terminals, like (X)Emacs
1088 # buffers, to avoid completion problems.
1088 # buffers, to avoid completion problems.
1089 term = os.environ.get('TERM','xterm')
1089 term = os.environ.get('TERM','xterm')
1090 self.dumb_terminal = term in ['dumb','emacs']
1090 self.dumb_terminal = term in ['dumb','emacs']
1091
1091
1092 # Special handling of backslashes needed in win32 platforms
1092 # Special handling of backslashes needed in win32 platforms
1093 if sys.platform == "win32":
1093 if sys.platform == "win32":
1094 self.clean_glob = self._clean_glob_win32
1094 self.clean_glob = self._clean_glob_win32
1095 else:
1095 else:
1096 self.clean_glob = self._clean_glob
1096 self.clean_glob = self._clean_glob
1097
1097
1098 #regexp to parse docstring for function signature
1098 #regexp to parse docstring for function signature
1099 self.docstring_sig_re = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
1099 self.docstring_sig_re = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
1100 self.docstring_kwd_re = re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
1100 self.docstring_kwd_re = re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
1101 #use this if positional argument name is also needed
1101 #use this if positional argument name is also needed
1102 #= re.compile(r'[\s|\[]*(\w+)(?:\s*=?\s*.*)')
1102 #= re.compile(r'[\s|\[]*(\w+)(?:\s*=?\s*.*)')
1103
1103
1104 # All active matcher routines for completion
1104 # All active matcher routines for completion
1105 self.matchers = [
1105 self.matchers = [
1106 self.python_matches,
1106 self.python_matches,
1107 self.file_matches,
1107 self.file_matches,
1108 self.magic_matches,
1108 self.magic_matches,
1109 self.python_func_kw_matches,
1109 self.python_func_kw_matches,
1110 self.dict_key_matches,
1110 self.dict_key_matches,
1111 ]
1111 ]
1112 self.magic_arg_matchers = [
1112 self.magic_arg_matchers = [
1113 self.magic_config_matches,
1113 self.magic_config_matches,
1114 self.magic_color_matches,
1114 self.magic_color_matches,
1115 ]
1115 ]
1116
1116
1117 # This is set externally by InteractiveShell
1117 # This is set externally by InteractiveShell
1118 self.custom_completers = None
1118 self.custom_completers = None
1119
1119
1120 def all_completions(self, text):
1120 def all_completions(self, text):
1121 """
1121 """
1122 Wrapper around the complete method for the benefit of emacs.
1122 Wrapper around the complete method for the benefit of emacs.
1123 """
1123 """
1124 return self.complete(text)[1]
1124 return self.complete(text)[1]
1125
1125
1126 def _clean_glob(self, text):
1126 def _clean_glob(self, text):
1127 return self.glob("%s*" % text)
1127 return self.glob("%s*" % text)
1128
1128
1129 def _clean_glob_win32(self,text):
1129 def _clean_glob_win32(self,text):
1130 return [f.replace("\\","/")
1130 return [f.replace("\\","/")
1131 for f in self.glob("%s*" % text)]
1131 for f in self.glob("%s*" % text)]
1132
1132
1133 def file_matches(self, text):
1133 def file_matches(self, text):
1134 """Match filenames, expanding ~USER type strings.
1134 """Match filenames, expanding ~USER type strings.
1135
1135
1136 Most of the seemingly convoluted logic in this completer is an
1136 Most of the seemingly convoluted logic in this completer is an
1137 attempt to handle filenames with spaces in them. And yet it's not
1137 attempt to handle filenames with spaces in them. And yet it's not
1138 quite perfect, because Python's readline doesn't expose all of the
1138 quite perfect, because Python's readline doesn't expose all of the
1139 GNU readline details needed for this to be done correctly.
1139 GNU readline details needed for this to be done correctly.
1140
1140
1141 For a filename with a space in it, the printed completions will be
1141 For a filename with a space in it, the printed completions will be
1142 only the parts after what's already been typed (instead of the
1142 only the parts after what's already been typed (instead of the
1143 full completions, as is normally done). I don't think with the
1143 full completions, as is normally done). I don't think with the
1144 current (as of Python 2.3) Python readline it's possible to do
1144 current (as of Python 2.3) Python readline it's possible to do
1145 better."""
1145 better."""
1146
1146
1147 # chars that require escaping with backslash - i.e. chars
1147 # chars that require escaping with backslash - i.e. chars
1148 # that readline treats incorrectly as delimiters, but we
1148 # that readline treats incorrectly as delimiters, but we
1149 # don't want to treat as delimiters in filename matching
1149 # don't want to treat as delimiters in filename matching
1150 # when escaped with backslash
1150 # when escaped with backslash
1151 if text.startswith('!'):
1151 if text.startswith('!'):
1152 text = text[1:]
1152 text = text[1:]
1153 text_prefix = u'!'
1153 text_prefix = u'!'
1154 else:
1154 else:
1155 text_prefix = u''
1155 text_prefix = u''
1156
1156
1157 text_until_cursor = self.text_until_cursor
1157 text_until_cursor = self.text_until_cursor
1158 # track strings with open quotes
1158 # track strings with open quotes
1159 open_quotes = has_open_quotes(text_until_cursor)
1159 open_quotes = has_open_quotes(text_until_cursor)
1160
1160
1161 if '(' in text_until_cursor or '[' in text_until_cursor:
1161 if '(' in text_until_cursor or '[' in text_until_cursor:
1162 lsplit = text
1162 lsplit = text
1163 else:
1163 else:
1164 try:
1164 try:
1165 # arg_split ~ shlex.split, but with unicode bugs fixed by us
1165 # arg_split ~ shlex.split, but with unicode bugs fixed by us
1166 lsplit = arg_split(text_until_cursor)[-1]
1166 lsplit = arg_split(text_until_cursor)[-1]
1167 except ValueError:
1167 except ValueError:
1168 # typically an unmatched ", or backslash without escaped char.
1168 # typically an unmatched ", or backslash without escaped char.
1169 if open_quotes:
1169 if open_quotes:
1170 lsplit = text_until_cursor.split(open_quotes)[-1]
1170 lsplit = text_until_cursor.split(open_quotes)[-1]
1171 else:
1171 else:
1172 return []
1172 return []
1173 except IndexError:
1173 except IndexError:
1174 # tab pressed on empty line
1174 # tab pressed on empty line
1175 lsplit = ""
1175 lsplit = ""
1176
1176
1177 if not open_quotes and lsplit != protect_filename(lsplit):
1177 if not open_quotes and lsplit != protect_filename(lsplit):
1178 # if protectables are found, do matching on the whole escaped name
1178 # if protectables are found, do matching on the whole escaped name
1179 has_protectables = True
1179 has_protectables = True
1180 text0,text = text,lsplit
1180 text0,text = text,lsplit
1181 else:
1181 else:
1182 has_protectables = False
1182 has_protectables = False
1183 text = os.path.expanduser(text)
1183 text = os.path.expanduser(text)
1184
1184
1185 if text == "":
1185 if text == "":
1186 return [text_prefix + protect_filename(f) for f in self.glob("*")]
1186 return [text_prefix + protect_filename(f) for f in self.glob("*")]
1187
1187
1188 # Compute the matches from the filesystem
1188 # Compute the matches from the filesystem
1189 if sys.platform == 'win32':
1189 if sys.platform == 'win32':
1190 m0 = self.clean_glob(text)
1190 m0 = self.clean_glob(text)
1191 else:
1191 else:
1192 m0 = self.clean_glob(text.replace('\\', ''))
1192 m0 = self.clean_glob(text.replace('\\', ''))
1193
1193
1194 if has_protectables:
1194 if has_protectables:
1195 # If we had protectables, we need to revert our changes to the
1195 # If we had protectables, we need to revert our changes to the
1196 # beginning of filename so that we don't double-write the part
1196 # beginning of filename so that we don't double-write the part
1197 # of the filename we have so far
1197 # of the filename we have so far
1198 len_lsplit = len(lsplit)
1198 len_lsplit = len(lsplit)
1199 matches = [text_prefix + text0 +
1199 matches = [text_prefix + text0 +
1200 protect_filename(f[len_lsplit:]) for f in m0]
1200 protect_filename(f[len_lsplit:]) for f in m0]
1201 else:
1201 else:
1202 if open_quotes:
1202 if open_quotes:
1203 # if we have a string with an open quote, we don't need to
1203 # if we have a string with an open quote, we don't need to
1204 # protect the names beyond the quote (and we _shouldn't_, as
1204 # protect the names beyond the quote (and we _shouldn't_, as
1205 # it would cause bugs when the filesystem call is made).
1205 # it would cause bugs when the filesystem call is made).
1206 matches = m0 if sys.platform == "win32" else\
1206 matches = m0 if sys.platform == "win32" else\
1207 [protect_filename(f, open_quotes) for f in m0]
1207 [protect_filename(f, open_quotes) for f in m0]
1208 else:
1208 else:
1209 matches = [text_prefix +
1209 matches = [text_prefix +
1210 protect_filename(f) for f in m0]
1210 protect_filename(f) for f in m0]
1211
1211
1212 # Mark directories in input list by appending '/' to their names.
1212 # Mark directories in input list by appending '/' to their names.
1213 return [x+'/' if os.path.isdir(x) else x for x in matches]
1213 return [x+'/' if os.path.isdir(x) else x for x in matches]
1214
1214
1215 def magic_matches(self, text):
1215 def magic_matches(self, text):
1216 """Match magics"""
1216 """Match magics"""
1217 # Get all shell magics now rather than statically, so magics loaded at
1217 # Get all shell magics now rather than statically, so magics loaded at
1218 # runtime show up too.
1218 # runtime show up too.
1219 lsm = self.shell.magics_manager.lsmagic()
1219 lsm = self.shell.magics_manager.lsmagic()
1220 line_magics = lsm['line']
1220 line_magics = lsm['line']
1221 cell_magics = lsm['cell']
1221 cell_magics = lsm['cell']
1222 pre = self.magic_escape
1222 pre = self.magic_escape
1223 pre2 = pre+pre
1223 pre2 = pre+pre
1224
1224
1225 explicit_magic = text.startswith(pre)
1226
1225 # Completion logic:
1227 # Completion logic:
1226 # - user gives %%: only do cell magics
1228 # - user gives %%: only do cell magics
1227 # - user gives %: do both line and cell magics
1229 # - user gives %: do both line and cell magics
1228 # - no prefix: do both
1230 # - no prefix: do both
1229 # In other words, line magics are skipped if the user gives %% explicitly
1231 # In other words, line magics are skipped if the user gives %% explicitly
1230 #
1232 #
1231 # We also exclude magics that match any currently visible names:
1233 # We also exclude magics that match any currently visible names:
1232 # https://github.com/ipython/ipython/issues/4877
1234 # https://github.com/ipython/ipython/issues/4877, unless the user has
1235 # typed a %:
1236 # https://github.com/ipython/ipython/issues/10754
1233 bare_text = text.lstrip(pre)
1237 bare_text = text.lstrip(pre)
1234 global_matches = self.global_matches(bare_text)
1238 global_matches = self.global_matches(bare_text)
1235 matches = lambda magic: magic.startswith(bare_text) \
1239 if not explicit_magic:
1236 and magic not in global_matches
1240 def matches(magic):
1241 """
1242 Filter magics, in particular remove magics that match
1243 a name present in global namespace.
1244 """
1245 return ( magic.startswith(bare_text) and
1246 magic not in global_matches )
1247 else:
1248 def matches(magic):
1249 return magic.startswith(bare_text)
1250
1237 comp = [ pre2+m for m in cell_magics if matches(m)]
1251 comp = [ pre2+m for m in cell_magics if matches(m)]
1238 if not text.startswith(pre2):
1252 if not text.startswith(pre2):
1239 comp += [ pre+m for m in line_magics if matches(m)]
1253 comp += [ pre+m for m in line_magics if matches(m)]
1240
1254
1241 return comp
1255 return comp
1242
1256
1243 def magic_config_matches(self, text:str) -> List[str]:
1257 def magic_config_matches(self, text:str) -> List[str]:
1244 """ Match class names and attributes for %config magic """
1258 """ Match class names and attributes for %config magic """
1245 texts = text.strip().split()
1259 texts = text.strip().split()
1246
1260
1247 if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
1261 if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
1248 # get all configuration classes
1262 # get all configuration classes
1249 classes = sorted(set([ c for c in self.shell.configurables
1263 classes = sorted(set([ c for c in self.shell.configurables
1250 if c.__class__.class_traits(config=True)
1264 if c.__class__.class_traits(config=True)
1251 ]), key=lambda x: x.__class__.__name__)
1265 ]), key=lambda x: x.__class__.__name__)
1252 classnames = [ c.__class__.__name__ for c in classes ]
1266 classnames = [ c.__class__.__name__ for c in classes ]
1253
1267
1254 # return all classnames if config or %config is given
1268 # return all classnames if config or %config is given
1255 if len(texts) == 1:
1269 if len(texts) == 1:
1256 return classnames
1270 return classnames
1257
1271
1258 # match classname
1272 # match classname
1259 classname_texts = texts[1].split('.')
1273 classname_texts = texts[1].split('.')
1260 classname = classname_texts[0]
1274 classname = classname_texts[0]
1261 classname_matches = [ c for c in classnames
1275 classname_matches = [ c for c in classnames
1262 if c.startswith(classname) ]
1276 if c.startswith(classname) ]
1263
1277
1264 # return matched classes or the matched class with attributes
1278 # return matched classes or the matched class with attributes
1265 if texts[1].find('.') < 0:
1279 if texts[1].find('.') < 0:
1266 return classname_matches
1280 return classname_matches
1267 elif len(classname_matches) == 1 and \
1281 elif len(classname_matches) == 1 and \
1268 classname_matches[0] == classname:
1282 classname_matches[0] == classname:
1269 cls = classes[classnames.index(classname)].__class__
1283 cls = classes[classnames.index(classname)].__class__
1270 help = cls.class_get_help()
1284 help = cls.class_get_help()
1271 # strip leading '--' from cl-args:
1285 # strip leading '--' from cl-args:
1272 help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
1286 help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
1273 return [ attr.split('=')[0]
1287 return [ attr.split('=')[0]
1274 for attr in help.strip().splitlines()
1288 for attr in help.strip().splitlines()
1275 if attr.startswith(texts[1]) ]
1289 if attr.startswith(texts[1]) ]
1276 return []
1290 return []
1277
1291
1278 def magic_color_matches(self, text:str) -> List[str] :
1292 def magic_color_matches(self, text:str) -> List[str] :
1279 """ Match color schemes for %colors magic"""
1293 """ Match color schemes for %colors magic"""
1280 texts = text.split()
1294 texts = text.split()
1281 if text.endswith(' '):
1295 if text.endswith(' '):
1282 # .split() strips off the trailing whitespace. Add '' back
1296 # .split() strips off the trailing whitespace. Add '' back
1283 # so that: '%colors ' -> ['%colors', '']
1297 # so that: '%colors ' -> ['%colors', '']
1284 texts.append('')
1298 texts.append('')
1285
1299
1286 if len(texts) == 2 and (texts[0] == 'colors' or texts[0] == '%colors'):
1300 if len(texts) == 2 and (texts[0] == 'colors' or texts[0] == '%colors'):
1287 prefix = texts[1]
1301 prefix = texts[1]
1288 return [ color for color in InspectColors.keys()
1302 return [ color for color in InspectColors.keys()
1289 if color.startswith(prefix) ]
1303 if color.startswith(prefix) ]
1290 return []
1304 return []
1291
1305
1292 def _jedi_matches(self, cursor_column:int, cursor_line:int, text:str):
1306 def _jedi_matches(self, cursor_column:int, cursor_line:int, text:str):
1293 """
1307 """
1294
1308
1295 Return a list of :any:`jedi.api.Completions` object from a ``text`` and
1309 Return a list of :any:`jedi.api.Completions` object from a ``text`` and
1296 cursor position.
1310 cursor position.
1297
1311
1298 Parameters
1312 Parameters
1299 ----------
1313 ----------
1300 cursor_column : int
1314 cursor_column : int
1301 column position of the cursor in ``text``, 0-indexed.
1315 column position of the cursor in ``text``, 0-indexed.
1302 cursor_line : int
1316 cursor_line : int
1303 line position of the cursor in ``text``, 0-indexed
1317 line position of the cursor in ``text``, 0-indexed
1304 text : str
1318 text : str
1305 text to complete
1319 text to complete
1306
1320
1307 Debugging
1321 Debugging
1308 ---------
1322 ---------
1309
1323
1310 If ``IPCompleter.debug`` is ``True`` may return a :any:`_FakeJediCompletion`
1324 If ``IPCompleter.debug`` is ``True`` may return a :any:`_FakeJediCompletion`
1311 object containing a string with the Jedi debug information attached.
1325 object containing a string with the Jedi debug information attached.
1312 """
1326 """
1313 namespaces = [self.namespace]
1327 namespaces = [self.namespace]
1314 if self.global_namespace is not None:
1328 if self.global_namespace is not None:
1315 namespaces.append(self.global_namespace)
1329 namespaces.append(self.global_namespace)
1316
1330
1317 completion_filter = lambda x:x
1331 completion_filter = lambda x:x
1318 # cursor_pos is an it, jedi wants line and column
1332 # cursor_pos is an it, jedi wants line and column
1319 offset = cursor_to_position(text, cursor_line, cursor_column)
1333 offset = cursor_to_position(text, cursor_line, cursor_column)
1320 # filter output if we are completing for object members
1334 # filter output if we are completing for object members
1321 if offset:
1335 if offset:
1322 pre = text[offset-1]
1336 pre = text[offset-1]
1323 if pre == '.':
1337 if pre == '.':
1324 if self.omit__names == 2:
1338 if self.omit__names == 2:
1325 completion_filter = lambda c:not c.name.startswith('_')
1339 completion_filter = lambda c:not c.name.startswith('_')
1326 elif self.omit__names == 1:
1340 elif self.omit__names == 1:
1327 completion_filter = lambda c:not (c.name.startswith('__') and c.name.endswith('__'))
1341 completion_filter = lambda c:not (c.name.startswith('__') and c.name.endswith('__'))
1328 elif self.omit__names == 0:
1342 elif self.omit__names == 0:
1329 completion_filter = lambda x:x
1343 completion_filter = lambda x:x
1330 else:
1344 else:
1331 raise ValueError("Don't understand self.omit__names == {}".format(self.omit__names))
1345 raise ValueError("Don't understand self.omit__names == {}".format(self.omit__names))
1332
1346
1333 interpreter = jedi.Interpreter(
1347 interpreter = jedi.Interpreter(
1334 text, namespaces, column=cursor_column, line=cursor_line + 1)
1348 text, namespaces, column=cursor_column, line=cursor_line + 1)
1335
1349
1336 try_jedi = False
1350 try_jedi = False
1337
1351
1338 try:
1352 try:
1339 # should we check the type of the node is Error ?
1353 # should we check the type of the node is Error ?
1340 from jedi.parser.tree import ErrorLeaf
1354 from jedi.parser.tree import ErrorLeaf
1341 next_to_last_tree = interpreter._get_module().tree_node.children[-2]
1355 next_to_last_tree = interpreter._get_module().tree_node.children[-2]
1342 completing_string = False
1356 completing_string = False
1343 if isinstance(next_to_last_tree, ErrorLeaf):
1357 if isinstance(next_to_last_tree, ErrorLeaf):
1344 completing_string = interpreter._get_module().tree_node.children[-2].value[0] in {'"', "'"}
1358 completing_string = interpreter._get_module().tree_node.children[-2].value[0] in {'"', "'"}
1345 # if we are in a string jedi is likely not the right candidate for
1359 # if we are in a string jedi is likely not the right candidate for
1346 # now. Skip it.
1360 # now. Skip it.
1347 try_jedi = not completing_string
1361 try_jedi = not completing_string
1348 except Exception as e:
1362 except Exception as e:
1349 # many of things can go wrong, we are using private API just don't crash.
1363 # many of things can go wrong, we are using private API just don't crash.
1350 if self.debug:
1364 if self.debug:
1351 print("Error detecting if completing a non-finished string :", e, '|')
1365 print("Error detecting if completing a non-finished string :", e, '|')
1352
1366
1353 if not try_jedi:
1367 if not try_jedi:
1354 return []
1368 return []
1355 try:
1369 try:
1356 return filter(completion_filter, interpreter.completions())
1370 return filter(completion_filter, interpreter.completions())
1357 except Exception as e:
1371 except Exception as e:
1358 if self.debug:
1372 if self.debug:
1359 return [_FakeJediCompletion('Oops Jedi has crashed, please report a bug with the following:\n"""\n%s\ns"""' % (e))]
1373 return [_FakeJediCompletion('Oops Jedi has crashed, please report a bug with the following:\n"""\n%s\ns"""' % (e))]
1360 else:
1374 else:
1361 return []
1375 return []
1362
1376
1363 def python_matches(self, text):
1377 def python_matches(self, text):
1364 """Match attributes or global python names"""
1378 """Match attributes or global python names"""
1365 if "." in text:
1379 if "." in text:
1366 try:
1380 try:
1367 matches = self.attr_matches(text)
1381 matches = self.attr_matches(text)
1368 if text.endswith('.') and self.omit__names:
1382 if text.endswith('.') and self.omit__names:
1369 if self.omit__names == 1:
1383 if self.omit__names == 1:
1370 # true if txt is _not_ a __ name, false otherwise:
1384 # true if txt is _not_ a __ name, false otherwise:
1371 no__name = (lambda txt:
1385 no__name = (lambda txt:
1372 re.match(r'.*\.__.*?__',txt) is None)
1386 re.match(r'.*\.__.*?__',txt) is None)
1373 else:
1387 else:
1374 # true if txt is _not_ a _ name, false otherwise:
1388 # true if txt is _not_ a _ name, false otherwise:
1375 no__name = (lambda txt:
1389 no__name = (lambda txt:
1376 re.match(r'\._.*?',txt[txt.rindex('.'):]) is None)
1390 re.match(r'\._.*?',txt[txt.rindex('.'):]) is None)
1377 matches = filter(no__name, matches)
1391 matches = filter(no__name, matches)
1378 except NameError:
1392 except NameError:
1379 # catches <undefined attributes>.<tab>
1393 # catches <undefined attributes>.<tab>
1380 matches = []
1394 matches = []
1381 else:
1395 else:
1382 matches = self.global_matches(text)
1396 matches = self.global_matches(text)
1383 return matches
1397 return matches
1384
1398
1385 def _default_arguments_from_docstring(self, doc):
1399 def _default_arguments_from_docstring(self, doc):
1386 """Parse the first line of docstring for call signature.
1400 """Parse the first line of docstring for call signature.
1387
1401
1388 Docstring should be of the form 'min(iterable[, key=func])\n'.
1402 Docstring should be of the form 'min(iterable[, key=func])\n'.
1389 It can also parse cython docstring of the form
1403 It can also parse cython docstring of the form
1390 'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'.
1404 'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'.
1391 """
1405 """
1392 if doc is None:
1406 if doc is None:
1393 return []
1407 return []
1394
1408
1395 #care only the firstline
1409 #care only the firstline
1396 line = doc.lstrip().splitlines()[0]
1410 line = doc.lstrip().splitlines()[0]
1397
1411
1398 #p = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
1412 #p = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
1399 #'min(iterable[, key=func])\n' -> 'iterable[, key=func]'
1413 #'min(iterable[, key=func])\n' -> 'iterable[, key=func]'
1400 sig = self.docstring_sig_re.search(line)
1414 sig = self.docstring_sig_re.search(line)
1401 if sig is None:
1415 if sig is None:
1402 return []
1416 return []
1403 # iterable[, key=func]' -> ['iterable[' ,' key=func]']
1417 # iterable[, key=func]' -> ['iterable[' ,' key=func]']
1404 sig = sig.groups()[0].split(',')
1418 sig = sig.groups()[0].split(',')
1405 ret = []
1419 ret = []
1406 for s in sig:
1420 for s in sig:
1407 #re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
1421 #re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
1408 ret += self.docstring_kwd_re.findall(s)
1422 ret += self.docstring_kwd_re.findall(s)
1409 return ret
1423 return ret
1410
1424
1411 def _default_arguments(self, obj):
1425 def _default_arguments(self, obj):
1412 """Return the list of default arguments of obj if it is callable,
1426 """Return the list of default arguments of obj if it is callable,
1413 or empty list otherwise."""
1427 or empty list otherwise."""
1414 call_obj = obj
1428 call_obj = obj
1415 ret = []
1429 ret = []
1416 if inspect.isbuiltin(obj):
1430 if inspect.isbuiltin(obj):
1417 pass
1431 pass
1418 elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
1432 elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
1419 if inspect.isclass(obj):
1433 if inspect.isclass(obj):
1420 #for cython embedsignature=True the constructor docstring
1434 #for cython embedsignature=True the constructor docstring
1421 #belongs to the object itself not __init__
1435 #belongs to the object itself not __init__
1422 ret += self._default_arguments_from_docstring(
1436 ret += self._default_arguments_from_docstring(
1423 getattr(obj, '__doc__', ''))
1437 getattr(obj, '__doc__', ''))
1424 # for classes, check for __init__,__new__
1438 # for classes, check for __init__,__new__
1425 call_obj = (getattr(obj, '__init__', None) or
1439 call_obj = (getattr(obj, '__init__', None) or
1426 getattr(obj, '__new__', None))
1440 getattr(obj, '__new__', None))
1427 # for all others, check if they are __call__able
1441 # for all others, check if they are __call__able
1428 elif hasattr(obj, '__call__'):
1442 elif hasattr(obj, '__call__'):
1429 call_obj = obj.__call__
1443 call_obj = obj.__call__
1430 ret += self._default_arguments_from_docstring(
1444 ret += self._default_arguments_from_docstring(
1431 getattr(call_obj, '__doc__', ''))
1445 getattr(call_obj, '__doc__', ''))
1432
1446
1433 _keeps = (inspect.Parameter.KEYWORD_ONLY,
1447 _keeps = (inspect.Parameter.KEYWORD_ONLY,
1434 inspect.Parameter.POSITIONAL_OR_KEYWORD)
1448 inspect.Parameter.POSITIONAL_OR_KEYWORD)
1435
1449
1436 try:
1450 try:
1437 sig = inspect.signature(call_obj)
1451 sig = inspect.signature(call_obj)
1438 ret.extend(k for k, v in sig.parameters.items() if
1452 ret.extend(k for k, v in sig.parameters.items() if
1439 v.kind in _keeps)
1453 v.kind in _keeps)
1440 except ValueError:
1454 except ValueError:
1441 pass
1455 pass
1442
1456
1443 return list(set(ret))
1457 return list(set(ret))
1444
1458
1445 def python_func_kw_matches(self,text):
1459 def python_func_kw_matches(self,text):
1446 """Match named parameters (kwargs) of the last open function"""
1460 """Match named parameters (kwargs) of the last open function"""
1447
1461
1448 if "." in text: # a parameter cannot be dotted
1462 if "." in text: # a parameter cannot be dotted
1449 return []
1463 return []
1450 try: regexp = self.__funcParamsRegex
1464 try: regexp = self.__funcParamsRegex
1451 except AttributeError:
1465 except AttributeError:
1452 regexp = self.__funcParamsRegex = re.compile(r'''
1466 regexp = self.__funcParamsRegex = re.compile(r'''
1453 '.*?(?<!\\)' | # single quoted strings or
1467 '.*?(?<!\\)' | # single quoted strings or
1454 ".*?(?<!\\)" | # double quoted strings or
1468 ".*?(?<!\\)" | # double quoted strings or
1455 \w+ | # identifier
1469 \w+ | # identifier
1456 \S # other characters
1470 \S # other characters
1457 ''', re.VERBOSE | re.DOTALL)
1471 ''', re.VERBOSE | re.DOTALL)
1458 # 1. find the nearest identifier that comes before an unclosed
1472 # 1. find the nearest identifier that comes before an unclosed
1459 # parenthesis before the cursor
1473 # parenthesis before the cursor
1460 # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
1474 # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
1461 tokens = regexp.findall(self.text_until_cursor)
1475 tokens = regexp.findall(self.text_until_cursor)
1462 iterTokens = reversed(tokens); openPar = 0
1476 iterTokens = reversed(tokens); openPar = 0
1463
1477
1464 for token in iterTokens:
1478 for token in iterTokens:
1465 if token == ')':
1479 if token == ')':
1466 openPar -= 1
1480 openPar -= 1
1467 elif token == '(':
1481 elif token == '(':
1468 openPar += 1
1482 openPar += 1
1469 if openPar > 0:
1483 if openPar > 0:
1470 # found the last unclosed parenthesis
1484 # found the last unclosed parenthesis
1471 break
1485 break
1472 else:
1486 else:
1473 return []
1487 return []
1474 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
1488 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
1475 ids = []
1489 ids = []
1476 isId = re.compile(r'\w+$').match
1490 isId = re.compile(r'\w+$').match
1477
1491
1478 while True:
1492 while True:
1479 try:
1493 try:
1480 ids.append(next(iterTokens))
1494 ids.append(next(iterTokens))
1481 if not isId(ids[-1]):
1495 if not isId(ids[-1]):
1482 ids.pop(); break
1496 ids.pop(); break
1483 if not next(iterTokens) == '.':
1497 if not next(iterTokens) == '.':
1484 break
1498 break
1485 except StopIteration:
1499 except StopIteration:
1486 break
1500 break
1487
1501
1488 # Find all named arguments already assigned to, as to avoid suggesting
1502 # Find all named arguments already assigned to, as to avoid suggesting
1489 # them again
1503 # them again
1490 usedNamedArgs = set()
1504 usedNamedArgs = set()
1491 par_level = -1
1505 par_level = -1
1492 for token, next_token in zip(tokens, tokens[1:]):
1506 for token, next_token in zip(tokens, tokens[1:]):
1493 if token == '(':
1507 if token == '(':
1494 par_level += 1
1508 par_level += 1
1495 elif token == ')':
1509 elif token == ')':
1496 par_level -= 1
1510 par_level -= 1
1497
1511
1498 if par_level != 0:
1512 if par_level != 0:
1499 continue
1513 continue
1500
1514
1501 if next_token != '=':
1515 if next_token != '=':
1502 continue
1516 continue
1503
1517
1504 usedNamedArgs.add(token)
1518 usedNamedArgs.add(token)
1505
1519
1506 # lookup the candidate callable matches either using global_matches
1520 # lookup the candidate callable matches either using global_matches
1507 # or attr_matches for dotted names
1521 # or attr_matches for dotted names
1508 if len(ids) == 1:
1522 if len(ids) == 1:
1509 callableMatches = self.global_matches(ids[0])
1523 callableMatches = self.global_matches(ids[0])
1510 else:
1524 else:
1511 callableMatches = self.attr_matches('.'.join(ids[::-1]))
1525 callableMatches = self.attr_matches('.'.join(ids[::-1]))
1512 argMatches = []
1526 argMatches = []
1513 for callableMatch in callableMatches:
1527 for callableMatch in callableMatches:
1514 try:
1528 try:
1515 namedArgs = self._default_arguments(eval(callableMatch,
1529 namedArgs = self._default_arguments(eval(callableMatch,
1516 self.namespace))
1530 self.namespace))
1517 except:
1531 except:
1518 continue
1532 continue
1519
1533
1520 # Remove used named arguments from the list, no need to show twice
1534 # Remove used named arguments from the list, no need to show twice
1521 for namedArg in set(namedArgs) - usedNamedArgs:
1535 for namedArg in set(namedArgs) - usedNamedArgs:
1522 if namedArg.startswith(text):
1536 if namedArg.startswith(text):
1523 argMatches.append(u"%s=" %namedArg)
1537 argMatches.append(u"%s=" %namedArg)
1524 return argMatches
1538 return argMatches
1525
1539
1526 def dict_key_matches(self, text):
1540 def dict_key_matches(self, text):
1527 "Match string keys in a dictionary, after e.g. 'foo[' "
1541 "Match string keys in a dictionary, after e.g. 'foo[' "
1528 def get_keys(obj):
1542 def get_keys(obj):
1529 # Objects can define their own completions by defining an
1543 # Objects can define their own completions by defining an
1530 # _ipy_key_completions_() method.
1544 # _ipy_key_completions_() method.
1531 method = get_real_method(obj, '_ipython_key_completions_')
1545 method = get_real_method(obj, '_ipython_key_completions_')
1532 if method is not None:
1546 if method is not None:
1533 return method()
1547 return method()
1534
1548
1535 # Special case some common in-memory dict-like types
1549 # Special case some common in-memory dict-like types
1536 if isinstance(obj, dict) or\
1550 if isinstance(obj, dict) or\
1537 _safe_isinstance(obj, 'pandas', 'DataFrame'):
1551 _safe_isinstance(obj, 'pandas', 'DataFrame'):
1538 try:
1552 try:
1539 return list(obj.keys())
1553 return list(obj.keys())
1540 except Exception:
1554 except Exception:
1541 return []
1555 return []
1542 elif _safe_isinstance(obj, 'numpy', 'ndarray') or\
1556 elif _safe_isinstance(obj, 'numpy', 'ndarray') or\
1543 _safe_isinstance(obj, 'numpy', 'void'):
1557 _safe_isinstance(obj, 'numpy', 'void'):
1544 return obj.dtype.names or []
1558 return obj.dtype.names or []
1545 return []
1559 return []
1546
1560
1547 try:
1561 try:
1548 regexps = self.__dict_key_regexps
1562 regexps = self.__dict_key_regexps
1549 except AttributeError:
1563 except AttributeError:
1550 dict_key_re_fmt = r'''(?x)
1564 dict_key_re_fmt = r'''(?x)
1551 ( # match dict-referring expression wrt greedy setting
1565 ( # match dict-referring expression wrt greedy setting
1552 %s
1566 %s
1553 )
1567 )
1554 \[ # open bracket
1568 \[ # open bracket
1555 \s* # and optional whitespace
1569 \s* # and optional whitespace
1556 ([uUbB]? # string prefix (r not handled)
1570 ([uUbB]? # string prefix (r not handled)
1557 (?: # unclosed string
1571 (?: # unclosed string
1558 '(?:[^']|(?<!\\)\\')*
1572 '(?:[^']|(?<!\\)\\')*
1559 |
1573 |
1560 "(?:[^"]|(?<!\\)\\")*
1574 "(?:[^"]|(?<!\\)\\")*
1561 )
1575 )
1562 )?
1576 )?
1563 $
1577 $
1564 '''
1578 '''
1565 regexps = self.__dict_key_regexps = {
1579 regexps = self.__dict_key_regexps = {
1566 False: re.compile(dict_key_re_fmt % '''
1580 False: re.compile(dict_key_re_fmt % '''
1567 # identifiers separated by .
1581 # identifiers separated by .
1568 (?!\d)\w+
1582 (?!\d)\w+
1569 (?:\.(?!\d)\w+)*
1583 (?:\.(?!\d)\w+)*
1570 '''),
1584 '''),
1571 True: re.compile(dict_key_re_fmt % '''
1585 True: re.compile(dict_key_re_fmt % '''
1572 .+
1586 .+
1573 ''')
1587 ''')
1574 }
1588 }
1575
1589
1576 match = regexps[self.greedy].search(self.text_until_cursor)
1590 match = regexps[self.greedy].search(self.text_until_cursor)
1577 if match is None:
1591 if match is None:
1578 return []
1592 return []
1579
1593
1580 expr, prefix = match.groups()
1594 expr, prefix = match.groups()
1581 try:
1595 try:
1582 obj = eval(expr, self.namespace)
1596 obj = eval(expr, self.namespace)
1583 except Exception:
1597 except Exception:
1584 try:
1598 try:
1585 obj = eval(expr, self.global_namespace)
1599 obj = eval(expr, self.global_namespace)
1586 except Exception:
1600 except Exception:
1587 return []
1601 return []
1588
1602
1589 keys = get_keys(obj)
1603 keys = get_keys(obj)
1590 if not keys:
1604 if not keys:
1591 return keys
1605 return keys
1592 closing_quote, token_offset, matches = match_dict_keys(keys, prefix, self.splitter.delims)
1606 closing_quote, token_offset, matches = match_dict_keys(keys, prefix, self.splitter.delims)
1593 if not matches:
1607 if not matches:
1594 return matches
1608 return matches
1595
1609
1596 # get the cursor position of
1610 # get the cursor position of
1597 # - the text being completed
1611 # - the text being completed
1598 # - the start of the key text
1612 # - the start of the key text
1599 # - the start of the completion
1613 # - the start of the completion
1600 text_start = len(self.text_until_cursor) - len(text)
1614 text_start = len(self.text_until_cursor) - len(text)
1601 if prefix:
1615 if prefix:
1602 key_start = match.start(2)
1616 key_start = match.start(2)
1603 completion_start = key_start + token_offset
1617 completion_start = key_start + token_offset
1604 else:
1618 else:
1605 key_start = completion_start = match.end()
1619 key_start = completion_start = match.end()
1606
1620
1607 # grab the leading prefix, to make sure all completions start with `text`
1621 # grab the leading prefix, to make sure all completions start with `text`
1608 if text_start > key_start:
1622 if text_start > key_start:
1609 leading = ''
1623 leading = ''
1610 else:
1624 else:
1611 leading = text[text_start:completion_start]
1625 leading = text[text_start:completion_start]
1612
1626
1613 # the index of the `[` character
1627 # the index of the `[` character
1614 bracket_idx = match.end(1)
1628 bracket_idx = match.end(1)
1615
1629
1616 # append closing quote and bracket as appropriate
1630 # append closing quote and bracket as appropriate
1617 # this is *not* appropriate if the opening quote or bracket is outside
1631 # this is *not* appropriate if the opening quote or bracket is outside
1618 # the text given to this method
1632 # the text given to this method
1619 suf = ''
1633 suf = ''
1620 continuation = self.line_buffer[len(self.text_until_cursor):]
1634 continuation = self.line_buffer[len(self.text_until_cursor):]
1621 if key_start > text_start and closing_quote:
1635 if key_start > text_start and closing_quote:
1622 # quotes were opened inside text, maybe close them
1636 # quotes were opened inside text, maybe close them
1623 if continuation.startswith(closing_quote):
1637 if continuation.startswith(closing_quote):
1624 continuation = continuation[len(closing_quote):]
1638 continuation = continuation[len(closing_quote):]
1625 else:
1639 else:
1626 suf += closing_quote
1640 suf += closing_quote
1627 if bracket_idx > text_start:
1641 if bracket_idx > text_start:
1628 # brackets were opened inside text, maybe close them
1642 # brackets were opened inside text, maybe close them
1629 if not continuation.startswith(']'):
1643 if not continuation.startswith(']'):
1630 suf += ']'
1644 suf += ']'
1631
1645
1632 return [leading + k + suf for k in matches]
1646 return [leading + k + suf for k in matches]
1633
1647
1634 def unicode_name_matches(self, text):
1648 def unicode_name_matches(self, text):
1635 u"""Match Latex-like syntax for unicode characters base
1649 u"""Match Latex-like syntax for unicode characters base
1636 on the name of the character.
1650 on the name of the character.
1637
1651
1638 This does ``\\GREEK SMALL LETTER ETA`` -> ``Ξ·``
1652 This does ``\\GREEK SMALL LETTER ETA`` -> ``Ξ·``
1639
1653
1640 Works only on valid python 3 identifier, or on combining characters that
1654 Works only on valid python 3 identifier, or on combining characters that
1641 will combine to form a valid identifier.
1655 will combine to form a valid identifier.
1642
1656
1643 Used on Python 3 only.
1657 Used on Python 3 only.
1644 """
1658 """
1645 slashpos = text.rfind('\\')
1659 slashpos = text.rfind('\\')
1646 if slashpos > -1:
1660 if slashpos > -1:
1647 s = text[slashpos+1:]
1661 s = text[slashpos+1:]
1648 try :
1662 try :
1649 unic = unicodedata.lookup(s)
1663 unic = unicodedata.lookup(s)
1650 # allow combining chars
1664 # allow combining chars
1651 if ('a'+unic).isidentifier():
1665 if ('a'+unic).isidentifier():
1652 return '\\'+s,[unic]
1666 return '\\'+s,[unic]
1653 except KeyError:
1667 except KeyError:
1654 pass
1668 pass
1655 return u'', []
1669 return u'', []
1656
1670
1657
1671
1658 def latex_matches(self, text):
1672 def latex_matches(self, text):
1659 u"""Match Latex syntax for unicode characters.
1673 u"""Match Latex syntax for unicode characters.
1660
1674
1661 This does both ``\\alp`` -> ``\\alpha`` and ``\\alpha`` -> ``Ξ±``
1675 This does both ``\\alp`` -> ``\\alpha`` and ``\\alpha`` -> ``Ξ±``
1662
1676
1663 Used on Python 3 only.
1677 Used on Python 3 only.
1664 """
1678 """
1665 slashpos = text.rfind('\\')
1679 slashpos = text.rfind('\\')
1666 if slashpos > -1:
1680 if slashpos > -1:
1667 s = text[slashpos:]
1681 s = text[slashpos:]
1668 if s in latex_symbols:
1682 if s in latex_symbols:
1669 # Try to complete a full latex symbol to unicode
1683 # Try to complete a full latex symbol to unicode
1670 # \\alpha -> Ξ±
1684 # \\alpha -> Ξ±
1671 return s, [latex_symbols[s]]
1685 return s, [latex_symbols[s]]
1672 else:
1686 else:
1673 # If a user has partially typed a latex symbol, give them
1687 # If a user has partially typed a latex symbol, give them
1674 # a full list of options \al -> [\aleph, \alpha]
1688 # a full list of options \al -> [\aleph, \alpha]
1675 matches = [k for k in latex_symbols if k.startswith(s)]
1689 matches = [k for k in latex_symbols if k.startswith(s)]
1676 return s, matches
1690 return s, matches
1677 return u'', []
1691 return u'', []
1678
1692
1679 def dispatch_custom_completer(self, text):
1693 def dispatch_custom_completer(self, text):
1680 if not self.custom_completers:
1694 if not self.custom_completers:
1681 return
1695 return
1682
1696
1683 line = self.line_buffer
1697 line = self.line_buffer
1684 if not line.strip():
1698 if not line.strip():
1685 return None
1699 return None
1686
1700
1687 # Create a little structure to pass all the relevant information about
1701 # Create a little structure to pass all the relevant information about
1688 # the current completion to any custom completer.
1702 # the current completion to any custom completer.
1689 event = SimpleNamespace()
1703 event = SimpleNamespace()
1690 event.line = line
1704 event.line = line
1691 event.symbol = text
1705 event.symbol = text
1692 cmd = line.split(None,1)[0]
1706 cmd = line.split(None,1)[0]
1693 event.command = cmd
1707 event.command = cmd
1694 event.text_until_cursor = self.text_until_cursor
1708 event.text_until_cursor = self.text_until_cursor
1695
1709
1696 # for foo etc, try also to find completer for %foo
1710 # for foo etc, try also to find completer for %foo
1697 if not cmd.startswith(self.magic_escape):
1711 if not cmd.startswith(self.magic_escape):
1698 try_magic = self.custom_completers.s_matches(
1712 try_magic = self.custom_completers.s_matches(
1699 self.magic_escape + cmd)
1713 self.magic_escape + cmd)
1700 else:
1714 else:
1701 try_magic = []
1715 try_magic = []
1702
1716
1703 for c in itertools.chain(self.custom_completers.s_matches(cmd),
1717 for c in itertools.chain(self.custom_completers.s_matches(cmd),
1704 try_magic,
1718 try_magic,
1705 self.custom_completers.flat_matches(self.text_until_cursor)):
1719 self.custom_completers.flat_matches(self.text_until_cursor)):
1706 try:
1720 try:
1707 res = c(event)
1721 res = c(event)
1708 if res:
1722 if res:
1709 # first, try case sensitive match
1723 # first, try case sensitive match
1710 withcase = [r for r in res if r.startswith(text)]
1724 withcase = [r for r in res if r.startswith(text)]
1711 if withcase:
1725 if withcase:
1712 return withcase
1726 return withcase
1713 # if none, then case insensitive ones are ok too
1727 # if none, then case insensitive ones are ok too
1714 text_low = text.lower()
1728 text_low = text.lower()
1715 return [r for r in res if r.lower().startswith(text_low)]
1729 return [r for r in res if r.lower().startswith(text_low)]
1716 except TryNext:
1730 except TryNext:
1717 pass
1731 pass
1718
1732
1719 return None
1733 return None
1720
1734
1721 def completions(self, text: str, offset: int)->Iterator[Completion]:
1735 def completions(self, text: str, offset: int)->Iterator[Completion]:
1722 """
1736 """
1723 Returns an iterator over the possible completions
1737 Returns an iterator over the possible completions
1724
1738
1725 .. warning:: Unstable
1739 .. warning:: Unstable
1726
1740
1727 This function is unstable, API may change without warning.
1741 This function is unstable, API may change without warning.
1728 It will also raise unless use in proper context manager.
1742 It will also raise unless use in proper context manager.
1729
1743
1730 Parameters
1744 Parameters
1731 ----------
1745 ----------
1732
1746
1733 text:str
1747 text:str
1734 Full text of the current input, multi line string.
1748 Full text of the current input, multi line string.
1735 offset:int
1749 offset:int
1736 Integer representing the position of the cursor in ``text``. Offset
1750 Integer representing the position of the cursor in ``text``. Offset
1737 is 0-based indexed.
1751 is 0-based indexed.
1738
1752
1739 Yields
1753 Yields
1740 ------
1754 ------
1741 :any:`Completion` object
1755 :any:`Completion` object
1742
1756
1743
1757
1744 The cursor on a text can either be seen as being "in between"
1758 The cursor on a text can either be seen as being "in between"
1745 characters or "On" a character depending on the interface visible to
1759 characters or "On" a character depending on the interface visible to
1746 the user. For consistency the cursor being on "in between" characters X
1760 the user. For consistency the cursor being on "in between" characters X
1747 and Y is equivalent to the cursor being "on" character Y, that is to say
1761 and Y is equivalent to the cursor being "on" character Y, that is to say
1748 the character the cursor is on is considered as being after the cursor.
1762 the character the cursor is on is considered as being after the cursor.
1749
1763
1750 Combining characters may span more that one position in the
1764 Combining characters may span more that one position in the
1751 text.
1765 text.
1752
1766
1753
1767
1754 .. note::
1768 .. note::
1755
1769
1756 If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
1770 If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
1757 fake Completion token to distinguish completion returned by Jedi
1771 fake Completion token to distinguish completion returned by Jedi
1758 and usual IPython completion.
1772 and usual IPython completion.
1759
1773
1760 .. note::
1774 .. note::
1761
1775
1762 Completions are not completely deduplicated yet. If identical
1776 Completions are not completely deduplicated yet. If identical
1763 completions are coming from different sources this function does not
1777 completions are coming from different sources this function does not
1764 ensure that each completion object will only be present once.
1778 ensure that each completion object will only be present once.
1765 """
1779 """
1766 warnings.warn("_complete is a provisional API (as of IPython 6.0). "
1780 warnings.warn("_complete is a provisional API (as of IPython 6.0). "
1767 "It may change without warnings. "
1781 "It may change without warnings. "
1768 "Use in corresponding context manager.",
1782 "Use in corresponding context manager.",
1769 category=ProvisionalCompleterWarning, stacklevel=2)
1783 category=ProvisionalCompleterWarning, stacklevel=2)
1770
1784
1771 seen = set()
1785 seen = set()
1772 for c in self._completions(text, offset, _timeout=self.jedi_compute_type_timeout/1000):
1786 for c in self._completions(text, offset, _timeout=self.jedi_compute_type_timeout/1000):
1773 if c and (c in seen):
1787 if c and (c in seen):
1774 continue
1788 continue
1775 yield c
1789 yield c
1776 seen.add(c)
1790 seen.add(c)
1777
1791
1778 def _completions(self, full_text: str, offset: int, *, _timeout)->Iterator[Completion]:
1792 def _completions(self, full_text: str, offset: int, *, _timeout)->Iterator[Completion]:
1779 """
1793 """
1780 Core completion module.Same signature as :any:`completions`, with the
1794 Core completion module.Same signature as :any:`completions`, with the
1781 extra `timeout` parameter (in seconds).
1795 extra `timeout` parameter (in seconds).
1782
1796
1783
1797
1784 Computing jedi's completion ``.type`` can be quite expensive (it is a
1798 Computing jedi's completion ``.type`` can be quite expensive (it is a
1785 lazy property) and can require some warm-up, more warm up than just
1799 lazy property) and can require some warm-up, more warm up than just
1786 computing the ``name`` of a completion. The warm-up can be :
1800 computing the ``name`` of a completion. The warm-up can be :
1787
1801
1788 - Long warm-up the first time a module is encountered after
1802 - Long warm-up the first time a module is encountered after
1789 install/update: actually build parse/inference tree.
1803 install/update: actually build parse/inference tree.
1790
1804
1791 - first time the module is encountered in a session: load tree from
1805 - first time the module is encountered in a session: load tree from
1792 disk.
1806 disk.
1793
1807
1794 We don't want to block completions for tens of seconds so we give the
1808 We don't want to block completions for tens of seconds so we give the
1795 completer a "budget" of ``_timeout`` seconds per invocation to compute
1809 completer a "budget" of ``_timeout`` seconds per invocation to compute
1796 completions types, the completions that have not yet been computed will
1810 completions types, the completions that have not yet been computed will
1797 be marked as "unknown" an will have a chance to be computed next round
1811 be marked as "unknown" an will have a chance to be computed next round
1798 are things get cached.
1812 are things get cached.
1799
1813
1800 Keep in mind that Jedi is not the only thing treating the completion so
1814 Keep in mind that Jedi is not the only thing treating the completion so
1801 keep the timeout short-ish as if we take more than 0.3 second we still
1815 keep the timeout short-ish as if we take more than 0.3 second we still
1802 have lots of processing to do.
1816 have lots of processing to do.
1803
1817
1804 """
1818 """
1805 deadline = time.monotonic() + _timeout
1819 deadline = time.monotonic() + _timeout
1806
1820
1807
1821
1808 before = full_text[:offset]
1822 before = full_text[:offset]
1809 cursor_line, cursor_column = position_to_cursor(full_text, offset)
1823 cursor_line, cursor_column = position_to_cursor(full_text, offset)
1810
1824
1811 matched_text, matches, matches_origin, jedi_matches = self._complete(
1825 matched_text, matches, matches_origin, jedi_matches = self._complete(
1812 full_text=full_text, cursor_line=cursor_line, cursor_pos=cursor_column)
1826 full_text=full_text, cursor_line=cursor_line, cursor_pos=cursor_column)
1813
1827
1814 iter_jm = iter(jedi_matches)
1828 iter_jm = iter(jedi_matches)
1815 if _timeout:
1829 if _timeout:
1816 for jm in iter_jm:
1830 for jm in iter_jm:
1817 try:
1831 try:
1818 type_ = jm.type
1832 type_ = jm.type
1819 except Exception:
1833 except Exception:
1820 if self.debug:
1834 if self.debug:
1821 print("Error in Jedi getting type of ", jm)
1835 print("Error in Jedi getting type of ", jm)
1822 type_ = None
1836 type_ = None
1823 delta = len(jm.name_with_symbols) - len(jm.complete)
1837 delta = len(jm.name_with_symbols) - len(jm.complete)
1824 if type_ == 'function':
1838 if type_ == 'function':
1825 signature = _make_signature(jm)
1839 signature = _make_signature(jm)
1826 else:
1840 else:
1827 signature = ''
1841 signature = ''
1828 yield Completion(start=offset - delta,
1842 yield Completion(start=offset - delta,
1829 end=offset,
1843 end=offset,
1830 text=jm.name_with_symbols,
1844 text=jm.name_with_symbols,
1831 type=type_,
1845 type=type_,
1832 signature=signature,
1846 signature=signature,
1833 _origin='jedi')
1847 _origin='jedi')
1834
1848
1835 if time.monotonic() > deadline:
1849 if time.monotonic() > deadline:
1836 break
1850 break
1837
1851
1838 for jm in iter_jm:
1852 for jm in iter_jm:
1839 delta = len(jm.name_with_symbols) - len(jm.complete)
1853 delta = len(jm.name_with_symbols) - len(jm.complete)
1840 yield Completion(start=offset - delta,
1854 yield Completion(start=offset - delta,
1841 end=offset,
1855 end=offset,
1842 text=jm.name_with_symbols,
1856 text=jm.name_with_symbols,
1843 type='<unknown>', # don't compute type for speed
1857 type='<unknown>', # don't compute type for speed
1844 _origin='jedi',
1858 _origin='jedi',
1845 signature='')
1859 signature='')
1846
1860
1847
1861
1848 start_offset = before.rfind(matched_text)
1862 start_offset = before.rfind(matched_text)
1849
1863
1850 # TODO:
1864 # TODO:
1851 # Supress this, right now just for debug.
1865 # Supress this, right now just for debug.
1852 if jedi_matches and matches and self.debug:
1866 if jedi_matches and matches and self.debug:
1853 yield Completion(start=start_offset, end=offset, text='--jedi/ipython--',
1867 yield Completion(start=start_offset, end=offset, text='--jedi/ipython--',
1854 _origin='debug', type='none', signature='')
1868 _origin='debug', type='none', signature='')
1855
1869
1856 # I'm unsure if this is always true, so let's assert and see if it
1870 # I'm unsure if this is always true, so let's assert and see if it
1857 # crash
1871 # crash
1858 assert before.endswith(matched_text)
1872 assert before.endswith(matched_text)
1859 for m, t in zip(matches, matches_origin):
1873 for m, t in zip(matches, matches_origin):
1860 yield Completion(start=start_offset, end=offset, text=m, _origin=t, signature='', type='<unknown>')
1874 yield Completion(start=start_offset, end=offset, text=m, _origin=t, signature='', type='<unknown>')
1861
1875
1862
1876
1863 def complete(self, text=None, line_buffer=None, cursor_pos=None):
1877 def complete(self, text=None, line_buffer=None, cursor_pos=None):
1864 """Find completions for the given text and line context.
1878 """Find completions for the given text and line context.
1865
1879
1866 Note that both the text and the line_buffer are optional, but at least
1880 Note that both the text and the line_buffer are optional, but at least
1867 one of them must be given.
1881 one of them must be given.
1868
1882
1869 Parameters
1883 Parameters
1870 ----------
1884 ----------
1871 text : string, optional
1885 text : string, optional
1872 Text to perform the completion on. If not given, the line buffer
1886 Text to perform the completion on. If not given, the line buffer
1873 is split using the instance's CompletionSplitter object.
1887 is split using the instance's CompletionSplitter object.
1874
1888
1875 line_buffer : string, optional
1889 line_buffer : string, optional
1876 If not given, the completer attempts to obtain the current line
1890 If not given, the completer attempts to obtain the current line
1877 buffer via readline. This keyword allows clients which are
1891 buffer via readline. This keyword allows clients which are
1878 requesting for text completions in non-readline contexts to inform
1892 requesting for text completions in non-readline contexts to inform
1879 the completer of the entire text.
1893 the completer of the entire text.
1880
1894
1881 cursor_pos : int, optional
1895 cursor_pos : int, optional
1882 Index of the cursor in the full line buffer. Should be provided by
1896 Index of the cursor in the full line buffer. Should be provided by
1883 remote frontends where kernel has no access to frontend state.
1897 remote frontends where kernel has no access to frontend state.
1884
1898
1885 Returns
1899 Returns
1886 -------
1900 -------
1887 text : str
1901 text : str
1888 Text that was actually used in the completion.
1902 Text that was actually used in the completion.
1889
1903
1890 matches : list
1904 matches : list
1891 A list of completion matches.
1905 A list of completion matches.
1892
1906
1893
1907
1894 .. note::
1908 .. note::
1895
1909
1896 This API is likely to be deprecated and replaced by
1910 This API is likely to be deprecated and replaced by
1897 :any:`IPCompleter.completions` in the future.
1911 :any:`IPCompleter.completions` in the future.
1898
1912
1899
1913
1900 """
1914 """
1901 warnings.warn('`Completer.complete` is pending deprecation since '
1915 warnings.warn('`Completer.complete` is pending deprecation since '
1902 'IPython 6.0 and will be replaced by `Completer.completions`.',
1916 'IPython 6.0 and will be replaced by `Completer.completions`.',
1903 PendingDeprecationWarning)
1917 PendingDeprecationWarning)
1904 # potential todo, FOLD the 3rd throw away argument of _complete
1918 # potential todo, FOLD the 3rd throw away argument of _complete
1905 # into the first 2 one.
1919 # into the first 2 one.
1906 return self._complete(line_buffer=line_buffer, cursor_pos=cursor_pos, text=text, cursor_line=0)[:2]
1920 return self._complete(line_buffer=line_buffer, cursor_pos=cursor_pos, text=text, cursor_line=0)[:2]
1907
1921
1908 def _complete(self, *, cursor_line, cursor_pos, line_buffer=None, text=None,
1922 def _complete(self, *, cursor_line, cursor_pos, line_buffer=None, text=None,
1909 full_text=None, return_jedi_results=True) -> Tuple[str, List[str], List[str], Iterable[_FakeJediCompletion]]:
1923 full_text=None, return_jedi_results=True) -> Tuple[str, List[str], List[str], Iterable[_FakeJediCompletion]]:
1910 """
1924 """
1911
1925
1912 Like complete but can also returns raw jedi completions as well as the
1926 Like complete but can also returns raw jedi completions as well as the
1913 origin of the completion text. This could (and should) be made much
1927 origin of the completion text. This could (and should) be made much
1914 cleaner but that will be simpler once we drop the old (and stateful)
1928 cleaner but that will be simpler once we drop the old (and stateful)
1915 :any:`complete` API.
1929 :any:`complete` API.
1916
1930
1917
1931
1918 With current provisional API, cursor_pos act both (depending on the
1932 With current provisional API, cursor_pos act both (depending on the
1919 caller) as the offset in the ``text`` or ``line_buffer``, or as the
1933 caller) as the offset in the ``text`` or ``line_buffer``, or as the
1920 ``column`` when passing multiline strings this could/should be renamed
1934 ``column`` when passing multiline strings this could/should be renamed
1921 but would add extra noise.
1935 but would add extra noise.
1922 """
1936 """
1923
1937
1924 # if the cursor position isn't given, the only sane assumption we can
1938 # if the cursor position isn't given, the only sane assumption we can
1925 # make is that it's at the end of the line (the common case)
1939 # make is that it's at the end of the line (the common case)
1926 if cursor_pos is None:
1940 if cursor_pos is None:
1927 cursor_pos = len(line_buffer) if text is None else len(text)
1941 cursor_pos = len(line_buffer) if text is None else len(text)
1928
1942
1929 if self.use_main_ns:
1943 if self.use_main_ns:
1930 self.namespace = __main__.__dict__
1944 self.namespace = __main__.__dict__
1931
1945
1932 # if text is either None or an empty string, rely on the line buffer
1946 # if text is either None or an empty string, rely on the line buffer
1933 if (not line_buffer) and full_text:
1947 if (not line_buffer) and full_text:
1934 line_buffer = full_text.split('\n')[cursor_line]
1948 line_buffer = full_text.split('\n')[cursor_line]
1935 if not text:
1949 if not text:
1936 text = self.splitter.split_line(line_buffer, cursor_pos)
1950 text = self.splitter.split_line(line_buffer, cursor_pos)
1937
1951
1938 if self.backslash_combining_completions:
1952 if self.backslash_combining_completions:
1939 # allow deactivation of these on windows.
1953 # allow deactivation of these on windows.
1940 base_text = text if not line_buffer else line_buffer[:cursor_pos]
1954 base_text = text if not line_buffer else line_buffer[:cursor_pos]
1941 latex_text, latex_matches = self.latex_matches(base_text)
1955 latex_text, latex_matches = self.latex_matches(base_text)
1942 if latex_matches:
1956 if latex_matches:
1943 return latex_text, latex_matches, ['latex_matches']*len(latex_matches), ()
1957 return latex_text, latex_matches, ['latex_matches']*len(latex_matches), ()
1944 name_text = ''
1958 name_text = ''
1945 name_matches = []
1959 name_matches = []
1946 for meth in (self.unicode_name_matches, back_latex_name_matches, back_unicode_name_matches):
1960 for meth in (self.unicode_name_matches, back_latex_name_matches, back_unicode_name_matches):
1947 name_text, name_matches = meth(base_text)
1961 name_text, name_matches = meth(base_text)
1948 if name_text:
1962 if name_text:
1949 return name_text, name_matches[:MATCHES_LIMIT], \
1963 return name_text, name_matches[:MATCHES_LIMIT], \
1950 [meth.__qualname__]*min(len(name_matches), MATCHES_LIMIT), ()
1964 [meth.__qualname__]*min(len(name_matches), MATCHES_LIMIT), ()
1951
1965
1952
1966
1953 # If no line buffer is given, assume the input text is all there was
1967 # If no line buffer is given, assume the input text is all there was
1954 if line_buffer is None:
1968 if line_buffer is None:
1955 line_buffer = text
1969 line_buffer = text
1956
1970
1957 self.line_buffer = line_buffer
1971 self.line_buffer = line_buffer
1958 self.text_until_cursor = self.line_buffer[:cursor_pos]
1972 self.text_until_cursor = self.line_buffer[:cursor_pos]
1959
1973
1960 # Do magic arg matches
1974 # Do magic arg matches
1961 for matcher in self.magic_arg_matchers:
1975 for matcher in self.magic_arg_matchers:
1962 matches = list(matcher(line_buffer))[:MATCHES_LIMIT]
1976 matches = list(matcher(line_buffer))[:MATCHES_LIMIT]
1963 if matches:
1977 if matches:
1964 origins = [matcher.__qualname__] * len(matches)
1978 origins = [matcher.__qualname__] * len(matches)
1965 return text, matches, origins, ()
1979 return text, matches, origins, ()
1966
1980
1967 # Start with a clean slate of completions
1981 # Start with a clean slate of completions
1968 matches = []
1982 matches = []
1969 custom_res = self.dispatch_custom_completer(text)
1983 custom_res = self.dispatch_custom_completer(text)
1970 # FIXME: we should extend our api to return a dict with completions for
1984 # FIXME: we should extend our api to return a dict with completions for
1971 # different types of objects. The rlcomplete() method could then
1985 # different types of objects. The rlcomplete() method could then
1972 # simply collapse the dict into a list for readline, but we'd have
1986 # simply collapse the dict into a list for readline, but we'd have
1973 # richer completion semantics in other evironments.
1987 # richer completion semantics in other evironments.
1974 completions = ()
1988 completions = ()
1975 if self.use_jedi and return_jedi_results:
1989 if self.use_jedi and return_jedi_results:
1976 if not full_text:
1990 if not full_text:
1977 full_text = line_buffer
1991 full_text = line_buffer
1978 completions = self._jedi_matches(
1992 completions = self._jedi_matches(
1979 cursor_pos, cursor_line, full_text)
1993 cursor_pos, cursor_line, full_text)
1980 if custom_res is not None:
1994 if custom_res is not None:
1981 # did custom completers produce something?
1995 # did custom completers produce something?
1982 matches = [(m, 'custom') for m in custom_res]
1996 matches = [(m, 'custom') for m in custom_res]
1983 else:
1997 else:
1984 # Extend the list of completions with the results of each
1998 # Extend the list of completions with the results of each
1985 # matcher, so we return results to the user from all
1999 # matcher, so we return results to the user from all
1986 # namespaces.
2000 # namespaces.
1987 if self.merge_completions:
2001 if self.merge_completions:
1988 matches = []
2002 matches = []
1989 for matcher in self.matchers:
2003 for matcher in self.matchers:
1990 try:
2004 try:
1991 matches.extend([(m, matcher.__qualname__)
2005 matches.extend([(m, matcher.__qualname__)
1992 for m in matcher(text)])
2006 for m in matcher(text)])
1993 except:
2007 except:
1994 # Show the ugly traceback if the matcher causes an
2008 # Show the ugly traceback if the matcher causes an
1995 # exception, but do NOT crash the kernel!
2009 # exception, but do NOT crash the kernel!
1996 sys.excepthook(*sys.exc_info())
2010 sys.excepthook(*sys.exc_info())
1997 else:
2011 else:
1998 for matcher in self.matchers:
2012 for matcher in self.matchers:
1999 matches = [(m, matcher.__qualname__)
2013 matches = [(m, matcher.__qualname__)
2000 for m in matcher(text)]
2014 for m in matcher(text)]
2001 if matches:
2015 if matches:
2002 break
2016 break
2003 seen = set()
2017 seen = set()
2004 filtered_matches = set()
2018 filtered_matches = set()
2005 for m in matches:
2019 for m in matches:
2006 t, c = m
2020 t, c = m
2007 if t not in seen:
2021 if t not in seen:
2008 filtered_matches.add(m)
2022 filtered_matches.add(m)
2009 seen.add(t)
2023 seen.add(t)
2010
2024
2011 _filtered_matches = sorted(
2025 _filtered_matches = sorted(
2012 set(filtered_matches), key=lambda x: completions_sorting_key(x[0]))\
2026 set(filtered_matches), key=lambda x: completions_sorting_key(x[0]))\
2013 [:MATCHES_LIMIT]
2027 [:MATCHES_LIMIT]
2014
2028
2015 _matches = [m[0] for m in _filtered_matches]
2029 _matches = [m[0] for m in _filtered_matches]
2016 origins = [m[1] for m in _filtered_matches]
2030 origins = [m[1] for m in _filtered_matches]
2017
2031
2018 self.matches = _matches
2032 self.matches = _matches
2019
2033
2020 return text, _matches, origins, completions
2034 return text, _matches, origins, completions
@@ -1,963 +1,981 b''
1 # encoding: utf-8
1 # encoding: utf-8
2 """Tests for the IPython tab-completion machinery."""
2 """Tests for the IPython tab-completion machinery."""
3
3
4 # Copyright (c) IPython Development Team.
4 # Copyright (c) IPython Development Team.
5 # Distributed under the terms of the Modified BSD License.
5 # Distributed under the terms of the Modified BSD License.
6
6
7 import os
7 import os
8 import sys
8 import sys
9 import textwrap
9 import textwrap
10 import unittest
10 import unittest
11
11
12 from contextlib import contextmanager
12 from contextlib import contextmanager
13
13
14 import nose.tools as nt
14 import nose.tools as nt
15
15
16 from traitlets.config.loader import Config
16 from traitlets.config.loader import Config
17 from IPython import get_ipython
17 from IPython import get_ipython
18 from IPython.core import completer
18 from IPython.core import completer
19 from IPython.external.decorators import knownfailureif
19 from IPython.external.decorators import knownfailureif
20 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
20 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
21 from IPython.utils.generics import complete_object
21 from IPython.utils.generics import complete_object
22 from IPython.testing import decorators as dec
22 from IPython.testing import decorators as dec
23
23
24 from IPython.core.completer import (
24 from IPython.core.completer import (
25 Completion, provisionalcompleter, match_dict_keys, _deduplicate_completions)
25 Completion, provisionalcompleter, match_dict_keys, _deduplicate_completions)
26 from nose.tools import assert_in, assert_not_in
26 from nose.tools import assert_in, assert_not_in
27
27
28 #-----------------------------------------------------------------------------
28 #-----------------------------------------------------------------------------
29 # Test functions
29 # Test functions
30 #-----------------------------------------------------------------------------
30 #-----------------------------------------------------------------------------
31
31
32 @contextmanager
32 @contextmanager
33 def greedy_completion():
33 def greedy_completion():
34 ip = get_ipython()
34 ip = get_ipython()
35 greedy_original = ip.Completer.greedy
35 greedy_original = ip.Completer.greedy
36 try:
36 try:
37 ip.Completer.greedy = True
37 ip.Completer.greedy = True
38 yield
38 yield
39 finally:
39 finally:
40 ip.Completer.greedy = greedy_original
40 ip.Completer.greedy = greedy_original
41
41
42 def test_protect_filename():
42 def test_protect_filename():
43 if sys.platform == 'win32':
43 if sys.platform == 'win32':
44 pairs = [('abc','abc'),
44 pairs = [('abc','abc'),
45 (' abc','" abc"'),
45 (' abc','" abc"'),
46 ('a bc','"a bc"'),
46 ('a bc','"a bc"'),
47 ('a bc','"a bc"'),
47 ('a bc','"a bc"'),
48 (' bc','" bc"'),
48 (' bc','" bc"'),
49 ]
49 ]
50 else:
50 else:
51 pairs = [('abc','abc'),
51 pairs = [('abc','abc'),
52 (' abc',r'\ abc'),
52 (' abc',r'\ abc'),
53 ('a bc',r'a\ bc'),
53 ('a bc',r'a\ bc'),
54 ('a bc',r'a\ \ bc'),
54 ('a bc',r'a\ \ bc'),
55 (' bc',r'\ \ bc'),
55 (' bc',r'\ \ bc'),
56 # On posix, we also protect parens and other special characters.
56 # On posix, we also protect parens and other special characters.
57 ('a(bc',r'a\(bc'),
57 ('a(bc',r'a\(bc'),
58 ('a)bc',r'a\)bc'),
58 ('a)bc',r'a\)bc'),
59 ('a( )bc',r'a\(\ \)bc'),
59 ('a( )bc',r'a\(\ \)bc'),
60 ('a[1]bc', r'a\[1\]bc'),
60 ('a[1]bc', r'a\[1\]bc'),
61 ('a{1}bc', r'a\{1\}bc'),
61 ('a{1}bc', r'a\{1\}bc'),
62 ('a#bc', r'a\#bc'),
62 ('a#bc', r'a\#bc'),
63 ('a?bc', r'a\?bc'),
63 ('a?bc', r'a\?bc'),
64 ('a=bc', r'a\=bc'),
64 ('a=bc', r'a\=bc'),
65 ('a\\bc', r'a\\bc'),
65 ('a\\bc', r'a\\bc'),
66 ('a|bc', r'a\|bc'),
66 ('a|bc', r'a\|bc'),
67 ('a;bc', r'a\;bc'),
67 ('a;bc', r'a\;bc'),
68 ('a:bc', r'a\:bc'),
68 ('a:bc', r'a\:bc'),
69 ("a'bc", r"a\'bc"),
69 ("a'bc", r"a\'bc"),
70 ('a*bc', r'a\*bc'),
70 ('a*bc', r'a\*bc'),
71 ('a"bc', r'a\"bc'),
71 ('a"bc', r'a\"bc'),
72 ('a^bc', r'a\^bc'),
72 ('a^bc', r'a\^bc'),
73 ('a&bc', r'a\&bc'),
73 ('a&bc', r'a\&bc'),
74 ]
74 ]
75 # run the actual tests
75 # run the actual tests
76 for s1, s2 in pairs:
76 for s1, s2 in pairs:
77 s1p = completer.protect_filename(s1)
77 s1p = completer.protect_filename(s1)
78 nt.assert_equal(s1p, s2)
78 nt.assert_equal(s1p, s2)
79
79
80
80
81 def check_line_split(splitter, test_specs):
81 def check_line_split(splitter, test_specs):
82 for part1, part2, split in test_specs:
82 for part1, part2, split in test_specs:
83 cursor_pos = len(part1)
83 cursor_pos = len(part1)
84 line = part1+part2
84 line = part1+part2
85 out = splitter.split_line(line, cursor_pos)
85 out = splitter.split_line(line, cursor_pos)
86 nt.assert_equal(out, split)
86 nt.assert_equal(out, split)
87
87
88
88
89 def test_line_split():
89 def test_line_split():
90 """Basic line splitter test with default specs."""
90 """Basic line splitter test with default specs."""
91 sp = completer.CompletionSplitter()
91 sp = completer.CompletionSplitter()
92 # The format of the test specs is: part1, part2, expected answer. Parts 1
92 # The format of the test specs is: part1, part2, expected answer. Parts 1
93 # and 2 are joined into the 'line' sent to the splitter, as if the cursor
93 # and 2 are joined into the 'line' sent to the splitter, as if the cursor
94 # was at the end of part1. So an empty part2 represents someone hitting
94 # was at the end of part1. So an empty part2 represents someone hitting
95 # tab at the end of the line, the most common case.
95 # tab at the end of the line, the most common case.
96 t = [('run some/scrip', '', 'some/scrip'),
96 t = [('run some/scrip', '', 'some/scrip'),
97 ('run scripts/er', 'ror.py foo', 'scripts/er'),
97 ('run scripts/er', 'ror.py foo', 'scripts/er'),
98 ('echo $HOM', '', 'HOM'),
98 ('echo $HOM', '', 'HOM'),
99 ('print sys.pa', '', 'sys.pa'),
99 ('print sys.pa', '', 'sys.pa'),
100 ('print(sys.pa', '', 'sys.pa'),
100 ('print(sys.pa', '', 'sys.pa'),
101 ("execfile('scripts/er", '', 'scripts/er'),
101 ("execfile('scripts/er", '', 'scripts/er'),
102 ('a[x.', '', 'x.'),
102 ('a[x.', '', 'x.'),
103 ('a[x.', 'y', 'x.'),
103 ('a[x.', 'y', 'x.'),
104 ('cd "some_file/', '', 'some_file/'),
104 ('cd "some_file/', '', 'some_file/'),
105 ]
105 ]
106 check_line_split(sp, t)
106 check_line_split(sp, t)
107 # Ensure splitting works OK with unicode by re-running the tests with
107 # Ensure splitting works OK with unicode by re-running the tests with
108 # all inputs turned into unicode
108 # all inputs turned into unicode
109 check_line_split(sp, [ map(str, p) for p in t] )
109 check_line_split(sp, [ map(str, p) for p in t] )
110
110
111
111
112 def test_custom_completion_error():
112 def test_custom_completion_error():
113 """Test that errors from custom attribute completers are silenced."""
113 """Test that errors from custom attribute completers are silenced."""
114 ip = get_ipython()
114 ip = get_ipython()
115 class A(object): pass
115 class A(object): pass
116 ip.user_ns['a'] = A()
116 ip.user_ns['a'] = A()
117
117
118 @complete_object.when_type(A)
118 @complete_object.when_type(A)
119 def complete_A(a, existing_completions):
119 def complete_A(a, existing_completions):
120 raise TypeError("this should be silenced")
120 raise TypeError("this should be silenced")
121
121
122 ip.complete("a.")
122 ip.complete("a.")
123
123
124
124
125 def test_unicode_completions():
125 def test_unicode_completions():
126 ip = get_ipython()
126 ip = get_ipython()
127 # Some strings that trigger different types of completion. Check them both
127 # Some strings that trigger different types of completion. Check them both
128 # in str and unicode forms
128 # in str and unicode forms
129 s = ['ru', '%ru', 'cd /', 'floa', 'float(x)/']
129 s = ['ru', '%ru', 'cd /', 'floa', 'float(x)/']
130 for t in s + list(map(str, s)):
130 for t in s + list(map(str, s)):
131 # We don't need to check exact completion values (they may change
131 # We don't need to check exact completion values (they may change
132 # depending on the state of the namespace, but at least no exceptions
132 # depending on the state of the namespace, but at least no exceptions
133 # should be thrown and the return value should be a pair of text, list
133 # should be thrown and the return value should be a pair of text, list
134 # values.
134 # values.
135 text, matches = ip.complete(t)
135 text, matches = ip.complete(t)
136 nt.assert_true(isinstance(text, str))
136 nt.assert_true(isinstance(text, str))
137 nt.assert_true(isinstance(matches, list))
137 nt.assert_true(isinstance(matches, list))
138
138
139 def test_latex_completions():
139 def test_latex_completions():
140 from IPython.core.latex_symbols import latex_symbols
140 from IPython.core.latex_symbols import latex_symbols
141 import random
141 import random
142 ip = get_ipython()
142 ip = get_ipython()
143 # Test some random unicode symbols
143 # Test some random unicode symbols
144 keys = random.sample(latex_symbols.keys(), 10)
144 keys = random.sample(latex_symbols.keys(), 10)
145 for k in keys:
145 for k in keys:
146 text, matches = ip.complete(k)
146 text, matches = ip.complete(k)
147 nt.assert_equal(len(matches),1)
147 nt.assert_equal(len(matches),1)
148 nt.assert_equal(text, k)
148 nt.assert_equal(text, k)
149 nt.assert_equal(matches[0], latex_symbols[k])
149 nt.assert_equal(matches[0], latex_symbols[k])
150 # Test a more complex line
150 # Test a more complex line
151 text, matches = ip.complete(u'print(\\alpha')
151 text, matches = ip.complete(u'print(\\alpha')
152 nt.assert_equal(text, u'\\alpha')
152 nt.assert_equal(text, u'\\alpha')
153 nt.assert_equal(matches[0], latex_symbols['\\alpha'])
153 nt.assert_equal(matches[0], latex_symbols['\\alpha'])
154 # Test multiple matching latex symbols
154 # Test multiple matching latex symbols
155 text, matches = ip.complete(u'\\al')
155 text, matches = ip.complete(u'\\al')
156 nt.assert_in('\\alpha', matches)
156 nt.assert_in('\\alpha', matches)
157 nt.assert_in('\\aleph', matches)
157 nt.assert_in('\\aleph', matches)
158
158
159
159
160
160
161
161
162 def test_back_latex_completion():
162 def test_back_latex_completion():
163 ip = get_ipython()
163 ip = get_ipython()
164
164
165 # do not return more than 1 matches fro \beta, only the latex one.
165 # do not return more than 1 matches fro \beta, only the latex one.
166 name, matches = ip.complete('\\Ξ²')
166 name, matches = ip.complete('\\Ξ²')
167 nt.assert_equal(len(matches), 1)
167 nt.assert_equal(len(matches), 1)
168 nt.assert_equal(matches[0], '\\beta')
168 nt.assert_equal(matches[0], '\\beta')
169
169
170 def test_back_unicode_completion():
170 def test_back_unicode_completion():
171 ip = get_ipython()
171 ip = get_ipython()
172
172
173 name, matches = ip.complete('\\β…€')
173 name, matches = ip.complete('\\β…€')
174 nt.assert_equal(len(matches), 1)
174 nt.assert_equal(len(matches), 1)
175 nt.assert_equal(matches[0], '\\ROMAN NUMERAL FIVE')
175 nt.assert_equal(matches[0], '\\ROMAN NUMERAL FIVE')
176
176
177
177
178 def test_forward_unicode_completion():
178 def test_forward_unicode_completion():
179 ip = get_ipython()
179 ip = get_ipython()
180
180
181 name, matches = ip.complete('\\ROMAN NUMERAL FIVE')
181 name, matches = ip.complete('\\ROMAN NUMERAL FIVE')
182 nt.assert_equal(len(matches), 1)
182 nt.assert_equal(len(matches), 1)
183 nt.assert_equal(matches[0], 'β…€')
183 nt.assert_equal(matches[0], 'β…€')
184
184
185 @dec.knownfailureif(sys.platform == 'win32', 'Fails if there is a C:\\j... path')
185 @dec.knownfailureif(sys.platform == 'win32', 'Fails if there is a C:\\j... path')
186 def test_no_ascii_back_completion():
186 def test_no_ascii_back_completion():
187 ip = get_ipython()
187 ip = get_ipython()
188 with TemporaryWorkingDirectory(): # Avoid any filename completions
188 with TemporaryWorkingDirectory(): # Avoid any filename completions
189 # single ascii letter that don't have yet completions
189 # single ascii letter that don't have yet completions
190 for letter in 'jJ' :
190 for letter in 'jJ' :
191 name, matches = ip.complete('\\'+letter)
191 name, matches = ip.complete('\\'+letter)
192 nt.assert_equal(matches, [])
192 nt.assert_equal(matches, [])
193
193
194
194
195
195
196
196
197 class CompletionSplitterTestCase(unittest.TestCase):
197 class CompletionSplitterTestCase(unittest.TestCase):
198 def setUp(self):
198 def setUp(self):
199 self.sp = completer.CompletionSplitter()
199 self.sp = completer.CompletionSplitter()
200
200
201 def test_delim_setting(self):
201 def test_delim_setting(self):
202 self.sp.delims = ' '
202 self.sp.delims = ' '
203 nt.assert_equal(self.sp.delims, ' ')
203 nt.assert_equal(self.sp.delims, ' ')
204 nt.assert_equal(self.sp._delim_expr, '[\ ]')
204 nt.assert_equal(self.sp._delim_expr, '[\ ]')
205
205
206 def test_spaces(self):
206 def test_spaces(self):
207 """Test with only spaces as split chars."""
207 """Test with only spaces as split chars."""
208 self.sp.delims = ' '
208 self.sp.delims = ' '
209 t = [('foo', '', 'foo'),
209 t = [('foo', '', 'foo'),
210 ('run foo', '', 'foo'),
210 ('run foo', '', 'foo'),
211 ('run foo', 'bar', 'foo'),
211 ('run foo', 'bar', 'foo'),
212 ]
212 ]
213 check_line_split(self.sp, t)
213 check_line_split(self.sp, t)
214
214
215
215
216 def test_has_open_quotes1():
216 def test_has_open_quotes1():
217 for s in ["'", "'''", "'hi' '"]:
217 for s in ["'", "'''", "'hi' '"]:
218 nt.assert_equal(completer.has_open_quotes(s), "'")
218 nt.assert_equal(completer.has_open_quotes(s), "'")
219
219
220
220
221 def test_has_open_quotes2():
221 def test_has_open_quotes2():
222 for s in ['"', '"""', '"hi" "']:
222 for s in ['"', '"""', '"hi" "']:
223 nt.assert_equal(completer.has_open_quotes(s), '"')
223 nt.assert_equal(completer.has_open_quotes(s), '"')
224
224
225
225
226 def test_has_open_quotes3():
226 def test_has_open_quotes3():
227 for s in ["''", "''' '''", "'hi' 'ipython'"]:
227 for s in ["''", "''' '''", "'hi' 'ipython'"]:
228 nt.assert_false(completer.has_open_quotes(s))
228 nt.assert_false(completer.has_open_quotes(s))
229
229
230
230
231 def test_has_open_quotes4():
231 def test_has_open_quotes4():
232 for s in ['""', '""" """', '"hi" "ipython"']:
232 for s in ['""', '""" """', '"hi" "ipython"']:
233 nt.assert_false(completer.has_open_quotes(s))
233 nt.assert_false(completer.has_open_quotes(s))
234
234
235
235
236 @knownfailureif(sys.platform == 'win32', "abspath completions fail on Windows")
236 @knownfailureif(sys.platform == 'win32', "abspath completions fail on Windows")
237 def test_abspath_file_completions():
237 def test_abspath_file_completions():
238 ip = get_ipython()
238 ip = get_ipython()
239 with TemporaryDirectory() as tmpdir:
239 with TemporaryDirectory() as tmpdir:
240 prefix = os.path.join(tmpdir, 'foo')
240 prefix = os.path.join(tmpdir, 'foo')
241 suffixes = ['1', '2']
241 suffixes = ['1', '2']
242 names = [prefix+s for s in suffixes]
242 names = [prefix+s for s in suffixes]
243 for n in names:
243 for n in names:
244 open(n, 'w').close()
244 open(n, 'w').close()
245
245
246 # Check simple completion
246 # Check simple completion
247 c = ip.complete(prefix)[1]
247 c = ip.complete(prefix)[1]
248 nt.assert_equal(c, names)
248 nt.assert_equal(c, names)
249
249
250 # Now check with a function call
250 # Now check with a function call
251 cmd = 'a = f("%s' % prefix
251 cmd = 'a = f("%s' % prefix
252 c = ip.complete(prefix, cmd)[1]
252 c = ip.complete(prefix, cmd)[1]
253 comp = [prefix+s for s in suffixes]
253 comp = [prefix+s for s in suffixes]
254 nt.assert_equal(c, comp)
254 nt.assert_equal(c, comp)
255
255
256
256
257 def test_local_file_completions():
257 def test_local_file_completions():
258 ip = get_ipython()
258 ip = get_ipython()
259 with TemporaryWorkingDirectory():
259 with TemporaryWorkingDirectory():
260 prefix = './foo'
260 prefix = './foo'
261 suffixes = ['1', '2']
261 suffixes = ['1', '2']
262 names = [prefix+s for s in suffixes]
262 names = [prefix+s for s in suffixes]
263 for n in names:
263 for n in names:
264 open(n, 'w').close()
264 open(n, 'w').close()
265
265
266 # Check simple completion
266 # Check simple completion
267 c = ip.complete(prefix)[1]
267 c = ip.complete(prefix)[1]
268 nt.assert_equal(c, names)
268 nt.assert_equal(c, names)
269
269
270 # Now check with a function call
270 # Now check with a function call
271 cmd = 'a = f("%s' % prefix
271 cmd = 'a = f("%s' % prefix
272 c = ip.complete(prefix, cmd)[1]
272 c = ip.complete(prefix, cmd)[1]
273 comp = set(prefix+s for s in suffixes)
273 comp = set(prefix+s for s in suffixes)
274 nt.assert_true(comp.issubset(set(c)))
274 nt.assert_true(comp.issubset(set(c)))
275
275
276
276
277 def test_quoted_file_completions():
277 def test_quoted_file_completions():
278 ip = get_ipython()
278 ip = get_ipython()
279 with TemporaryWorkingDirectory():
279 with TemporaryWorkingDirectory():
280 name = "foo'bar"
280 name = "foo'bar"
281 open(name, 'w').close()
281 open(name, 'w').close()
282
282
283 # Don't escape Windows
283 # Don't escape Windows
284 escaped = name if sys.platform == "win32" else "foo\\'bar"
284 escaped = name if sys.platform == "win32" else "foo\\'bar"
285
285
286 # Single quote matches embedded single quote
286 # Single quote matches embedded single quote
287 text = "open('foo"
287 text = "open('foo"
288 c = ip.Completer._complete(cursor_line=0,
288 c = ip.Completer._complete(cursor_line=0,
289 cursor_pos=len(text),
289 cursor_pos=len(text),
290 full_text=text)[1]
290 full_text=text)[1]
291 nt.assert_equal(c, [escaped])
291 nt.assert_equal(c, [escaped])
292
292
293 # Double quote requires no escape
293 # Double quote requires no escape
294 text = 'open("foo'
294 text = 'open("foo'
295 c = ip.Completer._complete(cursor_line=0,
295 c = ip.Completer._complete(cursor_line=0,
296 cursor_pos=len(text),
296 cursor_pos=len(text),
297 full_text=text)[1]
297 full_text=text)[1]
298 nt.assert_equal(c, [name])
298 nt.assert_equal(c, [name])
299
299
300 # No quote requires an escape
300 # No quote requires an escape
301 text = '%ls foo'
301 text = '%ls foo'
302 c = ip.Completer._complete(cursor_line=0,
302 c = ip.Completer._complete(cursor_line=0,
303 cursor_pos=len(text),
303 cursor_pos=len(text),
304 full_text=text)[1]
304 full_text=text)[1]
305 nt.assert_equal(c, [escaped])
305 nt.assert_equal(c, [escaped])
306
306
307
307
308 def test_jedi():
308 def test_jedi():
309 """
309 """
310 A couple of issue we had with Jedi
310 A couple of issue we had with Jedi
311 """
311 """
312 ip = get_ipython()
312 ip = get_ipython()
313
313
314 def _test_complete(reason, s, comp, start=None, end=None):
314 def _test_complete(reason, s, comp, start=None, end=None):
315 l = len(s)
315 l = len(s)
316 start = start if start is not None else l
316 start = start if start is not None else l
317 end = end if end is not None else l
317 end = end if end is not None else l
318 with provisionalcompleter():
318 with provisionalcompleter():
319 completions = set(ip.Completer.completions(s, l))
319 completions = set(ip.Completer.completions(s, l))
320 assert_in(Completion(start, end, comp), completions, reason)
320 assert_in(Completion(start, end, comp), completions, reason)
321
321
322 def _test_not_complete(reason, s, comp):
322 def _test_not_complete(reason, s, comp):
323 l = len(s)
323 l = len(s)
324 with provisionalcompleter():
324 with provisionalcompleter():
325 completions = set(ip.Completer.completions(s, l))
325 completions = set(ip.Completer.completions(s, l))
326 assert_not_in(Completion(l, l, comp), completions, reason)
326 assert_not_in(Completion(l, l, comp), completions, reason)
327
327
328 import jedi
328 import jedi
329 jedi_version = tuple(int(i) for i in jedi.__version__.split('.')[:3])
329 jedi_version = tuple(int(i) for i in jedi.__version__.split('.')[:3])
330 if jedi_version > (0, 10):
330 if jedi_version > (0, 10):
331 yield _test_complete, 'jedi >0.9 should complete and not crash', 'a=1;a.', 'real'
331 yield _test_complete, 'jedi >0.9 should complete and not crash', 'a=1;a.', 'real'
332 yield _test_complete, 'can infer first argument', 'a=(1,"foo");a[0].', 'real'
332 yield _test_complete, 'can infer first argument', 'a=(1,"foo");a[0].', 'real'
333 yield _test_complete, 'can infer second argument', 'a=(1,"foo");a[1].', 'capitalize'
333 yield _test_complete, 'can infer second argument', 'a=(1,"foo");a[1].', 'capitalize'
334 yield _test_complete, 'cover duplicate completions', 'im', 'import', 0, 2
334 yield _test_complete, 'cover duplicate completions', 'im', 'import', 0, 2
335
335
336 yield _test_not_complete, 'does not mix types', 'a=(1,"foo");a[0].', 'capitalize'
336 yield _test_not_complete, 'does not mix types', 'a=(1,"foo");a[0].', 'capitalize'
337
337
338 def test_completion_have_signature():
338 def test_completion_have_signature():
339 """
339 """
340 Lets make sure jedi is capable of pulling out the signature of the function we are completing.
340 Lets make sure jedi is capable of pulling out the signature of the function we are completing.
341 """
341 """
342 ip = get_ipython()
342 ip = get_ipython()
343 with provisionalcompleter():
343 with provisionalcompleter():
344 completions = ip.Completer.completions('ope', 3)
344 completions = ip.Completer.completions('ope', 3)
345 c = next(completions) # should be `open`
345 c = next(completions) # should be `open`
346 assert 'file' in c.signature, "Signature of function was not found by completer"
346 assert 'file' in c.signature, "Signature of function was not found by completer"
347 assert 'encoding' in c.signature, "Signature of function was not found by completer"
347 assert 'encoding' in c.signature, "Signature of function was not found by completer"
348
348
349
349
350 def test_deduplicate_completions():
350 def test_deduplicate_completions():
351 """
351 """
352 Test that completions are correctly deduplicated (even if ranges are not the same)
352 Test that completions are correctly deduplicated (even if ranges are not the same)
353 """
353 """
354 ip = get_ipython()
354 ip = get_ipython()
355 ip.ex(textwrap.dedent('''
355 ip.ex(textwrap.dedent('''
356 class Z:
356 class Z:
357 zoo = 1
357 zoo = 1
358 '''))
358 '''))
359 with provisionalcompleter():
359 with provisionalcompleter():
360 l = list(_deduplicate_completions('Z.z', ip.Completer.completions('Z.z', 3)))
360 l = list(_deduplicate_completions('Z.z', ip.Completer.completions('Z.z', 3)))
361
361
362 assert len(l) == 1, 'Completions (Z.z<tab>) correctly deduplicate: %s ' % l
362 assert len(l) == 1, 'Completions (Z.z<tab>) correctly deduplicate: %s ' % l
363 assert l[0].text == 'zoo' # and not `it.accumulate`
363 assert l[0].text == 'zoo' # and not `it.accumulate`
364
364
365
365
366 def test_greedy_completions():
366 def test_greedy_completions():
367 """
367 """
368 Test the capability of the Greedy completer.
368 Test the capability of the Greedy completer.
369
369
370 Most of the test here do not really show off the greedy completer, for proof
370 Most of the test here do not really show off the greedy completer, for proof
371 each of the text bellow now pass with Jedi. The greedy completer is capable of more.
371 each of the text bellow now pass with Jedi. The greedy completer is capable of more.
372
372
373 See the :any:`test_dict_key_completion_contexts`
373 See the :any:`test_dict_key_completion_contexts`
374
374
375 """
375 """
376 ip = get_ipython()
376 ip = get_ipython()
377 ip.ex('a=list(range(5))')
377 ip.ex('a=list(range(5))')
378 _,c = ip.complete('.',line='a[0].')
378 _,c = ip.complete('.',line='a[0].')
379 nt.assert_false('.real' in c,
379 nt.assert_false('.real' in c,
380 "Shouldn't have completed on a[0]: %s"%c)
380 "Shouldn't have completed on a[0]: %s"%c)
381 with greedy_completion(), provisionalcompleter():
381 with greedy_completion(), provisionalcompleter():
382 def _(line, cursor_pos, expect, message, completion):
382 def _(line, cursor_pos, expect, message, completion):
383 _,c = ip.complete('.', line=line, cursor_pos=cursor_pos)
383 _,c = ip.complete('.', line=line, cursor_pos=cursor_pos)
384 with provisionalcompleter():
384 with provisionalcompleter():
385 completions = ip.Completer.completions(line, cursor_pos)
385 completions = ip.Completer.completions(line, cursor_pos)
386 nt.assert_in(expect, c, message%c)
386 nt.assert_in(expect, c, message%c)
387 nt.assert_in(completion, completions)
387 nt.assert_in(completion, completions)
388
388
389 yield _, 'a[0].', 5, 'a[0].real', "Should have completed on a[0].: %s", Completion(5,5, 'real')
389 yield _, 'a[0].', 5, 'a[0].real', "Should have completed on a[0].: %s", Completion(5,5, 'real')
390 yield _, 'a[0].r', 6, 'a[0].real', "Should have completed on a[0].r: %s", Completion(5,6, 'real')
390 yield _, 'a[0].r', 6, 'a[0].real', "Should have completed on a[0].r: %s", Completion(5,6, 'real')
391
391
392 if sys.version_info > (3, 4):
392 if sys.version_info > (3, 4):
393 yield _, 'a[0].from_', 10, 'a[0].from_bytes', "Should have completed on a[0].from_: %s", Completion(5, 10, 'from_bytes')
393 yield _, 'a[0].from_', 10, 'a[0].from_bytes', "Should have completed on a[0].from_: %s", Completion(5, 10, 'from_bytes')
394
394
395
395
396 def test_omit__names():
396 def test_omit__names():
397 # also happens to test IPCompleter as a configurable
397 # also happens to test IPCompleter as a configurable
398 ip = get_ipython()
398 ip = get_ipython()
399 ip._hidden_attr = 1
399 ip._hidden_attr = 1
400 ip._x = {}
400 ip._x = {}
401 c = ip.Completer
401 c = ip.Completer
402 ip.ex('ip=get_ipython()')
402 ip.ex('ip=get_ipython()')
403 cfg = Config()
403 cfg = Config()
404 cfg.IPCompleter.omit__names = 0
404 cfg.IPCompleter.omit__names = 0
405 c.update_config(cfg)
405 c.update_config(cfg)
406 with provisionalcompleter():
406 with provisionalcompleter():
407 s,matches = c.complete('ip.')
407 s,matches = c.complete('ip.')
408 completions = set(c.completions('ip.', 3))
408 completions = set(c.completions('ip.', 3))
409
409
410 nt.assert_in('ip.__str__', matches)
410 nt.assert_in('ip.__str__', matches)
411 nt.assert_in(Completion(3, 3, '__str__'), completions)
411 nt.assert_in(Completion(3, 3, '__str__'), completions)
412
412
413 nt.assert_in('ip._hidden_attr', matches)
413 nt.assert_in('ip._hidden_attr', matches)
414 nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
414 nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
415
415
416
416
417 cfg = Config()
417 cfg = Config()
418 cfg.IPCompleter.omit__names = 1
418 cfg.IPCompleter.omit__names = 1
419 c.update_config(cfg)
419 c.update_config(cfg)
420 with provisionalcompleter():
420 with provisionalcompleter():
421 s,matches = c.complete('ip.')
421 s,matches = c.complete('ip.')
422 completions = set(c.completions('ip.', 3))
422 completions = set(c.completions('ip.', 3))
423
423
424 nt.assert_not_in('ip.__str__', matches)
424 nt.assert_not_in('ip.__str__', matches)
425 nt.assert_not_in(Completion(3,3,'__str__'), completions)
425 nt.assert_not_in(Completion(3,3,'__str__'), completions)
426
426
427 # nt.assert_in('ip._hidden_attr', matches)
427 # nt.assert_in('ip._hidden_attr', matches)
428 nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
428 nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
429
429
430 cfg = Config()
430 cfg = Config()
431 cfg.IPCompleter.omit__names = 2
431 cfg.IPCompleter.omit__names = 2
432 c.update_config(cfg)
432 c.update_config(cfg)
433 with provisionalcompleter():
433 with provisionalcompleter():
434 s,matches = c.complete('ip.')
434 s,matches = c.complete('ip.')
435 completions = set(c.completions('ip.', 3))
435 completions = set(c.completions('ip.', 3))
436
436
437 nt.assert_not_in('ip.__str__', matches)
437 nt.assert_not_in('ip.__str__', matches)
438 nt.assert_not_in(Completion(3,3,'__str__'), completions)
438 nt.assert_not_in(Completion(3,3,'__str__'), completions)
439
439
440 nt.assert_not_in('ip._hidden_attr', matches)
440 nt.assert_not_in('ip._hidden_attr', matches)
441 nt.assert_not_in(Completion(3,3, "_hidden_attr"), completions)
441 nt.assert_not_in(Completion(3,3, "_hidden_attr"), completions)
442
442
443 with provisionalcompleter():
443 with provisionalcompleter():
444 s,matches = c.complete('ip._x.')
444 s,matches = c.complete('ip._x.')
445 completions = set(c.completions('ip._x.', 6))
445 completions = set(c.completions('ip._x.', 6))
446
446
447 nt.assert_in('ip._x.keys', matches)
447 nt.assert_in('ip._x.keys', matches)
448 nt.assert_in(Completion(6,6, "keys"), completions)
448 nt.assert_in(Completion(6,6, "keys"), completions)
449
449
450 del ip._hidden_attr
450 del ip._hidden_attr
451 del ip._x
451 del ip._x
452
452
453
453
454 def test_limit_to__all__False_ok():
454 def test_limit_to__all__False_ok():
455 """
455 """
456 Limit to all is deprecated, once we remove it this test can go away.
456 Limit to all is deprecated, once we remove it this test can go away.
457 """
457 """
458 ip = get_ipython()
458 ip = get_ipython()
459 c = ip.Completer
459 c = ip.Completer
460 ip.ex('class D: x=24')
460 ip.ex('class D: x=24')
461 ip.ex('d=D()')
461 ip.ex('d=D()')
462 cfg = Config()
462 cfg = Config()
463 cfg.IPCompleter.limit_to__all__ = False
463 cfg.IPCompleter.limit_to__all__ = False
464 c.update_config(cfg)
464 c.update_config(cfg)
465 s, matches = c.complete('d.')
465 s, matches = c.complete('d.')
466 nt.assert_in('d.x', matches)
466 nt.assert_in('d.x', matches)
467
467
468
468
469 def test_get__all__entries_ok():
469 def test_get__all__entries_ok():
470 class A(object):
470 class A(object):
471 __all__ = ['x', 1]
471 __all__ = ['x', 1]
472 words = completer.get__all__entries(A())
472 words = completer.get__all__entries(A())
473 nt.assert_equal(words, ['x'])
473 nt.assert_equal(words, ['x'])
474
474
475
475
476 def test_get__all__entries_no__all__ok():
476 def test_get__all__entries_no__all__ok():
477 class A(object):
477 class A(object):
478 pass
478 pass
479 words = completer.get__all__entries(A())
479 words = completer.get__all__entries(A())
480 nt.assert_equal(words, [])
480 nt.assert_equal(words, [])
481
481
482
482
483 def test_func_kw_completions():
483 def test_func_kw_completions():
484 ip = get_ipython()
484 ip = get_ipython()
485 c = ip.Completer
485 c = ip.Completer
486 ip.ex('def myfunc(a=1,b=2): return a+b')
486 ip.ex('def myfunc(a=1,b=2): return a+b')
487 s, matches = c.complete(None, 'myfunc(1,b')
487 s, matches = c.complete(None, 'myfunc(1,b')
488 nt.assert_in('b=', matches)
488 nt.assert_in('b=', matches)
489 # Simulate completing with cursor right after b (pos==10):
489 # Simulate completing with cursor right after b (pos==10):
490 s, matches = c.complete(None, 'myfunc(1,b)', 10)
490 s, matches = c.complete(None, 'myfunc(1,b)', 10)
491 nt.assert_in('b=', matches)
491 nt.assert_in('b=', matches)
492 s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b')
492 s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b')
493 nt.assert_in('b=', matches)
493 nt.assert_in('b=', matches)
494 #builtin function
494 #builtin function
495 s, matches = c.complete(None, 'min(k, k')
495 s, matches = c.complete(None, 'min(k, k')
496 nt.assert_in('key=', matches)
496 nt.assert_in('key=', matches)
497
497
498
498
499 def test_default_arguments_from_docstring():
499 def test_default_arguments_from_docstring():
500 ip = get_ipython()
500 ip = get_ipython()
501 c = ip.Completer
501 c = ip.Completer
502 kwd = c._default_arguments_from_docstring(
502 kwd = c._default_arguments_from_docstring(
503 'min(iterable[, key=func]) -> value')
503 'min(iterable[, key=func]) -> value')
504 nt.assert_equal(kwd, ['key'])
504 nt.assert_equal(kwd, ['key'])
505 #with cython type etc
505 #with cython type etc
506 kwd = c._default_arguments_from_docstring(
506 kwd = c._default_arguments_from_docstring(
507 'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n')
507 'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n')
508 nt.assert_equal(kwd, ['ncall', 'resume', 'nsplit'])
508 nt.assert_equal(kwd, ['ncall', 'resume', 'nsplit'])
509 #white spaces
509 #white spaces
510 kwd = c._default_arguments_from_docstring(
510 kwd = c._default_arguments_from_docstring(
511 '\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n')
511 '\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n')
512 nt.assert_equal(kwd, ['ncall', 'resume', 'nsplit'])
512 nt.assert_equal(kwd, ['ncall', 'resume', 'nsplit'])
513
513
514 def test_line_magics():
514 def test_line_magics():
515 ip = get_ipython()
515 ip = get_ipython()
516 c = ip.Completer
516 c = ip.Completer
517 s, matches = c.complete(None, 'lsmag')
517 s, matches = c.complete(None, 'lsmag')
518 nt.assert_in('%lsmagic', matches)
518 nt.assert_in('%lsmagic', matches)
519 s, matches = c.complete(None, '%lsmag')
519 s, matches = c.complete(None, '%lsmag')
520 nt.assert_in('%lsmagic', matches)
520 nt.assert_in('%lsmagic', matches)
521
521
522
522
523 def test_cell_magics():
523 def test_cell_magics():
524 from IPython.core.magic import register_cell_magic
524 from IPython.core.magic import register_cell_magic
525
525
526 @register_cell_magic
526 @register_cell_magic
527 def _foo_cellm(line, cell):
527 def _foo_cellm(line, cell):
528 pass
528 pass
529
529
530 ip = get_ipython()
530 ip = get_ipython()
531 c = ip.Completer
531 c = ip.Completer
532
532
533 s, matches = c.complete(None, '_foo_ce')
533 s, matches = c.complete(None, '_foo_ce')
534 nt.assert_in('%%_foo_cellm', matches)
534 nt.assert_in('%%_foo_cellm', matches)
535 s, matches = c.complete(None, '%%_foo_ce')
535 s, matches = c.complete(None, '%%_foo_ce')
536 nt.assert_in('%%_foo_cellm', matches)
536 nt.assert_in('%%_foo_cellm', matches)
537
537
538
538
539 def test_line_cell_magics():
539 def test_line_cell_magics():
540 from IPython.core.magic import register_line_cell_magic
540 from IPython.core.magic import register_line_cell_magic
541
541
542 @register_line_cell_magic
542 @register_line_cell_magic
543 def _bar_cellm(line, cell):
543 def _bar_cellm(line, cell):
544 pass
544 pass
545
545
546 ip = get_ipython()
546 ip = get_ipython()
547 c = ip.Completer
547 c = ip.Completer
548
548
549 # The policy here is trickier, see comments in completion code. The
549 # The policy here is trickier, see comments in completion code. The
550 # returned values depend on whether the user passes %% or not explicitly,
550 # returned values depend on whether the user passes %% or not explicitly,
551 # and this will show a difference if the same name is both a line and cell
551 # and this will show a difference if the same name is both a line and cell
552 # magic.
552 # magic.
553 s, matches = c.complete(None, '_bar_ce')
553 s, matches = c.complete(None, '_bar_ce')
554 nt.assert_in('%_bar_cellm', matches)
554 nt.assert_in('%_bar_cellm', matches)
555 nt.assert_in('%%_bar_cellm', matches)
555 nt.assert_in('%%_bar_cellm', matches)
556 s, matches = c.complete(None, '%_bar_ce')
556 s, matches = c.complete(None, '%_bar_ce')
557 nt.assert_in('%_bar_cellm', matches)
557 nt.assert_in('%_bar_cellm', matches)
558 nt.assert_in('%%_bar_cellm', matches)
558 nt.assert_in('%%_bar_cellm', matches)
559 s, matches = c.complete(None, '%%_bar_ce')
559 s, matches = c.complete(None, '%%_bar_ce')
560 nt.assert_not_in('%_bar_cellm', matches)
560 nt.assert_not_in('%_bar_cellm', matches)
561 nt.assert_in('%%_bar_cellm', matches)
561 nt.assert_in('%%_bar_cellm', matches)
562
562
563
563
564 def test_magic_completion_order():
564 def test_magic_completion_order():
565 ip = get_ipython()
565 ip = get_ipython()
566 c = ip.Completer
566 c = ip.Completer
567
567
568 # Test ordering of line and cell magics.
568 # Test ordering of line and cell magics.
569 text, matches = c.complete("timeit")
569 text, matches = c.complete("timeit")
570 nt.assert_equal(matches, ["%timeit", "%%timeit"])
570 nt.assert_equal(matches, ["%timeit", "%%timeit"])
571
571
572
572
573 def test_magic_completion_shadowing():
573 def test_magic_completion_shadowing():
574 ip = get_ipython()
574 ip = get_ipython()
575 c = ip.Completer
575 c = ip.Completer
576
576
577 # Before importing matplotlib, %matplotlib magic should be the only option.
577 # Before importing matplotlib, %matplotlib magic should be the only option.
578 text, matches = c.complete("mat")
578 text, matches = c.complete("mat")
579 nt.assert_equal(matches, ["%matplotlib"])
579 nt.assert_equal(matches, ["%matplotlib"])
580
580
581 # The newly introduced name should shadow the magic.
581 # The newly introduced name should shadow the magic.
582 ip.run_cell("matplotlib = 1")
582 ip.run_cell("matplotlib = 1")
583 text, matches = c.complete("mat")
583 text, matches = c.complete("mat")
584 nt.assert_equal(matches, ["matplotlib"])
584 nt.assert_equal(matches, ["matplotlib"])
585
585
586 # After removing matplotlib from namespace, the magic should again be
586 # After removing matplotlib from namespace, the magic should again be
587 # the only option.
587 # the only option.
588 del ip.user_ns["matplotlib"]
588 del ip.user_ns["matplotlib"]
589 text, matches = c.complete("mat")
589 text, matches = c.complete("mat")
590 nt.assert_equal(matches, ["%matplotlib"])
590 nt.assert_equal(matches, ["%matplotlib"])
591
591
592 def test_magic_completion_shadowing_explicit():
593 """
594 If the user try to complete a shadowed magic, and explicit % start should
595 still return the completions.
596 """
597 ip = get_ipython()
598 c = ip.Completer
599
600 # Before importing matplotlib, %matplotlib magic should be the only option.
601 text, matches = c.complete("%mat")
602 nt.assert_equal(matches, ["%matplotlib"])
603
604 ip.run_cell("matplotlib = 1")
605
606 # After removing matplotlib from namespace, the magic should still be
607 # the only option.
608 text, matches = c.complete("%mat")
609 nt.assert_equal(matches, ["%matplotlib"])
592
610
593 def test_magic_config():
611 def test_magic_config():
594 ip = get_ipython()
612 ip = get_ipython()
595 c = ip.Completer
613 c = ip.Completer
596
614
597 s, matches = c.complete(None, 'conf')
615 s, matches = c.complete(None, 'conf')
598 nt.assert_in('%config', matches)
616 nt.assert_in('%config', matches)
599 s, matches = c.complete(None, 'conf')
617 s, matches = c.complete(None, 'conf')
600 nt.assert_not_in('AliasManager', matches)
618 nt.assert_not_in('AliasManager', matches)
601 s, matches = c.complete(None, 'config ')
619 s, matches = c.complete(None, 'config ')
602 nt.assert_in('AliasManager', matches)
620 nt.assert_in('AliasManager', matches)
603 s, matches = c.complete(None, '%config ')
621 s, matches = c.complete(None, '%config ')
604 nt.assert_in('AliasManager', matches)
622 nt.assert_in('AliasManager', matches)
605 s, matches = c.complete(None, 'config Ali')
623 s, matches = c.complete(None, 'config Ali')
606 nt.assert_list_equal(['AliasManager'], matches)
624 nt.assert_list_equal(['AliasManager'], matches)
607 s, matches = c.complete(None, '%config Ali')
625 s, matches = c.complete(None, '%config Ali')
608 nt.assert_list_equal(['AliasManager'], matches)
626 nt.assert_list_equal(['AliasManager'], matches)
609 s, matches = c.complete(None, 'config AliasManager')
627 s, matches = c.complete(None, 'config AliasManager')
610 nt.assert_list_equal(['AliasManager'], matches)
628 nt.assert_list_equal(['AliasManager'], matches)
611 s, matches = c.complete(None, '%config AliasManager')
629 s, matches = c.complete(None, '%config AliasManager')
612 nt.assert_list_equal(['AliasManager'], matches)
630 nt.assert_list_equal(['AliasManager'], matches)
613 s, matches = c.complete(None, 'config AliasManager.')
631 s, matches = c.complete(None, 'config AliasManager.')
614 nt.assert_in('AliasManager.default_aliases', matches)
632 nt.assert_in('AliasManager.default_aliases', matches)
615 s, matches = c.complete(None, '%config AliasManager.')
633 s, matches = c.complete(None, '%config AliasManager.')
616 nt.assert_in('AliasManager.default_aliases', matches)
634 nt.assert_in('AliasManager.default_aliases', matches)
617 s, matches = c.complete(None, 'config AliasManager.de')
635 s, matches = c.complete(None, 'config AliasManager.de')
618 nt.assert_list_equal(['AliasManager.default_aliases'], matches)
636 nt.assert_list_equal(['AliasManager.default_aliases'], matches)
619 s, matches = c.complete(None, 'config AliasManager.de')
637 s, matches = c.complete(None, 'config AliasManager.de')
620 nt.assert_list_equal(['AliasManager.default_aliases'], matches)
638 nt.assert_list_equal(['AliasManager.default_aliases'], matches)
621
639
622
640
623 def test_magic_color():
641 def test_magic_color():
624 ip = get_ipython()
642 ip = get_ipython()
625 c = ip.Completer
643 c = ip.Completer
626
644
627 s, matches = c.complete(None, 'colo')
645 s, matches = c.complete(None, 'colo')
628 nt.assert_in('%colors', matches)
646 nt.assert_in('%colors', matches)
629 s, matches = c.complete(None, 'colo')
647 s, matches = c.complete(None, 'colo')
630 nt.assert_not_in('NoColor', matches)
648 nt.assert_not_in('NoColor', matches)
631 s, matches = c.complete(None, '%colors') # No trailing space
649 s, matches = c.complete(None, '%colors') # No trailing space
632 nt.assert_not_in('NoColor', matches)
650 nt.assert_not_in('NoColor', matches)
633 s, matches = c.complete(None, 'colors ')
651 s, matches = c.complete(None, 'colors ')
634 nt.assert_in('NoColor', matches)
652 nt.assert_in('NoColor', matches)
635 s, matches = c.complete(None, '%colors ')
653 s, matches = c.complete(None, '%colors ')
636 nt.assert_in('NoColor', matches)
654 nt.assert_in('NoColor', matches)
637 s, matches = c.complete(None, 'colors NoCo')
655 s, matches = c.complete(None, 'colors NoCo')
638 nt.assert_list_equal(['NoColor'], matches)
656 nt.assert_list_equal(['NoColor'], matches)
639 s, matches = c.complete(None, '%colors NoCo')
657 s, matches = c.complete(None, '%colors NoCo')
640 nt.assert_list_equal(['NoColor'], matches)
658 nt.assert_list_equal(['NoColor'], matches)
641
659
642
660
643 def test_match_dict_keys():
661 def test_match_dict_keys():
644 """
662 """
645 Test that match_dict_keys works on a couple of use case does return what
663 Test that match_dict_keys works on a couple of use case does return what
646 expected, and does not crash
664 expected, and does not crash
647 """
665 """
648 delims = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
666 delims = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
649
667
650
668
651 keys = ['foo', b'far']
669 keys = ['foo', b'far']
652 assert match_dict_keys(keys, "b'", delims=delims) == ("'", 2 ,['far'])
670 assert match_dict_keys(keys, "b'", delims=delims) == ("'", 2 ,['far'])
653 assert match_dict_keys(keys, "b'f", delims=delims) == ("'", 2 ,['far'])
671 assert match_dict_keys(keys, "b'f", delims=delims) == ("'", 2 ,['far'])
654 assert match_dict_keys(keys, 'b"', delims=delims) == ('"', 2 ,['far'])
672 assert match_dict_keys(keys, 'b"', delims=delims) == ('"', 2 ,['far'])
655 assert match_dict_keys(keys, 'b"f', delims=delims) == ('"', 2 ,['far'])
673 assert match_dict_keys(keys, 'b"f', delims=delims) == ('"', 2 ,['far'])
656
674
657 assert match_dict_keys(keys, "'", delims=delims) == ("'", 1 ,['foo'])
675 assert match_dict_keys(keys, "'", delims=delims) == ("'", 1 ,['foo'])
658 assert match_dict_keys(keys, "'f", delims=delims) == ("'", 1 ,['foo'])
676 assert match_dict_keys(keys, "'f", delims=delims) == ("'", 1 ,['foo'])
659 assert match_dict_keys(keys, '"', delims=delims) == ('"', 1 ,['foo'])
677 assert match_dict_keys(keys, '"', delims=delims) == ('"', 1 ,['foo'])
660 assert match_dict_keys(keys, '"f', delims=delims) == ('"', 1 ,['foo'])
678 assert match_dict_keys(keys, '"f', delims=delims) == ('"', 1 ,['foo'])
661
679
662 match_dict_keys
680 match_dict_keys
663
681
664
682
665 def test_dict_key_completion_string():
683 def test_dict_key_completion_string():
666 """Test dictionary key completion for string keys"""
684 """Test dictionary key completion for string keys"""
667 ip = get_ipython()
685 ip = get_ipython()
668 complete = ip.Completer.complete
686 complete = ip.Completer.complete
669
687
670 ip.user_ns['d'] = {'abc': None}
688 ip.user_ns['d'] = {'abc': None}
671
689
672 # check completion at different stages
690 # check completion at different stages
673 _, matches = complete(line_buffer="d[")
691 _, matches = complete(line_buffer="d[")
674 nt.assert_in("'abc'", matches)
692 nt.assert_in("'abc'", matches)
675 nt.assert_not_in("'abc']", matches)
693 nt.assert_not_in("'abc']", matches)
676
694
677 _, matches = complete(line_buffer="d['")
695 _, matches = complete(line_buffer="d['")
678 nt.assert_in("abc", matches)
696 nt.assert_in("abc", matches)
679 nt.assert_not_in("abc']", matches)
697 nt.assert_not_in("abc']", matches)
680
698
681 _, matches = complete(line_buffer="d['a")
699 _, matches = complete(line_buffer="d['a")
682 nt.assert_in("abc", matches)
700 nt.assert_in("abc", matches)
683 nt.assert_not_in("abc']", matches)
701 nt.assert_not_in("abc']", matches)
684
702
685 # check use of different quoting
703 # check use of different quoting
686 _, matches = complete(line_buffer="d[\"")
704 _, matches = complete(line_buffer="d[\"")
687 nt.assert_in("abc", matches)
705 nt.assert_in("abc", matches)
688 nt.assert_not_in('abc\"]', matches)
706 nt.assert_not_in('abc\"]', matches)
689
707
690 _, matches = complete(line_buffer="d[\"a")
708 _, matches = complete(line_buffer="d[\"a")
691 nt.assert_in("abc", matches)
709 nt.assert_in("abc", matches)
692 nt.assert_not_in('abc\"]', matches)
710 nt.assert_not_in('abc\"]', matches)
693
711
694 # check sensitivity to following context
712 # check sensitivity to following context
695 _, matches = complete(line_buffer="d[]", cursor_pos=2)
713 _, matches = complete(line_buffer="d[]", cursor_pos=2)
696 nt.assert_in("'abc'", matches)
714 nt.assert_in("'abc'", matches)
697
715
698 _, matches = complete(line_buffer="d['']", cursor_pos=3)
716 _, matches = complete(line_buffer="d['']", cursor_pos=3)
699 nt.assert_in("abc", matches)
717 nt.assert_in("abc", matches)
700 nt.assert_not_in("abc'", matches)
718 nt.assert_not_in("abc'", matches)
701 nt.assert_not_in("abc']", matches)
719 nt.assert_not_in("abc']", matches)
702
720
703 # check multiple solutions are correctly returned and that noise is not
721 # check multiple solutions are correctly returned and that noise is not
704 ip.user_ns['d'] = {'abc': None, 'abd': None, 'bad': None, object(): None,
722 ip.user_ns['d'] = {'abc': None, 'abd': None, 'bad': None, object(): None,
705 5: None}
723 5: None}
706
724
707 _, matches = complete(line_buffer="d['a")
725 _, matches = complete(line_buffer="d['a")
708 nt.assert_in("abc", matches)
726 nt.assert_in("abc", matches)
709 nt.assert_in("abd", matches)
727 nt.assert_in("abd", matches)
710 nt.assert_not_in("bad", matches)
728 nt.assert_not_in("bad", matches)
711 assert not any(m.endswith((']', '"', "'")) for m in matches), matches
729 assert not any(m.endswith((']', '"', "'")) for m in matches), matches
712
730
713 # check escaping and whitespace
731 # check escaping and whitespace
714 ip.user_ns['d'] = {'a\nb': None, 'a\'b': None, 'a"b': None, 'a word': None}
732 ip.user_ns['d'] = {'a\nb': None, 'a\'b': None, 'a"b': None, 'a word': None}
715 _, matches = complete(line_buffer="d['a")
733 _, matches = complete(line_buffer="d['a")
716 nt.assert_in("a\\nb", matches)
734 nt.assert_in("a\\nb", matches)
717 nt.assert_in("a\\'b", matches)
735 nt.assert_in("a\\'b", matches)
718 nt.assert_in("a\"b", matches)
736 nt.assert_in("a\"b", matches)
719 nt.assert_in("a word", matches)
737 nt.assert_in("a word", matches)
720 assert not any(m.endswith((']', '"', "'")) for m in matches), matches
738 assert not any(m.endswith((']', '"', "'")) for m in matches), matches
721
739
722 # - can complete on non-initial word of the string
740 # - can complete on non-initial word of the string
723 _, matches = complete(line_buffer="d['a w")
741 _, matches = complete(line_buffer="d['a w")
724 nt.assert_in("word", matches)
742 nt.assert_in("word", matches)
725
743
726 # - understands quote escaping
744 # - understands quote escaping
727 _, matches = complete(line_buffer="d['a\\'")
745 _, matches = complete(line_buffer="d['a\\'")
728 nt.assert_in("b", matches)
746 nt.assert_in("b", matches)
729
747
730 # - default quoting should work like repr
748 # - default quoting should work like repr
731 _, matches = complete(line_buffer="d[")
749 _, matches = complete(line_buffer="d[")
732 nt.assert_in("\"a'b\"", matches)
750 nt.assert_in("\"a'b\"", matches)
733
751
734 # - when opening quote with ", possible to match with unescaped apostrophe
752 # - when opening quote with ", possible to match with unescaped apostrophe
735 _, matches = complete(line_buffer="d[\"a'")
753 _, matches = complete(line_buffer="d[\"a'")
736 nt.assert_in("b", matches)
754 nt.assert_in("b", matches)
737
755
738 # need to not split at delims that readline won't split at
756 # need to not split at delims that readline won't split at
739 if '-' not in ip.Completer.splitter.delims:
757 if '-' not in ip.Completer.splitter.delims:
740 ip.user_ns['d'] = {'before-after': None}
758 ip.user_ns['d'] = {'before-after': None}
741 _, matches = complete(line_buffer="d['before-af")
759 _, matches = complete(line_buffer="d['before-af")
742 nt.assert_in('before-after', matches)
760 nt.assert_in('before-after', matches)
743
761
744 def test_dict_key_completion_contexts():
762 def test_dict_key_completion_contexts():
745 """Test expression contexts in which dict key completion occurs"""
763 """Test expression contexts in which dict key completion occurs"""
746 ip = get_ipython()
764 ip = get_ipython()
747 complete = ip.Completer.complete
765 complete = ip.Completer.complete
748 d = {'abc': None}
766 d = {'abc': None}
749 ip.user_ns['d'] = d
767 ip.user_ns['d'] = d
750
768
751 class C:
769 class C:
752 data = d
770 data = d
753 ip.user_ns['C'] = C
771 ip.user_ns['C'] = C
754 ip.user_ns['get'] = lambda: d
772 ip.user_ns['get'] = lambda: d
755
773
756 def assert_no_completion(**kwargs):
774 def assert_no_completion(**kwargs):
757 _, matches = complete(**kwargs)
775 _, matches = complete(**kwargs)
758 nt.assert_not_in('abc', matches)
776 nt.assert_not_in('abc', matches)
759 nt.assert_not_in('abc\'', matches)
777 nt.assert_not_in('abc\'', matches)
760 nt.assert_not_in('abc\']', matches)
778 nt.assert_not_in('abc\']', matches)
761 nt.assert_not_in('\'abc\'', matches)
779 nt.assert_not_in('\'abc\'', matches)
762 nt.assert_not_in('\'abc\']', matches)
780 nt.assert_not_in('\'abc\']', matches)
763
781
764 def assert_completion(**kwargs):
782 def assert_completion(**kwargs):
765 _, matches = complete(**kwargs)
783 _, matches = complete(**kwargs)
766 nt.assert_in("'abc'", matches)
784 nt.assert_in("'abc'", matches)
767 nt.assert_not_in("'abc']", matches)
785 nt.assert_not_in("'abc']", matches)
768
786
769 # no completion after string closed, even if reopened
787 # no completion after string closed, even if reopened
770 assert_no_completion(line_buffer="d['a'")
788 assert_no_completion(line_buffer="d['a'")
771 assert_no_completion(line_buffer="d[\"a\"")
789 assert_no_completion(line_buffer="d[\"a\"")
772 assert_no_completion(line_buffer="d['a' + ")
790 assert_no_completion(line_buffer="d['a' + ")
773 assert_no_completion(line_buffer="d['a' + '")
791 assert_no_completion(line_buffer="d['a' + '")
774
792
775 # completion in non-trivial expressions
793 # completion in non-trivial expressions
776 assert_completion(line_buffer="+ d[")
794 assert_completion(line_buffer="+ d[")
777 assert_completion(line_buffer="(d[")
795 assert_completion(line_buffer="(d[")
778 assert_completion(line_buffer="C.data[")
796 assert_completion(line_buffer="C.data[")
779
797
780 # greedy flag
798 # greedy flag
781 def assert_completion(**kwargs):
799 def assert_completion(**kwargs):
782 _, matches = complete(**kwargs)
800 _, matches = complete(**kwargs)
783 nt.assert_in("get()['abc']", matches)
801 nt.assert_in("get()['abc']", matches)
784
802
785 assert_no_completion(line_buffer="get()[")
803 assert_no_completion(line_buffer="get()[")
786 with greedy_completion():
804 with greedy_completion():
787 assert_completion(line_buffer="get()[")
805 assert_completion(line_buffer="get()[")
788 assert_completion(line_buffer="get()['")
806 assert_completion(line_buffer="get()['")
789 assert_completion(line_buffer="get()['a")
807 assert_completion(line_buffer="get()['a")
790 assert_completion(line_buffer="get()['ab")
808 assert_completion(line_buffer="get()['ab")
791 assert_completion(line_buffer="get()['abc")
809 assert_completion(line_buffer="get()['abc")
792
810
793
811
794
812
795 def test_dict_key_completion_bytes():
813 def test_dict_key_completion_bytes():
796 """Test handling of bytes in dict key completion"""
814 """Test handling of bytes in dict key completion"""
797 ip = get_ipython()
815 ip = get_ipython()
798 complete = ip.Completer.complete
816 complete = ip.Completer.complete
799
817
800 ip.user_ns['d'] = {'abc': None, b'abd': None}
818 ip.user_ns['d'] = {'abc': None, b'abd': None}
801
819
802 _, matches = complete(line_buffer="d[")
820 _, matches = complete(line_buffer="d[")
803 nt.assert_in("'abc'", matches)
821 nt.assert_in("'abc'", matches)
804 nt.assert_in("b'abd'", matches)
822 nt.assert_in("b'abd'", matches)
805
823
806 if False: # not currently implemented
824 if False: # not currently implemented
807 _, matches = complete(line_buffer="d[b")
825 _, matches = complete(line_buffer="d[b")
808 nt.assert_in("b'abd'", matches)
826 nt.assert_in("b'abd'", matches)
809 nt.assert_not_in("b'abc'", matches)
827 nt.assert_not_in("b'abc'", matches)
810
828
811 _, matches = complete(line_buffer="d[b'")
829 _, matches = complete(line_buffer="d[b'")
812 nt.assert_in("abd", matches)
830 nt.assert_in("abd", matches)
813 nt.assert_not_in("abc", matches)
831 nt.assert_not_in("abc", matches)
814
832
815 _, matches = complete(line_buffer="d[B'")
833 _, matches = complete(line_buffer="d[B'")
816 nt.assert_in("abd", matches)
834 nt.assert_in("abd", matches)
817 nt.assert_not_in("abc", matches)
835 nt.assert_not_in("abc", matches)
818
836
819 _, matches = complete(line_buffer="d['")
837 _, matches = complete(line_buffer="d['")
820 nt.assert_in("abc", matches)
838 nt.assert_in("abc", matches)
821 nt.assert_not_in("abd", matches)
839 nt.assert_not_in("abd", matches)
822
840
823
841
824 def test_dict_key_completion_unicode_py3():
842 def test_dict_key_completion_unicode_py3():
825 """Test handling of unicode in dict key completion"""
843 """Test handling of unicode in dict key completion"""
826 ip = get_ipython()
844 ip = get_ipython()
827 complete = ip.Completer.complete
845 complete = ip.Completer.complete
828
846
829 ip.user_ns['d'] = {u'a\u05d0': None}
847 ip.user_ns['d'] = {u'a\u05d0': None}
830
848
831 # query using escape
849 # query using escape
832 if sys.platform != 'win32':
850 if sys.platform != 'win32':
833 # Known failure on Windows
851 # Known failure on Windows
834 _, matches = complete(line_buffer="d['a\\u05d0")
852 _, matches = complete(line_buffer="d['a\\u05d0")
835 nt.assert_in("u05d0", matches) # tokenized after \\
853 nt.assert_in("u05d0", matches) # tokenized after \\
836
854
837 # query using character
855 # query using character
838 _, matches = complete(line_buffer="d['a\u05d0")
856 _, matches = complete(line_buffer="d['a\u05d0")
839 nt.assert_in(u"a\u05d0", matches)
857 nt.assert_in(u"a\u05d0", matches)
840
858
841 with greedy_completion():
859 with greedy_completion():
842 # query using escape
860 # query using escape
843 _, matches = complete(line_buffer="d['a\\u05d0")
861 _, matches = complete(line_buffer="d['a\\u05d0")
844 nt.assert_in("d['a\\u05d0']", matches) # tokenized after \\
862 nt.assert_in("d['a\\u05d0']", matches) # tokenized after \\
845
863
846 # query using character
864 # query using character
847 _, matches = complete(line_buffer="d['a\u05d0")
865 _, matches = complete(line_buffer="d['a\u05d0")
848 nt.assert_in(u"d['a\u05d0']", matches)
866 nt.assert_in(u"d['a\u05d0']", matches)
849
867
850
868
851
869
852 @dec.skip_without('numpy')
870 @dec.skip_without('numpy')
853 def test_struct_array_key_completion():
871 def test_struct_array_key_completion():
854 """Test dict key completion applies to numpy struct arrays"""
872 """Test dict key completion applies to numpy struct arrays"""
855 import numpy
873 import numpy
856 ip = get_ipython()
874 ip = get_ipython()
857 complete = ip.Completer.complete
875 complete = ip.Completer.complete
858 ip.user_ns['d'] = numpy.array([], dtype=[('hello', 'f'), ('world', 'f')])
876 ip.user_ns['d'] = numpy.array([], dtype=[('hello', 'f'), ('world', 'f')])
859 _, matches = complete(line_buffer="d['")
877 _, matches = complete(line_buffer="d['")
860 nt.assert_in("hello", matches)
878 nt.assert_in("hello", matches)
861 nt.assert_in("world", matches)
879 nt.assert_in("world", matches)
862 # complete on the numpy struct itself
880 # complete on the numpy struct itself
863 dt = numpy.dtype([('my_head', [('my_dt', '>u4'), ('my_df', '>u4')]),
881 dt = numpy.dtype([('my_head', [('my_dt', '>u4'), ('my_df', '>u4')]),
864 ('my_data', '>f4', 5)])
882 ('my_data', '>f4', 5)])
865 x = numpy.zeros(2, dtype=dt)
883 x = numpy.zeros(2, dtype=dt)
866 ip.user_ns['d'] = x[1]
884 ip.user_ns['d'] = x[1]
867 _, matches = complete(line_buffer="d['")
885 _, matches = complete(line_buffer="d['")
868 nt.assert_in("my_head", matches)
886 nt.assert_in("my_head", matches)
869 nt.assert_in("my_data", matches)
887 nt.assert_in("my_data", matches)
870 # complete on a nested level
888 # complete on a nested level
871 with greedy_completion():
889 with greedy_completion():
872 ip.user_ns['d'] = numpy.zeros(2, dtype=dt)
890 ip.user_ns['d'] = numpy.zeros(2, dtype=dt)
873 _, matches = complete(line_buffer="d[1]['my_head']['")
891 _, matches = complete(line_buffer="d[1]['my_head']['")
874 nt.assert_true(any(["my_dt" in m for m in matches]))
892 nt.assert_true(any(["my_dt" in m for m in matches]))
875 nt.assert_true(any(["my_df" in m for m in matches]))
893 nt.assert_true(any(["my_df" in m for m in matches]))
876
894
877
895
878 @dec.skip_without('pandas')
896 @dec.skip_without('pandas')
879 def test_dataframe_key_completion():
897 def test_dataframe_key_completion():
880 """Test dict key completion applies to pandas DataFrames"""
898 """Test dict key completion applies to pandas DataFrames"""
881 import pandas
899 import pandas
882 ip = get_ipython()
900 ip = get_ipython()
883 complete = ip.Completer.complete
901 complete = ip.Completer.complete
884 ip.user_ns['d'] = pandas.DataFrame({'hello': [1], 'world': [2]})
902 ip.user_ns['d'] = pandas.DataFrame({'hello': [1], 'world': [2]})
885 _, matches = complete(line_buffer="d['")
903 _, matches = complete(line_buffer="d['")
886 nt.assert_in("hello", matches)
904 nt.assert_in("hello", matches)
887 nt.assert_in("world", matches)
905 nt.assert_in("world", matches)
888
906
889
907
890 def test_dict_key_completion_invalids():
908 def test_dict_key_completion_invalids():
891 """Smoke test cases dict key completion can't handle"""
909 """Smoke test cases dict key completion can't handle"""
892 ip = get_ipython()
910 ip = get_ipython()
893 complete = ip.Completer.complete
911 complete = ip.Completer.complete
894
912
895 ip.user_ns['no_getitem'] = None
913 ip.user_ns['no_getitem'] = None
896 ip.user_ns['no_keys'] = []
914 ip.user_ns['no_keys'] = []
897 ip.user_ns['cant_call_keys'] = dict
915 ip.user_ns['cant_call_keys'] = dict
898 ip.user_ns['empty'] = {}
916 ip.user_ns['empty'] = {}
899 ip.user_ns['d'] = {'abc': 5}
917 ip.user_ns['d'] = {'abc': 5}
900
918
901 _, matches = complete(line_buffer="no_getitem['")
919 _, matches = complete(line_buffer="no_getitem['")
902 _, matches = complete(line_buffer="no_keys['")
920 _, matches = complete(line_buffer="no_keys['")
903 _, matches = complete(line_buffer="cant_call_keys['")
921 _, matches = complete(line_buffer="cant_call_keys['")
904 _, matches = complete(line_buffer="empty['")
922 _, matches = complete(line_buffer="empty['")
905 _, matches = complete(line_buffer="name_error['")
923 _, matches = complete(line_buffer="name_error['")
906 _, matches = complete(line_buffer="d['\\") # incomplete escape
924 _, matches = complete(line_buffer="d['\\") # incomplete escape
907
925
908 class KeyCompletable(object):
926 class KeyCompletable(object):
909 def __init__(self, things=()):
927 def __init__(self, things=()):
910 self.things = things
928 self.things = things
911
929
912 def _ipython_key_completions_(self):
930 def _ipython_key_completions_(self):
913 return list(self.things)
931 return list(self.things)
914
932
915 def test_object_key_completion():
933 def test_object_key_completion():
916 ip = get_ipython()
934 ip = get_ipython()
917 ip.user_ns['key_completable'] = KeyCompletable(['qwerty', 'qwick'])
935 ip.user_ns['key_completable'] = KeyCompletable(['qwerty', 'qwick'])
918
936
919 _, matches = ip.Completer.complete(line_buffer="key_completable['qw")
937 _, matches = ip.Completer.complete(line_buffer="key_completable['qw")
920 nt.assert_in('qwerty', matches)
938 nt.assert_in('qwerty', matches)
921 nt.assert_in('qwick', matches)
939 nt.assert_in('qwick', matches)
922
940
923
941
924 def test_tryimport():
942 def test_tryimport():
925 """
943 """
926 Test that try-import don't crash on trailing dot, and import modules before
944 Test that try-import don't crash on trailing dot, and import modules before
927 """
945 """
928 from IPython.core.completerlib import try_import
946 from IPython.core.completerlib import try_import
929 assert(try_import("IPython."))
947 assert(try_import("IPython."))
930
948
931
949
932 def test_aimport_module_completer():
950 def test_aimport_module_completer():
933 ip = get_ipython()
951 ip = get_ipython()
934 _, matches = ip.complete('i', '%aimport i')
952 _, matches = ip.complete('i', '%aimport i')
935 nt.assert_in('io', matches)
953 nt.assert_in('io', matches)
936 nt.assert_not_in('int', matches)
954 nt.assert_not_in('int', matches)
937
955
938 def test_nested_import_module_completer():
956 def test_nested_import_module_completer():
939 ip = get_ipython()
957 ip = get_ipython()
940 _, matches = ip.complete(None, 'import IPython.co', 17)
958 _, matches = ip.complete(None, 'import IPython.co', 17)
941 nt.assert_in('IPython.core', matches)
959 nt.assert_in('IPython.core', matches)
942 nt.assert_not_in('import IPython.core', matches)
960 nt.assert_not_in('import IPython.core', matches)
943 nt.assert_not_in('IPython.display', matches)
961 nt.assert_not_in('IPython.display', matches)
944
962
945 def test_import_module_completer():
963 def test_import_module_completer():
946 ip = get_ipython()
964 ip = get_ipython()
947 _, matches = ip.complete('i', 'import i')
965 _, matches = ip.complete('i', 'import i')
948 nt.assert_in('io', matches)
966 nt.assert_in('io', matches)
949 nt.assert_not_in('int', matches)
967 nt.assert_not_in('int', matches)
950
968
951 def test_from_module_completer():
969 def test_from_module_completer():
952 ip = get_ipython()
970 ip = get_ipython()
953 _, matches = ip.complete('B', 'from io import B', 16)
971 _, matches = ip.complete('B', 'from io import B', 16)
954 nt.assert_in('BytesIO', matches)
972 nt.assert_in('BytesIO', matches)
955 nt.assert_not_in('BaseException', matches)
973 nt.assert_not_in('BaseException', matches)
956
974
957 def test_snake_case_completion():
975 def test_snake_case_completion():
958 ip = get_ipython()
976 ip = get_ipython()
959 ip.user_ns['some_three'] = 3
977 ip.user_ns['some_three'] = 3
960 ip.user_ns['some_four'] = 4
978 ip.user_ns['some_four'] = 4
961 _, matches = ip.complete("s_", "print(s_f")
979 _, matches = ip.complete("s_", "print(s_f")
962 nt.assert_in('some_three', matches)
980 nt.assert_in('some_three', matches)
963 nt.assert_in('some_four', matches)
981 nt.assert_in('some_four', matches)
General Comments 0
You need to be logged in to leave comments. Login now