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