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