##// END OF EJS Templates
Ensure set_custom_completer is working. Fixes #11272
Nathan Goldbaum -
Show More
@@ -1,2089 +1,2093 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
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
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 context 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_experimental_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 your liking, you should report
202 202 a bug to explain your use case upstream.
203 203
204 204 We'll be happy to get your feedback, feature requests, and improvements on
205 205 any of the unstable APIs!
206 206 """
207 207 with warnings.catch_warnings():
208 208 warnings.filterwarnings(action, category=ProvisionalCompleterWarning)
209 209 yield
210 210
211 211
212 212 def has_open_quotes(s):
213 213 """Return whether a string has open quotes.
214 214
215 215 This simply counts whether the number of quote characters of either type in
216 216 the string is odd.
217 217
218 218 Returns
219 219 -------
220 220 If there is an open quote, the quote character is returned. Else, return
221 221 False.
222 222 """
223 223 # We check " first, then ', so complex cases with nested quotes will get
224 224 # the " to take precedence.
225 225 if s.count('"') % 2:
226 226 return '"'
227 227 elif s.count("'") % 2:
228 228 return "'"
229 229 else:
230 230 return False
231 231
232 232
233 233 def protect_filename(s, protectables=PROTECTABLES):
234 234 """Escape a string to protect certain characters."""
235 235 if set(s) & set(protectables):
236 236 if sys.platform == "win32":
237 237 return '"' + s + '"'
238 238 else:
239 239 return "".join(("\\" + c if c in protectables else c) for c in s)
240 240 else:
241 241 return s
242 242
243 243
244 244 def expand_user(path:str) -> Tuple[str, bool, str]:
245 245 """Expand ``~``-style usernames in strings.
246 246
247 247 This is similar to :func:`os.path.expanduser`, but it computes and returns
248 248 extra information that will be useful if the input was being used in
249 249 computing completions, and you wish to return the completions with the
250 250 original '~' instead of its expanded value.
251 251
252 252 Parameters
253 253 ----------
254 254 path : str
255 255 String to be expanded. If no ~ is present, the output is the same as the
256 256 input.
257 257
258 258 Returns
259 259 -------
260 260 newpath : str
261 261 Result of ~ expansion in the input path.
262 262 tilde_expand : bool
263 263 Whether any expansion was performed or not.
264 264 tilde_val : str
265 265 The value that ~ was replaced with.
266 266 """
267 267 # Default values
268 268 tilde_expand = False
269 269 tilde_val = ''
270 270 newpath = path
271 271
272 272 if path.startswith('~'):
273 273 tilde_expand = True
274 274 rest = len(path)-1
275 275 newpath = os.path.expanduser(path)
276 276 if rest:
277 277 tilde_val = newpath[:-rest]
278 278 else:
279 279 tilde_val = newpath
280 280
281 281 return newpath, tilde_expand, tilde_val
282 282
283 283
284 284 def compress_user(path:str, tilde_expand:bool, tilde_val:str) -> str:
285 285 """Does the opposite of expand_user, with its outputs.
286 286 """
287 287 if tilde_expand:
288 288 return path.replace(tilde_val, '~')
289 289 else:
290 290 return path
291 291
292 292
293 293 def completions_sorting_key(word):
294 294 """key for sorting completions
295 295
296 296 This does several things:
297 297
298 298 - Demote any completions starting with underscores to the end
299 299 - Insert any %magic and %%cellmagic completions in the alphabetical order
300 300 by their name
301 301 """
302 302 prio1, prio2 = 0, 0
303 303
304 304 if word.startswith('__'):
305 305 prio1 = 2
306 306 elif word.startswith('_'):
307 307 prio1 = 1
308 308
309 309 if word.endswith('='):
310 310 prio1 = -1
311 311
312 312 if word.startswith('%%'):
313 313 # If there's another % in there, this is something else, so leave it alone
314 314 if not "%" in word[2:]:
315 315 word = word[2:]
316 316 prio2 = 2
317 317 elif word.startswith('%'):
318 318 if not "%" in word[1:]:
319 319 word = word[1:]
320 320 prio2 = 1
321 321
322 322 return prio1, word, prio2
323 323
324 324
325 325 class _FakeJediCompletion:
326 326 """
327 327 This is a workaround to communicate to the UI that Jedi has crashed and to
328 328 report a bug. Will be used only id :any:`IPCompleter.debug` is set to true.
329 329
330 330 Added in IPython 6.0 so should likely be removed for 7.0
331 331
332 332 """
333 333
334 334 def __init__(self, name):
335 335
336 336 self.name = name
337 337 self.complete = name
338 338 self.type = 'crashed'
339 339 self.name_with_symbols = name
340 340 self.signature = ''
341 341 self._origin = 'fake'
342 342
343 343 def __repr__(self):
344 344 return '<Fake completion object jedi has crashed>'
345 345
346 346
347 347 class Completion:
348 348 """
349 349 Completion object used and return by IPython completers.
350 350
351 351 .. warning:: Unstable
352 352
353 353 This function is unstable, API may change without warning.
354 354 It will also raise unless use in proper context manager.
355 355
356 356 This act as a middle ground :any:`Completion` object between the
357 357 :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
358 358 object. While Jedi need a lot of information about evaluator and how the
359 359 code should be ran/inspected, PromptToolkit (and other frontend) mostly
360 360 need user facing information.
361 361
362 362 - Which range should be replaced replaced by what.
363 363 - Some metadata (like completion type), or meta information to displayed to
364 364 the use user.
365 365
366 366 For debugging purpose we can also store the origin of the completion (``jedi``,
367 367 ``IPython.python_matches``, ``IPython.magics_matches``...).
368 368 """
369 369
370 370 __slots__ = ['start', 'end', 'text', 'type', 'signature', '_origin']
371 371
372 372 def __init__(self, start: int, end: int, text: str, *, type: str=None, _origin='', signature='') -> None:
373 373 warnings.warn("``Completion`` is a provisional API (as of IPython 6.0). "
374 374 "It may change without warnings. "
375 375 "Use in corresponding context manager.",
376 376 category=ProvisionalCompleterWarning, stacklevel=2)
377 377
378 378 self.start = start
379 379 self.end = end
380 380 self.text = text
381 381 self.type = type
382 382 self.signature = signature
383 383 self._origin = _origin
384 384
385 385 def __repr__(self):
386 386 return '<Completion start=%s end=%s text=%r type=%r, signature=%r,>' % \
387 387 (self.start, self.end, self.text, self.type or '?', self.signature or '?')
388 388
389 389 def __eq__(self, other)->Bool:
390 390 """
391 391 Equality and hash do not hash the type (as some completer may not be
392 392 able to infer the type), but are use to (partially) de-duplicate
393 393 completion.
394 394
395 395 Completely de-duplicating completion is a bit tricker that just
396 396 comparing as it depends on surrounding text, which Completions are not
397 397 aware of.
398 398 """
399 399 return self.start == other.start and \
400 400 self.end == other.end and \
401 401 self.text == other.text
402 402
403 403 def __hash__(self):
404 404 return hash((self.start, self.end, self.text))
405 405
406 406
407 407 _IC = Iterable[Completion]
408 408
409 409
410 410 def _deduplicate_completions(text: str, completions: _IC)-> _IC:
411 411 """
412 412 Deduplicate a set of completions.
413 413
414 414 .. warning:: Unstable
415 415
416 416 This function is unstable, API may change without warning.
417 417
418 418 Parameters
419 419 ----------
420 420 text: str
421 421 text that should be completed.
422 422 completions: Iterator[Completion]
423 423 iterator over the completions to deduplicate
424 424
425 425 Yields
426 426 ------
427 427 `Completions` objects
428 428
429 429
430 430 Completions coming from multiple sources, may be different but end up having
431 431 the same effect when applied to ``text``. If this is the case, this will
432 432 consider completions as equal and only emit the first encountered.
433 433
434 434 Not folded in `completions()` yet for debugging purpose, and to detect when
435 435 the IPython completer does return things that Jedi does not, but should be
436 436 at some point.
437 437 """
438 438 completions = list(completions)
439 439 if not completions:
440 440 return
441 441
442 442 new_start = min(c.start for c in completions)
443 443 new_end = max(c.end for c in completions)
444 444
445 445 seen = set()
446 446 for c in completions:
447 447 new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
448 448 if new_text not in seen:
449 449 yield c
450 450 seen.add(new_text)
451 451
452 452
453 453 def rectify_completions(text: str, completions: _IC, *, _debug=False)->_IC:
454 454 """
455 455 Rectify a set of completions to all have the same ``start`` and ``end``
456 456
457 457 .. warning:: Unstable
458 458
459 459 This function is unstable, API may change without warning.
460 460 It will also raise unless use in proper context manager.
461 461
462 462 Parameters
463 463 ----------
464 464 text: str
465 465 text that should be completed.
466 466 completions: Iterator[Completion]
467 467 iterator over the completions to rectify
468 468
469 469
470 470 :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
471 471 the Jupyter Protocol requires them to behave like so. This will readjust
472 472 the completion to have the same ``start`` and ``end`` by padding both
473 473 extremities with surrounding text.
474 474
475 475 During stabilisation should support a ``_debug`` option to log which
476 476 completion are return by the IPython completer and not found in Jedi in
477 477 order to make upstream bug report.
478 478 """
479 479 warnings.warn("`rectify_completions` is a provisional API (as of IPython 6.0). "
480 480 "It may change without warnings. "
481 481 "Use in corresponding context manager.",
482 482 category=ProvisionalCompleterWarning, stacklevel=2)
483 483
484 484 completions = list(completions)
485 485 if not completions:
486 486 return
487 487 starts = (c.start for c in completions)
488 488 ends = (c.end for c in completions)
489 489
490 490 new_start = min(starts)
491 491 new_end = max(ends)
492 492
493 493 seen_jedi = set()
494 494 seen_python_matches = set()
495 495 for c in completions:
496 496 new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
497 497 if c._origin == 'jedi':
498 498 seen_jedi.add(new_text)
499 499 elif c._origin == 'IPCompleter.python_matches':
500 500 seen_python_matches.add(new_text)
501 501 yield Completion(new_start, new_end, new_text, type=c.type, _origin=c._origin, signature=c.signature)
502 502 diff = seen_python_matches.difference(seen_jedi)
503 503 if diff and _debug:
504 504 print('IPython.python matches have extras:', diff)
505 505
506 506
507 507 if sys.platform == 'win32':
508 508 DELIMS = ' \t\n`!@#$^&*()=+[{]}|;\'",<>?'
509 509 else:
510 510 DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
511 511
512 512 GREEDY_DELIMS = ' =\r\n'
513 513
514 514
515 515 class CompletionSplitter(object):
516 516 """An object to split an input line in a manner similar to readline.
517 517
518 518 By having our own implementation, we can expose readline-like completion in
519 519 a uniform manner to all frontends. This object only needs to be given the
520 520 line of text to be split and the cursor position on said line, and it
521 521 returns the 'word' to be completed on at the cursor after splitting the
522 522 entire line.
523 523
524 524 What characters are used as splitting delimiters can be controlled by
525 525 setting the ``delims`` attribute (this is a property that internally
526 526 automatically builds the necessary regular expression)"""
527 527
528 528 # Private interface
529 529
530 530 # A string of delimiter characters. The default value makes sense for
531 531 # IPython's most typical usage patterns.
532 532 _delims = DELIMS
533 533
534 534 # The expression (a normal string) to be compiled into a regular expression
535 535 # for actual splitting. We store it as an attribute mostly for ease of
536 536 # debugging, since this type of code can be so tricky to debug.
537 537 _delim_expr = None
538 538
539 539 # The regular expression that does the actual splitting
540 540 _delim_re = None
541 541
542 542 def __init__(self, delims=None):
543 543 delims = CompletionSplitter._delims if delims is None else delims
544 544 self.delims = delims
545 545
546 546 @property
547 547 def delims(self):
548 548 """Return the string of delimiter characters."""
549 549 return self._delims
550 550
551 551 @delims.setter
552 552 def delims(self, delims):
553 553 """Set the delimiters for line splitting."""
554 554 expr = '[' + ''.join('\\'+ c for c in delims) + ']'
555 555 self._delim_re = re.compile(expr)
556 556 self._delims = delims
557 557 self._delim_expr = expr
558 558
559 559 def split_line(self, line, cursor_pos=None):
560 560 """Split a line of text with a cursor at the given position.
561 561 """
562 562 l = line if cursor_pos is None else line[:cursor_pos]
563 563 return self._delim_re.split(l)[-1]
564 564
565 565
566 566
567 567 class Completer(Configurable):
568 568
569 569 greedy = Bool(False,
570 570 help="""Activate greedy completion
571 571 PENDING DEPRECTION. this is now mostly taken care of with Jedi.
572 572
573 573 This will enable completion on elements of lists, results of function calls, etc.,
574 574 but can be unsafe because the code is actually evaluated on TAB.
575 575 """
576 576 ).tag(config=True)
577 577
578 578 use_jedi = Bool(default_value=JEDI_INSTALLED,
579 579 help="Experimental: Use Jedi to generate autocompletions. "
580 580 "Default to True if jedi is installed.").tag(config=True)
581 581
582 582 jedi_compute_type_timeout = Int(default_value=400,
583 583 help="""Experimental: restrict time (in milliseconds) during which Jedi can compute types.
584 584 Set to 0 to stop computing types. Non-zero value lower than 100ms may hurt
585 585 performance by preventing jedi to build its cache.
586 586 """).tag(config=True)
587 587
588 588 debug = Bool(default_value=False,
589 589 help='Enable debug for the Completer. Mostly print extra '
590 590 'information for experimental jedi integration.')\
591 591 .tag(config=True)
592 592
593 593 backslash_combining_completions = Bool(True,
594 594 help="Enable unicode completions, e.g. \\alpha<tab> . "
595 595 "Includes completion of latex commands, unicode names, and expanding "
596 596 "unicode characters back to latex commands.").tag(config=True)
597 597
598 598
599 599
600 600 def __init__(self, namespace=None, global_namespace=None, **kwargs):
601 601 """Create a new completer for the command line.
602 602
603 603 Completer(namespace=ns, global_namespace=ns2) -> completer instance.
604 604
605 605 If unspecified, the default namespace where completions are performed
606 606 is __main__ (technically, __main__.__dict__). Namespaces should be
607 607 given as dictionaries.
608 608
609 609 An optional second namespace can be given. This allows the completer
610 610 to handle cases where both the local and global scopes need to be
611 611 distinguished.
612 612 """
613 613
614 614 # Don't bind to namespace quite yet, but flag whether the user wants a
615 615 # specific namespace or to use __main__.__dict__. This will allow us
616 616 # to bind to __main__.__dict__ at completion time, not now.
617 617 if namespace is None:
618 618 self.use_main_ns = True
619 619 else:
620 620 self.use_main_ns = False
621 621 self.namespace = namespace
622 622
623 623 # The global namespace, if given, can be bound directly
624 624 if global_namespace is None:
625 625 self.global_namespace = {}
626 626 else:
627 627 self.global_namespace = global_namespace
628 628
629 self.custom_matchers = []
630
629 631 super(Completer, self).__init__(**kwargs)
630 632
631 633 def complete(self, text, state):
632 634 """Return the next possible completion for 'text'.
633 635
634 636 This is called successively with state == 0, 1, 2, ... until it
635 637 returns None. The completion should begin with 'text'.
636 638
637 639 """
638 640 if self.use_main_ns:
639 641 self.namespace = __main__.__dict__
640 642
641 643 if state == 0:
642 644 if "." in text:
643 645 self.matches = self.attr_matches(text)
644 646 else:
645 647 self.matches = self.global_matches(text)
646 648 try:
647 649 return self.matches[state]
648 650 except IndexError:
649 651 return None
650 652
651 653 def global_matches(self, text):
652 654 """Compute matches when text is a simple name.
653 655
654 656 Return a list of all keywords, built-in functions and names currently
655 657 defined in self.namespace or self.global_namespace that match.
656 658
657 659 """
658 660 matches = []
659 661 match_append = matches.append
660 662 n = len(text)
661 663 for lst in [keyword.kwlist,
662 664 builtin_mod.__dict__.keys(),
663 665 self.namespace.keys(),
664 666 self.global_namespace.keys()]:
665 667 for word in lst:
666 668 if word[:n] == text and word != "__builtins__":
667 669 match_append(word)
668 670
669 671 snake_case_re = re.compile(r"[^_]+(_[^_]+)+?\Z")
670 672 for lst in [self.namespace.keys(),
671 673 self.global_namespace.keys()]:
672 674 shortened = {"_".join([sub[0] for sub in word.split('_')]) : word
673 675 for word in lst if snake_case_re.match(word)}
674 676 for word in shortened.keys():
675 677 if word[:n] == text and word != "__builtins__":
676 678 match_append(shortened[word])
677 679 return matches
678 680
679 681 def attr_matches(self, text):
680 682 """Compute matches when text contains a dot.
681 683
682 684 Assuming the text is of the form NAME.NAME....[NAME], and is
683 685 evaluatable in self.namespace or self.global_namespace, it will be
684 686 evaluated and its attributes (as revealed by dir()) are used as
685 687 possible completions. (For class instances, class members are
686 688 also considered.)
687 689
688 690 WARNING: this can still invoke arbitrary C code, if an object
689 691 with a __getattr__ hook is evaluated.
690 692
691 693 """
692 694
693 695 # Another option, seems to work great. Catches things like ''.<tab>
694 696 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
695 697
696 698 if m:
697 699 expr, attr = m.group(1, 3)
698 700 elif self.greedy:
699 701 m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
700 702 if not m2:
701 703 return []
702 704 expr, attr = m2.group(1,2)
703 705 else:
704 706 return []
705 707
706 708 try:
707 709 obj = eval(expr, self.namespace)
708 710 except:
709 711 try:
710 712 obj = eval(expr, self.global_namespace)
711 713 except:
712 714 return []
713 715
714 716 if self.limit_to__all__ and hasattr(obj, '__all__'):
715 717 words = get__all__entries(obj)
716 718 else:
717 719 words = dir2(obj)
718 720
719 721 try:
720 722 words = generics.complete_object(obj, words)
721 723 except TryNext:
722 724 pass
723 725 except AssertionError:
724 726 raise
725 727 except Exception:
726 728 # Silence errors from completion function
727 729 #raise # dbg
728 730 pass
729 731 # Build match list to return
730 732 n = len(attr)
731 733 return [u"%s.%s" % (expr, w) for w in words if w[:n] == attr ]
732 734
733 735
734 736 def get__all__entries(obj):
735 737 """returns the strings in the __all__ attribute"""
736 738 try:
737 739 words = getattr(obj, '__all__')
738 740 except:
739 741 return []
740 742
741 743 return [w for w in words if isinstance(w, str)]
742 744
743 745
744 746 def match_dict_keys(keys: List[str], prefix: str, delims: str):
745 747 """Used by dict_key_matches, matching the prefix to a list of keys
746 748
747 749 Parameters
748 750 ==========
749 751 keys:
750 752 list of keys in dictionary currently being completed.
751 753 prefix:
752 754 Part of the text already typed by the user. e.g. `mydict[b'fo`
753 755 delims:
754 756 String of delimiters to consider when finding the current key.
755 757
756 758 Returns
757 759 =======
758 760
759 761 A tuple of three elements: ``quote``, ``token_start``, ``matched``, with
760 762 ``quote`` being the quote that need to be used to close current string.
761 763 ``token_start`` the position where the replacement should start occurring,
762 764 ``matches`` a list of replacement/completion
763 765
764 766 """
765 767 if not prefix:
766 768 return None, 0, [repr(k) for k in keys
767 769 if isinstance(k, (str, bytes))]
768 770 quote_match = re.search('["\']', prefix)
769 771 quote = quote_match.group()
770 772 try:
771 773 prefix_str = eval(prefix + quote, {})
772 774 except Exception:
773 775 return None, 0, []
774 776
775 777 pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
776 778 token_match = re.search(pattern, prefix, re.UNICODE)
777 779 token_start = token_match.start()
778 780 token_prefix = token_match.group()
779 781
780 782 matched = []
781 783 for key in keys:
782 784 try:
783 785 if not key.startswith(prefix_str):
784 786 continue
785 787 except (AttributeError, TypeError, UnicodeError):
786 788 # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
787 789 continue
788 790
789 791 # reformat remainder of key to begin with prefix
790 792 rem = key[len(prefix_str):]
791 793 # force repr wrapped in '
792 794 rem_repr = repr(rem + '"') if isinstance(rem, str) else repr(rem + b'"')
793 795 if rem_repr.startswith('u') and prefix[0] not in 'uU':
794 796 # Found key is unicode, but prefix is Py2 string.
795 797 # Therefore attempt to interpret key as string.
796 798 try:
797 799 rem_repr = repr(rem.encode('ascii') + '"')
798 800 except UnicodeEncodeError:
799 801 continue
800 802
801 803 rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
802 804 if quote == '"':
803 805 # The entered prefix is quoted with ",
804 806 # but the match is quoted with '.
805 807 # A contained " hence needs escaping for comparison:
806 808 rem_repr = rem_repr.replace('"', '\\"')
807 809
808 810 # then reinsert prefix from start of token
809 811 matched.append('%s%s' % (token_prefix, rem_repr))
810 812 return quote, token_start, matched
811 813
812 814
813 815 def cursor_to_position(text:str, line:int, column:int)->int:
814 816 """
815 817
816 818 Convert the (line,column) position of the cursor in text to an offset in a
817 819 string.
818 820
819 821 Parameters
820 822 ----------
821 823
822 824 text : str
823 825 The text in which to calculate the cursor offset
824 826 line : int
825 827 Line of the cursor; 0-indexed
826 828 column : int
827 829 Column of the cursor 0-indexed
828 830
829 831 Return
830 832 ------
831 833 Position of the cursor in ``text``, 0-indexed.
832 834
833 835 See Also
834 836 --------
835 837 position_to_cursor: reciprocal of this function
836 838
837 839 """
838 840 lines = text.split('\n')
839 841 assert line <= len(lines), '{} <= {}'.format(str(line), str(len(lines)))
840 842
841 843 return sum(len(l) + 1 for l in lines[:line]) + column
842 844
843 845 def position_to_cursor(text:str, offset:int)->Tuple[int, int]:
844 846 """
845 847 Convert the position of the cursor in text (0 indexed) to a line
846 848 number(0-indexed) and a column number (0-indexed) pair
847 849
848 850 Position should be a valid position in ``text``.
849 851
850 852 Parameters
851 853 ----------
852 854
853 855 text : str
854 856 The text in which to calculate the cursor offset
855 857 offset : int
856 858 Position of the cursor in ``text``, 0-indexed.
857 859
858 860 Return
859 861 ------
860 862 (line, column) : (int, int)
861 863 Line of the cursor; 0-indexed, column of the cursor 0-indexed
862 864
863 865
864 866 See Also
865 867 --------
866 868 cursor_to_position : reciprocal of this function
867 869
868 870
869 871 """
870 872
871 873 assert 0 <= offset <= len(text) , "0 <= %s <= %s" % (offset , len(text))
872 874
873 875 before = text[:offset]
874 876 blines = before.split('\n') # ! splitnes trim trailing \n
875 877 line = before.count('\n')
876 878 col = len(blines[-1])
877 879 return line, col
878 880
879 881
880 882 def _safe_isinstance(obj, module, class_name):
881 883 """Checks if obj is an instance of module.class_name if loaded
882 884 """
883 885 return (module in sys.modules and
884 886 isinstance(obj, getattr(import_module(module), class_name)))
885 887
886 888
887 889 def back_unicode_name_matches(text):
888 890 u"""Match unicode characters back to unicode name
889 891
890 892 This does ``β˜ƒ`` -> ``\\snowman``
891 893
892 894 Note that snowman is not a valid python3 combining character but will be expanded.
893 895 Though it will not recombine back to the snowman character by the completion machinery.
894 896
895 897 This will not either back-complete standard sequences like \\n, \\b ...
896 898
897 899 Used on Python 3 only.
898 900 """
899 901 if len(text)<2:
900 902 return u'', ()
901 903 maybe_slash = text[-2]
902 904 if maybe_slash != '\\':
903 905 return u'', ()
904 906
905 907 char = text[-1]
906 908 # no expand on quote for completion in strings.
907 909 # nor backcomplete standard ascii keys
908 910 if char in string.ascii_letters or char in ['"',"'"]:
909 911 return u'', ()
910 912 try :
911 913 unic = unicodedata.name(char)
912 914 return '\\'+char,['\\'+unic]
913 915 except KeyError:
914 916 pass
915 917 return u'', ()
916 918
917 919 def back_latex_name_matches(text:str):
918 920 """Match latex characters back to unicode name
919 921
920 922 This does ``\\β„΅`` -> ``\\aleph``
921 923
922 924 Used on Python 3 only.
923 925 """
924 926 if len(text)<2:
925 927 return u'', ()
926 928 maybe_slash = text[-2]
927 929 if maybe_slash != '\\':
928 930 return u'', ()
929 931
930 932
931 933 char = text[-1]
932 934 # no expand on quote for completion in strings.
933 935 # nor backcomplete standard ascii keys
934 936 if char in string.ascii_letters or char in ['"',"'"]:
935 937 return u'', ()
936 938 try :
937 939 latex = reverse_latex_symbol[char]
938 940 # '\\' replace the \ as well
939 941 return '\\'+char,[latex]
940 942 except KeyError:
941 943 pass
942 944 return u'', ()
943 945
944 946
945 947 def _formatparamchildren(parameter) -> str:
946 948 """
947 949 Get parameter name and value from Jedi Private API
948 950
949 951 Jedi does not expose a simple way to get `param=value` from its API.
950 952
951 953 Parameter
952 954 =========
953 955
954 956 parameter:
955 957 Jedi's function `Param`
956 958
957 959 Returns
958 960 =======
959 961
960 962 A string like 'a', 'b=1', '*args', '**kwargs'
961 963
962 964
963 965 """
964 966 description = parameter.description
965 967 if not description.startswith('param '):
966 968 raise ValueError('Jedi function parameter description have change format.'
967 969 'Expected "param ...", found %r".' % description)
968 970 return description[6:]
969 971
970 972 def _make_signature(completion)-> str:
971 973 """
972 974 Make the signature from a jedi completion
973 975
974 976 Parameter
975 977 =========
976 978
977 979 completion: jedi.Completion
978 980 object does not complete a function type
979 981
980 982 Returns
981 983 =======
982 984
983 985 a string consisting of the function signature, with the parenthesis but
984 986 without the function name. example:
985 987 `(a, *args, b=1, **kwargs)`
986 988
987 989 """
988 990
989 991 return '(%s)'% ', '.join([f for f in (_formatparamchildren(p) for p in completion.params) if f])
990 992
991 993 class IPCompleter(Completer):
992 994 """Extension of the completer class with IPython-specific features"""
993 995
994 996 _names = None
995 997
996 998 @observe('greedy')
997 999 def _greedy_changed(self, change):
998 1000 """update the splitter and readline delims when greedy is changed"""
999 1001 if change['new']:
1000 1002 self.splitter.delims = GREEDY_DELIMS
1001 1003 else:
1002 1004 self.splitter.delims = DELIMS
1003 1005
1004 1006 dict_keys_only = Bool(False,
1005 1007 help="""Whether to show dict key matches only""")
1006 1008
1007 1009 merge_completions = Bool(True,
1008 1010 help="""Whether to merge completion results into a single list
1009 1011
1010 1012 If False, only the completion results from the first non-empty
1011 1013 completer will be returned.
1012 1014 """
1013 1015 ).tag(config=True)
1014 1016 omit__names = Enum((0,1,2), default_value=2,
1015 1017 help="""Instruct the completer to omit private method names
1016 1018
1017 1019 Specifically, when completing on ``object.<tab>``.
1018 1020
1019 1021 When 2 [default]: all names that start with '_' will be excluded.
1020 1022
1021 1023 When 1: all 'magic' names (``__foo__``) will be excluded.
1022 1024
1023 1025 When 0: nothing will be excluded.
1024 1026 """
1025 1027 ).tag(config=True)
1026 1028 limit_to__all__ = Bool(False,
1027 1029 help="""
1028 1030 DEPRECATED as of version 5.0.
1029 1031
1030 1032 Instruct the completer to use __all__ for the completion
1031 1033
1032 1034 Specifically, when completing on ``object.<tab>``.
1033 1035
1034 1036 When True: only those names in obj.__all__ will be included.
1035 1037
1036 1038 When False [default]: the __all__ attribute is ignored
1037 1039 """,
1038 1040 ).tag(config=True)
1039 1041
1040 1042 @observe('limit_to__all__')
1041 1043 def _limit_to_all_changed(self, change):
1042 1044 warnings.warn('`IPython.core.IPCompleter.limit_to__all__` configuration '
1043 1045 'value has been deprecated since IPython 5.0, will be made to have '
1044 1046 'no effects and then removed in future version of IPython.',
1045 1047 UserWarning)
1046 1048
1047 1049 def __init__(self, shell=None, namespace=None, global_namespace=None,
1048 1050 use_readline=_deprecation_readline_sentinel, config=None, **kwargs):
1049 1051 """IPCompleter() -> completer
1050 1052
1051 1053 Return a completer object.
1052 1054
1053 1055 Parameters
1054 1056 ----------
1055 1057
1056 1058 shell
1057 1059 a pointer to the ipython shell itself. This is needed
1058 1060 because this completer knows about magic functions, and those can
1059 1061 only be accessed via the ipython instance.
1060 1062
1061 1063 namespace : dict, optional
1062 1064 an optional dict where completions are performed.
1063 1065
1064 1066 global_namespace : dict, optional
1065 1067 secondary optional dict for completions, to
1066 1068 handle cases (such as IPython embedded inside functions) where
1067 1069 both Python scopes are visible.
1068 1070
1069 1071 use_readline : bool, optional
1070 1072 DEPRECATED, ignored since IPython 6.0, will have no effects
1071 1073 """
1072 1074
1073 1075 self.magic_escape = ESC_MAGIC
1074 1076 self.splitter = CompletionSplitter()
1075 1077
1076 1078 if use_readline is not _deprecation_readline_sentinel:
1077 1079 warnings.warn('The `use_readline` parameter is deprecated and ignored since IPython 6.0.',
1078 1080 DeprecationWarning, stacklevel=2)
1079 1081
1080 1082 # _greedy_changed() depends on splitter and readline being defined:
1081 1083 Completer.__init__(self, namespace=namespace, global_namespace=global_namespace,
1082 1084 config=config, **kwargs)
1083 1085
1084 1086 # List where completion matches will be stored
1085 1087 self.matches = []
1086 1088 self.shell = shell
1087 1089 # Regexp to split filenames with spaces in them
1088 1090 self.space_name_re = re.compile(r'([^\\] )')
1089 1091 # Hold a local ref. to glob.glob for speed
1090 1092 self.glob = glob.glob
1091 1093
1092 1094 # Determine if we are running on 'dumb' terminals, like (X)Emacs
1093 1095 # buffers, to avoid completion problems.
1094 1096 term = os.environ.get('TERM','xterm')
1095 1097 self.dumb_terminal = term in ['dumb','emacs']
1096 1098
1097 1099 # Special handling of backslashes needed in win32 platforms
1098 1100 if sys.platform == "win32":
1099 1101 self.clean_glob = self._clean_glob_win32
1100 1102 else:
1101 1103 self.clean_glob = self._clean_glob
1102 1104
1103 1105 #regexp to parse docstring for function signature
1104 1106 self.docstring_sig_re = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
1105 1107 self.docstring_kwd_re = re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
1106 1108 #use this if positional argument name is also needed
1107 1109 #= re.compile(r'[\s|\[]*(\w+)(?:\s*=?\s*.*)')
1108 1110
1109 1111 self.magic_arg_matchers = [
1110 1112 self.magic_config_matches,
1111 1113 self.magic_color_matches,
1112 1114 ]
1113 1115
1114 1116 # This is set externally by InteractiveShell
1115 1117 self.custom_completers = None
1116 1118
1117 1119 @property
1118 1120 def matchers(self):
1119 1121 """All active matcher routines for completion"""
1120 1122 if self.dict_keys_only:
1121 1123 return [self.dict_key_matches]
1122 1124
1123 1125 if self.use_jedi:
1124 1126 return [
1127 *self.custom_matchers,
1125 1128 self.file_matches,
1126 1129 self.magic_matches,
1127 1130 self.dict_key_matches,
1128 1131 ]
1129 1132 else:
1130 1133 return [
1134 *self.custom_matchers,
1131 1135 self.python_matches,
1132 1136 self.file_matches,
1133 1137 self.magic_matches,
1134 1138 self.python_func_kw_matches,
1135 1139 self.dict_key_matches,
1136 1140 ]
1137 1141
1138 1142 def all_completions(self, text) -> List[str]:
1139 1143 """
1140 1144 Wrapper around the completion methods for the benefit of emacs.
1141 1145 """
1142 1146 prefix = text.rpartition('.')[0]
1143 1147 with provisionalcompleter():
1144 1148 return ['.'.join([prefix, c.text]) if prefix and self.use_jedi else c.text
1145 1149 for c in self.completions(text, len(text))]
1146 1150
1147 1151 return self.complete(text)[1]
1148 1152
1149 1153 def _clean_glob(self, text):
1150 1154 return self.glob("%s*" % text)
1151 1155
1152 1156 def _clean_glob_win32(self,text):
1153 1157 return [f.replace("\\","/")
1154 1158 for f in self.glob("%s*" % text)]
1155 1159
1156 1160 def file_matches(self, text):
1157 1161 """Match filenames, expanding ~USER type strings.
1158 1162
1159 1163 Most of the seemingly convoluted logic in this completer is an
1160 1164 attempt to handle filenames with spaces in them. And yet it's not
1161 1165 quite perfect, because Python's readline doesn't expose all of the
1162 1166 GNU readline details needed for this to be done correctly.
1163 1167
1164 1168 For a filename with a space in it, the printed completions will be
1165 1169 only the parts after what's already been typed (instead of the
1166 1170 full completions, as is normally done). I don't think with the
1167 1171 current (as of Python 2.3) Python readline it's possible to do
1168 1172 better."""
1169 1173
1170 1174 # chars that require escaping with backslash - i.e. chars
1171 1175 # that readline treats incorrectly as delimiters, but we
1172 1176 # don't want to treat as delimiters in filename matching
1173 1177 # when escaped with backslash
1174 1178 if text.startswith('!'):
1175 1179 text = text[1:]
1176 1180 text_prefix = u'!'
1177 1181 else:
1178 1182 text_prefix = u''
1179 1183
1180 1184 text_until_cursor = self.text_until_cursor
1181 1185 # track strings with open quotes
1182 1186 open_quotes = has_open_quotes(text_until_cursor)
1183 1187
1184 1188 if '(' in text_until_cursor or '[' in text_until_cursor:
1185 1189 lsplit = text
1186 1190 else:
1187 1191 try:
1188 1192 # arg_split ~ shlex.split, but with unicode bugs fixed by us
1189 1193 lsplit = arg_split(text_until_cursor)[-1]
1190 1194 except ValueError:
1191 1195 # typically an unmatched ", or backslash without escaped char.
1192 1196 if open_quotes:
1193 1197 lsplit = text_until_cursor.split(open_quotes)[-1]
1194 1198 else:
1195 1199 return []
1196 1200 except IndexError:
1197 1201 # tab pressed on empty line
1198 1202 lsplit = ""
1199 1203
1200 1204 if not open_quotes and lsplit != protect_filename(lsplit):
1201 1205 # if protectables are found, do matching on the whole escaped name
1202 1206 has_protectables = True
1203 1207 text0,text = text,lsplit
1204 1208 else:
1205 1209 has_protectables = False
1206 1210 text = os.path.expanduser(text)
1207 1211
1208 1212 if text == "":
1209 1213 return [text_prefix + protect_filename(f) for f in self.glob("*")]
1210 1214
1211 1215 # Compute the matches from the filesystem
1212 1216 if sys.platform == 'win32':
1213 1217 m0 = self.clean_glob(text)
1214 1218 else:
1215 1219 m0 = self.clean_glob(text.replace('\\', ''))
1216 1220
1217 1221 if has_protectables:
1218 1222 # If we had protectables, we need to revert our changes to the
1219 1223 # beginning of filename so that we don't double-write the part
1220 1224 # of the filename we have so far
1221 1225 len_lsplit = len(lsplit)
1222 1226 matches = [text_prefix + text0 +
1223 1227 protect_filename(f[len_lsplit:]) for f in m0]
1224 1228 else:
1225 1229 if open_quotes:
1226 1230 # if we have a string with an open quote, we don't need to
1227 1231 # protect the names beyond the quote (and we _shouldn't_, as
1228 1232 # it would cause bugs when the filesystem call is made).
1229 1233 matches = m0 if sys.platform == "win32" else\
1230 1234 [protect_filename(f, open_quotes) for f in m0]
1231 1235 else:
1232 1236 matches = [text_prefix +
1233 1237 protect_filename(f) for f in m0]
1234 1238
1235 1239 # Mark directories in input list by appending '/' to their names.
1236 1240 return [x+'/' if os.path.isdir(x) else x for x in matches]
1237 1241
1238 1242 def magic_matches(self, text):
1239 1243 """Match magics"""
1240 1244 # Get all shell magics now rather than statically, so magics loaded at
1241 1245 # runtime show up too.
1242 1246 lsm = self.shell.magics_manager.lsmagic()
1243 1247 line_magics = lsm['line']
1244 1248 cell_magics = lsm['cell']
1245 1249 pre = self.magic_escape
1246 1250 pre2 = pre+pre
1247 1251
1248 1252 explicit_magic = text.startswith(pre)
1249 1253
1250 1254 # Completion logic:
1251 1255 # - user gives %%: only do cell magics
1252 1256 # - user gives %: do both line and cell magics
1253 1257 # - no prefix: do both
1254 1258 # In other words, line magics are skipped if the user gives %% explicitly
1255 1259 #
1256 1260 # We also exclude magics that match any currently visible names:
1257 1261 # https://github.com/ipython/ipython/issues/4877, unless the user has
1258 1262 # typed a %:
1259 1263 # https://github.com/ipython/ipython/issues/10754
1260 1264 bare_text = text.lstrip(pre)
1261 1265 global_matches = self.global_matches(bare_text)
1262 1266 if not explicit_magic:
1263 1267 def matches(magic):
1264 1268 """
1265 1269 Filter magics, in particular remove magics that match
1266 1270 a name present in global namespace.
1267 1271 """
1268 1272 return ( magic.startswith(bare_text) and
1269 1273 magic not in global_matches )
1270 1274 else:
1271 1275 def matches(magic):
1272 1276 return magic.startswith(bare_text)
1273 1277
1274 1278 comp = [ pre2+m for m in cell_magics if matches(m)]
1275 1279 if not text.startswith(pre2):
1276 1280 comp += [ pre+m for m in line_magics if matches(m)]
1277 1281
1278 1282 return comp
1279 1283
1280 1284 def magic_config_matches(self, text:str) -> List[str]:
1281 1285 """ Match class names and attributes for %config magic """
1282 1286 texts = text.strip().split()
1283 1287
1284 1288 if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
1285 1289 # get all configuration classes
1286 1290 classes = sorted(set([ c for c in self.shell.configurables
1287 1291 if c.__class__.class_traits(config=True)
1288 1292 ]), key=lambda x: x.__class__.__name__)
1289 1293 classnames = [ c.__class__.__name__ for c in classes ]
1290 1294
1291 1295 # return all classnames if config or %config is given
1292 1296 if len(texts) == 1:
1293 1297 return classnames
1294 1298
1295 1299 # match classname
1296 1300 classname_texts = texts[1].split('.')
1297 1301 classname = classname_texts[0]
1298 1302 classname_matches = [ c for c in classnames
1299 1303 if c.startswith(classname) ]
1300 1304
1301 1305 # return matched classes or the matched class with attributes
1302 1306 if texts[1].find('.') < 0:
1303 1307 return classname_matches
1304 1308 elif len(classname_matches) == 1 and \
1305 1309 classname_matches[0] == classname:
1306 1310 cls = classes[classnames.index(classname)].__class__
1307 1311 help = cls.class_get_help()
1308 1312 # strip leading '--' from cl-args:
1309 1313 help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
1310 1314 return [ attr.split('=')[0]
1311 1315 for attr in help.strip().splitlines()
1312 1316 if attr.startswith(texts[1]) ]
1313 1317 return []
1314 1318
1315 1319 def magic_color_matches(self, text:str) -> List[str] :
1316 1320 """ Match color schemes for %colors magic"""
1317 1321 texts = text.split()
1318 1322 if text.endswith(' '):
1319 1323 # .split() strips off the trailing whitespace. Add '' back
1320 1324 # so that: '%colors ' -> ['%colors', '']
1321 1325 texts.append('')
1322 1326
1323 1327 if len(texts) == 2 and (texts[0] == 'colors' or texts[0] == '%colors'):
1324 1328 prefix = texts[1]
1325 1329 return [ color for color in InspectColors.keys()
1326 1330 if color.startswith(prefix) ]
1327 1331 return []
1328 1332
1329 1333 def _jedi_matches(self, cursor_column:int, cursor_line:int, text:str):
1330 1334 """
1331 1335
1332 1336 Return a list of :any:`jedi.api.Completions` object from a ``text`` and
1333 1337 cursor position.
1334 1338
1335 1339 Parameters
1336 1340 ----------
1337 1341 cursor_column : int
1338 1342 column position of the cursor in ``text``, 0-indexed.
1339 1343 cursor_line : int
1340 1344 line position of the cursor in ``text``, 0-indexed
1341 1345 text : str
1342 1346 text to complete
1343 1347
1344 1348 Debugging
1345 1349 ---------
1346 1350
1347 1351 If ``IPCompleter.debug`` is ``True`` may return a :any:`_FakeJediCompletion`
1348 1352 object containing a string with the Jedi debug information attached.
1349 1353 """
1350 1354 namespaces = [self.namespace]
1351 1355 if self.global_namespace is not None:
1352 1356 namespaces.append(self.global_namespace)
1353 1357
1354 1358 completion_filter = lambda x:x
1355 1359 offset = cursor_to_position(text, cursor_line, cursor_column)
1356 1360 # filter output if we are completing for object members
1357 1361 if offset:
1358 1362 pre = text[offset-1]
1359 1363 if pre == '.':
1360 1364 if self.omit__names == 2:
1361 1365 completion_filter = lambda c:not c.name.startswith('_')
1362 1366 elif self.omit__names == 1:
1363 1367 completion_filter = lambda c:not (c.name.startswith('__') and c.name.endswith('__'))
1364 1368 elif self.omit__names == 0:
1365 1369 completion_filter = lambda x:x
1366 1370 else:
1367 1371 raise ValueError("Don't understand self.omit__names == {}".format(self.omit__names))
1368 1372
1369 1373 interpreter = jedi.Interpreter(
1370 1374 text[:offset], namespaces, column=cursor_column, line=cursor_line + 1)
1371 1375 try_jedi = True
1372 1376
1373 1377 try:
1374 1378 # should we check the type of the node is Error ?
1375 1379 try:
1376 1380 # jedi < 0.11
1377 1381 from jedi.parser.tree import ErrorLeaf
1378 1382 except ImportError:
1379 1383 # jedi >= 0.11
1380 1384 from parso.tree import ErrorLeaf
1381 1385
1382 1386 next_to_last_tree = interpreter._get_module().tree_node.children[-2]
1383 1387 completing_string = False
1384 1388 if isinstance(next_to_last_tree, ErrorLeaf):
1385 1389 completing_string = next_to_last_tree.value.lstrip()[0] in {'"', "'"}
1386 1390 # if we are in a string jedi is likely not the right candidate for
1387 1391 # now. Skip it.
1388 1392 try_jedi = not completing_string
1389 1393 except Exception as e:
1390 1394 # many of things can go wrong, we are using private API just don't crash.
1391 1395 if self.debug:
1392 1396 print("Error detecting if completing a non-finished string :", e, '|')
1393 1397
1394 1398 if not try_jedi:
1395 1399 return []
1396 1400 try:
1397 1401 return filter(completion_filter, interpreter.completions())
1398 1402 except Exception as e:
1399 1403 if self.debug:
1400 1404 return [_FakeJediCompletion('Oops Jedi has crashed, please report a bug with the following:\n"""\n%s\ns"""' % (e))]
1401 1405 else:
1402 1406 return []
1403 1407
1404 1408 def python_matches(self, text):
1405 1409 """Match attributes or global python names"""
1406 1410 if "." in text:
1407 1411 try:
1408 1412 matches = self.attr_matches(text)
1409 1413 if text.endswith('.') and self.omit__names:
1410 1414 if self.omit__names == 1:
1411 1415 # true if txt is _not_ a __ name, false otherwise:
1412 1416 no__name = (lambda txt:
1413 1417 re.match(r'.*\.__.*?__',txt) is None)
1414 1418 else:
1415 1419 # true if txt is _not_ a _ name, false otherwise:
1416 1420 no__name = (lambda txt:
1417 1421 re.match(r'\._.*?',txt[txt.rindex('.'):]) is None)
1418 1422 matches = filter(no__name, matches)
1419 1423 except NameError:
1420 1424 # catches <undefined attributes>.<tab>
1421 1425 matches = []
1422 1426 else:
1423 1427 matches = self.global_matches(text)
1424 1428 return matches
1425 1429
1426 1430 def _default_arguments_from_docstring(self, doc):
1427 1431 """Parse the first line of docstring for call signature.
1428 1432
1429 1433 Docstring should be of the form 'min(iterable[, key=func])\n'.
1430 1434 It can also parse cython docstring of the form
1431 1435 'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'.
1432 1436 """
1433 1437 if doc is None:
1434 1438 return []
1435 1439
1436 1440 #care only the firstline
1437 1441 line = doc.lstrip().splitlines()[0]
1438 1442
1439 1443 #p = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
1440 1444 #'min(iterable[, key=func])\n' -> 'iterable[, key=func]'
1441 1445 sig = self.docstring_sig_re.search(line)
1442 1446 if sig is None:
1443 1447 return []
1444 1448 # iterable[, key=func]' -> ['iterable[' ,' key=func]']
1445 1449 sig = sig.groups()[0].split(',')
1446 1450 ret = []
1447 1451 for s in sig:
1448 1452 #re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
1449 1453 ret += self.docstring_kwd_re.findall(s)
1450 1454 return ret
1451 1455
1452 1456 def _default_arguments(self, obj):
1453 1457 """Return the list of default arguments of obj if it is callable,
1454 1458 or empty list otherwise."""
1455 1459 call_obj = obj
1456 1460 ret = []
1457 1461 if inspect.isbuiltin(obj):
1458 1462 pass
1459 1463 elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
1460 1464 if inspect.isclass(obj):
1461 1465 #for cython embedsignature=True the constructor docstring
1462 1466 #belongs to the object itself not __init__
1463 1467 ret += self._default_arguments_from_docstring(
1464 1468 getattr(obj, '__doc__', ''))
1465 1469 # for classes, check for __init__,__new__
1466 1470 call_obj = (getattr(obj, '__init__', None) or
1467 1471 getattr(obj, '__new__', None))
1468 1472 # for all others, check if they are __call__able
1469 1473 elif hasattr(obj, '__call__'):
1470 1474 call_obj = obj.__call__
1471 1475 ret += self._default_arguments_from_docstring(
1472 1476 getattr(call_obj, '__doc__', ''))
1473 1477
1474 1478 _keeps = (inspect.Parameter.KEYWORD_ONLY,
1475 1479 inspect.Parameter.POSITIONAL_OR_KEYWORD)
1476 1480
1477 1481 try:
1478 1482 sig = inspect.signature(call_obj)
1479 1483 ret.extend(k for k, v in sig.parameters.items() if
1480 1484 v.kind in _keeps)
1481 1485 except ValueError:
1482 1486 pass
1483 1487
1484 1488 return list(set(ret))
1485 1489
1486 1490 def python_func_kw_matches(self,text):
1487 1491 """Match named parameters (kwargs) of the last open function"""
1488 1492
1489 1493 if "." in text: # a parameter cannot be dotted
1490 1494 return []
1491 1495 try: regexp = self.__funcParamsRegex
1492 1496 except AttributeError:
1493 1497 regexp = self.__funcParamsRegex = re.compile(r'''
1494 1498 '.*?(?<!\\)' | # single quoted strings or
1495 1499 ".*?(?<!\\)" | # double quoted strings or
1496 1500 \w+ | # identifier
1497 1501 \S # other characters
1498 1502 ''', re.VERBOSE | re.DOTALL)
1499 1503 # 1. find the nearest identifier that comes before an unclosed
1500 1504 # parenthesis before the cursor
1501 1505 # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
1502 1506 tokens = regexp.findall(self.text_until_cursor)
1503 1507 iterTokens = reversed(tokens); openPar = 0
1504 1508
1505 1509 for token in iterTokens:
1506 1510 if token == ')':
1507 1511 openPar -= 1
1508 1512 elif token == '(':
1509 1513 openPar += 1
1510 1514 if openPar > 0:
1511 1515 # found the last unclosed parenthesis
1512 1516 break
1513 1517 else:
1514 1518 return []
1515 1519 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
1516 1520 ids = []
1517 1521 isId = re.compile(r'\w+$').match
1518 1522
1519 1523 while True:
1520 1524 try:
1521 1525 ids.append(next(iterTokens))
1522 1526 if not isId(ids[-1]):
1523 1527 ids.pop(); break
1524 1528 if not next(iterTokens) == '.':
1525 1529 break
1526 1530 except StopIteration:
1527 1531 break
1528 1532
1529 1533 # Find all named arguments already assigned to, as to avoid suggesting
1530 1534 # them again
1531 1535 usedNamedArgs = set()
1532 1536 par_level = -1
1533 1537 for token, next_token in zip(tokens, tokens[1:]):
1534 1538 if token == '(':
1535 1539 par_level += 1
1536 1540 elif token == ')':
1537 1541 par_level -= 1
1538 1542
1539 1543 if par_level != 0:
1540 1544 continue
1541 1545
1542 1546 if next_token != '=':
1543 1547 continue
1544 1548
1545 1549 usedNamedArgs.add(token)
1546 1550
1547 1551 argMatches = []
1548 1552 try:
1549 1553 callableObj = '.'.join(ids[::-1])
1550 1554 namedArgs = self._default_arguments(eval(callableObj,
1551 1555 self.namespace))
1552 1556
1553 1557 # Remove used named arguments from the list, no need to show twice
1554 1558 for namedArg in set(namedArgs) - usedNamedArgs:
1555 1559 if namedArg.startswith(text):
1556 1560 argMatches.append(u"%s=" %namedArg)
1557 1561 except:
1558 1562 pass
1559 1563
1560 1564 return argMatches
1561 1565
1562 1566 def dict_key_matches(self, text):
1563 1567 "Match string keys in a dictionary, after e.g. 'foo[' "
1564 1568 def get_keys(obj):
1565 1569 # Objects can define their own completions by defining an
1566 1570 # _ipy_key_completions_() method.
1567 1571 method = get_real_method(obj, '_ipython_key_completions_')
1568 1572 if method is not None:
1569 1573 return method()
1570 1574
1571 1575 # Special case some common in-memory dict-like types
1572 1576 if isinstance(obj, dict) or\
1573 1577 _safe_isinstance(obj, 'pandas', 'DataFrame'):
1574 1578 try:
1575 1579 return list(obj.keys())
1576 1580 except Exception:
1577 1581 return []
1578 1582 elif _safe_isinstance(obj, 'numpy', 'ndarray') or\
1579 1583 _safe_isinstance(obj, 'numpy', 'void'):
1580 1584 return obj.dtype.names or []
1581 1585 return []
1582 1586
1583 1587 try:
1584 1588 regexps = self.__dict_key_regexps
1585 1589 except AttributeError:
1586 1590 dict_key_re_fmt = r'''(?x)
1587 1591 ( # match dict-referring expression wrt greedy setting
1588 1592 %s
1589 1593 )
1590 1594 \[ # open bracket
1591 1595 \s* # and optional whitespace
1592 1596 ([uUbB]? # string prefix (r not handled)
1593 1597 (?: # unclosed string
1594 1598 '(?:[^']|(?<!\\)\\')*
1595 1599 |
1596 1600 "(?:[^"]|(?<!\\)\\")*
1597 1601 )
1598 1602 )?
1599 1603 $
1600 1604 '''
1601 1605 regexps = self.__dict_key_regexps = {
1602 1606 False: re.compile(dict_key_re_fmt % r'''
1603 1607 # identifiers separated by .
1604 1608 (?!\d)\w+
1605 1609 (?:\.(?!\d)\w+)*
1606 1610 '''),
1607 1611 True: re.compile(dict_key_re_fmt % '''
1608 1612 .+
1609 1613 ''')
1610 1614 }
1611 1615
1612 1616 match = regexps[self.greedy].search(self.text_until_cursor)
1613 1617 if match is None:
1614 1618 return []
1615 1619
1616 1620 expr, prefix = match.groups()
1617 1621 try:
1618 1622 obj = eval(expr, self.namespace)
1619 1623 except Exception:
1620 1624 try:
1621 1625 obj = eval(expr, self.global_namespace)
1622 1626 except Exception:
1623 1627 return []
1624 1628
1625 1629 keys = get_keys(obj)
1626 1630 if not keys:
1627 1631 return keys
1628 1632 closing_quote, token_offset, matches = match_dict_keys(keys, prefix, self.splitter.delims)
1629 1633 if not matches:
1630 1634 return matches
1631 1635
1632 1636 # get the cursor position of
1633 1637 # - the text being completed
1634 1638 # - the start of the key text
1635 1639 # - the start of the completion
1636 1640 text_start = len(self.text_until_cursor) - len(text)
1637 1641 if prefix:
1638 1642 key_start = match.start(2)
1639 1643 completion_start = key_start + token_offset
1640 1644 else:
1641 1645 key_start = completion_start = match.end()
1642 1646
1643 1647 # grab the leading prefix, to make sure all completions start with `text`
1644 1648 if text_start > key_start:
1645 1649 leading = ''
1646 1650 else:
1647 1651 leading = text[text_start:completion_start]
1648 1652
1649 1653 # the index of the `[` character
1650 1654 bracket_idx = match.end(1)
1651 1655
1652 1656 # append closing quote and bracket as appropriate
1653 1657 # this is *not* appropriate if the opening quote or bracket is outside
1654 1658 # the text given to this method
1655 1659 suf = ''
1656 1660 continuation = self.line_buffer[len(self.text_until_cursor):]
1657 1661 if key_start > text_start and closing_quote:
1658 1662 # quotes were opened inside text, maybe close them
1659 1663 if continuation.startswith(closing_quote):
1660 1664 continuation = continuation[len(closing_quote):]
1661 1665 else:
1662 1666 suf += closing_quote
1663 1667 if bracket_idx > text_start:
1664 1668 # brackets were opened inside text, maybe close them
1665 1669 if not continuation.startswith(']'):
1666 1670 suf += ']'
1667 1671
1668 1672 return [leading + k + suf for k in matches]
1669 1673
1670 1674 def unicode_name_matches(self, text):
1671 1675 u"""Match Latex-like syntax for unicode characters base
1672 1676 on the name of the character.
1673 1677
1674 1678 This does ``\\GREEK SMALL LETTER ETA`` -> ``Ξ·``
1675 1679
1676 1680 Works only on valid python 3 identifier, or on combining characters that
1677 1681 will combine to form a valid identifier.
1678 1682
1679 1683 Used on Python 3 only.
1680 1684 """
1681 1685 slashpos = text.rfind('\\')
1682 1686 if slashpos > -1:
1683 1687 s = text[slashpos+1:]
1684 1688 try :
1685 1689 unic = unicodedata.lookup(s)
1686 1690 # allow combining chars
1687 1691 if ('a'+unic).isidentifier():
1688 1692 return '\\'+s,[unic]
1689 1693 except KeyError:
1690 1694 pass
1691 1695 return u'', []
1692 1696
1693 1697
1694 1698 def latex_matches(self, text):
1695 1699 u"""Match Latex syntax for unicode characters.
1696 1700
1697 1701 This does both ``\\alp`` -> ``\\alpha`` and ``\\alpha`` -> ``Ξ±``
1698 1702
1699 1703 Used on Python 3 only.
1700 1704 """
1701 1705 slashpos = text.rfind('\\')
1702 1706 if slashpos > -1:
1703 1707 s = text[slashpos:]
1704 1708 if s in latex_symbols:
1705 1709 # Try to complete a full latex symbol to unicode
1706 1710 # \\alpha -> Ξ±
1707 1711 return s, [latex_symbols[s]]
1708 1712 else:
1709 1713 # If a user has partially typed a latex symbol, give them
1710 1714 # a full list of options \al -> [\aleph, \alpha]
1711 1715 matches = [k for k in latex_symbols if k.startswith(s)]
1712 1716 return s, matches
1713 1717 return u'', []
1714 1718
1715 1719 def dispatch_custom_completer(self, text):
1716 1720 if not self.custom_completers:
1717 1721 return
1718 1722
1719 1723 line = self.line_buffer
1720 1724 if not line.strip():
1721 1725 return None
1722 1726
1723 1727 # Create a little structure to pass all the relevant information about
1724 1728 # the current completion to any custom completer.
1725 1729 event = SimpleNamespace()
1726 1730 event.line = line
1727 1731 event.symbol = text
1728 1732 cmd = line.split(None,1)[0]
1729 1733 event.command = cmd
1730 1734 event.text_until_cursor = self.text_until_cursor
1731 1735
1732 1736 # for foo etc, try also to find completer for %foo
1733 1737 if not cmd.startswith(self.magic_escape):
1734 1738 try_magic = self.custom_completers.s_matches(
1735 1739 self.magic_escape + cmd)
1736 1740 else:
1737 1741 try_magic = []
1738 1742
1739 1743 for c in itertools.chain(self.custom_completers.s_matches(cmd),
1740 1744 try_magic,
1741 1745 self.custom_completers.flat_matches(self.text_until_cursor)):
1742 1746 try:
1743 1747 res = c(event)
1744 1748 if res:
1745 1749 # first, try case sensitive match
1746 1750 withcase = [r for r in res if r.startswith(text)]
1747 1751 if withcase:
1748 1752 return withcase
1749 1753 # if none, then case insensitive ones are ok too
1750 1754 text_low = text.lower()
1751 1755 return [r for r in res if r.lower().startswith(text_low)]
1752 1756 except TryNext:
1753 1757 pass
1754 1758 except KeyboardInterrupt:
1755 1759 """
1756 1760 If custom completer take too long,
1757 1761 let keyboard interrupt abort and return nothing.
1758 1762 """
1759 1763 break
1760 1764
1761 1765 return None
1762 1766
1763 1767 def completions(self, text: str, offset: int)->Iterator[Completion]:
1764 1768 """
1765 1769 Returns an iterator over the possible completions
1766 1770
1767 1771 .. warning:: Unstable
1768 1772
1769 1773 This function is unstable, API may change without warning.
1770 1774 It will also raise unless use in proper context manager.
1771 1775
1772 1776 Parameters
1773 1777 ----------
1774 1778
1775 1779 text:str
1776 1780 Full text of the current input, multi line string.
1777 1781 offset:int
1778 1782 Integer representing the position of the cursor in ``text``. Offset
1779 1783 is 0-based indexed.
1780 1784
1781 1785 Yields
1782 1786 ------
1783 1787 :any:`Completion` object
1784 1788
1785 1789
1786 1790 The cursor on a text can either be seen as being "in between"
1787 1791 characters or "On" a character depending on the interface visible to
1788 1792 the user. For consistency the cursor being on "in between" characters X
1789 1793 and Y is equivalent to the cursor being "on" character Y, that is to say
1790 1794 the character the cursor is on is considered as being after the cursor.
1791 1795
1792 1796 Combining characters may span more that one position in the
1793 1797 text.
1794 1798
1795 1799
1796 1800 .. note::
1797 1801
1798 1802 If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
1799 1803 fake Completion token to distinguish completion returned by Jedi
1800 1804 and usual IPython completion.
1801 1805
1802 1806 .. note::
1803 1807
1804 1808 Completions are not completely deduplicated yet. If identical
1805 1809 completions are coming from different sources this function does not
1806 1810 ensure that each completion object will only be present once.
1807 1811 """
1808 1812 warnings.warn("_complete is a provisional API (as of IPython 6.0). "
1809 1813 "It may change without warnings. "
1810 1814 "Use in corresponding context manager.",
1811 1815 category=ProvisionalCompleterWarning, stacklevel=2)
1812 1816
1813 1817 seen = set()
1814 1818 try:
1815 1819 for c in self._completions(text, offset, _timeout=self.jedi_compute_type_timeout/1000):
1816 1820 if c and (c in seen):
1817 1821 continue
1818 1822 yield c
1819 1823 seen.add(c)
1820 1824 except KeyboardInterrupt:
1821 1825 """if completions take too long and users send keyboard interrupt,
1822 1826 do not crash and return ASAP. """
1823 1827 pass
1824 1828
1825 1829 def _completions(self, full_text: str, offset: int, *, _timeout)->Iterator[Completion]:
1826 1830 """
1827 1831 Core completion module.Same signature as :any:`completions`, with the
1828 1832 extra `timeout` parameter (in seconds).
1829 1833
1830 1834
1831 1835 Computing jedi's completion ``.type`` can be quite expensive (it is a
1832 1836 lazy property) and can require some warm-up, more warm up than just
1833 1837 computing the ``name`` of a completion. The warm-up can be :
1834 1838
1835 1839 - Long warm-up the first time a module is encountered after
1836 1840 install/update: actually build parse/inference tree.
1837 1841
1838 1842 - first time the module is encountered in a session: load tree from
1839 1843 disk.
1840 1844
1841 1845 We don't want to block completions for tens of seconds so we give the
1842 1846 completer a "budget" of ``_timeout`` seconds per invocation to compute
1843 1847 completions types, the completions that have not yet been computed will
1844 1848 be marked as "unknown" an will have a chance to be computed next round
1845 1849 are things get cached.
1846 1850
1847 1851 Keep in mind that Jedi is not the only thing treating the completion so
1848 1852 keep the timeout short-ish as if we take more than 0.3 second we still
1849 1853 have lots of processing to do.
1850 1854
1851 1855 """
1852 1856 deadline = time.monotonic() + _timeout
1853 1857
1854 1858
1855 1859 before = full_text[:offset]
1856 1860 cursor_line, cursor_column = position_to_cursor(full_text, offset)
1857 1861
1858 1862 matched_text, matches, matches_origin, jedi_matches = self._complete(
1859 1863 full_text=full_text, cursor_line=cursor_line, cursor_pos=cursor_column)
1860 1864
1861 1865 iter_jm = iter(jedi_matches)
1862 1866 if _timeout:
1863 1867 for jm in iter_jm:
1864 1868 try:
1865 1869 type_ = jm.type
1866 1870 except Exception:
1867 1871 if self.debug:
1868 1872 print("Error in Jedi getting type of ", jm)
1869 1873 type_ = None
1870 1874 delta = len(jm.name_with_symbols) - len(jm.complete)
1871 1875 if type_ == 'function':
1872 1876 signature = _make_signature(jm)
1873 1877 else:
1874 1878 signature = ''
1875 1879 yield Completion(start=offset - delta,
1876 1880 end=offset,
1877 1881 text=jm.name_with_symbols,
1878 1882 type=type_,
1879 1883 signature=signature,
1880 1884 _origin='jedi')
1881 1885
1882 1886 if time.monotonic() > deadline:
1883 1887 break
1884 1888
1885 1889 for jm in iter_jm:
1886 1890 delta = len(jm.name_with_symbols) - len(jm.complete)
1887 1891 yield Completion(start=offset - delta,
1888 1892 end=offset,
1889 1893 text=jm.name_with_symbols,
1890 1894 type='<unknown>', # don't compute type for speed
1891 1895 _origin='jedi',
1892 1896 signature='')
1893 1897
1894 1898
1895 1899 start_offset = before.rfind(matched_text)
1896 1900
1897 1901 # TODO:
1898 1902 # Suppress this, right now just for debug.
1899 1903 if jedi_matches and matches and self.debug:
1900 1904 yield Completion(start=start_offset, end=offset, text='--jedi/ipython--',
1901 1905 _origin='debug', type='none', signature='')
1902 1906
1903 1907 # I'm unsure if this is always true, so let's assert and see if it
1904 1908 # crash
1905 1909 assert before.endswith(matched_text)
1906 1910 for m, t in zip(matches, matches_origin):
1907 1911 yield Completion(start=start_offset, end=offset, text=m, _origin=t, signature='', type='<unknown>')
1908 1912
1909 1913
1910 1914 def complete(self, text=None, line_buffer=None, cursor_pos=None):
1911 1915 """Find completions for the given text and line context.
1912 1916
1913 1917 Note that both the text and the line_buffer are optional, but at least
1914 1918 one of them must be given.
1915 1919
1916 1920 Parameters
1917 1921 ----------
1918 1922 text : string, optional
1919 1923 Text to perform the completion on. If not given, the line buffer
1920 1924 is split using the instance's CompletionSplitter object.
1921 1925
1922 1926 line_buffer : string, optional
1923 1927 If not given, the completer attempts to obtain the current line
1924 1928 buffer via readline. This keyword allows clients which are
1925 1929 requesting for text completions in non-readline contexts to inform
1926 1930 the completer of the entire text.
1927 1931
1928 1932 cursor_pos : int, optional
1929 1933 Index of the cursor in the full line buffer. Should be provided by
1930 1934 remote frontends where kernel has no access to frontend state.
1931 1935
1932 1936 Returns
1933 1937 -------
1934 1938 text : str
1935 1939 Text that was actually used in the completion.
1936 1940
1937 1941 matches : list
1938 1942 A list of completion matches.
1939 1943
1940 1944
1941 1945 .. note::
1942 1946
1943 1947 This API is likely to be deprecated and replaced by
1944 1948 :any:`IPCompleter.completions` in the future.
1945 1949
1946 1950
1947 1951 """
1948 1952 warnings.warn('`Completer.complete` is pending deprecation since '
1949 1953 'IPython 6.0 and will be replaced by `Completer.completions`.',
1950 1954 PendingDeprecationWarning)
1951 1955 # potential todo, FOLD the 3rd throw away argument of _complete
1952 1956 # into the first 2 one.
1953 1957 return self._complete(line_buffer=line_buffer, cursor_pos=cursor_pos, text=text, cursor_line=0)[:2]
1954 1958
1955 1959 def _complete(self, *, cursor_line, cursor_pos, line_buffer=None, text=None,
1956 1960 full_text=None) -> Tuple[str, List[str], List[str], Iterable[_FakeJediCompletion]]:
1957 1961 """
1958 1962
1959 1963 Like complete but can also returns raw jedi completions as well as the
1960 1964 origin of the completion text. This could (and should) be made much
1961 1965 cleaner but that will be simpler once we drop the old (and stateful)
1962 1966 :any:`complete` API.
1963 1967
1964 1968
1965 1969 With current provisional API, cursor_pos act both (depending on the
1966 1970 caller) as the offset in the ``text`` or ``line_buffer``, or as the
1967 1971 ``column`` when passing multiline strings this could/should be renamed
1968 1972 but would add extra noise.
1969 1973 """
1970 1974
1971 1975 # if the cursor position isn't given, the only sane assumption we can
1972 1976 # make is that it's at the end of the line (the common case)
1973 1977 if cursor_pos is None:
1974 1978 cursor_pos = len(line_buffer) if text is None else len(text)
1975 1979
1976 1980 if self.use_main_ns:
1977 1981 self.namespace = __main__.__dict__
1978 1982
1979 1983 # if text is either None or an empty string, rely on the line buffer
1980 1984 if (not line_buffer) and full_text:
1981 1985 line_buffer = full_text.split('\n')[cursor_line]
1982 1986 if not text:
1983 1987 text = self.splitter.split_line(line_buffer, cursor_pos)
1984 1988
1985 1989 if self.backslash_combining_completions:
1986 1990 # allow deactivation of these on windows.
1987 1991 base_text = text if not line_buffer else line_buffer[:cursor_pos]
1988 1992 latex_text, latex_matches = self.latex_matches(base_text)
1989 1993 if latex_matches:
1990 1994 return latex_text, latex_matches, ['latex_matches']*len(latex_matches), ()
1991 1995 name_text = ''
1992 1996 name_matches = []
1993 1997 # need to add self.fwd_unicode_match() function here when done
1994 1998 for meth in (self.unicode_name_matches, back_latex_name_matches, back_unicode_name_matches, self.fwd_unicode_match):
1995 1999 name_text, name_matches = meth(base_text)
1996 2000 if name_text:
1997 2001 return name_text, name_matches[:MATCHES_LIMIT], \
1998 2002 [meth.__qualname__]*min(len(name_matches), MATCHES_LIMIT), ()
1999 2003
2000 2004
2001 2005 # If no line buffer is given, assume the input text is all there was
2002 2006 if line_buffer is None:
2003 2007 line_buffer = text
2004 2008
2005 2009 self.line_buffer = line_buffer
2006 2010 self.text_until_cursor = self.line_buffer[:cursor_pos]
2007 2011
2008 2012 # Do magic arg matches
2009 2013 for matcher in self.magic_arg_matchers:
2010 2014 matches = list(matcher(line_buffer))[:MATCHES_LIMIT]
2011 2015 if matches:
2012 2016 origins = [matcher.__qualname__] * len(matches)
2013 2017 return text, matches, origins, ()
2014 2018
2015 2019 # Start with a clean slate of completions
2016 2020 matches = []
2017 2021
2018 2022 # FIXME: we should extend our api to return a dict with completions for
2019 2023 # different types of objects. The rlcomplete() method could then
2020 2024 # simply collapse the dict into a list for readline, but we'd have
2021 2025 # richer completion semantics in other environments.
2022 2026 completions = ()
2023 2027 if self.use_jedi:
2024 2028 if not full_text:
2025 2029 full_text = line_buffer
2026 2030 completions = self._jedi_matches(
2027 2031 cursor_pos, cursor_line, full_text)
2028 2032
2029 2033 if self.merge_completions:
2030 2034 matches = []
2031 2035 for matcher in self.matchers:
2032 2036 try:
2033 2037 matches.extend([(m, matcher.__qualname__)
2034 2038 for m in matcher(text)])
2035 2039 except:
2036 2040 # Show the ugly traceback if the matcher causes an
2037 2041 # exception, but do NOT crash the kernel!
2038 2042 sys.excepthook(*sys.exc_info())
2039 2043 else:
2040 2044 for matcher in self.matchers:
2041 2045 matches = [(m, matcher.__qualname__)
2042 2046 for m in matcher(text)]
2043 2047 if matches:
2044 2048 break
2045 2049
2046 2050 seen = set()
2047 2051 filtered_matches = set()
2048 2052 for m in matches:
2049 2053 t, c = m
2050 2054 if t not in seen:
2051 2055 filtered_matches.add(m)
2052 2056 seen.add(t)
2053 2057
2054 2058 _filtered_matches = sorted(filtered_matches, key=lambda x: completions_sorting_key(x[0]))
2055 2059
2056 2060 custom_res = [(m, 'custom') for m in self.dispatch_custom_completer(text) or []]
2057 2061
2058 2062 _filtered_matches = custom_res or _filtered_matches
2059 2063
2060 2064 _filtered_matches = _filtered_matches[:MATCHES_LIMIT]
2061 2065 _matches = [m[0] for m in _filtered_matches]
2062 2066 origins = [m[1] for m in _filtered_matches]
2063 2067
2064 2068 self.matches = _matches
2065 2069
2066 2070 return text, _matches, origins, completions
2067 2071
2068 2072 def fwd_unicode_match(self, text:str) -> Tuple[str, list]:
2069 2073 if self._names is None:
2070 2074 self._names = []
2071 2075 for c in range(0,0x10FFFF + 1):
2072 2076 try:
2073 2077 self._names.append(unicodedata.name(chr(c)))
2074 2078 except ValueError:
2075 2079 pass
2076 2080
2077 2081 slashpos = text.rfind('\\')
2078 2082 # if text starts with slash
2079 2083 if slashpos > -1:
2080 2084 s = text[slashpos+1:]
2081 2085 candidates = [x for x in self._names if x.startswith(s)]
2082 2086 if candidates:
2083 2087 return s, candidates
2084 2088 else:
2085 2089 return '', ()
2086 2090
2087 2091 # if text does not start with slash
2088 2092 else:
2089 2093 return u'', ()
@@ -1,3713 +1,3713 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Main IPython class."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2011 The IPython Development Team
8 8 #
9 9 # Distributed under the terms of the BSD License. The full license is in
10 10 # the file COPYING, distributed as part of this software.
11 11 #-----------------------------------------------------------------------------
12 12
13 13
14 14 import abc
15 15 import ast
16 16 import atexit
17 17 import builtins as builtin_mod
18 18 import functools
19 19 import inspect
20 20 import os
21 21 import re
22 22 import runpy
23 23 import sys
24 24 import tempfile
25 25 import traceback
26 26 import types
27 27 import subprocess
28 28 import warnings
29 29 from io import open as io_open
30 30
31 31 from pickleshare import PickleShareDB
32 32
33 33 from traitlets.config.configurable import SingletonConfigurable
34 34 from traitlets.utils.importstring import import_item
35 35 from IPython.core import oinspect
36 36 from IPython.core import magic
37 37 from IPython.core import page
38 38 from IPython.core import prefilter
39 39 from IPython.core import ultratb
40 40 from IPython.core.alias import Alias, AliasManager
41 41 from IPython.core.autocall import ExitAutocall
42 42 from IPython.core.builtin_trap import BuiltinTrap
43 43 from IPython.core.events import EventManager, available_events
44 44 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
45 45 from IPython.core.debugger import Pdb
46 46 from IPython.core.display_trap import DisplayTrap
47 47 from IPython.core.displayhook import DisplayHook
48 48 from IPython.core.displaypub import DisplayPublisher
49 49 from IPython.core.error import InputRejected, UsageError
50 50 from IPython.core.extensions import ExtensionManager
51 51 from IPython.core.formatters import DisplayFormatter
52 52 from IPython.core.history import HistoryManager
53 53 from IPython.core.inputtransformer2 import ESC_MAGIC, ESC_MAGIC2
54 54 from IPython.core.logger import Logger
55 55 from IPython.core.macro import Macro
56 56 from IPython.core.payload import PayloadManager
57 57 from IPython.core.prefilter import PrefilterManager
58 58 from IPython.core.profiledir import ProfileDir
59 59 from IPython.core.usage import default_banner
60 60 from IPython.display import display
61 61 from IPython.testing.skipdoctest import skip_doctest
62 62 from IPython.utils import PyColorize
63 63 from IPython.utils import io
64 64 from IPython.utils import py3compat
65 65 from IPython.utils import openpy
66 66 from IPython.utils.decorators import undoc
67 67 from IPython.utils.io import ask_yes_no
68 68 from IPython.utils.ipstruct import Struct
69 69 from IPython.paths import get_ipython_dir
70 70 from IPython.utils.path import get_home_dir, get_py_filename, ensure_dir_exists
71 71 from IPython.utils.process import system, getoutput
72 72 from IPython.utils.strdispatch import StrDispatch
73 73 from IPython.utils.syspathcontext import prepended_to_syspath
74 74 from IPython.utils.text import format_screen, LSString, SList, DollarFormatter
75 75 from IPython.utils.tempdir import TemporaryDirectory
76 76 from traitlets import (
77 77 Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
78 78 observe, default, validate, Any
79 79 )
80 80 from warnings import warn
81 81 from logging import error
82 82 import IPython.core.hooks
83 83
84 84 from typing import List as ListType, Tuple
85 85 from ast import AST
86 86
87 87 # NoOpContext is deprecated, but ipykernel imports it from here.
88 88 # See https://github.com/ipython/ipykernel/issues/157
89 89 # (2016, let's try to remove than in IPython 8.0)
90 90 from IPython.utils.contexts import NoOpContext
91 91
92 92 try:
93 93 import docrepr.sphinxify as sphx
94 94
95 95 def sphinxify(doc):
96 96 with TemporaryDirectory() as dirname:
97 97 return {
98 98 'text/html': sphx.sphinxify(doc, dirname),
99 99 'text/plain': doc
100 100 }
101 101 except ImportError:
102 102 sphinxify = None
103 103
104 104
105 105 class ProvisionalWarning(DeprecationWarning):
106 106 """
107 107 Warning class for unstable features
108 108 """
109 109 pass
110 110
111 111 if sys.version_info > (3,8):
112 112 from ast import Module
113 113 else :
114 114 # mock the new API, ignore second argument
115 115 # see https://github.com/ipython/ipython/issues/11590
116 116 from ast import Module as OriginalModule
117 117 Module = lambda nodelist, type_ignores: OriginalModule(nodelist)
118 118
119 119 if sys.version_info > (3,6):
120 120 _assign_nodes = (ast.AugAssign, ast.AnnAssign, ast.Assign)
121 121 _single_targets_nodes = (ast.AugAssign, ast.AnnAssign)
122 122 else:
123 123 _assign_nodes = (ast.AugAssign, ast.Assign )
124 124 _single_targets_nodes = (ast.AugAssign, )
125 125
126 126 #-----------------------------------------------------------------------------
127 127 # Await Helpers
128 128 #-----------------------------------------------------------------------------
129 129
130 130 def removed_co_newlocals(function:types.FunctionType) -> types.FunctionType:
131 131 """Return a function that do not create a new local scope.
132 132
133 133 Given a function, create a clone of this function where the co_newlocal flag
134 134 has been removed, making this function code actually run in the sourounding
135 135 scope.
136 136
137 137 We need this in order to run asynchronous code in user level namespace.
138 138 """
139 139 from types import CodeType, FunctionType
140 140 CO_NEWLOCALS = 0x0002
141 141 code = function.__code__
142 142 new_co_flags = code.co_flags & ~CO_NEWLOCALS
143 143 if sys.version_info > (3, 8, 0, 'alpha', 3):
144 144 new_code = code.replace(co_flags=new_co_flags)
145 145 else:
146 146 new_code = CodeType(
147 147 code.co_argcount,
148 148 code.co_kwonlyargcount,
149 149 code.co_nlocals,
150 150 code.co_stacksize,
151 151 new_co_flags,
152 152 code.co_code,
153 153 code.co_consts,
154 154 code.co_names,
155 155 code.co_varnames,
156 156 code.co_filename,
157 157 code.co_name,
158 158 code.co_firstlineno,
159 159 code.co_lnotab,
160 160 code.co_freevars,
161 161 code.co_cellvars
162 162 )
163 163 return FunctionType(new_code, globals(), function.__name__, function.__defaults__)
164 164
165 165
166 166 # we still need to run things using the asyncio eventloop, but there is no
167 167 # async integration
168 168 from .async_helpers import (_asyncio_runner, _asyncify, _pseudo_sync_runner)
169 169 from .async_helpers import _curio_runner, _trio_runner, _should_be_async
170 170
171 171
172 172 def _ast_asyncify(cell:str, wrapper_name:str) -> ast.Module:
173 173 """
174 174 Parse a cell with top-level await and modify the AST to be able to run it later.
175 175
176 176 Parameter
177 177 ---------
178 178
179 179 cell: str
180 180 The code cell to asyncronify
181 181 wrapper_name: str
182 182 The name of the function to be used to wrap the passed `cell`. It is
183 183 advised to **not** use a python identifier in order to not pollute the
184 184 global namespace in which the function will be ran.
185 185
186 186 Return
187 187 ------
188 188
189 189 A module object AST containing **one** function named `wrapper_name`.
190 190
191 191 The given code is wrapped in a async-def function, parsed into an AST, and
192 192 the resulting function definition AST is modified to return the last
193 193 expression.
194 194
195 195 The last expression or await node is moved into a return statement at the
196 196 end of the function, and removed from its original location. If the last
197 197 node is not Expr or Await nothing is done.
198 198
199 199 The function `__code__` will need to be later modified (by
200 200 ``removed_co_newlocals``) in a subsequent step to not create new `locals()`
201 201 meaning that the local and global scope are the same, ie as if the body of
202 202 the function was at module level.
203 203
204 204 Lastly a call to `locals()` is made just before the last expression of the
205 205 function, or just after the last assignment or statement to make sure the
206 206 global dict is updated as python function work with a local fast cache which
207 207 is updated only on `local()` calls.
208 208 """
209 209
210 210 from ast import Expr, Await, Return
211 211 if sys.version_info >= (3,8):
212 212 return ast.parse(cell)
213 213 tree = ast.parse(_asyncify(cell))
214 214
215 215 function_def = tree.body[0]
216 216 function_def.name = wrapper_name
217 217 try_block = function_def.body[0]
218 218 lastexpr = try_block.body[-1]
219 219 if isinstance(lastexpr, (Expr, Await)):
220 220 try_block.body[-1] = Return(lastexpr.value)
221 221 ast.fix_missing_locations(tree)
222 222 return tree
223 223 #-----------------------------------------------------------------------------
224 224 # Globals
225 225 #-----------------------------------------------------------------------------
226 226
227 227 # compiled regexps for autoindent management
228 228 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
229 229
230 230 #-----------------------------------------------------------------------------
231 231 # Utilities
232 232 #-----------------------------------------------------------------------------
233 233
234 234 @undoc
235 235 def softspace(file, newvalue):
236 236 """Copied from code.py, to remove the dependency"""
237 237
238 238 oldvalue = 0
239 239 try:
240 240 oldvalue = file.softspace
241 241 except AttributeError:
242 242 pass
243 243 try:
244 244 file.softspace = newvalue
245 245 except (AttributeError, TypeError):
246 246 # "attribute-less object" or "read-only attributes"
247 247 pass
248 248 return oldvalue
249 249
250 250 @undoc
251 251 def no_op(*a, **kw):
252 252 pass
253 253
254 254
255 255 class SpaceInInput(Exception): pass
256 256
257 257
258 258 def get_default_colors():
259 259 "DEPRECATED"
260 260 warn('get_default_color is deprecated since IPython 5.0, and returns `Neutral` on all platforms.',
261 261 DeprecationWarning, stacklevel=2)
262 262 return 'Neutral'
263 263
264 264
265 265 class SeparateUnicode(Unicode):
266 266 r"""A Unicode subclass to validate separate_in, separate_out, etc.
267 267
268 268 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
269 269 """
270 270
271 271 def validate(self, obj, value):
272 272 if value == '0': value = ''
273 273 value = value.replace('\\n','\n')
274 274 return super(SeparateUnicode, self).validate(obj, value)
275 275
276 276
277 277 @undoc
278 278 class DummyMod(object):
279 279 """A dummy module used for IPython's interactive module when
280 280 a namespace must be assigned to the module's __dict__."""
281 281 __spec__ = None
282 282
283 283
284 284 class ExecutionInfo(object):
285 285 """The arguments used for a call to :meth:`InteractiveShell.run_cell`
286 286
287 287 Stores information about what is going to happen.
288 288 """
289 289 raw_cell = None
290 290 store_history = False
291 291 silent = False
292 292 shell_futures = True
293 293
294 294 def __init__(self, raw_cell, store_history, silent, shell_futures):
295 295 self.raw_cell = raw_cell
296 296 self.store_history = store_history
297 297 self.silent = silent
298 298 self.shell_futures = shell_futures
299 299
300 300 def __repr__(self):
301 301 name = self.__class__.__qualname__
302 302 raw_cell = ((self.raw_cell[:50] + '..')
303 303 if len(self.raw_cell) > 50 else self.raw_cell)
304 304 return '<%s object at %x, raw_cell="%s" store_history=%s silent=%s shell_futures=%s>' %\
305 305 (name, id(self), raw_cell, self.store_history, self.silent, self.shell_futures)
306 306
307 307
308 308 class ExecutionResult(object):
309 309 """The result of a call to :meth:`InteractiveShell.run_cell`
310 310
311 311 Stores information about what took place.
312 312 """
313 313 execution_count = None
314 314 error_before_exec = None
315 315 error_in_exec = None
316 316 info = None
317 317 result = None
318 318
319 319 def __init__(self, info):
320 320 self.info = info
321 321
322 322 @property
323 323 def success(self):
324 324 return (self.error_before_exec is None) and (self.error_in_exec is None)
325 325
326 326 def raise_error(self):
327 327 """Reraises error if `success` is `False`, otherwise does nothing"""
328 328 if self.error_before_exec is not None:
329 329 raise self.error_before_exec
330 330 if self.error_in_exec is not None:
331 331 raise self.error_in_exec
332 332
333 333 def __repr__(self):
334 334 name = self.__class__.__qualname__
335 335 return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s info=%s result=%s>' %\
336 336 (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.info), repr(self.result))
337 337
338 338
339 339 class InteractiveShell(SingletonConfigurable):
340 340 """An enhanced, interactive shell for Python."""
341 341
342 342 _instance = None
343 343
344 344 ast_transformers = List([], help=
345 345 """
346 346 A list of ast.NodeTransformer subclass instances, which will be applied
347 347 to user input before code is run.
348 348 """
349 349 ).tag(config=True)
350 350
351 351 autocall = Enum((0,1,2), default_value=0, help=
352 352 """
353 353 Make IPython automatically call any callable object even if you didn't
354 354 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
355 355 automatically. The value can be '0' to disable the feature, '1' for
356 356 'smart' autocall, where it is not applied if there are no more
357 357 arguments on the line, and '2' for 'full' autocall, where all callable
358 358 objects are automatically called (even if no arguments are present).
359 359 """
360 360 ).tag(config=True)
361 361
362 362 autoindent = Bool(True, help=
363 363 """
364 364 Autoindent IPython code entered interactively.
365 365 """
366 366 ).tag(config=True)
367 367
368 368 autoawait = Bool(True, help=
369 369 """
370 370 Automatically run await statement in the top level repl.
371 371 """
372 372 ).tag(config=True)
373 373
374 374 loop_runner_map ={
375 375 'asyncio':(_asyncio_runner, True),
376 376 'curio':(_curio_runner, True),
377 377 'trio':(_trio_runner, True),
378 378 'sync': (_pseudo_sync_runner, False)
379 379 }
380 380
381 381 loop_runner = Any(default_value="IPython.core.interactiveshell._asyncio_runner",
382 382 allow_none=True,
383 383 help="""Select the loop runner that will be used to execute top-level asynchronous code"""
384 384 ).tag(config=True)
385 385
386 386 @default('loop_runner')
387 387 def _default_loop_runner(self):
388 388 return import_item("IPython.core.interactiveshell._asyncio_runner")
389 389
390 390 @validate('loop_runner')
391 391 def _import_runner(self, proposal):
392 392 if isinstance(proposal.value, str):
393 393 if proposal.value in self.loop_runner_map:
394 394 runner, autoawait = self.loop_runner_map[proposal.value]
395 395 self.autoawait = autoawait
396 396 return runner
397 397 runner = import_item(proposal.value)
398 398 if not callable(runner):
399 399 raise ValueError('loop_runner must be callable')
400 400 return runner
401 401 if not callable(proposal.value):
402 402 raise ValueError('loop_runner must be callable')
403 403 return proposal.value
404 404
405 405 automagic = Bool(True, help=
406 406 """
407 407 Enable magic commands to be called without the leading %.
408 408 """
409 409 ).tag(config=True)
410 410
411 411 banner1 = Unicode(default_banner,
412 412 help="""The part of the banner to be printed before the profile"""
413 413 ).tag(config=True)
414 414 banner2 = Unicode('',
415 415 help="""The part of the banner to be printed after the profile"""
416 416 ).tag(config=True)
417 417
418 418 cache_size = Integer(1000, help=
419 419 """
420 420 Set the size of the output cache. The default is 1000, you can
421 421 change it permanently in your config file. Setting it to 0 completely
422 422 disables the caching system, and the minimum value accepted is 3 (if
423 423 you provide a value less than 3, it is reset to 0 and a warning is
424 424 issued). This limit is defined because otherwise you'll spend more
425 425 time re-flushing a too small cache than working
426 426 """
427 427 ).tag(config=True)
428 428 color_info = Bool(True, help=
429 429 """
430 430 Use colors for displaying information about objects. Because this
431 431 information is passed through a pager (like 'less'), and some pagers
432 432 get confused with color codes, this capability can be turned off.
433 433 """
434 434 ).tag(config=True)
435 435 colors = CaselessStrEnum(('Neutral', 'NoColor','LightBG','Linux'),
436 436 default_value='Neutral',
437 437 help="Set the color scheme (NoColor, Neutral, Linux, or LightBG)."
438 438 ).tag(config=True)
439 439 debug = Bool(False).tag(config=True)
440 440 disable_failing_post_execute = Bool(False,
441 441 help="Don't call post-execute functions that have failed in the past."
442 442 ).tag(config=True)
443 443 display_formatter = Instance(DisplayFormatter, allow_none=True)
444 444 displayhook_class = Type(DisplayHook)
445 445 display_pub_class = Type(DisplayPublisher)
446 446
447 447 sphinxify_docstring = Bool(False, help=
448 448 """
449 449 Enables rich html representation of docstrings. (This requires the
450 450 docrepr module).
451 451 """).tag(config=True)
452 452
453 453 @observe("sphinxify_docstring")
454 454 def _sphinxify_docstring_changed(self, change):
455 455 if change['new']:
456 456 warn("`sphinxify_docstring` is provisional since IPython 5.0 and might change in future versions." , ProvisionalWarning)
457 457
458 458 enable_html_pager = Bool(False, help=
459 459 """
460 460 (Provisional API) enables html representation in mime bundles sent
461 461 to pagers.
462 462 """).tag(config=True)
463 463
464 464 @observe("enable_html_pager")
465 465 def _enable_html_pager_changed(self, change):
466 466 if change['new']:
467 467 warn("`enable_html_pager` is provisional since IPython 5.0 and might change in future versions.", ProvisionalWarning)
468 468
469 469 data_pub_class = None
470 470
471 471 exit_now = Bool(False)
472 472 exiter = Instance(ExitAutocall)
473 473 @default('exiter')
474 474 def _exiter_default(self):
475 475 return ExitAutocall(self)
476 476 # Monotonically increasing execution counter
477 477 execution_count = Integer(1)
478 478 filename = Unicode("<ipython console>")
479 479 ipython_dir= Unicode('').tag(config=True) # Set to get_ipython_dir() in __init__
480 480
481 481 # Used to transform cells before running them, and check whether code is complete
482 482 input_transformer_manager = Instance('IPython.core.inputtransformer2.TransformerManager',
483 483 ())
484 484
485 485 @property
486 486 def input_transformers_cleanup(self):
487 487 return self.input_transformer_manager.cleanup_transforms
488 488
489 489 input_transformers_post = List([],
490 490 help="A list of string input transformers, to be applied after IPython's "
491 491 "own input transformations."
492 492 )
493 493
494 494 @property
495 495 def input_splitter(self):
496 496 """Make this available for backward compatibility (pre-7.0 release) with existing code.
497 497
498 498 For example, ipykernel ipykernel currently uses
499 499 `shell.input_splitter.check_complete`
500 500 """
501 501 from warnings import warn
502 502 warn("`input_splitter` is deprecated since IPython 7.0, prefer `input_transformer_manager`.",
503 503 DeprecationWarning, stacklevel=2
504 504 )
505 505 return self.input_transformer_manager
506 506
507 507 logstart = Bool(False, help=
508 508 """
509 509 Start logging to the default log file in overwrite mode.
510 510 Use `logappend` to specify a log file to **append** logs to.
511 511 """
512 512 ).tag(config=True)
513 513 logfile = Unicode('', help=
514 514 """
515 515 The name of the logfile to use.
516 516 """
517 517 ).tag(config=True)
518 518 logappend = Unicode('', help=
519 519 """
520 520 Start logging to the given file in append mode.
521 521 Use `logfile` to specify a log file to **overwrite** logs to.
522 522 """
523 523 ).tag(config=True)
524 524 object_info_string_level = Enum((0,1,2), default_value=0,
525 525 ).tag(config=True)
526 526 pdb = Bool(False, help=
527 527 """
528 528 Automatically call the pdb debugger after every exception.
529 529 """
530 530 ).tag(config=True)
531 531 display_page = Bool(False,
532 532 help="""If True, anything that would be passed to the pager
533 533 will be displayed as regular output instead."""
534 534 ).tag(config=True)
535 535
536 536 # deprecated prompt traits:
537 537
538 538 prompt_in1 = Unicode('In [\\#]: ',
539 539 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
540 540 ).tag(config=True)
541 541 prompt_in2 = Unicode(' .\\D.: ',
542 542 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
543 543 ).tag(config=True)
544 544 prompt_out = Unicode('Out[\\#]: ',
545 545 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
546 546 ).tag(config=True)
547 547 prompts_pad_left = Bool(True,
548 548 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
549 549 ).tag(config=True)
550 550
551 551 @observe('prompt_in1', 'prompt_in2', 'prompt_out', 'prompt_pad_left')
552 552 def _prompt_trait_changed(self, change):
553 553 name = change['name']
554 554 warn("InteractiveShell.{name} is deprecated since IPython 4.0"
555 555 " and ignored since 5.0, set TerminalInteractiveShell.prompts"
556 556 " object directly.".format(name=name))
557 557
558 558 # protect against weird cases where self.config may not exist:
559 559
560 560 show_rewritten_input = Bool(True,
561 561 help="Show rewritten input, e.g. for autocall."
562 562 ).tag(config=True)
563 563
564 564 quiet = Bool(False).tag(config=True)
565 565
566 566 history_length = Integer(10000,
567 567 help='Total length of command history'
568 568 ).tag(config=True)
569 569
570 570 history_load_length = Integer(1000, help=
571 571 """
572 572 The number of saved history entries to be loaded
573 573 into the history buffer at startup.
574 574 """
575 575 ).tag(config=True)
576 576
577 577 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none', 'last_expr_or_assign'],
578 578 default_value='last_expr',
579 579 help="""
580 580 'all', 'last', 'last_expr' or 'none', 'last_expr_or_assign' specifying
581 581 which nodes should be run interactively (displaying output from expressions).
582 582 """
583 583 ).tag(config=True)
584 584
585 585 # TODO: this part of prompt management should be moved to the frontends.
586 586 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
587 587 separate_in = SeparateUnicode('\n').tag(config=True)
588 588 separate_out = SeparateUnicode('').tag(config=True)
589 589 separate_out2 = SeparateUnicode('').tag(config=True)
590 590 wildcards_case_sensitive = Bool(True).tag(config=True)
591 591 xmode = CaselessStrEnum(('Context', 'Plain', 'Verbose', 'Minimal'),
592 592 default_value='Context',
593 593 help="Switch modes for the IPython exception handlers."
594 594 ).tag(config=True)
595 595
596 596 # Subcomponents of InteractiveShell
597 597 alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)
598 598 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
599 599 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)
600 600 display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)
601 601 extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)
602 602 payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)
603 603 history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)
604 604 magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)
605 605
606 606 profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)
607 607 @property
608 608 def profile(self):
609 609 if self.profile_dir is not None:
610 610 name = os.path.basename(self.profile_dir.location)
611 611 return name.replace('profile_','')
612 612
613 613
614 614 # Private interface
615 615 _post_execute = Dict()
616 616
617 617 # Tracks any GUI loop loaded for pylab
618 618 pylab_gui_select = None
619 619
620 620 last_execution_succeeded = Bool(True, help='Did last executed command succeeded')
621 621
622 622 last_execution_result = Instance('IPython.core.interactiveshell.ExecutionResult', help='Result of executing the last command', allow_none=True)
623 623
624 624 def __init__(self, ipython_dir=None, profile_dir=None,
625 625 user_module=None, user_ns=None,
626 626 custom_exceptions=((), None), **kwargs):
627 627
628 628 # This is where traits with a config_key argument are updated
629 629 # from the values on config.
630 630 super(InteractiveShell, self).__init__(**kwargs)
631 631 if 'PromptManager' in self.config:
632 632 warn('As of IPython 5.0 `PromptManager` config will have no effect'
633 633 ' and has been replaced by TerminalInteractiveShell.prompts_class')
634 634 self.configurables = [self]
635 635
636 636 # These are relatively independent and stateless
637 637 self.init_ipython_dir(ipython_dir)
638 638 self.init_profile_dir(profile_dir)
639 639 self.init_instance_attrs()
640 640 self.init_environment()
641 641
642 642 # Check if we're in a virtualenv, and set up sys.path.
643 643 self.init_virtualenv()
644 644
645 645 # Create namespaces (user_ns, user_global_ns, etc.)
646 646 self.init_create_namespaces(user_module, user_ns)
647 647 # This has to be done after init_create_namespaces because it uses
648 648 # something in self.user_ns, but before init_sys_modules, which
649 649 # is the first thing to modify sys.
650 650 # TODO: When we override sys.stdout and sys.stderr before this class
651 651 # is created, we are saving the overridden ones here. Not sure if this
652 652 # is what we want to do.
653 653 self.save_sys_module_state()
654 654 self.init_sys_modules()
655 655
656 656 # While we're trying to have each part of the code directly access what
657 657 # it needs without keeping redundant references to objects, we have too
658 658 # much legacy code that expects ip.db to exist.
659 659 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
660 660
661 661 self.init_history()
662 662 self.init_encoding()
663 663 self.init_prefilter()
664 664
665 665 self.init_syntax_highlighting()
666 666 self.init_hooks()
667 667 self.init_events()
668 668 self.init_pushd_popd_magic()
669 669 self.init_user_ns()
670 670 self.init_logger()
671 671 self.init_builtins()
672 672
673 673 # The following was in post_config_initialization
674 674 self.init_inspector()
675 675 self.raw_input_original = input
676 676 self.init_completer()
677 677 # TODO: init_io() needs to happen before init_traceback handlers
678 678 # because the traceback handlers hardcode the stdout/stderr streams.
679 679 # This logic in in debugger.Pdb and should eventually be changed.
680 680 self.init_io()
681 681 self.init_traceback_handlers(custom_exceptions)
682 682 self.init_prompts()
683 683 self.init_display_formatter()
684 684 self.init_display_pub()
685 685 self.init_data_pub()
686 686 self.init_displayhook()
687 687 self.init_magics()
688 688 self.init_alias()
689 689 self.init_logstart()
690 690 self.init_pdb()
691 691 self.init_extension_manager()
692 692 self.init_payload()
693 693 self.init_deprecation_warnings()
694 694 self.hooks.late_startup_hook()
695 695 self.events.trigger('shell_initialized', self)
696 696 atexit.register(self.atexit_operations)
697 697
698 698 # The trio runner is used for running Trio in the foreground thread. It
699 699 # is different from `_trio_runner(async_fn)` in `async_helpers.py`
700 700 # which calls `trio.run()` for every cell. This runner runs all cells
701 701 # inside a single Trio event loop. If used, it is set from
702 702 # `ipykernel.kernelapp`.
703 703 self.trio_runner = None
704 704
705 705 def get_ipython(self):
706 706 """Return the currently running IPython instance."""
707 707 return self
708 708
709 709 #-------------------------------------------------------------------------
710 710 # Trait changed handlers
711 711 #-------------------------------------------------------------------------
712 712 @observe('ipython_dir')
713 713 def _ipython_dir_changed(self, change):
714 714 ensure_dir_exists(change['new'])
715 715
716 716 def set_autoindent(self,value=None):
717 717 """Set the autoindent flag.
718 718
719 719 If called with no arguments, it acts as a toggle."""
720 720 if value is None:
721 721 self.autoindent = not self.autoindent
722 722 else:
723 723 self.autoindent = value
724 724
725 725 def set_trio_runner(self, tr):
726 726 self.trio_runner = tr
727 727
728 728 #-------------------------------------------------------------------------
729 729 # init_* methods called by __init__
730 730 #-------------------------------------------------------------------------
731 731
732 732 def init_ipython_dir(self, ipython_dir):
733 733 if ipython_dir is not None:
734 734 self.ipython_dir = ipython_dir
735 735 return
736 736
737 737 self.ipython_dir = get_ipython_dir()
738 738
739 739 def init_profile_dir(self, profile_dir):
740 740 if profile_dir is not None:
741 741 self.profile_dir = profile_dir
742 742 return
743 743 self.profile_dir =\
744 744 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
745 745
746 746 def init_instance_attrs(self):
747 747 self.more = False
748 748
749 749 # command compiler
750 750 self.compile = CachingCompiler()
751 751
752 752 # Make an empty namespace, which extension writers can rely on both
753 753 # existing and NEVER being used by ipython itself. This gives them a
754 754 # convenient location for storing additional information and state
755 755 # their extensions may require, without fear of collisions with other
756 756 # ipython names that may develop later.
757 757 self.meta = Struct()
758 758
759 759 # Temporary files used for various purposes. Deleted at exit.
760 760 self.tempfiles = []
761 761 self.tempdirs = []
762 762
763 763 # keep track of where we started running (mainly for crash post-mortem)
764 764 # This is not being used anywhere currently.
765 765 self.starting_dir = os.getcwd()
766 766
767 767 # Indentation management
768 768 self.indent_current_nsp = 0
769 769
770 770 # Dict to track post-execution functions that have been registered
771 771 self._post_execute = {}
772 772
773 773 def init_environment(self):
774 774 """Any changes we need to make to the user's environment."""
775 775 pass
776 776
777 777 def init_encoding(self):
778 778 # Get system encoding at startup time. Certain terminals (like Emacs
779 779 # under Win32 have it set to None, and we need to have a known valid
780 780 # encoding to use in the raw_input() method
781 781 try:
782 782 self.stdin_encoding = sys.stdin.encoding or 'ascii'
783 783 except AttributeError:
784 784 self.stdin_encoding = 'ascii'
785 785
786 786
787 787 @observe('colors')
788 788 def init_syntax_highlighting(self, changes=None):
789 789 # Python source parser/formatter for syntax highlighting
790 790 pyformat = PyColorize.Parser(style=self.colors, parent=self).format
791 791 self.pycolorize = lambda src: pyformat(src,'str')
792 792
793 793 def refresh_style(self):
794 794 # No-op here, used in subclass
795 795 pass
796 796
797 797 def init_pushd_popd_magic(self):
798 798 # for pushd/popd management
799 799 self.home_dir = get_home_dir()
800 800
801 801 self.dir_stack = []
802 802
803 803 def init_logger(self):
804 804 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
805 805 logmode='rotate')
806 806
807 807 def init_logstart(self):
808 808 """Initialize logging in case it was requested at the command line.
809 809 """
810 810 if self.logappend:
811 811 self.magic('logstart %s append' % self.logappend)
812 812 elif self.logfile:
813 813 self.magic('logstart %s' % self.logfile)
814 814 elif self.logstart:
815 815 self.magic('logstart')
816 816
817 817 def init_deprecation_warnings(self):
818 818 """
819 819 register default filter for deprecation warning.
820 820
821 821 This will allow deprecation warning of function used interactively to show
822 822 warning to users, and still hide deprecation warning from libraries import.
823 823 """
824 824 if sys.version_info < (3,7):
825 825 warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))
826 826
827 827
828 828 def init_builtins(self):
829 829 # A single, static flag that we set to True. Its presence indicates
830 830 # that an IPython shell has been created, and we make no attempts at
831 831 # removing on exit or representing the existence of more than one
832 832 # IPython at a time.
833 833 builtin_mod.__dict__['__IPYTHON__'] = True
834 834 builtin_mod.__dict__['display'] = display
835 835
836 836 self.builtin_trap = BuiltinTrap(shell=self)
837 837
838 838 @observe('colors')
839 839 def init_inspector(self, changes=None):
840 840 # Object inspector
841 841 self.inspector = oinspect.Inspector(oinspect.InspectColors,
842 842 PyColorize.ANSICodeColors,
843 843 self.colors,
844 844 self.object_info_string_level)
845 845
846 846 def init_io(self):
847 847 # This will just use sys.stdout and sys.stderr. If you want to
848 848 # override sys.stdout and sys.stderr themselves, you need to do that
849 849 # *before* instantiating this class, because io holds onto
850 850 # references to the underlying streams.
851 851 # io.std* are deprecated, but don't show our own deprecation warnings
852 852 # during initialization of the deprecated API.
853 853 with warnings.catch_warnings():
854 854 warnings.simplefilter('ignore', DeprecationWarning)
855 855 io.stdout = io.IOStream(sys.stdout)
856 856 io.stderr = io.IOStream(sys.stderr)
857 857
858 858 def init_prompts(self):
859 859 # Set system prompts, so that scripts can decide if they are running
860 860 # interactively.
861 861 sys.ps1 = 'In : '
862 862 sys.ps2 = '...: '
863 863 sys.ps3 = 'Out: '
864 864
865 865 def init_display_formatter(self):
866 866 self.display_formatter = DisplayFormatter(parent=self)
867 867 self.configurables.append(self.display_formatter)
868 868
869 869 def init_display_pub(self):
870 870 self.display_pub = self.display_pub_class(parent=self, shell=self)
871 871 self.configurables.append(self.display_pub)
872 872
873 873 def init_data_pub(self):
874 874 if not self.data_pub_class:
875 875 self.data_pub = None
876 876 return
877 877 self.data_pub = self.data_pub_class(parent=self)
878 878 self.configurables.append(self.data_pub)
879 879
880 880 def init_displayhook(self):
881 881 # Initialize displayhook, set in/out prompts and printing system
882 882 self.displayhook = self.displayhook_class(
883 883 parent=self,
884 884 shell=self,
885 885 cache_size=self.cache_size,
886 886 )
887 887 self.configurables.append(self.displayhook)
888 888 # This is a context manager that installs/revmoes the displayhook at
889 889 # the appropriate time.
890 890 self.display_trap = DisplayTrap(hook=self.displayhook)
891 891
892 892 def init_virtualenv(self):
893 893 """Add a virtualenv to sys.path so the user can import modules from it.
894 894 This isn't perfect: it doesn't use the Python interpreter with which the
895 895 virtualenv was built, and it ignores the --no-site-packages option. A
896 896 warning will appear suggesting the user installs IPython in the
897 897 virtualenv, but for many cases, it probably works well enough.
898 898
899 899 Adapted from code snippets online.
900 900
901 901 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
902 902 """
903 903 if 'VIRTUAL_ENV' not in os.environ:
904 904 # Not in a virtualenv
905 905 return
906 906
907 907 p = os.path.normcase(sys.executable)
908 908 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
909 909
910 910 # executable path should end like /bin/python or \\scripts\\python.exe
911 911 p_exe_up2 = os.path.dirname(os.path.dirname(p))
912 912 if p_exe_up2 and os.path.exists(p_venv) and os.path.samefile(p_exe_up2, p_venv):
913 913 # Our exe is inside the virtualenv, don't need to do anything.
914 914 return
915 915
916 916 # fallback venv detection:
917 917 # stdlib venv may symlink sys.executable, so we can't use realpath.
918 918 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
919 919 # So we just check every item in the symlink tree (generally <= 3)
920 920 paths = [p]
921 921 while os.path.islink(p):
922 922 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
923 923 paths.append(p)
924 924
925 925 # In Cygwin paths like "c:\..." and '\cygdrive\c\...' are possible
926 926 if p_venv.startswith('\\cygdrive'):
927 927 p_venv = p_venv[11:]
928 928 elif len(p_venv) >= 2 and p_venv[1] == ':':
929 929 p_venv = p_venv[2:]
930 930
931 931 if any(p_venv in p for p in paths):
932 932 # Running properly in the virtualenv, don't need to do anything
933 933 return
934 934
935 935 warn("Attempting to work in a virtualenv. If you encounter problems, please "
936 936 "install IPython inside the virtualenv.")
937 937 if sys.platform == "win32":
938 938 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
939 939 else:
940 940 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
941 941 'python%d.%d' % sys.version_info[:2], 'site-packages')
942 942
943 943 import site
944 944 sys.path.insert(0, virtual_env)
945 945 site.addsitedir(virtual_env)
946 946
947 947 #-------------------------------------------------------------------------
948 948 # Things related to injections into the sys module
949 949 #-------------------------------------------------------------------------
950 950
951 951 def save_sys_module_state(self):
952 952 """Save the state of hooks in the sys module.
953 953
954 954 This has to be called after self.user_module is created.
955 955 """
956 956 self._orig_sys_module_state = {'stdin': sys.stdin,
957 957 'stdout': sys.stdout,
958 958 'stderr': sys.stderr,
959 959 'excepthook': sys.excepthook}
960 960 self._orig_sys_modules_main_name = self.user_module.__name__
961 961 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
962 962
963 963 def restore_sys_module_state(self):
964 964 """Restore the state of the sys module."""
965 965 try:
966 966 for k, v in self._orig_sys_module_state.items():
967 967 setattr(sys, k, v)
968 968 except AttributeError:
969 969 pass
970 970 # Reset what what done in self.init_sys_modules
971 971 if self._orig_sys_modules_main_mod is not None:
972 972 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
973 973
974 974 #-------------------------------------------------------------------------
975 975 # Things related to the banner
976 976 #-------------------------------------------------------------------------
977 977
978 978 @property
979 979 def banner(self):
980 980 banner = self.banner1
981 981 if self.profile and self.profile != 'default':
982 982 banner += '\nIPython profile: %s\n' % self.profile
983 983 if self.banner2:
984 984 banner += '\n' + self.banner2
985 985 return banner
986 986
987 987 def show_banner(self, banner=None):
988 988 if banner is None:
989 989 banner = self.banner
990 990 sys.stdout.write(banner)
991 991
992 992 #-------------------------------------------------------------------------
993 993 # Things related to hooks
994 994 #-------------------------------------------------------------------------
995 995
996 996 def init_hooks(self):
997 997 # hooks holds pointers used for user-side customizations
998 998 self.hooks = Struct()
999 999
1000 1000 self.strdispatchers = {}
1001 1001
1002 1002 # Set all default hooks, defined in the IPython.hooks module.
1003 1003 hooks = IPython.core.hooks
1004 1004 for hook_name in hooks.__all__:
1005 1005 # default hooks have priority 100, i.e. low; user hooks should have
1006 1006 # 0-100 priority
1007 1007 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
1008 1008
1009 1009 if self.display_page:
1010 1010 self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)
1011 1011
1012 1012 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
1013 1013 _warn_deprecated=True):
1014 1014 """set_hook(name,hook) -> sets an internal IPython hook.
1015 1015
1016 1016 IPython exposes some of its internal API as user-modifiable hooks. By
1017 1017 adding your function to one of these hooks, you can modify IPython's
1018 1018 behavior to call at runtime your own routines."""
1019 1019
1020 1020 # At some point in the future, this should validate the hook before it
1021 1021 # accepts it. Probably at least check that the hook takes the number
1022 1022 # of args it's supposed to.
1023 1023
1024 1024 f = types.MethodType(hook,self)
1025 1025
1026 1026 # check if the hook is for strdispatcher first
1027 1027 if str_key is not None:
1028 1028 sdp = self.strdispatchers.get(name, StrDispatch())
1029 1029 sdp.add_s(str_key, f, priority )
1030 1030 self.strdispatchers[name] = sdp
1031 1031 return
1032 1032 if re_key is not None:
1033 1033 sdp = self.strdispatchers.get(name, StrDispatch())
1034 1034 sdp.add_re(re.compile(re_key), f, priority )
1035 1035 self.strdispatchers[name] = sdp
1036 1036 return
1037 1037
1038 1038 dp = getattr(self.hooks, name, None)
1039 1039 if name not in IPython.core.hooks.__all__:
1040 1040 print("Warning! Hook '%s' is not one of %s" % \
1041 1041 (name, IPython.core.hooks.__all__ ))
1042 1042
1043 1043 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
1044 1044 alternative = IPython.core.hooks.deprecated[name]
1045 1045 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative), stacklevel=2)
1046 1046
1047 1047 if not dp:
1048 1048 dp = IPython.core.hooks.CommandChainDispatcher()
1049 1049
1050 1050 try:
1051 1051 dp.add(f,priority)
1052 1052 except AttributeError:
1053 1053 # it was not commandchain, plain old func - replace
1054 1054 dp = f
1055 1055
1056 1056 setattr(self.hooks,name, dp)
1057 1057
1058 1058 #-------------------------------------------------------------------------
1059 1059 # Things related to events
1060 1060 #-------------------------------------------------------------------------
1061 1061
1062 1062 def init_events(self):
1063 1063 self.events = EventManager(self, available_events)
1064 1064
1065 1065 self.events.register("pre_execute", self._clear_warning_registry)
1066 1066
1067 1067 def register_post_execute(self, func):
1068 1068 """DEPRECATED: Use ip.events.register('post_run_cell', func)
1069 1069
1070 1070 Register a function for calling after code execution.
1071 1071 """
1072 1072 warn("ip.register_post_execute is deprecated, use "
1073 1073 "ip.events.register('post_run_cell', func) instead.", stacklevel=2)
1074 1074 self.events.register('post_run_cell', func)
1075 1075
1076 1076 def _clear_warning_registry(self):
1077 1077 # clear the warning registry, so that different code blocks with
1078 1078 # overlapping line number ranges don't cause spurious suppression of
1079 1079 # warnings (see gh-6611 for details)
1080 1080 if "__warningregistry__" in self.user_global_ns:
1081 1081 del self.user_global_ns["__warningregistry__"]
1082 1082
1083 1083 #-------------------------------------------------------------------------
1084 1084 # Things related to the "main" module
1085 1085 #-------------------------------------------------------------------------
1086 1086
1087 1087 def new_main_mod(self, filename, modname):
1088 1088 """Return a new 'main' module object for user code execution.
1089 1089
1090 1090 ``filename`` should be the path of the script which will be run in the
1091 1091 module. Requests with the same filename will get the same module, with
1092 1092 its namespace cleared.
1093 1093
1094 1094 ``modname`` should be the module name - normally either '__main__' or
1095 1095 the basename of the file without the extension.
1096 1096
1097 1097 When scripts are executed via %run, we must keep a reference to their
1098 1098 __main__ module around so that Python doesn't
1099 1099 clear it, rendering references to module globals useless.
1100 1100
1101 1101 This method keeps said reference in a private dict, keyed by the
1102 1102 absolute path of the script. This way, for multiple executions of the
1103 1103 same script we only keep one copy of the namespace (the last one),
1104 1104 thus preventing memory leaks from old references while allowing the
1105 1105 objects from the last execution to be accessible.
1106 1106 """
1107 1107 filename = os.path.abspath(filename)
1108 1108 try:
1109 1109 main_mod = self._main_mod_cache[filename]
1110 1110 except KeyError:
1111 1111 main_mod = self._main_mod_cache[filename] = types.ModuleType(
1112 1112 modname,
1113 1113 doc="Module created for script run in IPython")
1114 1114 else:
1115 1115 main_mod.__dict__.clear()
1116 1116 main_mod.__name__ = modname
1117 1117
1118 1118 main_mod.__file__ = filename
1119 1119 # It seems pydoc (and perhaps others) needs any module instance to
1120 1120 # implement a __nonzero__ method
1121 1121 main_mod.__nonzero__ = lambda : True
1122 1122
1123 1123 return main_mod
1124 1124
1125 1125 def clear_main_mod_cache(self):
1126 1126 """Clear the cache of main modules.
1127 1127
1128 1128 Mainly for use by utilities like %reset.
1129 1129
1130 1130 Examples
1131 1131 --------
1132 1132
1133 1133 In [15]: import IPython
1134 1134
1135 1135 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
1136 1136
1137 1137 In [17]: len(_ip._main_mod_cache) > 0
1138 1138 Out[17]: True
1139 1139
1140 1140 In [18]: _ip.clear_main_mod_cache()
1141 1141
1142 1142 In [19]: len(_ip._main_mod_cache) == 0
1143 1143 Out[19]: True
1144 1144 """
1145 1145 self._main_mod_cache.clear()
1146 1146
1147 1147 #-------------------------------------------------------------------------
1148 1148 # Things related to debugging
1149 1149 #-------------------------------------------------------------------------
1150 1150
1151 1151 def init_pdb(self):
1152 1152 # Set calling of pdb on exceptions
1153 1153 # self.call_pdb is a property
1154 1154 self.call_pdb = self.pdb
1155 1155
1156 1156 def _get_call_pdb(self):
1157 1157 return self._call_pdb
1158 1158
1159 1159 def _set_call_pdb(self,val):
1160 1160
1161 1161 if val not in (0,1,False,True):
1162 1162 raise ValueError('new call_pdb value must be boolean')
1163 1163
1164 1164 # store value in instance
1165 1165 self._call_pdb = val
1166 1166
1167 1167 # notify the actual exception handlers
1168 1168 self.InteractiveTB.call_pdb = val
1169 1169
1170 1170 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1171 1171 'Control auto-activation of pdb at exceptions')
1172 1172
1173 1173 def debugger(self,force=False):
1174 1174 """Call the pdb debugger.
1175 1175
1176 1176 Keywords:
1177 1177
1178 1178 - force(False): by default, this routine checks the instance call_pdb
1179 1179 flag and does not actually invoke the debugger if the flag is false.
1180 1180 The 'force' option forces the debugger to activate even if the flag
1181 1181 is false.
1182 1182 """
1183 1183
1184 1184 if not (force or self.call_pdb):
1185 1185 return
1186 1186
1187 1187 if not hasattr(sys,'last_traceback'):
1188 1188 error('No traceback has been produced, nothing to debug.')
1189 1189 return
1190 1190
1191 1191 self.InteractiveTB.debugger(force=True)
1192 1192
1193 1193 #-------------------------------------------------------------------------
1194 1194 # Things related to IPython's various namespaces
1195 1195 #-------------------------------------------------------------------------
1196 1196 default_user_namespaces = True
1197 1197
1198 1198 def init_create_namespaces(self, user_module=None, user_ns=None):
1199 1199 # Create the namespace where the user will operate. user_ns is
1200 1200 # normally the only one used, and it is passed to the exec calls as
1201 1201 # the locals argument. But we do carry a user_global_ns namespace
1202 1202 # given as the exec 'globals' argument, This is useful in embedding
1203 1203 # situations where the ipython shell opens in a context where the
1204 1204 # distinction between locals and globals is meaningful. For
1205 1205 # non-embedded contexts, it is just the same object as the user_ns dict.
1206 1206
1207 1207 # FIXME. For some strange reason, __builtins__ is showing up at user
1208 1208 # level as a dict instead of a module. This is a manual fix, but I
1209 1209 # should really track down where the problem is coming from. Alex
1210 1210 # Schmolck reported this problem first.
1211 1211
1212 1212 # A useful post by Alex Martelli on this topic:
1213 1213 # Re: inconsistent value from __builtins__
1214 1214 # Von: Alex Martelli <aleaxit@yahoo.com>
1215 1215 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1216 1216 # Gruppen: comp.lang.python
1217 1217
1218 1218 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1219 1219 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1220 1220 # > <type 'dict'>
1221 1221 # > >>> print type(__builtins__)
1222 1222 # > <type 'module'>
1223 1223 # > Is this difference in return value intentional?
1224 1224
1225 1225 # Well, it's documented that '__builtins__' can be either a dictionary
1226 1226 # or a module, and it's been that way for a long time. Whether it's
1227 1227 # intentional (or sensible), I don't know. In any case, the idea is
1228 1228 # that if you need to access the built-in namespace directly, you
1229 1229 # should start with "import __builtin__" (note, no 's') which will
1230 1230 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1231 1231
1232 1232 # These routines return a properly built module and dict as needed by
1233 1233 # the rest of the code, and can also be used by extension writers to
1234 1234 # generate properly initialized namespaces.
1235 1235 if (user_ns is not None) or (user_module is not None):
1236 1236 self.default_user_namespaces = False
1237 1237 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1238 1238
1239 1239 # A record of hidden variables we have added to the user namespace, so
1240 1240 # we can list later only variables defined in actual interactive use.
1241 1241 self.user_ns_hidden = {}
1242 1242
1243 1243 # Now that FakeModule produces a real module, we've run into a nasty
1244 1244 # problem: after script execution (via %run), the module where the user
1245 1245 # code ran is deleted. Now that this object is a true module (needed
1246 1246 # so doctest and other tools work correctly), the Python module
1247 1247 # teardown mechanism runs over it, and sets to None every variable
1248 1248 # present in that module. Top-level references to objects from the
1249 1249 # script survive, because the user_ns is updated with them. However,
1250 1250 # calling functions defined in the script that use other things from
1251 1251 # the script will fail, because the function's closure had references
1252 1252 # to the original objects, which are now all None. So we must protect
1253 1253 # these modules from deletion by keeping a cache.
1254 1254 #
1255 1255 # To avoid keeping stale modules around (we only need the one from the
1256 1256 # last run), we use a dict keyed with the full path to the script, so
1257 1257 # only the last version of the module is held in the cache. Note,
1258 1258 # however, that we must cache the module *namespace contents* (their
1259 1259 # __dict__). Because if we try to cache the actual modules, old ones
1260 1260 # (uncached) could be destroyed while still holding references (such as
1261 1261 # those held by GUI objects that tend to be long-lived)>
1262 1262 #
1263 1263 # The %reset command will flush this cache. See the cache_main_mod()
1264 1264 # and clear_main_mod_cache() methods for details on use.
1265 1265
1266 1266 # This is the cache used for 'main' namespaces
1267 1267 self._main_mod_cache = {}
1268 1268
1269 1269 # A table holding all the namespaces IPython deals with, so that
1270 1270 # introspection facilities can search easily.
1271 1271 self.ns_table = {'user_global':self.user_module.__dict__,
1272 1272 'user_local':self.user_ns,
1273 1273 'builtin':builtin_mod.__dict__
1274 1274 }
1275 1275
1276 1276 @property
1277 1277 def user_global_ns(self):
1278 1278 return self.user_module.__dict__
1279 1279
1280 1280 def prepare_user_module(self, user_module=None, user_ns=None):
1281 1281 """Prepare the module and namespace in which user code will be run.
1282 1282
1283 1283 When IPython is started normally, both parameters are None: a new module
1284 1284 is created automatically, and its __dict__ used as the namespace.
1285 1285
1286 1286 If only user_module is provided, its __dict__ is used as the namespace.
1287 1287 If only user_ns is provided, a dummy module is created, and user_ns
1288 1288 becomes the global namespace. If both are provided (as they may be
1289 1289 when embedding), user_ns is the local namespace, and user_module
1290 1290 provides the global namespace.
1291 1291
1292 1292 Parameters
1293 1293 ----------
1294 1294 user_module : module, optional
1295 1295 The current user module in which IPython is being run. If None,
1296 1296 a clean module will be created.
1297 1297 user_ns : dict, optional
1298 1298 A namespace in which to run interactive commands.
1299 1299
1300 1300 Returns
1301 1301 -------
1302 1302 A tuple of user_module and user_ns, each properly initialised.
1303 1303 """
1304 1304 if user_module is None and user_ns is not None:
1305 1305 user_ns.setdefault("__name__", "__main__")
1306 1306 user_module = DummyMod()
1307 1307 user_module.__dict__ = user_ns
1308 1308
1309 1309 if user_module is None:
1310 1310 user_module = types.ModuleType("__main__",
1311 1311 doc="Automatically created module for IPython interactive environment")
1312 1312
1313 1313 # We must ensure that __builtin__ (without the final 's') is always
1314 1314 # available and pointing to the __builtin__ *module*. For more details:
1315 1315 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1316 1316 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1317 1317 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1318 1318
1319 1319 if user_ns is None:
1320 1320 user_ns = user_module.__dict__
1321 1321
1322 1322 return user_module, user_ns
1323 1323
1324 1324 def init_sys_modules(self):
1325 1325 # We need to insert into sys.modules something that looks like a
1326 1326 # module but which accesses the IPython namespace, for shelve and
1327 1327 # pickle to work interactively. Normally they rely on getting
1328 1328 # everything out of __main__, but for embedding purposes each IPython
1329 1329 # instance has its own private namespace, so we can't go shoving
1330 1330 # everything into __main__.
1331 1331
1332 1332 # note, however, that we should only do this for non-embedded
1333 1333 # ipythons, which really mimic the __main__.__dict__ with their own
1334 1334 # namespace. Embedded instances, on the other hand, should not do
1335 1335 # this because they need to manage the user local/global namespaces
1336 1336 # only, but they live within a 'normal' __main__ (meaning, they
1337 1337 # shouldn't overtake the execution environment of the script they're
1338 1338 # embedded in).
1339 1339
1340 1340 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1341 1341 main_name = self.user_module.__name__
1342 1342 sys.modules[main_name] = self.user_module
1343 1343
1344 1344 def init_user_ns(self):
1345 1345 """Initialize all user-visible namespaces to their minimum defaults.
1346 1346
1347 1347 Certain history lists are also initialized here, as they effectively
1348 1348 act as user namespaces.
1349 1349
1350 1350 Notes
1351 1351 -----
1352 1352 All data structures here are only filled in, they are NOT reset by this
1353 1353 method. If they were not empty before, data will simply be added to
1354 1354 them.
1355 1355 """
1356 1356 # This function works in two parts: first we put a few things in
1357 1357 # user_ns, and we sync that contents into user_ns_hidden so that these
1358 1358 # initial variables aren't shown by %who. After the sync, we add the
1359 1359 # rest of what we *do* want the user to see with %who even on a new
1360 1360 # session (probably nothing, so they really only see their own stuff)
1361 1361
1362 1362 # The user dict must *always* have a __builtin__ reference to the
1363 1363 # Python standard __builtin__ namespace, which must be imported.
1364 1364 # This is so that certain operations in prompt evaluation can be
1365 1365 # reliably executed with builtins. Note that we can NOT use
1366 1366 # __builtins__ (note the 's'), because that can either be a dict or a
1367 1367 # module, and can even mutate at runtime, depending on the context
1368 1368 # (Python makes no guarantees on it). In contrast, __builtin__ is
1369 1369 # always a module object, though it must be explicitly imported.
1370 1370
1371 1371 # For more details:
1372 1372 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1373 1373 ns = {}
1374 1374
1375 1375 # make global variables for user access to the histories
1376 1376 ns['_ih'] = self.history_manager.input_hist_parsed
1377 1377 ns['_oh'] = self.history_manager.output_hist
1378 1378 ns['_dh'] = self.history_manager.dir_hist
1379 1379
1380 1380 # user aliases to input and output histories. These shouldn't show up
1381 1381 # in %who, as they can have very large reprs.
1382 1382 ns['In'] = self.history_manager.input_hist_parsed
1383 1383 ns['Out'] = self.history_manager.output_hist
1384 1384
1385 1385 # Store myself as the public api!!!
1386 1386 ns['get_ipython'] = self.get_ipython
1387 1387
1388 1388 ns['exit'] = self.exiter
1389 1389 ns['quit'] = self.exiter
1390 1390
1391 1391 # Sync what we've added so far to user_ns_hidden so these aren't seen
1392 1392 # by %who
1393 1393 self.user_ns_hidden.update(ns)
1394 1394
1395 1395 # Anything put into ns now would show up in %who. Think twice before
1396 1396 # putting anything here, as we really want %who to show the user their
1397 1397 # stuff, not our variables.
1398 1398
1399 1399 # Finally, update the real user's namespace
1400 1400 self.user_ns.update(ns)
1401 1401
1402 1402 @property
1403 1403 def all_ns_refs(self):
1404 1404 """Get a list of references to all the namespace dictionaries in which
1405 1405 IPython might store a user-created object.
1406 1406
1407 1407 Note that this does not include the displayhook, which also caches
1408 1408 objects from the output."""
1409 1409 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1410 1410 [m.__dict__ for m in self._main_mod_cache.values()]
1411 1411
1412 1412 def reset(self, new_session=True):
1413 1413 """Clear all internal namespaces, and attempt to release references to
1414 1414 user objects.
1415 1415
1416 1416 If new_session is True, a new history session will be opened.
1417 1417 """
1418 1418 # Clear histories
1419 1419 self.history_manager.reset(new_session)
1420 1420 # Reset counter used to index all histories
1421 1421 if new_session:
1422 1422 self.execution_count = 1
1423 1423
1424 1424 # Reset last execution result
1425 1425 self.last_execution_succeeded = True
1426 1426 self.last_execution_result = None
1427 1427
1428 1428 # Flush cached output items
1429 1429 if self.displayhook.do_full_cache:
1430 1430 self.displayhook.flush()
1431 1431
1432 1432 # The main execution namespaces must be cleared very carefully,
1433 1433 # skipping the deletion of the builtin-related keys, because doing so
1434 1434 # would cause errors in many object's __del__ methods.
1435 1435 if self.user_ns is not self.user_global_ns:
1436 1436 self.user_ns.clear()
1437 1437 ns = self.user_global_ns
1438 1438 drop_keys = set(ns.keys())
1439 1439 drop_keys.discard('__builtin__')
1440 1440 drop_keys.discard('__builtins__')
1441 1441 drop_keys.discard('__name__')
1442 1442 for k in drop_keys:
1443 1443 del ns[k]
1444 1444
1445 1445 self.user_ns_hidden.clear()
1446 1446
1447 1447 # Restore the user namespaces to minimal usability
1448 1448 self.init_user_ns()
1449 1449
1450 1450 # Restore the default and user aliases
1451 1451 self.alias_manager.clear_aliases()
1452 1452 self.alias_manager.init_aliases()
1453 1453
1454 1454 # Now define aliases that only make sense on the terminal, because they
1455 1455 # need direct access to the console in a way that we can't emulate in
1456 1456 # GUI or web frontend
1457 1457 if os.name == 'posix':
1458 1458 for cmd in ('clear', 'more', 'less', 'man'):
1459 1459 if cmd not in self.magics_manager.magics['line']:
1460 1460 self.alias_manager.soft_define_alias(cmd, cmd)
1461 1461
1462 1462 # Flush the private list of module references kept for script
1463 1463 # execution protection
1464 1464 self.clear_main_mod_cache()
1465 1465
1466 1466 def del_var(self, varname, by_name=False):
1467 1467 """Delete a variable from the various namespaces, so that, as
1468 1468 far as possible, we're not keeping any hidden references to it.
1469 1469
1470 1470 Parameters
1471 1471 ----------
1472 1472 varname : str
1473 1473 The name of the variable to delete.
1474 1474 by_name : bool
1475 1475 If True, delete variables with the given name in each
1476 1476 namespace. If False (default), find the variable in the user
1477 1477 namespace, and delete references to it.
1478 1478 """
1479 1479 if varname in ('__builtin__', '__builtins__'):
1480 1480 raise ValueError("Refusing to delete %s" % varname)
1481 1481
1482 1482 ns_refs = self.all_ns_refs
1483 1483
1484 1484 if by_name: # Delete by name
1485 1485 for ns in ns_refs:
1486 1486 try:
1487 1487 del ns[varname]
1488 1488 except KeyError:
1489 1489 pass
1490 1490 else: # Delete by object
1491 1491 try:
1492 1492 obj = self.user_ns[varname]
1493 1493 except KeyError:
1494 1494 raise NameError("name '%s' is not defined" % varname)
1495 1495 # Also check in output history
1496 1496 ns_refs.append(self.history_manager.output_hist)
1497 1497 for ns in ns_refs:
1498 1498 to_delete = [n for n, o in ns.items() if o is obj]
1499 1499 for name in to_delete:
1500 1500 del ns[name]
1501 1501
1502 1502 # Ensure it is removed from the last execution result
1503 1503 if self.last_execution_result.result is obj:
1504 1504 self.last_execution_result = None
1505 1505
1506 1506 # displayhook keeps extra references, but not in a dictionary
1507 1507 for name in ('_', '__', '___'):
1508 1508 if getattr(self.displayhook, name) is obj:
1509 1509 setattr(self.displayhook, name, None)
1510 1510
1511 1511 def reset_selective(self, regex=None):
1512 1512 """Clear selective variables from internal namespaces based on a
1513 1513 specified regular expression.
1514 1514
1515 1515 Parameters
1516 1516 ----------
1517 1517 regex : string or compiled pattern, optional
1518 1518 A regular expression pattern that will be used in searching
1519 1519 variable names in the users namespaces.
1520 1520 """
1521 1521 if regex is not None:
1522 1522 try:
1523 1523 m = re.compile(regex)
1524 1524 except TypeError:
1525 1525 raise TypeError('regex must be a string or compiled pattern')
1526 1526 # Search for keys in each namespace that match the given regex
1527 1527 # If a match is found, delete the key/value pair.
1528 1528 for ns in self.all_ns_refs:
1529 1529 for var in ns:
1530 1530 if m.search(var):
1531 1531 del ns[var]
1532 1532
1533 1533 def push(self, variables, interactive=True):
1534 1534 """Inject a group of variables into the IPython user namespace.
1535 1535
1536 1536 Parameters
1537 1537 ----------
1538 1538 variables : dict, str or list/tuple of str
1539 1539 The variables to inject into the user's namespace. If a dict, a
1540 1540 simple update is done. If a str, the string is assumed to have
1541 1541 variable names separated by spaces. A list/tuple of str can also
1542 1542 be used to give the variable names. If just the variable names are
1543 1543 give (list/tuple/str) then the variable values looked up in the
1544 1544 callers frame.
1545 1545 interactive : bool
1546 1546 If True (default), the variables will be listed with the ``who``
1547 1547 magic.
1548 1548 """
1549 1549 vdict = None
1550 1550
1551 1551 # We need a dict of name/value pairs to do namespace updates.
1552 1552 if isinstance(variables, dict):
1553 1553 vdict = variables
1554 1554 elif isinstance(variables, (str, list, tuple)):
1555 1555 if isinstance(variables, str):
1556 1556 vlist = variables.split()
1557 1557 else:
1558 1558 vlist = variables
1559 1559 vdict = {}
1560 1560 cf = sys._getframe(1)
1561 1561 for name in vlist:
1562 1562 try:
1563 1563 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1564 1564 except:
1565 1565 print('Could not get variable %s from %s' %
1566 1566 (name,cf.f_code.co_name))
1567 1567 else:
1568 1568 raise ValueError('variables must be a dict/str/list/tuple')
1569 1569
1570 1570 # Propagate variables to user namespace
1571 1571 self.user_ns.update(vdict)
1572 1572
1573 1573 # And configure interactive visibility
1574 1574 user_ns_hidden = self.user_ns_hidden
1575 1575 if interactive:
1576 1576 for name in vdict:
1577 1577 user_ns_hidden.pop(name, None)
1578 1578 else:
1579 1579 user_ns_hidden.update(vdict)
1580 1580
1581 1581 def drop_by_id(self, variables):
1582 1582 """Remove a dict of variables from the user namespace, if they are the
1583 1583 same as the values in the dictionary.
1584 1584
1585 1585 This is intended for use by extensions: variables that they've added can
1586 1586 be taken back out if they are unloaded, without removing any that the
1587 1587 user has overwritten.
1588 1588
1589 1589 Parameters
1590 1590 ----------
1591 1591 variables : dict
1592 1592 A dictionary mapping object names (as strings) to the objects.
1593 1593 """
1594 1594 for name, obj in variables.items():
1595 1595 if name in self.user_ns and self.user_ns[name] is obj:
1596 1596 del self.user_ns[name]
1597 1597 self.user_ns_hidden.pop(name, None)
1598 1598
1599 1599 #-------------------------------------------------------------------------
1600 1600 # Things related to object introspection
1601 1601 #-------------------------------------------------------------------------
1602 1602
1603 1603 def _ofind(self, oname, namespaces=None):
1604 1604 """Find an object in the available namespaces.
1605 1605
1606 1606 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1607 1607
1608 1608 Has special code to detect magic functions.
1609 1609 """
1610 1610 oname = oname.strip()
1611 1611 if not oname.startswith(ESC_MAGIC) and \
1612 1612 not oname.startswith(ESC_MAGIC2) and \
1613 1613 not all(a.isidentifier() for a in oname.split(".")):
1614 1614 return {'found': False}
1615 1615
1616 1616 if namespaces is None:
1617 1617 # Namespaces to search in:
1618 1618 # Put them in a list. The order is important so that we
1619 1619 # find things in the same order that Python finds them.
1620 1620 namespaces = [ ('Interactive', self.user_ns),
1621 1621 ('Interactive (global)', self.user_global_ns),
1622 1622 ('Python builtin', builtin_mod.__dict__),
1623 1623 ]
1624 1624
1625 1625 ismagic = False
1626 1626 isalias = False
1627 1627 found = False
1628 1628 ospace = None
1629 1629 parent = None
1630 1630 obj = None
1631 1631
1632 1632
1633 1633 # Look for the given name by splitting it in parts. If the head is
1634 1634 # found, then we look for all the remaining parts as members, and only
1635 1635 # declare success if we can find them all.
1636 1636 oname_parts = oname.split('.')
1637 1637 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1638 1638 for nsname,ns in namespaces:
1639 1639 try:
1640 1640 obj = ns[oname_head]
1641 1641 except KeyError:
1642 1642 continue
1643 1643 else:
1644 1644 for idx, part in enumerate(oname_rest):
1645 1645 try:
1646 1646 parent = obj
1647 1647 # The last part is looked up in a special way to avoid
1648 1648 # descriptor invocation as it may raise or have side
1649 1649 # effects.
1650 1650 if idx == len(oname_rest) - 1:
1651 1651 obj = self._getattr_property(obj, part)
1652 1652 else:
1653 1653 obj = getattr(obj, part)
1654 1654 except:
1655 1655 # Blanket except b/c some badly implemented objects
1656 1656 # allow __getattr__ to raise exceptions other than
1657 1657 # AttributeError, which then crashes IPython.
1658 1658 break
1659 1659 else:
1660 1660 # If we finish the for loop (no break), we got all members
1661 1661 found = True
1662 1662 ospace = nsname
1663 1663 break # namespace loop
1664 1664
1665 1665 # Try to see if it's magic
1666 1666 if not found:
1667 1667 obj = None
1668 1668 if oname.startswith(ESC_MAGIC2):
1669 1669 oname = oname.lstrip(ESC_MAGIC2)
1670 1670 obj = self.find_cell_magic(oname)
1671 1671 elif oname.startswith(ESC_MAGIC):
1672 1672 oname = oname.lstrip(ESC_MAGIC)
1673 1673 obj = self.find_line_magic(oname)
1674 1674 else:
1675 1675 # search without prefix, so run? will find %run?
1676 1676 obj = self.find_line_magic(oname)
1677 1677 if obj is None:
1678 1678 obj = self.find_cell_magic(oname)
1679 1679 if obj is not None:
1680 1680 found = True
1681 1681 ospace = 'IPython internal'
1682 1682 ismagic = True
1683 1683 isalias = isinstance(obj, Alias)
1684 1684
1685 1685 # Last try: special-case some literals like '', [], {}, etc:
1686 1686 if not found and oname_head in ["''",'""','[]','{}','()']:
1687 1687 obj = eval(oname_head)
1688 1688 found = True
1689 1689 ospace = 'Interactive'
1690 1690
1691 1691 return {
1692 1692 'obj':obj,
1693 1693 'found':found,
1694 1694 'parent':parent,
1695 1695 'ismagic':ismagic,
1696 1696 'isalias':isalias,
1697 1697 'namespace':ospace
1698 1698 }
1699 1699
1700 1700 @staticmethod
1701 1701 def _getattr_property(obj, attrname):
1702 1702 """Property-aware getattr to use in object finding.
1703 1703
1704 1704 If attrname represents a property, return it unevaluated (in case it has
1705 1705 side effects or raises an error.
1706 1706
1707 1707 """
1708 1708 if not isinstance(obj, type):
1709 1709 try:
1710 1710 # `getattr(type(obj), attrname)` is not guaranteed to return
1711 1711 # `obj`, but does so for property:
1712 1712 #
1713 1713 # property.__get__(self, None, cls) -> self
1714 1714 #
1715 1715 # The universal alternative is to traverse the mro manually
1716 1716 # searching for attrname in class dicts.
1717 1717 attr = getattr(type(obj), attrname)
1718 1718 except AttributeError:
1719 1719 pass
1720 1720 else:
1721 1721 # This relies on the fact that data descriptors (with both
1722 1722 # __get__ & __set__ magic methods) take precedence over
1723 1723 # instance-level attributes:
1724 1724 #
1725 1725 # class A(object):
1726 1726 # @property
1727 1727 # def foobar(self): return 123
1728 1728 # a = A()
1729 1729 # a.__dict__['foobar'] = 345
1730 1730 # a.foobar # == 123
1731 1731 #
1732 1732 # So, a property may be returned right away.
1733 1733 if isinstance(attr, property):
1734 1734 return attr
1735 1735
1736 1736 # Nothing helped, fall back.
1737 1737 return getattr(obj, attrname)
1738 1738
1739 1739 def _object_find(self, oname, namespaces=None):
1740 1740 """Find an object and return a struct with info about it."""
1741 1741 return Struct(self._ofind(oname, namespaces))
1742 1742
1743 1743 def _inspect(self, meth, oname, namespaces=None, **kw):
1744 1744 """Generic interface to the inspector system.
1745 1745
1746 1746 This function is meant to be called by pdef, pdoc & friends.
1747 1747 """
1748 1748 info = self._object_find(oname, namespaces)
1749 1749 docformat = sphinxify if self.sphinxify_docstring else None
1750 1750 if info.found:
1751 1751 pmethod = getattr(self.inspector, meth)
1752 1752 # TODO: only apply format_screen to the plain/text repr of the mime
1753 1753 # bundle.
1754 1754 formatter = format_screen if info.ismagic else docformat
1755 1755 if meth == 'pdoc':
1756 1756 pmethod(info.obj, oname, formatter)
1757 1757 elif meth == 'pinfo':
1758 1758 pmethod(info.obj, oname, formatter, info,
1759 1759 enable_html_pager=self.enable_html_pager, **kw)
1760 1760 else:
1761 1761 pmethod(info.obj, oname)
1762 1762 else:
1763 1763 print('Object `%s` not found.' % oname)
1764 1764 return 'not found' # so callers can take other action
1765 1765
1766 1766 def object_inspect(self, oname, detail_level=0):
1767 1767 """Get object info about oname"""
1768 1768 with self.builtin_trap:
1769 1769 info = self._object_find(oname)
1770 1770 if info.found:
1771 1771 return self.inspector.info(info.obj, oname, info=info,
1772 1772 detail_level=detail_level
1773 1773 )
1774 1774 else:
1775 1775 return oinspect.object_info(name=oname, found=False)
1776 1776
1777 1777 def object_inspect_text(self, oname, detail_level=0):
1778 1778 """Get object info as formatted text"""
1779 1779 return self.object_inspect_mime(oname, detail_level)['text/plain']
1780 1780
1781 1781 def object_inspect_mime(self, oname, detail_level=0):
1782 1782 """Get object info as a mimebundle of formatted representations.
1783 1783
1784 1784 A mimebundle is a dictionary, keyed by mime-type.
1785 1785 It must always have the key `'text/plain'`.
1786 1786 """
1787 1787 with self.builtin_trap:
1788 1788 info = self._object_find(oname)
1789 1789 if info.found:
1790 1790 return self.inspector._get_info(info.obj, oname, info=info,
1791 1791 detail_level=detail_level
1792 1792 )
1793 1793 else:
1794 1794 raise KeyError(oname)
1795 1795
1796 1796 #-------------------------------------------------------------------------
1797 1797 # Things related to history management
1798 1798 #-------------------------------------------------------------------------
1799 1799
1800 1800 def init_history(self):
1801 1801 """Sets up the command history, and starts regular autosaves."""
1802 1802 self.history_manager = HistoryManager(shell=self, parent=self)
1803 1803 self.configurables.append(self.history_manager)
1804 1804
1805 1805 #-------------------------------------------------------------------------
1806 1806 # Things related to exception handling and tracebacks (not debugging)
1807 1807 #-------------------------------------------------------------------------
1808 1808
1809 1809 debugger_cls = Pdb
1810 1810
1811 1811 def init_traceback_handlers(self, custom_exceptions):
1812 1812 # Syntax error handler.
1813 1813 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor', parent=self)
1814 1814
1815 1815 # The interactive one is initialized with an offset, meaning we always
1816 1816 # want to remove the topmost item in the traceback, which is our own
1817 1817 # internal code. Valid modes: ['Plain','Context','Verbose','Minimal']
1818 1818 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1819 1819 color_scheme='NoColor',
1820 1820 tb_offset = 1,
1821 1821 check_cache=check_linecache_ipython,
1822 1822 debugger_cls=self.debugger_cls, parent=self)
1823 1823
1824 1824 # The instance will store a pointer to the system-wide exception hook,
1825 1825 # so that runtime code (such as magics) can access it. This is because
1826 1826 # during the read-eval loop, it may get temporarily overwritten.
1827 1827 self.sys_excepthook = sys.excepthook
1828 1828
1829 1829 # and add any custom exception handlers the user may have specified
1830 1830 self.set_custom_exc(*custom_exceptions)
1831 1831
1832 1832 # Set the exception mode
1833 1833 self.InteractiveTB.set_mode(mode=self.xmode)
1834 1834
1835 1835 def set_custom_exc(self, exc_tuple, handler):
1836 1836 """set_custom_exc(exc_tuple, handler)
1837 1837
1838 1838 Set a custom exception handler, which will be called if any of the
1839 1839 exceptions in exc_tuple occur in the mainloop (specifically, in the
1840 1840 run_code() method).
1841 1841
1842 1842 Parameters
1843 1843 ----------
1844 1844
1845 1845 exc_tuple : tuple of exception classes
1846 1846 A *tuple* of exception classes, for which to call the defined
1847 1847 handler. It is very important that you use a tuple, and NOT A
1848 1848 LIST here, because of the way Python's except statement works. If
1849 1849 you only want to trap a single exception, use a singleton tuple::
1850 1850
1851 1851 exc_tuple == (MyCustomException,)
1852 1852
1853 1853 handler : callable
1854 1854 handler must have the following signature::
1855 1855
1856 1856 def my_handler(self, etype, value, tb, tb_offset=None):
1857 1857 ...
1858 1858 return structured_traceback
1859 1859
1860 1860 Your handler must return a structured traceback (a list of strings),
1861 1861 or None.
1862 1862
1863 1863 This will be made into an instance method (via types.MethodType)
1864 1864 of IPython itself, and it will be called if any of the exceptions
1865 1865 listed in the exc_tuple are caught. If the handler is None, an
1866 1866 internal basic one is used, which just prints basic info.
1867 1867
1868 1868 To protect IPython from crashes, if your handler ever raises an
1869 1869 exception or returns an invalid result, it will be immediately
1870 1870 disabled.
1871 1871
1872 1872 WARNING: by putting in your own exception handler into IPython's main
1873 1873 execution loop, you run a very good chance of nasty crashes. This
1874 1874 facility should only be used if you really know what you are doing."""
1875 1875 if not isinstance(exc_tuple, tuple):
1876 1876 raise TypeError("The custom exceptions must be given as a tuple.")
1877 1877
1878 1878 def dummy_handler(self, etype, value, tb, tb_offset=None):
1879 1879 print('*** Simple custom exception handler ***')
1880 1880 print('Exception type :', etype)
1881 1881 print('Exception value:', value)
1882 1882 print('Traceback :', tb)
1883 1883
1884 1884 def validate_stb(stb):
1885 1885 """validate structured traceback return type
1886 1886
1887 1887 return type of CustomTB *should* be a list of strings, but allow
1888 1888 single strings or None, which are harmless.
1889 1889
1890 1890 This function will *always* return a list of strings,
1891 1891 and will raise a TypeError if stb is inappropriate.
1892 1892 """
1893 1893 msg = "CustomTB must return list of strings, not %r" % stb
1894 1894 if stb is None:
1895 1895 return []
1896 1896 elif isinstance(stb, str):
1897 1897 return [stb]
1898 1898 elif not isinstance(stb, list):
1899 1899 raise TypeError(msg)
1900 1900 # it's a list
1901 1901 for line in stb:
1902 1902 # check every element
1903 1903 if not isinstance(line, str):
1904 1904 raise TypeError(msg)
1905 1905 return stb
1906 1906
1907 1907 if handler is None:
1908 1908 wrapped = dummy_handler
1909 1909 else:
1910 1910 def wrapped(self,etype,value,tb,tb_offset=None):
1911 1911 """wrap CustomTB handler, to protect IPython from user code
1912 1912
1913 1913 This makes it harder (but not impossible) for custom exception
1914 1914 handlers to crash IPython.
1915 1915 """
1916 1916 try:
1917 1917 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1918 1918 return validate_stb(stb)
1919 1919 except:
1920 1920 # clear custom handler immediately
1921 1921 self.set_custom_exc((), None)
1922 1922 print("Custom TB Handler failed, unregistering", file=sys.stderr)
1923 1923 # show the exception in handler first
1924 1924 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1925 1925 print(self.InteractiveTB.stb2text(stb))
1926 1926 print("The original exception:")
1927 1927 stb = self.InteractiveTB.structured_traceback(
1928 1928 (etype,value,tb), tb_offset=tb_offset
1929 1929 )
1930 1930 return stb
1931 1931
1932 1932 self.CustomTB = types.MethodType(wrapped,self)
1933 1933 self.custom_exceptions = exc_tuple
1934 1934
1935 1935 def excepthook(self, etype, value, tb):
1936 1936 """One more defense for GUI apps that call sys.excepthook.
1937 1937
1938 1938 GUI frameworks like wxPython trap exceptions and call
1939 1939 sys.excepthook themselves. I guess this is a feature that
1940 1940 enables them to keep running after exceptions that would
1941 1941 otherwise kill their mainloop. This is a bother for IPython
1942 1942 which excepts to catch all of the program exceptions with a try:
1943 1943 except: statement.
1944 1944
1945 1945 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1946 1946 any app directly invokes sys.excepthook, it will look to the user like
1947 1947 IPython crashed. In order to work around this, we can disable the
1948 1948 CrashHandler and replace it with this excepthook instead, which prints a
1949 1949 regular traceback using our InteractiveTB. In this fashion, apps which
1950 1950 call sys.excepthook will generate a regular-looking exception from
1951 1951 IPython, and the CrashHandler will only be triggered by real IPython
1952 1952 crashes.
1953 1953
1954 1954 This hook should be used sparingly, only in places which are not likely
1955 1955 to be true IPython errors.
1956 1956 """
1957 1957 self.showtraceback((etype, value, tb), tb_offset=0)
1958 1958
1959 1959 def _get_exc_info(self, exc_tuple=None):
1960 1960 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1961 1961
1962 1962 Ensures sys.last_type,value,traceback hold the exc_info we found,
1963 1963 from whichever source.
1964 1964
1965 1965 raises ValueError if none of these contain any information
1966 1966 """
1967 1967 if exc_tuple is None:
1968 1968 etype, value, tb = sys.exc_info()
1969 1969 else:
1970 1970 etype, value, tb = exc_tuple
1971 1971
1972 1972 if etype is None:
1973 1973 if hasattr(sys, 'last_type'):
1974 1974 etype, value, tb = sys.last_type, sys.last_value, \
1975 1975 sys.last_traceback
1976 1976
1977 1977 if etype is None:
1978 1978 raise ValueError("No exception to find")
1979 1979
1980 1980 # Now store the exception info in sys.last_type etc.
1981 1981 # WARNING: these variables are somewhat deprecated and not
1982 1982 # necessarily safe to use in a threaded environment, but tools
1983 1983 # like pdb depend on their existence, so let's set them. If we
1984 1984 # find problems in the field, we'll need to revisit their use.
1985 1985 sys.last_type = etype
1986 1986 sys.last_value = value
1987 1987 sys.last_traceback = tb
1988 1988
1989 1989 return etype, value, tb
1990 1990
1991 1991 def show_usage_error(self, exc):
1992 1992 """Show a short message for UsageErrors
1993 1993
1994 1994 These are special exceptions that shouldn't show a traceback.
1995 1995 """
1996 1996 print("UsageError: %s" % exc, file=sys.stderr)
1997 1997
1998 1998 def get_exception_only(self, exc_tuple=None):
1999 1999 """
2000 2000 Return as a string (ending with a newline) the exception that
2001 2001 just occurred, without any traceback.
2002 2002 """
2003 2003 etype, value, tb = self._get_exc_info(exc_tuple)
2004 2004 msg = traceback.format_exception_only(etype, value)
2005 2005 return ''.join(msg)
2006 2006
2007 2007 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
2008 2008 exception_only=False, running_compiled_code=False):
2009 2009 """Display the exception that just occurred.
2010 2010
2011 2011 If nothing is known about the exception, this is the method which
2012 2012 should be used throughout the code for presenting user tracebacks,
2013 2013 rather than directly invoking the InteractiveTB object.
2014 2014
2015 2015 A specific showsyntaxerror() also exists, but this method can take
2016 2016 care of calling it if needed, so unless you are explicitly catching a
2017 2017 SyntaxError exception, don't try to analyze the stack manually and
2018 2018 simply call this method."""
2019 2019
2020 2020 try:
2021 2021 try:
2022 2022 etype, value, tb = self._get_exc_info(exc_tuple)
2023 2023 except ValueError:
2024 2024 print('No traceback available to show.', file=sys.stderr)
2025 2025 return
2026 2026
2027 2027 if issubclass(etype, SyntaxError):
2028 2028 # Though this won't be called by syntax errors in the input
2029 2029 # line, there may be SyntaxError cases with imported code.
2030 2030 self.showsyntaxerror(filename, running_compiled_code)
2031 2031 elif etype is UsageError:
2032 2032 self.show_usage_error(value)
2033 2033 else:
2034 2034 if exception_only:
2035 2035 stb = ['An exception has occurred, use %tb to see '
2036 2036 'the full traceback.\n']
2037 2037 stb.extend(self.InteractiveTB.get_exception_only(etype,
2038 2038 value))
2039 2039 else:
2040 2040 try:
2041 2041 # Exception classes can customise their traceback - we
2042 2042 # use this in IPython.parallel for exceptions occurring
2043 2043 # in the engines. This should return a list of strings.
2044 2044 stb = value._render_traceback_()
2045 2045 except Exception:
2046 2046 stb = self.InteractiveTB.structured_traceback(etype,
2047 2047 value, tb, tb_offset=tb_offset)
2048 2048
2049 2049 self._showtraceback(etype, value, stb)
2050 2050 if self.call_pdb:
2051 2051 # drop into debugger
2052 2052 self.debugger(force=True)
2053 2053 return
2054 2054
2055 2055 # Actually show the traceback
2056 2056 self._showtraceback(etype, value, stb)
2057 2057
2058 2058 except KeyboardInterrupt:
2059 2059 print('\n' + self.get_exception_only(), file=sys.stderr)
2060 2060
2061 2061 def _showtraceback(self, etype, evalue, stb):
2062 2062 """Actually show a traceback.
2063 2063
2064 2064 Subclasses may override this method to put the traceback on a different
2065 2065 place, like a side channel.
2066 2066 """
2067 2067 print(self.InteractiveTB.stb2text(stb))
2068 2068
2069 2069 def showsyntaxerror(self, filename=None, running_compiled_code=False):
2070 2070 """Display the syntax error that just occurred.
2071 2071
2072 2072 This doesn't display a stack trace because there isn't one.
2073 2073
2074 2074 If a filename is given, it is stuffed in the exception instead
2075 2075 of what was there before (because Python's parser always uses
2076 2076 "<string>" when reading from a string).
2077 2077
2078 2078 If the syntax error occurred when running a compiled code (i.e. running_compile_code=True),
2079 2079 longer stack trace will be displayed.
2080 2080 """
2081 2081 etype, value, last_traceback = self._get_exc_info()
2082 2082
2083 2083 if filename and issubclass(etype, SyntaxError):
2084 2084 try:
2085 2085 value.filename = filename
2086 2086 except:
2087 2087 # Not the format we expect; leave it alone
2088 2088 pass
2089 2089
2090 2090 # If the error occurred when executing compiled code, we should provide full stacktrace.
2091 2091 elist = traceback.extract_tb(last_traceback) if running_compiled_code else []
2092 2092 stb = self.SyntaxTB.structured_traceback(etype, value, elist)
2093 2093 self._showtraceback(etype, value, stb)
2094 2094
2095 2095 # This is overridden in TerminalInteractiveShell to show a message about
2096 2096 # the %paste magic.
2097 2097 def showindentationerror(self):
2098 2098 """Called by _run_cell when there's an IndentationError in code entered
2099 2099 at the prompt.
2100 2100
2101 2101 This is overridden in TerminalInteractiveShell to show a message about
2102 2102 the %paste magic."""
2103 2103 self.showsyntaxerror()
2104 2104
2105 2105 #-------------------------------------------------------------------------
2106 2106 # Things related to readline
2107 2107 #-------------------------------------------------------------------------
2108 2108
2109 2109 def init_readline(self):
2110 2110 """DEPRECATED
2111 2111
2112 2112 Moved to terminal subclass, here only to simplify the init logic."""
2113 2113 # Set a number of methods that depend on readline to be no-op
2114 2114 warnings.warn('`init_readline` is no-op since IPython 5.0 and is Deprecated',
2115 2115 DeprecationWarning, stacklevel=2)
2116 2116 self.set_custom_completer = no_op
2117 2117
2118 2118 @skip_doctest
2119 2119 def set_next_input(self, s, replace=False):
2120 2120 """ Sets the 'default' input string for the next command line.
2121 2121
2122 2122 Example::
2123 2123
2124 2124 In [1]: _ip.set_next_input("Hello Word")
2125 2125 In [2]: Hello Word_ # cursor is here
2126 2126 """
2127 2127 self.rl_next_input = s
2128 2128
2129 2129 def _indent_current_str(self):
2130 2130 """return the current level of indentation as a string"""
2131 2131 return self.input_splitter.get_indent_spaces() * ' '
2132 2132
2133 2133 #-------------------------------------------------------------------------
2134 2134 # Things related to text completion
2135 2135 #-------------------------------------------------------------------------
2136 2136
2137 2137 def init_completer(self):
2138 2138 """Initialize the completion machinery.
2139 2139
2140 2140 This creates completion machinery that can be used by client code,
2141 2141 either interactively in-process (typically triggered by the readline
2142 2142 library), programmatically (such as in test suites) or out-of-process
2143 2143 (typically over the network by remote frontends).
2144 2144 """
2145 2145 from IPython.core.completer import IPCompleter
2146 2146 from IPython.core.completerlib import (module_completer,
2147 2147 magic_run_completer, cd_completer, reset_completer)
2148 2148
2149 2149 self.Completer = IPCompleter(shell=self,
2150 2150 namespace=self.user_ns,
2151 2151 global_namespace=self.user_global_ns,
2152 2152 parent=self,
2153 2153 )
2154 2154 self.configurables.append(self.Completer)
2155 2155
2156 2156 # Add custom completers to the basic ones built into IPCompleter
2157 2157 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2158 2158 self.strdispatchers['complete_command'] = sdisp
2159 2159 self.Completer.custom_completers = sdisp
2160 2160
2161 2161 self.set_hook('complete_command', module_completer, str_key = 'import')
2162 2162 self.set_hook('complete_command', module_completer, str_key = 'from')
2163 2163 self.set_hook('complete_command', module_completer, str_key = '%aimport')
2164 2164 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2165 2165 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2166 2166 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2167 2167
2168 2168 @skip_doctest
2169 2169 def complete(self, text, line=None, cursor_pos=None):
2170 2170 """Return the completed text and a list of completions.
2171 2171
2172 2172 Parameters
2173 2173 ----------
2174 2174
2175 2175 text : string
2176 2176 A string of text to be completed on. It can be given as empty and
2177 2177 instead a line/position pair are given. In this case, the
2178 2178 completer itself will split the line like readline does.
2179 2179
2180 2180 line : string, optional
2181 2181 The complete line that text is part of.
2182 2182
2183 2183 cursor_pos : int, optional
2184 2184 The position of the cursor on the input line.
2185 2185
2186 2186 Returns
2187 2187 -------
2188 2188 text : string
2189 2189 The actual text that was completed.
2190 2190
2191 2191 matches : list
2192 2192 A sorted list with all possible completions.
2193 2193
2194 2194 The optional arguments allow the completion to take more context into
2195 2195 account, and are part of the low-level completion API.
2196 2196
2197 2197 This is a wrapper around the completion mechanism, similar to what
2198 2198 readline does at the command line when the TAB key is hit. By
2199 2199 exposing it as a method, it can be used by other non-readline
2200 2200 environments (such as GUIs) for text completion.
2201 2201
2202 2202 Simple usage example:
2203 2203
2204 2204 In [1]: x = 'hello'
2205 2205
2206 2206 In [2]: _ip.complete('x.l')
2207 2207 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2208 2208 """
2209 2209
2210 2210 # Inject names into __builtin__ so we can complete on the added names.
2211 2211 with self.builtin_trap:
2212 2212 return self.Completer.complete(text, line, cursor_pos)
2213 2213
2214 2214 def set_custom_completer(self, completer, pos=0):
2215 2215 """Adds a new custom completer function.
2216 2216
2217 2217 The position argument (defaults to 0) is the index in the completers
2218 2218 list where you want the completer to be inserted."""
2219 2219
2220 2220 newcomp = types.MethodType(completer,self.Completer)
2221 self.Completer.matchers.insert(pos,newcomp)
2221 self.Completer.custom_matchers.insert(pos,newcomp)
2222 2222
2223 2223 def set_completer_frame(self, frame=None):
2224 2224 """Set the frame of the completer."""
2225 2225 if frame:
2226 2226 self.Completer.namespace = frame.f_locals
2227 2227 self.Completer.global_namespace = frame.f_globals
2228 2228 else:
2229 2229 self.Completer.namespace = self.user_ns
2230 2230 self.Completer.global_namespace = self.user_global_ns
2231 2231
2232 2232 #-------------------------------------------------------------------------
2233 2233 # Things related to magics
2234 2234 #-------------------------------------------------------------------------
2235 2235
2236 2236 def init_magics(self):
2237 2237 from IPython.core import magics as m
2238 2238 self.magics_manager = magic.MagicsManager(shell=self,
2239 2239 parent=self,
2240 2240 user_magics=m.UserMagics(self))
2241 2241 self.configurables.append(self.magics_manager)
2242 2242
2243 2243 # Expose as public API from the magics manager
2244 2244 self.register_magics = self.magics_manager.register
2245 2245
2246 2246 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2247 2247 m.ConfigMagics, m.DisplayMagics, m.ExecutionMagics,
2248 2248 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2249 2249 m.NamespaceMagics, m.OSMagics, m.PackagingMagics,
2250 2250 m.PylabMagics, m.ScriptMagics,
2251 2251 )
2252 2252 self.register_magics(m.AsyncMagics)
2253 2253
2254 2254 # Register Magic Aliases
2255 2255 mman = self.magics_manager
2256 2256 # FIXME: magic aliases should be defined by the Magics classes
2257 2257 # or in MagicsManager, not here
2258 2258 mman.register_alias('ed', 'edit')
2259 2259 mman.register_alias('hist', 'history')
2260 2260 mman.register_alias('rep', 'recall')
2261 2261 mman.register_alias('SVG', 'svg', 'cell')
2262 2262 mman.register_alias('HTML', 'html', 'cell')
2263 2263 mman.register_alias('file', 'writefile', 'cell')
2264 2264
2265 2265 # FIXME: Move the color initialization to the DisplayHook, which
2266 2266 # should be split into a prompt manager and displayhook. We probably
2267 2267 # even need a centralize colors management object.
2268 2268 self.run_line_magic('colors', self.colors)
2269 2269
2270 2270 # Defined here so that it's included in the documentation
2271 2271 @functools.wraps(magic.MagicsManager.register_function)
2272 2272 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2273 2273 self.magics_manager.register_function(func,
2274 2274 magic_kind=magic_kind, magic_name=magic_name)
2275 2275
2276 2276 def run_line_magic(self, magic_name, line, _stack_depth=1):
2277 2277 """Execute the given line magic.
2278 2278
2279 2279 Parameters
2280 2280 ----------
2281 2281 magic_name : str
2282 2282 Name of the desired magic function, without '%' prefix.
2283 2283
2284 2284 line : str
2285 2285 The rest of the input line as a single string.
2286 2286
2287 2287 _stack_depth : int
2288 2288 If run_line_magic() is called from magic() then _stack_depth=2.
2289 2289 This is added to ensure backward compatibility for use of 'get_ipython().magic()'
2290 2290 """
2291 2291 fn = self.find_line_magic(magic_name)
2292 2292 if fn is None:
2293 2293 cm = self.find_cell_magic(magic_name)
2294 2294 etpl = "Line magic function `%%%s` not found%s."
2295 2295 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2296 2296 'did you mean that instead?)' % magic_name )
2297 2297 raise UsageError(etpl % (magic_name, extra))
2298 2298 else:
2299 2299 # Note: this is the distance in the stack to the user's frame.
2300 2300 # This will need to be updated if the internal calling logic gets
2301 2301 # refactored, or else we'll be expanding the wrong variables.
2302 2302
2303 2303 # Determine stack_depth depending on where run_line_magic() has been called
2304 2304 stack_depth = _stack_depth
2305 2305 if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
2306 2306 # magic has opted out of var_expand
2307 2307 magic_arg_s = line
2308 2308 else:
2309 2309 magic_arg_s = self.var_expand(line, stack_depth)
2310 2310 # Put magic args in a list so we can call with f(*a) syntax
2311 2311 args = [magic_arg_s]
2312 2312 kwargs = {}
2313 2313 # Grab local namespace if we need it:
2314 2314 if getattr(fn, "needs_local_scope", False):
2315 2315 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2316 2316 with self.builtin_trap:
2317 2317 result = fn(*args, **kwargs)
2318 2318 return result
2319 2319
2320 2320 def run_cell_magic(self, magic_name, line, cell):
2321 2321 """Execute the given cell magic.
2322 2322
2323 2323 Parameters
2324 2324 ----------
2325 2325 magic_name : str
2326 2326 Name of the desired magic function, without '%' prefix.
2327 2327
2328 2328 line : str
2329 2329 The rest of the first input line as a single string.
2330 2330
2331 2331 cell : str
2332 2332 The body of the cell as a (possibly multiline) string.
2333 2333 """
2334 2334 fn = self.find_cell_magic(magic_name)
2335 2335 if fn is None:
2336 2336 lm = self.find_line_magic(magic_name)
2337 2337 etpl = "Cell magic `%%{0}` not found{1}."
2338 2338 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2339 2339 'did you mean that instead?)'.format(magic_name))
2340 2340 raise UsageError(etpl.format(magic_name, extra))
2341 2341 elif cell == '':
2342 2342 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2343 2343 if self.find_line_magic(magic_name) is not None:
2344 2344 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2345 2345 raise UsageError(message)
2346 2346 else:
2347 2347 # Note: this is the distance in the stack to the user's frame.
2348 2348 # This will need to be updated if the internal calling logic gets
2349 2349 # refactored, or else we'll be expanding the wrong variables.
2350 2350 stack_depth = 2
2351 2351 if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
2352 2352 # magic has opted out of var_expand
2353 2353 magic_arg_s = line
2354 2354 else:
2355 2355 magic_arg_s = self.var_expand(line, stack_depth)
2356 2356 kwargs = {}
2357 2357 if getattr(fn, "needs_local_scope", False):
2358 2358 kwargs['local_ns'] = self.user_ns
2359 2359
2360 2360 with self.builtin_trap:
2361 2361 args = (magic_arg_s, cell)
2362 2362 result = fn(*args, **kwargs)
2363 2363 return result
2364 2364
2365 2365 def find_line_magic(self, magic_name):
2366 2366 """Find and return a line magic by name.
2367 2367
2368 2368 Returns None if the magic isn't found."""
2369 2369 return self.magics_manager.magics['line'].get(magic_name)
2370 2370
2371 2371 def find_cell_magic(self, magic_name):
2372 2372 """Find and return a cell magic by name.
2373 2373
2374 2374 Returns None if the magic isn't found."""
2375 2375 return self.magics_manager.magics['cell'].get(magic_name)
2376 2376
2377 2377 def find_magic(self, magic_name, magic_kind='line'):
2378 2378 """Find and return a magic of the given type by name.
2379 2379
2380 2380 Returns None if the magic isn't found."""
2381 2381 return self.magics_manager.magics[magic_kind].get(magic_name)
2382 2382
2383 2383 def magic(self, arg_s):
2384 2384 """DEPRECATED. Use run_line_magic() instead.
2385 2385
2386 2386 Call a magic function by name.
2387 2387
2388 2388 Input: a string containing the name of the magic function to call and
2389 2389 any additional arguments to be passed to the magic.
2390 2390
2391 2391 magic('name -opt foo bar') is equivalent to typing at the ipython
2392 2392 prompt:
2393 2393
2394 2394 In[1]: %name -opt foo bar
2395 2395
2396 2396 To call a magic without arguments, simply use magic('name').
2397 2397
2398 2398 This provides a proper Python function to call IPython's magics in any
2399 2399 valid Python code you can type at the interpreter, including loops and
2400 2400 compound statements.
2401 2401 """
2402 2402 # TODO: should we issue a loud deprecation warning here?
2403 2403 magic_name, _, magic_arg_s = arg_s.partition(' ')
2404 2404 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2405 2405 return self.run_line_magic(magic_name, magic_arg_s, _stack_depth=2)
2406 2406
2407 2407 #-------------------------------------------------------------------------
2408 2408 # Things related to macros
2409 2409 #-------------------------------------------------------------------------
2410 2410
2411 2411 def define_macro(self, name, themacro):
2412 2412 """Define a new macro
2413 2413
2414 2414 Parameters
2415 2415 ----------
2416 2416 name : str
2417 2417 The name of the macro.
2418 2418 themacro : str or Macro
2419 2419 The action to do upon invoking the macro. If a string, a new
2420 2420 Macro object is created by passing the string to it.
2421 2421 """
2422 2422
2423 2423 from IPython.core import macro
2424 2424
2425 2425 if isinstance(themacro, str):
2426 2426 themacro = macro.Macro(themacro)
2427 2427 if not isinstance(themacro, macro.Macro):
2428 2428 raise ValueError('A macro must be a string or a Macro instance.')
2429 2429 self.user_ns[name] = themacro
2430 2430
2431 2431 #-------------------------------------------------------------------------
2432 2432 # Things related to the running of system commands
2433 2433 #-------------------------------------------------------------------------
2434 2434
2435 2435 def system_piped(self, cmd):
2436 2436 """Call the given cmd in a subprocess, piping stdout/err
2437 2437
2438 2438 Parameters
2439 2439 ----------
2440 2440 cmd : str
2441 2441 Command to execute (can not end in '&', as background processes are
2442 2442 not supported. Should not be a command that expects input
2443 2443 other than simple text.
2444 2444 """
2445 2445 if cmd.rstrip().endswith('&'):
2446 2446 # this is *far* from a rigorous test
2447 2447 # We do not support backgrounding processes because we either use
2448 2448 # pexpect or pipes to read from. Users can always just call
2449 2449 # os.system() or use ip.system=ip.system_raw
2450 2450 # if they really want a background process.
2451 2451 raise OSError("Background processes not supported.")
2452 2452
2453 2453 # we explicitly do NOT return the subprocess status code, because
2454 2454 # a non-None value would trigger :func:`sys.displayhook` calls.
2455 2455 # Instead, we store the exit_code in user_ns.
2456 2456 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2457 2457
2458 2458 def system_raw(self, cmd):
2459 2459 """Call the given cmd in a subprocess using os.system on Windows or
2460 2460 subprocess.call using the system shell on other platforms.
2461 2461
2462 2462 Parameters
2463 2463 ----------
2464 2464 cmd : str
2465 2465 Command to execute.
2466 2466 """
2467 2467 cmd = self.var_expand(cmd, depth=1)
2468 2468 # protect os.system from UNC paths on Windows, which it can't handle:
2469 2469 if sys.platform == 'win32':
2470 2470 from IPython.utils._process_win32 import AvoidUNCPath
2471 2471 with AvoidUNCPath() as path:
2472 2472 if path is not None:
2473 2473 cmd = '"pushd %s &&"%s' % (path, cmd)
2474 2474 try:
2475 2475 ec = os.system(cmd)
2476 2476 except KeyboardInterrupt:
2477 2477 print('\n' + self.get_exception_only(), file=sys.stderr)
2478 2478 ec = -2
2479 2479 else:
2480 2480 # For posix the result of the subprocess.call() below is an exit
2481 2481 # code, which by convention is zero for success, positive for
2482 2482 # program failure. Exit codes above 128 are reserved for signals,
2483 2483 # and the formula for converting a signal to an exit code is usually
2484 2484 # signal_number+128. To more easily differentiate between exit
2485 2485 # codes and signals, ipython uses negative numbers. For instance
2486 2486 # since control-c is signal 2 but exit code 130, ipython's
2487 2487 # _exit_code variable will read -2. Note that some shells like
2488 2488 # csh and fish don't follow sh/bash conventions for exit codes.
2489 2489 executable = os.environ.get('SHELL', None)
2490 2490 try:
2491 2491 # Use env shell instead of default /bin/sh
2492 2492 ec = subprocess.call(cmd, shell=True, executable=executable)
2493 2493 except KeyboardInterrupt:
2494 2494 # intercept control-C; a long traceback is not useful here
2495 2495 print('\n' + self.get_exception_only(), file=sys.stderr)
2496 2496 ec = 130
2497 2497 if ec > 128:
2498 2498 ec = -(ec - 128)
2499 2499
2500 2500 # We explicitly do NOT return the subprocess status code, because
2501 2501 # a non-None value would trigger :func:`sys.displayhook` calls.
2502 2502 # Instead, we store the exit_code in user_ns. Note the semantics
2503 2503 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2504 2504 # but raising SystemExit(_exit_code) will give status 254!
2505 2505 self.user_ns['_exit_code'] = ec
2506 2506
2507 2507 # use piped system by default, because it is better behaved
2508 2508 system = system_piped
2509 2509
2510 2510 def getoutput(self, cmd, split=True, depth=0):
2511 2511 """Get output (possibly including stderr) from a subprocess.
2512 2512
2513 2513 Parameters
2514 2514 ----------
2515 2515 cmd : str
2516 2516 Command to execute (can not end in '&', as background processes are
2517 2517 not supported.
2518 2518 split : bool, optional
2519 2519 If True, split the output into an IPython SList. Otherwise, an
2520 2520 IPython LSString is returned. These are objects similar to normal
2521 2521 lists and strings, with a few convenience attributes for easier
2522 2522 manipulation of line-based output. You can use '?' on them for
2523 2523 details.
2524 2524 depth : int, optional
2525 2525 How many frames above the caller are the local variables which should
2526 2526 be expanded in the command string? The default (0) assumes that the
2527 2527 expansion variables are in the stack frame calling this function.
2528 2528 """
2529 2529 if cmd.rstrip().endswith('&'):
2530 2530 # this is *far* from a rigorous test
2531 2531 raise OSError("Background processes not supported.")
2532 2532 out = getoutput(self.var_expand(cmd, depth=depth+1))
2533 2533 if split:
2534 2534 out = SList(out.splitlines())
2535 2535 else:
2536 2536 out = LSString(out)
2537 2537 return out
2538 2538
2539 2539 #-------------------------------------------------------------------------
2540 2540 # Things related to aliases
2541 2541 #-------------------------------------------------------------------------
2542 2542
2543 2543 def init_alias(self):
2544 2544 self.alias_manager = AliasManager(shell=self, parent=self)
2545 2545 self.configurables.append(self.alias_manager)
2546 2546
2547 2547 #-------------------------------------------------------------------------
2548 2548 # Things related to extensions
2549 2549 #-------------------------------------------------------------------------
2550 2550
2551 2551 def init_extension_manager(self):
2552 2552 self.extension_manager = ExtensionManager(shell=self, parent=self)
2553 2553 self.configurables.append(self.extension_manager)
2554 2554
2555 2555 #-------------------------------------------------------------------------
2556 2556 # Things related to payloads
2557 2557 #-------------------------------------------------------------------------
2558 2558
2559 2559 def init_payload(self):
2560 2560 self.payload_manager = PayloadManager(parent=self)
2561 2561 self.configurables.append(self.payload_manager)
2562 2562
2563 2563 #-------------------------------------------------------------------------
2564 2564 # Things related to the prefilter
2565 2565 #-------------------------------------------------------------------------
2566 2566
2567 2567 def init_prefilter(self):
2568 2568 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2569 2569 self.configurables.append(self.prefilter_manager)
2570 2570 # Ultimately this will be refactored in the new interpreter code, but
2571 2571 # for now, we should expose the main prefilter method (there's legacy
2572 2572 # code out there that may rely on this).
2573 2573 self.prefilter = self.prefilter_manager.prefilter_lines
2574 2574
2575 2575 def auto_rewrite_input(self, cmd):
2576 2576 """Print to the screen the rewritten form of the user's command.
2577 2577
2578 2578 This shows visual feedback by rewriting input lines that cause
2579 2579 automatic calling to kick in, like::
2580 2580
2581 2581 /f x
2582 2582
2583 2583 into::
2584 2584
2585 2585 ------> f(x)
2586 2586
2587 2587 after the user's input prompt. This helps the user understand that the
2588 2588 input line was transformed automatically by IPython.
2589 2589 """
2590 2590 if not self.show_rewritten_input:
2591 2591 return
2592 2592
2593 2593 # This is overridden in TerminalInteractiveShell to use fancy prompts
2594 2594 print("------> " + cmd)
2595 2595
2596 2596 #-------------------------------------------------------------------------
2597 2597 # Things related to extracting values/expressions from kernel and user_ns
2598 2598 #-------------------------------------------------------------------------
2599 2599
2600 2600 def _user_obj_error(self):
2601 2601 """return simple exception dict
2602 2602
2603 2603 for use in user_expressions
2604 2604 """
2605 2605
2606 2606 etype, evalue, tb = self._get_exc_info()
2607 2607 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2608 2608
2609 2609 exc_info = {
2610 2610 u'status' : 'error',
2611 2611 u'traceback' : stb,
2612 2612 u'ename' : etype.__name__,
2613 2613 u'evalue' : py3compat.safe_unicode(evalue),
2614 2614 }
2615 2615
2616 2616 return exc_info
2617 2617
2618 2618 def _format_user_obj(self, obj):
2619 2619 """format a user object to display dict
2620 2620
2621 2621 for use in user_expressions
2622 2622 """
2623 2623
2624 2624 data, md = self.display_formatter.format(obj)
2625 2625 value = {
2626 2626 'status' : 'ok',
2627 2627 'data' : data,
2628 2628 'metadata' : md,
2629 2629 }
2630 2630 return value
2631 2631
2632 2632 def user_expressions(self, expressions):
2633 2633 """Evaluate a dict of expressions in the user's namespace.
2634 2634
2635 2635 Parameters
2636 2636 ----------
2637 2637 expressions : dict
2638 2638 A dict with string keys and string values. The expression values
2639 2639 should be valid Python expressions, each of which will be evaluated
2640 2640 in the user namespace.
2641 2641
2642 2642 Returns
2643 2643 -------
2644 2644 A dict, keyed like the input expressions dict, with the rich mime-typed
2645 2645 display_data of each value.
2646 2646 """
2647 2647 out = {}
2648 2648 user_ns = self.user_ns
2649 2649 global_ns = self.user_global_ns
2650 2650
2651 2651 for key, expr in expressions.items():
2652 2652 try:
2653 2653 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2654 2654 except:
2655 2655 value = self._user_obj_error()
2656 2656 out[key] = value
2657 2657 return out
2658 2658
2659 2659 #-------------------------------------------------------------------------
2660 2660 # Things related to the running of code
2661 2661 #-------------------------------------------------------------------------
2662 2662
2663 2663 def ex(self, cmd):
2664 2664 """Execute a normal python statement in user namespace."""
2665 2665 with self.builtin_trap:
2666 2666 exec(cmd, self.user_global_ns, self.user_ns)
2667 2667
2668 2668 def ev(self, expr):
2669 2669 """Evaluate python expression expr in user namespace.
2670 2670
2671 2671 Returns the result of evaluation
2672 2672 """
2673 2673 with self.builtin_trap:
2674 2674 return eval(expr, self.user_global_ns, self.user_ns)
2675 2675
2676 2676 def safe_execfile(self, fname, *where, exit_ignore=False, raise_exceptions=False, shell_futures=False):
2677 2677 """A safe version of the builtin execfile().
2678 2678
2679 2679 This version will never throw an exception, but instead print
2680 2680 helpful error messages to the screen. This only works on pure
2681 2681 Python files with the .py extension.
2682 2682
2683 2683 Parameters
2684 2684 ----------
2685 2685 fname : string
2686 2686 The name of the file to be executed.
2687 2687 where : tuple
2688 2688 One or two namespaces, passed to execfile() as (globals,locals).
2689 2689 If only one is given, it is passed as both.
2690 2690 exit_ignore : bool (False)
2691 2691 If True, then silence SystemExit for non-zero status (it is always
2692 2692 silenced for zero status, as it is so common).
2693 2693 raise_exceptions : bool (False)
2694 2694 If True raise exceptions everywhere. Meant for testing.
2695 2695 shell_futures : bool (False)
2696 2696 If True, the code will share future statements with the interactive
2697 2697 shell. It will both be affected by previous __future__ imports, and
2698 2698 any __future__ imports in the code will affect the shell. If False,
2699 2699 __future__ imports are not shared in either direction.
2700 2700
2701 2701 """
2702 2702 fname = os.path.abspath(os.path.expanduser(fname))
2703 2703
2704 2704 # Make sure we can open the file
2705 2705 try:
2706 2706 with open(fname):
2707 2707 pass
2708 2708 except:
2709 2709 warn('Could not open file <%s> for safe execution.' % fname)
2710 2710 return
2711 2711
2712 2712 # Find things also in current directory. This is needed to mimic the
2713 2713 # behavior of running a script from the system command line, where
2714 2714 # Python inserts the script's directory into sys.path
2715 2715 dname = os.path.dirname(fname)
2716 2716
2717 2717 with prepended_to_syspath(dname), self.builtin_trap:
2718 2718 try:
2719 2719 glob, loc = (where + (None, ))[:2]
2720 2720 py3compat.execfile(
2721 2721 fname, glob, loc,
2722 2722 self.compile if shell_futures else None)
2723 2723 except SystemExit as status:
2724 2724 # If the call was made with 0 or None exit status (sys.exit(0)
2725 2725 # or sys.exit() ), don't bother showing a traceback, as both of
2726 2726 # these are considered normal by the OS:
2727 2727 # > python -c'import sys;sys.exit(0)'; echo $?
2728 2728 # 0
2729 2729 # > python -c'import sys;sys.exit()'; echo $?
2730 2730 # 0
2731 2731 # For other exit status, we show the exception unless
2732 2732 # explicitly silenced, but only in short form.
2733 2733 if status.code:
2734 2734 if raise_exceptions:
2735 2735 raise
2736 2736 if not exit_ignore:
2737 2737 self.showtraceback(exception_only=True)
2738 2738 except:
2739 2739 if raise_exceptions:
2740 2740 raise
2741 2741 # tb offset is 2 because we wrap execfile
2742 2742 self.showtraceback(tb_offset=2)
2743 2743
2744 2744 def safe_execfile_ipy(self, fname, shell_futures=False, raise_exceptions=False):
2745 2745 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2746 2746
2747 2747 Parameters
2748 2748 ----------
2749 2749 fname : str
2750 2750 The name of the file to execute. The filename must have a
2751 2751 .ipy or .ipynb extension.
2752 2752 shell_futures : bool (False)
2753 2753 If True, the code will share future statements with the interactive
2754 2754 shell. It will both be affected by previous __future__ imports, and
2755 2755 any __future__ imports in the code will affect the shell. If False,
2756 2756 __future__ imports are not shared in either direction.
2757 2757 raise_exceptions : bool (False)
2758 2758 If True raise exceptions everywhere. Meant for testing.
2759 2759 """
2760 2760 fname = os.path.abspath(os.path.expanduser(fname))
2761 2761
2762 2762 # Make sure we can open the file
2763 2763 try:
2764 2764 with open(fname):
2765 2765 pass
2766 2766 except:
2767 2767 warn('Could not open file <%s> for safe execution.' % fname)
2768 2768 return
2769 2769
2770 2770 # Find things also in current directory. This is needed to mimic the
2771 2771 # behavior of running a script from the system command line, where
2772 2772 # Python inserts the script's directory into sys.path
2773 2773 dname = os.path.dirname(fname)
2774 2774
2775 2775 def get_cells():
2776 2776 """generator for sequence of code blocks to run"""
2777 2777 if fname.endswith('.ipynb'):
2778 2778 from nbformat import read
2779 2779 nb = read(fname, as_version=4)
2780 2780 if not nb.cells:
2781 2781 return
2782 2782 for cell in nb.cells:
2783 2783 if cell.cell_type == 'code':
2784 2784 yield cell.source
2785 2785 else:
2786 2786 with open(fname) as f:
2787 2787 yield f.read()
2788 2788
2789 2789 with prepended_to_syspath(dname):
2790 2790 try:
2791 2791 for cell in get_cells():
2792 2792 result = self.run_cell(cell, silent=True, shell_futures=shell_futures)
2793 2793 if raise_exceptions:
2794 2794 result.raise_error()
2795 2795 elif not result.success:
2796 2796 break
2797 2797 except:
2798 2798 if raise_exceptions:
2799 2799 raise
2800 2800 self.showtraceback()
2801 2801 warn('Unknown failure executing file: <%s>' % fname)
2802 2802
2803 2803 def safe_run_module(self, mod_name, where):
2804 2804 """A safe version of runpy.run_module().
2805 2805
2806 2806 This version will never throw an exception, but instead print
2807 2807 helpful error messages to the screen.
2808 2808
2809 2809 `SystemExit` exceptions with status code 0 or None are ignored.
2810 2810
2811 2811 Parameters
2812 2812 ----------
2813 2813 mod_name : string
2814 2814 The name of the module to be executed.
2815 2815 where : dict
2816 2816 The globals namespace.
2817 2817 """
2818 2818 try:
2819 2819 try:
2820 2820 where.update(
2821 2821 runpy.run_module(str(mod_name), run_name="__main__",
2822 2822 alter_sys=True)
2823 2823 )
2824 2824 except SystemExit as status:
2825 2825 if status.code:
2826 2826 raise
2827 2827 except:
2828 2828 self.showtraceback()
2829 2829 warn('Unknown failure executing module: <%s>' % mod_name)
2830 2830
2831 2831 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2832 2832 """Run a complete IPython cell.
2833 2833
2834 2834 Parameters
2835 2835 ----------
2836 2836 raw_cell : str
2837 2837 The code (including IPython code such as %magic functions) to run.
2838 2838 store_history : bool
2839 2839 If True, the raw and translated cell will be stored in IPython's
2840 2840 history. For user code calling back into IPython's machinery, this
2841 2841 should be set to False.
2842 2842 silent : bool
2843 2843 If True, avoid side-effects, such as implicit displayhooks and
2844 2844 and logging. silent=True forces store_history=False.
2845 2845 shell_futures : bool
2846 2846 If True, the code will share future statements with the interactive
2847 2847 shell. It will both be affected by previous __future__ imports, and
2848 2848 any __future__ imports in the code will affect the shell. If False,
2849 2849 __future__ imports are not shared in either direction.
2850 2850
2851 2851 Returns
2852 2852 -------
2853 2853 result : :class:`ExecutionResult`
2854 2854 """
2855 2855 result = None
2856 2856 try:
2857 2857 result = self._run_cell(
2858 2858 raw_cell, store_history, silent, shell_futures)
2859 2859 finally:
2860 2860 self.events.trigger('post_execute')
2861 2861 if not silent:
2862 2862 self.events.trigger('post_run_cell', result)
2863 2863 return result
2864 2864
2865 2865 def _run_cell(self, raw_cell:str, store_history:bool, silent:bool, shell_futures:bool):
2866 2866 """Internal method to run a complete IPython cell."""
2867 2867 coro = self.run_cell_async(
2868 2868 raw_cell,
2869 2869 store_history=store_history,
2870 2870 silent=silent,
2871 2871 shell_futures=shell_futures,
2872 2872 )
2873 2873
2874 2874 # run_cell_async is async, but may not actually need an eventloop.
2875 2875 # when this is the case, we want to run it using the pseudo_sync_runner
2876 2876 # so that code can invoke eventloops (for example via the %run , and
2877 2877 # `%paste` magic.
2878 2878 if self.trio_runner:
2879 2879 runner = self.trio_runner
2880 2880 elif self.should_run_async(raw_cell):
2881 2881 runner = self.loop_runner
2882 2882 else:
2883 2883 runner = _pseudo_sync_runner
2884 2884
2885 2885 try:
2886 2886 return runner(coro)
2887 2887 except BaseException as e:
2888 2888 info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
2889 2889 result = ExecutionResult(info)
2890 2890 result.error_in_exec = e
2891 2891 self.showtraceback(running_compiled_code=True)
2892 2892 return result
2893 2893 return
2894 2894
2895 2895 def should_run_async(self, raw_cell: str) -> bool:
2896 2896 """Return whether a cell should be run asynchronously via a coroutine runner
2897 2897
2898 2898 Parameters
2899 2899 ----------
2900 2900 raw_cell: str
2901 2901 The code to be executed
2902 2902
2903 2903 Returns
2904 2904 -------
2905 2905 result: bool
2906 2906 Whether the code needs to be run with a coroutine runner or not
2907 2907
2908 2908 .. versionadded: 7.0
2909 2909 """
2910 2910 if not self.autoawait:
2911 2911 return False
2912 2912 try:
2913 2913 cell = self.transform_cell(raw_cell)
2914 2914 except Exception:
2915 2915 # any exception during transform will be raised
2916 2916 # prior to execution
2917 2917 return False
2918 2918 return _should_be_async(cell)
2919 2919
2920 2920 async def run_cell_async(self, raw_cell: str, store_history=False, silent=False, shell_futures=True) -> ExecutionResult:
2921 2921 """Run a complete IPython cell asynchronously.
2922 2922
2923 2923 Parameters
2924 2924 ----------
2925 2925 raw_cell : str
2926 2926 The code (including IPython code such as %magic functions) to run.
2927 2927 store_history : bool
2928 2928 If True, the raw and translated cell will be stored in IPython's
2929 2929 history. For user code calling back into IPython's machinery, this
2930 2930 should be set to False.
2931 2931 silent : bool
2932 2932 If True, avoid side-effects, such as implicit displayhooks and
2933 2933 and logging. silent=True forces store_history=False.
2934 2934 shell_futures : bool
2935 2935 If True, the code will share future statements with the interactive
2936 2936 shell. It will both be affected by previous __future__ imports, and
2937 2937 any __future__ imports in the code will affect the shell. If False,
2938 2938 __future__ imports are not shared in either direction.
2939 2939
2940 2940 Returns
2941 2941 -------
2942 2942 result : :class:`ExecutionResult`
2943 2943
2944 2944 .. versionadded: 7.0
2945 2945 """
2946 2946 info = ExecutionInfo(
2947 2947 raw_cell, store_history, silent, shell_futures)
2948 2948 result = ExecutionResult(info)
2949 2949
2950 2950 if (not raw_cell) or raw_cell.isspace():
2951 2951 self.last_execution_succeeded = True
2952 2952 self.last_execution_result = result
2953 2953 return result
2954 2954
2955 2955 if silent:
2956 2956 store_history = False
2957 2957
2958 2958 if store_history:
2959 2959 result.execution_count = self.execution_count
2960 2960
2961 2961 def error_before_exec(value):
2962 2962 if store_history:
2963 2963 self.execution_count += 1
2964 2964 result.error_before_exec = value
2965 2965 self.last_execution_succeeded = False
2966 2966 self.last_execution_result = result
2967 2967 return result
2968 2968
2969 2969 self.events.trigger('pre_execute')
2970 2970 if not silent:
2971 2971 self.events.trigger('pre_run_cell', info)
2972 2972
2973 2973 # If any of our input transformation (input_transformer_manager or
2974 2974 # prefilter_manager) raises an exception, we store it in this variable
2975 2975 # so that we can display the error after logging the input and storing
2976 2976 # it in the history.
2977 2977 try:
2978 2978 cell = self.transform_cell(raw_cell)
2979 2979 except Exception:
2980 2980 preprocessing_exc_tuple = sys.exc_info()
2981 2981 cell = raw_cell # cell has to exist so it can be stored/logged
2982 2982 else:
2983 2983 preprocessing_exc_tuple = None
2984 2984
2985 2985 # Store raw and processed history
2986 2986 if store_history:
2987 2987 self.history_manager.store_inputs(self.execution_count,
2988 2988 cell, raw_cell)
2989 2989 if not silent:
2990 2990 self.logger.log(cell, raw_cell)
2991 2991
2992 2992 # Display the exception if input processing failed.
2993 2993 if preprocessing_exc_tuple is not None:
2994 2994 self.showtraceback(preprocessing_exc_tuple)
2995 2995 if store_history:
2996 2996 self.execution_count += 1
2997 2997 return error_before_exec(preprocessing_exc_tuple[1])
2998 2998
2999 2999 # Our own compiler remembers the __future__ environment. If we want to
3000 3000 # run code with a separate __future__ environment, use the default
3001 3001 # compiler
3002 3002 compiler = self.compile if shell_futures else CachingCompiler()
3003 3003
3004 3004 _run_async = False
3005 3005
3006 3006 with self.builtin_trap:
3007 3007 cell_name = self.compile.cache(cell, self.execution_count)
3008 3008
3009 3009 with self.display_trap:
3010 3010 # Compile to bytecode
3011 3011 try:
3012 3012 if sys.version_info < (3,8) and self.autoawait:
3013 3013 if _should_be_async(cell):
3014 3014 # the code AST below will not be user code: we wrap it
3015 3015 # in an `async def`. This will likely make some AST
3016 3016 # transformer below miss some transform opportunity and
3017 3017 # introduce a small coupling to run_code (in which we
3018 3018 # bake some assumptions of what _ast_asyncify returns.
3019 3019 # they are ways around (like grafting part of the ast
3020 3020 # later:
3021 3021 # - Here, return code_ast.body[0].body[1:-1], as well
3022 3022 # as last expression in return statement which is
3023 3023 # the user code part.
3024 3024 # - Let it go through the AST transformers, and graft
3025 3025 # - it back after the AST transform
3026 3026 # But that seem unreasonable, at least while we
3027 3027 # do not need it.
3028 3028 code_ast = _ast_asyncify(cell, 'async-def-wrapper')
3029 3029 _run_async = True
3030 3030 else:
3031 3031 code_ast = compiler.ast_parse(cell, filename=cell_name)
3032 3032 else:
3033 3033 code_ast = compiler.ast_parse(cell, filename=cell_name)
3034 3034 except self.custom_exceptions as e:
3035 3035 etype, value, tb = sys.exc_info()
3036 3036 self.CustomTB(etype, value, tb)
3037 3037 return error_before_exec(e)
3038 3038 except IndentationError as e:
3039 3039 self.showindentationerror()
3040 3040 return error_before_exec(e)
3041 3041 except (OverflowError, SyntaxError, ValueError, TypeError,
3042 3042 MemoryError) as e:
3043 3043 self.showsyntaxerror()
3044 3044 return error_before_exec(e)
3045 3045
3046 3046 # Apply AST transformations
3047 3047 try:
3048 3048 code_ast = self.transform_ast(code_ast)
3049 3049 except InputRejected as e:
3050 3050 self.showtraceback()
3051 3051 return error_before_exec(e)
3052 3052
3053 3053 # Give the displayhook a reference to our ExecutionResult so it
3054 3054 # can fill in the output value.
3055 3055 self.displayhook.exec_result = result
3056 3056
3057 3057 # Execute the user code
3058 3058 interactivity = "none" if silent else self.ast_node_interactivity
3059 3059 if _run_async:
3060 3060 interactivity = 'async'
3061 3061
3062 3062 has_raised = await self.run_ast_nodes(code_ast.body, cell_name,
3063 3063 interactivity=interactivity, compiler=compiler, result=result)
3064 3064
3065 3065 self.last_execution_succeeded = not has_raised
3066 3066 self.last_execution_result = result
3067 3067
3068 3068 # Reset this so later displayed values do not modify the
3069 3069 # ExecutionResult
3070 3070 self.displayhook.exec_result = None
3071 3071
3072 3072 if store_history:
3073 3073 # Write output to the database. Does nothing unless
3074 3074 # history output logging is enabled.
3075 3075 self.history_manager.store_output(self.execution_count)
3076 3076 # Each cell is a *single* input, regardless of how many lines it has
3077 3077 self.execution_count += 1
3078 3078
3079 3079 return result
3080 3080
3081 3081 def transform_cell(self, raw_cell):
3082 3082 """Transform an input cell before parsing it.
3083 3083
3084 3084 Static transformations, implemented in IPython.core.inputtransformer2,
3085 3085 deal with things like ``%magic`` and ``!system`` commands.
3086 3086 These run on all input.
3087 3087 Dynamic transformations, for things like unescaped magics and the exit
3088 3088 autocall, depend on the state of the interpreter.
3089 3089 These only apply to single line inputs.
3090 3090
3091 3091 These string-based transformations are followed by AST transformations;
3092 3092 see :meth:`transform_ast`.
3093 3093 """
3094 3094 # Static input transformations
3095 3095 cell = self.input_transformer_manager.transform_cell(raw_cell)
3096 3096
3097 3097 if len(cell.splitlines()) == 1:
3098 3098 # Dynamic transformations - only applied for single line commands
3099 3099 with self.builtin_trap:
3100 3100 # use prefilter_lines to handle trailing newlines
3101 3101 # restore trailing newline for ast.parse
3102 3102 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
3103 3103
3104 3104 lines = cell.splitlines(keepends=True)
3105 3105 for transform in self.input_transformers_post:
3106 3106 lines = transform(lines)
3107 3107 cell = ''.join(lines)
3108 3108
3109 3109 return cell
3110 3110
3111 3111 def transform_ast(self, node):
3112 3112 """Apply the AST transformations from self.ast_transformers
3113 3113
3114 3114 Parameters
3115 3115 ----------
3116 3116 node : ast.Node
3117 3117 The root node to be transformed. Typically called with the ast.Module
3118 3118 produced by parsing user input.
3119 3119
3120 3120 Returns
3121 3121 -------
3122 3122 An ast.Node corresponding to the node it was called with. Note that it
3123 3123 may also modify the passed object, so don't rely on references to the
3124 3124 original AST.
3125 3125 """
3126 3126 for transformer in self.ast_transformers:
3127 3127 try:
3128 3128 node = transformer.visit(node)
3129 3129 except InputRejected:
3130 3130 # User-supplied AST transformers can reject an input by raising
3131 3131 # an InputRejected. Short-circuit in this case so that we
3132 3132 # don't unregister the transform.
3133 3133 raise
3134 3134 except Exception:
3135 3135 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
3136 3136 self.ast_transformers.remove(transformer)
3137 3137
3138 3138 if self.ast_transformers:
3139 3139 ast.fix_missing_locations(node)
3140 3140 return node
3141 3141
3142 3142 async def run_ast_nodes(self, nodelist:ListType[AST], cell_name:str, interactivity='last_expr',
3143 3143 compiler=compile, result=None):
3144 3144 """Run a sequence of AST nodes. The execution mode depends on the
3145 3145 interactivity parameter.
3146 3146
3147 3147 Parameters
3148 3148 ----------
3149 3149 nodelist : list
3150 3150 A sequence of AST nodes to run.
3151 3151 cell_name : str
3152 3152 Will be passed to the compiler as the filename of the cell. Typically
3153 3153 the value returned by ip.compile.cache(cell).
3154 3154 interactivity : str
3155 3155 'all', 'last', 'last_expr' , 'last_expr_or_assign' or 'none',
3156 3156 specifying which nodes should be run interactively (displaying output
3157 3157 from expressions). 'last_expr' will run the last node interactively
3158 3158 only if it is an expression (i.e. expressions in loops or other blocks
3159 3159 are not displayed) 'last_expr_or_assign' will run the last expression
3160 3160 or the last assignment. Other values for this parameter will raise a
3161 3161 ValueError.
3162 3162
3163 3163 Experimental value: 'async' Will try to run top level interactive
3164 3164 async/await code in default runner, this will not respect the
3165 3165 interactivity setting and will only run the last node if it is an
3166 3166 expression.
3167 3167
3168 3168 compiler : callable
3169 3169 A function with the same interface as the built-in compile(), to turn
3170 3170 the AST nodes into code objects. Default is the built-in compile().
3171 3171 result : ExecutionResult, optional
3172 3172 An object to store exceptions that occur during execution.
3173 3173
3174 3174 Returns
3175 3175 -------
3176 3176 True if an exception occurred while running code, False if it finished
3177 3177 running.
3178 3178 """
3179 3179 if not nodelist:
3180 3180 return
3181 3181
3182 3182 if interactivity == 'last_expr_or_assign':
3183 3183 if isinstance(nodelist[-1], _assign_nodes):
3184 3184 asg = nodelist[-1]
3185 3185 if isinstance(asg, ast.Assign) and len(asg.targets) == 1:
3186 3186 target = asg.targets[0]
3187 3187 elif isinstance(asg, _single_targets_nodes):
3188 3188 target = asg.target
3189 3189 else:
3190 3190 target = None
3191 3191 if isinstance(target, ast.Name):
3192 3192 nnode = ast.Expr(ast.Name(target.id, ast.Load()))
3193 3193 ast.fix_missing_locations(nnode)
3194 3194 nodelist.append(nnode)
3195 3195 interactivity = 'last_expr'
3196 3196
3197 3197 _async = False
3198 3198 if interactivity == 'last_expr':
3199 3199 if isinstance(nodelist[-1], ast.Expr):
3200 3200 interactivity = "last"
3201 3201 else:
3202 3202 interactivity = "none"
3203 3203
3204 3204 if interactivity == 'none':
3205 3205 to_run_exec, to_run_interactive = nodelist, []
3206 3206 elif interactivity == 'last':
3207 3207 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
3208 3208 elif interactivity == 'all':
3209 3209 to_run_exec, to_run_interactive = [], nodelist
3210 3210 elif interactivity == 'async':
3211 3211 to_run_exec, to_run_interactive = [], nodelist
3212 3212 _async = True
3213 3213 else:
3214 3214 raise ValueError("Interactivity was %r" % interactivity)
3215 3215
3216 3216 try:
3217 3217 if _async and sys.version_info > (3,8):
3218 3218 raise ValueError("This branch should never happen on Python 3.8 and above, "
3219 3219 "please try to upgrade IPython and open a bug report with your case.")
3220 3220 if _async:
3221 3221 # If interactivity is async the semantics of run_code are
3222 3222 # completely different Skip usual machinery.
3223 3223 mod = Module(nodelist, [])
3224 3224 async_wrapper_code = compiler(mod, cell_name, 'exec')
3225 3225 exec(async_wrapper_code, self.user_global_ns, self.user_ns)
3226 3226 async_code = removed_co_newlocals(self.user_ns.pop('async-def-wrapper')).__code__
3227 3227 if (await self.run_code(async_code, result, async_=True)):
3228 3228 return True
3229 3229 else:
3230 3230 if sys.version_info > (3, 8):
3231 3231 def compare(code):
3232 3232 is_async = (inspect.CO_COROUTINE & code.co_flags == inspect.CO_COROUTINE)
3233 3233 return is_async
3234 3234 else:
3235 3235 def compare(code):
3236 3236 return _async
3237 3237
3238 3238 # refactor that to just change the mod constructor.
3239 3239 to_run = []
3240 3240 for node in to_run_exec:
3241 3241 to_run.append((node, 'exec'))
3242 3242
3243 3243 for node in to_run_interactive:
3244 3244 to_run.append((node, 'single'))
3245 3245
3246 3246 for node,mode in to_run:
3247 3247 if mode == 'exec':
3248 3248 mod = Module([node], [])
3249 3249 elif mode == 'single':
3250 3250 mod = ast.Interactive([node])
3251 3251 with compiler.extra_flags(getattr(ast, 'PyCF_ALLOW_TOP_LEVEL_AWAIT', 0x0) if self.autoawait else 0x0):
3252 3252 code = compiler(mod, cell_name, mode)
3253 3253 asy = compare(code)
3254 3254 if (await self.run_code(code, result, async_=asy)):
3255 3255 return True
3256 3256
3257 3257 # Flush softspace
3258 3258 if softspace(sys.stdout, 0):
3259 3259 print()
3260 3260
3261 3261 except:
3262 3262 # It's possible to have exceptions raised here, typically by
3263 3263 # compilation of odd code (such as a naked 'return' outside a
3264 3264 # function) that did parse but isn't valid. Typically the exception
3265 3265 # is a SyntaxError, but it's safest just to catch anything and show
3266 3266 # the user a traceback.
3267 3267
3268 3268 # We do only one try/except outside the loop to minimize the impact
3269 3269 # on runtime, and also because if any node in the node list is
3270 3270 # broken, we should stop execution completely.
3271 3271 if result:
3272 3272 result.error_before_exec = sys.exc_info()[1]
3273 3273 self.showtraceback()
3274 3274 return True
3275 3275
3276 3276 return False
3277 3277
3278 3278 def _async_exec(self, code_obj: types.CodeType, user_ns: dict):
3279 3279 """
3280 3280 Evaluate an asynchronous code object using a code runner
3281 3281
3282 3282 Fake asynchronous execution of code_object in a namespace via a proxy namespace.
3283 3283
3284 3284 Returns coroutine object, which can be executed via async loop runner
3285 3285
3286 3286 WARNING: The semantics of `async_exec` are quite different from `exec`,
3287 3287 in particular you can only pass a single namespace. It also return a
3288 3288 handle to the value of the last things returned by code_object.
3289 3289 """
3290 3290
3291 3291 return eval(code_obj, user_ns)
3292 3292
3293 3293 async def run_code(self, code_obj, result=None, *, async_=False):
3294 3294 """Execute a code object.
3295 3295
3296 3296 When an exception occurs, self.showtraceback() is called to display a
3297 3297 traceback.
3298 3298
3299 3299 Parameters
3300 3300 ----------
3301 3301 code_obj : code object
3302 3302 A compiled code object, to be executed
3303 3303 result : ExecutionResult, optional
3304 3304 An object to store exceptions that occur during execution.
3305 3305 async_ : Bool (Experimental)
3306 3306 Attempt to run top-level asynchronous code in a default loop.
3307 3307
3308 3308 Returns
3309 3309 -------
3310 3310 False : successful execution.
3311 3311 True : an error occurred.
3312 3312 """
3313 3313 # Set our own excepthook in case the user code tries to call it
3314 3314 # directly, so that the IPython crash handler doesn't get triggered
3315 3315 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
3316 3316
3317 3317 # we save the original sys.excepthook in the instance, in case config
3318 3318 # code (such as magics) needs access to it.
3319 3319 self.sys_excepthook = old_excepthook
3320 3320 outflag = True # happens in more places, so it's easier as default
3321 3321 try:
3322 3322 try:
3323 3323 self.hooks.pre_run_code_hook()
3324 3324 if async_ and sys.version_info < (3,8):
3325 3325 last_expr = (await self._async_exec(code_obj, self.user_ns))
3326 3326 code = compile('last_expr', 'fake', "single")
3327 3327 exec(code, {'last_expr': last_expr})
3328 3328 elif async_ :
3329 3329 await eval(code_obj, self.user_global_ns, self.user_ns)
3330 3330 else:
3331 3331 exec(code_obj, self.user_global_ns, self.user_ns)
3332 3332 finally:
3333 3333 # Reset our crash handler in place
3334 3334 sys.excepthook = old_excepthook
3335 3335 except SystemExit as e:
3336 3336 if result is not None:
3337 3337 result.error_in_exec = e
3338 3338 self.showtraceback(exception_only=True)
3339 3339 warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
3340 3340 except self.custom_exceptions:
3341 3341 etype, value, tb = sys.exc_info()
3342 3342 if result is not None:
3343 3343 result.error_in_exec = value
3344 3344 self.CustomTB(etype, value, tb)
3345 3345 except:
3346 3346 if result is not None:
3347 3347 result.error_in_exec = sys.exc_info()[1]
3348 3348 self.showtraceback(running_compiled_code=True)
3349 3349 else:
3350 3350 outflag = False
3351 3351 return outflag
3352 3352
3353 3353 # For backwards compatibility
3354 3354 runcode = run_code
3355 3355
3356 3356 def check_complete(self, code: str) -> Tuple[str, str]:
3357 3357 """Return whether a block of code is ready to execute, or should be continued
3358 3358
3359 3359 Parameters
3360 3360 ----------
3361 3361 source : string
3362 3362 Python input code, which can be multiline.
3363 3363
3364 3364 Returns
3365 3365 -------
3366 3366 status : str
3367 3367 One of 'complete', 'incomplete', or 'invalid' if source is not a
3368 3368 prefix of valid code.
3369 3369 indent : str
3370 3370 When status is 'incomplete', this is some whitespace to insert on
3371 3371 the next line of the prompt.
3372 3372 """
3373 3373 status, nspaces = self.input_transformer_manager.check_complete(code)
3374 3374 return status, ' ' * (nspaces or 0)
3375 3375
3376 3376 #-------------------------------------------------------------------------
3377 3377 # Things related to GUI support and pylab
3378 3378 #-------------------------------------------------------------------------
3379 3379
3380 3380 active_eventloop = None
3381 3381
3382 3382 def enable_gui(self, gui=None):
3383 3383 raise NotImplementedError('Implement enable_gui in a subclass')
3384 3384
3385 3385 def enable_matplotlib(self, gui=None):
3386 3386 """Enable interactive matplotlib and inline figure support.
3387 3387
3388 3388 This takes the following steps:
3389 3389
3390 3390 1. select the appropriate eventloop and matplotlib backend
3391 3391 2. set up matplotlib for interactive use with that backend
3392 3392 3. configure formatters for inline figure display
3393 3393 4. enable the selected gui eventloop
3394 3394
3395 3395 Parameters
3396 3396 ----------
3397 3397 gui : optional, string
3398 3398 If given, dictates the choice of matplotlib GUI backend to use
3399 3399 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3400 3400 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3401 3401 matplotlib (as dictated by the matplotlib build-time options plus the
3402 3402 user's matplotlibrc configuration file). Note that not all backends
3403 3403 make sense in all contexts, for example a terminal ipython can't
3404 3404 display figures inline.
3405 3405 """
3406 3406 from IPython.core import pylabtools as pt
3407 3407 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3408 3408
3409 3409 if gui != 'inline':
3410 3410 # If we have our first gui selection, store it
3411 3411 if self.pylab_gui_select is None:
3412 3412 self.pylab_gui_select = gui
3413 3413 # Otherwise if they are different
3414 3414 elif gui != self.pylab_gui_select:
3415 3415 print('Warning: Cannot change to a different GUI toolkit: %s.'
3416 3416 ' Using %s instead.' % (gui, self.pylab_gui_select))
3417 3417 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3418 3418
3419 3419 pt.activate_matplotlib(backend)
3420 3420 pt.configure_inline_support(self, backend)
3421 3421
3422 3422 # Now we must activate the gui pylab wants to use, and fix %run to take
3423 3423 # plot updates into account
3424 3424 self.enable_gui(gui)
3425 3425 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3426 3426 pt.mpl_runner(self.safe_execfile)
3427 3427
3428 3428 return gui, backend
3429 3429
3430 3430 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3431 3431 """Activate pylab support at runtime.
3432 3432
3433 3433 This turns on support for matplotlib, preloads into the interactive
3434 3434 namespace all of numpy and pylab, and configures IPython to correctly
3435 3435 interact with the GUI event loop. The GUI backend to be used can be
3436 3436 optionally selected with the optional ``gui`` argument.
3437 3437
3438 3438 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3439 3439
3440 3440 Parameters
3441 3441 ----------
3442 3442 gui : optional, string
3443 3443 If given, dictates the choice of matplotlib GUI backend to use
3444 3444 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3445 3445 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3446 3446 matplotlib (as dictated by the matplotlib build-time options plus the
3447 3447 user's matplotlibrc configuration file). Note that not all backends
3448 3448 make sense in all contexts, for example a terminal ipython can't
3449 3449 display figures inline.
3450 3450 import_all : optional, bool, default: True
3451 3451 Whether to do `from numpy import *` and `from pylab import *`
3452 3452 in addition to module imports.
3453 3453 welcome_message : deprecated
3454 3454 This argument is ignored, no welcome message will be displayed.
3455 3455 """
3456 3456 from IPython.core.pylabtools import import_pylab
3457 3457
3458 3458 gui, backend = self.enable_matplotlib(gui)
3459 3459
3460 3460 # We want to prevent the loading of pylab to pollute the user's
3461 3461 # namespace as shown by the %who* magics, so we execute the activation
3462 3462 # code in an empty namespace, and we update *both* user_ns and
3463 3463 # user_ns_hidden with this information.
3464 3464 ns = {}
3465 3465 import_pylab(ns, import_all)
3466 3466 # warn about clobbered names
3467 3467 ignored = {"__builtins__"}
3468 3468 both = set(ns).intersection(self.user_ns).difference(ignored)
3469 3469 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3470 3470 self.user_ns.update(ns)
3471 3471 self.user_ns_hidden.update(ns)
3472 3472 return gui, backend, clobbered
3473 3473
3474 3474 #-------------------------------------------------------------------------
3475 3475 # Utilities
3476 3476 #-------------------------------------------------------------------------
3477 3477
3478 3478 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3479 3479 """Expand python variables in a string.
3480 3480
3481 3481 The depth argument indicates how many frames above the caller should
3482 3482 be walked to look for the local namespace where to expand variables.
3483 3483
3484 3484 The global namespace for expansion is always the user's interactive
3485 3485 namespace.
3486 3486 """
3487 3487 ns = self.user_ns.copy()
3488 3488 try:
3489 3489 frame = sys._getframe(depth+1)
3490 3490 except ValueError:
3491 3491 # This is thrown if there aren't that many frames on the stack,
3492 3492 # e.g. if a script called run_line_magic() directly.
3493 3493 pass
3494 3494 else:
3495 3495 ns.update(frame.f_locals)
3496 3496
3497 3497 try:
3498 3498 # We have to use .vformat() here, because 'self' is a valid and common
3499 3499 # name, and expanding **ns for .format() would make it collide with
3500 3500 # the 'self' argument of the method.
3501 3501 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3502 3502 except Exception:
3503 3503 # if formatter couldn't format, just let it go untransformed
3504 3504 pass
3505 3505 return cmd
3506 3506
3507 3507 def mktempfile(self, data=None, prefix='ipython_edit_'):
3508 3508 """Make a new tempfile and return its filename.
3509 3509
3510 3510 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3511 3511 but it registers the created filename internally so ipython cleans it up
3512 3512 at exit time.
3513 3513
3514 3514 Optional inputs:
3515 3515
3516 3516 - data(None): if data is given, it gets written out to the temp file
3517 3517 immediately, and the file is closed again."""
3518 3518
3519 3519 dirname = tempfile.mkdtemp(prefix=prefix)
3520 3520 self.tempdirs.append(dirname)
3521 3521
3522 3522 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3523 3523 os.close(handle) # On Windows, there can only be one open handle on a file
3524 3524 self.tempfiles.append(filename)
3525 3525
3526 3526 if data:
3527 3527 with open(filename, 'w') as tmp_file:
3528 3528 tmp_file.write(data)
3529 3529 return filename
3530 3530
3531 3531 @undoc
3532 3532 def write(self,data):
3533 3533 """DEPRECATED: Write a string to the default output"""
3534 3534 warn('InteractiveShell.write() is deprecated, use sys.stdout instead',
3535 3535 DeprecationWarning, stacklevel=2)
3536 3536 sys.stdout.write(data)
3537 3537
3538 3538 @undoc
3539 3539 def write_err(self,data):
3540 3540 """DEPRECATED: Write a string to the default error output"""
3541 3541 warn('InteractiveShell.write_err() is deprecated, use sys.stderr instead',
3542 3542 DeprecationWarning, stacklevel=2)
3543 3543 sys.stderr.write(data)
3544 3544
3545 3545 def ask_yes_no(self, prompt, default=None, interrupt=None):
3546 3546 if self.quiet:
3547 3547 return True
3548 3548 return ask_yes_no(prompt,default,interrupt)
3549 3549
3550 3550 def show_usage(self):
3551 3551 """Show a usage message"""
3552 3552 page.page(IPython.core.usage.interactive_usage)
3553 3553
3554 3554 def extract_input_lines(self, range_str, raw=False):
3555 3555 """Return as a string a set of input history slices.
3556 3556
3557 3557 Parameters
3558 3558 ----------
3559 3559 range_str : string
3560 3560 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3561 3561 since this function is for use by magic functions which get their
3562 3562 arguments as strings. The number before the / is the session
3563 3563 number: ~n goes n back from the current session.
3564 3564
3565 3565 raw : bool, optional
3566 3566 By default, the processed input is used. If this is true, the raw
3567 3567 input history is used instead.
3568 3568
3569 3569 Notes
3570 3570 -----
3571 3571
3572 3572 Slices can be described with two notations:
3573 3573
3574 3574 * ``N:M`` -> standard python form, means including items N...(M-1).
3575 3575 * ``N-M`` -> include items N..M (closed endpoint).
3576 3576 """
3577 3577 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3578 3578 return "\n".join(x for _, _, x in lines)
3579 3579
3580 3580 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3581 3581 """Get a code string from history, file, url, or a string or macro.
3582 3582
3583 3583 This is mainly used by magic functions.
3584 3584
3585 3585 Parameters
3586 3586 ----------
3587 3587
3588 3588 target : str
3589 3589
3590 3590 A string specifying code to retrieve. This will be tried respectively
3591 3591 as: ranges of input history (see %history for syntax), url,
3592 3592 corresponding .py file, filename, or an expression evaluating to a
3593 3593 string or Macro in the user namespace.
3594 3594
3595 3595 raw : bool
3596 3596 If true (default), retrieve raw history. Has no effect on the other
3597 3597 retrieval mechanisms.
3598 3598
3599 3599 py_only : bool (default False)
3600 3600 Only try to fetch python code, do not try alternative methods to decode file
3601 3601 if unicode fails.
3602 3602
3603 3603 Returns
3604 3604 -------
3605 3605 A string of code.
3606 3606
3607 3607 ValueError is raised if nothing is found, and TypeError if it evaluates
3608 3608 to an object of another type. In each case, .args[0] is a printable
3609 3609 message.
3610 3610 """
3611 3611 code = self.extract_input_lines(target, raw=raw) # Grab history
3612 3612 if code:
3613 3613 return code
3614 3614 try:
3615 3615 if target.startswith(('http://', 'https://')):
3616 3616 return openpy.read_py_url(target, skip_encoding_cookie=skip_encoding_cookie)
3617 3617 except UnicodeDecodeError:
3618 3618 if not py_only :
3619 3619 # Deferred import
3620 3620 from urllib.request import urlopen
3621 3621 response = urlopen(target)
3622 3622 return response.read().decode('latin1')
3623 3623 raise ValueError(("'%s' seem to be unreadable.") % target)
3624 3624
3625 3625 potential_target = [target]
3626 3626 try :
3627 3627 potential_target.insert(0,get_py_filename(target))
3628 3628 except IOError:
3629 3629 pass
3630 3630
3631 3631 for tgt in potential_target :
3632 3632 if os.path.isfile(tgt): # Read file
3633 3633 try :
3634 3634 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3635 3635 except UnicodeDecodeError :
3636 3636 if not py_only :
3637 3637 with io_open(tgt,'r', encoding='latin1') as f :
3638 3638 return f.read()
3639 3639 raise ValueError(("'%s' seem to be unreadable.") % target)
3640 3640 elif os.path.isdir(os.path.expanduser(tgt)):
3641 3641 raise ValueError("'%s' is a directory, not a regular file." % target)
3642 3642
3643 3643 if search_ns:
3644 3644 # Inspect namespace to load object source
3645 3645 object_info = self.object_inspect(target, detail_level=1)
3646 3646 if object_info['found'] and object_info['source']:
3647 3647 return object_info['source']
3648 3648
3649 3649 try: # User namespace
3650 3650 codeobj = eval(target, self.user_ns)
3651 3651 except Exception:
3652 3652 raise ValueError(("'%s' was not found in history, as a file, url, "
3653 3653 "nor in the user namespace.") % target)
3654 3654
3655 3655 if isinstance(codeobj, str):
3656 3656 return codeobj
3657 3657 elif isinstance(codeobj, Macro):
3658 3658 return codeobj.value
3659 3659
3660 3660 raise TypeError("%s is neither a string nor a macro." % target,
3661 3661 codeobj)
3662 3662
3663 3663 #-------------------------------------------------------------------------
3664 3664 # Things related to IPython exiting
3665 3665 #-------------------------------------------------------------------------
3666 3666 def atexit_operations(self):
3667 3667 """This will be executed at the time of exit.
3668 3668
3669 3669 Cleanup operations and saving of persistent data that is done
3670 3670 unconditionally by IPython should be performed here.
3671 3671
3672 3672 For things that may depend on startup flags or platform specifics (such
3673 3673 as having readline or not), register a separate atexit function in the
3674 3674 code that has the appropriate information, rather than trying to
3675 3675 clutter
3676 3676 """
3677 3677 # Close the history session (this stores the end time and line count)
3678 3678 # this must be *before* the tempfile cleanup, in case of temporary
3679 3679 # history db
3680 3680 self.history_manager.end_session()
3681 3681
3682 3682 # Cleanup all tempfiles and folders left around
3683 3683 for tfile in self.tempfiles:
3684 3684 try:
3685 3685 os.unlink(tfile)
3686 3686 except OSError:
3687 3687 pass
3688 3688
3689 3689 for tdir in self.tempdirs:
3690 3690 try:
3691 3691 os.rmdir(tdir)
3692 3692 except OSError:
3693 3693 pass
3694 3694
3695 3695 # Clear all user namespaces to release all references cleanly.
3696 3696 self.reset(new_session=False)
3697 3697
3698 3698 # Run user hooks
3699 3699 self.hooks.shutdown_hook()
3700 3700
3701 3701 def cleanup(self):
3702 3702 self.restore_sys_module_state()
3703 3703
3704 3704
3705 3705 # Overridden in terminal subclass to change prompts
3706 3706 def switch_doctest_mode(self, mode):
3707 3707 pass
3708 3708
3709 3709
3710 3710 class InteractiveShellABC(metaclass=abc.ABCMeta):
3711 3711 """An abstract base class for InteractiveShell."""
3712 3712
3713 3713 InteractiveShellABC.register(InteractiveShell)
@@ -1,1000 +1,1018 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Tests for the key interactiveshell module.
3 3
4 4 Historically the main classes in interactiveshell have been under-tested. This
5 5 module should grow as many single-method tests as possible to trap many of the
6 6 recurring bugs we seem to encounter with high-level interaction.
7 7 """
8 8
9 9 # Copyright (c) IPython Development Team.
10 10 # Distributed under the terms of the Modified BSD License.
11 11
12 12 import asyncio
13 13 import ast
14 14 import os
15 15 import signal
16 16 import shutil
17 17 import sys
18 18 import tempfile
19 19 import unittest
20 20 from unittest import mock
21 21
22 22 from os.path import join
23 23
24 24 import nose.tools as nt
25 25
26 26 from IPython.core.error import InputRejected
27 27 from IPython.core.inputtransformer import InputTransformer
28 28 from IPython.core import interactiveshell
29 29 from IPython.testing.decorators import (
30 30 skipif, skip_win32, onlyif_unicode_paths, onlyif_cmds_exist,
31 31 )
32 32 from IPython.testing import tools as tt
33 33 from IPython.utils.process import find_cmd
34 34
35 35 #-----------------------------------------------------------------------------
36 36 # Globals
37 37 #-----------------------------------------------------------------------------
38 38 # This is used by every single test, no point repeating it ad nauseam
39 39
40 40 #-----------------------------------------------------------------------------
41 41 # Tests
42 42 #-----------------------------------------------------------------------------
43 43
44 44 class DerivedInterrupt(KeyboardInterrupt):
45 45 pass
46 46
47 47 class InteractiveShellTestCase(unittest.TestCase):
48 48 def test_naked_string_cells(self):
49 49 """Test that cells with only naked strings are fully executed"""
50 50 # First, single-line inputs
51 51 ip.run_cell('"a"\n')
52 52 self.assertEqual(ip.user_ns['_'], 'a')
53 53 # And also multi-line cells
54 54 ip.run_cell('"""a\nb"""\n')
55 55 self.assertEqual(ip.user_ns['_'], 'a\nb')
56 56
57 57 def test_run_empty_cell(self):
58 58 """Just make sure we don't get a horrible error with a blank
59 59 cell of input. Yes, I did overlook that."""
60 60 old_xc = ip.execution_count
61 61 res = ip.run_cell('')
62 62 self.assertEqual(ip.execution_count, old_xc)
63 63 self.assertEqual(res.execution_count, None)
64 64
65 65 def test_run_cell_multiline(self):
66 66 """Multi-block, multi-line cells must execute correctly.
67 67 """
68 68 src = '\n'.join(["x=1",
69 69 "y=2",
70 70 "if 1:",
71 71 " x += 1",
72 72 " y += 1",])
73 73 res = ip.run_cell(src)
74 74 self.assertEqual(ip.user_ns['x'], 2)
75 75 self.assertEqual(ip.user_ns['y'], 3)
76 76 self.assertEqual(res.success, True)
77 77 self.assertEqual(res.result, None)
78 78
79 79 def test_multiline_string_cells(self):
80 80 "Code sprinkled with multiline strings should execute (GH-306)"
81 81 ip.run_cell('tmp=0')
82 82 self.assertEqual(ip.user_ns['tmp'], 0)
83 83 res = ip.run_cell('tmp=1;"""a\nb"""\n')
84 84 self.assertEqual(ip.user_ns['tmp'], 1)
85 85 self.assertEqual(res.success, True)
86 86 self.assertEqual(res.result, "a\nb")
87 87
88 88 def test_dont_cache_with_semicolon(self):
89 89 "Ending a line with semicolon should not cache the returned object (GH-307)"
90 90 oldlen = len(ip.user_ns['Out'])
91 91 for cell in ['1;', '1;1;']:
92 92 res = ip.run_cell(cell, store_history=True)
93 93 newlen = len(ip.user_ns['Out'])
94 94 self.assertEqual(oldlen, newlen)
95 95 self.assertIsNone(res.result)
96 96 i = 0
97 97 #also test the default caching behavior
98 98 for cell in ['1', '1;1']:
99 99 ip.run_cell(cell, store_history=True)
100 100 newlen = len(ip.user_ns['Out'])
101 101 i += 1
102 102 self.assertEqual(oldlen+i, newlen)
103 103
104 104 def test_syntax_error(self):
105 105 res = ip.run_cell("raise = 3")
106 106 self.assertIsInstance(res.error_before_exec, SyntaxError)
107 107
108 108 def test_In_variable(self):
109 109 "Verify that In variable grows with user input (GH-284)"
110 110 oldlen = len(ip.user_ns['In'])
111 111 ip.run_cell('1;', store_history=True)
112 112 newlen = len(ip.user_ns['In'])
113 113 self.assertEqual(oldlen+1, newlen)
114 114 self.assertEqual(ip.user_ns['In'][-1],'1;')
115 115
116 116 def test_magic_names_in_string(self):
117 117 ip.run_cell('a = """\n%exit\n"""')
118 118 self.assertEqual(ip.user_ns['a'], '\n%exit\n')
119 119
120 120 def test_trailing_newline(self):
121 121 """test that running !(command) does not raise a SyntaxError"""
122 122 ip.run_cell('!(true)\n', False)
123 123 ip.run_cell('!(true)\n\n\n', False)
124 124
125 125 def test_gh_597(self):
126 126 """Pretty-printing lists of objects with non-ascii reprs may cause
127 127 problems."""
128 128 class Spam(object):
129 129 def __repr__(self):
130 130 return "\xe9"*50
131 131 import IPython.core.formatters
132 132 f = IPython.core.formatters.PlainTextFormatter()
133 133 f([Spam(),Spam()])
134 134
135 135
136 136 def test_future_flags(self):
137 137 """Check that future flags are used for parsing code (gh-777)"""
138 138 ip.run_cell('from __future__ import barry_as_FLUFL')
139 139 try:
140 140 ip.run_cell('prfunc_return_val = 1 <> 2')
141 141 assert 'prfunc_return_val' in ip.user_ns
142 142 finally:
143 143 # Reset compiler flags so we don't mess up other tests.
144 144 ip.compile.reset_compiler_flags()
145 145
146 146 def test_can_pickle(self):
147 147 "Can we pickle objects defined interactively (GH-29)"
148 148 ip = get_ipython()
149 149 ip.reset()
150 150 ip.run_cell(("class Mylist(list):\n"
151 151 " def __init__(self,x=[]):\n"
152 152 " list.__init__(self,x)"))
153 153 ip.run_cell("w=Mylist([1,2,3])")
154 154
155 155 from pickle import dumps
156 156
157 157 # We need to swap in our main module - this is only necessary
158 158 # inside the test framework, because IPython puts the interactive module
159 159 # in place (but the test framework undoes this).
160 160 _main = sys.modules['__main__']
161 161 sys.modules['__main__'] = ip.user_module
162 162 try:
163 163 res = dumps(ip.user_ns["w"])
164 164 finally:
165 165 sys.modules['__main__'] = _main
166 166 self.assertTrue(isinstance(res, bytes))
167 167
168 168 def test_global_ns(self):
169 169 "Code in functions must be able to access variables outside them."
170 170 ip = get_ipython()
171 171 ip.run_cell("a = 10")
172 172 ip.run_cell(("def f(x):\n"
173 173 " return x + a"))
174 174 ip.run_cell("b = f(12)")
175 175 self.assertEqual(ip.user_ns["b"], 22)
176 176
177 177 def test_bad_custom_tb(self):
178 178 """Check that InteractiveShell is protected from bad custom exception handlers"""
179 179 ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
180 180 self.assertEqual(ip.custom_exceptions, (IOError,))
181 181 with tt.AssertPrints("Custom TB Handler failed", channel='stderr'):
182 182 ip.run_cell(u'raise IOError("foo")')
183 183 self.assertEqual(ip.custom_exceptions, ())
184 184
185 185 def test_bad_custom_tb_return(self):
186 186 """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
187 187 ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
188 188 self.assertEqual(ip.custom_exceptions, (NameError,))
189 189 with tt.AssertPrints("Custom TB Handler failed", channel='stderr'):
190 190 ip.run_cell(u'a=abracadabra')
191 191 self.assertEqual(ip.custom_exceptions, ())
192 192
193 193 def test_drop_by_id(self):
194 194 myvars = {"a":object(), "b":object(), "c": object()}
195 195 ip.push(myvars, interactive=False)
196 196 for name in myvars:
197 197 assert name in ip.user_ns, name
198 198 assert name in ip.user_ns_hidden, name
199 199 ip.user_ns['b'] = 12
200 200 ip.drop_by_id(myvars)
201 201 for name in ["a", "c"]:
202 202 assert name not in ip.user_ns, name
203 203 assert name not in ip.user_ns_hidden, name
204 204 assert ip.user_ns['b'] == 12
205 205 ip.reset()
206 206
207 207 def test_var_expand(self):
208 208 ip.user_ns['f'] = u'Ca\xf1o'
209 209 self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
210 210 self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
211 211 self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
212 212 self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
213 213
214 214 self.assertEqual(ip.var_expand(u"grep x | awk '{print $1}'"), u"grep x | awk '{print $1}'")
215 215
216 216 ip.user_ns['f'] = b'Ca\xc3\xb1o'
217 217 # This should not raise any exception:
218 218 ip.var_expand(u'echo $f')
219 219
220 220 def test_var_expand_local(self):
221 221 """Test local variable expansion in !system and %magic calls"""
222 222 # !system
223 223 ip.run_cell('def test():\n'
224 224 ' lvar = "ttt"\n'
225 225 ' ret = !echo {lvar}\n'
226 226 ' return ret[0]\n')
227 227 res = ip.user_ns['test']()
228 228 nt.assert_in('ttt', res)
229 229
230 230 # %magic
231 231 ip.run_cell('def makemacro():\n'
232 232 ' macroname = "macro_var_expand_locals"\n'
233 233 ' %macro {macroname} codestr\n')
234 234 ip.user_ns['codestr'] = "str(12)"
235 235 ip.run_cell('makemacro()')
236 236 nt.assert_in('macro_var_expand_locals', ip.user_ns)
237 237
238 238 def test_var_expand_self(self):
239 239 """Test variable expansion with the name 'self', which was failing.
240 240
241 241 See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
242 242 """
243 243 ip.run_cell('class cTest:\n'
244 244 ' classvar="see me"\n'
245 245 ' def test(self):\n'
246 246 ' res = !echo Variable: {self.classvar}\n'
247 247 ' return res[0]\n')
248 248 nt.assert_in('see me', ip.user_ns['cTest']().test())
249 249
250 250 def test_bad_var_expand(self):
251 251 """var_expand on invalid formats shouldn't raise"""
252 252 # SyntaxError
253 253 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
254 254 # NameError
255 255 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
256 256 # ZeroDivisionError
257 257 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
258 258
259 259 def test_silent_postexec(self):
260 260 """run_cell(silent=True) doesn't invoke pre/post_run_cell callbacks"""
261 261 pre_explicit = mock.Mock()
262 262 pre_always = mock.Mock()
263 263 post_explicit = mock.Mock()
264 264 post_always = mock.Mock()
265 265 all_mocks = [pre_explicit, pre_always, post_explicit, post_always]
266 266
267 267 ip.events.register('pre_run_cell', pre_explicit)
268 268 ip.events.register('pre_execute', pre_always)
269 269 ip.events.register('post_run_cell', post_explicit)
270 270 ip.events.register('post_execute', post_always)
271 271
272 272 try:
273 273 ip.run_cell("1", silent=True)
274 274 assert pre_always.called
275 275 assert not pre_explicit.called
276 276 assert post_always.called
277 277 assert not post_explicit.called
278 278 # double-check that non-silent exec did what we expected
279 279 # silent to avoid
280 280 ip.run_cell("1")
281 281 assert pre_explicit.called
282 282 assert post_explicit.called
283 283 info, = pre_explicit.call_args[0]
284 284 result, = post_explicit.call_args[0]
285 285 self.assertEqual(info, result.info)
286 286 # check that post hooks are always called
287 287 [m.reset_mock() for m in all_mocks]
288 288 ip.run_cell("syntax error")
289 289 assert pre_always.called
290 290 assert pre_explicit.called
291 291 assert post_always.called
292 292 assert post_explicit.called
293 293 info, = pre_explicit.call_args[0]
294 294 result, = post_explicit.call_args[0]
295 295 self.assertEqual(info, result.info)
296 296 finally:
297 297 # remove post-exec
298 298 ip.events.unregister('pre_run_cell', pre_explicit)
299 299 ip.events.unregister('pre_execute', pre_always)
300 300 ip.events.unregister('post_run_cell', post_explicit)
301 301 ip.events.unregister('post_execute', post_always)
302 302
303 303 def test_silent_noadvance(self):
304 304 """run_cell(silent=True) doesn't advance execution_count"""
305 305 ec = ip.execution_count
306 306 # silent should force store_history=False
307 307 ip.run_cell("1", store_history=True, silent=True)
308 308
309 309 self.assertEqual(ec, ip.execution_count)
310 310 # double-check that non-silent exec did what we expected
311 311 # silent to avoid
312 312 ip.run_cell("1", store_history=True)
313 313 self.assertEqual(ec+1, ip.execution_count)
314 314
315 315 def test_silent_nodisplayhook(self):
316 316 """run_cell(silent=True) doesn't trigger displayhook"""
317 317 d = dict(called=False)
318 318
319 319 trap = ip.display_trap
320 320 save_hook = trap.hook
321 321
322 322 def failing_hook(*args, **kwargs):
323 323 d['called'] = True
324 324
325 325 try:
326 326 trap.hook = failing_hook
327 327 res = ip.run_cell("1", silent=True)
328 328 self.assertFalse(d['called'])
329 329 self.assertIsNone(res.result)
330 330 # double-check that non-silent exec did what we expected
331 331 # silent to avoid
332 332 ip.run_cell("1")
333 333 self.assertTrue(d['called'])
334 334 finally:
335 335 trap.hook = save_hook
336 336
337 337 def test_ofind_line_magic(self):
338 338 from IPython.core.magic import register_line_magic
339 339
340 340 @register_line_magic
341 341 def lmagic(line):
342 342 "A line magic"
343 343
344 344 # Get info on line magic
345 345 lfind = ip._ofind('lmagic')
346 346 info = dict(found=True, isalias=False, ismagic=True,
347 347 namespace = 'IPython internal', obj= lmagic.__wrapped__,
348 348 parent = None)
349 349 nt.assert_equal(lfind, info)
350 350
351 351 def test_ofind_cell_magic(self):
352 352 from IPython.core.magic import register_cell_magic
353 353
354 354 @register_cell_magic
355 355 def cmagic(line, cell):
356 356 "A cell magic"
357 357
358 358 # Get info on cell magic
359 359 find = ip._ofind('cmagic')
360 360 info = dict(found=True, isalias=False, ismagic=True,
361 361 namespace = 'IPython internal', obj= cmagic.__wrapped__,
362 362 parent = None)
363 363 nt.assert_equal(find, info)
364 364
365 365 def test_ofind_property_with_error(self):
366 366 class A(object):
367 367 @property
368 368 def foo(self):
369 369 raise NotImplementedError()
370 370 a = A()
371 371
372 372 found = ip._ofind('a.foo', [('locals', locals())])
373 373 info = dict(found=True, isalias=False, ismagic=False,
374 374 namespace='locals', obj=A.foo, parent=a)
375 375 nt.assert_equal(found, info)
376 376
377 377 def test_ofind_multiple_attribute_lookups(self):
378 378 class A(object):
379 379 @property
380 380 def foo(self):
381 381 raise NotImplementedError()
382 382
383 383 a = A()
384 384 a.a = A()
385 385 a.a.a = A()
386 386
387 387 found = ip._ofind('a.a.a.foo', [('locals', locals())])
388 388 info = dict(found=True, isalias=False, ismagic=False,
389 389 namespace='locals', obj=A.foo, parent=a.a.a)
390 390 nt.assert_equal(found, info)
391 391
392 392 def test_ofind_slotted_attributes(self):
393 393 class A(object):
394 394 __slots__ = ['foo']
395 395 def __init__(self):
396 396 self.foo = 'bar'
397 397
398 398 a = A()
399 399 found = ip._ofind('a.foo', [('locals', locals())])
400 400 info = dict(found=True, isalias=False, ismagic=False,
401 401 namespace='locals', obj=a.foo, parent=a)
402 402 nt.assert_equal(found, info)
403 403
404 404 found = ip._ofind('a.bar', [('locals', locals())])
405 405 info = dict(found=False, isalias=False, ismagic=False,
406 406 namespace=None, obj=None, parent=a)
407 407 nt.assert_equal(found, info)
408 408
409 409 def test_ofind_prefers_property_to_instance_level_attribute(self):
410 410 class A(object):
411 411 @property
412 412 def foo(self):
413 413 return 'bar'
414 414 a = A()
415 415 a.__dict__['foo'] = 'baz'
416 416 nt.assert_equal(a.foo, 'bar')
417 417 found = ip._ofind('a.foo', [('locals', locals())])
418 418 nt.assert_is(found['obj'], A.foo)
419 419
420 420 def test_custom_syntaxerror_exception(self):
421 421 called = []
422 422 def my_handler(shell, etype, value, tb, tb_offset=None):
423 423 called.append(etype)
424 424 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
425 425
426 426 ip.set_custom_exc((SyntaxError,), my_handler)
427 427 try:
428 428 ip.run_cell("1f")
429 429 # Check that this was called, and only once.
430 430 self.assertEqual(called, [SyntaxError])
431 431 finally:
432 432 # Reset the custom exception hook
433 433 ip.set_custom_exc((), None)
434 434
435 435 def test_custom_exception(self):
436 436 called = []
437 437 def my_handler(shell, etype, value, tb, tb_offset=None):
438 438 called.append(etype)
439 439 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
440 440
441 441 ip.set_custom_exc((ValueError,), my_handler)
442 442 try:
443 443 res = ip.run_cell("raise ValueError('test')")
444 444 # Check that this was called, and only once.
445 445 self.assertEqual(called, [ValueError])
446 446 # Check that the error is on the result object
447 447 self.assertIsInstance(res.error_in_exec, ValueError)
448 448 finally:
449 449 # Reset the custom exception hook
450 450 ip.set_custom_exc((), None)
451 451
452 452 def test_mktempfile(self):
453 453 filename = ip.mktempfile()
454 454 # Check that we can open the file again on Windows
455 455 with open(filename, 'w') as f:
456 456 f.write('abc')
457 457
458 458 filename = ip.mktempfile(data='blah')
459 459 with open(filename, 'r') as f:
460 460 self.assertEqual(f.read(), 'blah')
461 461
462 462 def test_new_main_mod(self):
463 463 # Smoketest to check that this accepts a unicode module name
464 464 name = u'jiefmw'
465 465 mod = ip.new_main_mod(u'%s.py' % name, name)
466 466 self.assertEqual(mod.__name__, name)
467 467
468 468 def test_get_exception_only(self):
469 469 try:
470 470 raise KeyboardInterrupt
471 471 except KeyboardInterrupt:
472 472 msg = ip.get_exception_only()
473 473 self.assertEqual(msg, 'KeyboardInterrupt\n')
474 474
475 475 try:
476 476 raise DerivedInterrupt("foo")
477 477 except KeyboardInterrupt:
478 478 msg = ip.get_exception_only()
479 479 self.assertEqual(msg, 'IPython.core.tests.test_interactiveshell.DerivedInterrupt: foo\n')
480 480
481 481 def test_inspect_text(self):
482 482 ip.run_cell('a = 5')
483 483 text = ip.object_inspect_text('a')
484 484 self.assertIsInstance(text, str)
485 485
486 486 def test_last_execution_result(self):
487 487 """ Check that last execution result gets set correctly (GH-10702) """
488 488 result = ip.run_cell('a = 5; a')
489 489 self.assertTrue(ip.last_execution_succeeded)
490 490 self.assertEqual(ip.last_execution_result.result, 5)
491 491
492 492 result = ip.run_cell('a = x_invalid_id_x')
493 493 self.assertFalse(ip.last_execution_succeeded)
494 494 self.assertFalse(ip.last_execution_result.success)
495 495 self.assertIsInstance(ip.last_execution_result.error_in_exec, NameError)
496 496
497 497 def test_reset_aliasing(self):
498 498 """ Check that standard posix aliases work after %reset. """
499 499 if os.name != 'posix':
500 500 return
501 501
502 502 ip.reset()
503 503 for cmd in ('clear', 'more', 'less', 'man'):
504 504 res = ip.run_cell('%' + cmd)
505 505 self.assertEqual(res.success, True)
506 506
507 507
508 508 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
509 509
510 510 @onlyif_unicode_paths
511 511 def setUp(self):
512 512 self.BASETESTDIR = tempfile.mkdtemp()
513 513 self.TESTDIR = join(self.BASETESTDIR, u"Γ₯Àâ")
514 514 os.mkdir(self.TESTDIR)
515 515 with open(join(self.TESTDIR, u"Γ₯Àâtestscript.py"), "w") as sfile:
516 516 sfile.write("pass\n")
517 517 self.oldpath = os.getcwd()
518 518 os.chdir(self.TESTDIR)
519 519 self.fname = u"Γ₯Àâtestscript.py"
520 520
521 521 def tearDown(self):
522 522 os.chdir(self.oldpath)
523 523 shutil.rmtree(self.BASETESTDIR)
524 524
525 525 @onlyif_unicode_paths
526 526 def test_1(self):
527 527 """Test safe_execfile with non-ascii path
528 528 """
529 529 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
530 530
531 531 class ExitCodeChecks(tt.TempFileMixin):
532 532
533 533 def setUp(self):
534 534 self.system = ip.system_raw
535 535
536 536 def test_exit_code_ok(self):
537 537 self.system('exit 0')
538 538 self.assertEqual(ip.user_ns['_exit_code'], 0)
539 539
540 540 def test_exit_code_error(self):
541 541 self.system('exit 1')
542 542 self.assertEqual(ip.user_ns['_exit_code'], 1)
543 543
544 544 @skipif(not hasattr(signal, 'SIGALRM'))
545 545 def test_exit_code_signal(self):
546 546 self.mktmp("import signal, time\n"
547 547 "signal.setitimer(signal.ITIMER_REAL, 0.1)\n"
548 548 "time.sleep(1)\n")
549 549 self.system("%s %s" % (sys.executable, self.fname))
550 550 self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGALRM)
551 551
552 552 @onlyif_cmds_exist("csh")
553 553 def test_exit_code_signal_csh(self):
554 554 SHELL = os.environ.get('SHELL', None)
555 555 os.environ['SHELL'] = find_cmd("csh")
556 556 try:
557 557 self.test_exit_code_signal()
558 558 finally:
559 559 if SHELL is not None:
560 560 os.environ['SHELL'] = SHELL
561 561 else:
562 562 del os.environ['SHELL']
563 563
564 564
565 565 class TestSystemRaw(ExitCodeChecks):
566 566
567 567 def setUp(self):
568 568 super().setUp()
569 569 self.system = ip.system_raw
570 570
571 571 @onlyif_unicode_paths
572 572 def test_1(self):
573 573 """Test system_raw with non-ascii cmd
574 574 """
575 575 cmd = u'''python -c "'Γ₯Àâ'" '''
576 576 ip.system_raw(cmd)
577 577
578 578 @mock.patch('subprocess.call', side_effect=KeyboardInterrupt)
579 579 @mock.patch('os.system', side_effect=KeyboardInterrupt)
580 580 def test_control_c(self, *mocks):
581 581 try:
582 582 self.system("sleep 1 # wont happen")
583 583 except KeyboardInterrupt:
584 584 self.fail("system call should intercept "
585 585 "keyboard interrupt from subprocess.call")
586 586 self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGINT)
587 587
588 588 # TODO: Exit codes are currently ignored on Windows.
589 589 class TestSystemPipedExitCode(ExitCodeChecks):
590 590
591 591 def setUp(self):
592 592 super().setUp()
593 593 self.system = ip.system_piped
594 594
595 595 @skip_win32
596 596 def test_exit_code_ok(self):
597 597 ExitCodeChecks.test_exit_code_ok(self)
598 598
599 599 @skip_win32
600 600 def test_exit_code_error(self):
601 601 ExitCodeChecks.test_exit_code_error(self)
602 602
603 603 @skip_win32
604 604 def test_exit_code_signal(self):
605 605 ExitCodeChecks.test_exit_code_signal(self)
606 606
607 607 class TestModules(tt.TempFileMixin):
608 608 def test_extraneous_loads(self):
609 609 """Test we're not loading modules on startup that we shouldn't.
610 610 """
611 611 self.mktmp("import sys\n"
612 612 "print('numpy' in sys.modules)\n"
613 613 "print('ipyparallel' in sys.modules)\n"
614 614 "print('ipykernel' in sys.modules)\n"
615 615 )
616 616 out = "False\nFalse\nFalse\n"
617 617 tt.ipexec_validate(self.fname, out)
618 618
619 619 class Negator(ast.NodeTransformer):
620 620 """Negates all number literals in an AST."""
621 621
622 622 # for python 3.7 and earlier
623 623 def visit_Num(self, node):
624 624 node.n = -node.n
625 625 return node
626 626
627 627 # for python 3.8+
628 628 def visit_Constant(self, node):
629 629 if isinstance(node.value, int):
630 630 return self.visit_Num(node)
631 631 return node
632 632
633 633 class TestAstTransform(unittest.TestCase):
634 634 def setUp(self):
635 635 self.negator = Negator()
636 636 ip.ast_transformers.append(self.negator)
637 637
638 638 def tearDown(self):
639 639 ip.ast_transformers.remove(self.negator)
640 640
641 641 def test_run_cell(self):
642 642 with tt.AssertPrints('-34'):
643 643 ip.run_cell('print (12 + 22)')
644 644
645 645 # A named reference to a number shouldn't be transformed.
646 646 ip.user_ns['n'] = 55
647 647 with tt.AssertNotPrints('-55'):
648 648 ip.run_cell('print (n)')
649 649
650 650 def test_timeit(self):
651 651 called = set()
652 652 def f(x):
653 653 called.add(x)
654 654 ip.push({'f':f})
655 655
656 656 with tt.AssertPrints("std. dev. of"):
657 657 ip.run_line_magic("timeit", "-n1 f(1)")
658 658 self.assertEqual(called, {-1})
659 659 called.clear()
660 660
661 661 with tt.AssertPrints("std. dev. of"):
662 662 ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
663 663 self.assertEqual(called, {-2, -3})
664 664
665 665 def test_time(self):
666 666 called = []
667 667 def f(x):
668 668 called.append(x)
669 669 ip.push({'f':f})
670 670
671 671 # Test with an expression
672 672 with tt.AssertPrints("Wall time: "):
673 673 ip.run_line_magic("time", "f(5+9)")
674 674 self.assertEqual(called, [-14])
675 675 called[:] = []
676 676
677 677 # Test with a statement (different code path)
678 678 with tt.AssertPrints("Wall time: "):
679 679 ip.run_line_magic("time", "a = f(-3 + -2)")
680 680 self.assertEqual(called, [5])
681 681
682 682 def test_macro(self):
683 683 ip.push({'a':10})
684 684 # The AST transformation makes this do a+=-1
685 685 ip.define_macro("amacro", "a+=1\nprint(a)")
686 686
687 687 with tt.AssertPrints("9"):
688 688 ip.run_cell("amacro")
689 689 with tt.AssertPrints("8"):
690 690 ip.run_cell("amacro")
691 691
692 692 class IntegerWrapper(ast.NodeTransformer):
693 693 """Wraps all integers in a call to Integer()"""
694 694
695 695 # for Python 3.7 and earlier
696 696
697 697 # for Python 3.7 and earlier
698 698 def visit_Num(self, node):
699 699 if isinstance(node.n, int):
700 700 return ast.Call(func=ast.Name(id='Integer', ctx=ast.Load()),
701 701 args=[node], keywords=[])
702 702 return node
703 703
704 704 # For Python 3.8+
705 705 def visit_Constant(self, node):
706 706 if isinstance(node.value, int):
707 707 return self.visit_Num(node)
708 708 return node
709 709
710 710
711 711 class TestAstTransform2(unittest.TestCase):
712 712 def setUp(self):
713 713 self.intwrapper = IntegerWrapper()
714 714 ip.ast_transformers.append(self.intwrapper)
715 715
716 716 self.calls = []
717 717 def Integer(*args):
718 718 self.calls.append(args)
719 719 return args
720 720 ip.push({"Integer": Integer})
721 721
722 722 def tearDown(self):
723 723 ip.ast_transformers.remove(self.intwrapper)
724 724 del ip.user_ns['Integer']
725 725
726 726 def test_run_cell(self):
727 727 ip.run_cell("n = 2")
728 728 self.assertEqual(self.calls, [(2,)])
729 729
730 730 # This shouldn't throw an error
731 731 ip.run_cell("o = 2.0")
732 732 self.assertEqual(ip.user_ns['o'], 2.0)
733 733
734 734 def test_timeit(self):
735 735 called = set()
736 736 def f(x):
737 737 called.add(x)
738 738 ip.push({'f':f})
739 739
740 740 with tt.AssertPrints("std. dev. of"):
741 741 ip.run_line_magic("timeit", "-n1 f(1)")
742 742 self.assertEqual(called, {(1,)})
743 743 called.clear()
744 744
745 745 with tt.AssertPrints("std. dev. of"):
746 746 ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
747 747 self.assertEqual(called, {(2,), (3,)})
748 748
749 749 class ErrorTransformer(ast.NodeTransformer):
750 750 """Throws an error when it sees a number."""
751 751
752 752 # for Python 3.7 and earlier
753 753 def visit_Num(self, node):
754 754 raise ValueError("test")
755 755
756 756 # for Python 3.8+
757 757 def visit_Constant(self, node):
758 758 if isinstance(node.value, int):
759 759 return self.visit_Num(node)
760 760 return node
761 761
762 762
763 763 class TestAstTransformError(unittest.TestCase):
764 764 def test_unregistering(self):
765 765 err_transformer = ErrorTransformer()
766 766 ip.ast_transformers.append(err_transformer)
767 767
768 768 with self.assertWarnsRegex(UserWarning, "It will be unregistered"):
769 769 ip.run_cell("1 + 2")
770 770
771 771 # This should have been removed.
772 772 nt.assert_not_in(err_transformer, ip.ast_transformers)
773 773
774 774
775 775 class StringRejector(ast.NodeTransformer):
776 776 """Throws an InputRejected when it sees a string literal.
777 777
778 778 Used to verify that NodeTransformers can signal that a piece of code should
779 779 not be executed by throwing an InputRejected.
780 780 """
781 781
782 782 #for python 3.7 and earlier
783 783 def visit_Str(self, node):
784 784 raise InputRejected("test")
785 785
786 786 # 3.8 only
787 787 def visit_Constant(self, node):
788 788 if isinstance(node.value, str):
789 789 raise InputRejected("test")
790 790 return node
791 791
792 792
793 793 class TestAstTransformInputRejection(unittest.TestCase):
794 794
795 795 def setUp(self):
796 796 self.transformer = StringRejector()
797 797 ip.ast_transformers.append(self.transformer)
798 798
799 799 def tearDown(self):
800 800 ip.ast_transformers.remove(self.transformer)
801 801
802 802 def test_input_rejection(self):
803 803 """Check that NodeTransformers can reject input."""
804 804
805 805 expect_exception_tb = tt.AssertPrints("InputRejected: test")
806 806 expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False)
807 807
808 808 # Run the same check twice to verify that the transformer is not
809 809 # disabled after raising.
810 810 with expect_exception_tb, expect_no_cell_output:
811 811 ip.run_cell("'unsafe'")
812 812
813 813 with expect_exception_tb, expect_no_cell_output:
814 814 res = ip.run_cell("'unsafe'")
815 815
816 816 self.assertIsInstance(res.error_before_exec, InputRejected)
817 817
818 818 def test__IPYTHON__():
819 819 # This shouldn't raise a NameError, that's all
820 820 __IPYTHON__
821 821
822 822
823 823 class DummyRepr(object):
824 824 def __repr__(self):
825 825 return "DummyRepr"
826 826
827 827 def _repr_html_(self):
828 828 return "<b>dummy</b>"
829 829
830 830 def _repr_javascript_(self):
831 831 return "console.log('hi');", {'key': 'value'}
832 832
833 833
834 834 def test_user_variables():
835 835 # enable all formatters
836 836 ip.display_formatter.active_types = ip.display_formatter.format_types
837 837
838 838 ip.user_ns['dummy'] = d = DummyRepr()
839 839 keys = {'dummy', 'doesnotexist'}
840 840 r = ip.user_expressions({ key:key for key in keys})
841 841
842 842 nt.assert_equal(keys, set(r.keys()))
843 843 dummy = r['dummy']
844 844 nt.assert_equal({'status', 'data', 'metadata'}, set(dummy.keys()))
845 845 nt.assert_equal(dummy['status'], 'ok')
846 846 data = dummy['data']
847 847 metadata = dummy['metadata']
848 848 nt.assert_equal(data.get('text/html'), d._repr_html_())
849 849 js, jsmd = d._repr_javascript_()
850 850 nt.assert_equal(data.get('application/javascript'), js)
851 851 nt.assert_equal(metadata.get('application/javascript'), jsmd)
852 852
853 853 dne = r['doesnotexist']
854 854 nt.assert_equal(dne['status'], 'error')
855 855 nt.assert_equal(dne['ename'], 'NameError')
856 856
857 857 # back to text only
858 858 ip.display_formatter.active_types = ['text/plain']
859 859
860 860 def test_user_expression():
861 861 # enable all formatters
862 862 ip.display_formatter.active_types = ip.display_formatter.format_types
863 863 query = {
864 864 'a' : '1 + 2',
865 865 'b' : '1/0',
866 866 }
867 867 r = ip.user_expressions(query)
868 868 import pprint
869 869 pprint.pprint(r)
870 870 nt.assert_equal(set(r.keys()), set(query.keys()))
871 871 a = r['a']
872 872 nt.assert_equal({'status', 'data', 'metadata'}, set(a.keys()))
873 873 nt.assert_equal(a['status'], 'ok')
874 874 data = a['data']
875 875 metadata = a['metadata']
876 876 nt.assert_equal(data.get('text/plain'), '3')
877 877
878 878 b = r['b']
879 879 nt.assert_equal(b['status'], 'error')
880 880 nt.assert_equal(b['ename'], 'ZeroDivisionError')
881 881
882 882 # back to text only
883 883 ip.display_formatter.active_types = ['text/plain']
884 884
885 885
886 886 class TestSyntaxErrorTransformer(unittest.TestCase):
887 887 """Check that SyntaxError raised by an input transformer is handled by run_cell()"""
888 888
889 889 @staticmethod
890 890 def transformer(lines):
891 891 for line in lines:
892 892 pos = line.find('syntaxerror')
893 893 if pos >= 0:
894 894 e = SyntaxError('input contains "syntaxerror"')
895 895 e.text = line
896 896 e.offset = pos + 1
897 897 raise e
898 898 return lines
899 899
900 900 def setUp(self):
901 901 ip.input_transformers_post.append(self.transformer)
902 902
903 903 def tearDown(self):
904 904 ip.input_transformers_post.remove(self.transformer)
905 905
906 906 def test_syntaxerror_input_transformer(self):
907 907 with tt.AssertPrints('1234'):
908 908 ip.run_cell('1234')
909 909 with tt.AssertPrints('SyntaxError: invalid syntax'):
910 910 ip.run_cell('1 2 3') # plain python syntax error
911 911 with tt.AssertPrints('SyntaxError: input contains "syntaxerror"'):
912 912 ip.run_cell('2345 # syntaxerror') # input transformer syntax error
913 913 with tt.AssertPrints('3456'):
914 914 ip.run_cell('3456')
915 915
916 916
917 917 class TestWarningSuppression(unittest.TestCase):
918 918 def test_warning_suppression(self):
919 919 ip.run_cell("import warnings")
920 920 try:
921 921 with self.assertWarnsRegex(UserWarning, "asdf"):
922 922 ip.run_cell("warnings.warn('asdf')")
923 923 # Here's the real test -- if we run that again, we should get the
924 924 # warning again. Traditionally, each warning was only issued once per
925 925 # IPython session (approximately), even if the user typed in new and
926 926 # different code that should have also triggered the warning, leading
927 927 # to much confusion.
928 928 with self.assertWarnsRegex(UserWarning, "asdf"):
929 929 ip.run_cell("warnings.warn('asdf')")
930 930 finally:
931 931 ip.run_cell("del warnings")
932 932
933 933
934 934 def test_deprecation_warning(self):
935 935 ip.run_cell("""
936 936 import warnings
937 937 def wrn():
938 938 warnings.warn(
939 939 "I AM A WARNING",
940 940 DeprecationWarning
941 941 )
942 942 """)
943 943 try:
944 944 with self.assertWarnsRegex(DeprecationWarning, "I AM A WARNING"):
945 945 ip.run_cell("wrn()")
946 946 finally:
947 947 ip.run_cell("del warnings")
948 948 ip.run_cell("del wrn")
949 949
950 950
951 951 class TestImportNoDeprecate(tt.TempFileMixin):
952 952
953 953 def setUp(self):
954 954 """Make a valid python temp file."""
955 955 self.mktmp("""
956 956 import warnings
957 957 def wrn():
958 958 warnings.warn(
959 959 "I AM A WARNING",
960 960 DeprecationWarning
961 961 )
962 962 """)
963 963 super().setUp()
964 964
965 965 def test_no_dep(self):
966 966 """
967 967 No deprecation warning should be raised from imported functions
968 968 """
969 969 ip.run_cell("from {} import wrn".format(self.fname))
970 970
971 971 with tt.AssertNotPrints("I AM A WARNING"):
972 972 ip.run_cell("wrn()")
973 973 ip.run_cell("del wrn")
974 974
975 975
976 976 def test_custom_exc_count():
977 977 hook = mock.Mock(return_value=None)
978 978 ip.set_custom_exc((SyntaxError,), hook)
979 979 before = ip.execution_count
980 980 ip.run_cell("def foo()", store_history=True)
981 981 # restore default excepthook
982 982 ip.set_custom_exc((), None)
983 983 nt.assert_equal(hook.call_count, 1)
984 984 nt.assert_equal(ip.execution_count, before + 1)
985 985
986 986
987 987 def test_run_cell_async():
988 988 loop = asyncio.get_event_loop()
989 989 ip.run_cell("import asyncio")
990 990 coro = ip.run_cell_async("await asyncio.sleep(0.01)\n5")
991 991 assert asyncio.iscoroutine(coro)
992 992 result = loop.run_until_complete(coro)
993 993 assert isinstance(result, interactiveshell.ExecutionResult)
994 994 assert result.result == 5
995 995
996 996
997 997 def test_should_run_async():
998 998 assert not ip.should_run_async("a = 5")
999 999 assert ip.should_run_async("await x")
1000 1000 assert ip.should_run_async("import asyncio; await asyncio.sleep(1)")
1001
1002
1003 def test_set_custom_completer():
1004 num_completers = len(ip.Completer.matchers)
1005
1006 def foo(*args, **kwargs):
1007 return "I'm a completer!"
1008
1009 ip.set_custom_completer(foo, 0)
1010
1011 # check that we've really added a new completer
1012 assert len(ip.Completer.matchers) == num_completers + 1
1013
1014 # check that the first completer is the function we defined
1015 assert ip.Completer.matchers[0]() == "I'm a completer!"
1016
1017 # clean up
1018 ip.Completer.custom_matchers.pop()
General Comments 0
You need to be logged in to leave comments. Login now