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