##// END OF EJS Templates
Simplify IPythonInputSplitter API
Thomas Kluyver -
Show More
@@ -1,668 +1,672 b''
1 1 """Analysis of text input into executable blocks.
2 2
3 3 The main class in this module, :class:`InputSplitter`, is designed to break
4 4 input from either interactive, line-by-line environments or block-based ones,
5 5 into standalone blocks that can be executed by Python as 'single' statements
6 6 (thus triggering sys.displayhook).
7 7
8 8 A companion, :class:`IPythonInputSplitter`, provides the same functionality but
9 9 with full support for the extended IPython syntax (magics, system calls, etc).
10 10
11 11 For more details, see the class docstring below.
12 12
13 13 Syntax Transformations
14 14 ----------------------
15 15
16 16 One of the main jobs of the code in this file is to apply all syntax
17 17 transformations that make up 'the IPython language', i.e. magics, shell
18 18 escapes, etc. All transformations should be implemented as *fully stateless*
19 19 entities, that simply take one line as their input and return a line.
20 20 Internally for implementation purposes they may be a normal function or a
21 21 callable object, but the only input they receive will be a single line and they
22 22 should only return a line, without holding any data-dependent state between
23 23 calls.
24 24
25 25 As an example, the EscapedTransformer is a class so we can more clearly group
26 26 together the functionality of dispatching to individual functions based on the
27 27 starting escape character, but the only method for public use is its call
28 28 method.
29 29
30 30
31 31 ToDo
32 32 ----
33 33
34 34 - Should we make push() actually raise an exception once push_accepts_more()
35 35 returns False?
36 36
37 37 - Naming cleanups. The tr_* names aren't the most elegant, though now they are
38 38 at least just attributes of a class so not really very exposed.
39 39
40 40 - Think about the best way to support dynamic things: automagic, autocall,
41 41 macros, etc.
42 42
43 43 - Think of a better heuristic for the application of the transforms in
44 44 IPythonInputSplitter.push() than looking at the buffer ending in ':'. Idea:
45 45 track indentation change events (indent, dedent, nothing) and apply them only
46 46 if the indentation went up, but not otherwise.
47 47
48 48 - Think of the cleanest way for supporting user-specified transformations (the
49 49 user prefilters we had before).
50 50
51 51 Authors
52 52 -------
53 53
54 54 * Fernando Perez
55 55 * Brian Granger
56 56 """
57 57 #-----------------------------------------------------------------------------
58 58 # Copyright (C) 2010 The IPython Development Team
59 59 #
60 60 # Distributed under the terms of the BSD License. The full license is in
61 61 # the file COPYING, distributed as part of this software.
62 62 #-----------------------------------------------------------------------------
63 63
64 64 #-----------------------------------------------------------------------------
65 65 # Imports
66 66 #-----------------------------------------------------------------------------
67 67 # stdlib
68 68 import ast
69 69 import codeop
70 70 import re
71 71 import sys
72 72
73 73 # IPython modules
74 74 from IPython.utils.py3compat import cast_unicode
75 75 from IPython.core.inputtransformer import (leading_indent,
76 76 classic_prompt,
77 77 ipy_prompt,
78 78 strip_encoding_cookie,
79 79 cellmagic,
80 80 assemble_logical_lines,
81 81 help_end,
82 82 escaped_commands,
83 83 assign_from_magic,
84 84 assign_from_system,
85 85 assemble_python_lines,
86 86 )
87 87
88 88 # These are available in this module for backwards compatibility.
89 89 from IPython.core.inputtransformer import (ESC_SHELL, ESC_SH_CAP, ESC_HELP,
90 90 ESC_HELP2, ESC_MAGIC, ESC_MAGIC2,
91 91 ESC_QUOTE, ESC_QUOTE2, ESC_PAREN, ESC_SEQUENCES)
92 92
93 93 #-----------------------------------------------------------------------------
94 94 # Utilities
95 95 #-----------------------------------------------------------------------------
96 96
97 97 # FIXME: These are general-purpose utilities that later can be moved to the
98 98 # general ward. Kept here for now because we're being very strict about test
99 99 # coverage with this code, and this lets us ensure that we keep 100% coverage
100 100 # while developing.
101 101
102 102 # compiled regexps for autoindent management
103 103 dedent_re = re.compile('|'.join([
104 104 r'^\s+raise(\s.*)?$', # raise statement (+ space + other stuff, maybe)
105 105 r'^\s+raise\([^\)]*\).*$', # wacky raise with immediate open paren
106 106 r'^\s+return(\s.*)?$', # normal return (+ space + other stuff, maybe)
107 107 r'^\s+return\([^\)]*\).*$', # wacky return with immediate open paren
108 108 r'^\s+pass\s*$', # pass (optionally followed by trailing spaces)
109 109 r'^\s+break\s*$', # break (optionally followed by trailing spaces)
110 110 r'^\s+continue\s*$', # continue (optionally followed by trailing spaces)
111 111 ]))
112 112 ini_spaces_re = re.compile(r'^([ \t\r\f\v]+)')
113 113
114 114 # regexp to match pure comment lines so we don't accidentally insert 'if 1:'
115 115 # before pure comments
116 116 comment_line_re = re.compile('^\s*\#')
117 117
118 118
119 119 def num_ini_spaces(s):
120 120 """Return the number of initial spaces in a string.
121 121
122 122 Note that tabs are counted as a single space. For now, we do *not* support
123 123 mixing of tabs and spaces in the user's input.
124 124
125 125 Parameters
126 126 ----------
127 127 s : string
128 128
129 129 Returns
130 130 -------
131 131 n : int
132 132 """
133 133
134 134 ini_spaces = ini_spaces_re.match(s)
135 135 if ini_spaces:
136 136 return ini_spaces.end()
137 137 else:
138 138 return 0
139 139
140 140 def last_blank(src):
141 141 """Determine if the input source ends in a blank.
142 142
143 143 A blank is either a newline or a line consisting of whitespace.
144 144
145 145 Parameters
146 146 ----------
147 147 src : string
148 148 A single or multiline string.
149 149 """
150 150 if not src: return False
151 151 ll = src.splitlines()[-1]
152 152 return (ll == '') or ll.isspace()
153 153
154 154
155 155 last_two_blanks_re = re.compile(r'\n\s*\n\s*$', re.MULTILINE)
156 156 last_two_blanks_re2 = re.compile(r'.+\n\s*\n\s+$', re.MULTILINE)
157 157
158 158 def last_two_blanks(src):
159 159 """Determine if the input source ends in two blanks.
160 160
161 161 A blank is either a newline or a line consisting of whitespace.
162 162
163 163 Parameters
164 164 ----------
165 165 src : string
166 166 A single or multiline string.
167 167 """
168 168 if not src: return False
169 169 # The logic here is tricky: I couldn't get a regexp to work and pass all
170 170 # the tests, so I took a different approach: split the source by lines,
171 171 # grab the last two and prepend '###\n' as a stand-in for whatever was in
172 172 # the body before the last two lines. Then, with that structure, it's
173 173 # possible to analyze with two regexps. Not the most elegant solution, but
174 174 # it works. If anyone tries to change this logic, make sure to validate
175 175 # the whole test suite first!
176 176 new_src = '\n'.join(['###\n'] + src.splitlines()[-2:])
177 177 return (bool(last_two_blanks_re.match(new_src)) or
178 178 bool(last_two_blanks_re2.match(new_src)) )
179 179
180 180
181 181 def remove_comments(src):
182 182 """Remove all comments from input source.
183 183
184 184 Note: comments are NOT recognized inside of strings!
185 185
186 186 Parameters
187 187 ----------
188 188 src : string
189 189 A single or multiline input string.
190 190
191 191 Returns
192 192 -------
193 193 String with all Python comments removed.
194 194 """
195 195
196 196 return re.sub('#.*', '', src)
197 197
198 198
199 199 def get_input_encoding():
200 200 """Return the default standard input encoding.
201 201
202 202 If sys.stdin has no encoding, 'ascii' is returned."""
203 203 # There are strange environments for which sys.stdin.encoding is None. We
204 204 # ensure that a valid encoding is returned.
205 205 encoding = getattr(sys.stdin, 'encoding', None)
206 206 if encoding is None:
207 207 encoding = 'ascii'
208 208 return encoding
209 209
210 210 #-----------------------------------------------------------------------------
211 211 # Classes and functions for normal Python syntax handling
212 212 #-----------------------------------------------------------------------------
213 213
214 214 class InputSplitter(object):
215 215 """An object that can accumulate lines of Python source before execution.
216 216
217 217 This object is designed to be fed python source line-by-line, using
218 218 :meth:`push`. It will return on each push whether the currently pushed
219 219 code could be executed already. In addition, it provides a method called
220 220 :meth:`push_accepts_more` that can be used to query whether more input
221 221 can be pushed into a single interactive block.
222 222
223 223 This is a simple example of how an interactive terminal-based client can use
224 224 this tool::
225 225
226 226 isp = InputSplitter()
227 227 while isp.push_accepts_more():
228 228 indent = ' '*isp.indent_spaces
229 229 prompt = '>>> ' + indent
230 230 line = indent + raw_input(prompt)
231 231 isp.push(line)
232 232 print 'Input source was:\n', isp.source_reset(),
233 233 """
234 234 # Number of spaces of indentation computed from input that has been pushed
235 235 # so far. This is the attributes callers should query to get the current
236 236 # indentation level, in order to provide auto-indent facilities.
237 237 indent_spaces = 0
238 238 # String, indicating the default input encoding. It is computed by default
239 239 # at initialization time via get_input_encoding(), but it can be reset by a
240 240 # client with specific knowledge of the encoding.
241 241 encoding = ''
242 242 # String where the current full source input is stored, properly encoded.
243 243 # Reading this attribute is the normal way of querying the currently pushed
244 244 # source code, that has been properly encoded.
245 245 source = ''
246 246 # Code object corresponding to the current source. It is automatically
247 247 # synced to the source, so it can be queried at any time to obtain the code
248 248 # object; it will be None if the source doesn't compile to valid Python.
249 249 code = None
250 250
251 251 # Private attributes
252 252
253 253 # List with lines of input accumulated so far
254 254 _buffer = None
255 255 # Command compiler
256 256 _compile = None
257 257 # Mark when input has changed indentation all the way back to flush-left
258 258 _full_dedent = False
259 259 # Boolean indicating whether the current block is complete
260 260 _is_complete = None
261 261
262 262 def __init__(self):
263 263 """Create a new InputSplitter instance.
264 264 """
265 265 self._buffer = []
266 266 self._compile = codeop.CommandCompiler()
267 267 self.encoding = get_input_encoding()
268 268
269 269 def reset(self):
270 270 """Reset the input buffer and associated state."""
271 271 self.indent_spaces = 0
272 272 self._buffer[:] = []
273 273 self.source = ''
274 274 self.code = None
275 275 self._is_complete = False
276 276 self._full_dedent = False
277 277
278 278 def source_reset(self):
279 279 """Return the input source and perform a full reset.
280 280 """
281 281 out = self.source
282 282 self.reset()
283 283 return out
284 284
285 285 def push(self, lines):
286 286 """Push one or more lines of input.
287 287
288 288 This stores the given lines and returns a status code indicating
289 289 whether the code forms a complete Python block or not.
290 290
291 291 Any exceptions generated in compilation are swallowed, but if an
292 292 exception was produced, the method returns True.
293 293
294 294 Parameters
295 295 ----------
296 296 lines : string
297 297 One or more lines of Python input.
298 298
299 299 Returns
300 300 -------
301 301 is_complete : boolean
302 302 True if the current input source (the result of the current input
303 303 plus prior inputs) forms a complete Python execution block. Note that
304 304 this value is also stored as a private attribute (``_is_complete``), so it
305 305 can be queried at any time.
306 306 """
307 307 self._store(lines)
308 308 source = self.source
309 309
310 310 # Before calling _compile(), reset the code object to None so that if an
311 311 # exception is raised in compilation, we don't mislead by having
312 312 # inconsistent code/source attributes.
313 313 self.code, self._is_complete = None, None
314 314
315 315 # Honor termination lines properly
316 316 if source.endswith('\\\n'):
317 317 return False
318 318
319 319 self._update_indent(lines)
320 320 try:
321 321 self.code = self._compile(source, symbol="exec")
322 322 # Invalid syntax can produce any of a number of different errors from
323 323 # inside the compiler, so we have to catch them all. Syntax errors
324 324 # immediately produce a 'ready' block, so the invalid Python can be
325 325 # sent to the kernel for evaluation with possible ipython
326 326 # special-syntax conversion.
327 327 except (SyntaxError, OverflowError, ValueError, TypeError,
328 328 MemoryError):
329 329 self._is_complete = True
330 330 else:
331 331 # Compilation didn't produce any exceptions (though it may not have
332 332 # given a complete code object)
333 333 self._is_complete = self.code is not None
334 334
335 335 return self._is_complete
336 336
337 337 def push_accepts_more(self):
338 338 """Return whether a block of interactive input can accept more input.
339 339
340 340 This method is meant to be used by line-oriented frontends, who need to
341 341 guess whether a block is complete or not based solely on prior and
342 342 current input lines. The InputSplitter considers it has a complete
343 343 interactive block and will not accept more input when either:
344 344
345 345 * A SyntaxError is raised
346 346
347 347 * The code is complete and consists of a single line or a single
348 348 non-compound statement
349 349
350 350 * The code is complete and has a blank line at the end
351 351
352 352 If the current input produces a syntax error, this method immediately
353 353 returns False but does *not* raise the syntax error exception, as
354 354 typically clients will want to send invalid syntax to an execution
355 355 backend which might convert the invalid syntax into valid Python via
356 356 one of the dynamic IPython mechanisms.
357 357 """
358 358
359 359 # With incomplete input, unconditionally accept more
360 360 # A syntax error also sets _is_complete to True - see push()
361 361 if not self._is_complete:
362 362 #print("Not complete") # debug
363 363 return True
364 364
365 365 # The user can make any (complete) input execute by leaving a blank line
366 366 last_line = self.source.splitlines()[-1]
367 367 if (not last_line) or last_line.isspace():
368 368 #print("Blank line") # debug
369 369 return False
370 370
371 371 # If there's just a single line or AST node, and we're flush left, as is
372 372 # the case after a simple statement such as 'a=1', we want to execute it
373 373 # straight away.
374 374 if self.indent_spaces==0:
375 375 if len(self.source.splitlines()) <= 1:
376 376 return False
377 377
378 378 try:
379 379 code_ast = ast.parse(u''.join(self._buffer))
380 380 except Exception:
381 381 #print("Can't parse AST") # debug
382 382 return False
383 383 else:
384 384 if len(code_ast.body) == 1 and \
385 385 not hasattr(code_ast.body[0], 'body'):
386 386 #print("Simple statement") # debug
387 387 return False
388 388
389 389 # General fallback - accept more code
390 390 return True
391 391
392 392 #------------------------------------------------------------------------
393 393 # Private interface
394 394 #------------------------------------------------------------------------
395 395
396 396 def _find_indent(self, line):
397 397 """Compute the new indentation level for a single line.
398 398
399 399 Parameters
400 400 ----------
401 401 line : str
402 402 A single new line of non-whitespace, non-comment Python input.
403 403
404 404 Returns
405 405 -------
406 406 indent_spaces : int
407 407 New value for the indent level (it may be equal to self.indent_spaces
408 408 if indentation doesn't change.
409 409
410 410 full_dedent : boolean
411 411 Whether the new line causes a full flush-left dedent.
412 412 """
413 413 indent_spaces = self.indent_spaces
414 414 full_dedent = self._full_dedent
415 415
416 416 inisp = num_ini_spaces(line)
417 417 if inisp < indent_spaces:
418 418 indent_spaces = inisp
419 419 if indent_spaces <= 0:
420 420 #print 'Full dedent in text',self.source # dbg
421 421 full_dedent = True
422 422
423 423 if line.rstrip()[-1] == ':':
424 424 indent_spaces += 4
425 425 elif dedent_re.match(line):
426 426 indent_spaces -= 4
427 427 if indent_spaces <= 0:
428 428 full_dedent = True
429 429
430 430 # Safety
431 431 if indent_spaces < 0:
432 432 indent_spaces = 0
433 433 #print 'safety' # dbg
434 434
435 435 return indent_spaces, full_dedent
436 436
437 437 def _update_indent(self, lines):
438 438 for line in remove_comments(lines).splitlines():
439 439 if line and not line.isspace():
440 440 self.indent_spaces, self._full_dedent = self._find_indent(line)
441 441
442 442 def _store(self, lines, buffer=None, store='source'):
443 443 """Store one or more lines of input.
444 444
445 445 If input lines are not newline-terminated, a newline is automatically
446 446 appended."""
447 447
448 448 if buffer is None:
449 449 buffer = self._buffer
450 450
451 451 if lines.endswith('\n'):
452 452 buffer.append(lines)
453 453 else:
454 454 buffer.append(lines+'\n')
455 455 setattr(self, store, self._set_source(buffer))
456 456
457 457 def _set_source(self, buffer):
458 458 return u''.join(buffer)
459 459
460 460
461 461 class IPythonInputSplitter(InputSplitter):
462 462 """An input splitter that recognizes all of IPython's special syntax."""
463 463
464 464 # String with raw, untransformed input.
465 465 source_raw = ''
466 466
467 467 # Flag to track when a transformer has stored input that it hasn't given
468 468 # back yet.
469 469 transformer_accumulating = False
470 470
471 471 # Flag to track when assemble_python_lines has stored input that it hasn't
472 472 # given back yet.
473 473 within_python_line = False
474 474
475 475 # Private attributes
476 476
477 477 # List with lines of raw input accumulated so far.
478 478 _buffer_raw = None
479 479
480 480 def __init__(self, line_input_checker=True, physical_line_transforms=None,
481 481 logical_line_transforms=None, python_line_transforms=None):
482 482 super(IPythonInputSplitter, self).__init__()
483 483 self._buffer_raw = []
484 484 self._validate = True
485 485
486 486 if physical_line_transforms is not None:
487 487 self.physical_line_transforms = physical_line_transforms
488 488 else:
489 489 self.physical_line_transforms = [
490 490 leading_indent(),
491 491 classic_prompt(),
492 492 ipy_prompt(),
493 493 strip_encoding_cookie(),
494 494 cellmagic(end_on_blank_line=line_input_checker),
495 495 ]
496 496
497 497 self.assemble_logical_lines = assemble_logical_lines()
498 498 if logical_line_transforms is not None:
499 499 self.logical_line_transforms = logical_line_transforms
500 500 else:
501 501 self.logical_line_transforms = [
502 502 help_end(),
503 503 escaped_commands(),
504 504 assign_from_magic(),
505 505 assign_from_system(),
506 506 ]
507 507
508 508 self.assemble_python_lines = assemble_python_lines()
509 509 if python_line_transforms is not None:
510 510 self.python_line_transforms = python_line_transforms
511 511 else:
512 512 # We don't use any of these at present
513 513 self.python_line_transforms = []
514 514
515 515 @property
516 516 def transforms(self):
517 517 "Quick access to all transformers."
518 518 return self.physical_line_transforms + \
519 519 [self.assemble_logical_lines] + self.logical_line_transforms + \
520 520 [self.assemble_python_lines] + self.python_line_transforms
521 521
522 522 @property
523 523 def transforms_in_use(self):
524 524 """Transformers, excluding logical line transformers if we're in a
525 525 Python line."""
526 526 t = self.physical_line_transforms[:]
527 527 if not self.within_python_line:
528 528 t += [self.assemble_logical_lines] + self.logical_line_transforms
529 529 return t + [self.assemble_python_lines] + self.python_line_transforms
530 530
531 531 def reset(self):
532 532 """Reset the input buffer and associated state."""
533 533 super(IPythonInputSplitter, self).reset()
534 534 self._buffer_raw[:] = []
535 535 self.source_raw = ''
536 536 self.transformer_accumulating = False
537 537 self.within_python_line = False
538 538
539 last_exc = None
540 539 for t in self.transforms:
541 540 try:
542 541 t.reset()
543 except SyntaxError as e:
544 last_exc = e
545 if last_exc is not None:
546 raise last_exc
542 except SyntaxError:
543 # Nothing that calls reset() expects to handle transformer
544 # errors
545 pass
547 546
548 547 def flush_transformers(self):
549 548 def _flush(transform, out):
550 549 if out is not None:
551 550 tmp = transform.push(out)
552 551 return tmp or transform.reset() or None
553 552 else:
554 553 return transform.reset() or None
555 554
556 555 out = None
557 556 for t in self.transforms_in_use:
558 557 out = _flush(t, out)
559 558
560 559 if out is not None:
561 560 self._store(out)
562 561
563 def source_raw_reset(self):
564 """Return input and raw source and perform a full reset.
562 def raw_reset(self):
563 """Return raw input only and perform a full reset.
565 564 """
566 self.flush_transformers()
567 out = self.source
568 out_r = self.source_raw
565 out = self.source_raw
569 566 self.reset()
570 return out, out_r
567 return out
571 568
572 569 def source_reset(self):
570 try:
573 571 self.flush_transformers()
574 return super(IPythonInputSplitter, self).source_reset()
572 return self.source
573 finally:
574 self.reset()
575 575
576 576 def push_accepts_more(self):
577 577 if self.transformer_accumulating:
578 578 return True
579 579 else:
580 580 return super(IPythonInputSplitter, self).push_accepts_more()
581 581
582 582 def transform_cell(self, cell):
583 583 """Process and translate a cell of input.
584 584 """
585 585 self.reset()
586 try:
586 587 self.push(cell)
587 return self.source_reset()
588 self.flush_transformers()
589 return self.source
590 finally:
591 self.reset()
588 592
589 593 def push(self, lines):
590 594 """Push one or more lines of IPython input.
591 595
592 596 This stores the given lines and returns a status code indicating
593 597 whether the code forms a complete Python block or not, after processing
594 598 all input lines for special IPython syntax.
595 599
596 600 Any exceptions generated in compilation are swallowed, but if an
597 601 exception was produced, the method returns True.
598 602
599 603 Parameters
600 604 ----------
601 605 lines : string
602 606 One or more lines of Python input.
603 607
604 608 Returns
605 609 -------
606 610 is_complete : boolean
607 611 True if the current input source (the result of the current input
608 612 plus prior inputs) forms a complete Python execution block. Note that
609 613 this value is also stored as a private attribute (_is_complete), so it
610 614 can be queried at any time.
611 615 """
612 616
613 617 # We must ensure all input is pure unicode
614 618 lines = cast_unicode(lines, self.encoding)
615 619
616 620 # ''.splitlines() --> [], but we need to push the empty line to transformers
617 621 lines_list = lines.splitlines()
618 622 if not lines_list:
619 623 lines_list = ['']
620 624
621 625 # Store raw source before applying any transformations to it. Note
622 626 # that this must be done *after* the reset() call that would otherwise
623 627 # flush the buffer.
624 628 self._store(lines, self._buffer_raw, 'source_raw')
625 629
626 630 for line in lines_list:
627 631 out = self.push_line(line)
628 632
629 633 return out
630 634
631 635 def push_line(self, line):
632 636 buf = self._buffer
633 637
634 638 def _accumulating(dbg):
635 639 #print(dbg)
636 640 self.transformer_accumulating = True
637 641 return False
638 642
639 643 for transformer in self.physical_line_transforms:
640 644 line = transformer.push(line)
641 645 if line is None:
642 646 return _accumulating(transformer)
643 647
644 648 if not self.within_python_line:
645 649 line = self.assemble_logical_lines.push(line)
646 650 if line is None:
647 651 return _accumulating('acc logical line')
648 652
649 653 for transformer in self.logical_line_transforms:
650 654 line = transformer.push(line)
651 655 if line is None:
652 656 return _accumulating(transformer)
653 657
654 658 line = self.assemble_python_lines.push(line)
655 659 if line is None:
656 660 self.within_python_line = True
657 661 return _accumulating('acc python line')
658 662 else:
659 663 self.within_python_line = False
660 664
661 665 for transformer in self.python_line_transforms:
662 666 line = transformer.push(line)
663 667 if line is None:
664 668 return _accumulating(transformer)
665 669
666 670 #print("transformers clear") #debug
667 671 self.transformer_accumulating = False
668 672 return super(IPythonInputSplitter, self).push(line)
@@ -1,3178 +1,3177 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 # Imports
15 15 #-----------------------------------------------------------------------------
16 16
17 17 from __future__ import absolute_import
18 18 from __future__ import print_function
19 19
20 20 import __future__
21 21 import abc
22 22 import ast
23 23 import atexit
24 24 import functools
25 25 import os
26 26 import re
27 27 import runpy
28 28 import sys
29 29 import tempfile
30 30 import types
31 31 import subprocess
32 32 from io import open as io_open
33 33
34 34 from IPython.config.configurable import SingletonConfigurable
35 35 from IPython.core import debugger, 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 shadowns
40 40 from IPython.core import ultratb
41 41 from IPython.core.alias import AliasManager, AliasError
42 42 from IPython.core.autocall import ExitAutocall
43 43 from IPython.core.builtin_trap import BuiltinTrap
44 44 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
45 45 from IPython.core.display_trap import DisplayTrap
46 46 from IPython.core.displayhook import DisplayHook
47 47 from IPython.core.displaypub import DisplayPublisher
48 48 from IPython.core.error import UsageError
49 49 from IPython.core.extensions import ExtensionManager
50 50 from IPython.core.formatters import DisplayFormatter
51 51 from IPython.core.history import HistoryManager
52 52 from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2
53 53 from IPython.core.logger import Logger
54 54 from IPython.core.macro import Macro
55 55 from IPython.core.payload import PayloadManager
56 56 from IPython.core.prefilter import PrefilterManager
57 57 from IPython.core.profiledir import ProfileDir
58 58 from IPython.core.prompts import PromptManager
59 59 from IPython.lib.latextools import LaTeXTool
60 60 from IPython.testing.skipdoctest import skip_doctest
61 61 from IPython.utils import PyColorize
62 62 from IPython.utils import io
63 63 from IPython.utils import py3compat
64 64 from IPython.utils import openpy
65 65 from IPython.utils.decorators import undoc
66 66 from IPython.utils.io import ask_yes_no
67 67 from IPython.utils.ipstruct import Struct
68 68 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename
69 69 from IPython.utils.pickleshare import PickleShareDB
70 70 from IPython.utils.process import system, getoutput
71 71 from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,
72 72 with_metaclass, iteritems)
73 73 from IPython.utils.strdispatch import StrDispatch
74 74 from IPython.utils.syspathcontext import prepended_to_syspath
75 75 from IPython.utils.text import (format_screen, LSString, SList,
76 76 DollarFormatter)
77 77 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
78 78 List, Unicode, Instance, Type)
79 79 from IPython.utils.warn import warn, error
80 80 import IPython.core.hooks
81 81
82 82 #-----------------------------------------------------------------------------
83 83 # Globals
84 84 #-----------------------------------------------------------------------------
85 85
86 86 # compiled regexps for autoindent management
87 87 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
88 88
89 89 #-----------------------------------------------------------------------------
90 90 # Utilities
91 91 #-----------------------------------------------------------------------------
92 92
93 93 @undoc
94 94 def softspace(file, newvalue):
95 95 """Copied from code.py, to remove the dependency"""
96 96
97 97 oldvalue = 0
98 98 try:
99 99 oldvalue = file.softspace
100 100 except AttributeError:
101 101 pass
102 102 try:
103 103 file.softspace = newvalue
104 104 except (AttributeError, TypeError):
105 105 # "attribute-less object" or "read-only attributes"
106 106 pass
107 107 return oldvalue
108 108
109 109 @undoc
110 110 def no_op(*a, **kw): pass
111 111
112 112 @undoc
113 113 class NoOpContext(object):
114 114 def __enter__(self): pass
115 115 def __exit__(self, type, value, traceback): pass
116 116 no_op_context = NoOpContext()
117 117
118 118 class SpaceInInput(Exception): pass
119 119
120 120 @undoc
121 121 class Bunch: pass
122 122
123 123
124 124 def get_default_colors():
125 125 if sys.platform=='darwin':
126 126 return "LightBG"
127 127 elif os.name=='nt':
128 128 return 'Linux'
129 129 else:
130 130 return 'Linux'
131 131
132 132
133 133 class SeparateUnicode(Unicode):
134 134 """A Unicode subclass to validate separate_in, separate_out, etc.
135 135
136 136 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
137 137 """
138 138
139 139 def validate(self, obj, value):
140 140 if value == '0': value = ''
141 141 value = value.replace('\\n','\n')
142 142 return super(SeparateUnicode, self).validate(obj, value)
143 143
144 144
145 145 class ReadlineNoRecord(object):
146 146 """Context manager to execute some code, then reload readline history
147 147 so that interactive input to the code doesn't appear when pressing up."""
148 148 def __init__(self, shell):
149 149 self.shell = shell
150 150 self._nested_level = 0
151 151
152 152 def __enter__(self):
153 153 if self._nested_level == 0:
154 154 try:
155 155 self.orig_length = self.current_length()
156 156 self.readline_tail = self.get_readline_tail()
157 157 except (AttributeError, IndexError): # Can fail with pyreadline
158 158 self.orig_length, self.readline_tail = 999999, []
159 159 self._nested_level += 1
160 160
161 161 def __exit__(self, type, value, traceback):
162 162 self._nested_level -= 1
163 163 if self._nested_level == 0:
164 164 # Try clipping the end if it's got longer
165 165 try:
166 166 e = self.current_length() - self.orig_length
167 167 if e > 0:
168 168 for _ in range(e):
169 169 self.shell.readline.remove_history_item(self.orig_length)
170 170
171 171 # If it still doesn't match, just reload readline history.
172 172 if self.current_length() != self.orig_length \
173 173 or self.get_readline_tail() != self.readline_tail:
174 174 self.shell.refill_readline_hist()
175 175 except (AttributeError, IndexError):
176 176 pass
177 177 # Returning False will cause exceptions to propagate
178 178 return False
179 179
180 180 def current_length(self):
181 181 return self.shell.readline.get_current_history_length()
182 182
183 183 def get_readline_tail(self, n=10):
184 184 """Get the last n items in readline history."""
185 185 end = self.shell.readline.get_current_history_length() + 1
186 186 start = max(end-n, 1)
187 187 ghi = self.shell.readline.get_history_item
188 188 return [ghi(x) for x in range(start, end)]
189 189
190 190
191 191 @undoc
192 192 class DummyMod(object):
193 193 """A dummy module used for IPython's interactive module when
194 194 a namespace must be assigned to the module's __dict__."""
195 195 pass
196 196
197 197 #-----------------------------------------------------------------------------
198 198 # Main IPython class
199 199 #-----------------------------------------------------------------------------
200 200
201 201 class InteractiveShell(SingletonConfigurable):
202 202 """An enhanced, interactive shell for Python."""
203 203
204 204 _instance = None
205 205
206 206 ast_transformers = List([], config=True, help=
207 207 """
208 208 A list of ast.NodeTransformer subclass instances, which will be applied
209 209 to user input before code is run.
210 210 """
211 211 )
212 212
213 213 autocall = Enum((0,1,2), default_value=0, config=True, help=
214 214 """
215 215 Make IPython automatically call any callable object even if you didn't
216 216 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
217 217 automatically. The value can be '0' to disable the feature, '1' for
218 218 'smart' autocall, where it is not applied if there are no more
219 219 arguments on the line, and '2' for 'full' autocall, where all callable
220 220 objects are automatically called (even if no arguments are present).
221 221 """
222 222 )
223 223 # TODO: remove all autoindent logic and put into frontends.
224 224 # We can't do this yet because even runlines uses the autoindent.
225 225 autoindent = CBool(True, config=True, help=
226 226 """
227 227 Autoindent IPython code entered interactively.
228 228 """
229 229 )
230 230 automagic = CBool(True, config=True, help=
231 231 """
232 232 Enable magic commands to be called without the leading %.
233 233 """
234 234 )
235 235 cache_size = Integer(1000, config=True, help=
236 236 """
237 237 Set the size of the output cache. The default is 1000, you can
238 238 change it permanently in your config file. Setting it to 0 completely
239 239 disables the caching system, and the minimum value accepted is 20 (if
240 240 you provide a value less than 20, it is reset to 0 and a warning is
241 241 issued). This limit is defined because otherwise you'll spend more
242 242 time re-flushing a too small cache than working
243 243 """
244 244 )
245 245 color_info = CBool(True, config=True, help=
246 246 """
247 247 Use colors for displaying information about objects. Because this
248 248 information is passed through a pager (like 'less'), and some pagers
249 249 get confused with color codes, this capability can be turned off.
250 250 """
251 251 )
252 252 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
253 253 default_value=get_default_colors(), config=True,
254 254 help="Set the color scheme (NoColor, Linux, or LightBG)."
255 255 )
256 256 colors_force = CBool(False, help=
257 257 """
258 258 Force use of ANSI color codes, regardless of OS and readline
259 259 availability.
260 260 """
261 261 # FIXME: This is essentially a hack to allow ZMQShell to show colors
262 262 # without readline on Win32. When the ZMQ formatting system is
263 263 # refactored, this should be removed.
264 264 )
265 265 debug = CBool(False, config=True)
266 266 deep_reload = CBool(False, config=True, help=
267 267 """
268 268 Enable deep (recursive) reloading by default. IPython can use the
269 269 deep_reload module which reloads changes in modules recursively (it
270 270 replaces the reload() function, so you don't need to change anything to
271 271 use it). deep_reload() forces a full reload of modules whose code may
272 272 have changed, which the default reload() function does not. When
273 273 deep_reload is off, IPython will use the normal reload(), but
274 274 deep_reload will still be available as dreload().
275 275 """
276 276 )
277 277 disable_failing_post_execute = CBool(False, config=True,
278 278 help="Don't call post-execute functions that have failed in the past."
279 279 )
280 280 display_formatter = Instance(DisplayFormatter)
281 281 displayhook_class = Type(DisplayHook)
282 282 display_pub_class = Type(DisplayPublisher)
283 283 data_pub_class = None
284 284
285 285 exit_now = CBool(False)
286 286 exiter = Instance(ExitAutocall)
287 287 def _exiter_default(self):
288 288 return ExitAutocall(self)
289 289 # Monotonically increasing execution counter
290 290 execution_count = Integer(1)
291 291 filename = Unicode("<ipython console>")
292 292 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
293 293
294 294 # Input splitter, to transform input line by line and detect when a block
295 295 # is ready to be executed.
296 296 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
297 297 (), {'line_input_checker': True})
298 298
299 299 # This InputSplitter instance is used to transform completed cells before
300 300 # running them. It allows cell magics to contain blank lines.
301 301 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
302 302 (), {'line_input_checker': False})
303 303
304 304 logstart = CBool(False, config=True, help=
305 305 """
306 306 Start logging to the default log file.
307 307 """
308 308 )
309 309 logfile = Unicode('', config=True, help=
310 310 """
311 311 The name of the logfile to use.
312 312 """
313 313 )
314 314 logappend = Unicode('', config=True, help=
315 315 """
316 316 Start logging to the given file in append mode.
317 317 """
318 318 )
319 319 object_info_string_level = Enum((0,1,2), default_value=0,
320 320 config=True)
321 321 pdb = CBool(False, config=True, help=
322 322 """
323 323 Automatically call the pdb debugger after every exception.
324 324 """
325 325 )
326 326 multiline_history = CBool(sys.platform != 'win32', config=True,
327 327 help="Save multi-line entries as one entry in readline history"
328 328 )
329 329
330 330 # deprecated prompt traits:
331 331
332 332 prompt_in1 = Unicode('In [\\#]: ', config=True,
333 333 help="Deprecated, use PromptManager.in_template")
334 334 prompt_in2 = Unicode(' .\\D.: ', config=True,
335 335 help="Deprecated, use PromptManager.in2_template")
336 336 prompt_out = Unicode('Out[\\#]: ', config=True,
337 337 help="Deprecated, use PromptManager.out_template")
338 338 prompts_pad_left = CBool(True, config=True,
339 339 help="Deprecated, use PromptManager.justify")
340 340
341 341 def _prompt_trait_changed(self, name, old, new):
342 342 table = {
343 343 'prompt_in1' : 'in_template',
344 344 'prompt_in2' : 'in2_template',
345 345 'prompt_out' : 'out_template',
346 346 'prompts_pad_left' : 'justify',
347 347 }
348 348 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
349 349 name=name, newname=table[name])
350 350 )
351 351 # protect against weird cases where self.config may not exist:
352 352 if self.config is not None:
353 353 # propagate to corresponding PromptManager trait
354 354 setattr(self.config.PromptManager, table[name], new)
355 355
356 356 _prompt_in1_changed = _prompt_trait_changed
357 357 _prompt_in2_changed = _prompt_trait_changed
358 358 _prompt_out_changed = _prompt_trait_changed
359 359 _prompt_pad_left_changed = _prompt_trait_changed
360 360
361 361 show_rewritten_input = CBool(True, config=True,
362 362 help="Show rewritten input, e.g. for autocall."
363 363 )
364 364
365 365 quiet = CBool(False, config=True)
366 366
367 367 history_length = Integer(10000, config=True)
368 368
369 369 # The readline stuff will eventually be moved to the terminal subclass
370 370 # but for now, we can't do that as readline is welded in everywhere.
371 371 readline_use = CBool(True, config=True)
372 372 readline_remove_delims = Unicode('-/~', config=True)
373 373 readline_delims = Unicode() # set by init_readline()
374 374 # don't use \M- bindings by default, because they
375 375 # conflict with 8-bit encodings. See gh-58,gh-88
376 376 readline_parse_and_bind = List([
377 377 'tab: complete',
378 378 '"\C-l": clear-screen',
379 379 'set show-all-if-ambiguous on',
380 380 '"\C-o": tab-insert',
381 381 '"\C-r": reverse-search-history',
382 382 '"\C-s": forward-search-history',
383 383 '"\C-p": history-search-backward',
384 384 '"\C-n": history-search-forward',
385 385 '"\e[A": history-search-backward',
386 386 '"\e[B": history-search-forward',
387 387 '"\C-k": kill-line',
388 388 '"\C-u": unix-line-discard',
389 389 ], allow_none=False, config=True)
390 390
391 391 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
392 392 default_value='last_expr', config=True,
393 393 help="""
394 394 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
395 395 run interactively (displaying output from expressions).""")
396 396
397 397 # TODO: this part of prompt management should be moved to the frontends.
398 398 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
399 399 separate_in = SeparateUnicode('\n', config=True)
400 400 separate_out = SeparateUnicode('', config=True)
401 401 separate_out2 = SeparateUnicode('', config=True)
402 402 wildcards_case_sensitive = CBool(True, config=True)
403 403 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
404 404 default_value='Context', config=True)
405 405
406 406 # Subcomponents of InteractiveShell
407 407 alias_manager = Instance('IPython.core.alias.AliasManager')
408 408 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
409 409 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
410 410 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
411 411 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
412 412 payload_manager = Instance('IPython.core.payload.PayloadManager')
413 413 history_manager = Instance('IPython.core.history.HistoryManager')
414 414 magics_manager = Instance('IPython.core.magic.MagicsManager')
415 415
416 416 profile_dir = Instance('IPython.core.application.ProfileDir')
417 417 @property
418 418 def profile(self):
419 419 if self.profile_dir is not None:
420 420 name = os.path.basename(self.profile_dir.location)
421 421 return name.replace('profile_','')
422 422
423 423
424 424 # Private interface
425 425 _post_execute = Instance(dict)
426 426
427 427 # Tracks any GUI loop loaded for pylab
428 428 pylab_gui_select = None
429 429
430 430 def __init__(self, ipython_dir=None, profile_dir=None,
431 431 user_module=None, user_ns=None,
432 432 custom_exceptions=((), None), **kwargs):
433 433
434 434 # This is where traits with a config_key argument are updated
435 435 # from the values on config.
436 436 super(InteractiveShell, self).__init__(**kwargs)
437 437 self.configurables = [self]
438 438
439 439 # These are relatively independent and stateless
440 440 self.init_ipython_dir(ipython_dir)
441 441 self.init_profile_dir(profile_dir)
442 442 self.init_instance_attrs()
443 443 self.init_environment()
444 444
445 445 # Check if we're in a virtualenv, and set up sys.path.
446 446 self.init_virtualenv()
447 447
448 448 # Create namespaces (user_ns, user_global_ns, etc.)
449 449 self.init_create_namespaces(user_module, user_ns)
450 450 # This has to be done after init_create_namespaces because it uses
451 451 # something in self.user_ns, but before init_sys_modules, which
452 452 # is the first thing to modify sys.
453 453 # TODO: When we override sys.stdout and sys.stderr before this class
454 454 # is created, we are saving the overridden ones here. Not sure if this
455 455 # is what we want to do.
456 456 self.save_sys_module_state()
457 457 self.init_sys_modules()
458 458
459 459 # While we're trying to have each part of the code directly access what
460 460 # it needs without keeping redundant references to objects, we have too
461 461 # much legacy code that expects ip.db to exist.
462 462 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
463 463
464 464 self.init_history()
465 465 self.init_encoding()
466 466 self.init_prefilter()
467 467
468 468 self.init_syntax_highlighting()
469 469 self.init_hooks()
470 470 self.init_pushd_popd_magic()
471 471 # self.init_traceback_handlers use to be here, but we moved it below
472 472 # because it and init_io have to come after init_readline.
473 473 self.init_user_ns()
474 474 self.init_logger()
475 475 self.init_builtins()
476 476
477 477 # The following was in post_config_initialization
478 478 self.init_inspector()
479 479 # init_readline() must come before init_io(), because init_io uses
480 480 # readline related things.
481 481 self.init_readline()
482 482 # We save this here in case user code replaces raw_input, but it needs
483 483 # to be after init_readline(), because PyPy's readline works by replacing
484 484 # raw_input.
485 485 if py3compat.PY3:
486 486 self.raw_input_original = input
487 487 else:
488 488 self.raw_input_original = raw_input
489 489 # init_completer must come after init_readline, because it needs to
490 490 # know whether readline is present or not system-wide to configure the
491 491 # completers, since the completion machinery can now operate
492 492 # independently of readline (e.g. over the network)
493 493 self.init_completer()
494 494 # TODO: init_io() needs to happen before init_traceback handlers
495 495 # because the traceback handlers hardcode the stdout/stderr streams.
496 496 # This logic in in debugger.Pdb and should eventually be changed.
497 497 self.init_io()
498 498 self.init_traceback_handlers(custom_exceptions)
499 499 self.init_prompts()
500 500 self.init_display_formatter()
501 501 self.init_display_pub()
502 502 self.init_data_pub()
503 503 self.init_displayhook()
504 504 self.init_latextool()
505 505 self.init_magics()
506 506 self.init_alias()
507 507 self.init_logstart()
508 508 self.init_pdb()
509 509 self.init_extension_manager()
510 510 self.init_payload()
511 511 self.init_comms()
512 512 self.hooks.late_startup_hook()
513 513 atexit.register(self.atexit_operations)
514 514
515 515 def get_ipython(self):
516 516 """Return the currently running IPython instance."""
517 517 return self
518 518
519 519 #-------------------------------------------------------------------------
520 520 # Trait changed handlers
521 521 #-------------------------------------------------------------------------
522 522
523 523 def _ipython_dir_changed(self, name, new):
524 524 if not os.path.isdir(new):
525 525 os.makedirs(new, mode = 0o777)
526 526
527 527 def set_autoindent(self,value=None):
528 528 """Set the autoindent flag, checking for readline support.
529 529
530 530 If called with no arguments, it acts as a toggle."""
531 531
532 532 if value != 0 and not self.has_readline:
533 533 if os.name == 'posix':
534 534 warn("The auto-indent feature requires the readline library")
535 535 self.autoindent = 0
536 536 return
537 537 if value is None:
538 538 self.autoindent = not self.autoindent
539 539 else:
540 540 self.autoindent = value
541 541
542 542 #-------------------------------------------------------------------------
543 543 # init_* methods called by __init__
544 544 #-------------------------------------------------------------------------
545 545
546 546 def init_ipython_dir(self, ipython_dir):
547 547 if ipython_dir is not None:
548 548 self.ipython_dir = ipython_dir
549 549 return
550 550
551 551 self.ipython_dir = get_ipython_dir()
552 552
553 553 def init_profile_dir(self, profile_dir):
554 554 if profile_dir is not None:
555 555 self.profile_dir = profile_dir
556 556 return
557 557 self.profile_dir =\
558 558 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
559 559
560 560 def init_instance_attrs(self):
561 561 self.more = False
562 562
563 563 # command compiler
564 564 self.compile = CachingCompiler()
565 565
566 566 # Make an empty namespace, which extension writers can rely on both
567 567 # existing and NEVER being used by ipython itself. This gives them a
568 568 # convenient location for storing additional information and state
569 569 # their extensions may require, without fear of collisions with other
570 570 # ipython names that may develop later.
571 571 self.meta = Struct()
572 572
573 573 # Temporary files used for various purposes. Deleted at exit.
574 574 self.tempfiles = []
575 575
576 576 # Keep track of readline usage (later set by init_readline)
577 577 self.has_readline = False
578 578
579 579 # keep track of where we started running (mainly for crash post-mortem)
580 580 # This is not being used anywhere currently.
581 581 self.starting_dir = py3compat.getcwd()
582 582
583 583 # Indentation management
584 584 self.indent_current_nsp = 0
585 585
586 586 # Dict to track post-execution functions that have been registered
587 587 self._post_execute = {}
588 588
589 589 def init_environment(self):
590 590 """Any changes we need to make to the user's environment."""
591 591 pass
592 592
593 593 def init_encoding(self):
594 594 # Get system encoding at startup time. Certain terminals (like Emacs
595 595 # under Win32 have it set to None, and we need to have a known valid
596 596 # encoding to use in the raw_input() method
597 597 try:
598 598 self.stdin_encoding = sys.stdin.encoding or 'ascii'
599 599 except AttributeError:
600 600 self.stdin_encoding = 'ascii'
601 601
602 602 def init_syntax_highlighting(self):
603 603 # Python source parser/formatter for syntax highlighting
604 604 pyformat = PyColorize.Parser().format
605 605 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
606 606
607 607 def init_pushd_popd_magic(self):
608 608 # for pushd/popd management
609 609 self.home_dir = get_home_dir()
610 610
611 611 self.dir_stack = []
612 612
613 613 def init_logger(self):
614 614 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
615 615 logmode='rotate')
616 616
617 617 def init_logstart(self):
618 618 """Initialize logging in case it was requested at the command line.
619 619 """
620 620 if self.logappend:
621 621 self.magic('logstart %s append' % self.logappend)
622 622 elif self.logfile:
623 623 self.magic('logstart %s' % self.logfile)
624 624 elif self.logstart:
625 625 self.magic('logstart')
626 626
627 627 def init_builtins(self):
628 628 # A single, static flag that we set to True. Its presence indicates
629 629 # that an IPython shell has been created, and we make no attempts at
630 630 # removing on exit or representing the existence of more than one
631 631 # IPython at a time.
632 632 builtin_mod.__dict__['__IPYTHON__'] = True
633 633
634 634 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
635 635 # manage on enter/exit, but with all our shells it's virtually
636 636 # impossible to get all the cases right. We're leaving the name in for
637 637 # those who adapted their codes to check for this flag, but will
638 638 # eventually remove it after a few more releases.
639 639 builtin_mod.__dict__['__IPYTHON__active'] = \
640 640 'Deprecated, check for __IPYTHON__'
641 641
642 642 self.builtin_trap = BuiltinTrap(shell=self)
643 643
644 644 def init_inspector(self):
645 645 # Object inspector
646 646 self.inspector = oinspect.Inspector(oinspect.InspectColors,
647 647 PyColorize.ANSICodeColors,
648 648 'NoColor',
649 649 self.object_info_string_level)
650 650
651 651 def init_io(self):
652 652 # This will just use sys.stdout and sys.stderr. If you want to
653 653 # override sys.stdout and sys.stderr themselves, you need to do that
654 654 # *before* instantiating this class, because io holds onto
655 655 # references to the underlying streams.
656 656 if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
657 657 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
658 658 else:
659 659 io.stdout = io.IOStream(sys.stdout)
660 660 io.stderr = io.IOStream(sys.stderr)
661 661
662 662 def init_prompts(self):
663 663 self.prompt_manager = PromptManager(shell=self, parent=self)
664 664 self.configurables.append(self.prompt_manager)
665 665 # Set system prompts, so that scripts can decide if they are running
666 666 # interactively.
667 667 sys.ps1 = 'In : '
668 668 sys.ps2 = '...: '
669 669 sys.ps3 = 'Out: '
670 670
671 671 def init_display_formatter(self):
672 672 self.display_formatter = DisplayFormatter(parent=self)
673 673 self.configurables.append(self.display_formatter)
674 674
675 675 def init_display_pub(self):
676 676 self.display_pub = self.display_pub_class(parent=self)
677 677 self.configurables.append(self.display_pub)
678 678
679 679 def init_data_pub(self):
680 680 if not self.data_pub_class:
681 681 self.data_pub = None
682 682 return
683 683 self.data_pub = self.data_pub_class(parent=self)
684 684 self.configurables.append(self.data_pub)
685 685
686 686 def init_displayhook(self):
687 687 # Initialize displayhook, set in/out prompts and printing system
688 688 self.displayhook = self.displayhook_class(
689 689 parent=self,
690 690 shell=self,
691 691 cache_size=self.cache_size,
692 692 )
693 693 self.configurables.append(self.displayhook)
694 694 # This is a context manager that installs/revmoes the displayhook at
695 695 # the appropriate time.
696 696 self.display_trap = DisplayTrap(hook=self.displayhook)
697 697
698 698 def init_latextool(self):
699 699 """Configure LaTeXTool."""
700 700 cfg = LaTeXTool.instance(parent=self)
701 701 if cfg not in self.configurables:
702 702 self.configurables.append(cfg)
703 703
704 704 def init_virtualenv(self):
705 705 """Add a virtualenv to sys.path so the user can import modules from it.
706 706 This isn't perfect: it doesn't use the Python interpreter with which the
707 707 virtualenv was built, and it ignores the --no-site-packages option. A
708 708 warning will appear suggesting the user installs IPython in the
709 709 virtualenv, but for many cases, it probably works well enough.
710 710
711 711 Adapted from code snippets online.
712 712
713 713 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
714 714 """
715 715 if 'VIRTUAL_ENV' not in os.environ:
716 716 # Not in a virtualenv
717 717 return
718 718
719 719 if os.path.realpath(sys.executable).startswith(
720 720 os.path.realpath(os.environ['VIRTUAL_ENV'])
721 721 ):
722 722 # Running properly in the virtualenv, don't need to do anything
723 723 return
724 724
725 725 warn("Attempting to work in a virtualenv. If you encounter problems, please "
726 726 "install IPython inside the virtualenv.")
727 727 if sys.platform == "win32":
728 728 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
729 729 else:
730 730 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
731 731 'python%d.%d' % sys.version_info[:2], 'site-packages')
732 732
733 733 import site
734 734 sys.path.insert(0, virtual_env)
735 735 site.addsitedir(virtual_env)
736 736
737 737 #-------------------------------------------------------------------------
738 738 # Things related to injections into the sys module
739 739 #-------------------------------------------------------------------------
740 740
741 741 def save_sys_module_state(self):
742 742 """Save the state of hooks in the sys module.
743 743
744 744 This has to be called after self.user_module is created.
745 745 """
746 746 self._orig_sys_module_state = {}
747 747 self._orig_sys_module_state['stdin'] = sys.stdin
748 748 self._orig_sys_module_state['stdout'] = sys.stdout
749 749 self._orig_sys_module_state['stderr'] = sys.stderr
750 750 self._orig_sys_module_state['excepthook'] = sys.excepthook
751 751 self._orig_sys_modules_main_name = self.user_module.__name__
752 752 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
753 753
754 754 def restore_sys_module_state(self):
755 755 """Restore the state of the sys module."""
756 756 try:
757 757 for k, v in iteritems(self._orig_sys_module_state):
758 758 setattr(sys, k, v)
759 759 except AttributeError:
760 760 pass
761 761 # Reset what what done in self.init_sys_modules
762 762 if self._orig_sys_modules_main_mod is not None:
763 763 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
764 764
765 765 #-------------------------------------------------------------------------
766 766 # Things related to hooks
767 767 #-------------------------------------------------------------------------
768 768
769 769 def init_hooks(self):
770 770 # hooks holds pointers used for user-side customizations
771 771 self.hooks = Struct()
772 772
773 773 self.strdispatchers = {}
774 774
775 775 # Set all default hooks, defined in the IPython.hooks module.
776 776 hooks = IPython.core.hooks
777 777 for hook_name in hooks.__all__:
778 778 # default hooks have priority 100, i.e. low; user hooks should have
779 779 # 0-100 priority
780 780 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
781 781
782 782 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
783 783 """set_hook(name,hook) -> sets an internal IPython hook.
784 784
785 785 IPython exposes some of its internal API as user-modifiable hooks. By
786 786 adding your function to one of these hooks, you can modify IPython's
787 787 behavior to call at runtime your own routines."""
788 788
789 789 # At some point in the future, this should validate the hook before it
790 790 # accepts it. Probably at least check that the hook takes the number
791 791 # of args it's supposed to.
792 792
793 793 f = types.MethodType(hook,self)
794 794
795 795 # check if the hook is for strdispatcher first
796 796 if str_key is not None:
797 797 sdp = self.strdispatchers.get(name, StrDispatch())
798 798 sdp.add_s(str_key, f, priority )
799 799 self.strdispatchers[name] = sdp
800 800 return
801 801 if re_key is not None:
802 802 sdp = self.strdispatchers.get(name, StrDispatch())
803 803 sdp.add_re(re.compile(re_key), f, priority )
804 804 self.strdispatchers[name] = sdp
805 805 return
806 806
807 807 dp = getattr(self.hooks, name, None)
808 808 if name not in IPython.core.hooks.__all__:
809 809 print("Warning! Hook '%s' is not one of %s" % \
810 810 (name, IPython.core.hooks.__all__ ))
811 811 if not dp:
812 812 dp = IPython.core.hooks.CommandChainDispatcher()
813 813
814 814 try:
815 815 dp.add(f,priority)
816 816 except AttributeError:
817 817 # it was not commandchain, plain old func - replace
818 818 dp = f
819 819
820 820 setattr(self.hooks,name, dp)
821 821
822 822 def register_post_execute(self, func):
823 823 """Register a function for calling after code execution.
824 824 """
825 825 if not callable(func):
826 826 raise ValueError('argument %s must be callable' % func)
827 827 self._post_execute[func] = True
828 828
829 829 #-------------------------------------------------------------------------
830 830 # Things related to the "main" module
831 831 #-------------------------------------------------------------------------
832 832
833 833 def new_main_mod(self, filename, modname):
834 834 """Return a new 'main' module object for user code execution.
835 835
836 836 ``filename`` should be the path of the script which will be run in the
837 837 module. Requests with the same filename will get the same module, with
838 838 its namespace cleared.
839 839
840 840 ``modname`` should be the module name - normally either '__main__' or
841 841 the basename of the file without the extension.
842 842
843 843 When scripts are executed via %run, we must keep a reference to their
844 844 __main__ module around so that Python doesn't
845 845 clear it, rendering references to module globals useless.
846 846
847 847 This method keeps said reference in a private dict, keyed by the
848 848 absolute path of the script. This way, for multiple executions of the
849 849 same script we only keep one copy of the namespace (the last one),
850 850 thus preventing memory leaks from old references while allowing the
851 851 objects from the last execution to be accessible.
852 852 """
853 853 filename = os.path.abspath(filename)
854 854 try:
855 855 main_mod = self._main_mod_cache[filename]
856 856 except KeyError:
857 857 main_mod = self._main_mod_cache[filename] = types.ModuleType(modname,
858 858 doc="Module created for script run in IPython")
859 859 else:
860 860 main_mod.__dict__.clear()
861 861 main_mod.__name__ = modname
862 862
863 863 main_mod.__file__ = filename
864 864 # It seems pydoc (and perhaps others) needs any module instance to
865 865 # implement a __nonzero__ method
866 866 main_mod.__nonzero__ = lambda : True
867 867
868 868 return main_mod
869 869
870 870 def clear_main_mod_cache(self):
871 871 """Clear the cache of main modules.
872 872
873 873 Mainly for use by utilities like %reset.
874 874
875 875 Examples
876 876 --------
877 877
878 878 In [15]: import IPython
879 879
880 880 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
881 881
882 882 In [17]: len(_ip._main_mod_cache) > 0
883 883 Out[17]: True
884 884
885 885 In [18]: _ip.clear_main_mod_cache()
886 886
887 887 In [19]: len(_ip._main_mod_cache) == 0
888 888 Out[19]: True
889 889 """
890 890 self._main_mod_cache.clear()
891 891
892 892 #-------------------------------------------------------------------------
893 893 # Things related to debugging
894 894 #-------------------------------------------------------------------------
895 895
896 896 def init_pdb(self):
897 897 # Set calling of pdb on exceptions
898 898 # self.call_pdb is a property
899 899 self.call_pdb = self.pdb
900 900
901 901 def _get_call_pdb(self):
902 902 return self._call_pdb
903 903
904 904 def _set_call_pdb(self,val):
905 905
906 906 if val not in (0,1,False,True):
907 907 raise ValueError('new call_pdb value must be boolean')
908 908
909 909 # store value in instance
910 910 self._call_pdb = val
911 911
912 912 # notify the actual exception handlers
913 913 self.InteractiveTB.call_pdb = val
914 914
915 915 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
916 916 'Control auto-activation of pdb at exceptions')
917 917
918 918 def debugger(self,force=False):
919 919 """Call the pydb/pdb debugger.
920 920
921 921 Keywords:
922 922
923 923 - force(False): by default, this routine checks the instance call_pdb
924 924 flag and does not actually invoke the debugger if the flag is false.
925 925 The 'force' option forces the debugger to activate even if the flag
926 926 is false.
927 927 """
928 928
929 929 if not (force or self.call_pdb):
930 930 return
931 931
932 932 if not hasattr(sys,'last_traceback'):
933 933 error('No traceback has been produced, nothing to debug.')
934 934 return
935 935
936 936 # use pydb if available
937 937 if debugger.has_pydb:
938 938 from pydb import pm
939 939 else:
940 940 # fallback to our internal debugger
941 941 pm = lambda : self.InteractiveTB.debugger(force=True)
942 942
943 943 with self.readline_no_record:
944 944 pm()
945 945
946 946 #-------------------------------------------------------------------------
947 947 # Things related to IPython's various namespaces
948 948 #-------------------------------------------------------------------------
949 949 default_user_namespaces = True
950 950
951 951 def init_create_namespaces(self, user_module=None, user_ns=None):
952 952 # Create the namespace where the user will operate. user_ns is
953 953 # normally the only one used, and it is passed to the exec calls as
954 954 # the locals argument. But we do carry a user_global_ns namespace
955 955 # given as the exec 'globals' argument, This is useful in embedding
956 956 # situations where the ipython shell opens in a context where the
957 957 # distinction between locals and globals is meaningful. For
958 958 # non-embedded contexts, it is just the same object as the user_ns dict.
959 959
960 960 # FIXME. For some strange reason, __builtins__ is showing up at user
961 961 # level as a dict instead of a module. This is a manual fix, but I
962 962 # should really track down where the problem is coming from. Alex
963 963 # Schmolck reported this problem first.
964 964
965 965 # A useful post by Alex Martelli on this topic:
966 966 # Re: inconsistent value from __builtins__
967 967 # Von: Alex Martelli <aleaxit@yahoo.com>
968 968 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
969 969 # Gruppen: comp.lang.python
970 970
971 971 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
972 972 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
973 973 # > <type 'dict'>
974 974 # > >>> print type(__builtins__)
975 975 # > <type 'module'>
976 976 # > Is this difference in return value intentional?
977 977
978 978 # Well, it's documented that '__builtins__' can be either a dictionary
979 979 # or a module, and it's been that way for a long time. Whether it's
980 980 # intentional (or sensible), I don't know. In any case, the idea is
981 981 # that if you need to access the built-in namespace directly, you
982 982 # should start with "import __builtin__" (note, no 's') which will
983 983 # definitely give you a module. Yeah, it's somewhat confusing:-(.
984 984
985 985 # These routines return a properly built module and dict as needed by
986 986 # the rest of the code, and can also be used by extension writers to
987 987 # generate properly initialized namespaces.
988 988 if (user_ns is not None) or (user_module is not None):
989 989 self.default_user_namespaces = False
990 990 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
991 991
992 992 # A record of hidden variables we have added to the user namespace, so
993 993 # we can list later only variables defined in actual interactive use.
994 994 self.user_ns_hidden = {}
995 995
996 996 # Now that FakeModule produces a real module, we've run into a nasty
997 997 # problem: after script execution (via %run), the module where the user
998 998 # code ran is deleted. Now that this object is a true module (needed
999 999 # so docetst and other tools work correctly), the Python module
1000 1000 # teardown mechanism runs over it, and sets to None every variable
1001 1001 # present in that module. Top-level references to objects from the
1002 1002 # script survive, because the user_ns is updated with them. However,
1003 1003 # calling functions defined in the script that use other things from
1004 1004 # the script will fail, because the function's closure had references
1005 1005 # to the original objects, which are now all None. So we must protect
1006 1006 # these modules from deletion by keeping a cache.
1007 1007 #
1008 1008 # To avoid keeping stale modules around (we only need the one from the
1009 1009 # last run), we use a dict keyed with the full path to the script, so
1010 1010 # only the last version of the module is held in the cache. Note,
1011 1011 # however, that we must cache the module *namespace contents* (their
1012 1012 # __dict__). Because if we try to cache the actual modules, old ones
1013 1013 # (uncached) could be destroyed while still holding references (such as
1014 1014 # those held by GUI objects that tend to be long-lived)>
1015 1015 #
1016 1016 # The %reset command will flush this cache. See the cache_main_mod()
1017 1017 # and clear_main_mod_cache() methods for details on use.
1018 1018
1019 1019 # This is the cache used for 'main' namespaces
1020 1020 self._main_mod_cache = {}
1021 1021
1022 1022 # A table holding all the namespaces IPython deals with, so that
1023 1023 # introspection facilities can search easily.
1024 1024 self.ns_table = {'user_global':self.user_module.__dict__,
1025 1025 'user_local':self.user_ns,
1026 1026 'builtin':builtin_mod.__dict__
1027 1027 }
1028 1028
1029 1029 @property
1030 1030 def user_global_ns(self):
1031 1031 return self.user_module.__dict__
1032 1032
1033 1033 def prepare_user_module(self, user_module=None, user_ns=None):
1034 1034 """Prepare the module and namespace in which user code will be run.
1035 1035
1036 1036 When IPython is started normally, both parameters are None: a new module
1037 1037 is created automatically, and its __dict__ used as the namespace.
1038 1038
1039 1039 If only user_module is provided, its __dict__ is used as the namespace.
1040 1040 If only user_ns is provided, a dummy module is created, and user_ns
1041 1041 becomes the global namespace. If both are provided (as they may be
1042 1042 when embedding), user_ns is the local namespace, and user_module
1043 1043 provides the global namespace.
1044 1044
1045 1045 Parameters
1046 1046 ----------
1047 1047 user_module : module, optional
1048 1048 The current user module in which IPython is being run. If None,
1049 1049 a clean module will be created.
1050 1050 user_ns : dict, optional
1051 1051 A namespace in which to run interactive commands.
1052 1052
1053 1053 Returns
1054 1054 -------
1055 1055 A tuple of user_module and user_ns, each properly initialised.
1056 1056 """
1057 1057 if user_module is None and user_ns is not None:
1058 1058 user_ns.setdefault("__name__", "__main__")
1059 1059 user_module = DummyMod()
1060 1060 user_module.__dict__ = user_ns
1061 1061
1062 1062 if user_module is None:
1063 1063 user_module = types.ModuleType("__main__",
1064 1064 doc="Automatically created module for IPython interactive environment")
1065 1065
1066 1066 # We must ensure that __builtin__ (without the final 's') is always
1067 1067 # available and pointing to the __builtin__ *module*. For more details:
1068 1068 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1069 1069 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1070 1070 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1071 1071
1072 1072 if user_ns is None:
1073 1073 user_ns = user_module.__dict__
1074 1074
1075 1075 return user_module, user_ns
1076 1076
1077 1077 def init_sys_modules(self):
1078 1078 # We need to insert into sys.modules something that looks like a
1079 1079 # module but which accesses the IPython namespace, for shelve and
1080 1080 # pickle to work interactively. Normally they rely on getting
1081 1081 # everything out of __main__, but for embedding purposes each IPython
1082 1082 # instance has its own private namespace, so we can't go shoving
1083 1083 # everything into __main__.
1084 1084
1085 1085 # note, however, that we should only do this for non-embedded
1086 1086 # ipythons, which really mimic the __main__.__dict__ with their own
1087 1087 # namespace. Embedded instances, on the other hand, should not do
1088 1088 # this because they need to manage the user local/global namespaces
1089 1089 # only, but they live within a 'normal' __main__ (meaning, they
1090 1090 # shouldn't overtake the execution environment of the script they're
1091 1091 # embedded in).
1092 1092
1093 1093 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1094 1094 main_name = self.user_module.__name__
1095 1095 sys.modules[main_name] = self.user_module
1096 1096
1097 1097 def init_user_ns(self):
1098 1098 """Initialize all user-visible namespaces to their minimum defaults.
1099 1099
1100 1100 Certain history lists are also initialized here, as they effectively
1101 1101 act as user namespaces.
1102 1102
1103 1103 Notes
1104 1104 -----
1105 1105 All data structures here are only filled in, they are NOT reset by this
1106 1106 method. If they were not empty before, data will simply be added to
1107 1107 therm.
1108 1108 """
1109 1109 # This function works in two parts: first we put a few things in
1110 1110 # user_ns, and we sync that contents into user_ns_hidden so that these
1111 1111 # initial variables aren't shown by %who. After the sync, we add the
1112 1112 # rest of what we *do* want the user to see with %who even on a new
1113 1113 # session (probably nothing, so theye really only see their own stuff)
1114 1114
1115 1115 # The user dict must *always* have a __builtin__ reference to the
1116 1116 # Python standard __builtin__ namespace, which must be imported.
1117 1117 # This is so that certain operations in prompt evaluation can be
1118 1118 # reliably executed with builtins. Note that we can NOT use
1119 1119 # __builtins__ (note the 's'), because that can either be a dict or a
1120 1120 # module, and can even mutate at runtime, depending on the context
1121 1121 # (Python makes no guarantees on it). In contrast, __builtin__ is
1122 1122 # always a module object, though it must be explicitly imported.
1123 1123
1124 1124 # For more details:
1125 1125 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1126 1126 ns = dict()
1127 1127
1128 1128 # Put 'help' in the user namespace
1129 1129 try:
1130 1130 from site import _Helper
1131 1131 ns['help'] = _Helper()
1132 1132 except ImportError:
1133 1133 warn('help() not available - check site.py')
1134 1134
1135 1135 # make global variables for user access to the histories
1136 1136 ns['_ih'] = self.history_manager.input_hist_parsed
1137 1137 ns['_oh'] = self.history_manager.output_hist
1138 1138 ns['_dh'] = self.history_manager.dir_hist
1139 1139
1140 1140 ns['_sh'] = shadowns
1141 1141
1142 1142 # user aliases to input and output histories. These shouldn't show up
1143 1143 # in %who, as they can have very large reprs.
1144 1144 ns['In'] = self.history_manager.input_hist_parsed
1145 1145 ns['Out'] = self.history_manager.output_hist
1146 1146
1147 1147 # Store myself as the public api!!!
1148 1148 ns['get_ipython'] = self.get_ipython
1149 1149
1150 1150 ns['exit'] = self.exiter
1151 1151 ns['quit'] = self.exiter
1152 1152
1153 1153 # Sync what we've added so far to user_ns_hidden so these aren't seen
1154 1154 # by %who
1155 1155 self.user_ns_hidden.update(ns)
1156 1156
1157 1157 # Anything put into ns now would show up in %who. Think twice before
1158 1158 # putting anything here, as we really want %who to show the user their
1159 1159 # stuff, not our variables.
1160 1160
1161 1161 # Finally, update the real user's namespace
1162 1162 self.user_ns.update(ns)
1163 1163
1164 1164 @property
1165 1165 def all_ns_refs(self):
1166 1166 """Get a list of references to all the namespace dictionaries in which
1167 1167 IPython might store a user-created object.
1168 1168
1169 1169 Note that this does not include the displayhook, which also caches
1170 1170 objects from the output."""
1171 1171 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1172 1172 [m.__dict__ for m in self._main_mod_cache.values()]
1173 1173
1174 1174 def reset(self, new_session=True):
1175 1175 """Clear all internal namespaces, and attempt to release references to
1176 1176 user objects.
1177 1177
1178 1178 If new_session is True, a new history session will be opened.
1179 1179 """
1180 1180 # Clear histories
1181 1181 self.history_manager.reset(new_session)
1182 1182 # Reset counter used to index all histories
1183 1183 if new_session:
1184 1184 self.execution_count = 1
1185 1185
1186 1186 # Flush cached output items
1187 1187 if self.displayhook.do_full_cache:
1188 1188 self.displayhook.flush()
1189 1189
1190 1190 # The main execution namespaces must be cleared very carefully,
1191 1191 # skipping the deletion of the builtin-related keys, because doing so
1192 1192 # would cause errors in many object's __del__ methods.
1193 1193 if self.user_ns is not self.user_global_ns:
1194 1194 self.user_ns.clear()
1195 1195 ns = self.user_global_ns
1196 1196 drop_keys = set(ns.keys())
1197 1197 drop_keys.discard('__builtin__')
1198 1198 drop_keys.discard('__builtins__')
1199 1199 drop_keys.discard('__name__')
1200 1200 for k in drop_keys:
1201 1201 del ns[k]
1202 1202
1203 1203 self.user_ns_hidden.clear()
1204 1204
1205 1205 # Restore the user namespaces to minimal usability
1206 1206 self.init_user_ns()
1207 1207
1208 1208 # Restore the default and user aliases
1209 1209 self.alias_manager.clear_aliases()
1210 1210 self.alias_manager.init_aliases()
1211 1211
1212 1212 # Flush the private list of module references kept for script
1213 1213 # execution protection
1214 1214 self.clear_main_mod_cache()
1215 1215
1216 1216 def del_var(self, varname, by_name=False):
1217 1217 """Delete a variable from the various namespaces, so that, as
1218 1218 far as possible, we're not keeping any hidden references to it.
1219 1219
1220 1220 Parameters
1221 1221 ----------
1222 1222 varname : str
1223 1223 The name of the variable to delete.
1224 1224 by_name : bool
1225 1225 If True, delete variables with the given name in each
1226 1226 namespace. If False (default), find the variable in the user
1227 1227 namespace, and delete references to it.
1228 1228 """
1229 1229 if varname in ('__builtin__', '__builtins__'):
1230 1230 raise ValueError("Refusing to delete %s" % varname)
1231 1231
1232 1232 ns_refs = self.all_ns_refs
1233 1233
1234 1234 if by_name: # Delete by name
1235 1235 for ns in ns_refs:
1236 1236 try:
1237 1237 del ns[varname]
1238 1238 except KeyError:
1239 1239 pass
1240 1240 else: # Delete by object
1241 1241 try:
1242 1242 obj = self.user_ns[varname]
1243 1243 except KeyError:
1244 1244 raise NameError("name '%s' is not defined" % varname)
1245 1245 # Also check in output history
1246 1246 ns_refs.append(self.history_manager.output_hist)
1247 1247 for ns in ns_refs:
1248 1248 to_delete = [n for n, o in iteritems(ns) if o is obj]
1249 1249 for name in to_delete:
1250 1250 del ns[name]
1251 1251
1252 1252 # displayhook keeps extra references, but not in a dictionary
1253 1253 for name in ('_', '__', '___'):
1254 1254 if getattr(self.displayhook, name) is obj:
1255 1255 setattr(self.displayhook, name, None)
1256 1256
1257 1257 def reset_selective(self, regex=None):
1258 1258 """Clear selective variables from internal namespaces based on a
1259 1259 specified regular expression.
1260 1260
1261 1261 Parameters
1262 1262 ----------
1263 1263 regex : string or compiled pattern, optional
1264 1264 A regular expression pattern that will be used in searching
1265 1265 variable names in the users namespaces.
1266 1266 """
1267 1267 if regex is not None:
1268 1268 try:
1269 1269 m = re.compile(regex)
1270 1270 except TypeError:
1271 1271 raise TypeError('regex must be a string or compiled pattern')
1272 1272 # Search for keys in each namespace that match the given regex
1273 1273 # If a match is found, delete the key/value pair.
1274 1274 for ns in self.all_ns_refs:
1275 1275 for var in ns:
1276 1276 if m.search(var):
1277 1277 del ns[var]
1278 1278
1279 1279 def push(self, variables, interactive=True):
1280 1280 """Inject a group of variables into the IPython user namespace.
1281 1281
1282 1282 Parameters
1283 1283 ----------
1284 1284 variables : dict, str or list/tuple of str
1285 1285 The variables to inject into the user's namespace. If a dict, a
1286 1286 simple update is done. If a str, the string is assumed to have
1287 1287 variable names separated by spaces. A list/tuple of str can also
1288 1288 be used to give the variable names. If just the variable names are
1289 1289 give (list/tuple/str) then the variable values looked up in the
1290 1290 callers frame.
1291 1291 interactive : bool
1292 1292 If True (default), the variables will be listed with the ``who``
1293 1293 magic.
1294 1294 """
1295 1295 vdict = None
1296 1296
1297 1297 # We need a dict of name/value pairs to do namespace updates.
1298 1298 if isinstance(variables, dict):
1299 1299 vdict = variables
1300 1300 elif isinstance(variables, string_types+(list, tuple)):
1301 1301 if isinstance(variables, string_types):
1302 1302 vlist = variables.split()
1303 1303 else:
1304 1304 vlist = variables
1305 1305 vdict = {}
1306 1306 cf = sys._getframe(1)
1307 1307 for name in vlist:
1308 1308 try:
1309 1309 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1310 1310 except:
1311 1311 print('Could not get variable %s from %s' %
1312 1312 (name,cf.f_code.co_name))
1313 1313 else:
1314 1314 raise ValueError('variables must be a dict/str/list/tuple')
1315 1315
1316 1316 # Propagate variables to user namespace
1317 1317 self.user_ns.update(vdict)
1318 1318
1319 1319 # And configure interactive visibility
1320 1320 user_ns_hidden = self.user_ns_hidden
1321 1321 if interactive:
1322 1322 for name in vdict:
1323 1323 user_ns_hidden.pop(name, None)
1324 1324 else:
1325 1325 user_ns_hidden.update(vdict)
1326 1326
1327 1327 def drop_by_id(self, variables):
1328 1328 """Remove a dict of variables from the user namespace, if they are the
1329 1329 same as the values in the dictionary.
1330 1330
1331 1331 This is intended for use by extensions: variables that they've added can
1332 1332 be taken back out if they are unloaded, without removing any that the
1333 1333 user has overwritten.
1334 1334
1335 1335 Parameters
1336 1336 ----------
1337 1337 variables : dict
1338 1338 A dictionary mapping object names (as strings) to the objects.
1339 1339 """
1340 1340 for name, obj in iteritems(variables):
1341 1341 if name in self.user_ns and self.user_ns[name] is obj:
1342 1342 del self.user_ns[name]
1343 1343 self.user_ns_hidden.pop(name, None)
1344 1344
1345 1345 #-------------------------------------------------------------------------
1346 1346 # Things related to object introspection
1347 1347 #-------------------------------------------------------------------------
1348 1348
1349 1349 def _ofind(self, oname, namespaces=None):
1350 1350 """Find an object in the available namespaces.
1351 1351
1352 1352 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1353 1353
1354 1354 Has special code to detect magic functions.
1355 1355 """
1356 1356 oname = oname.strip()
1357 1357 #print '1- oname: <%r>' % oname # dbg
1358 1358 if not oname.startswith(ESC_MAGIC) and \
1359 1359 not oname.startswith(ESC_MAGIC2) and \
1360 1360 not py3compat.isidentifier(oname, dotted=True):
1361 1361 return dict(found=False)
1362 1362
1363 1363 alias_ns = None
1364 1364 if namespaces is None:
1365 1365 # Namespaces to search in:
1366 1366 # Put them in a list. The order is important so that we
1367 1367 # find things in the same order that Python finds them.
1368 1368 namespaces = [ ('Interactive', self.user_ns),
1369 1369 ('Interactive (global)', self.user_global_ns),
1370 1370 ('Python builtin', builtin_mod.__dict__),
1371 1371 ]
1372 1372
1373 1373 # initialize results to 'null'
1374 1374 found = False; obj = None; ospace = None; ds = None;
1375 1375 ismagic = False; isalias = False; parent = None
1376 1376
1377 1377 # We need to special-case 'print', which as of python2.6 registers as a
1378 1378 # function but should only be treated as one if print_function was
1379 1379 # loaded with a future import. In this case, just bail.
1380 1380 if (oname == 'print' and not py3compat.PY3 and not \
1381 1381 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1382 1382 return {'found':found, 'obj':obj, 'namespace':ospace,
1383 1383 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1384 1384
1385 1385 # Look for the given name by splitting it in parts. If the head is
1386 1386 # found, then we look for all the remaining parts as members, and only
1387 1387 # declare success if we can find them all.
1388 1388 oname_parts = oname.split('.')
1389 1389 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1390 1390 for nsname,ns in namespaces:
1391 1391 try:
1392 1392 obj = ns[oname_head]
1393 1393 except KeyError:
1394 1394 continue
1395 1395 else:
1396 1396 #print 'oname_rest:', oname_rest # dbg
1397 1397 for part in oname_rest:
1398 1398 try:
1399 1399 parent = obj
1400 1400 obj = getattr(obj,part)
1401 1401 except:
1402 1402 # Blanket except b/c some badly implemented objects
1403 1403 # allow __getattr__ to raise exceptions other than
1404 1404 # AttributeError, which then crashes IPython.
1405 1405 break
1406 1406 else:
1407 1407 # If we finish the for loop (no break), we got all members
1408 1408 found = True
1409 1409 ospace = nsname
1410 1410 break # namespace loop
1411 1411
1412 1412 # Try to see if it's magic
1413 1413 if not found:
1414 1414 obj = None
1415 1415 if oname.startswith(ESC_MAGIC2):
1416 1416 oname = oname.lstrip(ESC_MAGIC2)
1417 1417 obj = self.find_cell_magic(oname)
1418 1418 elif oname.startswith(ESC_MAGIC):
1419 1419 oname = oname.lstrip(ESC_MAGIC)
1420 1420 obj = self.find_line_magic(oname)
1421 1421 else:
1422 1422 # search without prefix, so run? will find %run?
1423 1423 obj = self.find_line_magic(oname)
1424 1424 if obj is None:
1425 1425 obj = self.find_cell_magic(oname)
1426 1426 if obj is not None:
1427 1427 found = True
1428 1428 ospace = 'IPython internal'
1429 1429 ismagic = True
1430 1430
1431 1431 # Last try: special-case some literals like '', [], {}, etc:
1432 1432 if not found and oname_head in ["''",'""','[]','{}','()']:
1433 1433 obj = eval(oname_head)
1434 1434 found = True
1435 1435 ospace = 'Interactive'
1436 1436
1437 1437 return {'found':found, 'obj':obj, 'namespace':ospace,
1438 1438 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1439 1439
1440 1440 def _ofind_property(self, oname, info):
1441 1441 """Second part of object finding, to look for property details."""
1442 1442 if info.found:
1443 1443 # Get the docstring of the class property if it exists.
1444 1444 path = oname.split('.')
1445 1445 root = '.'.join(path[:-1])
1446 1446 if info.parent is not None:
1447 1447 try:
1448 1448 target = getattr(info.parent, '__class__')
1449 1449 # The object belongs to a class instance.
1450 1450 try:
1451 1451 target = getattr(target, path[-1])
1452 1452 # The class defines the object.
1453 1453 if isinstance(target, property):
1454 1454 oname = root + '.__class__.' + path[-1]
1455 1455 info = Struct(self._ofind(oname))
1456 1456 except AttributeError: pass
1457 1457 except AttributeError: pass
1458 1458
1459 1459 # We return either the new info or the unmodified input if the object
1460 1460 # hadn't been found
1461 1461 return info
1462 1462
1463 1463 def _object_find(self, oname, namespaces=None):
1464 1464 """Find an object and return a struct with info about it."""
1465 1465 inf = Struct(self._ofind(oname, namespaces))
1466 1466 return Struct(self._ofind_property(oname, inf))
1467 1467
1468 1468 def _inspect(self, meth, oname, namespaces=None, **kw):
1469 1469 """Generic interface to the inspector system.
1470 1470
1471 1471 This function is meant to be called by pdef, pdoc & friends."""
1472 1472 info = self._object_find(oname, namespaces)
1473 1473 if info.found:
1474 1474 pmethod = getattr(self.inspector, meth)
1475 1475 formatter = format_screen if info.ismagic else None
1476 1476 if meth == 'pdoc':
1477 1477 pmethod(info.obj, oname, formatter)
1478 1478 elif meth == 'pinfo':
1479 1479 pmethod(info.obj, oname, formatter, info, **kw)
1480 1480 else:
1481 1481 pmethod(info.obj, oname)
1482 1482 else:
1483 1483 print('Object `%s` not found.' % oname)
1484 1484 return 'not found' # so callers can take other action
1485 1485
1486 1486 def object_inspect(self, oname, detail_level=0):
1487 1487 with self.builtin_trap:
1488 1488 info = self._object_find(oname)
1489 1489 if info.found:
1490 1490 return self.inspector.info(info.obj, oname, info=info,
1491 1491 detail_level=detail_level
1492 1492 )
1493 1493 else:
1494 1494 return oinspect.object_info(name=oname, found=False)
1495 1495
1496 1496 #-------------------------------------------------------------------------
1497 1497 # Things related to history management
1498 1498 #-------------------------------------------------------------------------
1499 1499
1500 1500 def init_history(self):
1501 1501 """Sets up the command history, and starts regular autosaves."""
1502 1502 self.history_manager = HistoryManager(shell=self, parent=self)
1503 1503 self.configurables.append(self.history_manager)
1504 1504
1505 1505 #-------------------------------------------------------------------------
1506 1506 # Things related to exception handling and tracebacks (not debugging)
1507 1507 #-------------------------------------------------------------------------
1508 1508
1509 1509 def init_traceback_handlers(self, custom_exceptions):
1510 1510 # Syntax error handler.
1511 1511 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1512 1512
1513 1513 # The interactive one is initialized with an offset, meaning we always
1514 1514 # want to remove the topmost item in the traceback, which is our own
1515 1515 # internal code. Valid modes: ['Plain','Context','Verbose']
1516 1516 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1517 1517 color_scheme='NoColor',
1518 1518 tb_offset = 1,
1519 1519 check_cache=check_linecache_ipython)
1520 1520
1521 1521 # The instance will store a pointer to the system-wide exception hook,
1522 1522 # so that runtime code (such as magics) can access it. This is because
1523 1523 # during the read-eval loop, it may get temporarily overwritten.
1524 1524 self.sys_excepthook = sys.excepthook
1525 1525
1526 1526 # and add any custom exception handlers the user may have specified
1527 1527 self.set_custom_exc(*custom_exceptions)
1528 1528
1529 1529 # Set the exception mode
1530 1530 self.InteractiveTB.set_mode(mode=self.xmode)
1531 1531
1532 1532 def set_custom_exc(self, exc_tuple, handler):
1533 1533 """set_custom_exc(exc_tuple,handler)
1534 1534
1535 1535 Set a custom exception handler, which will be called if any of the
1536 1536 exceptions in exc_tuple occur in the mainloop (specifically, in the
1537 1537 run_code() method).
1538 1538
1539 1539 Parameters
1540 1540 ----------
1541 1541
1542 1542 exc_tuple : tuple of exception classes
1543 1543 A *tuple* of exception classes, for which to call the defined
1544 1544 handler. It is very important that you use a tuple, and NOT A
1545 1545 LIST here, because of the way Python's except statement works. If
1546 1546 you only want to trap a single exception, use a singleton tuple::
1547 1547
1548 1548 exc_tuple == (MyCustomException,)
1549 1549
1550 1550 handler : callable
1551 1551 handler must have the following signature::
1552 1552
1553 1553 def my_handler(self, etype, value, tb, tb_offset=None):
1554 1554 ...
1555 1555 return structured_traceback
1556 1556
1557 1557 Your handler must return a structured traceback (a list of strings),
1558 1558 or None.
1559 1559
1560 1560 This will be made into an instance method (via types.MethodType)
1561 1561 of IPython itself, and it will be called if any of the exceptions
1562 1562 listed in the exc_tuple are caught. If the handler is None, an
1563 1563 internal basic one is used, which just prints basic info.
1564 1564
1565 1565 To protect IPython from crashes, if your handler ever raises an
1566 1566 exception or returns an invalid result, it will be immediately
1567 1567 disabled.
1568 1568
1569 1569 WARNING: by putting in your own exception handler into IPython's main
1570 1570 execution loop, you run a very good chance of nasty crashes. This
1571 1571 facility should only be used if you really know what you are doing."""
1572 1572
1573 1573 assert type(exc_tuple)==type(()) , \
1574 1574 "The custom exceptions must be given AS A TUPLE."
1575 1575
1576 1576 def dummy_handler(self,etype,value,tb,tb_offset=None):
1577 1577 print('*** Simple custom exception handler ***')
1578 1578 print('Exception type :',etype)
1579 1579 print('Exception value:',value)
1580 1580 print('Traceback :',tb)
1581 1581 #print 'Source code :','\n'.join(self.buffer)
1582 1582
1583 1583 def validate_stb(stb):
1584 1584 """validate structured traceback return type
1585 1585
1586 1586 return type of CustomTB *should* be a list of strings, but allow
1587 1587 single strings or None, which are harmless.
1588 1588
1589 1589 This function will *always* return a list of strings,
1590 1590 and will raise a TypeError if stb is inappropriate.
1591 1591 """
1592 1592 msg = "CustomTB must return list of strings, not %r" % stb
1593 1593 if stb is None:
1594 1594 return []
1595 1595 elif isinstance(stb, string_types):
1596 1596 return [stb]
1597 1597 elif not isinstance(stb, list):
1598 1598 raise TypeError(msg)
1599 1599 # it's a list
1600 1600 for line in stb:
1601 1601 # check every element
1602 1602 if not isinstance(line, string_types):
1603 1603 raise TypeError(msg)
1604 1604 return stb
1605 1605
1606 1606 if handler is None:
1607 1607 wrapped = dummy_handler
1608 1608 else:
1609 1609 def wrapped(self,etype,value,tb,tb_offset=None):
1610 1610 """wrap CustomTB handler, to protect IPython from user code
1611 1611
1612 1612 This makes it harder (but not impossible) for custom exception
1613 1613 handlers to crash IPython.
1614 1614 """
1615 1615 try:
1616 1616 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1617 1617 return validate_stb(stb)
1618 1618 except:
1619 1619 # clear custom handler immediately
1620 1620 self.set_custom_exc((), None)
1621 1621 print("Custom TB Handler failed, unregistering", file=io.stderr)
1622 1622 # show the exception in handler first
1623 1623 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1624 1624 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1625 1625 print("The original exception:", file=io.stdout)
1626 1626 stb = self.InteractiveTB.structured_traceback(
1627 1627 (etype,value,tb), tb_offset=tb_offset
1628 1628 )
1629 1629 return stb
1630 1630
1631 1631 self.CustomTB = types.MethodType(wrapped,self)
1632 1632 self.custom_exceptions = exc_tuple
1633 1633
1634 1634 def excepthook(self, etype, value, tb):
1635 1635 """One more defense for GUI apps that call sys.excepthook.
1636 1636
1637 1637 GUI frameworks like wxPython trap exceptions and call
1638 1638 sys.excepthook themselves. I guess this is a feature that
1639 1639 enables them to keep running after exceptions that would
1640 1640 otherwise kill their mainloop. This is a bother for IPython
1641 1641 which excepts to catch all of the program exceptions with a try:
1642 1642 except: statement.
1643 1643
1644 1644 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1645 1645 any app directly invokes sys.excepthook, it will look to the user like
1646 1646 IPython crashed. In order to work around this, we can disable the
1647 1647 CrashHandler and replace it with this excepthook instead, which prints a
1648 1648 regular traceback using our InteractiveTB. In this fashion, apps which
1649 1649 call sys.excepthook will generate a regular-looking exception from
1650 1650 IPython, and the CrashHandler will only be triggered by real IPython
1651 1651 crashes.
1652 1652
1653 1653 This hook should be used sparingly, only in places which are not likely
1654 1654 to be true IPython errors.
1655 1655 """
1656 1656 self.showtraceback((etype,value,tb),tb_offset=0)
1657 1657
1658 1658 def _get_exc_info(self, exc_tuple=None):
1659 1659 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1660 1660
1661 1661 Ensures sys.last_type,value,traceback hold the exc_info we found,
1662 1662 from whichever source.
1663 1663
1664 1664 raises ValueError if none of these contain any information
1665 1665 """
1666 1666 if exc_tuple is None:
1667 1667 etype, value, tb = sys.exc_info()
1668 1668 else:
1669 1669 etype, value, tb = exc_tuple
1670 1670
1671 1671 if etype is None:
1672 1672 if hasattr(sys, 'last_type'):
1673 1673 etype, value, tb = sys.last_type, sys.last_value, \
1674 1674 sys.last_traceback
1675 1675
1676 1676 if etype is None:
1677 1677 raise ValueError("No exception to find")
1678 1678
1679 1679 # Now store the exception info in sys.last_type etc.
1680 1680 # WARNING: these variables are somewhat deprecated and not
1681 1681 # necessarily safe to use in a threaded environment, but tools
1682 1682 # like pdb depend on their existence, so let's set them. If we
1683 1683 # find problems in the field, we'll need to revisit their use.
1684 1684 sys.last_type = etype
1685 1685 sys.last_value = value
1686 1686 sys.last_traceback = tb
1687 1687
1688 1688 return etype, value, tb
1689 1689
1690 1690 def show_usage_error(self, exc):
1691 1691 """Show a short message for UsageErrors
1692 1692
1693 1693 These are special exceptions that shouldn't show a traceback.
1694 1694 """
1695 1695 self.write_err("UsageError: %s" % exc)
1696 1696
1697 1697 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1698 1698 exception_only=False):
1699 1699 """Display the exception that just occurred.
1700 1700
1701 1701 If nothing is known about the exception, this is the method which
1702 1702 should be used throughout the code for presenting user tracebacks,
1703 1703 rather than directly invoking the InteractiveTB object.
1704 1704
1705 1705 A specific showsyntaxerror() also exists, but this method can take
1706 1706 care of calling it if needed, so unless you are explicitly catching a
1707 1707 SyntaxError exception, don't try to analyze the stack manually and
1708 1708 simply call this method."""
1709 1709
1710 1710 try:
1711 1711 try:
1712 1712 etype, value, tb = self._get_exc_info(exc_tuple)
1713 1713 except ValueError:
1714 1714 self.write_err('No traceback available to show.\n')
1715 1715 return
1716 1716
1717 1717 if issubclass(etype, SyntaxError):
1718 1718 # Though this won't be called by syntax errors in the input
1719 1719 # line, there may be SyntaxError cases with imported code.
1720 1720 self.showsyntaxerror(filename)
1721 1721 elif etype is UsageError:
1722 1722 self.show_usage_error(value)
1723 1723 else:
1724 1724 if exception_only:
1725 1725 stb = ['An exception has occurred, use %tb to see '
1726 1726 'the full traceback.\n']
1727 1727 stb.extend(self.InteractiveTB.get_exception_only(etype,
1728 1728 value))
1729 1729 else:
1730 1730 try:
1731 1731 # Exception classes can customise their traceback - we
1732 1732 # use this in IPython.parallel for exceptions occurring
1733 1733 # in the engines. This should return a list of strings.
1734 1734 stb = value._render_traceback_()
1735 1735 except Exception:
1736 1736 stb = self.InteractiveTB.structured_traceback(etype,
1737 1737 value, tb, tb_offset=tb_offset)
1738 1738
1739 1739 self._showtraceback(etype, value, stb)
1740 1740 if self.call_pdb:
1741 1741 # drop into debugger
1742 1742 self.debugger(force=True)
1743 1743 return
1744 1744
1745 1745 # Actually show the traceback
1746 1746 self._showtraceback(etype, value, stb)
1747 1747
1748 1748 except KeyboardInterrupt:
1749 1749 self.write_err("\nKeyboardInterrupt\n")
1750 1750
1751 1751 def _showtraceback(self, etype, evalue, stb):
1752 1752 """Actually show a traceback.
1753 1753
1754 1754 Subclasses may override this method to put the traceback on a different
1755 1755 place, like a side channel.
1756 1756 """
1757 1757 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1758 1758
1759 1759 def showsyntaxerror(self, filename=None):
1760 1760 """Display the syntax error that just occurred.
1761 1761
1762 1762 This doesn't display a stack trace because there isn't one.
1763 1763
1764 1764 If a filename is given, it is stuffed in the exception instead
1765 1765 of what was there before (because Python's parser always uses
1766 1766 "<string>" when reading from a string).
1767 1767 """
1768 1768 etype, value, last_traceback = self._get_exc_info()
1769 1769
1770 1770 if filename and issubclass(etype, SyntaxError):
1771 1771 try:
1772 1772 value.filename = filename
1773 1773 except:
1774 1774 # Not the format we expect; leave it alone
1775 1775 pass
1776 1776
1777 1777 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1778 1778 self._showtraceback(etype, value, stb)
1779 1779
1780 1780 # This is overridden in TerminalInteractiveShell to show a message about
1781 1781 # the %paste magic.
1782 1782 def showindentationerror(self):
1783 1783 """Called by run_cell when there's an IndentationError in code entered
1784 1784 at the prompt.
1785 1785
1786 1786 This is overridden in TerminalInteractiveShell to show a message about
1787 1787 the %paste magic."""
1788 1788 self.showsyntaxerror()
1789 1789
1790 1790 #-------------------------------------------------------------------------
1791 1791 # Things related to readline
1792 1792 #-------------------------------------------------------------------------
1793 1793
1794 1794 def init_readline(self):
1795 1795 """Command history completion/saving/reloading."""
1796 1796
1797 1797 if self.readline_use:
1798 1798 import IPython.utils.rlineimpl as readline
1799 1799
1800 1800 self.rl_next_input = None
1801 1801 self.rl_do_indent = False
1802 1802
1803 1803 if not self.readline_use or not readline.have_readline:
1804 1804 self.has_readline = False
1805 1805 self.readline = None
1806 1806 # Set a number of methods that depend on readline to be no-op
1807 1807 self.readline_no_record = no_op_context
1808 1808 self.set_readline_completer = no_op
1809 1809 self.set_custom_completer = no_op
1810 1810 if self.readline_use:
1811 1811 warn('Readline services not available or not loaded.')
1812 1812 else:
1813 1813 self.has_readline = True
1814 1814 self.readline = readline
1815 1815 sys.modules['readline'] = readline
1816 1816
1817 1817 # Platform-specific configuration
1818 1818 if os.name == 'nt':
1819 1819 # FIXME - check with Frederick to see if we can harmonize
1820 1820 # naming conventions with pyreadline to avoid this
1821 1821 # platform-dependent check
1822 1822 self.readline_startup_hook = readline.set_pre_input_hook
1823 1823 else:
1824 1824 self.readline_startup_hook = readline.set_startup_hook
1825 1825
1826 1826 # Load user's initrc file (readline config)
1827 1827 # Or if libedit is used, load editrc.
1828 1828 inputrc_name = os.environ.get('INPUTRC')
1829 1829 if inputrc_name is None:
1830 1830 inputrc_name = '.inputrc'
1831 1831 if readline.uses_libedit:
1832 1832 inputrc_name = '.editrc'
1833 1833 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1834 1834 if os.path.isfile(inputrc_name):
1835 1835 try:
1836 1836 readline.read_init_file(inputrc_name)
1837 1837 except:
1838 1838 warn('Problems reading readline initialization file <%s>'
1839 1839 % inputrc_name)
1840 1840
1841 1841 # Configure readline according to user's prefs
1842 1842 # This is only done if GNU readline is being used. If libedit
1843 1843 # is being used (as on Leopard) the readline config is
1844 1844 # not run as the syntax for libedit is different.
1845 1845 if not readline.uses_libedit:
1846 1846 for rlcommand in self.readline_parse_and_bind:
1847 1847 #print "loading rl:",rlcommand # dbg
1848 1848 readline.parse_and_bind(rlcommand)
1849 1849
1850 1850 # Remove some chars from the delimiters list. If we encounter
1851 1851 # unicode chars, discard them.
1852 1852 delims = readline.get_completer_delims()
1853 1853 if not py3compat.PY3:
1854 1854 delims = delims.encode("ascii", "ignore")
1855 1855 for d in self.readline_remove_delims:
1856 1856 delims = delims.replace(d, "")
1857 1857 delims = delims.replace(ESC_MAGIC, '')
1858 1858 readline.set_completer_delims(delims)
1859 1859 # Store these so we can restore them if something like rpy2 modifies
1860 1860 # them.
1861 1861 self.readline_delims = delims
1862 1862 # otherwise we end up with a monster history after a while:
1863 1863 readline.set_history_length(self.history_length)
1864 1864
1865 1865 self.refill_readline_hist()
1866 1866 self.readline_no_record = ReadlineNoRecord(self)
1867 1867
1868 1868 # Configure auto-indent for all platforms
1869 1869 self.set_autoindent(self.autoindent)
1870 1870
1871 1871 def refill_readline_hist(self):
1872 1872 # Load the last 1000 lines from history
1873 1873 self.readline.clear_history()
1874 1874 stdin_encoding = sys.stdin.encoding or "utf-8"
1875 1875 last_cell = u""
1876 1876 for _, _, cell in self.history_manager.get_tail(1000,
1877 1877 include_latest=True):
1878 1878 # Ignore blank lines and consecutive duplicates
1879 1879 cell = cell.rstrip()
1880 1880 if cell and (cell != last_cell):
1881 1881 try:
1882 1882 if self.multiline_history:
1883 1883 self.readline.add_history(py3compat.unicode_to_str(cell,
1884 1884 stdin_encoding))
1885 1885 else:
1886 1886 for line in cell.splitlines():
1887 1887 self.readline.add_history(py3compat.unicode_to_str(line,
1888 1888 stdin_encoding))
1889 1889 last_cell = cell
1890 1890
1891 1891 except TypeError:
1892 1892 # The history DB can get corrupted so it returns strings
1893 1893 # containing null bytes, which readline objects to.
1894 1894 continue
1895 1895
1896 1896 @skip_doctest
1897 1897 def set_next_input(self, s):
1898 1898 """ Sets the 'default' input string for the next command line.
1899 1899
1900 1900 Requires readline.
1901 1901
1902 1902 Example::
1903 1903
1904 1904 In [1]: _ip.set_next_input("Hello Word")
1905 1905 In [2]: Hello Word_ # cursor is here
1906 1906 """
1907 1907 self.rl_next_input = py3compat.cast_bytes_py2(s)
1908 1908
1909 1909 # Maybe move this to the terminal subclass?
1910 1910 def pre_readline(self):
1911 1911 """readline hook to be used at the start of each line.
1912 1912
1913 1913 Currently it handles auto-indent only."""
1914 1914
1915 1915 if self.rl_do_indent:
1916 1916 self.readline.insert_text(self._indent_current_str())
1917 1917 if self.rl_next_input is not None:
1918 1918 self.readline.insert_text(self.rl_next_input)
1919 1919 self.rl_next_input = None
1920 1920
1921 1921 def _indent_current_str(self):
1922 1922 """return the current level of indentation as a string"""
1923 1923 return self.input_splitter.indent_spaces * ' '
1924 1924
1925 1925 #-------------------------------------------------------------------------
1926 1926 # Things related to text completion
1927 1927 #-------------------------------------------------------------------------
1928 1928
1929 1929 def init_completer(self):
1930 1930 """Initialize the completion machinery.
1931 1931
1932 1932 This creates completion machinery that can be used by client code,
1933 1933 either interactively in-process (typically triggered by the readline
1934 1934 library), programatically (such as in test suites) or out-of-prcess
1935 1935 (typically over the network by remote frontends).
1936 1936 """
1937 1937 from IPython.core.completer import IPCompleter
1938 1938 from IPython.core.completerlib import (module_completer,
1939 1939 magic_run_completer, cd_completer, reset_completer)
1940 1940
1941 1941 self.Completer = IPCompleter(shell=self,
1942 1942 namespace=self.user_ns,
1943 1943 global_namespace=self.user_global_ns,
1944 1944 use_readline=self.has_readline,
1945 1945 parent=self,
1946 1946 )
1947 1947 self.configurables.append(self.Completer)
1948 1948
1949 1949 # Add custom completers to the basic ones built into IPCompleter
1950 1950 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1951 1951 self.strdispatchers['complete_command'] = sdisp
1952 1952 self.Completer.custom_completers = sdisp
1953 1953
1954 1954 self.set_hook('complete_command', module_completer, str_key = 'import')
1955 1955 self.set_hook('complete_command', module_completer, str_key = 'from')
1956 1956 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1957 1957 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1958 1958 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1959 1959
1960 1960 # Only configure readline if we truly are using readline. IPython can
1961 1961 # do tab-completion over the network, in GUIs, etc, where readline
1962 1962 # itself may be absent
1963 1963 if self.has_readline:
1964 1964 self.set_readline_completer()
1965 1965
1966 1966 def complete(self, text, line=None, cursor_pos=None):
1967 1967 """Return the completed text and a list of completions.
1968 1968
1969 1969 Parameters
1970 1970 ----------
1971 1971
1972 1972 text : string
1973 1973 A string of text to be completed on. It can be given as empty and
1974 1974 instead a line/position pair are given. In this case, the
1975 1975 completer itself will split the line like readline does.
1976 1976
1977 1977 line : string, optional
1978 1978 The complete line that text is part of.
1979 1979
1980 1980 cursor_pos : int, optional
1981 1981 The position of the cursor on the input line.
1982 1982
1983 1983 Returns
1984 1984 -------
1985 1985 text : string
1986 1986 The actual text that was completed.
1987 1987
1988 1988 matches : list
1989 1989 A sorted list with all possible completions.
1990 1990
1991 1991 The optional arguments allow the completion to take more context into
1992 1992 account, and are part of the low-level completion API.
1993 1993
1994 1994 This is a wrapper around the completion mechanism, similar to what
1995 1995 readline does at the command line when the TAB key is hit. By
1996 1996 exposing it as a method, it can be used by other non-readline
1997 1997 environments (such as GUIs) for text completion.
1998 1998
1999 1999 Simple usage example:
2000 2000
2001 2001 In [1]: x = 'hello'
2002 2002
2003 2003 In [2]: _ip.complete('x.l')
2004 2004 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2005 2005 """
2006 2006
2007 2007 # Inject names into __builtin__ so we can complete on the added names.
2008 2008 with self.builtin_trap:
2009 2009 return self.Completer.complete(text, line, cursor_pos)
2010 2010
2011 2011 def set_custom_completer(self, completer, pos=0):
2012 2012 """Adds a new custom completer function.
2013 2013
2014 2014 The position argument (defaults to 0) is the index in the completers
2015 2015 list where you want the completer to be inserted."""
2016 2016
2017 2017 newcomp = types.MethodType(completer,self.Completer)
2018 2018 self.Completer.matchers.insert(pos,newcomp)
2019 2019
2020 2020 def set_readline_completer(self):
2021 2021 """Reset readline's completer to be our own."""
2022 2022 self.readline.set_completer(self.Completer.rlcomplete)
2023 2023
2024 2024 def set_completer_frame(self, frame=None):
2025 2025 """Set the frame of the completer."""
2026 2026 if frame:
2027 2027 self.Completer.namespace = frame.f_locals
2028 2028 self.Completer.global_namespace = frame.f_globals
2029 2029 else:
2030 2030 self.Completer.namespace = self.user_ns
2031 2031 self.Completer.global_namespace = self.user_global_ns
2032 2032
2033 2033 #-------------------------------------------------------------------------
2034 2034 # Things related to magics
2035 2035 #-------------------------------------------------------------------------
2036 2036
2037 2037 def init_magics(self):
2038 2038 from IPython.core import magics as m
2039 2039 self.magics_manager = magic.MagicsManager(shell=self,
2040 2040 parent=self,
2041 2041 user_magics=m.UserMagics(self))
2042 2042 self.configurables.append(self.magics_manager)
2043 2043
2044 2044 # Expose as public API from the magics manager
2045 2045 self.register_magics = self.magics_manager.register
2046 2046 self.define_magic = self.magics_manager.define_magic
2047 2047
2048 2048 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2049 2049 m.ConfigMagics, m.DeprecatedMagics, m.DisplayMagics, m.ExecutionMagics,
2050 2050 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2051 2051 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2052 2052 )
2053 2053
2054 2054 # Register Magic Aliases
2055 2055 mman = self.magics_manager
2056 2056 # FIXME: magic aliases should be defined by the Magics classes
2057 2057 # or in MagicsManager, not here
2058 2058 mman.register_alias('ed', 'edit')
2059 2059 mman.register_alias('hist', 'history')
2060 2060 mman.register_alias('rep', 'recall')
2061 2061 mman.register_alias('SVG', 'svg', 'cell')
2062 2062 mman.register_alias('HTML', 'html', 'cell')
2063 2063 mman.register_alias('file', 'writefile', 'cell')
2064 2064
2065 2065 # FIXME: Move the color initialization to the DisplayHook, which
2066 2066 # should be split into a prompt manager and displayhook. We probably
2067 2067 # even need a centralize colors management object.
2068 2068 self.magic('colors %s' % self.colors)
2069 2069
2070 2070 # Defined here so that it's included in the documentation
2071 2071 @functools.wraps(magic.MagicsManager.register_function)
2072 2072 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2073 2073 self.magics_manager.register_function(func,
2074 2074 magic_kind=magic_kind, magic_name=magic_name)
2075 2075
2076 2076 def run_line_magic(self, magic_name, line):
2077 2077 """Execute the given line magic.
2078 2078
2079 2079 Parameters
2080 2080 ----------
2081 2081 magic_name : str
2082 2082 Name of the desired magic function, without '%' prefix.
2083 2083
2084 2084 line : str
2085 2085 The rest of the input line as a single string.
2086 2086 """
2087 2087 fn = self.find_line_magic(magic_name)
2088 2088 if fn is None:
2089 2089 cm = self.find_cell_magic(magic_name)
2090 2090 etpl = "Line magic function `%%%s` not found%s."
2091 2091 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2092 2092 'did you mean that instead?)' % magic_name )
2093 2093 error(etpl % (magic_name, extra))
2094 2094 else:
2095 2095 # Note: this is the distance in the stack to the user's frame.
2096 2096 # This will need to be updated if the internal calling logic gets
2097 2097 # refactored, or else we'll be expanding the wrong variables.
2098 2098 stack_depth = 2
2099 2099 magic_arg_s = self.var_expand(line, stack_depth)
2100 2100 # Put magic args in a list so we can call with f(*a) syntax
2101 2101 args = [magic_arg_s]
2102 2102 kwargs = {}
2103 2103 # Grab local namespace if we need it:
2104 2104 if getattr(fn, "needs_local_scope", False):
2105 2105 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2106 2106 with self.builtin_trap:
2107 2107 result = fn(*args,**kwargs)
2108 2108 return result
2109 2109
2110 2110 def run_cell_magic(self, magic_name, line, cell):
2111 2111 """Execute the given cell magic.
2112 2112
2113 2113 Parameters
2114 2114 ----------
2115 2115 magic_name : str
2116 2116 Name of the desired magic function, without '%' prefix.
2117 2117
2118 2118 line : str
2119 2119 The rest of the first input line as a single string.
2120 2120
2121 2121 cell : str
2122 2122 The body of the cell as a (possibly multiline) string.
2123 2123 """
2124 2124 fn = self.find_cell_magic(magic_name)
2125 2125 if fn is None:
2126 2126 lm = self.find_line_magic(magic_name)
2127 2127 etpl = "Cell magic `%%{0}` not found{1}."
2128 2128 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2129 2129 'did you mean that instead?)'.format(magic_name))
2130 2130 error(etpl.format(magic_name, extra))
2131 2131 elif cell == '':
2132 2132 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2133 2133 if self.find_line_magic(magic_name) is not None:
2134 2134 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2135 2135 raise UsageError(message)
2136 2136 else:
2137 2137 # Note: this is the distance in the stack to the user's frame.
2138 2138 # This will need to be updated if the internal calling logic gets
2139 2139 # refactored, or else we'll be expanding the wrong variables.
2140 2140 stack_depth = 2
2141 2141 magic_arg_s = self.var_expand(line, stack_depth)
2142 2142 with self.builtin_trap:
2143 2143 result = fn(magic_arg_s, cell)
2144 2144 return result
2145 2145
2146 2146 def find_line_magic(self, magic_name):
2147 2147 """Find and return a line magic by name.
2148 2148
2149 2149 Returns None if the magic isn't found."""
2150 2150 return self.magics_manager.magics['line'].get(magic_name)
2151 2151
2152 2152 def find_cell_magic(self, magic_name):
2153 2153 """Find and return a cell magic by name.
2154 2154
2155 2155 Returns None if the magic isn't found."""
2156 2156 return self.magics_manager.magics['cell'].get(magic_name)
2157 2157
2158 2158 def find_magic(self, magic_name, magic_kind='line'):
2159 2159 """Find and return a magic of the given type by name.
2160 2160
2161 2161 Returns None if the magic isn't found."""
2162 2162 return self.magics_manager.magics[magic_kind].get(magic_name)
2163 2163
2164 2164 def magic(self, arg_s):
2165 2165 """DEPRECATED. Use run_line_magic() instead.
2166 2166
2167 2167 Call a magic function by name.
2168 2168
2169 2169 Input: a string containing the name of the magic function to call and
2170 2170 any additional arguments to be passed to the magic.
2171 2171
2172 2172 magic('name -opt foo bar') is equivalent to typing at the ipython
2173 2173 prompt:
2174 2174
2175 2175 In[1]: %name -opt foo bar
2176 2176
2177 2177 To call a magic without arguments, simply use magic('name').
2178 2178
2179 2179 This provides a proper Python function to call IPython's magics in any
2180 2180 valid Python code you can type at the interpreter, including loops and
2181 2181 compound statements.
2182 2182 """
2183 2183 # TODO: should we issue a loud deprecation warning here?
2184 2184 magic_name, _, magic_arg_s = arg_s.partition(' ')
2185 2185 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2186 2186 return self.run_line_magic(magic_name, magic_arg_s)
2187 2187
2188 2188 #-------------------------------------------------------------------------
2189 2189 # Things related to macros
2190 2190 #-------------------------------------------------------------------------
2191 2191
2192 2192 def define_macro(self, name, themacro):
2193 2193 """Define a new macro
2194 2194
2195 2195 Parameters
2196 2196 ----------
2197 2197 name : str
2198 2198 The name of the macro.
2199 2199 themacro : str or Macro
2200 2200 The action to do upon invoking the macro. If a string, a new
2201 2201 Macro object is created by passing the string to it.
2202 2202 """
2203 2203
2204 2204 from IPython.core import macro
2205 2205
2206 2206 if isinstance(themacro, string_types):
2207 2207 themacro = macro.Macro(themacro)
2208 2208 if not isinstance(themacro, macro.Macro):
2209 2209 raise ValueError('A macro must be a string or a Macro instance.')
2210 2210 self.user_ns[name] = themacro
2211 2211
2212 2212 #-------------------------------------------------------------------------
2213 2213 # Things related to the running of system commands
2214 2214 #-------------------------------------------------------------------------
2215 2215
2216 2216 def system_piped(self, cmd):
2217 2217 """Call the given cmd in a subprocess, piping stdout/err
2218 2218
2219 2219 Parameters
2220 2220 ----------
2221 2221 cmd : str
2222 2222 Command to execute (can not end in '&', as background processes are
2223 2223 not supported. Should not be a command that expects input
2224 2224 other than simple text.
2225 2225 """
2226 2226 if cmd.rstrip().endswith('&'):
2227 2227 # this is *far* from a rigorous test
2228 2228 # We do not support backgrounding processes because we either use
2229 2229 # pexpect or pipes to read from. Users can always just call
2230 2230 # os.system() or use ip.system=ip.system_raw
2231 2231 # if they really want a background process.
2232 2232 raise OSError("Background processes not supported.")
2233 2233
2234 2234 # we explicitly do NOT return the subprocess status code, because
2235 2235 # a non-None value would trigger :func:`sys.displayhook` calls.
2236 2236 # Instead, we store the exit_code in user_ns.
2237 2237 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2238 2238
2239 2239 def system_raw(self, cmd):
2240 2240 """Call the given cmd in a subprocess using os.system on Windows or
2241 2241 subprocess.call using the system shell on other platforms.
2242 2242
2243 2243 Parameters
2244 2244 ----------
2245 2245 cmd : str
2246 2246 Command to execute.
2247 2247 """
2248 2248 cmd = self.var_expand(cmd, depth=1)
2249 2249 # protect os.system from UNC paths on Windows, which it can't handle:
2250 2250 if sys.platform == 'win32':
2251 2251 from IPython.utils._process_win32 import AvoidUNCPath
2252 2252 with AvoidUNCPath() as path:
2253 2253 if path is not None:
2254 2254 cmd = '"pushd %s &&"%s' % (path, cmd)
2255 2255 cmd = py3compat.unicode_to_str(cmd)
2256 2256 ec = os.system(cmd)
2257 2257 else:
2258 2258 cmd = py3compat.unicode_to_str(cmd)
2259 2259 # Call the cmd using the OS shell, instead of the default /bin/sh, if set.
2260 2260 ec = subprocess.call(cmd, shell=True, executable=os.environ.get('SHELL', None))
2261 2261 # exit code is positive for program failure, or negative for
2262 2262 # terminating signal number.
2263 2263
2264 2264 # We explicitly do NOT return the subprocess status code, because
2265 2265 # a non-None value would trigger :func:`sys.displayhook` calls.
2266 2266 # Instead, we store the exit_code in user_ns.
2267 2267 self.user_ns['_exit_code'] = ec
2268 2268
2269 2269 # use piped system by default, because it is better behaved
2270 2270 system = system_piped
2271 2271
2272 2272 def getoutput(self, cmd, split=True, depth=0):
2273 2273 """Get output (possibly including stderr) from a subprocess.
2274 2274
2275 2275 Parameters
2276 2276 ----------
2277 2277 cmd : str
2278 2278 Command to execute (can not end in '&', as background processes are
2279 2279 not supported.
2280 2280 split : bool, optional
2281 2281 If True, split the output into an IPython SList. Otherwise, an
2282 2282 IPython LSString is returned. These are objects similar to normal
2283 2283 lists and strings, with a few convenience attributes for easier
2284 2284 manipulation of line-based output. You can use '?' on them for
2285 2285 details.
2286 2286 depth : int, optional
2287 2287 How many frames above the caller are the local variables which should
2288 2288 be expanded in the command string? The default (0) assumes that the
2289 2289 expansion variables are in the stack frame calling this function.
2290 2290 """
2291 2291 if cmd.rstrip().endswith('&'):
2292 2292 # this is *far* from a rigorous test
2293 2293 raise OSError("Background processes not supported.")
2294 2294 out = getoutput(self.var_expand(cmd, depth=depth+1))
2295 2295 if split:
2296 2296 out = SList(out.splitlines())
2297 2297 else:
2298 2298 out = LSString(out)
2299 2299 return out
2300 2300
2301 2301 #-------------------------------------------------------------------------
2302 2302 # Things related to aliases
2303 2303 #-------------------------------------------------------------------------
2304 2304
2305 2305 def init_alias(self):
2306 2306 self.alias_manager = AliasManager(shell=self, parent=self)
2307 2307 self.configurables.append(self.alias_manager)
2308 2308
2309 2309 #-------------------------------------------------------------------------
2310 2310 # Things related to extensions
2311 2311 #-------------------------------------------------------------------------
2312 2312
2313 2313 def init_extension_manager(self):
2314 2314 self.extension_manager = ExtensionManager(shell=self, parent=self)
2315 2315 self.configurables.append(self.extension_manager)
2316 2316
2317 2317 #-------------------------------------------------------------------------
2318 2318 # Things related to payloads
2319 2319 #-------------------------------------------------------------------------
2320 2320
2321 2321 def init_payload(self):
2322 2322 self.payload_manager = PayloadManager(parent=self)
2323 2323 self.configurables.append(self.payload_manager)
2324 2324
2325 2325 #-------------------------------------------------------------------------
2326 2326 # Things related to widgets
2327 2327 #-------------------------------------------------------------------------
2328 2328
2329 2329 def init_comms(self):
2330 2330 # not implemented in the base class
2331 2331 pass
2332 2332
2333 2333 #-------------------------------------------------------------------------
2334 2334 # Things related to the prefilter
2335 2335 #-------------------------------------------------------------------------
2336 2336
2337 2337 def init_prefilter(self):
2338 2338 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2339 2339 self.configurables.append(self.prefilter_manager)
2340 2340 # Ultimately this will be refactored in the new interpreter code, but
2341 2341 # for now, we should expose the main prefilter method (there's legacy
2342 2342 # code out there that may rely on this).
2343 2343 self.prefilter = self.prefilter_manager.prefilter_lines
2344 2344
2345 2345 def auto_rewrite_input(self, cmd):
2346 2346 """Print to the screen the rewritten form of the user's command.
2347 2347
2348 2348 This shows visual feedback by rewriting input lines that cause
2349 2349 automatic calling to kick in, like::
2350 2350
2351 2351 /f x
2352 2352
2353 2353 into::
2354 2354
2355 2355 ------> f(x)
2356 2356
2357 2357 after the user's input prompt. This helps the user understand that the
2358 2358 input line was transformed automatically by IPython.
2359 2359 """
2360 2360 if not self.show_rewritten_input:
2361 2361 return
2362 2362
2363 2363 rw = self.prompt_manager.render('rewrite') + cmd
2364 2364
2365 2365 try:
2366 2366 # plain ascii works better w/ pyreadline, on some machines, so
2367 2367 # we use it and only print uncolored rewrite if we have unicode
2368 2368 rw = str(rw)
2369 2369 print(rw, file=io.stdout)
2370 2370 except UnicodeEncodeError:
2371 2371 print("------> " + cmd)
2372 2372
2373 2373 #-------------------------------------------------------------------------
2374 2374 # Things related to extracting values/expressions from kernel and user_ns
2375 2375 #-------------------------------------------------------------------------
2376 2376
2377 2377 def _user_obj_error(self):
2378 2378 """return simple exception dict
2379 2379
2380 2380 for use in user_variables / expressions
2381 2381 """
2382 2382
2383 2383 etype, evalue, tb = self._get_exc_info()
2384 2384 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2385 2385
2386 2386 exc_info = {
2387 2387 u'status' : 'error',
2388 2388 u'traceback' : stb,
2389 2389 u'ename' : unicode_type(etype.__name__),
2390 2390 u'evalue' : py3compat.safe_unicode(evalue),
2391 2391 }
2392 2392
2393 2393 return exc_info
2394 2394
2395 2395 def _format_user_obj(self, obj):
2396 2396 """format a user object to display dict
2397 2397
2398 2398 for use in user_expressions / variables
2399 2399 """
2400 2400
2401 2401 data, md = self.display_formatter.format(obj)
2402 2402 value = {
2403 2403 'status' : 'ok',
2404 2404 'data' : data,
2405 2405 'metadata' : md,
2406 2406 }
2407 2407 return value
2408 2408
2409 2409 def user_variables(self, names):
2410 2410 """Get a list of variable names from the user's namespace.
2411 2411
2412 2412 Parameters
2413 2413 ----------
2414 2414 names : list of strings
2415 2415 A list of names of variables to be read from the user namespace.
2416 2416
2417 2417 Returns
2418 2418 -------
2419 2419 A dict, keyed by the input names and with the rich mime-type repr(s) of each value.
2420 2420 Each element will be a sub-dict of the same form as a display_data message.
2421 2421 """
2422 2422 out = {}
2423 2423 user_ns = self.user_ns
2424 2424
2425 2425 for varname in names:
2426 2426 try:
2427 2427 value = self._format_user_obj(user_ns[varname])
2428 2428 except:
2429 2429 value = self._user_obj_error()
2430 2430 out[varname] = value
2431 2431 return out
2432 2432
2433 2433 def user_expressions(self, expressions):
2434 2434 """Evaluate a dict of expressions in the user's namespace.
2435 2435
2436 2436 Parameters
2437 2437 ----------
2438 2438 expressions : dict
2439 2439 A dict with string keys and string values. The expression values
2440 2440 should be valid Python expressions, each of which will be evaluated
2441 2441 in the user namespace.
2442 2442
2443 2443 Returns
2444 2444 -------
2445 2445 A dict, keyed like the input expressions dict, with the rich mime-typed
2446 2446 display_data of each value.
2447 2447 """
2448 2448 out = {}
2449 2449 user_ns = self.user_ns
2450 2450 global_ns = self.user_global_ns
2451 2451
2452 2452 for key, expr in iteritems(expressions):
2453 2453 try:
2454 2454 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2455 2455 except:
2456 2456 value = self._user_obj_error()
2457 2457 out[key] = value
2458 2458 return out
2459 2459
2460 2460 #-------------------------------------------------------------------------
2461 2461 # Things related to the running of code
2462 2462 #-------------------------------------------------------------------------
2463 2463
2464 2464 def ex(self, cmd):
2465 2465 """Execute a normal python statement in user namespace."""
2466 2466 with self.builtin_trap:
2467 2467 exec(cmd, self.user_global_ns, self.user_ns)
2468 2468
2469 2469 def ev(self, expr):
2470 2470 """Evaluate python expression expr in user namespace.
2471 2471
2472 2472 Returns the result of evaluation
2473 2473 """
2474 2474 with self.builtin_trap:
2475 2475 return eval(expr, self.user_global_ns, self.user_ns)
2476 2476
2477 2477 def safe_execfile(self, fname, *where, **kw):
2478 2478 """A safe version of the builtin execfile().
2479 2479
2480 2480 This version will never throw an exception, but instead print
2481 2481 helpful error messages to the screen. This only works on pure
2482 2482 Python files with the .py extension.
2483 2483
2484 2484 Parameters
2485 2485 ----------
2486 2486 fname : string
2487 2487 The name of the file to be executed.
2488 2488 where : tuple
2489 2489 One or two namespaces, passed to execfile() as (globals,locals).
2490 2490 If only one is given, it is passed as both.
2491 2491 exit_ignore : bool (False)
2492 2492 If True, then silence SystemExit for non-zero status (it is always
2493 2493 silenced for zero status, as it is so common).
2494 2494 raise_exceptions : bool (False)
2495 2495 If True raise exceptions everywhere. Meant for testing.
2496 2496
2497 2497 """
2498 2498 kw.setdefault('exit_ignore', False)
2499 2499 kw.setdefault('raise_exceptions', False)
2500 2500
2501 2501 fname = os.path.abspath(os.path.expanduser(fname))
2502 2502
2503 2503 # Make sure we can open the file
2504 2504 try:
2505 2505 with open(fname) as thefile:
2506 2506 pass
2507 2507 except:
2508 2508 warn('Could not open file <%s> for safe execution.' % fname)
2509 2509 return
2510 2510
2511 2511 # Find things also in current directory. This is needed to mimic the
2512 2512 # behavior of running a script from the system command line, where
2513 2513 # Python inserts the script's directory into sys.path
2514 2514 dname = os.path.dirname(fname)
2515 2515
2516 2516 with prepended_to_syspath(dname):
2517 2517 try:
2518 2518 py3compat.execfile(fname,*where)
2519 2519 except SystemExit as status:
2520 2520 # If the call was made with 0 or None exit status (sys.exit(0)
2521 2521 # or sys.exit() ), don't bother showing a traceback, as both of
2522 2522 # these are considered normal by the OS:
2523 2523 # > python -c'import sys;sys.exit(0)'; echo $?
2524 2524 # 0
2525 2525 # > python -c'import sys;sys.exit()'; echo $?
2526 2526 # 0
2527 2527 # For other exit status, we show the exception unless
2528 2528 # explicitly silenced, but only in short form.
2529 2529 if kw['raise_exceptions']:
2530 2530 raise
2531 2531 if status.code and not kw['exit_ignore']:
2532 2532 self.showtraceback(exception_only=True)
2533 2533 except:
2534 2534 if kw['raise_exceptions']:
2535 2535 raise
2536 2536 self.showtraceback()
2537 2537
2538 2538 def safe_execfile_ipy(self, fname):
2539 2539 """Like safe_execfile, but for .ipy files with IPython syntax.
2540 2540
2541 2541 Parameters
2542 2542 ----------
2543 2543 fname : str
2544 2544 The name of the file to execute. The filename must have a
2545 2545 .ipy extension.
2546 2546 """
2547 2547 fname = os.path.abspath(os.path.expanduser(fname))
2548 2548
2549 2549 # Make sure we can open the file
2550 2550 try:
2551 2551 with open(fname) as thefile:
2552 2552 pass
2553 2553 except:
2554 2554 warn('Could not open file <%s> for safe execution.' % fname)
2555 2555 return
2556 2556
2557 2557 # Find things also in current directory. This is needed to mimic the
2558 2558 # behavior of running a script from the system command line, where
2559 2559 # Python inserts the script's directory into sys.path
2560 2560 dname = os.path.dirname(fname)
2561 2561
2562 2562 with prepended_to_syspath(dname):
2563 2563 try:
2564 2564 with open(fname) as thefile:
2565 2565 # self.run_cell currently captures all exceptions
2566 2566 # raised in user code. It would be nice if there were
2567 2567 # versions of runlines, execfile that did raise, so
2568 2568 # we could catch the errors.
2569 2569 self.run_cell(thefile.read(), store_history=False, shell_futures=False)
2570 2570 except:
2571 2571 self.showtraceback()
2572 2572 warn('Unknown failure executing file: <%s>' % fname)
2573 2573
2574 2574 def safe_run_module(self, mod_name, where):
2575 2575 """A safe version of runpy.run_module().
2576 2576
2577 2577 This version will never throw an exception, but instead print
2578 2578 helpful error messages to the screen.
2579 2579
2580 2580 `SystemExit` exceptions with status code 0 or None are ignored.
2581 2581
2582 2582 Parameters
2583 2583 ----------
2584 2584 mod_name : string
2585 2585 The name of the module to be executed.
2586 2586 where : dict
2587 2587 The globals namespace.
2588 2588 """
2589 2589 try:
2590 2590 try:
2591 2591 where.update(
2592 2592 runpy.run_module(str(mod_name), run_name="__main__",
2593 2593 alter_sys=True)
2594 2594 )
2595 2595 except SystemExit as status:
2596 2596 if status.code:
2597 2597 raise
2598 2598 except:
2599 2599 self.showtraceback()
2600 2600 warn('Unknown failure executing module: <%s>' % mod_name)
2601 2601
2602 2602 def _run_cached_cell_magic(self, magic_name, line):
2603 2603 """Special method to call a cell magic with the data stored in self.
2604 2604 """
2605 2605 cell = self._current_cell_magic_body
2606 2606 self._current_cell_magic_body = None
2607 2607 return self.run_cell_magic(magic_name, line, cell)
2608 2608
2609 2609 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2610 2610 """Run a complete IPython cell.
2611 2611
2612 2612 Parameters
2613 2613 ----------
2614 2614 raw_cell : str
2615 2615 The code (including IPython code such as %magic functions) to run.
2616 2616 store_history : bool
2617 2617 If True, the raw and translated cell will be stored in IPython's
2618 2618 history. For user code calling back into IPython's machinery, this
2619 2619 should be set to False.
2620 2620 silent : bool
2621 2621 If True, avoid side-effects, such as implicit displayhooks and
2622 2622 and logging. silent=True forces store_history=False.
2623 2623 shell_futures : bool
2624 2624 If True, the code will share future statements with the interactive
2625 2625 shell. It will both be affected by previous __future__ imports, and
2626 2626 any __future__ imports in the code will affect the shell. If False,
2627 2627 __future__ imports are not shared in either direction.
2628 2628 """
2629 2629 if (not raw_cell) or raw_cell.isspace():
2630 2630 return
2631 2631
2632 2632 if silent:
2633 2633 store_history = False
2634 2634
2635 2635 preprocessing_exc_tuple = None
2636 2636 try:
2637 2637 # Static input transformations
2638 self.input_transformer_manager.push(raw_cell)
2639 cell = self.input_transformer_manager.source_reset()
2638 cell = self.input_transformer_manager.transform_cell(raw_cell)
2640 2639 except SyntaxError:
2641 2640 preprocessing_exc_tuple = sys.exc_info()
2642 2641 cell = raw_cell # cell has to exist so it can be stored/logged
2643 2642 else:
2644 2643 if len(cell.splitlines()) == 1:
2645 2644 # Dynamic transformations - only applied for single line commands
2646 2645 with self.builtin_trap:
2647 2646 try:
2648 2647 # use prefilter_lines to handle trailing newlines
2649 2648 # restore trailing newline for ast.parse
2650 2649 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2651 2650 except Exception:
2652 2651 # don't allow prefilter errors to crash IPython
2653 2652 preprocessing_exc_tuple = sys.exc_info()
2654 2653
2655 2654 # Store raw and processed history
2656 2655 if store_history:
2657 2656 self.history_manager.store_inputs(self.execution_count,
2658 2657 cell, raw_cell)
2659 2658 if not silent:
2660 2659 self.logger.log(cell, raw_cell)
2661 2660
2662 2661 # Display the exception if input processing failed.
2663 2662 if preprocessing_exc_tuple is not None:
2664 2663 self.showtraceback(preprocessing_exc_tuple)
2665 2664 del preprocessing_exc_tuple # Break reference cycle
2666 2665 if store_history:
2667 2666 self.execution_count += 1
2668 2667 return
2669 2668
2670 2669 # Our own compiler remembers the __future__ environment. If we want to
2671 2670 # run code with a separate __future__ environment, use the default
2672 2671 # compiler
2673 2672 compiler = self.compile if shell_futures else CachingCompiler()
2674 2673
2675 2674 with self.builtin_trap:
2676 2675 cell_name = self.compile.cache(cell, self.execution_count)
2677 2676
2678 2677 with self.display_trap:
2679 2678 # Compile to bytecode
2680 2679 try:
2681 2680 code_ast = compiler.ast_parse(cell, filename=cell_name)
2682 2681 except IndentationError:
2683 2682 self.showindentationerror()
2684 2683 if store_history:
2685 2684 self.execution_count += 1
2686 2685 return None
2687 2686 except (OverflowError, SyntaxError, ValueError, TypeError,
2688 2687 MemoryError):
2689 2688 self.showsyntaxerror()
2690 2689 if store_history:
2691 2690 self.execution_count += 1
2692 2691 return None
2693 2692
2694 2693 # Apply AST transformations
2695 2694 code_ast = self.transform_ast(code_ast)
2696 2695
2697 2696 # Execute the user code
2698 2697 interactivity = "none" if silent else self.ast_node_interactivity
2699 2698 self.run_ast_nodes(code_ast.body, cell_name,
2700 2699 interactivity=interactivity, compiler=compiler)
2701 2700
2702 2701 # Execute any registered post-execution functions.
2703 2702 # unless we are silent
2704 2703 post_exec = [] if silent else iteritems(self._post_execute)
2705 2704
2706 2705 for func, status in post_exec:
2707 2706 if self.disable_failing_post_execute and not status:
2708 2707 continue
2709 2708 try:
2710 2709 func()
2711 2710 except KeyboardInterrupt:
2712 2711 print("\nKeyboardInterrupt", file=io.stderr)
2713 2712 except Exception:
2714 2713 # register as failing:
2715 2714 self._post_execute[func] = False
2716 2715 self.showtraceback()
2717 2716 print('\n'.join([
2718 2717 "post-execution function %r produced an error." % func,
2719 2718 "If this problem persists, you can disable failing post-exec functions with:",
2720 2719 "",
2721 2720 " get_ipython().disable_failing_post_execute = True"
2722 2721 ]), file=io.stderr)
2723 2722
2724 2723 if store_history:
2725 2724 # Write output to the database. Does nothing unless
2726 2725 # history output logging is enabled.
2727 2726 self.history_manager.store_output(self.execution_count)
2728 2727 # Each cell is a *single* input, regardless of how many lines it has
2729 2728 self.execution_count += 1
2730 2729
2731 2730 def transform_ast(self, node):
2732 2731 """Apply the AST transformations from self.ast_transformers
2733 2732
2734 2733 Parameters
2735 2734 ----------
2736 2735 node : ast.Node
2737 2736 The root node to be transformed. Typically called with the ast.Module
2738 2737 produced by parsing user input.
2739 2738
2740 2739 Returns
2741 2740 -------
2742 2741 An ast.Node corresponding to the node it was called with. Note that it
2743 2742 may also modify the passed object, so don't rely on references to the
2744 2743 original AST.
2745 2744 """
2746 2745 for transformer in self.ast_transformers:
2747 2746 try:
2748 2747 node = transformer.visit(node)
2749 2748 except Exception:
2750 2749 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2751 2750 self.ast_transformers.remove(transformer)
2752 2751
2753 2752 if self.ast_transformers:
2754 2753 ast.fix_missing_locations(node)
2755 2754 return node
2756 2755
2757 2756
2758 2757 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2759 2758 compiler=compile):
2760 2759 """Run a sequence of AST nodes. The execution mode depends on the
2761 2760 interactivity parameter.
2762 2761
2763 2762 Parameters
2764 2763 ----------
2765 2764 nodelist : list
2766 2765 A sequence of AST nodes to run.
2767 2766 cell_name : str
2768 2767 Will be passed to the compiler as the filename of the cell. Typically
2769 2768 the value returned by ip.compile.cache(cell).
2770 2769 interactivity : str
2771 2770 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2772 2771 run interactively (displaying output from expressions). 'last_expr'
2773 2772 will run the last node interactively only if it is an expression (i.e.
2774 2773 expressions in loops or other blocks are not displayed. Other values
2775 2774 for this parameter will raise a ValueError.
2776 2775 compiler : callable
2777 2776 A function with the same interface as the built-in compile(), to turn
2778 2777 the AST nodes into code objects. Default is the built-in compile().
2779 2778 """
2780 2779 if not nodelist:
2781 2780 return
2782 2781
2783 2782 if interactivity == 'last_expr':
2784 2783 if isinstance(nodelist[-1], ast.Expr):
2785 2784 interactivity = "last"
2786 2785 else:
2787 2786 interactivity = "none"
2788 2787
2789 2788 if interactivity == 'none':
2790 2789 to_run_exec, to_run_interactive = nodelist, []
2791 2790 elif interactivity == 'last':
2792 2791 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2793 2792 elif interactivity == 'all':
2794 2793 to_run_exec, to_run_interactive = [], nodelist
2795 2794 else:
2796 2795 raise ValueError("Interactivity was %r" % interactivity)
2797 2796
2798 2797 exec_count = self.execution_count
2799 2798
2800 2799 try:
2801 2800 for i, node in enumerate(to_run_exec):
2802 2801 mod = ast.Module([node])
2803 2802 code = compiler(mod, cell_name, "exec")
2804 2803 if self.run_code(code):
2805 2804 return True
2806 2805
2807 2806 for i, node in enumerate(to_run_interactive):
2808 2807 mod = ast.Interactive([node])
2809 2808 code = compiler(mod, cell_name, "single")
2810 2809 if self.run_code(code):
2811 2810 return True
2812 2811
2813 2812 # Flush softspace
2814 2813 if softspace(sys.stdout, 0):
2815 2814 print()
2816 2815
2817 2816 except:
2818 2817 # It's possible to have exceptions raised here, typically by
2819 2818 # compilation of odd code (such as a naked 'return' outside a
2820 2819 # function) that did parse but isn't valid. Typically the exception
2821 2820 # is a SyntaxError, but it's safest just to catch anything and show
2822 2821 # the user a traceback.
2823 2822
2824 2823 # We do only one try/except outside the loop to minimize the impact
2825 2824 # on runtime, and also because if any node in the node list is
2826 2825 # broken, we should stop execution completely.
2827 2826 self.showtraceback()
2828 2827
2829 2828 return False
2830 2829
2831 2830 def run_code(self, code_obj):
2832 2831 """Execute a code object.
2833 2832
2834 2833 When an exception occurs, self.showtraceback() is called to display a
2835 2834 traceback.
2836 2835
2837 2836 Parameters
2838 2837 ----------
2839 2838 code_obj : code object
2840 2839 A compiled code object, to be executed
2841 2840
2842 2841 Returns
2843 2842 -------
2844 2843 False : successful execution.
2845 2844 True : an error occurred.
2846 2845 """
2847 2846
2848 2847 # Set our own excepthook in case the user code tries to call it
2849 2848 # directly, so that the IPython crash handler doesn't get triggered
2850 2849 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2851 2850
2852 2851 # we save the original sys.excepthook in the instance, in case config
2853 2852 # code (such as magics) needs access to it.
2854 2853 self.sys_excepthook = old_excepthook
2855 2854 outflag = 1 # happens in more places, so it's easier as default
2856 2855 try:
2857 2856 try:
2858 2857 self.hooks.pre_run_code_hook()
2859 2858 #rprint('Running code', repr(code_obj)) # dbg
2860 2859 exec(code_obj, self.user_global_ns, self.user_ns)
2861 2860 finally:
2862 2861 # Reset our crash handler in place
2863 2862 sys.excepthook = old_excepthook
2864 2863 except SystemExit:
2865 2864 self.showtraceback(exception_only=True)
2866 2865 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2867 2866 except self.custom_exceptions:
2868 2867 etype,value,tb = sys.exc_info()
2869 2868 self.CustomTB(etype,value,tb)
2870 2869 except:
2871 2870 self.showtraceback()
2872 2871 else:
2873 2872 outflag = 0
2874 2873 return outflag
2875 2874
2876 2875 # For backwards compatibility
2877 2876 runcode = run_code
2878 2877
2879 2878 #-------------------------------------------------------------------------
2880 2879 # Things related to GUI support and pylab
2881 2880 #-------------------------------------------------------------------------
2882 2881
2883 2882 def enable_gui(self, gui=None):
2884 2883 raise NotImplementedError('Implement enable_gui in a subclass')
2885 2884
2886 2885 def enable_matplotlib(self, gui=None):
2887 2886 """Enable interactive matplotlib and inline figure support.
2888 2887
2889 2888 This takes the following steps:
2890 2889
2891 2890 1. select the appropriate eventloop and matplotlib backend
2892 2891 2. set up matplotlib for interactive use with that backend
2893 2892 3. configure formatters for inline figure display
2894 2893 4. enable the selected gui eventloop
2895 2894
2896 2895 Parameters
2897 2896 ----------
2898 2897 gui : optional, string
2899 2898 If given, dictates the choice of matplotlib GUI backend to use
2900 2899 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2901 2900 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2902 2901 matplotlib (as dictated by the matplotlib build-time options plus the
2903 2902 user's matplotlibrc configuration file). Note that not all backends
2904 2903 make sense in all contexts, for example a terminal ipython can't
2905 2904 display figures inline.
2906 2905 """
2907 2906 from IPython.core import pylabtools as pt
2908 2907 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
2909 2908
2910 2909 if gui != 'inline':
2911 2910 # If we have our first gui selection, store it
2912 2911 if self.pylab_gui_select is None:
2913 2912 self.pylab_gui_select = gui
2914 2913 # Otherwise if they are different
2915 2914 elif gui != self.pylab_gui_select:
2916 2915 print ('Warning: Cannot change to a different GUI toolkit: %s.'
2917 2916 ' Using %s instead.' % (gui, self.pylab_gui_select))
2918 2917 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
2919 2918
2920 2919 pt.activate_matplotlib(backend)
2921 2920 pt.configure_inline_support(self, backend)
2922 2921
2923 2922 # Now we must activate the gui pylab wants to use, and fix %run to take
2924 2923 # plot updates into account
2925 2924 self.enable_gui(gui)
2926 2925 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2927 2926 pt.mpl_runner(self.safe_execfile)
2928 2927
2929 2928 return gui, backend
2930 2929
2931 2930 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
2932 2931 """Activate pylab support at runtime.
2933 2932
2934 2933 This turns on support for matplotlib, preloads into the interactive
2935 2934 namespace all of numpy and pylab, and configures IPython to correctly
2936 2935 interact with the GUI event loop. The GUI backend to be used can be
2937 2936 optionally selected with the optional ``gui`` argument.
2938 2937
2939 2938 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
2940 2939
2941 2940 Parameters
2942 2941 ----------
2943 2942 gui : optional, string
2944 2943 If given, dictates the choice of matplotlib GUI backend to use
2945 2944 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2946 2945 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2947 2946 matplotlib (as dictated by the matplotlib build-time options plus the
2948 2947 user's matplotlibrc configuration file). Note that not all backends
2949 2948 make sense in all contexts, for example a terminal ipython can't
2950 2949 display figures inline.
2951 2950 import_all : optional, bool, default: True
2952 2951 Whether to do `from numpy import *` and `from pylab import *`
2953 2952 in addition to module imports.
2954 2953 welcome_message : deprecated
2955 2954 This argument is ignored, no welcome message will be displayed.
2956 2955 """
2957 2956 from IPython.core.pylabtools import import_pylab
2958 2957
2959 2958 gui, backend = self.enable_matplotlib(gui)
2960 2959
2961 2960 # We want to prevent the loading of pylab to pollute the user's
2962 2961 # namespace as shown by the %who* magics, so we execute the activation
2963 2962 # code in an empty namespace, and we update *both* user_ns and
2964 2963 # user_ns_hidden with this information.
2965 2964 ns = {}
2966 2965 import_pylab(ns, import_all)
2967 2966 # warn about clobbered names
2968 2967 ignored = set(["__builtins__"])
2969 2968 both = set(ns).intersection(self.user_ns).difference(ignored)
2970 2969 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
2971 2970 self.user_ns.update(ns)
2972 2971 self.user_ns_hidden.update(ns)
2973 2972 return gui, backend, clobbered
2974 2973
2975 2974 #-------------------------------------------------------------------------
2976 2975 # Utilities
2977 2976 #-------------------------------------------------------------------------
2978 2977
2979 2978 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2980 2979 """Expand python variables in a string.
2981 2980
2982 2981 The depth argument indicates how many frames above the caller should
2983 2982 be walked to look for the local namespace where to expand variables.
2984 2983
2985 2984 The global namespace for expansion is always the user's interactive
2986 2985 namespace.
2987 2986 """
2988 2987 ns = self.user_ns.copy()
2989 2988 ns.update(sys._getframe(depth+1).f_locals)
2990 2989 try:
2991 2990 # We have to use .vformat() here, because 'self' is a valid and common
2992 2991 # name, and expanding **ns for .format() would make it collide with
2993 2992 # the 'self' argument of the method.
2994 2993 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
2995 2994 except Exception:
2996 2995 # if formatter couldn't format, just let it go untransformed
2997 2996 pass
2998 2997 return cmd
2999 2998
3000 2999 def mktempfile(self, data=None, prefix='ipython_edit_'):
3001 3000 """Make a new tempfile and return its filename.
3002 3001
3003 3002 This makes a call to tempfile.mktemp, but it registers the created
3004 3003 filename internally so ipython cleans it up at exit time.
3005 3004
3006 3005 Optional inputs:
3007 3006
3008 3007 - data(None): if data is given, it gets written out to the temp file
3009 3008 immediately, and the file is closed again."""
3010 3009
3011 3010 filename = tempfile.mktemp('.py', prefix)
3012 3011 self.tempfiles.append(filename)
3013 3012
3014 3013 if data:
3015 3014 tmp_file = open(filename,'w')
3016 3015 tmp_file.write(data)
3017 3016 tmp_file.close()
3018 3017 return filename
3019 3018
3020 3019 # TODO: This should be removed when Term is refactored.
3021 3020 def write(self,data):
3022 3021 """Write a string to the default output"""
3023 3022 io.stdout.write(data)
3024 3023
3025 3024 # TODO: This should be removed when Term is refactored.
3026 3025 def write_err(self,data):
3027 3026 """Write a string to the default error output"""
3028 3027 io.stderr.write(data)
3029 3028
3030 3029 def ask_yes_no(self, prompt, default=None):
3031 3030 if self.quiet:
3032 3031 return True
3033 3032 return ask_yes_no(prompt,default)
3034 3033
3035 3034 def show_usage(self):
3036 3035 """Show a usage message"""
3037 3036 page.page(IPython.core.usage.interactive_usage)
3038 3037
3039 3038 def extract_input_lines(self, range_str, raw=False):
3040 3039 """Return as a string a set of input history slices.
3041 3040
3042 3041 Parameters
3043 3042 ----------
3044 3043 range_str : string
3045 3044 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3046 3045 since this function is for use by magic functions which get their
3047 3046 arguments as strings. The number before the / is the session
3048 3047 number: ~n goes n back from the current session.
3049 3048
3050 3049 Optional Parameters:
3051 3050 - raw(False): by default, the processed input is used. If this is
3052 3051 true, the raw input history is used instead.
3053 3052
3054 3053 Note that slices can be called with two notations:
3055 3054
3056 3055 N:M -> standard python form, means including items N...(M-1).
3057 3056
3058 3057 N-M -> include items N..M (closed endpoint).
3059 3058 """
3060 3059 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3061 3060 return "\n".join(x for _, _, x in lines)
3062 3061
3063 3062 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True):
3064 3063 """Get a code string from history, file, url, or a string or macro.
3065 3064
3066 3065 This is mainly used by magic functions.
3067 3066
3068 3067 Parameters
3069 3068 ----------
3070 3069
3071 3070 target : str
3072 3071
3073 3072 A string specifying code to retrieve. This will be tried respectively
3074 3073 as: ranges of input history (see %history for syntax), url,
3075 3074 correspnding .py file, filename, or an expression evaluating to a
3076 3075 string or Macro in the user namespace.
3077 3076
3078 3077 raw : bool
3079 3078 If true (default), retrieve raw history. Has no effect on the other
3080 3079 retrieval mechanisms.
3081 3080
3082 3081 py_only : bool (default False)
3083 3082 Only try to fetch python code, do not try alternative methods to decode file
3084 3083 if unicode fails.
3085 3084
3086 3085 Returns
3087 3086 -------
3088 3087 A string of code.
3089 3088
3090 3089 ValueError is raised if nothing is found, and TypeError if it evaluates
3091 3090 to an object of another type. In each case, .args[0] is a printable
3092 3091 message.
3093 3092 """
3094 3093 code = self.extract_input_lines(target, raw=raw) # Grab history
3095 3094 if code:
3096 3095 return code
3097 3096 utarget = unquote_filename(target)
3098 3097 try:
3099 3098 if utarget.startswith(('http://', 'https://')):
3100 3099 return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
3101 3100 except UnicodeDecodeError:
3102 3101 if not py_only :
3103 3102 from urllib import urlopen # Deferred import
3104 3103 response = urlopen(target)
3105 3104 return response.read().decode('latin1')
3106 3105 raise ValueError(("'%s' seem to be unreadable.") % utarget)
3107 3106
3108 3107 potential_target = [target]
3109 3108 try :
3110 3109 potential_target.insert(0,get_py_filename(target))
3111 3110 except IOError:
3112 3111 pass
3113 3112
3114 3113 for tgt in potential_target :
3115 3114 if os.path.isfile(tgt): # Read file
3116 3115 try :
3117 3116 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3118 3117 except UnicodeDecodeError :
3119 3118 if not py_only :
3120 3119 with io_open(tgt,'r', encoding='latin1') as f :
3121 3120 return f.read()
3122 3121 raise ValueError(("'%s' seem to be unreadable.") % target)
3123 3122 elif os.path.isdir(os.path.expanduser(tgt)):
3124 3123 raise ValueError("'%s' is a directory, not a regular file." % target)
3125 3124
3126 3125 try: # User namespace
3127 3126 codeobj = eval(target, self.user_ns)
3128 3127 except Exception:
3129 3128 raise ValueError(("'%s' was not found in history, as a file, url, "
3130 3129 "nor in the user namespace.") % target)
3131 3130 if isinstance(codeobj, string_types):
3132 3131 return codeobj
3133 3132 elif isinstance(codeobj, Macro):
3134 3133 return codeobj.value
3135 3134
3136 3135 raise TypeError("%s is neither a string nor a macro." % target,
3137 3136 codeobj)
3138 3137
3139 3138 #-------------------------------------------------------------------------
3140 3139 # Things related to IPython exiting
3141 3140 #-------------------------------------------------------------------------
3142 3141 def atexit_operations(self):
3143 3142 """This will be executed at the time of exit.
3144 3143
3145 3144 Cleanup operations and saving of persistent data that is done
3146 3145 unconditionally by IPython should be performed here.
3147 3146
3148 3147 For things that may depend on startup flags or platform specifics (such
3149 3148 as having readline or not), register a separate atexit function in the
3150 3149 code that has the appropriate information, rather than trying to
3151 3150 clutter
3152 3151 """
3153 3152 # Close the history session (this stores the end time and line count)
3154 3153 # this must be *before* the tempfile cleanup, in case of temporary
3155 3154 # history db
3156 3155 self.history_manager.end_session()
3157 3156
3158 3157 # Cleanup all tempfiles left around
3159 3158 for tfile in self.tempfiles:
3160 3159 try:
3161 3160 os.unlink(tfile)
3162 3161 except OSError:
3163 3162 pass
3164 3163
3165 3164 # Clear all user namespaces to release all references cleanly.
3166 3165 self.reset(new_session=False)
3167 3166
3168 3167 # Run user hooks
3169 3168 self.hooks.shutdown_hook()
3170 3169
3171 3170 def cleanup(self):
3172 3171 self.restore_sys_module_state()
3173 3172
3174 3173
3175 3174 class InteractiveShellABC(with_metaclass(abc.ABCMeta, object)):
3176 3175 """An abstract base class for InteractiveShell."""
3177 3176
3178 3177 InteractiveShellABC.register(InteractiveShell)
@@ -1,584 +1,585 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Tests for the inputsplitter module.
3 3
4 4 Authors
5 5 -------
6 6 * Fernando Perez
7 7 * Robert Kern
8 8 """
9 9 from __future__ import print_function
10 10 #-----------------------------------------------------------------------------
11 11 # Copyright (C) 2010-2011 The IPython Development Team
12 12 #
13 13 # Distributed under the terms of the BSD License. The full license is in
14 14 # the file COPYING, distributed as part of this software.
15 15 #-----------------------------------------------------------------------------
16 16
17 17 #-----------------------------------------------------------------------------
18 18 # Imports
19 19 #-----------------------------------------------------------------------------
20 20 # stdlib
21 21 import unittest
22 22 import sys
23 23
24 24 # Third party
25 25 import nose.tools as nt
26 26
27 27 # Our own
28 28 from IPython.core import inputsplitter as isp
29 29 from IPython.core.tests.test_inputtransformer import syntax, syntax_ml
30 30 from IPython.testing import tools as tt
31 31 from IPython.utils import py3compat
32 32 from IPython.utils.py3compat import string_types, input
33 33
34 34 #-----------------------------------------------------------------------------
35 35 # Semi-complete examples (also used as tests)
36 36 #-----------------------------------------------------------------------------
37 37
38 38 # Note: at the bottom, there's a slightly more complete version of this that
39 39 # can be useful during development of code here.
40 40
41 41 def mini_interactive_loop(input_func):
42 42 """Minimal example of the logic of an interactive interpreter loop.
43 43
44 44 This serves as an example, and it is used by the test system with a fake
45 45 raw_input that simulates interactive input."""
46 46
47 47 from IPython.core.inputsplitter import InputSplitter
48 48
49 49 isp = InputSplitter()
50 50 # In practice, this input loop would be wrapped in an outside loop to read
51 51 # input indefinitely, until some exit/quit command was issued. Here we
52 52 # only illustrate the basic inner loop.
53 53 while isp.push_accepts_more():
54 54 indent = ' '*isp.indent_spaces
55 55 prompt = '>>> ' + indent
56 56 line = indent + input_func(prompt)
57 57 isp.push(line)
58 58
59 59 # Here we just return input so we can use it in a test suite, but a real
60 60 # interpreter would instead send it for execution somewhere.
61 61 src = isp.source_reset()
62 62 #print 'Input source was:\n', src # dbg
63 63 return src
64 64
65 65 #-----------------------------------------------------------------------------
66 66 # Test utilities, just for local use
67 67 #-----------------------------------------------------------------------------
68 68
69 69 def assemble(block):
70 70 """Assemble a block into multi-line sub-blocks."""
71 71 return ['\n'.join(sub_block)+'\n' for sub_block in block]
72 72
73 73
74 74 def pseudo_input(lines):
75 75 """Return a function that acts like raw_input but feeds the input list."""
76 76 ilines = iter(lines)
77 77 def raw_in(prompt):
78 78 try:
79 79 return next(ilines)
80 80 except StopIteration:
81 81 return ''
82 82 return raw_in
83 83
84 84 #-----------------------------------------------------------------------------
85 85 # Tests
86 86 #-----------------------------------------------------------------------------
87 87 def test_spaces():
88 88 tests = [('', 0),
89 89 (' ', 1),
90 90 ('\n', 0),
91 91 (' \n', 1),
92 92 ('x', 0),
93 93 (' x', 1),
94 94 (' x',2),
95 95 (' x',4),
96 96 # Note: tabs are counted as a single whitespace!
97 97 ('\tx', 1),
98 98 ('\t x', 2),
99 99 ]
100 100 tt.check_pairs(isp.num_ini_spaces, tests)
101 101
102 102
103 103 def test_remove_comments():
104 104 tests = [('text', 'text'),
105 105 ('text # comment', 'text '),
106 106 ('text # comment\n', 'text \n'),
107 107 ('text # comment \n', 'text \n'),
108 108 ('line # c \nline\n','line \nline\n'),
109 109 ('line # c \nline#c2 \nline\nline #c\n\n',
110 110 'line \nline\nline\nline \n\n'),
111 111 ]
112 112 tt.check_pairs(isp.remove_comments, tests)
113 113
114 114
115 115 def test_get_input_encoding():
116 116 encoding = isp.get_input_encoding()
117 117 nt.assert_true(isinstance(encoding, string_types))
118 118 # simple-minded check that at least encoding a simple string works with the
119 119 # encoding we got.
120 120 nt.assert_equal(u'test'.encode(encoding), b'test')
121 121
122 122
123 123 class NoInputEncodingTestCase(unittest.TestCase):
124 124 def setUp(self):
125 125 self.old_stdin = sys.stdin
126 126 class X: pass
127 127 fake_stdin = X()
128 128 sys.stdin = fake_stdin
129 129
130 130 def test(self):
131 131 # Verify that if sys.stdin has no 'encoding' attribute we do the right
132 132 # thing
133 133 enc = isp.get_input_encoding()
134 134 self.assertEqual(enc, 'ascii')
135 135
136 136 def tearDown(self):
137 137 sys.stdin = self.old_stdin
138 138
139 139
140 140 class InputSplitterTestCase(unittest.TestCase):
141 141 def setUp(self):
142 142 self.isp = isp.InputSplitter()
143 143
144 144 def test_reset(self):
145 145 isp = self.isp
146 146 isp.push('x=1')
147 147 isp.reset()
148 148 self.assertEqual(isp._buffer, [])
149 149 self.assertEqual(isp.indent_spaces, 0)
150 150 self.assertEqual(isp.source, '')
151 151 self.assertEqual(isp.code, None)
152 152 self.assertEqual(isp._is_complete, False)
153 153
154 154 def test_source(self):
155 155 self.isp._store('1')
156 156 self.isp._store('2')
157 157 self.assertEqual(self.isp.source, '1\n2\n')
158 158 self.assertTrue(len(self.isp._buffer)>0)
159 159 self.assertEqual(self.isp.source_reset(), '1\n2\n')
160 160 self.assertEqual(self.isp._buffer, [])
161 161 self.assertEqual(self.isp.source, '')
162 162
163 163 def test_indent(self):
164 164 isp = self.isp # shorthand
165 165 isp.push('x=1')
166 166 self.assertEqual(isp.indent_spaces, 0)
167 167 isp.push('if 1:\n x=1')
168 168 self.assertEqual(isp.indent_spaces, 4)
169 169 isp.push('y=2\n')
170 170 self.assertEqual(isp.indent_spaces, 0)
171 171
172 172 def test_indent2(self):
173 173 isp = self.isp
174 174 isp.push('if 1:')
175 175 self.assertEqual(isp.indent_spaces, 4)
176 176 isp.push(' x=1')
177 177 self.assertEqual(isp.indent_spaces, 4)
178 178 # Blank lines shouldn't change the indent level
179 179 isp.push(' '*2)
180 180 self.assertEqual(isp.indent_spaces, 4)
181 181
182 182 def test_indent3(self):
183 183 isp = self.isp
184 184 # When a multiline statement contains parens or multiline strings, we
185 185 # shouldn't get confused.
186 186 isp.push("if 1:")
187 187 isp.push(" x = (1+\n 2)")
188 188 self.assertEqual(isp.indent_spaces, 4)
189 189
190 190 def test_indent4(self):
191 191 isp = self.isp
192 192 # whitespace after ':' should not screw up indent level
193 193 isp.push('if 1: \n x=1')
194 194 self.assertEqual(isp.indent_spaces, 4)
195 195 isp.push('y=2\n')
196 196 self.assertEqual(isp.indent_spaces, 0)
197 197 isp.push('if 1:\t\n x=1')
198 198 self.assertEqual(isp.indent_spaces, 4)
199 199 isp.push('y=2\n')
200 200 self.assertEqual(isp.indent_spaces, 0)
201 201
202 202 def test_dedent_pass(self):
203 203 isp = self.isp # shorthand
204 204 # should NOT cause dedent
205 205 isp.push('if 1:\n passes = 5')
206 206 self.assertEqual(isp.indent_spaces, 4)
207 207 isp.push('if 1:\n pass')
208 208 self.assertEqual(isp.indent_spaces, 0)
209 209 isp.push('if 1:\n pass ')
210 210 self.assertEqual(isp.indent_spaces, 0)
211 211
212 212 def test_dedent_break(self):
213 213 isp = self.isp # shorthand
214 214 # should NOT cause dedent
215 215 isp.push('while 1:\n breaks = 5')
216 216 self.assertEqual(isp.indent_spaces, 4)
217 217 isp.push('while 1:\n break')
218 218 self.assertEqual(isp.indent_spaces, 0)
219 219 isp.push('while 1:\n break ')
220 220 self.assertEqual(isp.indent_spaces, 0)
221 221
222 222 def test_dedent_continue(self):
223 223 isp = self.isp # shorthand
224 224 # should NOT cause dedent
225 225 isp.push('while 1:\n continues = 5')
226 226 self.assertEqual(isp.indent_spaces, 4)
227 227 isp.push('while 1:\n continue')
228 228 self.assertEqual(isp.indent_spaces, 0)
229 229 isp.push('while 1:\n continue ')
230 230 self.assertEqual(isp.indent_spaces, 0)
231 231
232 232 def test_dedent_raise(self):
233 233 isp = self.isp # shorthand
234 234 # should NOT cause dedent
235 235 isp.push('if 1:\n raised = 4')
236 236 self.assertEqual(isp.indent_spaces, 4)
237 237 isp.push('if 1:\n raise TypeError()')
238 238 self.assertEqual(isp.indent_spaces, 0)
239 239 isp.push('if 1:\n raise')
240 240 self.assertEqual(isp.indent_spaces, 0)
241 241 isp.push('if 1:\n raise ')
242 242 self.assertEqual(isp.indent_spaces, 0)
243 243
244 244 def test_dedent_return(self):
245 245 isp = self.isp # shorthand
246 246 # should NOT cause dedent
247 247 isp.push('if 1:\n returning = 4')
248 248 self.assertEqual(isp.indent_spaces, 4)
249 249 isp.push('if 1:\n return 5 + 493')
250 250 self.assertEqual(isp.indent_spaces, 0)
251 251 isp.push('if 1:\n return')
252 252 self.assertEqual(isp.indent_spaces, 0)
253 253 isp.push('if 1:\n return ')
254 254 self.assertEqual(isp.indent_spaces, 0)
255 255 isp.push('if 1:\n return(0)')
256 256 self.assertEqual(isp.indent_spaces, 0)
257 257
258 258 def test_push(self):
259 259 isp = self.isp
260 260 self.assertTrue(isp.push('x=1'))
261 261
262 262 def test_push2(self):
263 263 isp = self.isp
264 264 self.assertFalse(isp.push('if 1:'))
265 265 for line in [' x=1', '# a comment', ' y=2']:
266 266 print(line)
267 267 self.assertTrue(isp.push(line))
268 268
269 269 def test_push3(self):
270 270 isp = self.isp
271 271 isp.push('if True:')
272 272 isp.push(' a = 1')
273 273 self.assertFalse(isp.push('b = [1,'))
274 274
275 275 def test_push_accepts_more(self):
276 276 isp = self.isp
277 277 isp.push('x=1')
278 278 self.assertFalse(isp.push_accepts_more())
279 279
280 280 def test_push_accepts_more2(self):
281 281 isp = self.isp
282 282 isp.push('if 1:')
283 283 self.assertTrue(isp.push_accepts_more())
284 284 isp.push(' x=1')
285 285 self.assertTrue(isp.push_accepts_more())
286 286 isp.push('')
287 287 self.assertFalse(isp.push_accepts_more())
288 288
289 289 def test_push_accepts_more3(self):
290 290 isp = self.isp
291 291 isp.push("x = (2+\n3)")
292 292 self.assertFalse(isp.push_accepts_more())
293 293
294 294 def test_push_accepts_more4(self):
295 295 isp = self.isp
296 296 # When a multiline statement contains parens or multiline strings, we
297 297 # shouldn't get confused.
298 298 # FIXME: we should be able to better handle de-dents in statements like
299 299 # multiline strings and multiline expressions (continued with \ or
300 300 # parens). Right now we aren't handling the indentation tracking quite
301 301 # correctly with this, though in practice it may not be too much of a
302 302 # problem. We'll need to see.
303 303 isp.push("if 1:")
304 304 isp.push(" x = (2+")
305 305 isp.push(" 3)")
306 306 self.assertTrue(isp.push_accepts_more())
307 307 isp.push(" y = 3")
308 308 self.assertTrue(isp.push_accepts_more())
309 309 isp.push('')
310 310 self.assertFalse(isp.push_accepts_more())
311 311
312 312 def test_push_accepts_more5(self):
313 313 isp = self.isp
314 314 isp.push('try:')
315 315 isp.push(' a = 5')
316 316 isp.push('except:')
317 317 isp.push(' raise')
318 318 # We want to be able to add an else: block at this point, so it should
319 319 # wait for a blank line.
320 320 self.assertTrue(isp.push_accepts_more())
321 321
322 322 def test_continuation(self):
323 323 isp = self.isp
324 324 isp.push("import os, \\")
325 325 self.assertTrue(isp.push_accepts_more())
326 326 isp.push("sys")
327 327 self.assertFalse(isp.push_accepts_more())
328 328
329 329 def test_syntax_error(self):
330 330 isp = self.isp
331 331 # Syntax errors immediately produce a 'ready' block, so the invalid
332 332 # Python can be sent to the kernel for evaluation with possible ipython
333 333 # special-syntax conversion.
334 334 isp.push('run foo')
335 335 self.assertFalse(isp.push_accepts_more())
336 336
337 337 def test_unicode(self):
338 338 self.isp.push(u"PΓ©rez")
339 339 self.isp.push(u'\xc3\xa9')
340 340 self.isp.push(u"u'\xc3\xa9'")
341 341
342 342 def test_line_continuation(self):
343 343 """ Test issue #2108."""
344 344 isp = self.isp
345 345 # A blank line after a line continuation should not accept more
346 346 isp.push("1 \\\n\n")
347 347 self.assertFalse(isp.push_accepts_more())
348 348 # Whitespace after a \ is a SyntaxError. The only way to test that
349 349 # here is to test that push doesn't accept more (as with
350 350 # test_syntax_error() above).
351 351 isp.push(r"1 \ ")
352 352 self.assertFalse(isp.push_accepts_more())
353 353 # Even if the line is continuable (c.f. the regular Python
354 354 # interpreter)
355 355 isp.push(r"(1 \ ")
356 356 self.assertFalse(isp.push_accepts_more())
357 357
358 358 class InteractiveLoopTestCase(unittest.TestCase):
359 359 """Tests for an interactive loop like a python shell.
360 360 """
361 361 def check_ns(self, lines, ns):
362 362 """Validate that the given input lines produce the resulting namespace.
363 363
364 364 Note: the input lines are given exactly as they would be typed in an
365 365 auto-indenting environment, as mini_interactive_loop above already does
366 366 auto-indenting and prepends spaces to the input.
367 367 """
368 368 src = mini_interactive_loop(pseudo_input(lines))
369 369 test_ns = {}
370 370 exec(src, test_ns)
371 371 # We can't check that the provided ns is identical to the test_ns,
372 372 # because Python fills test_ns with extra keys (copyright, etc). But
373 373 # we can check that the given dict is *contained* in test_ns
374 374 for k,v in ns.items():
375 375 self.assertEqual(test_ns[k], v)
376 376
377 377 def test_simple(self):
378 378 self.check_ns(['x=1'], dict(x=1))
379 379
380 380 def test_simple2(self):
381 381 self.check_ns(['if 1:', 'x=2'], dict(x=2))
382 382
383 383 def test_xy(self):
384 384 self.check_ns(['x=1; y=2'], dict(x=1, y=2))
385 385
386 386 def test_abc(self):
387 387 self.check_ns(['if 1:','a=1','b=2','c=3'], dict(a=1, b=2, c=3))
388 388
389 389 def test_multi(self):
390 390 self.check_ns(['x =(1+','1+','2)'], dict(x=4))
391 391
392 392
393 393 class IPythonInputTestCase(InputSplitterTestCase):
394 394 """By just creating a new class whose .isp is a different instance, we
395 395 re-run the same test battery on the new input splitter.
396 396
397 397 In addition, this runs the tests over the syntax and syntax_ml dicts that
398 398 were tested by individual functions, as part of the OO interface.
399 399
400 400 It also makes some checks on the raw buffer storage.
401 401 """
402 402
403 403 def setUp(self):
404 404 self.isp = isp.IPythonInputSplitter()
405 405
406 406 def test_syntax(self):
407 407 """Call all single-line syntax tests from the main object"""
408 408 isp = self.isp
409 409 for example in syntax.values():
410 410 for raw, out_t in example:
411 411 if raw.startswith(' '):
412 412 continue
413 413
414 414 isp.push(raw+'\n')
415 out, out_raw = isp.source_raw_reset()
415 out_raw = isp.source_raw
416 out = isp.source_reset()
416 417 self.assertEqual(out.rstrip(), out_t,
417 418 tt.pair_fail_msg.format("inputsplitter",raw, out_t, out))
418 419 self.assertEqual(out_raw.rstrip(), raw.rstrip())
419 420
420 421 def test_syntax_multiline(self):
421 422 isp = self.isp
422 423 for example in syntax_ml.values():
423 424 for line_pairs in example:
424 425 out_t_parts = []
425 426 raw_parts = []
426 427 for lraw, out_t_part in line_pairs:
427 428 if out_t_part is not None:
428 429 out_t_parts.append(out_t_part)
429 430
430 431 if lraw is not None:
431 432 isp.push(lraw)
432 433 raw_parts.append(lraw)
433 434
434 out, out_raw = isp.source_raw_reset()
435 out_raw = isp.source_raw
436 out = isp.source_reset()
435 437 out_t = '\n'.join(out_t_parts).rstrip()
436 438 raw = '\n'.join(raw_parts).rstrip()
437 439 self.assertEqual(out.rstrip(), out_t)
438 440 self.assertEqual(out_raw.rstrip(), raw)
439 441
440 442 def test_syntax_multiline_cell(self):
441 443 isp = self.isp
442 444 for example in syntax_ml.values():
443 445
444 446 out_t_parts = []
445 447 for line_pairs in example:
446 448 raw = '\n'.join(r for r, _ in line_pairs if r is not None)
447 449 out_t = '\n'.join(t for _,t in line_pairs if t is not None)
448 450 out = isp.transform_cell(raw)
449 451 # Match ignoring trailing whitespace
450 452 self.assertEqual(out.rstrip(), out_t.rstrip())
451 453
452 454 def test_cellmagic_preempt(self):
453 455 isp = self.isp
454 456 for raw, name, line, cell in [
455 457 ("%%cellm a\nIn[1]:", u'cellm', u'a', u'In[1]:'),
456 458 ("%%cellm \nline\n>>>hi", u'cellm', u'', u'line\n>>>hi'),
457 459 (">>>%%cellm \nline\n>>>hi", u'cellm', u'', u'line\nhi'),
458 460 ("%%cellm \n>>>hi", u'cellm', u'', u'hi'),
459 461 ("%%cellm \nline1\nline2", u'cellm', u'', u'line1\nline2'),
460 462 ("%%cellm \nline1\\\\\nline2", u'cellm', u'', u'line1\\\\\nline2'),
461 463 ]:
462 464 expected = "get_ipython().run_cell_magic(%r, %r, %r)" % (
463 465 name, line, cell
464 466 )
465 467 out = isp.transform_cell(raw)
466 468 self.assertEqual(out.rstrip(), expected.rstrip())
467 469
468 470
469 471
470 472 #-----------------------------------------------------------------------------
471 473 # Main - use as a script, mostly for developer experiments
472 474 #-----------------------------------------------------------------------------
473 475
474 476 if __name__ == '__main__':
475 477 # A simple demo for interactive experimentation. This code will not get
476 478 # picked up by any test suite.
477 479 from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
478 480
479 481 # configure here the syntax to use, prompt and whether to autoindent
480 482 #isp, start_prompt = InputSplitter(), '>>> '
481 483 isp, start_prompt = IPythonInputSplitter(), 'In> '
482 484
483 485 autoindent = True
484 486 #autoindent = False
485 487
486 488 try:
487 489 while True:
488 490 prompt = start_prompt
489 491 while isp.push_accepts_more():
490 492 indent = ' '*isp.indent_spaces
491 493 if autoindent:
492 494 line = indent + input(prompt+indent)
493 495 else:
494 496 line = input(prompt)
495 497 isp.push(line)
496 498 prompt = '... '
497 499
498 500 # Here we just return input so we can use it in a test suite, but a
499 501 # real interpreter would instead send it for execution somewhere.
500 502 #src = isp.source; raise EOFError # dbg
501 src, raw = isp.source_raw_reset()
503 raw = isp.source_raw
504 src = isp.source_reset()
502 505 print('Input source was:\n', src)
503 506 print('Raw source was:\n', raw)
504 507 except EOFError:
505 508 print('Bye')
506 509
507 510 # Tests for cell magics support
508 511
509 512 def test_last_blank():
510 513 nt.assert_false(isp.last_blank(''))
511 514 nt.assert_false(isp.last_blank('abc'))
512 515 nt.assert_false(isp.last_blank('abc\n'))
513 516 nt.assert_false(isp.last_blank('abc\na'))
514 517
515 518 nt.assert_true(isp.last_blank('\n'))
516 519 nt.assert_true(isp.last_blank('\n '))
517 520 nt.assert_true(isp.last_blank('abc\n '))
518 521 nt.assert_true(isp.last_blank('abc\n\n'))
519 522 nt.assert_true(isp.last_blank('abc\nd\n\n'))
520 523 nt.assert_true(isp.last_blank('abc\nd\ne\n\n'))
521 524 nt.assert_true(isp.last_blank('abc \n \n \n\n'))
522 525
523 526
524 527 def test_last_two_blanks():
525 528 nt.assert_false(isp.last_two_blanks(''))
526 529 nt.assert_false(isp.last_two_blanks('abc'))
527 530 nt.assert_false(isp.last_two_blanks('abc\n'))
528 531 nt.assert_false(isp.last_two_blanks('abc\n\na'))
529 532 nt.assert_false(isp.last_two_blanks('abc\n \n'))
530 533 nt.assert_false(isp.last_two_blanks('abc\n\n'))
531 534
532 535 nt.assert_true(isp.last_two_blanks('\n\n'))
533 536 nt.assert_true(isp.last_two_blanks('\n\n '))
534 537 nt.assert_true(isp.last_two_blanks('\n \n'))
535 538 nt.assert_true(isp.last_two_blanks('abc\n\n '))
536 539 nt.assert_true(isp.last_two_blanks('abc\n\n\n'))
537 540 nt.assert_true(isp.last_two_blanks('abc\n\n \n'))
538 541 nt.assert_true(isp.last_two_blanks('abc\n\n \n '))
539 542 nt.assert_true(isp.last_two_blanks('abc\n\n \n \n'))
540 543 nt.assert_true(isp.last_two_blanks('abc\nd\n\n\n'))
541 544 nt.assert_true(isp.last_two_blanks('abc\nd\ne\nf\n\n\n'))
542 545
543 546
544 547 class CellMagicsCommon(object):
545 548
546 549 def test_whole_cell(self):
547 550 src = "%%cellm line\nbody\n"
548 sp = self.sp
549 sp.push(src)
550 out = sp.source_reset()
551 out = self.sp.transform_cell(src)
551 552 ref = u"get_ipython().run_cell_magic({u}'cellm', {u}'line', {u}'body')\n"
552 553 nt.assert_equal(out, py3compat.u_format(ref))
553 554
554 555 def test_cellmagic_help(self):
555 556 self.sp.push('%%cellm?')
556 557 nt.assert_false(self.sp.push_accepts_more())
557 558
558 559 def tearDown(self):
559 560 self.sp.reset()
560 561
561 562
562 563 class CellModeCellMagics(CellMagicsCommon, unittest.TestCase):
563 564 sp = isp.IPythonInputSplitter(line_input_checker=False)
564 565
565 566 def test_incremental(self):
566 567 sp = self.sp
567 568 sp.push('%%cellm firstline\n')
568 569 nt.assert_true(sp.push_accepts_more()) #1
569 570 sp.push('line2\n')
570 571 nt.assert_true(sp.push_accepts_more()) #2
571 572 sp.push('\n')
572 573 # This should accept a blank line and carry on until the cell is reset
573 574 nt.assert_true(sp.push_accepts_more()) #3
574 575
575 576 class LineModeCellMagics(CellMagicsCommon, unittest.TestCase):
576 577 sp = isp.IPythonInputSplitter(line_input_checker=True)
577 578
578 579 def test_incremental(self):
579 580 sp = self.sp
580 581 sp.push('%%cellm line2\n')
581 582 nt.assert_true(sp.push_accepts_more()) #1
582 583 sp.push('\n')
583 584 # In this case, a blank line should end the cell magic
584 585 nt.assert_false(sp.push_accepts_more()) #2
@@ -1,793 +1,787 b''
1 1 from __future__ import print_function
2 2
3 3 # Standard library imports
4 4 from collections import namedtuple
5 5 import sys
6 6 import uuid
7 7
8 8 # System library imports
9 9 from pygments.lexers import PythonLexer
10 10 from IPython.external import qt
11 11 from IPython.external.qt import QtCore, QtGui
12 12
13 13 # Local imports
14 14 from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
15 15 from IPython.core.inputtransformer import classic_prompt
16 16 from IPython.core.oinspect import call_tip
17 17 from IPython.qt.base_frontend_mixin import BaseFrontendMixin
18 18 from IPython.utils.traitlets import Bool, Instance, Unicode
19 19 from .bracket_matcher import BracketMatcher
20 20 from .call_tip_widget import CallTipWidget
21 21 from .completion_lexer import CompletionLexer
22 22 from .history_console_widget import HistoryConsoleWidget
23 23 from .pygments_highlighter import PygmentsHighlighter
24 24
25 25
26 26 class FrontendHighlighter(PygmentsHighlighter):
27 27 """ A PygmentsHighlighter that understands and ignores prompts.
28 28 """
29 29
30 30 def __init__(self, frontend):
31 31 super(FrontendHighlighter, self).__init__(frontend._control.document())
32 32 self._current_offset = 0
33 33 self._frontend = frontend
34 34 self.highlighting_on = False
35 35
36 36 def highlightBlock(self, string):
37 37 """ Highlight a block of text. Reimplemented to highlight selectively.
38 38 """
39 39 if not self.highlighting_on:
40 40 return
41 41
42 42 # The input to this function is a unicode string that may contain
43 43 # paragraph break characters, non-breaking spaces, etc. Here we acquire
44 44 # the string as plain text so we can compare it.
45 45 current_block = self.currentBlock()
46 46 string = self._frontend._get_block_plain_text(current_block)
47 47
48 48 # Decide whether to check for the regular or continuation prompt.
49 49 if current_block.contains(self._frontend._prompt_pos):
50 50 prompt = self._frontend._prompt
51 51 else:
52 52 prompt = self._frontend._continuation_prompt
53 53
54 54 # Only highlight if we can identify a prompt, but make sure not to
55 55 # highlight the prompt.
56 56 if string.startswith(prompt):
57 57 self._current_offset = len(prompt)
58 58 string = string[len(prompt):]
59 59 super(FrontendHighlighter, self).highlightBlock(string)
60 60
61 61 def rehighlightBlock(self, block):
62 62 """ Reimplemented to temporarily enable highlighting if disabled.
63 63 """
64 64 old = self.highlighting_on
65 65 self.highlighting_on = True
66 66 super(FrontendHighlighter, self).rehighlightBlock(block)
67 67 self.highlighting_on = old
68 68
69 69 def setFormat(self, start, count, format):
70 70 """ Reimplemented to highlight selectively.
71 71 """
72 72 start += self._current_offset
73 73 super(FrontendHighlighter, self).setFormat(start, count, format)
74 74
75 75
76 76 class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
77 77 """ A Qt frontend for a generic Python kernel.
78 78 """
79 79
80 80 # The text to show when the kernel is (re)started.
81 81 banner = Unicode(config=True)
82 82
83 83 # An option and corresponding signal for overriding the default kernel
84 84 # interrupt behavior.
85 85 custom_interrupt = Bool(False)
86 86 custom_interrupt_requested = QtCore.Signal()
87 87
88 88 # An option and corresponding signals for overriding the default kernel
89 89 # restart behavior.
90 90 custom_restart = Bool(False)
91 91 custom_restart_kernel_died = QtCore.Signal(float)
92 92 custom_restart_requested = QtCore.Signal()
93 93
94 94 # Whether to automatically show calltips on open-parentheses.
95 95 enable_calltips = Bool(True, config=True,
96 96 help="Whether to draw information calltips on open-parentheses.")
97 97
98 98 clear_on_kernel_restart = Bool(True, config=True,
99 99 help="Whether to clear the console when the kernel is restarted")
100 100
101 101 confirm_restart = Bool(True, config=True,
102 102 help="Whether to ask for user confirmation when restarting kernel")
103 103
104 104 # Emitted when a user visible 'execute_request' has been submitted to the
105 105 # kernel from the FrontendWidget. Contains the code to be executed.
106 106 executing = QtCore.Signal(object)
107 107
108 108 # Emitted when a user-visible 'execute_reply' has been received from the
109 109 # kernel and processed by the FrontendWidget. Contains the response message.
110 110 executed = QtCore.Signal(object)
111 111
112 112 # Emitted when an exit request has been received from the kernel.
113 113 exit_requested = QtCore.Signal(object)
114 114
115 115 # Protected class variables.
116 116 _prompt_transformer = IPythonInputSplitter(physical_line_transforms=[classic_prompt()],
117 117 logical_line_transforms=[],
118 118 python_line_transforms=[],
119 119 )
120 120 _CallTipRequest = namedtuple('_CallTipRequest', ['id', 'pos'])
121 121 _CompletionRequest = namedtuple('_CompletionRequest', ['id', 'pos'])
122 122 _ExecutionRequest = namedtuple('_ExecutionRequest', ['id', 'kind'])
123 123 _input_splitter_class = InputSplitter
124 124 _local_kernel = False
125 125 _highlighter = Instance(FrontendHighlighter)
126 126
127 127 #---------------------------------------------------------------------------
128 128 # 'object' interface
129 129 #---------------------------------------------------------------------------
130 130
131 131 def __init__(self, *args, **kw):
132 132 super(FrontendWidget, self).__init__(*args, **kw)
133 133 # FIXME: remove this when PySide min version is updated past 1.0.7
134 134 # forcefully disable calltips if PySide is < 1.0.7, because they crash
135 135 if qt.QT_API == qt.QT_API_PYSIDE:
136 136 import PySide
137 137 if PySide.__version_info__ < (1,0,7):
138 138 self.log.warn("PySide %s < 1.0.7 detected, disabling calltips" % PySide.__version__)
139 139 self.enable_calltips = False
140 140
141 141 # FrontendWidget protected variables.
142 142 self._bracket_matcher = BracketMatcher(self._control)
143 143 self._call_tip_widget = CallTipWidget(self._control)
144 144 self._completion_lexer = CompletionLexer(PythonLexer())
145 145 self._copy_raw_action = QtGui.QAction('Copy (Raw Text)', None)
146 146 self._hidden = False
147 147 self._highlighter = FrontendHighlighter(self)
148 148 self._input_splitter = self._input_splitter_class()
149 149 self._kernel_manager = None
150 150 self._kernel_client = None
151 151 self._request_info = {}
152 152 self._request_info['execute'] = {};
153 153 self._callback_dict = {}
154 154
155 155 # Configure the ConsoleWidget.
156 156 self.tab_width = 4
157 157 self._set_continuation_prompt('... ')
158 158
159 159 # Configure the CallTipWidget.
160 160 self._call_tip_widget.setFont(self.font)
161 161 self.font_changed.connect(self._call_tip_widget.setFont)
162 162
163 163 # Configure actions.
164 164 action = self._copy_raw_action
165 165 key = QtCore.Qt.CTRL | QtCore.Qt.SHIFT | QtCore.Qt.Key_C
166 166 action.setEnabled(False)
167 167 action.setShortcut(QtGui.QKeySequence(key))
168 168 action.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
169 169 action.triggered.connect(self.copy_raw)
170 170 self.copy_available.connect(action.setEnabled)
171 171 self.addAction(action)
172 172
173 173 # Connect signal handlers.
174 174 document = self._control.document()
175 175 document.contentsChange.connect(self._document_contents_change)
176 176
177 177 # Set flag for whether we are connected via localhost.
178 178 self._local_kernel = kw.get('local_kernel',
179 179 FrontendWidget._local_kernel)
180 180
181 181 #---------------------------------------------------------------------------
182 182 # 'ConsoleWidget' public interface
183 183 #---------------------------------------------------------------------------
184 184
185 185 def copy(self):
186 186 """ Copy the currently selected text to the clipboard, removing prompts.
187 187 """
188 188 if self._page_control is not None and self._page_control.hasFocus():
189 189 self._page_control.copy()
190 190 elif self._control.hasFocus():
191 191 text = self._control.textCursor().selection().toPlainText()
192 192 if text:
193 193 text = self._prompt_transformer.transform_cell(text)
194 194 QtGui.QApplication.clipboard().setText(text)
195 195 else:
196 196 self.log.debug("frontend widget : unknown copy target")
197 197
198 198 #---------------------------------------------------------------------------
199 199 # 'ConsoleWidget' abstract interface
200 200 #---------------------------------------------------------------------------
201 201
202 202 def _is_complete(self, source, interactive):
203 203 """ Returns whether 'source' can be completely processed and a new
204 204 prompt created. When triggered by an Enter/Return key press,
205 205 'interactive' is True; otherwise, it is False.
206 206 """
207 try:
208 207 self._input_splitter.reset()
209 except SyntaxError:
210 pass
211 208 try:
212 209 complete = self._input_splitter.push(source)
213 210 except SyntaxError:
214 211 return True
215 212 if interactive:
216 213 complete = not self._input_splitter.push_accepts_more()
217 214 return complete
218 215
219 216 def _execute(self, source, hidden):
220 217 """ Execute 'source'. If 'hidden', do not show any output.
221 218
222 219 See parent class :meth:`execute` docstring for full details.
223 220 """
224 221 msg_id = self.kernel_client.execute(source, hidden)
225 222 self._request_info['execute'][msg_id] = self._ExecutionRequest(msg_id, 'user')
226 223 self._hidden = hidden
227 224 if not hidden:
228 225 self.executing.emit(source)
229 226
230 227 def _prompt_started_hook(self):
231 228 """ Called immediately after a new prompt is displayed.
232 229 """
233 230 if not self._reading:
234 231 self._highlighter.highlighting_on = True
235 232
236 233 def _prompt_finished_hook(self):
237 234 """ Called immediately after a prompt is finished, i.e. when some input
238 235 will be processed and a new prompt displayed.
239 236 """
240 237 # Flush all state from the input splitter so the next round of
241 238 # reading input starts with a clean buffer.
242 try:
243 239 self._input_splitter.reset()
244 except SyntaxError:
245 pass
246 240
247 241 if not self._reading:
248 242 self._highlighter.highlighting_on = False
249 243
250 244 def _tab_pressed(self):
251 245 """ Called when the tab key is pressed. Returns whether to continue
252 246 processing the event.
253 247 """
254 248 # Perform tab completion if:
255 249 # 1) The cursor is in the input buffer.
256 250 # 2) There is a non-whitespace character before the cursor.
257 251 text = self._get_input_buffer_cursor_line()
258 252 if text is None:
259 253 return False
260 254 complete = bool(text[:self._get_input_buffer_cursor_column()].strip())
261 255 if complete:
262 256 self._complete()
263 257 return not complete
264 258
265 259 #---------------------------------------------------------------------------
266 260 # 'ConsoleWidget' protected interface
267 261 #---------------------------------------------------------------------------
268 262
269 263 def _context_menu_make(self, pos):
270 264 """ Reimplemented to add an action for raw copy.
271 265 """
272 266 menu = super(FrontendWidget, self)._context_menu_make(pos)
273 267 for before_action in menu.actions():
274 268 if before_action.shortcut().matches(QtGui.QKeySequence.Paste) == \
275 269 QtGui.QKeySequence.ExactMatch:
276 270 menu.insertAction(before_action, self._copy_raw_action)
277 271 break
278 272 return menu
279 273
280 274 def request_interrupt_kernel(self):
281 275 if self._executing:
282 276 self.interrupt_kernel()
283 277
284 278 def request_restart_kernel(self):
285 279 message = 'Are you sure you want to restart the kernel?'
286 280 self.restart_kernel(message, now=False)
287 281
288 282 def _event_filter_console_keypress(self, event):
289 283 """ Reimplemented for execution interruption and smart backspace.
290 284 """
291 285 key = event.key()
292 286 if self._control_key_down(event.modifiers(), include_command=False):
293 287
294 288 if key == QtCore.Qt.Key_C and self._executing:
295 289 self.request_interrupt_kernel()
296 290 return True
297 291
298 292 elif key == QtCore.Qt.Key_Period:
299 293 self.request_restart_kernel()
300 294 return True
301 295
302 296 elif not event.modifiers() & QtCore.Qt.AltModifier:
303 297
304 298 # Smart backspace: remove four characters in one backspace if:
305 299 # 1) everything left of the cursor is whitespace
306 300 # 2) the four characters immediately left of the cursor are spaces
307 301 if key == QtCore.Qt.Key_Backspace:
308 302 col = self._get_input_buffer_cursor_column()
309 303 cursor = self._control.textCursor()
310 304 if col > 3 and not cursor.hasSelection():
311 305 text = self._get_input_buffer_cursor_line()[:col]
312 306 if text.endswith(' ') and not text.strip():
313 307 cursor.movePosition(QtGui.QTextCursor.Left,
314 308 QtGui.QTextCursor.KeepAnchor, 4)
315 309 cursor.removeSelectedText()
316 310 return True
317 311
318 312 return super(FrontendWidget, self)._event_filter_console_keypress(event)
319 313
320 314 def _insert_continuation_prompt(self, cursor):
321 315 """ Reimplemented for auto-indentation.
322 316 """
323 317 super(FrontendWidget, self)._insert_continuation_prompt(cursor)
324 318 cursor.insertText(' ' * self._input_splitter.indent_spaces)
325 319
326 320 #---------------------------------------------------------------------------
327 321 # 'BaseFrontendMixin' abstract interface
328 322 #---------------------------------------------------------------------------
329 323
330 324 def _handle_complete_reply(self, rep):
331 325 """ Handle replies for tab completion.
332 326 """
333 327 self.log.debug("complete: %s", rep.get('content', ''))
334 328 cursor = self._get_cursor()
335 329 info = self._request_info.get('complete')
336 330 if info and info.id == rep['parent_header']['msg_id'] and \
337 331 info.pos == cursor.position():
338 332 text = '.'.join(self._get_context())
339 333 cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
340 334 self._complete_with_items(cursor, rep['content']['matches'])
341 335
342 336 def _silent_exec_callback(self, expr, callback):
343 337 """Silently execute `expr` in the kernel and call `callback` with reply
344 338
345 339 the `expr` is evaluated silently in the kernel (without) output in
346 340 the frontend. Call `callback` with the
347 341 `repr <http://docs.python.org/library/functions.html#repr> `_ as first argument
348 342
349 343 Parameters
350 344 ----------
351 345 expr : string
352 346 valid string to be executed by the kernel.
353 347 callback : function
354 348 function accepting one argument, as a string. The string will be
355 349 the `repr` of the result of evaluating `expr`
356 350
357 351 The `callback` is called with the `repr()` of the result of `expr` as
358 352 first argument. To get the object, do `eval()` on the passed value.
359 353
360 354 See Also
361 355 --------
362 356 _handle_exec_callback : private method, deal with calling callback with reply
363 357
364 358 """
365 359
366 360 # generate uuid, which would be used as an indication of whether or
367 361 # not the unique request originated from here (can use msg id ?)
368 362 local_uuid = str(uuid.uuid1())
369 363 msg_id = self.kernel_client.execute('',
370 364 silent=True, user_expressions={ local_uuid:expr })
371 365 self._callback_dict[local_uuid] = callback
372 366 self._request_info['execute'][msg_id] = self._ExecutionRequest(msg_id, 'silent_exec_callback')
373 367
374 368 def _handle_exec_callback(self, msg):
375 369 """Execute `callback` corresponding to `msg` reply, after ``_silent_exec_callback``
376 370
377 371 Parameters
378 372 ----------
379 373 msg : raw message send by the kernel containing an `user_expressions`
380 374 and having a 'silent_exec_callback' kind.
381 375
382 376 Notes
383 377 -----
384 378 This function will look for a `callback` associated with the
385 379 corresponding message id. Association has been made by
386 380 `_silent_exec_callback`. `callback` is then called with the `repr()`
387 381 of the value of corresponding `user_expressions` as argument.
388 382 `callback` is then removed from the known list so that any message
389 383 coming again with the same id won't trigger it.
390 384
391 385 """
392 386
393 387 user_exp = msg['content'].get('user_expressions')
394 388 if not user_exp:
395 389 return
396 390 for expression in user_exp:
397 391 if expression in self._callback_dict:
398 392 self._callback_dict.pop(expression)(user_exp[expression])
399 393
400 394 def _handle_execute_reply(self, msg):
401 395 """ Handles replies for code execution.
402 396 """
403 397 self.log.debug("execute: %s", msg.get('content', ''))
404 398 msg_id = msg['parent_header']['msg_id']
405 399 info = self._request_info['execute'].get(msg_id)
406 400 # unset reading flag, because if execute finished, raw_input can't
407 401 # still be pending.
408 402 self._reading = False
409 403 if info and info.kind == 'user' and not self._hidden:
410 404 # Make sure that all output from the SUB channel has been processed
411 405 # before writing a new prompt.
412 406 self.kernel_client.iopub_channel.flush()
413 407
414 408 # Reset the ANSI style information to prevent bad text in stdout
415 409 # from messing up our colors. We're not a true terminal so we're
416 410 # allowed to do this.
417 411 if self.ansi_codes:
418 412 self._ansi_processor.reset_sgr()
419 413
420 414 content = msg['content']
421 415 status = content['status']
422 416 if status == 'ok':
423 417 self._process_execute_ok(msg)
424 418 elif status == 'error':
425 419 self._process_execute_error(msg)
426 420 elif status == 'aborted':
427 421 self._process_execute_abort(msg)
428 422
429 423 self._show_interpreter_prompt_for_reply(msg)
430 424 self.executed.emit(msg)
431 425 self._request_info['execute'].pop(msg_id)
432 426 elif info and info.kind == 'silent_exec_callback' and not self._hidden:
433 427 self._handle_exec_callback(msg)
434 428 self._request_info['execute'].pop(msg_id)
435 429 else:
436 430 super(FrontendWidget, self)._handle_execute_reply(msg)
437 431
438 432 def _handle_input_request(self, msg):
439 433 """ Handle requests for raw_input.
440 434 """
441 435 self.log.debug("input: %s", msg.get('content', ''))
442 436 if self._hidden:
443 437 raise RuntimeError('Request for raw input during hidden execution.')
444 438
445 439 # Make sure that all output from the SUB channel has been processed
446 440 # before entering readline mode.
447 441 self.kernel_client.iopub_channel.flush()
448 442
449 443 def callback(line):
450 444 self.kernel_client.stdin_channel.input(line)
451 445 if self._reading:
452 446 self.log.debug("Got second input request, assuming first was interrupted.")
453 447 self._reading = False
454 448 self._readline(msg['content']['prompt'], callback=callback)
455 449
456 450 def _kernel_restarted_message(self, died=True):
457 451 msg = "Kernel died, restarting" if died else "Kernel restarting"
458 452 self._append_html("<br>%s<hr><br>" % msg,
459 453 before_prompt=False
460 454 )
461 455
462 456 def _handle_kernel_died(self, since_last_heartbeat):
463 457 """Handle the kernel's death (if we do not own the kernel).
464 458 """
465 459 self.log.warn("kernel died: %s", since_last_heartbeat)
466 460 if self.custom_restart:
467 461 self.custom_restart_kernel_died.emit(since_last_heartbeat)
468 462 else:
469 463 self._kernel_restarted_message(died=True)
470 464 self.reset()
471 465
472 466 def _handle_kernel_restarted(self, died=True):
473 467 """Notice that the autorestarter restarted the kernel.
474 468
475 469 There's nothing to do but show a message.
476 470 """
477 471 self.log.warn("kernel restarted")
478 472 self._kernel_restarted_message(died=died)
479 473 self.reset()
480 474
481 475 def _handle_object_info_reply(self, rep):
482 476 """ Handle replies for call tips.
483 477 """
484 478 self.log.debug("oinfo: %s", rep.get('content', ''))
485 479 cursor = self._get_cursor()
486 480 info = self._request_info.get('call_tip')
487 481 if info and info.id == rep['parent_header']['msg_id'] and \
488 482 info.pos == cursor.position():
489 483 # Get the information for a call tip. For now we format the call
490 484 # line as string, later we can pass False to format_call and
491 485 # syntax-highlight it ourselves for nicer formatting in the
492 486 # calltip.
493 487 content = rep['content']
494 488 # if this is from pykernel, 'docstring' will be the only key
495 489 if content.get('ismagic', False):
496 490 # Don't generate a call-tip for magics. Ideally, we should
497 491 # generate a tooltip, but not on ( like we do for actual
498 492 # callables.
499 493 call_info, doc = None, None
500 494 else:
501 495 call_info, doc = call_tip(content, format_call=True)
502 496 if call_info or doc:
503 497 self._call_tip_widget.show_call_info(call_info, doc)
504 498
505 499 def _handle_pyout(self, msg):
506 500 """ Handle display hook output.
507 501 """
508 502 self.log.debug("pyout: %s", msg.get('content', ''))
509 503 if not self._hidden and self._is_from_this_session(msg):
510 504 text = msg['content']['data']
511 505 self._append_plain_text(text + '\n', before_prompt=True)
512 506
513 507 def _handle_stream(self, msg):
514 508 """ Handle stdout, stderr, and stdin.
515 509 """
516 510 self.log.debug("stream: %s", msg.get('content', ''))
517 511 if not self._hidden and self._is_from_this_session(msg):
518 512 # Most consoles treat tabs as being 8 space characters. Convert tabs
519 513 # to spaces so that output looks as expected regardless of this
520 514 # widget's tab width.
521 515 text = msg['content']['data'].expandtabs(8)
522 516
523 517 self._append_plain_text(text, before_prompt=True)
524 518 self._control.moveCursor(QtGui.QTextCursor.End)
525 519
526 520 def _handle_shutdown_reply(self, msg):
527 521 """ Handle shutdown signal, only if from other console.
528 522 """
529 523 self.log.warn("shutdown: %s", msg.get('content', ''))
530 524 restart = msg.get('content', {}).get('restart', False)
531 525 if not self._hidden and not self._is_from_this_session(msg):
532 526 # got shutdown reply, request came from session other than ours
533 527 if restart:
534 528 # someone restarted the kernel, handle it
535 529 self._handle_kernel_restarted(died=False)
536 530 else:
537 531 # kernel was shutdown permanently
538 532 # this triggers exit_requested if the kernel was local,
539 533 # and a dialog if the kernel was remote,
540 534 # so we don't suddenly clear the qtconsole without asking.
541 535 if self._local_kernel:
542 536 self.exit_requested.emit(self)
543 537 else:
544 538 title = self.window().windowTitle()
545 539 reply = QtGui.QMessageBox.question(self, title,
546 540 "Kernel has been shutdown permanently. "
547 541 "Close the Console?",
548 542 QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
549 543 if reply == QtGui.QMessageBox.Yes:
550 544 self.exit_requested.emit(self)
551 545
552 546 def _handle_status(self, msg):
553 547 """Handle status message"""
554 548 # This is where a busy/idle indicator would be triggered,
555 549 # when we make one.
556 550 state = msg['content'].get('execution_state', '')
557 551 if state == 'starting':
558 552 # kernel started while we were running
559 553 if self._executing:
560 554 self._handle_kernel_restarted(died=True)
561 555 elif state == 'idle':
562 556 pass
563 557 elif state == 'busy':
564 558 pass
565 559
566 560 def _started_channels(self):
567 561 """ Called when the KernelManager channels have started listening or
568 562 when the frontend is assigned an already listening KernelManager.
569 563 """
570 564 self.reset(clear=True)
571 565
572 566 #---------------------------------------------------------------------------
573 567 # 'FrontendWidget' public interface
574 568 #---------------------------------------------------------------------------
575 569
576 570 def copy_raw(self):
577 571 """ Copy the currently selected text to the clipboard without attempting
578 572 to remove prompts or otherwise alter the text.
579 573 """
580 574 self._control.copy()
581 575
582 576 def execute_file(self, path, hidden=False):
583 577 """ Attempts to execute file with 'path'. If 'hidden', no output is
584 578 shown.
585 579 """
586 580 self.execute('execfile(%r)' % path, hidden=hidden)
587 581
588 582 def interrupt_kernel(self):
589 583 """ Attempts to interrupt the running kernel.
590 584
591 585 Also unsets _reading flag, to avoid runtime errors
592 586 if raw_input is called again.
593 587 """
594 588 if self.custom_interrupt:
595 589 self._reading = False
596 590 self.custom_interrupt_requested.emit()
597 591 elif self.kernel_manager:
598 592 self._reading = False
599 593 self.kernel_manager.interrupt_kernel()
600 594 else:
601 595 self._append_plain_text('Cannot interrupt a kernel I did not start.\n')
602 596
603 597 def reset(self, clear=False):
604 598 """ Resets the widget to its initial state if ``clear`` parameter
605 599 is True, otherwise
606 600 prints a visual indication of the fact that the kernel restarted, but
607 601 does not clear the traces from previous usage of the kernel before it
608 602 was restarted. With ``clear=True``, it is similar to ``%clear``, but
609 603 also re-writes the banner and aborts execution if necessary.
610 604 """
611 605 if self._executing:
612 606 self._executing = False
613 607 self._request_info['execute'] = {}
614 608 self._reading = False
615 609 self._highlighter.highlighting_on = False
616 610
617 611 if clear:
618 612 self._control.clear()
619 613 self._append_plain_text(self.banner)
620 614 # update output marker for stdout/stderr, so that startup
621 615 # messages appear after banner:
622 616 self._append_before_prompt_pos = self._get_cursor().position()
623 617 self._show_interpreter_prompt()
624 618
625 619 def restart_kernel(self, message, now=False):
626 620 """ Attempts to restart the running kernel.
627 621 """
628 622 # FIXME: now should be configurable via a checkbox in the dialog. Right
629 623 # now at least the heartbeat path sets it to True and the manual restart
630 624 # to False. But those should just be the pre-selected states of a
631 625 # checkbox that the user could override if so desired. But I don't know
632 626 # enough Qt to go implementing the checkbox now.
633 627
634 628 if self.custom_restart:
635 629 self.custom_restart_requested.emit()
636 630 return
637 631
638 632 if self.kernel_manager:
639 633 # Pause the heart beat channel to prevent further warnings.
640 634 self.kernel_client.hb_channel.pause()
641 635
642 636 # Prompt the user to restart the kernel. Un-pause the heartbeat if
643 637 # they decline. (If they accept, the heartbeat will be un-paused
644 638 # automatically when the kernel is restarted.)
645 639 if self.confirm_restart:
646 640 buttons = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
647 641 result = QtGui.QMessageBox.question(self, 'Restart kernel?',
648 642 message, buttons)
649 643 do_restart = result == QtGui.QMessageBox.Yes
650 644 else:
651 645 # confirm_restart is False, so we don't need to ask user
652 646 # anything, just do the restart
653 647 do_restart = True
654 648 if do_restart:
655 649 try:
656 650 self.kernel_manager.restart_kernel(now=now)
657 651 except RuntimeError as e:
658 652 self._append_plain_text(
659 653 'Error restarting kernel: %s\n' % e,
660 654 before_prompt=True
661 655 )
662 656 else:
663 657 self._append_html("<br>Restarting kernel...\n<hr><br>",
664 658 before_prompt=True,
665 659 )
666 660 else:
667 661 self.kernel_client.hb_channel.unpause()
668 662
669 663 else:
670 664 self._append_plain_text(
671 665 'Cannot restart a Kernel I did not start\n',
672 666 before_prompt=True
673 667 )
674 668
675 669 #---------------------------------------------------------------------------
676 670 # 'FrontendWidget' protected interface
677 671 #---------------------------------------------------------------------------
678 672
679 673 def _call_tip(self):
680 674 """ Shows a call tip, if appropriate, at the current cursor location.
681 675 """
682 676 # Decide if it makes sense to show a call tip
683 677 if not self.enable_calltips:
684 678 return False
685 679 cursor = self._get_cursor()
686 680 cursor.movePosition(QtGui.QTextCursor.Left)
687 681 if cursor.document().characterAt(cursor.position()) != '(':
688 682 return False
689 683 context = self._get_context(cursor)
690 684 if not context:
691 685 return False
692 686
693 687 # Send the metadata request to the kernel
694 688 name = '.'.join(context)
695 689 msg_id = self.kernel_client.object_info(name)
696 690 pos = self._get_cursor().position()
697 691 self._request_info['call_tip'] = self._CallTipRequest(msg_id, pos)
698 692 return True
699 693
700 694 def _complete(self):
701 695 """ Performs completion at the current cursor location.
702 696 """
703 697 context = self._get_context()
704 698 if context:
705 699 # Send the completion request to the kernel
706 700 msg_id = self.kernel_client.complete(
707 701 '.'.join(context), # text
708 702 self._get_input_buffer_cursor_line(), # line
709 703 self._get_input_buffer_cursor_column(), # cursor_pos
710 704 self.input_buffer) # block
711 705 pos = self._get_cursor().position()
712 706 info = self._CompletionRequest(msg_id, pos)
713 707 self._request_info['complete'] = info
714 708
715 709 def _get_context(self, cursor=None):
716 710 """ Gets the context for the specified cursor (or the current cursor
717 711 if none is specified).
718 712 """
719 713 if cursor is None:
720 714 cursor = self._get_cursor()
721 715 cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
722 716 QtGui.QTextCursor.KeepAnchor)
723 717 text = cursor.selection().toPlainText()
724 718 return self._completion_lexer.get_context(text)
725 719
726 720 def _process_execute_abort(self, msg):
727 721 """ Process a reply for an aborted execution request.
728 722 """
729 723 self._append_plain_text("ERROR: execution aborted\n")
730 724
731 725 def _process_execute_error(self, msg):
732 726 """ Process a reply for an execution request that resulted in an error.
733 727 """
734 728 content = msg['content']
735 729 # If a SystemExit is passed along, this means exit() was called - also
736 730 # all the ipython %exit magic syntax of '-k' to be used to keep
737 731 # the kernel running
738 732 if content['ename']=='SystemExit':
739 733 keepkernel = content['evalue']=='-k' or content['evalue']=='True'
740 734 self._keep_kernel_on_exit = keepkernel
741 735 self.exit_requested.emit(self)
742 736 else:
743 737 traceback = ''.join(content['traceback'])
744 738 self._append_plain_text(traceback)
745 739
746 740 def _process_execute_ok(self, msg):
747 741 """ Process a reply for a successful execution request.
748 742 """
749 743 payload = msg['content']['payload']
750 744 for item in payload:
751 745 if not self._process_execute_payload(item):
752 746 warning = 'Warning: received unknown payload of type %s'
753 747 print(warning % repr(item['source']))
754 748
755 749 def _process_execute_payload(self, item):
756 750 """ Process a single payload item from the list of payload items in an
757 751 execution reply. Returns whether the payload was handled.
758 752 """
759 753 # The basic FrontendWidget doesn't handle payloads, as they are a
760 754 # mechanism for going beyond the standard Python interpreter model.
761 755 return False
762 756
763 757 def _show_interpreter_prompt(self):
764 758 """ Shows a prompt for the interpreter.
765 759 """
766 760 self._show_prompt('>>> ')
767 761
768 762 def _show_interpreter_prompt_for_reply(self, msg):
769 763 """ Shows a prompt for the interpreter given an 'execute_reply' message.
770 764 """
771 765 self._show_interpreter_prompt()
772 766
773 767 #------ Signal handlers ----------------------------------------------------
774 768
775 769 def _document_contents_change(self, position, removed, added):
776 770 """ Called whenever the document's content changes. Display a call tip
777 771 if appropriate.
778 772 """
779 773 # Calculate where the cursor should be *after* the change:
780 774 position += added
781 775
782 776 document = self._control.document()
783 777 if position == self._get_cursor().position():
784 778 self._call_tip()
785 779
786 780 #------ Trait default initializers -----------------------------------------
787 781
788 782 def _banner_default(self):
789 783 """ Returns the standard Python banner.
790 784 """
791 785 banner = 'Python %s on %s\nType "help", "copyright", "credits" or ' \
792 786 '"license" for more information.'
793 787 return banner % (sys.version, sys.platform)
@@ -1,835 +1,835 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Sphinx directive to support embedded IPython code.
3 3
4 4 This directive allows pasting of entire interactive IPython sessions, prompts
5 5 and all, and their code will actually get re-executed at doc build time, with
6 6 all prompts renumbered sequentially. It also allows you to input code as a pure
7 7 python input by giving the argument python to the directive. The output looks
8 8 like an interactive ipython section.
9 9
10 10 To enable this directive, simply list it in your Sphinx ``conf.py`` file
11 11 (making sure the directory where you placed it is visible to sphinx, as is
12 12 needed for all Sphinx directives).
13 13
14 14 By default this directive assumes that your prompts are unchanged IPython ones,
15 15 but this can be customized. The configurable options that can be placed in
16 16 conf.py are
17 17
18 18 ipython_savefig_dir:
19 19 The directory in which to save the figures. This is relative to the
20 20 Sphinx source directory. The default is `html_static_path`.
21 21 ipython_rgxin:
22 22 The compiled regular expression to denote the start of IPython input
23 23 lines. The default is re.compile('In \[(\d+)\]:\s?(.*)\s*'). You
24 24 shouldn't need to change this.
25 25 ipython_rgxout:
26 26 The compiled regular expression to denote the start of IPython output
27 27 lines. The default is re.compile('Out\[(\d+)\]:\s?(.*)\s*'). You
28 28 shouldn't need to change this.
29 29 ipython_promptin:
30 30 The string to represent the IPython input prompt in the generated ReST.
31 31 The default is 'In [%d]:'. This expects that the line numbers are used
32 32 in the prompt.
33 33 ipython_promptout:
34 34
35 35 The string to represent the IPython prompt in the generated ReST. The
36 36 default is 'Out [%d]:'. This expects that the line numbers are used
37 37 in the prompt.
38 38
39 39 ToDo
40 40 ----
41 41
42 42 - Turn the ad-hoc test() function into a real test suite.
43 43 - Break up ipython-specific functionality from matplotlib stuff into better
44 44 separated code.
45 45
46 46 Authors
47 47 -------
48 48
49 49 - John D Hunter: orignal author.
50 50 - Fernando Perez: refactoring, documentation, cleanups, port to 0.11.
51 51 - VΓ‘clavΕ milauer <eudoxos-AT-arcig.cz>: Prompt generalizations.
52 52 - Skipper Seabold, refactoring, cleanups, pure python addition
53 53 """
54 54 from __future__ import print_function
55 55
56 56 #-----------------------------------------------------------------------------
57 57 # Imports
58 58 #-----------------------------------------------------------------------------
59 59
60 60 # Stdlib
61 61 import os
62 62 import re
63 63 import sys
64 64 import tempfile
65 65 import ast
66 66
67 67 # To keep compatibility with various python versions
68 68 try:
69 69 from hashlib import md5
70 70 except ImportError:
71 71 from md5 import md5
72 72
73 73 # Third-party
74 74 import matplotlib
75 75 import sphinx
76 76 from docutils.parsers.rst import directives
77 77 from docutils import nodes
78 78 from sphinx.util.compat import Directive
79 79
80 80 matplotlib.use('Agg')
81 81
82 82 # Our own
83 83 from IPython import Config, InteractiveShell
84 84 from IPython.core.profiledir import ProfileDir
85 85 from IPython.utils import io
86 86 from IPython.utils.py3compat import PY3
87 87
88 88 if PY3:
89 89 from io import StringIO
90 90 else:
91 91 from StringIO import StringIO
92 92
93 93 #-----------------------------------------------------------------------------
94 94 # Globals
95 95 #-----------------------------------------------------------------------------
96 96 # for tokenizing blocks
97 97 COMMENT, INPUT, OUTPUT = range(3)
98 98
99 99 #-----------------------------------------------------------------------------
100 100 # Functions and class declarations
101 101 #-----------------------------------------------------------------------------
102 102 def block_parser(part, rgxin, rgxout, fmtin, fmtout):
103 103 """
104 104 part is a string of ipython text, comprised of at most one
105 105 input, one ouput, comments, and blank lines. The block parser
106 106 parses the text into a list of::
107 107
108 108 blocks = [ (TOKEN0, data0), (TOKEN1, data1), ...]
109 109
110 110 where TOKEN is one of [COMMENT | INPUT | OUTPUT ] and
111 111 data is, depending on the type of token::
112 112
113 113 COMMENT : the comment string
114 114
115 115 INPUT: the (DECORATOR, INPUT_LINE, REST) where
116 116 DECORATOR: the input decorator (or None)
117 117 INPUT_LINE: the input as string (possibly multi-line)
118 118 REST : any stdout generated by the input line (not OUTPUT)
119 119
120 120
121 121 OUTPUT: the output string, possibly multi-line
122 122 """
123 123
124 124 block = []
125 125 lines = part.split('\n')
126 126 N = len(lines)
127 127 i = 0
128 128 decorator = None
129 129 while 1:
130 130
131 131 if i==N:
132 132 # nothing left to parse -- the last line
133 133 break
134 134
135 135 line = lines[i]
136 136 i += 1
137 137 line_stripped = line.strip()
138 138 if line_stripped.startswith('#'):
139 139 block.append((COMMENT, line))
140 140 continue
141 141
142 142 if line_stripped.startswith('@'):
143 143 # we're assuming at most one decorator -- may need to
144 144 # rethink
145 145 decorator = line_stripped
146 146 continue
147 147
148 148 # does this look like an input line?
149 149 matchin = rgxin.match(line)
150 150 if matchin:
151 151 lineno, inputline = int(matchin.group(1)), matchin.group(2)
152 152
153 153 # the ....: continuation string
154 154 continuation = ' %s:'%''.join(['.']*(len(str(lineno))+2))
155 155 Nc = len(continuation)
156 156 # input lines can continue on for more than one line, if
157 157 # we have a '\' line continuation char or a function call
158 158 # echo line 'print'. The input line can only be
159 159 # terminated by the end of the block or an output line, so
160 160 # we parse out the rest of the input line if it is
161 161 # multiline as well as any echo text
162 162
163 163 rest = []
164 164 while i<N:
165 165
166 166 # look ahead; if the next line is blank, or a comment, or
167 167 # an output line, we're done
168 168
169 169 nextline = lines[i]
170 170 matchout = rgxout.match(nextline)
171 171 #print "nextline=%s, continuation=%s, starts=%s"%(nextline, continuation, nextline.startswith(continuation))
172 172 if matchout or nextline.startswith('#'):
173 173 break
174 174 elif nextline.startswith(continuation):
175 175 inputline += '\n' + nextline[Nc:]
176 176 else:
177 177 rest.append(nextline)
178 178 i+= 1
179 179
180 180 block.append((INPUT, (decorator, inputline, '\n'.join(rest))))
181 181 continue
182 182
183 183 # if it looks like an output line grab all the text to the end
184 184 # of the block
185 185 matchout = rgxout.match(line)
186 186 if matchout:
187 187 lineno, output = int(matchout.group(1)), matchout.group(2)
188 188 if i<N-1:
189 189 output = '\n'.join([output] + lines[i:])
190 190
191 191 block.append((OUTPUT, output))
192 192 break
193 193
194 194 return block
195 195
196 196 class EmbeddedSphinxShell(object):
197 197 """An embedded IPython instance to run inside Sphinx"""
198 198
199 199 def __init__(self):
200 200
201 201 self.cout = StringIO()
202 202
203 203
204 204 # Create config object for IPython
205 205 config = Config()
206 206 config.Global.display_banner = False
207 207 config.Global.exec_lines = ['import numpy as np',
208 208 'from pylab import *'
209 209 ]
210 210 config.InteractiveShell.autocall = False
211 211 config.InteractiveShell.autoindent = False
212 212 config.InteractiveShell.colors = 'NoColor'
213 213
214 214 # create a profile so instance history isn't saved
215 215 tmp_profile_dir = tempfile.mkdtemp(prefix='profile_')
216 216 profname = 'auto_profile_sphinx_build'
217 217 pdir = os.path.join(tmp_profile_dir,profname)
218 218 profile = ProfileDir.create_profile_dir(pdir)
219 219
220 220 # Create and initialize ipython, but don't start its mainloop
221 221 IP = InteractiveShell.instance(config=config, profile_dir=profile)
222 222 # io.stdout redirect must be done *after* instantiating InteractiveShell
223 223 io.stdout = self.cout
224 224 io.stderr = self.cout
225 225
226 226 # For debugging, so we can see normal output, use this:
227 227 #from IPython.utils.io import Tee
228 228 #io.stdout = Tee(self.cout, channel='stdout') # dbg
229 229 #io.stderr = Tee(self.cout, channel='stderr') # dbg
230 230
231 231 # Store a few parts of IPython we'll need.
232 232 self.IP = IP
233 233 self.user_ns = self.IP.user_ns
234 234 self.user_global_ns = self.IP.user_global_ns
235 235
236 236 self.input = ''
237 237 self.output = ''
238 238
239 239 self.is_verbatim = False
240 240 self.is_doctest = False
241 241 self.is_suppress = False
242 242
243 243 # on the first call to the savefig decorator, we'll import
244 244 # pyplot as plt so we can make a call to the plt.gcf().savefig
245 245 self._pyplot_imported = False
246 246
247 247 def clear_cout(self):
248 248 self.cout.seek(0)
249 249 self.cout.truncate(0)
250 250
251 251 def process_input_line(self, line, store_history=True):
252 252 """process the input, capturing stdout"""
253 253 #print "input='%s'"%self.input
254 254 stdout = sys.stdout
255 255 splitter = self.IP.input_splitter
256 256 try:
257 257 sys.stdout = self.cout
258 258 splitter.push(line)
259 259 more = splitter.push_accepts_more()
260 260 if not more:
261 source_raw = splitter.source_raw_reset()[1]
261 source_raw = splitter.raw_reset()
262 262 self.IP.run_cell(source_raw, store_history=store_history)
263 263 finally:
264 264 sys.stdout = stdout
265 265
266 266 def process_image(self, decorator):
267 267 """
268 268 # build out an image directive like
269 269 # .. image:: somefile.png
270 270 # :width 4in
271 271 #
272 272 # from an input like
273 273 # savefig somefile.png width=4in
274 274 """
275 275 savefig_dir = self.savefig_dir
276 276 source_dir = self.source_dir
277 277 saveargs = decorator.split(' ')
278 278 filename = saveargs[1]
279 279 # insert relative path to image file in source
280 280 outfile = os.path.relpath(os.path.join(savefig_dir,filename),
281 281 source_dir)
282 282
283 283 imagerows = ['.. image:: %s'%outfile]
284 284
285 285 for kwarg in saveargs[2:]:
286 286 arg, val = kwarg.split('=')
287 287 arg = arg.strip()
288 288 val = val.strip()
289 289 imagerows.append(' :%s: %s'%(arg, val))
290 290
291 291 image_file = os.path.basename(outfile) # only return file name
292 292 image_directive = '\n'.join(imagerows)
293 293 return image_file, image_directive
294 294
295 295
296 296 # Callbacks for each type of token
297 297 def process_input(self, data, input_prompt, lineno):
298 298 """Process data block for INPUT token."""
299 299 decorator, input, rest = data
300 300 image_file = None
301 301 image_directive = None
302 302 #print 'INPUT:', data # dbg
303 303 is_verbatim = decorator=='@verbatim' or self.is_verbatim
304 304 is_doctest = decorator=='@doctest' or self.is_doctest
305 305 is_suppress = decorator=='@suppress' or self.is_suppress
306 306 is_savefig = decorator is not None and \
307 307 decorator.startswith('@savefig')
308 308
309 309 input_lines = input.split('\n')
310 310 if len(input_lines) > 1:
311 311 if input_lines[-1] != "":
312 312 input_lines.append('') # make sure there's a blank line
313 313 # so splitter buffer gets reset
314 314
315 315 continuation = ' %s:'%''.join(['.']*(len(str(lineno))+2))
316 316 Nc = len(continuation)
317 317
318 318 if is_savefig:
319 319 image_file, image_directive = self.process_image(decorator)
320 320
321 321 ret = []
322 322 is_semicolon = False
323 323
324 324 for i, line in enumerate(input_lines):
325 325 if line.endswith(';'):
326 326 is_semicolon = True
327 327
328 328 if i==0:
329 329 # process the first input line
330 330 if is_verbatim:
331 331 self.process_input_line('')
332 332 self.IP.execution_count += 1 # increment it anyway
333 333 else:
334 334 # only submit the line in non-verbatim mode
335 335 self.process_input_line(line, store_history=True)
336 336 formatted_line = '%s %s'%(input_prompt, line)
337 337 else:
338 338 # process a continuation line
339 339 if not is_verbatim:
340 340 self.process_input_line(line, store_history=True)
341 341
342 342 formatted_line = '%s %s'%(continuation, line)
343 343
344 344 if not is_suppress:
345 345 ret.append(formatted_line)
346 346
347 347 if not is_suppress and len(rest.strip()) and is_verbatim:
348 348 # the "rest" is the standard output of the
349 349 # input, which needs to be added in
350 350 # verbatim mode
351 351 ret.append(rest)
352 352
353 353 self.cout.seek(0)
354 354 output = self.cout.read()
355 355 if not is_suppress and not is_semicolon:
356 356 ret.append(output)
357 357 elif is_semicolon: # get spacing right
358 358 ret.append('')
359 359
360 360 self.cout.truncate(0)
361 361 return (ret, input_lines, output, is_doctest, image_file,
362 362 image_directive)
363 363 #print 'OUTPUT', output # dbg
364 364
365 365 def process_output(self, data, output_prompt,
366 366 input_lines, output, is_doctest, image_file):
367 367 """Process data block for OUTPUT token."""
368 368 if is_doctest:
369 369 submitted = data.strip()
370 370 found = output
371 371 if found is not None:
372 372 found = found.strip()
373 373
374 374 # XXX - fperez: in 0.11, 'output' never comes with the prompt
375 375 # in it, just the actual output text. So I think all this code
376 376 # can be nuked...
377 377
378 378 # the above comment does not appear to be accurate... (minrk)
379 379
380 380 ind = found.find(output_prompt)
381 381 if ind<0:
382 382 e='output prompt="%s" does not match out line=%s' % \
383 383 (output_prompt, found)
384 384 raise RuntimeError(e)
385 385 found = found[len(output_prompt):].strip()
386 386
387 387 if found!=submitted:
388 388 e = ('doctest failure for input_lines="%s" with '
389 389 'found_output="%s" and submitted output="%s"' %
390 390 (input_lines, found, submitted) )
391 391 raise RuntimeError(e)
392 392 #print 'doctest PASSED for input_lines="%s" with found_output="%s" and submitted output="%s"'%(input_lines, found, submitted)
393 393
394 394 def process_comment(self, data):
395 395 """Process data fPblock for COMMENT token."""
396 396 if not self.is_suppress:
397 397 return [data]
398 398
399 399 def save_image(self, image_file):
400 400 """
401 401 Saves the image file to disk.
402 402 """
403 403 self.ensure_pyplot()
404 404 command = 'plt.gcf().savefig("%s")'%image_file
405 405 #print 'SAVEFIG', command # dbg
406 406 self.process_input_line('bookmark ipy_thisdir', store_history=False)
407 407 self.process_input_line('cd -b ipy_savedir', store_history=False)
408 408 self.process_input_line(command, store_history=False)
409 409 self.process_input_line('cd -b ipy_thisdir', store_history=False)
410 410 self.process_input_line('bookmark -d ipy_thisdir', store_history=False)
411 411 self.clear_cout()
412 412
413 413
414 414 def process_block(self, block):
415 415 """
416 416 process block from the block_parser and return a list of processed lines
417 417 """
418 418 ret = []
419 419 output = None
420 420 input_lines = None
421 421 lineno = self.IP.execution_count
422 422
423 423 input_prompt = self.promptin%lineno
424 424 output_prompt = self.promptout%lineno
425 425 image_file = None
426 426 image_directive = None
427 427
428 428 for token, data in block:
429 429 if token==COMMENT:
430 430 out_data = self.process_comment(data)
431 431 elif token==INPUT:
432 432 (out_data, input_lines, output, is_doctest, image_file,
433 433 image_directive) = \
434 434 self.process_input(data, input_prompt, lineno)
435 435 elif token==OUTPUT:
436 436 out_data = \
437 437 self.process_output(data, output_prompt,
438 438 input_lines, output, is_doctest,
439 439 image_file)
440 440 if out_data:
441 441 ret.extend(out_data)
442 442
443 443 # save the image files
444 444 if image_file is not None:
445 445 self.save_image(image_file)
446 446
447 447 return ret, image_directive
448 448
449 449 def ensure_pyplot(self):
450 450 if self._pyplot_imported:
451 451 return
452 452 self.process_input_line('import matplotlib.pyplot as plt',
453 453 store_history=False)
454 454
455 455 def process_pure_python(self, content):
456 456 """
457 457 content is a list of strings. it is unedited directive conent
458 458
459 459 This runs it line by line in the InteractiveShell, prepends
460 460 prompts as needed capturing stderr and stdout, then returns
461 461 the content as a list as if it were ipython code
462 462 """
463 463 output = []
464 464 savefig = False # keep up with this to clear figure
465 465 multiline = False # to handle line continuation
466 466 multiline_start = None
467 467 fmtin = self.promptin
468 468
469 469 ct = 0
470 470
471 471 for lineno, line in enumerate(content):
472 472
473 473 line_stripped = line.strip()
474 474 if not len(line):
475 475 output.append(line)
476 476 continue
477 477
478 478 # handle decorators
479 479 if line_stripped.startswith('@'):
480 480 output.extend([line])
481 481 if 'savefig' in line:
482 482 savefig = True # and need to clear figure
483 483 continue
484 484
485 485 # handle comments
486 486 if line_stripped.startswith('#'):
487 487 output.extend([line])
488 488 continue
489 489
490 490 # deal with lines checking for multiline
491 491 continuation = u' %s:'% ''.join(['.']*(len(str(ct))+2))
492 492 if not multiline:
493 493 modified = u"%s %s" % (fmtin % ct, line_stripped)
494 494 output.append(modified)
495 495 ct += 1
496 496 try:
497 497 ast.parse(line_stripped)
498 498 output.append(u'')
499 499 except Exception: # on a multiline
500 500 multiline = True
501 501 multiline_start = lineno
502 502 else: # still on a multiline
503 503 modified = u'%s %s' % (continuation, line)
504 504 output.append(modified)
505 505
506 506 # if the next line is indented, it should be part of multiline
507 507 if len(content) > lineno + 1:
508 508 nextline = content[lineno + 1]
509 509 if len(nextline) - len(nextline.lstrip()) > 3:
510 510 continue
511 511 try:
512 512 mod = ast.parse(
513 513 '\n'.join(content[multiline_start:lineno+1]))
514 514 if isinstance(mod.body[0], ast.FunctionDef):
515 515 # check to see if we have the whole function
516 516 for element in mod.body[0].body:
517 517 if isinstance(element, ast.Return):
518 518 multiline = False
519 519 else:
520 520 output.append(u'')
521 521 multiline = False
522 522 except Exception:
523 523 pass
524 524
525 525 if savefig: # clear figure if plotted
526 526 self.ensure_pyplot()
527 527 self.process_input_line('plt.clf()', store_history=False)
528 528 self.clear_cout()
529 529 savefig = False
530 530
531 531 return output
532 532
533 533 class IPythonDirective(Directive):
534 534
535 535 has_content = True
536 536 required_arguments = 0
537 537 optional_arguments = 4 # python, suppress, verbatim, doctest
538 538 final_argumuent_whitespace = True
539 539 option_spec = { 'python': directives.unchanged,
540 540 'suppress' : directives.flag,
541 541 'verbatim' : directives.flag,
542 542 'doctest' : directives.flag,
543 543 }
544 544
545 545 shell = None
546 546
547 547 seen_docs = set()
548 548
549 549 def get_config_options(self):
550 550 # contains sphinx configuration variables
551 551 config = self.state.document.settings.env.config
552 552
553 553 # get config variables to set figure output directory
554 554 confdir = self.state.document.settings.env.app.confdir
555 555 savefig_dir = config.ipython_savefig_dir
556 556 source_dir = os.path.dirname(self.state.document.current_source)
557 557 if savefig_dir is None:
558 558 savefig_dir = config.html_static_path
559 559 if isinstance(savefig_dir, list):
560 560 savefig_dir = savefig_dir[0] # safe to assume only one path?
561 561 savefig_dir = os.path.join(confdir, savefig_dir)
562 562
563 563 # get regex and prompt stuff
564 564 rgxin = config.ipython_rgxin
565 565 rgxout = config.ipython_rgxout
566 566 promptin = config.ipython_promptin
567 567 promptout = config.ipython_promptout
568 568
569 569 return savefig_dir, source_dir, rgxin, rgxout, promptin, promptout
570 570
571 571 def setup(self):
572 572 if self.shell is None:
573 573 self.shell = EmbeddedSphinxShell()
574 574 # reset the execution count if we haven't processed this doc
575 575 #NOTE: this may be borked if there are multiple seen_doc tmp files
576 576 #check time stamp?
577 577
578 578 if not self.state.document.current_source in self.seen_docs:
579 579 self.shell.IP.history_manager.reset()
580 580 self.shell.IP.execution_count = 1
581 581 self.seen_docs.add(self.state.document.current_source)
582 582
583 583
584 584
585 585 # get config values
586 586 (savefig_dir, source_dir, rgxin,
587 587 rgxout, promptin, promptout) = self.get_config_options()
588 588
589 589 # and attach to shell so we don't have to pass them around
590 590 self.shell.rgxin = rgxin
591 591 self.shell.rgxout = rgxout
592 592 self.shell.promptin = promptin
593 593 self.shell.promptout = promptout
594 594 self.shell.savefig_dir = savefig_dir
595 595 self.shell.source_dir = source_dir
596 596
597 597 # setup bookmark for saving figures directory
598 598
599 599 self.shell.process_input_line('bookmark ipy_savedir %s'%savefig_dir,
600 600 store_history=False)
601 601 self.shell.clear_cout()
602 602
603 603 return rgxin, rgxout, promptin, promptout
604 604
605 605
606 606 def teardown(self):
607 607 # delete last bookmark
608 608 self.shell.process_input_line('bookmark -d ipy_savedir',
609 609 store_history=False)
610 610 self.shell.clear_cout()
611 611
612 612 def run(self):
613 613 debug = False
614 614
615 615 #TODO, any reason block_parser can't be a method of embeddable shell
616 616 # then we wouldn't have to carry these around
617 617 rgxin, rgxout, promptin, promptout = self.setup()
618 618
619 619 options = self.options
620 620 self.shell.is_suppress = 'suppress' in options
621 621 self.shell.is_doctest = 'doctest' in options
622 622 self.shell.is_verbatim = 'verbatim' in options
623 623
624 624
625 625 # handle pure python code
626 626 if 'python' in self.arguments:
627 627 content = self.content
628 628 self.content = self.shell.process_pure_python(content)
629 629
630 630 parts = '\n'.join(self.content).split('\n\n')
631 631
632 632 lines = ['.. code-block:: ipython','']
633 633 figures = []
634 634
635 635 for part in parts:
636 636
637 637 block = block_parser(part, rgxin, rgxout, promptin, promptout)
638 638
639 639 if len(block):
640 640 rows, figure = self.shell.process_block(block)
641 641 for row in rows:
642 642 lines.extend([' %s'%line for line in row.split('\n')])
643 643
644 644 if figure is not None:
645 645 figures.append(figure)
646 646
647 647 #text = '\n'.join(lines)
648 648 #figs = '\n'.join(figures)
649 649
650 650 for figure in figures:
651 651 lines.append('')
652 652 lines.extend(figure.split('\n'))
653 653 lines.append('')
654 654
655 655 #print lines
656 656 if len(lines)>2:
657 657 if debug:
658 658 print('\n'.join(lines))
659 659 else: #NOTE: this raises some errors, what's it for?
660 660 #print 'INSERTING %d lines'%len(lines)
661 661 self.state_machine.insert_input(
662 662 lines, self.state_machine.input_lines.source(0))
663 663
664 664 text = '\n'.join(lines)
665 665 txtnode = nodes.literal_block(text, text)
666 666 txtnode['language'] = 'ipython'
667 667 #imgnode = nodes.image(figs)
668 668
669 669 # cleanup
670 670 self.teardown()
671 671
672 672 return []#, imgnode]
673 673
674 674 # Enable as a proper Sphinx directive
675 675 def setup(app):
676 676 setup.app = app
677 677
678 678 app.add_directive('ipython', IPythonDirective)
679 679 app.add_config_value('ipython_savefig_dir', None, True)
680 680 app.add_config_value('ipython_rgxin',
681 681 re.compile('In \[(\d+)\]:\s?(.*)\s*'), True)
682 682 app.add_config_value('ipython_rgxout',
683 683 re.compile('Out\[(\d+)\]:\s?(.*)\s*'), True)
684 684 app.add_config_value('ipython_promptin', 'In [%d]:', True)
685 685 app.add_config_value('ipython_promptout', 'Out[%d]:', True)
686 686
687 687
688 688 # Simple smoke test, needs to be converted to a proper automatic test.
689 689 def test():
690 690
691 691 examples = [
692 692 r"""
693 693 In [9]: pwd
694 694 Out[9]: '/home/jdhunter/py4science/book'
695 695
696 696 In [10]: cd bookdata/
697 697 /home/jdhunter/py4science/book/bookdata
698 698
699 699 In [2]: from pylab import *
700 700
701 701 In [2]: ion()
702 702
703 703 In [3]: im = imread('stinkbug.png')
704 704
705 705 @savefig mystinkbug.png width=4in
706 706 In [4]: imshow(im)
707 707 Out[4]: <matplotlib.image.AxesImage object at 0x39ea850>
708 708
709 709 """,
710 710 r"""
711 711
712 712 In [1]: x = 'hello world'
713 713
714 714 # string methods can be
715 715 # used to alter the string
716 716 @doctest
717 717 In [2]: x.upper()
718 718 Out[2]: 'HELLO WORLD'
719 719
720 720 @verbatim
721 721 In [3]: x.st<TAB>
722 722 x.startswith x.strip
723 723 """,
724 724 r"""
725 725
726 726 In [130]: url = 'http://ichart.finance.yahoo.com/table.csv?s=CROX\
727 727 .....: &d=9&e=22&f=2009&g=d&a=1&br=8&c=2006&ignore=.csv'
728 728
729 729 In [131]: print url.split('&')
730 730 ['http://ichart.finance.yahoo.com/table.csv?s=CROX', 'd=9', 'e=22', 'f=2009', 'g=d', 'a=1', 'b=8', 'c=2006', 'ignore=.csv']
731 731
732 732 In [60]: import urllib
733 733
734 734 """,
735 735 r"""\
736 736
737 737 In [133]: import numpy.random
738 738
739 739 @suppress
740 740 In [134]: numpy.random.seed(2358)
741 741
742 742 @doctest
743 743 In [135]: numpy.random.rand(10,2)
744 744 Out[135]:
745 745 array([[ 0.64524308, 0.59943846],
746 746 [ 0.47102322, 0.8715456 ],
747 747 [ 0.29370834, 0.74776844],
748 748 [ 0.99539577, 0.1313423 ],
749 749 [ 0.16250302, 0.21103583],
750 750 [ 0.81626524, 0.1312433 ],
751 751 [ 0.67338089, 0.72302393],
752 752 [ 0.7566368 , 0.07033696],
753 753 [ 0.22591016, 0.77731835],
754 754 [ 0.0072729 , 0.34273127]])
755 755
756 756 """,
757 757
758 758 r"""
759 759 In [106]: print x
760 760 jdh
761 761
762 762 In [109]: for i in range(10):
763 763 .....: print i
764 764 .....:
765 765 .....:
766 766 0
767 767 1
768 768 2
769 769 3
770 770 4
771 771 5
772 772 6
773 773 7
774 774 8
775 775 9
776 776 """,
777 777
778 778 r"""
779 779
780 780 In [144]: from pylab import *
781 781
782 782 In [145]: ion()
783 783
784 784 # use a semicolon to suppress the output
785 785 @savefig test_hist.png width=4in
786 786 In [151]: hist(np.random.randn(10000), 100);
787 787
788 788
789 789 @savefig test_plot.png width=4in
790 790 In [151]: plot(np.random.randn(10000), 'o');
791 791 """,
792 792
793 793 r"""
794 794 # use a semicolon to suppress the output
795 795 In [151]: plt.clf()
796 796
797 797 @savefig plot_simple.png width=4in
798 798 In [151]: plot([1,2,3])
799 799
800 800 @savefig hist_simple.png width=4in
801 801 In [151]: hist(np.random.randn(10000), 100);
802 802
803 803 """,
804 804 r"""
805 805 # update the current fig
806 806 In [151]: ylabel('number')
807 807
808 808 In [152]: title('normal distribution')
809 809
810 810
811 811 @savefig hist_with_text.png
812 812 In [153]: grid(True)
813 813
814 814 """,
815 815 ]
816 816 # skip local-file depending first example:
817 817 examples = examples[1:]
818 818
819 819 #ipython_directive.DEBUG = True # dbg
820 820 #options = dict(suppress=True) # dbg
821 821 options = dict()
822 822 for example in examples:
823 823 content = example.split('\n')
824 824 IPythonDirective('debug', arguments=None, options=options,
825 825 content=content, lineno=0,
826 826 content_offset=None, block_text=None,
827 827 state=None, state_machine=None,
828 828 )
829 829
830 830 # Run test suite as a script
831 831 if __name__=='__main__':
832 832 if not os.path.isdir('_static'):
833 833 os.mkdir('_static')
834 834 test()
835 835 print('All OK? Check figures in _static/')
@@ -1,492 +1,492 b''
1 1 # -*- coding: utf-8 -*-
2 2 """terminal client to the IPython kernel
3 3
4 4 """
5 5 #-----------------------------------------------------------------------------
6 6 # Copyright (C) 2013 The IPython Development Team
7 7 #
8 8 # Distributed under the terms of the BSD License. The full license is in
9 9 # the file COPYING, distributed as part of this software.
10 10 #-----------------------------------------------------------------------------
11 11
12 12 #-----------------------------------------------------------------------------
13 13 # Imports
14 14 #-----------------------------------------------------------------------------
15 15 from __future__ import print_function
16 16
17 17 import bdb
18 18 import signal
19 19 import os
20 20 import sys
21 21 import time
22 22 import subprocess
23 23 from io import BytesIO
24 24 import base64
25 25
26 26 try:
27 27 from queue import Empty # Py 3
28 28 except ImportError:
29 29 from Queue import Empty # Py 2
30 30
31 31 from IPython.core import page
32 32 from IPython.utils.warn import warn, error
33 33 from IPython.utils import io
34 34 from IPython.utils.py3compat import string_types, input
35 35 from IPython.utils.traitlets import List, Enum, Any, Instance, Unicode, Float
36 36 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
37 37
38 38 from IPython.terminal.interactiveshell import TerminalInteractiveShell
39 39 from IPython.terminal.console.completer import ZMQCompleter
40 40
41 41
42 42 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
43 43 """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
44 44 _executing = False
45 45 _execution_state = Unicode('')
46 46 kernel_timeout = Float(60, config=True,
47 47 help="""Timeout for giving up on a kernel (in seconds).
48 48
49 49 On first connect and restart, the console tests whether the
50 50 kernel is running and responsive by sending kernel_info_requests.
51 51 This sets the timeout in seconds for how long the kernel can take
52 52 before being presumed dead.
53 53 """
54 54 )
55 55
56 56 image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
57 57 config=True, help=
58 58 """
59 59 Handler for image type output. This is useful, for example,
60 60 when connecting to the kernel in which pylab inline backend is
61 61 activated. There are four handlers defined. 'PIL': Use
62 62 Python Imaging Library to popup image; 'stream': Use an
63 63 external program to show the image. Image will be fed into
64 64 the STDIN of the program. You will need to configure
65 65 `stream_image_handler`; 'tempfile': Use an external program to
66 66 show the image. Image will be saved in a temporally file and
67 67 the program is called with the temporally file. You will need
68 68 to configure `tempfile_image_handler`; 'callable': You can set
69 69 any Python callable which is called with the image data. You
70 70 will need to configure `callable_image_handler`.
71 71 """
72 72 )
73 73
74 74 stream_image_handler = List(config=True, help=
75 75 """
76 76 Command to invoke an image viewer program when you are using
77 77 'stream' image handler. This option is a list of string where
78 78 the first element is the command itself and reminders are the
79 79 options for the command. Raw image data is given as STDIN to
80 80 the program.
81 81 """
82 82 )
83 83
84 84 tempfile_image_handler = List(config=True, help=
85 85 """
86 86 Command to invoke an image viewer program when you are using
87 87 'tempfile' image handler. This option is a list of string
88 88 where the first element is the command itself and reminders
89 89 are the options for the command. You can use {file} and
90 90 {format} in the string to represent the location of the
91 91 generated image file and image format.
92 92 """
93 93 )
94 94
95 95 callable_image_handler = Any(config=True, help=
96 96 """
97 97 Callable object called via 'callable' image handler with one
98 98 argument, `data`, which is `msg["content"]["data"]` where
99 99 `msg` is the message from iopub channel. For exmaple, you can
100 100 find base64 encoded PNG data as `data['image/png']`.
101 101 """
102 102 )
103 103
104 104 mime_preference = List(
105 105 default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
106 106 config=True, allow_none=False, help=
107 107 """
108 108 Preferred object representation MIME type in order. First
109 109 matched MIME type will be used.
110 110 """
111 111 )
112 112
113 113 manager = Instance('IPython.kernel.KernelManager')
114 114 client = Instance('IPython.kernel.KernelClient')
115 115 def _client_changed(self, name, old, new):
116 116 self.session_id = new.session.session
117 117 session_id = Unicode()
118 118
119 119 def init_completer(self):
120 120 """Initialize the completion machinery.
121 121
122 122 This creates completion machinery that can be used by client code,
123 123 either interactively in-process (typically triggered by the readline
124 124 library), programatically (such as in test suites) or out-of-prcess
125 125 (typically over the network by remote frontends).
126 126 """
127 127 from IPython.core.completerlib import (module_completer,
128 128 magic_run_completer, cd_completer)
129 129
130 130 self.Completer = ZMQCompleter(self, self.client, config=self.config)
131 131
132 132
133 133 self.set_hook('complete_command', module_completer, str_key = 'import')
134 134 self.set_hook('complete_command', module_completer, str_key = 'from')
135 135 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
136 136 self.set_hook('complete_command', cd_completer, str_key = '%cd')
137 137
138 138 # Only configure readline if we truly are using readline. IPython can
139 139 # do tab-completion over the network, in GUIs, etc, where readline
140 140 # itself may be absent
141 141 if self.has_readline:
142 142 self.set_readline_completer()
143 143
144 144 def run_cell(self, cell, store_history=True):
145 145 """Run a complete IPython cell.
146 146
147 147 Parameters
148 148 ----------
149 149 cell : str
150 150 The code (including IPython code such as %magic functions) to run.
151 151 store_history : bool
152 152 If True, the raw and translated cell will be stored in IPython's
153 153 history. For user code calling back into IPython's machinery, this
154 154 should be set to False.
155 155 """
156 156 if (not cell) or cell.isspace():
157 157 return
158 158
159 159 if cell.strip() == 'exit':
160 160 # explicitly handle 'exit' command
161 161 return self.ask_exit()
162 162
163 163 # flush stale replies, which could have been ignored, due to missed heartbeats
164 164 while self.client.shell_channel.msg_ready():
165 165 self.client.shell_channel.get_msg()
166 166 # shell_channel.execute takes 'hidden', which is the inverse of store_hist
167 167 msg_id = self.client.shell_channel.execute(cell, not store_history)
168 168
169 169 # first thing is wait for any side effects (output, stdin, etc.)
170 170 self._executing = True
171 171 self._execution_state = "busy"
172 172 while self._execution_state != 'idle' and self.client.is_alive():
173 173 try:
174 174 self.handle_stdin_request(msg_id, timeout=0.05)
175 175 except Empty:
176 176 # display intermediate print statements, etc.
177 177 self.handle_iopub(msg_id)
178 178 pass
179 179
180 180 # after all of that is done, wait for the execute reply
181 181 while self.client.is_alive():
182 182 try:
183 183 self.handle_execute_reply(msg_id, timeout=0.05)
184 184 except Empty:
185 185 pass
186 186 else:
187 187 break
188 188 self._executing = False
189 189
190 190 #-----------------
191 191 # message handlers
192 192 #-----------------
193 193
194 194 def handle_execute_reply(self, msg_id, timeout=None):
195 195 msg = self.client.shell_channel.get_msg(block=False, timeout=timeout)
196 196 if msg["parent_header"].get("msg_id", None) == msg_id:
197 197
198 198 self.handle_iopub(msg_id)
199 199
200 200 content = msg["content"]
201 201 status = content['status']
202 202
203 203 if status == 'aborted':
204 204 self.write('Aborted\n')
205 205 return
206 206 elif status == 'ok':
207 207 # print execution payloads as well:
208 208 for item in content["payload"]:
209 209 text = item.get('text', None)
210 210 if text:
211 211 page.page(text)
212 212
213 213 elif status == 'error':
214 214 for frame in content["traceback"]:
215 215 print(frame, file=io.stderr)
216 216
217 217 self.execution_count = int(content["execution_count"] + 1)
218 218
219 219
220 220 def handle_iopub(self, msg_id):
221 221 """ Method to process subscribe channel's messages
222 222
223 223 This method consumes and processes messages on the IOPub channel,
224 224 such as stdout, stderr, pyout and status.
225 225
226 226 It only displays output that is caused by the given msg_id
227 227 """
228 228 while self.client.iopub_channel.msg_ready():
229 229 sub_msg = self.client.iopub_channel.get_msg()
230 230 msg_type = sub_msg['header']['msg_type']
231 231 parent = sub_msg["parent_header"]
232 232 if (not parent) or msg_id == parent['msg_id']:
233 233 if msg_type == 'status':
234 234 state = self._execution_state = sub_msg["content"]["execution_state"]
235 235 # idle messages mean an individual sequence is complete,
236 236 # so break out of consumption to allow other things to take over.
237 237 if state == 'idle':
238 238 break
239 239
240 240 elif msg_type == 'stream':
241 241 if sub_msg["content"]["name"] == "stdout":
242 242 print(sub_msg["content"]["data"], file=io.stdout, end="")
243 243 io.stdout.flush()
244 244 elif sub_msg["content"]["name"] == "stderr" :
245 245 print(sub_msg["content"]["data"], file=io.stderr, end="")
246 246 io.stderr.flush()
247 247
248 248 elif msg_type == 'pyout':
249 249 self.execution_count = int(sub_msg["content"]["execution_count"])
250 250 format_dict = sub_msg["content"]["data"]
251 251 self.handle_rich_data(format_dict)
252 252 # taken from DisplayHook.__call__:
253 253 hook = self.displayhook
254 254 hook.start_displayhook()
255 255 hook.write_output_prompt()
256 256 hook.write_format_data(format_dict)
257 257 hook.log_output(format_dict)
258 258 hook.finish_displayhook()
259 259
260 260 elif msg_type == 'display_data':
261 261 self.handle_rich_data(sub_msg["content"]["data"])
262 262
263 263
264 264 _imagemime = {
265 265 'image/png': 'png',
266 266 'image/jpeg': 'jpeg',
267 267 'image/svg+xml': 'svg',
268 268 }
269 269
270 270 def handle_rich_data(self, data):
271 271 for mime in self.mime_preference:
272 272 if mime in data and mime in self._imagemime:
273 273 self.handle_image(data, mime)
274 274 return
275 275
276 276 def handle_image(self, data, mime):
277 277 handler = getattr(
278 278 self, 'handle_image_{0}'.format(self.image_handler), None)
279 279 if handler:
280 280 handler(data, mime)
281 281
282 282 def handle_image_PIL(self, data, mime):
283 283 if mime not in ('image/png', 'image/jpeg'):
284 284 return
285 285 import PIL.Image
286 286 raw = base64.decodestring(data[mime].encode('ascii'))
287 287 img = PIL.Image.open(BytesIO(raw))
288 288 img.show()
289 289
290 290 def handle_image_stream(self, data, mime):
291 291 raw = base64.decodestring(data[mime].encode('ascii'))
292 292 imageformat = self._imagemime[mime]
293 293 fmt = dict(format=imageformat)
294 294 args = [s.format(**fmt) for s in self.stream_image_handler]
295 295 with open(os.devnull, 'w') as devnull:
296 296 proc = subprocess.Popen(
297 297 args, stdin=subprocess.PIPE,
298 298 stdout=devnull, stderr=devnull)
299 299 proc.communicate(raw)
300 300
301 301 def handle_image_tempfile(self, data, mime):
302 302 raw = base64.decodestring(data[mime].encode('ascii'))
303 303 imageformat = self._imagemime[mime]
304 304 filename = 'tmp.{0}'.format(imageformat)
305 305 with NamedFileInTemporaryDirectory(filename) as f, \
306 306 open(os.devnull, 'w') as devnull:
307 307 f.write(raw)
308 308 f.flush()
309 309 fmt = dict(file=f.name, format=imageformat)
310 310 args = [s.format(**fmt) for s in self.tempfile_image_handler]
311 311 subprocess.call(args, stdout=devnull, stderr=devnull)
312 312
313 313 def handle_image_callable(self, data, mime):
314 314 self.callable_image_handler(data)
315 315
316 316 def handle_stdin_request(self, msg_id, timeout=0.1):
317 317 """ Method to capture raw_input
318 318 """
319 319 msg_rep = self.client.stdin_channel.get_msg(timeout=timeout)
320 320 # in case any iopub came while we were waiting:
321 321 self.handle_iopub(msg_id)
322 322 if msg_id == msg_rep["parent_header"].get("msg_id"):
323 323 # wrap SIGINT handler
324 324 real_handler = signal.getsignal(signal.SIGINT)
325 325 def double_int(sig,frame):
326 326 # call real handler (forwards sigint to kernel),
327 327 # then raise local interrupt, stopping local raw_input
328 328 real_handler(sig,frame)
329 329 raise KeyboardInterrupt
330 330 signal.signal(signal.SIGINT, double_int)
331 331
332 332 try:
333 333 raw_data = input(msg_rep["content"]["prompt"])
334 334 except EOFError:
335 335 # turn EOFError into EOF character
336 336 raw_data = '\x04'
337 337 except KeyboardInterrupt:
338 338 sys.stdout.write('\n')
339 339 return
340 340 finally:
341 341 # restore SIGINT handler
342 342 signal.signal(signal.SIGINT, real_handler)
343 343
344 344 # only send stdin reply if there *was not* another request
345 345 # or execution finished while we were reading.
346 346 if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
347 347 self.client.stdin_channel.input(raw_data)
348 348
349 349 def mainloop(self, display_banner=False):
350 350 while True:
351 351 try:
352 352 self.interact(display_banner=display_banner)
353 353 #self.interact_with_readline()
354 354 # XXX for testing of a readline-decoupled repl loop, call
355 355 # interact_with_readline above
356 356 break
357 357 except KeyboardInterrupt:
358 358 # this should not be necessary, but KeyboardInterrupt
359 359 # handling seems rather unpredictable...
360 360 self.write("\nKeyboardInterrupt in interact()\n")
361 361
362 362 def wait_for_kernel(self, timeout=None):
363 363 """method to wait for a kernel to be ready"""
364 364 tic = time.time()
365 365 self.client.hb_channel.unpause()
366 366 while True:
367 367 msg_id = self.client.kernel_info()
368 368 reply = None
369 369 while True:
370 370 try:
371 371 reply = self.client.get_shell_msg(timeout=1)
372 372 except Empty:
373 373 break
374 374 else:
375 375 if reply['parent_header'].get('msg_id') == msg_id:
376 376 return True
377 377 if timeout is not None \
378 378 and (time.time() - tic) > timeout \
379 379 and not self.client.hb_channel.is_beating():
380 380 # heart failed
381 381 return False
382 382 return True
383 383
384 384 def interact(self, display_banner=None):
385 385 """Closely emulate the interactive Python console."""
386 386
387 387 # batch run -> do not interact
388 388 if self.exit_now:
389 389 return
390 390
391 391 if display_banner is None:
392 392 display_banner = self.display_banner
393 393
394 394 if isinstance(display_banner, string_types):
395 395 self.show_banner(display_banner)
396 396 elif display_banner:
397 397 self.show_banner()
398 398
399 399 more = False
400 400
401 401 # run a non-empty no-op, so that we don't get a prompt until
402 402 # we know the kernel is ready. This keeps the connection
403 403 # message above the first prompt.
404 404 if not self.wait_for_kernel(self.kernel_timeout):
405 405 error("Kernel did not respond\n")
406 406 return
407 407
408 408 if self.has_readline:
409 409 self.readline_startup_hook(self.pre_readline)
410 410 hlen_b4_cell = self.readline.get_current_history_length()
411 411 else:
412 412 hlen_b4_cell = 0
413 413 # exit_now is set by a call to %Exit or %Quit, through the
414 414 # ask_exit callback.
415 415
416 416 while not self.exit_now:
417 417 if not self.client.is_alive():
418 418 # kernel died, prompt for action or exit
419 419
420 420 action = "restart" if self.manager else "wait for restart"
421 421 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
422 422 if ans:
423 423 if self.manager:
424 424 self.manager.restart_kernel(True)
425 425 self.wait_for_kernel(self.kernel_timeout)
426 426 else:
427 427 self.exit_now = True
428 428 continue
429 429 try:
430 430 # protect prompt block from KeyboardInterrupt
431 431 # when sitting on ctrl-C
432 432 self.hooks.pre_prompt_hook()
433 433 if more:
434 434 try:
435 435 prompt = self.prompt_manager.render('in2')
436 436 except Exception:
437 437 self.showtraceback()
438 438 if self.autoindent:
439 439 self.rl_do_indent = True
440 440
441 441 else:
442 442 try:
443 443 prompt = self.separate_in + self.prompt_manager.render('in')
444 444 except Exception:
445 445 self.showtraceback()
446 446
447 447 line = self.raw_input(prompt)
448 448 if self.exit_now:
449 449 # quick exit on sys.std[in|out] close
450 450 break
451 451 if self.autoindent:
452 452 self.rl_do_indent = False
453 453
454 454 except KeyboardInterrupt:
455 455 #double-guard against keyboardinterrupts during kbdint handling
456 456 try:
457 457 self.write('\nKeyboardInterrupt\n')
458 source_raw = self.input_splitter.source_raw_reset()[1]
458 source_raw = self.input_splitter.raw_reset()
459 459 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
460 460 more = False
461 461 except KeyboardInterrupt:
462 462 pass
463 463 except EOFError:
464 464 if self.autoindent:
465 465 self.rl_do_indent = False
466 466 if self.has_readline:
467 467 self.readline_startup_hook(None)
468 468 self.write('\n')
469 469 self.exit()
470 470 except bdb.BdbQuit:
471 471 warn('The Python debugger has exited with a BdbQuit exception.\n'
472 472 'Because of how pdb handles the stack, it is impossible\n'
473 473 'for IPython to properly format this particular exception.\n'
474 474 'IPython will resume normal operation.')
475 475 except:
476 476 # exceptions here are VERY RARE, but they can be triggered
477 477 # asynchronously by signal handlers, for example.
478 478 self.showtraceback()
479 479 else:
480 480 self.input_splitter.push(line)
481 481 more = self.input_splitter.push_accepts_more()
482 482 if (self.SyntaxTB.last_syntax_error and
483 483 self.autoedit_syntax):
484 484 self.edit_syntax_error()
485 485 if not more:
486 source_raw = self.input_splitter.source_raw_reset()[1]
486 source_raw = self.input_splitter.raw_reset()
487 487 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
488 488 self.run_cell(source_raw)
489 489
490 490
491 491 # Turn off the exit flag, so the mainloop can be restarted if desired
492 492 self.exit_now = False
@@ -1,698 +1,698 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Subclass of InteractiveShell for terminal based frontends."""
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 # Imports
15 15 #-----------------------------------------------------------------------------
16 16 from __future__ import print_function
17 17
18 18 import bdb
19 19 import os
20 20 import sys
21 21
22 22 from IPython.core.error import TryNext, UsageError
23 23 from IPython.core.usage import interactive_usage, default_banner
24 24 from IPython.core.inputsplitter import IPythonInputSplitter
25 25 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
26 26 from IPython.core.magic import Magics, magics_class, line_magic
27 27 from IPython.lib.clipboard import ClipboardEmpty
28 28 from IPython.testing.skipdoctest import skip_doctest
29 29 from IPython.utils.encoding import get_stream_enc
30 30 from IPython.utils import py3compat
31 31 from IPython.utils.terminal import toggle_set_term_title, set_term_title
32 32 from IPython.utils.process import abbrev_cwd
33 33 from IPython.utils.warn import warn, error
34 34 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
35 35 from IPython.utils.traitlets import Integer, CBool, Unicode
36 36
37 37 #-----------------------------------------------------------------------------
38 38 # Utilities
39 39 #-----------------------------------------------------------------------------
40 40
41 41 def get_default_editor():
42 42 try:
43 43 ed = os.environ['EDITOR']
44 44 except KeyError:
45 45 if os.name == 'posix':
46 46 ed = 'vi' # the only one guaranteed to be there!
47 47 else:
48 48 ed = 'notepad' # same in Windows!
49 49 return ed
50 50
51 51
52 52 def get_pasted_lines(sentinel, l_input=py3compat.input):
53 53 """ Yield pasted lines until the user enters the given sentinel value.
54 54 """
55 55 print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
56 56 % sentinel)
57 57 while True:
58 58 try:
59 59 l = l_input(':')
60 60 if l == sentinel:
61 61 return
62 62 else:
63 63 yield l
64 64 except EOFError:
65 65 print('<EOF>')
66 66 return
67 67
68 68
69 69 #------------------------------------------------------------------------
70 70 # Terminal-specific magics
71 71 #------------------------------------------------------------------------
72 72
73 73 @magics_class
74 74 class TerminalMagics(Magics):
75 75 def __init__(self, shell):
76 76 super(TerminalMagics, self).__init__(shell)
77 77 self.input_splitter = IPythonInputSplitter()
78 78
79 79 def store_or_execute(self, block, name):
80 80 """ Execute a block, or store it in a variable, per the user's request.
81 81 """
82 82 if name:
83 83 # If storing it for further editing
84 84 self.shell.user_ns[name] = SList(block.splitlines())
85 85 print("Block assigned to '%s'" % name)
86 86 else:
87 87 b = self.preclean_input(block)
88 88 self.shell.user_ns['pasted_block'] = b
89 89 self.shell.using_paste_magics = True
90 90 try:
91 91 self.shell.run_cell(b)
92 92 finally:
93 93 self.shell.using_paste_magics = False
94 94
95 95 def preclean_input(self, block):
96 96 lines = block.splitlines()
97 97 while lines and not lines[0].strip():
98 98 lines = lines[1:]
99 99 return strip_email_quotes('\n'.join(lines))
100 100
101 101 def rerun_pasted(self, name='pasted_block'):
102 102 """ Rerun a previously pasted command.
103 103 """
104 104 b = self.shell.user_ns.get(name)
105 105
106 106 # Sanity checks
107 107 if b is None:
108 108 raise UsageError('No previous pasted block available')
109 109 if not isinstance(b, py3compat.string_types):
110 110 raise UsageError(
111 111 "Variable 'pasted_block' is not a string, can't execute")
112 112
113 113 print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
114 114 self.shell.run_cell(b)
115 115
116 116 @line_magic
117 117 def autoindent(self, parameter_s = ''):
118 118 """Toggle autoindent on/off (if available)."""
119 119
120 120 self.shell.set_autoindent()
121 121 print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
122 122
123 123 @skip_doctest
124 124 @line_magic
125 125 def cpaste(self, parameter_s=''):
126 126 """Paste & execute a pre-formatted code block from clipboard.
127 127
128 128 You must terminate the block with '--' (two minus-signs) or Ctrl-D
129 129 alone on the line. You can also provide your own sentinel with '%paste
130 130 -s %%' ('%%' is the new sentinel for this operation)
131 131
132 132 The block is dedented prior to execution to enable execution of method
133 133 definitions. '>' and '+' characters at the beginning of a line are
134 134 ignored, to allow pasting directly from e-mails, diff files and
135 135 doctests (the '...' continuation prompt is also stripped). The
136 136 executed block is also assigned to variable named 'pasted_block' for
137 137 later editing with '%edit pasted_block'.
138 138
139 139 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
140 140 This assigns the pasted block to variable 'foo' as string, without
141 141 dedenting or executing it (preceding >>> and + is still stripped)
142 142
143 143 '%cpaste -r' re-executes the block previously entered by cpaste.
144 144
145 145 Do not be alarmed by garbled output on Windows (it's a readline bug).
146 146 Just press enter and type -- (and press enter again) and the block
147 147 will be what was just pasted.
148 148
149 149 IPython statements (magics, shell escapes) are not supported (yet).
150 150
151 151 See also
152 152 --------
153 153 paste: automatically pull code from clipboard.
154 154
155 155 Examples
156 156 --------
157 157 ::
158 158
159 159 In [8]: %cpaste
160 160 Pasting code; enter '--' alone on the line to stop.
161 161 :>>> a = ["world!", "Hello"]
162 162 :>>> print " ".join(sorted(a))
163 163 :--
164 164 Hello world!
165 165 """
166 166 opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
167 167 if 'r' in opts:
168 168 self.rerun_pasted()
169 169 return
170 170
171 171 sentinel = opts.get('s', '--')
172 172 block = '\n'.join(get_pasted_lines(sentinel))
173 173 self.store_or_execute(block, name)
174 174
175 175 @line_magic
176 176 def paste(self, parameter_s=''):
177 177 """Paste & execute a pre-formatted code block from clipboard.
178 178
179 179 The text is pulled directly from the clipboard without user
180 180 intervention and printed back on the screen before execution (unless
181 181 the -q flag is given to force quiet mode).
182 182
183 183 The block is dedented prior to execution to enable execution of method
184 184 definitions. '>' and '+' characters at the beginning of a line are
185 185 ignored, to allow pasting directly from e-mails, diff files and
186 186 doctests (the '...' continuation prompt is also stripped). The
187 187 executed block is also assigned to variable named 'pasted_block' for
188 188 later editing with '%edit pasted_block'.
189 189
190 190 You can also pass a variable name as an argument, e.g. '%paste foo'.
191 191 This assigns the pasted block to variable 'foo' as string, without
192 192 executing it (preceding >>> and + is still stripped).
193 193
194 194 Options
195 195 -------
196 196
197 197 -r: re-executes the block previously entered by cpaste.
198 198
199 199 -q: quiet mode: do not echo the pasted text back to the terminal.
200 200
201 201 IPython statements (magics, shell escapes) are not supported (yet).
202 202
203 203 See also
204 204 --------
205 205 cpaste: manually paste code into terminal until you mark its end.
206 206 """
207 207 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
208 208 if 'r' in opts:
209 209 self.rerun_pasted()
210 210 return
211 211 try:
212 212 block = self.shell.hooks.clipboard_get()
213 213 except TryNext as clipboard_exc:
214 214 message = getattr(clipboard_exc, 'args')
215 215 if message:
216 216 error(message[0])
217 217 else:
218 218 error('Could not get text from the clipboard.')
219 219 return
220 220 except ClipboardEmpty:
221 221 raise UsageError("The clipboard appears to be empty")
222 222
223 223 # By default, echo back to terminal unless quiet mode is requested
224 224 if 'q' not in opts:
225 225 write = self.shell.write
226 226 write(self.shell.pycolorize(block))
227 227 if not block.endswith('\n'):
228 228 write('\n')
229 229 write("## -- End pasted text --\n")
230 230
231 231 self.store_or_execute(block, name)
232 232
233 233 # Class-level: add a '%cls' magic only on Windows
234 234 if sys.platform == 'win32':
235 235 @line_magic
236 236 def cls(self, s):
237 237 """Clear screen.
238 238 """
239 239 os.system("cls")
240 240
241 241 #-----------------------------------------------------------------------------
242 242 # Main class
243 243 #-----------------------------------------------------------------------------
244 244
245 245 class TerminalInteractiveShell(InteractiveShell):
246 246
247 247 autoedit_syntax = CBool(False, config=True,
248 248 help="auto editing of files with syntax errors.")
249 249 banner = Unicode('')
250 250 banner1 = Unicode(default_banner, config=True,
251 251 help="""The part of the banner to be printed before the profile"""
252 252 )
253 253 banner2 = Unicode('', config=True,
254 254 help="""The part of the banner to be printed after the profile"""
255 255 )
256 256 confirm_exit = CBool(True, config=True,
257 257 help="""
258 258 Set to confirm when you try to exit IPython with an EOF (Control-D
259 259 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
260 260 you can force a direct exit without any confirmation.""",
261 261 )
262 262 # This display_banner only controls whether or not self.show_banner()
263 263 # is called when mainloop/interact are called. The default is False
264 264 # because for the terminal based application, the banner behavior
265 265 # is controlled by Global.display_banner, which IPythonApp looks at
266 266 # to determine if *it* should call show_banner() by hand or not.
267 267 display_banner = CBool(False) # This isn't configurable!
268 268 embedded = CBool(False)
269 269 embedded_active = CBool(False)
270 270 editor = Unicode(get_default_editor(), config=True,
271 271 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
272 272 )
273 273 pager = Unicode('less', config=True,
274 274 help="The shell program to be used for paging.")
275 275
276 276 screen_length = Integer(0, config=True,
277 277 help=
278 278 """Number of lines of your screen, used to control printing of very
279 279 long strings. Strings longer than this number of lines will be sent
280 280 through a pager instead of directly printed. The default value for
281 281 this is 0, which means IPython will auto-detect your screen size every
282 282 time it needs to print certain potentially long strings (this doesn't
283 283 change the behavior of the 'print' keyword, it's only triggered
284 284 internally). If for some reason this isn't working well (it needs
285 285 curses support), specify it yourself. Otherwise don't change the
286 286 default.""",
287 287 )
288 288 term_title = CBool(False, config=True,
289 289 help="Enable auto setting the terminal title."
290 290 )
291 291
292 292 # This `using_paste_magics` is used to detect whether the code is being
293 293 # executed via paste magics functions
294 294 using_paste_magics = CBool(False)
295 295
296 296 # In the terminal, GUI control is done via PyOS_InputHook
297 297 @staticmethod
298 298 def enable_gui(gui=None, app=None):
299 299 """Switch amongst GUI input hooks by name.
300 300 """
301 301 # Deferred import
302 302 from IPython.lib.inputhook import enable_gui as real_enable_gui
303 303 try:
304 304 return real_enable_gui(gui, app)
305 305 except ValueError as e:
306 306 raise UsageError("%s" % e)
307 307
308 308 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
309 309 user_ns=None, user_module=None, custom_exceptions=((),None),
310 310 usage=None, banner1=None, banner2=None, display_banner=None,
311 311 **kwargs):
312 312
313 313 super(TerminalInteractiveShell, self).__init__(
314 314 config=config, ipython_dir=ipython_dir, profile_dir=profile_dir, user_ns=user_ns,
315 315 user_module=user_module, custom_exceptions=custom_exceptions,
316 316 **kwargs
317 317 )
318 318 # use os.system instead of utils.process.system by default,
319 319 # because piped system doesn't make sense in the Terminal:
320 320 self.system = self.system_raw
321 321
322 322 self.init_term_title()
323 323 self.init_usage(usage)
324 324 self.init_banner(banner1, banner2, display_banner)
325 325
326 326 #-------------------------------------------------------------------------
327 327 # Overrides of init stages
328 328 #-------------------------------------------------------------------------
329 329
330 330 def init_display_formatter(self):
331 331 super(TerminalInteractiveShell, self).init_display_formatter()
332 332 # terminal only supports plaintext
333 333 self.display_formatter.active_types = ['text/plain']
334 334
335 335 #-------------------------------------------------------------------------
336 336 # Things related to the terminal
337 337 #-------------------------------------------------------------------------
338 338
339 339 @property
340 340 def usable_screen_length(self):
341 341 if self.screen_length == 0:
342 342 return 0
343 343 else:
344 344 num_lines_bot = self.separate_in.count('\n')+1
345 345 return self.screen_length - num_lines_bot
346 346
347 347 def init_term_title(self):
348 348 # Enable or disable the terminal title.
349 349 if self.term_title:
350 350 toggle_set_term_title(True)
351 351 set_term_title('IPython: ' + abbrev_cwd())
352 352 else:
353 353 toggle_set_term_title(False)
354 354
355 355 #-------------------------------------------------------------------------
356 356 # Things related to aliases
357 357 #-------------------------------------------------------------------------
358 358
359 359 def init_alias(self):
360 360 # The parent class defines aliases that can be safely used with any
361 361 # frontend.
362 362 super(TerminalInteractiveShell, self).init_alias()
363 363
364 364 # Now define aliases that only make sense on the terminal, because they
365 365 # need direct access to the console in a way that we can't emulate in
366 366 # GUI or web frontend
367 367 if os.name == 'posix':
368 368 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
369 369 ('man', 'man')]
370 370 elif os.name == 'nt':
371 371 aliases = [('cls', 'cls')]
372 372
373 373
374 374 for name, cmd in aliases:
375 375 self.alias_manager.soft_define_alias(name, cmd)
376 376
377 377 #-------------------------------------------------------------------------
378 378 # Things related to the banner and usage
379 379 #-------------------------------------------------------------------------
380 380
381 381 def _banner1_changed(self):
382 382 self.compute_banner()
383 383
384 384 def _banner2_changed(self):
385 385 self.compute_banner()
386 386
387 387 def _term_title_changed(self, name, new_value):
388 388 self.init_term_title()
389 389
390 390 def init_banner(self, banner1, banner2, display_banner):
391 391 if banner1 is not None:
392 392 self.banner1 = banner1
393 393 if banner2 is not None:
394 394 self.banner2 = banner2
395 395 if display_banner is not None:
396 396 self.display_banner = display_banner
397 397 self.compute_banner()
398 398
399 399 def show_banner(self, banner=None):
400 400 if banner is None:
401 401 banner = self.banner
402 402 self.write(banner)
403 403
404 404 def compute_banner(self):
405 405 self.banner = self.banner1
406 406 if self.profile and self.profile != 'default':
407 407 self.banner += '\nIPython profile: %s\n' % self.profile
408 408 if self.banner2:
409 409 self.banner += '\n' + self.banner2
410 410
411 411 def init_usage(self, usage=None):
412 412 if usage is None:
413 413 self.usage = interactive_usage
414 414 else:
415 415 self.usage = usage
416 416
417 417 #-------------------------------------------------------------------------
418 418 # Mainloop and code execution logic
419 419 #-------------------------------------------------------------------------
420 420
421 421 def mainloop(self, display_banner=None):
422 422 """Start the mainloop.
423 423
424 424 If an optional banner argument is given, it will override the
425 425 internally created default banner.
426 426 """
427 427
428 428 with self.builtin_trap, self.display_trap:
429 429
430 430 while 1:
431 431 try:
432 432 self.interact(display_banner=display_banner)
433 433 #self.interact_with_readline()
434 434 # XXX for testing of a readline-decoupled repl loop, call
435 435 # interact_with_readline above
436 436 break
437 437 except KeyboardInterrupt:
438 438 # this should not be necessary, but KeyboardInterrupt
439 439 # handling seems rather unpredictable...
440 440 self.write("\nKeyboardInterrupt in interact()\n")
441 441
442 442 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
443 443 """Store multiple lines as a single entry in history"""
444 444
445 445 # do nothing without readline or disabled multiline
446 446 if not self.has_readline or not self.multiline_history:
447 447 return hlen_before_cell
448 448
449 449 # windows rl has no remove_history_item
450 450 if not hasattr(self.readline, "remove_history_item"):
451 451 return hlen_before_cell
452 452
453 453 # skip empty cells
454 454 if not source_raw.rstrip():
455 455 return hlen_before_cell
456 456
457 457 # nothing changed do nothing, e.g. when rl removes consecutive dups
458 458 hlen = self.readline.get_current_history_length()
459 459 if hlen == hlen_before_cell:
460 460 return hlen_before_cell
461 461
462 462 for i in range(hlen - hlen_before_cell):
463 463 self.readline.remove_history_item(hlen - i - 1)
464 464 stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
465 465 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
466 466 stdin_encoding))
467 467 return self.readline.get_current_history_length()
468 468
469 469 def interact(self, display_banner=None):
470 470 """Closely emulate the interactive Python console."""
471 471
472 472 # batch run -> do not interact
473 473 if self.exit_now:
474 474 return
475 475
476 476 if display_banner is None:
477 477 display_banner = self.display_banner
478 478
479 479 if isinstance(display_banner, py3compat.string_types):
480 480 self.show_banner(display_banner)
481 481 elif display_banner:
482 482 self.show_banner()
483 483
484 484 more = False
485 485
486 486 if self.has_readline:
487 487 self.readline_startup_hook(self.pre_readline)
488 488 hlen_b4_cell = self.readline.get_current_history_length()
489 489 else:
490 490 hlen_b4_cell = 0
491 491 # exit_now is set by a call to %Exit or %Quit, through the
492 492 # ask_exit callback.
493 493
494 494 while not self.exit_now:
495 495 self.hooks.pre_prompt_hook()
496 496 if more:
497 497 try:
498 498 prompt = self.prompt_manager.render('in2')
499 499 except:
500 500 self.showtraceback()
501 501 if self.autoindent:
502 502 self.rl_do_indent = True
503 503
504 504 else:
505 505 try:
506 506 prompt = self.separate_in + self.prompt_manager.render('in')
507 507 except:
508 508 self.showtraceback()
509 509 try:
510 510 line = self.raw_input(prompt)
511 511 if self.exit_now:
512 512 # quick exit on sys.std[in|out] close
513 513 break
514 514 if self.autoindent:
515 515 self.rl_do_indent = False
516 516
517 517 except KeyboardInterrupt:
518 518 #double-guard against keyboardinterrupts during kbdint handling
519 519 try:
520 520 self.write('\nKeyboardInterrupt\n')
521 source_raw = self.input_splitter.source_raw_reset()[1]
521 source_raw = self.input_splitter.raw_reset()
522 522 hlen_b4_cell = \
523 523 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
524 524 more = False
525 525 except KeyboardInterrupt:
526 526 pass
527 527 except EOFError:
528 528 if self.autoindent:
529 529 self.rl_do_indent = False
530 530 if self.has_readline:
531 531 self.readline_startup_hook(None)
532 532 self.write('\n')
533 533 self.exit()
534 534 except bdb.BdbQuit:
535 535 warn('The Python debugger has exited with a BdbQuit exception.\n'
536 536 'Because of how pdb handles the stack, it is impossible\n'
537 537 'for IPython to properly format this particular exception.\n'
538 538 'IPython will resume normal operation.')
539 539 except:
540 540 # exceptions here are VERY RARE, but they can be triggered
541 541 # asynchronously by signal handlers, for example.
542 542 self.showtraceback()
543 543 else:
544 544 try:
545 545 self.input_splitter.push(line)
546 546 more = self.input_splitter.push_accepts_more()
547 547 except SyntaxError:
548 548 # Run the code directly - run_cell takes care of displaying
549 549 # the exception.
550 550 more = False
551 551 if (self.SyntaxTB.last_syntax_error and
552 552 self.autoedit_syntax):
553 553 self.edit_syntax_error()
554 554 if not more:
555 source_raw = self.input_splitter.source_raw_reset()[1]
555 source_raw = self.input_splitter.raw_reset()
556 556 self.run_cell(source_raw, store_history=True)
557 557 hlen_b4_cell = \
558 558 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
559 559
560 560 # Turn off the exit flag, so the mainloop can be restarted if desired
561 561 self.exit_now = False
562 562
563 563 def raw_input(self, prompt=''):
564 564 """Write a prompt and read a line.
565 565
566 566 The returned line does not include the trailing newline.
567 567 When the user enters the EOF key sequence, EOFError is raised.
568 568
569 569 Optional inputs:
570 570
571 571 - prompt(''): a string to be printed to prompt the user.
572 572
573 573 - continue_prompt(False): whether this line is the first one or a
574 574 continuation in a sequence of inputs.
575 575 """
576 576 # Code run by the user may have modified the readline completer state.
577 577 # We must ensure that our completer is back in place.
578 578
579 579 if self.has_readline:
580 580 self.set_readline_completer()
581 581
582 582 # raw_input expects str, but we pass it unicode sometimes
583 583 prompt = py3compat.cast_bytes_py2(prompt)
584 584
585 585 try:
586 586 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
587 587 except ValueError:
588 588 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
589 589 " or sys.stdout.close()!\nExiting IPython!\n")
590 590 self.ask_exit()
591 591 return ""
592 592
593 593 # Try to be reasonably smart about not re-indenting pasted input more
594 594 # than necessary. We do this by trimming out the auto-indent initial
595 595 # spaces, if the user's actual input started itself with whitespace.
596 596 if self.autoindent:
597 597 if num_ini_spaces(line) > self.indent_current_nsp:
598 598 line = line[self.indent_current_nsp:]
599 599 self.indent_current_nsp = 0
600 600
601 601 return line
602 602
603 603 #-------------------------------------------------------------------------
604 604 # Methods to support auto-editing of SyntaxErrors.
605 605 #-------------------------------------------------------------------------
606 606
607 607 def edit_syntax_error(self):
608 608 """The bottom half of the syntax error handler called in the main loop.
609 609
610 610 Loop until syntax error is fixed or user cancels.
611 611 """
612 612
613 613 while self.SyntaxTB.last_syntax_error:
614 614 # copy and clear last_syntax_error
615 615 err = self.SyntaxTB.clear_err_state()
616 616 if not self._should_recompile(err):
617 617 return
618 618 try:
619 619 # may set last_syntax_error again if a SyntaxError is raised
620 620 self.safe_execfile(err.filename,self.user_ns)
621 621 except:
622 622 self.showtraceback()
623 623 else:
624 624 try:
625 625 f = open(err.filename)
626 626 try:
627 627 # This should be inside a display_trap block and I
628 628 # think it is.
629 629 sys.displayhook(f.read())
630 630 finally:
631 631 f.close()
632 632 except:
633 633 self.showtraceback()
634 634
635 635 def _should_recompile(self,e):
636 636 """Utility routine for edit_syntax_error"""
637 637
638 638 if e.filename in ('<ipython console>','<input>','<string>',
639 639 '<console>','<BackgroundJob compilation>',
640 640 None):
641 641
642 642 return False
643 643 try:
644 644 if (self.autoedit_syntax and
645 645 not self.ask_yes_no('Return to editor to correct syntax error? '
646 646 '[Y/n] ','y')):
647 647 return False
648 648 except EOFError:
649 649 return False
650 650
651 651 def int0(x):
652 652 try:
653 653 return int(x)
654 654 except TypeError:
655 655 return 0
656 656 # always pass integer line and offset values to editor hook
657 657 try:
658 658 self.hooks.fix_error_editor(e.filename,
659 659 int0(e.lineno),int0(e.offset),e.msg)
660 660 except TryNext:
661 661 warn('Could not open editor')
662 662 return False
663 663 return True
664 664
665 665 #-------------------------------------------------------------------------
666 666 # Things related to exiting
667 667 #-------------------------------------------------------------------------
668 668
669 669 def ask_exit(self):
670 670 """ Ask the shell to exit. Can be overiden and used as a callback. """
671 671 self.exit_now = True
672 672
673 673 def exit(self):
674 674 """Handle interactive exit.
675 675
676 676 This method calls the ask_exit callback."""
677 677 if self.confirm_exit:
678 678 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
679 679 self.ask_exit()
680 680 else:
681 681 self.ask_exit()
682 682
683 683 #-------------------------------------------------------------------------
684 684 # Things related to magics
685 685 #-------------------------------------------------------------------------
686 686
687 687 def init_magics(self):
688 688 super(TerminalInteractiveShell, self).init_magics()
689 689 self.register_magics(TerminalMagics)
690 690
691 691 def showindentationerror(self):
692 692 super(TerminalInteractiveShell, self).showindentationerror()
693 693 if not self.using_paste_magics:
694 694 print("If you want to paste code into IPython, try the "
695 695 "%paste and %cpaste magic functions.")
696 696
697 697
698 698 InteractiveShellABC.register(TerminalInteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now