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