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