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