##// END OF EJS Templates
Remove next_input nonsense in magic calls (but keep functionality).
Fernando Perez -
Show More
@@ -1,767 +1,771 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-2011 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 from __future__ import print_function
64 64
65 65 #-----------------------------------------------------------------------------
66 66 # Imports
67 67 #-----------------------------------------------------------------------------
68 68 # stdlib
69 69 import ast
70 70 import codeop
71 71 import re
72 72 import sys
73 73 import tokenize
74 74 from StringIO import StringIO
75 75
76 76 # IPython modules
77 77 from IPython.core.splitinput import split_user_input, LineInfo
78 78 from IPython.utils.py3compat import cast_unicode
79 79
80 80 #-----------------------------------------------------------------------------
81 81 # Globals
82 82 #-----------------------------------------------------------------------------
83 83
84 84 # The escape sequences that define the syntax transformations IPython will
85 85 # apply to user input. These can NOT be just changed here: many regular
86 86 # expressions and other parts of the code may use their hardcoded values, and
87 87 # for all intents and purposes they constitute the 'IPython syntax', so they
88 88 # should be considered fixed.
89 89
90 90 ESC_SHELL = '!' # Send line to underlying system shell
91 91 ESC_SH_CAP = '!!' # Send line to system shell and capture output
92 92 ESC_HELP = '?' # Find information about object
93 93 ESC_HELP2 = '??' # Find extra-detailed information about object
94 94 ESC_MAGIC = '%' # Call magic function
95 95 ESC_QUOTE = ',' # Split args on whitespace, quote each as string and call
96 96 ESC_QUOTE2 = ';' # Quote all args as a single string, call
97 97 ESC_PAREN = '/' # Call first argument with rest of line as arguments
98 98
99 99 #-----------------------------------------------------------------------------
100 100 # Utilities
101 101 #-----------------------------------------------------------------------------
102 102
103 103 # FIXME: These are general-purpose utilities that later can be moved to the
104 104 # general ward. Kept here for now because we're being very strict about test
105 105 # coverage with this code, and this lets us ensure that we keep 100% coverage
106 106 # while developing.
107 107
108 108 # compiled regexps for autoindent management
109 109 dedent_re = re.compile('|'.join([
110 110 r'^\s+raise(\s.*)?$', # raise statement (+ space + other stuff, maybe)
111 111 r'^\s+raise\([^\)]*\).*$', # wacky raise with immediate open paren
112 112 r'^\s+return(\s.*)?$', # normal return (+ space + other stuff, maybe)
113 113 r'^\s+return\([^\)]*\).*$', # wacky return with immediate open paren
114 114 r'^\s+pass\s*$' # pass (optionally followed by trailing spaces)
115 115 ]))
116 116 ini_spaces_re = re.compile(r'^([ \t\r\f\v]+)')
117 117
118 118 # regexp to match pure comment lines so we don't accidentally insert 'if 1:'
119 119 # before pure comments
120 120 comment_line_re = re.compile('^\s*\#')
121 121
122 122
123 123 def num_ini_spaces(s):
124 124 """Return the number of initial spaces in a string.
125 125
126 126 Note that tabs are counted as a single space. For now, we do *not* support
127 127 mixing of tabs and spaces in the user's input.
128 128
129 129 Parameters
130 130 ----------
131 131 s : string
132 132
133 133 Returns
134 134 -------
135 135 n : int
136 136 """
137 137
138 138 ini_spaces = ini_spaces_re.match(s)
139 139 if ini_spaces:
140 140 return ini_spaces.end()
141 141 else:
142 142 return 0
143 143
144 144
145 145 def remove_comments(src):
146 146 """Remove all comments from input source.
147 147
148 148 Note: comments are NOT recognized inside of strings!
149 149
150 150 Parameters
151 151 ----------
152 152 src : string
153 153 A single or multiline input string.
154 154
155 155 Returns
156 156 -------
157 157 String with all Python comments removed.
158 158 """
159 159
160 160 return re.sub('#.*', '', src)
161 161
162 162 def has_comment(src):
163 163 """Indicate whether an input line has (i.e. ends in, or is) a comment.
164 164
165 165 This uses tokenize, so it can distinguish comments from # inside strings.
166 166
167 167 Parameters
168 168 ----------
169 169 src : string
170 170 A single line input string.
171 171
172 172 Returns
173 173 -------
174 174 Boolean: True if source has a comment.
175 175 """
176 176 readline = StringIO(src).readline
177 177 toktypes = set()
178 178 try:
179 179 for t in tokenize.generate_tokens(readline):
180 180 toktypes.add(t[0])
181 181 except tokenize.TokenError:
182 182 pass
183 183 return(tokenize.COMMENT in toktypes)
184 184
185 185
186 186 def get_input_encoding():
187 187 """Return the default standard input encoding.
188 188
189 189 If sys.stdin has no encoding, 'ascii' is returned."""
190 190 # There are strange environments for which sys.stdin.encoding is None. We
191 191 # ensure that a valid encoding is returned.
192 192 encoding = getattr(sys.stdin, 'encoding', None)
193 193 if encoding is None:
194 194 encoding = 'ascii'
195 195 return encoding
196 196
197 197 #-----------------------------------------------------------------------------
198 198 # Classes and functions for normal Python syntax handling
199 199 #-----------------------------------------------------------------------------
200 200
201 201 class InputSplitter(object):
202 202 """An object that can accumulate lines of Python source before execution.
203 203
204 204 This object is designed to be fed python source line-by-line, using
205 205 :meth:`push`. It will return on each push whether the currently pushed
206 206 code could be executed already. In addition, it provides a method called
207 207 :meth:`push_accepts_more` that can be used to query whether more input
208 208 can be pushed into a single interactive block.
209 209
210 210 This is a simple example of how an interactive terminal-based client can use
211 211 this tool::
212 212
213 213 isp = InputSplitter()
214 214 while isp.push_accepts_more():
215 215 indent = ' '*isp.indent_spaces
216 216 prompt = '>>> ' + indent
217 217 line = indent + raw_input(prompt)
218 218 isp.push(line)
219 219 print 'Input source was:\n', isp.source_reset(),
220 220 """
221 221 # Number of spaces of indentation computed from input that has been pushed
222 222 # so far. This is the attributes callers should query to get the current
223 223 # indentation level, in order to provide auto-indent facilities.
224 224 indent_spaces = 0
225 225 # String, indicating the default input encoding. It is computed by default
226 226 # at initialization time via get_input_encoding(), but it can be reset by a
227 227 # client with specific knowledge of the encoding.
228 228 encoding = ''
229 229 # String where the current full source input is stored, properly encoded.
230 230 # Reading this attribute is the normal way of querying the currently pushed
231 231 # source code, that has been properly encoded.
232 232 source = ''
233 233 # Code object corresponding to the current source. It is automatically
234 234 # synced to the source, so it can be queried at any time to obtain the code
235 235 # object; it will be None if the source doesn't compile to valid Python.
236 236 code = None
237 237 # Input mode
238 238 input_mode = 'line'
239 239
240 240 # Private attributes
241 241
242 242 # List with lines of input accumulated so far
243 243 _buffer = None
244 244 # Command compiler
245 245 _compile = None
246 246 # Mark when input has changed indentation all the way back to flush-left
247 247 _full_dedent = False
248 248 # Boolean indicating whether the current block is complete
249 249 _is_complete = None
250 250
251 251 def __init__(self, input_mode=None):
252 252 """Create a new InputSplitter instance.
253 253
254 254 Parameters
255 255 ----------
256 256 input_mode : str
257 257
258 258 One of ['line', 'cell']; default is 'line'.
259 259
260 260 The input_mode parameter controls how new inputs are used when fed via
261 261 the :meth:`push` method:
262 262
263 263 - 'line': meant for line-oriented clients, inputs are appended one at a
264 264 time to the internal buffer and the whole buffer is compiled.
265 265
266 266 - 'cell': meant for clients that can edit multi-line 'cells' of text at
267 267 a time. A cell can contain one or more blocks that can be compile in
268 268 'single' mode by Python. In this mode, each new input new input
269 269 completely replaces all prior inputs. Cell mode is thus equivalent
270 270 to prepending a full reset() to every push() call.
271 271 """
272 272 self._buffer = []
273 273 self._compile = codeop.CommandCompiler()
274 274 self.encoding = get_input_encoding()
275 275 self.input_mode = InputSplitter.input_mode if input_mode is None \
276 276 else input_mode
277 277
278 278 def reset(self):
279 279 """Reset the input buffer and associated state."""
280 280 self.indent_spaces = 0
281 281 self._buffer[:] = []
282 282 self.source = ''
283 283 self.code = None
284 284 self._is_complete = False
285 285 self._full_dedent = False
286 286
287 287 def source_reset(self):
288 288 """Return the input source and perform a full reset.
289 289 """
290 290 out = self.source
291 291 self.reset()
292 292 return out
293 293
294 294 def push(self, lines):
295 295 """Push one or more lines of input.
296 296
297 297 This stores the given lines and returns a status code indicating
298 298 whether the code forms a complete Python block or not.
299 299
300 300 Any exceptions generated in compilation are swallowed, but if an
301 301 exception was produced, the method returns True.
302 302
303 303 Parameters
304 304 ----------
305 305 lines : string
306 306 One or more lines of Python input.
307 307
308 308 Returns
309 309 -------
310 310 is_complete : boolean
311 311 True if the current input source (the result of the current input
312 312 plus prior inputs) forms a complete Python execution block. Note that
313 313 this value is also stored as a private attribute (_is_complete), so it
314 314 can be queried at any time.
315 315 """
316 316 if self.input_mode == 'cell':
317 317 self.reset()
318 318
319 319 self._store(lines)
320 320 source = self.source
321 321
322 322 # Before calling _compile(), reset the code object to None so that if an
323 323 # exception is raised in compilation, we don't mislead by having
324 324 # inconsistent code/source attributes.
325 325 self.code, self._is_complete = None, None
326 326
327 327 # Honor termination lines properly
328 328 if source.rstrip().endswith('\\'):
329 329 return False
330 330
331 331 self._update_indent(lines)
332 332 try:
333 333 self.code = self._compile(source, symbol="exec")
334 334 # Invalid syntax can produce any of a number of different errors from
335 335 # inside the compiler, so we have to catch them all. Syntax errors
336 336 # immediately produce a 'ready' block, so the invalid Python can be
337 337 # sent to the kernel for evaluation with possible ipython
338 338 # special-syntax conversion.
339 339 except (SyntaxError, OverflowError, ValueError, TypeError,
340 340 MemoryError):
341 341 self._is_complete = True
342 342 else:
343 343 # Compilation didn't produce any exceptions (though it may not have
344 344 # given a complete code object)
345 345 self._is_complete = self.code is not None
346 346
347 347 return self._is_complete
348 348
349 349 def push_accepts_more(self):
350 350 """Return whether a block of interactive input can accept more input.
351 351
352 352 This method is meant to be used by line-oriented frontends, who need to
353 353 guess whether a block is complete or not based solely on prior and
354 354 current input lines. The InputSplitter considers it has a complete
355 355 interactive block and will not accept more input only when either a
356 356 SyntaxError is raised, or *all* of the following are true:
357 357
358 358 1. The input compiles to a complete statement.
359 359
360 360 2. The indentation level is flush-left (because if we are indented,
361 361 like inside a function definition or for loop, we need to keep
362 362 reading new input).
363 363
364 364 3. There is one extra line consisting only of whitespace.
365 365
366 366 Because of condition #3, this method should be used only by
367 367 *line-oriented* frontends, since it means that intermediate blank lines
368 368 are not allowed in function definitions (or any other indented block).
369 369
370 370 If the current input produces a syntax error, this method immediately
371 371 returns False but does *not* raise the syntax error exception, as
372 372 typically clients will want to send invalid syntax to an execution
373 373 backend which might convert the invalid syntax into valid Python via
374 374 one of the dynamic IPython mechanisms.
375 375 """
376 376
377 377 # With incomplete input, unconditionally accept more
378 378 if not self._is_complete:
379 379 return True
380 380
381 381 # If we already have complete input and we're flush left, the answer
382 382 # depends. In line mode, if there hasn't been any indentation,
383 383 # that's it. If we've come back from some indentation, we need
384 384 # the blank final line to finish.
385 385 # In cell mode, we need to check how many blocks the input so far
386 386 # compiles into, because if there's already more than one full
387 387 # independent block of input, then the client has entered full
388 388 # 'cell' mode and is feeding lines that each is complete. In this
389 389 # case we should then keep accepting. The Qt terminal-like console
390 390 # does precisely this, to provide the convenience of terminal-like
391 391 # input of single expressions, but allowing the user (with a
392 392 # separate keystroke) to switch to 'cell' mode and type multiple
393 393 # expressions in one shot.
394 394 if self.indent_spaces==0:
395 395 if self.input_mode=='line':
396 396 if not self._full_dedent:
397 397 return False
398 398 else:
399 399 try:
400 400 code_ast = ast.parse(u''.join(self._buffer))
401 401 except Exception:
402 402 return False
403 403 else:
404 404 if len(code_ast.body) == 1:
405 405 return False
406 406
407 407 # When input is complete, then termination is marked by an extra blank
408 408 # line at the end.
409 409 last_line = self.source.splitlines()[-1]
410 410 return bool(last_line and not last_line.isspace())
411 411
412 412 #------------------------------------------------------------------------
413 413 # Private interface
414 414 #------------------------------------------------------------------------
415 415
416 416 def _find_indent(self, line):
417 417 """Compute the new indentation level for a single line.
418 418
419 419 Parameters
420 420 ----------
421 421 line : str
422 422 A single new line of non-whitespace, non-comment Python input.
423 423
424 424 Returns
425 425 -------
426 426 indent_spaces : int
427 427 New value for the indent level (it may be equal to self.indent_spaces
428 428 if indentation doesn't change.
429 429
430 430 full_dedent : boolean
431 431 Whether the new line causes a full flush-left dedent.
432 432 """
433 433 indent_spaces = self.indent_spaces
434 434 full_dedent = self._full_dedent
435 435
436 436 inisp = num_ini_spaces(line)
437 437 if inisp < indent_spaces:
438 438 indent_spaces = inisp
439 439 if indent_spaces <= 0:
440 440 #print 'Full dedent in text',self.source # dbg
441 441 full_dedent = True
442 442
443 443 if line.rstrip()[-1] == ':':
444 444 indent_spaces += 4
445 445 elif dedent_re.match(line):
446 446 indent_spaces -= 4
447 447 if indent_spaces <= 0:
448 448 full_dedent = True
449 449
450 450 # Safety
451 451 if indent_spaces < 0:
452 452 indent_spaces = 0
453 453 #print 'safety' # dbg
454 454
455 455 return indent_spaces, full_dedent
456 456
457 457 def _update_indent(self, lines):
458 458 for line in remove_comments(lines).splitlines():
459 459 if line and not line.isspace():
460 460 self.indent_spaces, self._full_dedent = self._find_indent(line)
461 461
462 462 def _store(self, lines, buffer=None, store='source'):
463 463 """Store one or more lines of input.
464 464
465 465 If input lines are not newline-terminated, a newline is automatically
466 466 appended."""
467 467
468 468 if buffer is None:
469 469 buffer = self._buffer
470 470
471 471 if lines.endswith('\n'):
472 472 buffer.append(lines)
473 473 else:
474 474 buffer.append(lines+'\n')
475 475 setattr(self, store, self._set_source(buffer))
476 476
477 477 def _set_source(self, buffer):
478 478 return u''.join(buffer)
479 479
480 480
481 481 #-----------------------------------------------------------------------------
482 482 # Functions and classes for IPython-specific syntactic support
483 483 #-----------------------------------------------------------------------------
484 484
485 485 # The escaped translators ALL receive a line where their own escape has been
486 486 # stripped. Only '?' is valid at the end of the line, all others can only be
487 487 # placed at the start.
488 488
489 489 # Transformations of the special syntaxes that don't rely on an explicit escape
490 490 # character but instead on patterns on the input line
491 491
492 492 # The core transformations are implemented as standalone functions that can be
493 493 # tested and validated in isolation. Each of these uses a regexp, we
494 494 # pre-compile these and keep them close to each function definition for clarity
495 495
496 496 _assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
497 497 r'\s*=\s*!\s*(?P<cmd>.*)')
498 498
499 499 def transform_assign_system(line):
500 500 """Handle the `files = !ls` syntax."""
501 501 m = _assign_system_re.match(line)
502 502 if m is not None:
503 503 cmd = m.group('cmd')
504 504 lhs = m.group('lhs')
505 505 new_line = '%s = get_ipython().getoutput(%r)' % (lhs, cmd)
506 506 return new_line
507 507 return line
508 508
509 509
510 510 _assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
511 511 r'\s*=\s*%\s*(?P<cmd>.*)')
512 512
513 513 def transform_assign_magic(line):
514 514 """Handle the `a = %who` syntax."""
515 515 m = _assign_magic_re.match(line)
516 516 if m is not None:
517 517 cmd = m.group('cmd')
518 518 lhs = m.group('lhs')
519 519 new_line = '%s = get_ipython().magic(%r)' % (lhs, cmd)
520 520 return new_line
521 521 return line
522 522
523 523
524 524 _classic_prompt_re = re.compile(r'^([ \t]*>>> |^[ \t]*\.\.\. )')
525 525
526 526 def transform_classic_prompt(line):
527 527 """Handle inputs that start with '>>> ' syntax."""
528 528
529 529 if not line or line.isspace():
530 530 return line
531 531 m = _classic_prompt_re.match(line)
532 532 if m:
533 533 return line[len(m.group(0)):]
534 534 else:
535 535 return line
536 536
537 537
538 538 _ipy_prompt_re = re.compile(r'^([ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
539 539
540 540 def transform_ipy_prompt(line):
541 541 """Handle inputs that start classic IPython prompt syntax."""
542 542
543 543 if not line or line.isspace():
544 544 return line
545 545 #print 'LINE: %r' % line # dbg
546 546 m = _ipy_prompt_re.match(line)
547 547 if m:
548 548 #print 'MATCH! %r -> %r' % (line, line[len(m.group(0)):]) # dbg
549 549 return line[len(m.group(0)):]
550 550 else:
551 551 return line
552 552
553 553
554 554 def _make_help_call(target, esc, lspace, next_input=None):
555 555 """Prepares a pinfo(2)/psearch call from a target name and the escape
556 556 (i.e. ? or ??)"""
557 557 method = 'pinfo2' if esc == '??' \
558 558 else 'psearch' if '*' in target \
559 559 else 'pinfo'
560 560 arg = " ".join([method, target])
561 561
562 if next_input:
563 tpl = '%sget_ipython().magic(%r, next_input=%r)'
564 return tpl % (lspace, arg, next_input)
565 else:
562 if next_input is None:
566 563 return '%sget_ipython().magic(%r)' % (lspace, arg)
564 else:
565 return '%sget_ipython().set_next_input(%r);get_ipython().magic(%r)' % \
566 (lspace, next_input, arg)
567
567 568
568 569 _initial_space_re = re.compile(r'\s*')
570
569 571 _help_end_re = re.compile(r"""(%?
570 572 [a-zA-Z_*][\w*]* # Variable name
571 573 (\.[a-zA-Z_*][\w*]*)* # .etc.etc
572 574 )
573 575 (\?\??)$ # ? or ??""",
574 576 re.VERBOSE)
577
578
575 579 def transform_help_end(line):
576 580 """Translate lines with ?/?? at the end"""
577 581 m = _help_end_re.search(line)
578 582 if m is None or has_comment(line):
579 583 return line
580 584 target = m.group(1)
581 585 esc = m.group(3)
582 586 lspace = _initial_space_re.match(line).group(0)
583 587
584 588 # If we're mid-command, put it back on the next prompt for the user.
585 589 next_input = line.rstrip('?') if line.strip() != m.group(0) else None
586 590
587 591 return _make_help_call(target, esc, lspace, next_input)
588 592
589 593
590 594 class EscapedTransformer(object):
591 595 """Class to transform lines that are explicitly escaped out."""
592 596
593 597 def __init__(self):
594 598 tr = { ESC_SHELL : self._tr_system,
595 599 ESC_SH_CAP : self._tr_system2,
596 600 ESC_HELP : self._tr_help,
597 601 ESC_HELP2 : self._tr_help,
598 602 ESC_MAGIC : self._tr_magic,
599 603 ESC_QUOTE : self._tr_quote,
600 604 ESC_QUOTE2 : self._tr_quote2,
601 605 ESC_PAREN : self._tr_paren }
602 606 self.tr = tr
603 607
604 608 # Support for syntax transformations that use explicit escapes typed by the
605 609 # user at the beginning of a line
606 610 @staticmethod
607 611 def _tr_system(line_info):
608 612 "Translate lines escaped with: !"
609 613 cmd = line_info.line.lstrip().lstrip(ESC_SHELL)
610 614 return '%sget_ipython().system(%r)' % (line_info.pre, cmd)
611 615
612 616 @staticmethod
613 617 def _tr_system2(line_info):
614 618 "Translate lines escaped with: !!"
615 619 cmd = line_info.line.lstrip()[2:]
616 620 return '%sget_ipython().getoutput(%r)' % (line_info.pre, cmd)
617 621
618 622 @staticmethod
619 623 def _tr_help(line_info):
620 624 "Translate lines escaped with: ?/??"
621 625 # A naked help line should just fire the intro help screen
622 626 if not line_info.line[1:]:
623 627 return 'get_ipython().show_usage()'
624 628
625 629 return _make_help_call(line_info.ifun, line_info.esc, line_info.pre)
626 630
627 631 @staticmethod
628 632 def _tr_magic(line_info):
629 633 "Translate lines escaped with: %"
630 634 tpl = '%sget_ipython().magic(%r)'
631 635 cmd = ' '.join([line_info.ifun, line_info.the_rest]).strip()
632 636 return tpl % (line_info.pre, cmd)
633 637
634 638 @staticmethod
635 639 def _tr_quote(line_info):
636 640 "Translate lines escaped with: ,"
637 641 return '%s%s("%s")' % (line_info.pre, line_info.ifun,
638 642 '", "'.join(line_info.the_rest.split()) )
639 643
640 644 @staticmethod
641 645 def _tr_quote2(line_info):
642 646 "Translate lines escaped with: ;"
643 647 return '%s%s("%s")' % (line_info.pre, line_info.ifun,
644 648 line_info.the_rest)
645 649
646 650 @staticmethod
647 651 def _tr_paren(line_info):
648 652 "Translate lines escaped with: /"
649 653 return '%s%s(%s)' % (line_info.pre, line_info.ifun,
650 654 ", ".join(line_info.the_rest.split()))
651 655
652 656 def __call__(self, line):
653 657 """Class to transform lines that are explicitly escaped out.
654 658
655 659 This calls the above _tr_* static methods for the actual line
656 660 translations."""
657 661
658 662 # Empty lines just get returned unmodified
659 663 if not line or line.isspace():
660 664 return line
661 665
662 666 # Get line endpoints, where the escapes can be
663 667 line_info = LineInfo(line)
664 668
665 669 if not line_info.esc in self.tr:
666 670 # If we don't recognize the escape, don't modify the line
667 671 return line
668 672
669 673 return self.tr[line_info.esc](line_info)
670 674
671 675
672 676 # A function-looking object to be used by the rest of the code. The purpose of
673 677 # the class in this case is to organize related functionality, more than to
674 678 # manage state.
675 679 transform_escaped = EscapedTransformer()
676 680
677 681
678 682 class IPythonInputSplitter(InputSplitter):
679 683 """An input splitter that recognizes all of IPython's special syntax."""
680 684
681 685 # String with raw, untransformed input.
682 686 source_raw = ''
683 687
684 688 # Private attributes
685 689
686 690 # List with lines of raw input accumulated so far.
687 691 _buffer_raw = None
688 692
689 693 def __init__(self, input_mode=None):
690 694 InputSplitter.__init__(self, input_mode)
691 695 self._buffer_raw = []
692 696
693 697 def reset(self):
694 698 """Reset the input buffer and associated state."""
695 699 InputSplitter.reset(self)
696 700 self._buffer_raw[:] = []
697 701 self.source_raw = ''
698 702
699 703 def source_raw_reset(self):
700 704 """Return input and raw source and perform a full reset.
701 705 """
702 706 out = self.source
703 707 out_r = self.source_raw
704 708 self.reset()
705 709 return out, out_r
706 710
707 711 def push(self, lines):
708 712 """Push one or more lines of IPython input.
709 713 """
710 714 if not lines:
711 715 return super(IPythonInputSplitter, self).push(lines)
712 716
713 717 # We must ensure all input is pure unicode
714 718 lines = cast_unicode(lines, self.encoding)
715 719
716 720 lines_list = lines.splitlines()
717 721
718 722 transforms = [transform_ipy_prompt, transform_classic_prompt,
719 723 transform_help_end, transform_escaped,
720 724 transform_assign_system, transform_assign_magic]
721 725
722 726 # Transform logic
723 727 #
724 728 # We only apply the line transformers to the input if we have either no
725 729 # input yet, or complete input, or if the last line of the buffer ends
726 730 # with ':' (opening an indented block). This prevents the accidental
727 731 # transformation of escapes inside multiline expressions like
728 732 # triple-quoted strings or parenthesized expressions.
729 733 #
730 734 # The last heuristic, while ugly, ensures that the first line of an
731 735 # indented block is correctly transformed.
732 736 #
733 737 # FIXME: try to find a cleaner approach for this last bit.
734 738
735 739 # If we were in 'block' mode, since we're going to pump the parent
736 740 # class by hand line by line, we need to temporarily switch out to
737 741 # 'line' mode, do a single manual reset and then feed the lines one
738 742 # by one. Note that this only matters if the input has more than one
739 743 # line.
740 744 changed_input_mode = False
741 745
742 746 if self.input_mode == 'cell':
743 747 self.reset()
744 748 changed_input_mode = True
745 749 saved_input_mode = 'cell'
746 750 self.input_mode = 'line'
747 751
748 752 # Store raw source before applying any transformations to it. Note
749 753 # that this must be done *after* the reset() call that would otherwise
750 754 # flush the buffer.
751 755 self._store(lines, self._buffer_raw, 'source_raw')
752 756
753 757 try:
754 758 push = super(IPythonInputSplitter, self).push
755 759 buf = self._buffer
756 760 for line in lines_list:
757 761 if self._is_complete or not buf or \
758 762 (buf and (buf[-1].rstrip().endswith(':') or
759 763 buf[-1].rstrip().endswith(',')) ):
760 764 for f in transforms:
761 765 line = f(line)
762 766
763 767 out = push(line)
764 768 finally:
765 769 if changed_input_mode:
766 770 self.input_mode = saved_input_mode
767 771 return out
@@ -1,2950 +1,2942 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 with_statement
18 18 from __future__ import absolute_import
19 19
20 20 import __builtin__ as builtin_mod
21 21 import __future__
22 22 import abc
23 23 import ast
24 24 import atexit
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 urllib
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 history as ipcorehist
37 37 from IPython.core import magic
38 38 from IPython.core import page
39 39 from IPython.core import prefilter
40 40 from IPython.core import shadowns
41 41 from IPython.core import ultratb
42 42 from IPython.core.alias import AliasManager, AliasError
43 43 from IPython.core.autocall import ExitAutocall
44 44 from IPython.core.builtin_trap import BuiltinTrap
45 45 from IPython.core.compilerop import CachingCompiler
46 46 from IPython.core.display_trap import DisplayTrap
47 47 from IPython.core.displayhook import DisplayHook
48 48 from IPython.core.displaypub import DisplayPublisher
49 49 from IPython.core.error import UsageError
50 50 from IPython.core.extensions import ExtensionManager
51 51 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
52 52 from IPython.core.formatters import DisplayFormatter
53 53 from IPython.core.history import HistoryManager
54 54 from IPython.core.inputsplitter import IPythonInputSplitter
55 55 from IPython.core.logger import Logger
56 56 from IPython.core.macro import Macro
57 57 from IPython.core.payload import PayloadManager
58 58 from IPython.core.plugin import PluginManager
59 59 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
60 60 from IPython.core.profiledir import ProfileDir
61 61 from IPython.core.pylabtools import pylab_activate
62 62 from IPython.core.prompts import PromptManager
63 63 from IPython.utils import PyColorize
64 64 from IPython.utils import io
65 65 from IPython.utils import py3compat
66 66 from IPython.utils import openpy
67 67 from IPython.utils.doctestreload import doctest_reload
68 68 from IPython.utils.io import ask_yes_no
69 69 from IPython.utils.ipstruct import Struct
70 70 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename
71 71 from IPython.utils.pickleshare import PickleShareDB
72 72 from IPython.utils.process import system, getoutput
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 def softspace(file, newvalue):
94 94 """Copied from code.py, to remove the dependency"""
95 95
96 96 oldvalue = 0
97 97 try:
98 98 oldvalue = file.softspace
99 99 except AttributeError:
100 100 pass
101 101 try:
102 102 file.softspace = newvalue
103 103 except (AttributeError, TypeError):
104 104 # "attribute-less object" or "read-only attributes"
105 105 pass
106 106 return oldvalue
107 107
108 108
109 109 def no_op(*a, **kw): pass
110 110
111 111 class NoOpContext(object):
112 112 def __enter__(self): pass
113 113 def __exit__(self, type, value, traceback): pass
114 114 no_op_context = NoOpContext()
115 115
116 116 class SpaceInInput(Exception): pass
117 117
118 118 class Bunch: pass
119 119
120 120
121 121 def get_default_colors():
122 122 if sys.platform=='darwin':
123 123 return "LightBG"
124 124 elif os.name=='nt':
125 125 return 'Linux'
126 126 else:
127 127 return 'Linux'
128 128
129 129
130 130 class SeparateUnicode(Unicode):
131 131 """A Unicode subclass to validate separate_in, separate_out, etc.
132 132
133 133 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
134 134 """
135 135
136 136 def validate(self, obj, value):
137 137 if value == '0': value = ''
138 138 value = value.replace('\\n','\n')
139 139 return super(SeparateUnicode, self).validate(obj, value)
140 140
141 141
142 142 class ReadlineNoRecord(object):
143 143 """Context manager to execute some code, then reload readline history
144 144 so that interactive input to the code doesn't appear when pressing up."""
145 145 def __init__(self, shell):
146 146 self.shell = shell
147 147 self._nested_level = 0
148 148
149 149 def __enter__(self):
150 150 if self._nested_level == 0:
151 151 try:
152 152 self.orig_length = self.current_length()
153 153 self.readline_tail = self.get_readline_tail()
154 154 except (AttributeError, IndexError): # Can fail with pyreadline
155 155 self.orig_length, self.readline_tail = 999999, []
156 156 self._nested_level += 1
157 157
158 158 def __exit__(self, type, value, traceback):
159 159 self._nested_level -= 1
160 160 if self._nested_level == 0:
161 161 # Try clipping the end if it's got longer
162 162 try:
163 163 e = self.current_length() - self.orig_length
164 164 if e > 0:
165 165 for _ in range(e):
166 166 self.shell.readline.remove_history_item(self.orig_length)
167 167
168 168 # If it still doesn't match, just reload readline history.
169 169 if self.current_length() != self.orig_length \
170 170 or self.get_readline_tail() != self.readline_tail:
171 171 self.shell.refill_readline_hist()
172 172 except (AttributeError, IndexError):
173 173 pass
174 174 # Returning False will cause exceptions to propagate
175 175 return False
176 176
177 177 def current_length(self):
178 178 return self.shell.readline.get_current_history_length()
179 179
180 180 def get_readline_tail(self, n=10):
181 181 """Get the last n items in readline history."""
182 182 end = self.shell.readline.get_current_history_length() + 1
183 183 start = max(end-n, 1)
184 184 ghi = self.shell.readline.get_history_item
185 185 return [ghi(x) for x in range(start, end)]
186 186
187 187 #-----------------------------------------------------------------------------
188 188 # Main IPython class
189 189 #-----------------------------------------------------------------------------
190 190
191 191 class InteractiveShell(SingletonConfigurable):
192 192 """An enhanced, interactive shell for Python."""
193 193
194 194 _instance = None
195 195
196 196 autocall = Enum((0,1,2), default_value=0, config=True, help=
197 197 """
198 198 Make IPython automatically call any callable object even if you didn't
199 199 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
200 200 automatically. The value can be '0' to disable the feature, '1' for
201 201 'smart' autocall, where it is not applied if there are no more
202 202 arguments on the line, and '2' for 'full' autocall, where all callable
203 203 objects are automatically called (even if no arguments are present).
204 204 """
205 205 )
206 206 # TODO: remove all autoindent logic and put into frontends.
207 207 # We can't do this yet because even runlines uses the autoindent.
208 208 autoindent = CBool(True, config=True, help=
209 209 """
210 210 Autoindent IPython code entered interactively.
211 211 """
212 212 )
213 213 automagic = CBool(True, config=True, help=
214 214 """
215 215 Enable magic commands to be called without the leading %.
216 216 """
217 217 )
218 218 cache_size = Integer(1000, config=True, help=
219 219 """
220 220 Set the size of the output cache. The default is 1000, you can
221 221 change it permanently in your config file. Setting it to 0 completely
222 222 disables the caching system, and the minimum value accepted is 20 (if
223 223 you provide a value less than 20, it is reset to 0 and a warning is
224 224 issued). This limit is defined because otherwise you'll spend more
225 225 time re-flushing a too small cache than working
226 226 """
227 227 )
228 228 color_info = CBool(True, config=True, help=
229 229 """
230 230 Use colors for displaying information about objects. Because this
231 231 information is passed through a pager (like 'less'), and some pagers
232 232 get confused with color codes, this capability can be turned off.
233 233 """
234 234 )
235 235 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
236 236 default_value=get_default_colors(), config=True,
237 237 help="Set the color scheme (NoColor, Linux, or LightBG)."
238 238 )
239 239 colors_force = CBool(False, help=
240 240 """
241 241 Force use of ANSI color codes, regardless of OS and readline
242 242 availability.
243 243 """
244 244 # FIXME: This is essentially a hack to allow ZMQShell to show colors
245 245 # without readline on Win32. When the ZMQ formatting system is
246 246 # refactored, this should be removed.
247 247 )
248 248 debug = CBool(False, config=True)
249 249 deep_reload = CBool(False, config=True, help=
250 250 """
251 251 Enable deep (recursive) reloading by default. IPython can use the
252 252 deep_reload module which reloads changes in modules recursively (it
253 253 replaces the reload() function, so you don't need to change anything to
254 254 use it). deep_reload() forces a full reload of modules whose code may
255 255 have changed, which the default reload() function does not. When
256 256 deep_reload is off, IPython will use the normal reload(), but
257 257 deep_reload will still be available as dreload().
258 258 """
259 259 )
260 260 disable_failing_post_execute = CBool(False, config=True,
261 261 help="Don't call post-execute functions that have failed in the past."""
262 262 )
263 263 display_formatter = Instance(DisplayFormatter)
264 264 displayhook_class = Type(DisplayHook)
265 265 display_pub_class = Type(DisplayPublisher)
266 266
267 267 exit_now = CBool(False)
268 268 exiter = Instance(ExitAutocall)
269 269 def _exiter_default(self):
270 270 return ExitAutocall(self)
271 271 # Monotonically increasing execution counter
272 272 execution_count = Integer(1)
273 273 filename = Unicode("<ipython console>")
274 274 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
275 275
276 276 # Input splitter, to split entire cells of input into either individual
277 277 # interactive statements or whole blocks.
278 278 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
279 279 (), {})
280 280 logstart = CBool(False, config=True, help=
281 281 """
282 282 Start logging to the default log file.
283 283 """
284 284 )
285 285 logfile = Unicode('', config=True, help=
286 286 """
287 287 The name of the logfile to use.
288 288 """
289 289 )
290 290 logappend = Unicode('', config=True, help=
291 291 """
292 292 Start logging to the given file in append mode.
293 293 """
294 294 )
295 295 object_info_string_level = Enum((0,1,2), default_value=0,
296 296 config=True)
297 297 pdb = CBool(False, config=True, help=
298 298 """
299 299 Automatically call the pdb debugger after every exception.
300 300 """
301 301 )
302 302 multiline_history = CBool(sys.platform != 'win32', config=True,
303 303 help="Save multi-line entries as one entry in readline history"
304 304 )
305 305
306 306 # deprecated prompt traits:
307 307
308 308 prompt_in1 = Unicode('In [\\#]: ', config=True,
309 309 help="Deprecated, use PromptManager.in_template")
310 310 prompt_in2 = Unicode(' .\\D.: ', config=True,
311 311 help="Deprecated, use PromptManager.in2_template")
312 312 prompt_out = Unicode('Out[\\#]: ', config=True,
313 313 help="Deprecated, use PromptManager.out_template")
314 314 prompts_pad_left = CBool(True, config=True,
315 315 help="Deprecated, use PromptManager.justify")
316 316
317 317 def _prompt_trait_changed(self, name, old, new):
318 318 table = {
319 319 'prompt_in1' : 'in_template',
320 320 'prompt_in2' : 'in2_template',
321 321 'prompt_out' : 'out_template',
322 322 'prompts_pad_left' : 'justify',
323 323 }
324 324 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}\n".format(
325 325 name=name, newname=table[name])
326 326 )
327 327 # protect against weird cases where self.config may not exist:
328 328 if self.config is not None:
329 329 # propagate to corresponding PromptManager trait
330 330 setattr(self.config.PromptManager, table[name], new)
331 331
332 332 _prompt_in1_changed = _prompt_trait_changed
333 333 _prompt_in2_changed = _prompt_trait_changed
334 334 _prompt_out_changed = _prompt_trait_changed
335 335 _prompt_pad_left_changed = _prompt_trait_changed
336 336
337 337 show_rewritten_input = CBool(True, config=True,
338 338 help="Show rewritten input, e.g. for autocall."
339 339 )
340 340
341 341 quiet = CBool(False, config=True)
342 342
343 343 history_length = Integer(10000, config=True)
344 344
345 345 # The readline stuff will eventually be moved to the terminal subclass
346 346 # but for now, we can't do that as readline is welded in everywhere.
347 347 readline_use = CBool(True, config=True)
348 348 readline_remove_delims = Unicode('-/~', config=True)
349 349 # don't use \M- bindings by default, because they
350 350 # conflict with 8-bit encodings. See gh-58,gh-88
351 351 readline_parse_and_bind = List([
352 352 'tab: complete',
353 353 '"\C-l": clear-screen',
354 354 'set show-all-if-ambiguous on',
355 355 '"\C-o": tab-insert',
356 356 '"\C-r": reverse-search-history',
357 357 '"\C-s": forward-search-history',
358 358 '"\C-p": history-search-backward',
359 359 '"\C-n": history-search-forward',
360 360 '"\e[A": history-search-backward',
361 361 '"\e[B": history-search-forward',
362 362 '"\C-k": kill-line',
363 363 '"\C-u": unix-line-discard',
364 364 ], allow_none=False, config=True)
365 365
366 366 # TODO: this part of prompt management should be moved to the frontends.
367 367 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
368 368 separate_in = SeparateUnicode('\n', config=True)
369 369 separate_out = SeparateUnicode('', config=True)
370 370 separate_out2 = SeparateUnicode('', config=True)
371 371 wildcards_case_sensitive = CBool(True, config=True)
372 372 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
373 373 default_value='Context', config=True)
374 374
375 375 # Subcomponents of InteractiveShell
376 376 alias_manager = Instance('IPython.core.alias.AliasManager')
377 377 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
378 378 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
379 379 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
380 380 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
381 381 plugin_manager = Instance('IPython.core.plugin.PluginManager')
382 382 payload_manager = Instance('IPython.core.payload.PayloadManager')
383 383 history_manager = Instance('IPython.core.history.HistoryManager')
384 384 magics_manager = Instance('IPython.core.magic.MagicsManager')
385 385
386 386 profile_dir = Instance('IPython.core.application.ProfileDir')
387 387 @property
388 388 def profile(self):
389 389 if self.profile_dir is not None:
390 390 name = os.path.basename(self.profile_dir.location)
391 391 return name.replace('profile_','')
392 392
393 393
394 394 # Private interface
395 395 _post_execute = Instance(dict)
396 396
397 397 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
398 398 user_module=None, user_ns=None,
399 399 custom_exceptions=((), None)):
400 400
401 401 # This is where traits with a config_key argument are updated
402 402 # from the values on config.
403 403 super(InteractiveShell, self).__init__(config=config)
404 404 self.configurables = [self]
405 405
406 406 # These are relatively independent and stateless
407 407 self.init_ipython_dir(ipython_dir)
408 408 self.init_profile_dir(profile_dir)
409 409 self.init_instance_attrs()
410 410 self.init_environment()
411 411
412 412 # Check if we're in a virtualenv, and set up sys.path.
413 413 self.init_virtualenv()
414 414
415 415 # Create namespaces (user_ns, user_global_ns, etc.)
416 416 self.init_create_namespaces(user_module, user_ns)
417 417 # This has to be done after init_create_namespaces because it uses
418 418 # something in self.user_ns, but before init_sys_modules, which
419 419 # is the first thing to modify sys.
420 420 # TODO: When we override sys.stdout and sys.stderr before this class
421 421 # is created, we are saving the overridden ones here. Not sure if this
422 422 # is what we want to do.
423 423 self.save_sys_module_state()
424 424 self.init_sys_modules()
425 425
426 426 # While we're trying to have each part of the code directly access what
427 427 # it needs without keeping redundant references to objects, we have too
428 428 # much legacy code that expects ip.db to exist.
429 429 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
430 430
431 431 self.init_history()
432 432 self.init_encoding()
433 433 self.init_prefilter()
434 434
435 435 self.init_syntax_highlighting()
436 436 self.init_hooks()
437 437 self.init_pushd_popd_magic()
438 438 # self.init_traceback_handlers use to be here, but we moved it below
439 439 # because it and init_io have to come after init_readline.
440 440 self.init_user_ns()
441 441 self.init_logger()
442 442 self.init_alias()
443 443 self.init_builtins()
444 444
445 445 # pre_config_initialization
446 446
447 447 # The next section should contain everything that was in ipmaker.
448 448 self.init_logstart()
449 449
450 450 # The following was in post_config_initialization
451 451 self.init_inspector()
452 452 # init_readline() must come before init_io(), because init_io uses
453 453 # readline related things.
454 454 self.init_readline()
455 455 # We save this here in case user code replaces raw_input, but it needs
456 456 # to be after init_readline(), because PyPy's readline works by replacing
457 457 # raw_input.
458 458 if py3compat.PY3:
459 459 self.raw_input_original = input
460 460 else:
461 461 self.raw_input_original = raw_input
462 462 # init_completer must come after init_readline, because it needs to
463 463 # know whether readline is present or not system-wide to configure the
464 464 # completers, since the completion machinery can now operate
465 465 # independently of readline (e.g. over the network)
466 466 self.init_completer()
467 467 # TODO: init_io() needs to happen before init_traceback handlers
468 468 # because the traceback handlers hardcode the stdout/stderr streams.
469 469 # This logic in in debugger.Pdb and should eventually be changed.
470 470 self.init_io()
471 471 self.init_traceback_handlers(custom_exceptions)
472 472 self.init_prompts()
473 473 self.init_display_formatter()
474 474 self.init_display_pub()
475 475 self.init_displayhook()
476 476 self.init_reload_doctest()
477 477 self.init_magics()
478 478 self.init_pdb()
479 479 self.init_extension_manager()
480 480 self.init_plugin_manager()
481 481 self.init_payload()
482 482 self.hooks.late_startup_hook()
483 483 atexit.register(self.atexit_operations)
484 484
485 485 def get_ipython(self):
486 486 """Return the currently running IPython instance."""
487 487 return self
488 488
489 489 #-------------------------------------------------------------------------
490 490 # Trait changed handlers
491 491 #-------------------------------------------------------------------------
492 492
493 493 def _ipython_dir_changed(self, name, new):
494 494 if not os.path.isdir(new):
495 495 os.makedirs(new, mode = 0777)
496 496
497 497 def set_autoindent(self,value=None):
498 498 """Set the autoindent flag, checking for readline support.
499 499
500 500 If called with no arguments, it acts as a toggle."""
501 501
502 502 if value != 0 and not self.has_readline:
503 503 if os.name == 'posix':
504 504 warn("The auto-indent feature requires the readline library")
505 505 self.autoindent = 0
506 506 return
507 507 if value is None:
508 508 self.autoindent = not self.autoindent
509 509 else:
510 510 self.autoindent = value
511 511
512 512 #-------------------------------------------------------------------------
513 513 # init_* methods called by __init__
514 514 #-------------------------------------------------------------------------
515 515
516 516 def init_ipython_dir(self, ipython_dir):
517 517 if ipython_dir is not None:
518 518 self.ipython_dir = ipython_dir
519 519 return
520 520
521 521 self.ipython_dir = get_ipython_dir()
522 522
523 523 def init_profile_dir(self, profile_dir):
524 524 if profile_dir is not None:
525 525 self.profile_dir = profile_dir
526 526 return
527 527 self.profile_dir =\
528 528 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
529 529
530 530 def init_instance_attrs(self):
531 531 self.more = False
532 532
533 533 # command compiler
534 534 self.compile = CachingCompiler()
535 535
536 536 # Make an empty namespace, which extension writers can rely on both
537 537 # existing and NEVER being used by ipython itself. This gives them a
538 538 # convenient location for storing additional information and state
539 539 # their extensions may require, without fear of collisions with other
540 540 # ipython names that may develop later.
541 541 self.meta = Struct()
542 542
543 543 # Temporary files used for various purposes. Deleted at exit.
544 544 self.tempfiles = []
545 545
546 546 # Keep track of readline usage (later set by init_readline)
547 547 self.has_readline = False
548 548
549 549 # keep track of where we started running (mainly for crash post-mortem)
550 550 # This is not being used anywhere currently.
551 551 self.starting_dir = os.getcwdu()
552 552
553 553 # Indentation management
554 554 self.indent_current_nsp = 0
555 555
556 556 # Dict to track post-execution functions that have been registered
557 557 self._post_execute = {}
558 558
559 559 def init_environment(self):
560 560 """Any changes we need to make to the user's environment."""
561 561 pass
562 562
563 563 def init_encoding(self):
564 564 # Get system encoding at startup time. Certain terminals (like Emacs
565 565 # under Win32 have it set to None, and we need to have a known valid
566 566 # encoding to use in the raw_input() method
567 567 try:
568 568 self.stdin_encoding = sys.stdin.encoding or 'ascii'
569 569 except AttributeError:
570 570 self.stdin_encoding = 'ascii'
571 571
572 572 def init_syntax_highlighting(self):
573 573 # Python source parser/formatter for syntax highlighting
574 574 pyformat = PyColorize.Parser().format
575 575 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
576 576
577 577 def init_pushd_popd_magic(self):
578 578 # for pushd/popd management
579 579 self.home_dir = get_home_dir()
580 580
581 581 self.dir_stack = []
582 582
583 583 def init_logger(self):
584 584 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
585 585 logmode='rotate')
586 586
587 587 def init_logstart(self):
588 588 """Initialize logging in case it was requested at the command line.
589 589 """
590 590 if self.logappend:
591 591 self.magic('logstart %s append' % self.logappend)
592 592 elif self.logfile:
593 593 self.magic('logstart %' % self.logfile)
594 594 elif self.logstart:
595 595 self.magic('logstart')
596 596
597 597 def init_builtins(self):
598 598 # A single, static flag that we set to True. Its presence indicates
599 599 # that an IPython shell has been created, and we make no attempts at
600 600 # removing on exit or representing the existence of more than one
601 601 # IPython at a time.
602 602 builtin_mod.__dict__['__IPYTHON__'] = True
603 603
604 604 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
605 605 # manage on enter/exit, but with all our shells it's virtually
606 606 # impossible to get all the cases right. We're leaving the name in for
607 607 # those who adapted their codes to check for this flag, but will
608 608 # eventually remove it after a few more releases.
609 609 builtin_mod.__dict__['__IPYTHON__active'] = \
610 610 'Deprecated, check for __IPYTHON__'
611 611
612 612 self.builtin_trap = BuiltinTrap(shell=self)
613 613
614 614 def init_inspector(self):
615 615 # Object inspector
616 616 self.inspector = oinspect.Inspector(oinspect.InspectColors,
617 617 PyColorize.ANSICodeColors,
618 618 'NoColor',
619 619 self.object_info_string_level)
620 620
621 621 def init_io(self):
622 622 # This will just use sys.stdout and sys.stderr. If you want to
623 623 # override sys.stdout and sys.stderr themselves, you need to do that
624 624 # *before* instantiating this class, because io holds onto
625 625 # references to the underlying streams.
626 626 if sys.platform == 'win32' and self.has_readline:
627 627 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
628 628 else:
629 629 io.stdout = io.IOStream(sys.stdout)
630 630 io.stderr = io.IOStream(sys.stderr)
631 631
632 632 def init_prompts(self):
633 633 self.prompt_manager = PromptManager(shell=self, config=self.config)
634 634 self.configurables.append(self.prompt_manager)
635 635 # Set system prompts, so that scripts can decide if they are running
636 636 # interactively.
637 637 sys.ps1 = 'In : '
638 638 sys.ps2 = '...: '
639 639 sys.ps3 = 'Out: '
640 640
641 641 def init_display_formatter(self):
642 642 self.display_formatter = DisplayFormatter(config=self.config)
643 643 self.configurables.append(self.display_formatter)
644 644
645 645 def init_display_pub(self):
646 646 self.display_pub = self.display_pub_class(config=self.config)
647 647 self.configurables.append(self.display_pub)
648 648
649 649 def init_displayhook(self):
650 650 # Initialize displayhook, set in/out prompts and printing system
651 651 self.displayhook = self.displayhook_class(
652 652 config=self.config,
653 653 shell=self,
654 654 cache_size=self.cache_size,
655 655 )
656 656 self.configurables.append(self.displayhook)
657 657 # This is a context manager that installs/revmoes the displayhook at
658 658 # the appropriate time.
659 659 self.display_trap = DisplayTrap(hook=self.displayhook)
660 660
661 661 def init_reload_doctest(self):
662 662 # Do a proper resetting of doctest, including the necessary displayhook
663 663 # monkeypatching
664 664 try:
665 665 doctest_reload()
666 666 except ImportError:
667 667 warn("doctest module does not exist.")
668 668
669 669 def init_virtualenv(self):
670 670 """Add a virtualenv to sys.path so the user can import modules from it.
671 671 This isn't perfect: it doesn't use the Python interpreter with which the
672 672 virtualenv was built, and it ignores the --no-site-packages option. A
673 673 warning will appear suggesting the user installs IPython in the
674 674 virtualenv, but for many cases, it probably works well enough.
675 675
676 676 Adapted from code snippets online.
677 677
678 678 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
679 679 """
680 680 if 'VIRTUAL_ENV' not in os.environ:
681 681 # Not in a virtualenv
682 682 return
683 683
684 684 if sys.executable.startswith(os.environ['VIRTUAL_ENV']):
685 685 # Running properly in the virtualenv, don't need to do anything
686 686 return
687 687
688 688 warn("Attempting to work in a virtualenv. If you encounter problems, please "
689 689 "install IPython inside the virtualenv.\n")
690 690 if sys.platform == "win32":
691 691 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
692 692 else:
693 693 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
694 694 'python%d.%d' % sys.version_info[:2], 'site-packages')
695 695
696 696 import site
697 697 sys.path.insert(0, virtual_env)
698 698 site.addsitedir(virtual_env)
699 699
700 700 #-------------------------------------------------------------------------
701 701 # Things related to injections into the sys module
702 702 #-------------------------------------------------------------------------
703 703
704 704 def save_sys_module_state(self):
705 705 """Save the state of hooks in the sys module.
706 706
707 707 This has to be called after self.user_module is created.
708 708 """
709 709 self._orig_sys_module_state = {}
710 710 self._orig_sys_module_state['stdin'] = sys.stdin
711 711 self._orig_sys_module_state['stdout'] = sys.stdout
712 712 self._orig_sys_module_state['stderr'] = sys.stderr
713 713 self._orig_sys_module_state['excepthook'] = sys.excepthook
714 714 self._orig_sys_modules_main_name = self.user_module.__name__
715 715 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
716 716
717 717 def restore_sys_module_state(self):
718 718 """Restore the state of the sys module."""
719 719 try:
720 720 for k, v in self._orig_sys_module_state.iteritems():
721 721 setattr(sys, k, v)
722 722 except AttributeError:
723 723 pass
724 724 # Reset what what done in self.init_sys_modules
725 725 if self._orig_sys_modules_main_mod is not None:
726 726 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
727 727
728 728 #-------------------------------------------------------------------------
729 729 # Things related to hooks
730 730 #-------------------------------------------------------------------------
731 731
732 732 def init_hooks(self):
733 733 # hooks holds pointers used for user-side customizations
734 734 self.hooks = Struct()
735 735
736 736 self.strdispatchers = {}
737 737
738 738 # Set all default hooks, defined in the IPython.hooks module.
739 739 hooks = IPython.core.hooks
740 740 for hook_name in hooks.__all__:
741 741 # default hooks have priority 100, i.e. low; user hooks should have
742 742 # 0-100 priority
743 743 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
744 744
745 745 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
746 746 """set_hook(name,hook) -> sets an internal IPython hook.
747 747
748 748 IPython exposes some of its internal API as user-modifiable hooks. By
749 749 adding your function to one of these hooks, you can modify IPython's
750 750 behavior to call at runtime your own routines."""
751 751
752 752 # At some point in the future, this should validate the hook before it
753 753 # accepts it. Probably at least check that the hook takes the number
754 754 # of args it's supposed to.
755 755
756 756 f = types.MethodType(hook,self)
757 757
758 758 # check if the hook is for strdispatcher first
759 759 if str_key is not None:
760 760 sdp = self.strdispatchers.get(name, StrDispatch())
761 761 sdp.add_s(str_key, f, priority )
762 762 self.strdispatchers[name] = sdp
763 763 return
764 764 if re_key is not None:
765 765 sdp = self.strdispatchers.get(name, StrDispatch())
766 766 sdp.add_re(re.compile(re_key), f, priority )
767 767 self.strdispatchers[name] = sdp
768 768 return
769 769
770 770 dp = getattr(self.hooks, name, None)
771 771 if name not in IPython.core.hooks.__all__:
772 772 print "Warning! Hook '%s' is not one of %s" % \
773 773 (name, IPython.core.hooks.__all__ )
774 774 if not dp:
775 775 dp = IPython.core.hooks.CommandChainDispatcher()
776 776
777 777 try:
778 778 dp.add(f,priority)
779 779 except AttributeError:
780 780 # it was not commandchain, plain old func - replace
781 781 dp = f
782 782
783 783 setattr(self.hooks,name, dp)
784 784
785 785 def register_post_execute(self, func):
786 786 """Register a function for calling after code execution.
787 787 """
788 788 if not callable(func):
789 789 raise ValueError('argument %s must be callable' % func)
790 790 self._post_execute[func] = True
791 791
792 792 #-------------------------------------------------------------------------
793 793 # Things related to the "main" module
794 794 #-------------------------------------------------------------------------
795 795
796 796 def new_main_mod(self,ns=None):
797 797 """Return a new 'main' module object for user code execution.
798 798 """
799 799 main_mod = self._user_main_module
800 800 init_fakemod_dict(main_mod,ns)
801 801 return main_mod
802 802
803 803 def cache_main_mod(self,ns,fname):
804 804 """Cache a main module's namespace.
805 805
806 806 When scripts are executed via %run, we must keep a reference to the
807 807 namespace of their __main__ module (a FakeModule instance) around so
808 808 that Python doesn't clear it, rendering objects defined therein
809 809 useless.
810 810
811 811 This method keeps said reference in a private dict, keyed by the
812 812 absolute path of the module object (which corresponds to the script
813 813 path). This way, for multiple executions of the same script we only
814 814 keep one copy of the namespace (the last one), thus preventing memory
815 815 leaks from old references while allowing the objects from the last
816 816 execution to be accessible.
817 817
818 818 Note: we can not allow the actual FakeModule instances to be deleted,
819 819 because of how Python tears down modules (it hard-sets all their
820 820 references to None without regard for reference counts). This method
821 821 must therefore make a *copy* of the given namespace, to allow the
822 822 original module's __dict__ to be cleared and reused.
823 823
824 824
825 825 Parameters
826 826 ----------
827 827 ns : a namespace (a dict, typically)
828 828
829 829 fname : str
830 830 Filename associated with the namespace.
831 831
832 832 Examples
833 833 --------
834 834
835 835 In [10]: import IPython
836 836
837 837 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
838 838
839 839 In [12]: IPython.__file__ in _ip._main_ns_cache
840 840 Out[12]: True
841 841 """
842 842 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
843 843
844 844 def clear_main_mod_cache(self):
845 845 """Clear the cache of main modules.
846 846
847 847 Mainly for use by utilities like %reset.
848 848
849 849 Examples
850 850 --------
851 851
852 852 In [15]: import IPython
853 853
854 854 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
855 855
856 856 In [17]: len(_ip._main_ns_cache) > 0
857 857 Out[17]: True
858 858
859 859 In [18]: _ip.clear_main_mod_cache()
860 860
861 861 In [19]: len(_ip._main_ns_cache) == 0
862 862 Out[19]: True
863 863 """
864 864 self._main_ns_cache.clear()
865 865
866 866 #-------------------------------------------------------------------------
867 867 # Things related to debugging
868 868 #-------------------------------------------------------------------------
869 869
870 870 def init_pdb(self):
871 871 # Set calling of pdb on exceptions
872 872 # self.call_pdb is a property
873 873 self.call_pdb = self.pdb
874 874
875 875 def _get_call_pdb(self):
876 876 return self._call_pdb
877 877
878 878 def _set_call_pdb(self,val):
879 879
880 880 if val not in (0,1,False,True):
881 881 raise ValueError,'new call_pdb value must be boolean'
882 882
883 883 # store value in instance
884 884 self._call_pdb = val
885 885
886 886 # notify the actual exception handlers
887 887 self.InteractiveTB.call_pdb = val
888 888
889 889 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
890 890 'Control auto-activation of pdb at exceptions')
891 891
892 892 def debugger(self,force=False):
893 893 """Call the pydb/pdb debugger.
894 894
895 895 Keywords:
896 896
897 897 - force(False): by default, this routine checks the instance call_pdb
898 898 flag and does not actually invoke the debugger if the flag is false.
899 899 The 'force' option forces the debugger to activate even if the flag
900 900 is false.
901 901 """
902 902
903 903 if not (force or self.call_pdb):
904 904 return
905 905
906 906 if not hasattr(sys,'last_traceback'):
907 907 error('No traceback has been produced, nothing to debug.')
908 908 return
909 909
910 910 # use pydb if available
911 911 if debugger.has_pydb:
912 912 from pydb import pm
913 913 else:
914 914 # fallback to our internal debugger
915 915 pm = lambda : self.InteractiveTB.debugger(force=True)
916 916
917 917 with self.readline_no_record:
918 918 pm()
919 919
920 920 #-------------------------------------------------------------------------
921 921 # Things related to IPython's various namespaces
922 922 #-------------------------------------------------------------------------
923 923 default_user_namespaces = True
924 924
925 925 def init_create_namespaces(self, user_module=None, user_ns=None):
926 926 # Create the namespace where the user will operate. user_ns is
927 927 # normally the only one used, and it is passed to the exec calls as
928 928 # the locals argument. But we do carry a user_global_ns namespace
929 929 # given as the exec 'globals' argument, This is useful in embedding
930 930 # situations where the ipython shell opens in a context where the
931 931 # distinction between locals and globals is meaningful. For
932 932 # non-embedded contexts, it is just the same object as the user_ns dict.
933 933
934 934 # FIXME. For some strange reason, __builtins__ is showing up at user
935 935 # level as a dict instead of a module. This is a manual fix, but I
936 936 # should really track down where the problem is coming from. Alex
937 937 # Schmolck reported this problem first.
938 938
939 939 # A useful post by Alex Martelli on this topic:
940 940 # Re: inconsistent value from __builtins__
941 941 # Von: Alex Martelli <aleaxit@yahoo.com>
942 942 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
943 943 # Gruppen: comp.lang.python
944 944
945 945 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
946 946 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
947 947 # > <type 'dict'>
948 948 # > >>> print type(__builtins__)
949 949 # > <type 'module'>
950 950 # > Is this difference in return value intentional?
951 951
952 952 # Well, it's documented that '__builtins__' can be either a dictionary
953 953 # or a module, and it's been that way for a long time. Whether it's
954 954 # intentional (or sensible), I don't know. In any case, the idea is
955 955 # that if you need to access the built-in namespace directly, you
956 956 # should start with "import __builtin__" (note, no 's') which will
957 957 # definitely give you a module. Yeah, it's somewhat confusing:-(.
958 958
959 959 # These routines return a properly built module and dict as needed by
960 960 # the rest of the code, and can also be used by extension writers to
961 961 # generate properly initialized namespaces.
962 962 if (user_ns is not None) or (user_module is not None):
963 963 self.default_user_namespaces = False
964 964 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
965 965
966 966 # A record of hidden variables we have added to the user namespace, so
967 967 # we can list later only variables defined in actual interactive use.
968 968 self.user_ns_hidden = set()
969 969
970 970 # Now that FakeModule produces a real module, we've run into a nasty
971 971 # problem: after script execution (via %run), the module where the user
972 972 # code ran is deleted. Now that this object is a true module (needed
973 973 # so docetst and other tools work correctly), the Python module
974 974 # teardown mechanism runs over it, and sets to None every variable
975 975 # present in that module. Top-level references to objects from the
976 976 # script survive, because the user_ns is updated with them. However,
977 977 # calling functions defined in the script that use other things from
978 978 # the script will fail, because the function's closure had references
979 979 # to the original objects, which are now all None. So we must protect
980 980 # these modules from deletion by keeping a cache.
981 981 #
982 982 # To avoid keeping stale modules around (we only need the one from the
983 983 # last run), we use a dict keyed with the full path to the script, so
984 984 # only the last version of the module is held in the cache. Note,
985 985 # however, that we must cache the module *namespace contents* (their
986 986 # __dict__). Because if we try to cache the actual modules, old ones
987 987 # (uncached) could be destroyed while still holding references (such as
988 988 # those held by GUI objects that tend to be long-lived)>
989 989 #
990 990 # The %reset command will flush this cache. See the cache_main_mod()
991 991 # and clear_main_mod_cache() methods for details on use.
992 992
993 993 # This is the cache used for 'main' namespaces
994 994 self._main_ns_cache = {}
995 995 # And this is the single instance of FakeModule whose __dict__ we keep
996 996 # copying and clearing for reuse on each %run
997 997 self._user_main_module = FakeModule()
998 998
999 999 # A table holding all the namespaces IPython deals with, so that
1000 1000 # introspection facilities can search easily.
1001 1001 self.ns_table = {'user_global':self.user_module.__dict__,
1002 1002 'user_local':self.user_ns,
1003 1003 'builtin':builtin_mod.__dict__
1004 1004 }
1005 1005
1006 1006 @property
1007 1007 def user_global_ns(self):
1008 1008 return self.user_module.__dict__
1009 1009
1010 1010 def prepare_user_module(self, user_module=None, user_ns=None):
1011 1011 """Prepare the module and namespace in which user code will be run.
1012 1012
1013 1013 When IPython is started normally, both parameters are None: a new module
1014 1014 is created automatically, and its __dict__ used as the namespace.
1015 1015
1016 1016 If only user_module is provided, its __dict__ is used as the namespace.
1017 1017 If only user_ns is provided, a dummy module is created, and user_ns
1018 1018 becomes the global namespace. If both are provided (as they may be
1019 1019 when embedding), user_ns is the local namespace, and user_module
1020 1020 provides the global namespace.
1021 1021
1022 1022 Parameters
1023 1023 ----------
1024 1024 user_module : module, optional
1025 1025 The current user module in which IPython is being run. If None,
1026 1026 a clean module will be created.
1027 1027 user_ns : dict, optional
1028 1028 A namespace in which to run interactive commands.
1029 1029
1030 1030 Returns
1031 1031 -------
1032 1032 A tuple of user_module and user_ns, each properly initialised.
1033 1033 """
1034 1034 if user_module is None and user_ns is not None:
1035 1035 user_ns.setdefault("__name__", "__main__")
1036 1036 class DummyMod(object):
1037 1037 "A dummy module used for IPython's interactive namespace."
1038 1038 pass
1039 1039 user_module = DummyMod()
1040 1040 user_module.__dict__ = user_ns
1041 1041
1042 1042 if user_module is None:
1043 1043 user_module = types.ModuleType("__main__",
1044 1044 doc="Automatically created module for IPython interactive environment")
1045 1045
1046 1046 # We must ensure that __builtin__ (without the final 's') is always
1047 1047 # available and pointing to the __builtin__ *module*. For more details:
1048 1048 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1049 1049 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1050 1050 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1051 1051
1052 1052 if user_ns is None:
1053 1053 user_ns = user_module.__dict__
1054 1054
1055 1055 return user_module, user_ns
1056 1056
1057 1057 def init_sys_modules(self):
1058 1058 # We need to insert into sys.modules something that looks like a
1059 1059 # module but which accesses the IPython namespace, for shelve and
1060 1060 # pickle to work interactively. Normally they rely on getting
1061 1061 # everything out of __main__, but for embedding purposes each IPython
1062 1062 # instance has its own private namespace, so we can't go shoving
1063 1063 # everything into __main__.
1064 1064
1065 1065 # note, however, that we should only do this for non-embedded
1066 1066 # ipythons, which really mimic the __main__.__dict__ with their own
1067 1067 # namespace. Embedded instances, on the other hand, should not do
1068 1068 # this because they need to manage the user local/global namespaces
1069 1069 # only, but they live within a 'normal' __main__ (meaning, they
1070 1070 # shouldn't overtake the execution environment of the script they're
1071 1071 # embedded in).
1072 1072
1073 1073 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1074 1074 main_name = self.user_module.__name__
1075 1075 sys.modules[main_name] = self.user_module
1076 1076
1077 1077 def init_user_ns(self):
1078 1078 """Initialize all user-visible namespaces to their minimum defaults.
1079 1079
1080 1080 Certain history lists are also initialized here, as they effectively
1081 1081 act as user namespaces.
1082 1082
1083 1083 Notes
1084 1084 -----
1085 1085 All data structures here are only filled in, they are NOT reset by this
1086 1086 method. If they were not empty before, data will simply be added to
1087 1087 therm.
1088 1088 """
1089 1089 # This function works in two parts: first we put a few things in
1090 1090 # user_ns, and we sync that contents into user_ns_hidden so that these
1091 1091 # initial variables aren't shown by %who. After the sync, we add the
1092 1092 # rest of what we *do* want the user to see with %who even on a new
1093 1093 # session (probably nothing, so theye really only see their own stuff)
1094 1094
1095 1095 # The user dict must *always* have a __builtin__ reference to the
1096 1096 # Python standard __builtin__ namespace, which must be imported.
1097 1097 # This is so that certain operations in prompt evaluation can be
1098 1098 # reliably executed with builtins. Note that we can NOT use
1099 1099 # __builtins__ (note the 's'), because that can either be a dict or a
1100 1100 # module, and can even mutate at runtime, depending on the context
1101 1101 # (Python makes no guarantees on it). In contrast, __builtin__ is
1102 1102 # always a module object, though it must be explicitly imported.
1103 1103
1104 1104 # For more details:
1105 1105 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1106 1106 ns = dict()
1107 1107
1108 1108 # Put 'help' in the user namespace
1109 1109 try:
1110 1110 from site import _Helper
1111 1111 ns['help'] = _Helper()
1112 1112 except ImportError:
1113 1113 warn('help() not available - check site.py')
1114 1114
1115 1115 # make global variables for user access to the histories
1116 1116 ns['_ih'] = self.history_manager.input_hist_parsed
1117 1117 ns['_oh'] = self.history_manager.output_hist
1118 1118 ns['_dh'] = self.history_manager.dir_hist
1119 1119
1120 1120 ns['_sh'] = shadowns
1121 1121
1122 1122 # user aliases to input and output histories. These shouldn't show up
1123 1123 # in %who, as they can have very large reprs.
1124 1124 ns['In'] = self.history_manager.input_hist_parsed
1125 1125 ns['Out'] = self.history_manager.output_hist
1126 1126
1127 1127 # Store myself as the public api!!!
1128 1128 ns['get_ipython'] = self.get_ipython
1129 1129
1130 1130 ns['exit'] = self.exiter
1131 1131 ns['quit'] = self.exiter
1132 1132
1133 1133 # Sync what we've added so far to user_ns_hidden so these aren't seen
1134 1134 # by %who
1135 1135 self.user_ns_hidden.update(ns)
1136 1136
1137 1137 # Anything put into ns now would show up in %who. Think twice before
1138 1138 # putting anything here, as we really want %who to show the user their
1139 1139 # stuff, not our variables.
1140 1140
1141 1141 # Finally, update the real user's namespace
1142 1142 self.user_ns.update(ns)
1143 1143
1144 1144 @property
1145 1145 def all_ns_refs(self):
1146 1146 """Get a list of references to all the namespace dictionaries in which
1147 1147 IPython might store a user-created object.
1148 1148
1149 1149 Note that this does not include the displayhook, which also caches
1150 1150 objects from the output."""
1151 1151 return [self.user_ns, self.user_global_ns,
1152 1152 self._user_main_module.__dict__] + self._main_ns_cache.values()
1153 1153
1154 1154 def reset(self, new_session=True):
1155 1155 """Clear all internal namespaces, and attempt to release references to
1156 1156 user objects.
1157 1157
1158 1158 If new_session is True, a new history session will be opened.
1159 1159 """
1160 1160 # Clear histories
1161 1161 self.history_manager.reset(new_session)
1162 1162 # Reset counter used to index all histories
1163 1163 if new_session:
1164 1164 self.execution_count = 1
1165 1165
1166 1166 # Flush cached output items
1167 1167 if self.displayhook.do_full_cache:
1168 1168 self.displayhook.flush()
1169 1169
1170 1170 # The main execution namespaces must be cleared very carefully,
1171 1171 # skipping the deletion of the builtin-related keys, because doing so
1172 1172 # would cause errors in many object's __del__ methods.
1173 1173 if self.user_ns is not self.user_global_ns:
1174 1174 self.user_ns.clear()
1175 1175 ns = self.user_global_ns
1176 1176 drop_keys = set(ns.keys())
1177 1177 drop_keys.discard('__builtin__')
1178 1178 drop_keys.discard('__builtins__')
1179 1179 drop_keys.discard('__name__')
1180 1180 for k in drop_keys:
1181 1181 del ns[k]
1182 1182
1183 1183 self.user_ns_hidden.clear()
1184 1184
1185 1185 # Restore the user namespaces to minimal usability
1186 1186 self.init_user_ns()
1187 1187
1188 1188 # Restore the default and user aliases
1189 1189 self.alias_manager.clear_aliases()
1190 1190 self.alias_manager.init_aliases()
1191 1191
1192 1192 # Flush the private list of module references kept for script
1193 1193 # execution protection
1194 1194 self.clear_main_mod_cache()
1195 1195
1196 1196 # Clear out the namespace from the last %run
1197 1197 self.new_main_mod()
1198 1198
1199 1199 def del_var(self, varname, by_name=False):
1200 1200 """Delete a variable from the various namespaces, so that, as
1201 1201 far as possible, we're not keeping any hidden references to it.
1202 1202
1203 1203 Parameters
1204 1204 ----------
1205 1205 varname : str
1206 1206 The name of the variable to delete.
1207 1207 by_name : bool
1208 1208 If True, delete variables with the given name in each
1209 1209 namespace. If False (default), find the variable in the user
1210 1210 namespace, and delete references to it.
1211 1211 """
1212 1212 if varname in ('__builtin__', '__builtins__'):
1213 1213 raise ValueError("Refusing to delete %s" % varname)
1214 1214
1215 1215 ns_refs = self.all_ns_refs
1216 1216
1217 1217 if by_name: # Delete by name
1218 1218 for ns in ns_refs:
1219 1219 try:
1220 1220 del ns[varname]
1221 1221 except KeyError:
1222 1222 pass
1223 1223 else: # Delete by object
1224 1224 try:
1225 1225 obj = self.user_ns[varname]
1226 1226 except KeyError:
1227 1227 raise NameError("name '%s' is not defined" % varname)
1228 1228 # Also check in output history
1229 1229 ns_refs.append(self.history_manager.output_hist)
1230 1230 for ns in ns_refs:
1231 1231 to_delete = [n for n, o in ns.iteritems() if o is obj]
1232 1232 for name in to_delete:
1233 1233 del ns[name]
1234 1234
1235 1235 # displayhook keeps extra references, but not in a dictionary
1236 1236 for name in ('_', '__', '___'):
1237 1237 if getattr(self.displayhook, name) is obj:
1238 1238 setattr(self.displayhook, name, None)
1239 1239
1240 1240 def reset_selective(self, regex=None):
1241 1241 """Clear selective variables from internal namespaces based on a
1242 1242 specified regular expression.
1243 1243
1244 1244 Parameters
1245 1245 ----------
1246 1246 regex : string or compiled pattern, optional
1247 1247 A regular expression pattern that will be used in searching
1248 1248 variable names in the users namespaces.
1249 1249 """
1250 1250 if regex is not None:
1251 1251 try:
1252 1252 m = re.compile(regex)
1253 1253 except TypeError:
1254 1254 raise TypeError('regex must be a string or compiled pattern')
1255 1255 # Search for keys in each namespace that match the given regex
1256 1256 # If a match is found, delete the key/value pair.
1257 1257 for ns in self.all_ns_refs:
1258 1258 for var in ns:
1259 1259 if m.search(var):
1260 1260 del ns[var]
1261 1261
1262 1262 def push(self, variables, interactive=True):
1263 1263 """Inject a group of variables into the IPython user namespace.
1264 1264
1265 1265 Parameters
1266 1266 ----------
1267 1267 variables : dict, str or list/tuple of str
1268 1268 The variables to inject into the user's namespace. If a dict, a
1269 1269 simple update is done. If a str, the string is assumed to have
1270 1270 variable names separated by spaces. A list/tuple of str can also
1271 1271 be used to give the variable names. If just the variable names are
1272 1272 give (list/tuple/str) then the variable values looked up in the
1273 1273 callers frame.
1274 1274 interactive : bool
1275 1275 If True (default), the variables will be listed with the ``who``
1276 1276 magic.
1277 1277 """
1278 1278 vdict = None
1279 1279
1280 1280 # We need a dict of name/value pairs to do namespace updates.
1281 1281 if isinstance(variables, dict):
1282 1282 vdict = variables
1283 1283 elif isinstance(variables, (basestring, list, tuple)):
1284 1284 if isinstance(variables, basestring):
1285 1285 vlist = variables.split()
1286 1286 else:
1287 1287 vlist = variables
1288 1288 vdict = {}
1289 1289 cf = sys._getframe(1)
1290 1290 for name in vlist:
1291 1291 try:
1292 1292 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1293 1293 except:
1294 1294 print ('Could not get variable %s from %s' %
1295 1295 (name,cf.f_code.co_name))
1296 1296 else:
1297 1297 raise ValueError('variables must be a dict/str/list/tuple')
1298 1298
1299 1299 # Propagate variables to user namespace
1300 1300 self.user_ns.update(vdict)
1301 1301
1302 1302 # And configure interactive visibility
1303 1303 user_ns_hidden = self.user_ns_hidden
1304 1304 if interactive:
1305 1305 user_ns_hidden.difference_update(vdict)
1306 1306 else:
1307 1307 user_ns_hidden.update(vdict)
1308 1308
1309 1309 def drop_by_id(self, variables):
1310 1310 """Remove a dict of variables from the user namespace, if they are the
1311 1311 same as the values in the dictionary.
1312 1312
1313 1313 This is intended for use by extensions: variables that they've added can
1314 1314 be taken back out if they are unloaded, without removing any that the
1315 1315 user has overwritten.
1316 1316
1317 1317 Parameters
1318 1318 ----------
1319 1319 variables : dict
1320 1320 A dictionary mapping object names (as strings) to the objects.
1321 1321 """
1322 1322 for name, obj in variables.iteritems():
1323 1323 if name in self.user_ns and self.user_ns[name] is obj:
1324 1324 del self.user_ns[name]
1325 1325 self.user_ns_hidden.discard(name)
1326 1326
1327 1327 #-------------------------------------------------------------------------
1328 1328 # Things related to object introspection
1329 1329 #-------------------------------------------------------------------------
1330 1330
1331 1331 def _ofind(self, oname, namespaces=None):
1332 1332 """Find an object in the available namespaces.
1333 1333
1334 1334 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1335 1335
1336 1336 Has special code to detect magic functions.
1337 1337 """
1338 1338 oname = oname.strip()
1339 1339 #print '1- oname: <%r>' % oname # dbg
1340 1340 if not py3compat.isidentifier(oname.lstrip(ESC_MAGIC), dotted=True):
1341 1341 return dict(found=False)
1342 1342
1343 1343 alias_ns = None
1344 1344 if namespaces is None:
1345 1345 # Namespaces to search in:
1346 1346 # Put them in a list. The order is important so that we
1347 1347 # find things in the same order that Python finds them.
1348 1348 namespaces = [ ('Interactive', self.user_ns),
1349 1349 ('Interactive (global)', self.user_global_ns),
1350 1350 ('Python builtin', builtin_mod.__dict__),
1351 1351 ('Alias', self.alias_manager.alias_table),
1352 1352 ]
1353 1353 alias_ns = self.alias_manager.alias_table
1354 1354
1355 1355 # initialize results to 'null'
1356 1356 found = False; obj = None; ospace = None; ds = None;
1357 1357 ismagic = False; isalias = False; parent = None
1358 1358
1359 1359 # We need to special-case 'print', which as of python2.6 registers as a
1360 1360 # function but should only be treated as one if print_function was
1361 1361 # loaded with a future import. In this case, just bail.
1362 1362 if (oname == 'print' and not py3compat.PY3 and not \
1363 1363 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1364 1364 return {'found':found, 'obj':obj, 'namespace':ospace,
1365 1365 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1366 1366
1367 1367 # Look for the given name by splitting it in parts. If the head is
1368 1368 # found, then we look for all the remaining parts as members, and only
1369 1369 # declare success if we can find them all.
1370 1370 oname_parts = oname.split('.')
1371 1371 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1372 1372 for nsname,ns in namespaces:
1373 1373 try:
1374 1374 obj = ns[oname_head]
1375 1375 except KeyError:
1376 1376 continue
1377 1377 else:
1378 1378 #print 'oname_rest:', oname_rest # dbg
1379 1379 for part in oname_rest:
1380 1380 try:
1381 1381 parent = obj
1382 1382 obj = getattr(obj,part)
1383 1383 except:
1384 1384 # Blanket except b/c some badly implemented objects
1385 1385 # allow __getattr__ to raise exceptions other than
1386 1386 # AttributeError, which then crashes IPython.
1387 1387 break
1388 1388 else:
1389 1389 # If we finish the for loop (no break), we got all members
1390 1390 found = True
1391 1391 ospace = nsname
1392 1392 if ns == alias_ns:
1393 1393 isalias = True
1394 1394 break # namespace loop
1395 1395
1396 1396 # Try to see if it's magic
1397 1397 if not found:
1398 1398 if oname.startswith(ESC_MAGIC):
1399 1399 oname = oname[1:]
1400 1400 obj = self.find_magic(oname)
1401 1401 if obj is not None:
1402 1402 found = True
1403 1403 ospace = 'IPython internal'
1404 1404 ismagic = True
1405 1405
1406 1406 # Last try: special-case some literals like '', [], {}, etc:
1407 1407 if not found and oname_head in ["''",'""','[]','{}','()']:
1408 1408 obj = eval(oname_head)
1409 1409 found = True
1410 1410 ospace = 'Interactive'
1411 1411
1412 1412 return {'found':found, 'obj':obj, 'namespace':ospace,
1413 1413 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1414 1414
1415 1415 def _ofind_property(self, oname, info):
1416 1416 """Second part of object finding, to look for property details."""
1417 1417 if info.found:
1418 1418 # Get the docstring of the class property if it exists.
1419 1419 path = oname.split('.')
1420 1420 root = '.'.join(path[:-1])
1421 1421 if info.parent is not None:
1422 1422 try:
1423 1423 target = getattr(info.parent, '__class__')
1424 1424 # The object belongs to a class instance.
1425 1425 try:
1426 1426 target = getattr(target, path[-1])
1427 1427 # The class defines the object.
1428 1428 if isinstance(target, property):
1429 1429 oname = root + '.__class__.' + path[-1]
1430 1430 info = Struct(self._ofind(oname))
1431 1431 except AttributeError: pass
1432 1432 except AttributeError: pass
1433 1433
1434 1434 # We return either the new info or the unmodified input if the object
1435 1435 # hadn't been found
1436 1436 return info
1437 1437
1438 1438 def _object_find(self, oname, namespaces=None):
1439 1439 """Find an object and return a struct with info about it."""
1440 1440 inf = Struct(self._ofind(oname, namespaces))
1441 1441 return Struct(self._ofind_property(oname, inf))
1442 1442
1443 1443 def _inspect(self, meth, oname, namespaces=None, **kw):
1444 1444 """Generic interface to the inspector system.
1445 1445
1446 1446 This function is meant to be called by pdef, pdoc & friends."""
1447 1447 info = self._object_find(oname)
1448 1448 if info.found:
1449 1449 pmethod = getattr(self.inspector, meth)
1450 1450 formatter = format_screen if info.ismagic else None
1451 1451 if meth == 'pdoc':
1452 1452 pmethod(info.obj, oname, formatter)
1453 1453 elif meth == 'pinfo':
1454 1454 pmethod(info.obj, oname, formatter, info, **kw)
1455 1455 else:
1456 1456 pmethod(info.obj, oname)
1457 1457 else:
1458 1458 print 'Object `%s` not found.' % oname
1459 1459 return 'not found' # so callers can take other action
1460 1460
1461 1461 def object_inspect(self, oname, detail_level=0):
1462 1462 with self.builtin_trap:
1463 1463 info = self._object_find(oname)
1464 1464 if info.found:
1465 1465 return self.inspector.info(info.obj, oname, info=info,
1466 1466 detail_level=detail_level
1467 1467 )
1468 1468 else:
1469 1469 return oinspect.object_info(name=oname, found=False)
1470 1470
1471 1471 #-------------------------------------------------------------------------
1472 1472 # Things related to history management
1473 1473 #-------------------------------------------------------------------------
1474 1474
1475 1475 def init_history(self):
1476 1476 """Sets up the command history, and starts regular autosaves."""
1477 1477 self.history_manager = HistoryManager(shell=self, config=self.config)
1478 1478 self.configurables.append(self.history_manager)
1479 1479
1480 1480 #-------------------------------------------------------------------------
1481 1481 # Things related to exception handling and tracebacks (not debugging)
1482 1482 #-------------------------------------------------------------------------
1483 1483
1484 1484 def init_traceback_handlers(self, custom_exceptions):
1485 1485 # Syntax error handler.
1486 1486 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1487 1487
1488 1488 # The interactive one is initialized with an offset, meaning we always
1489 1489 # want to remove the topmost item in the traceback, which is our own
1490 1490 # internal code. Valid modes: ['Plain','Context','Verbose']
1491 1491 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1492 1492 color_scheme='NoColor',
1493 1493 tb_offset = 1,
1494 1494 check_cache=self.compile.check_cache)
1495 1495
1496 1496 # The instance will store a pointer to the system-wide exception hook,
1497 1497 # so that runtime code (such as magics) can access it. This is because
1498 1498 # during the read-eval loop, it may get temporarily overwritten.
1499 1499 self.sys_excepthook = sys.excepthook
1500 1500
1501 1501 # and add any custom exception handlers the user may have specified
1502 1502 self.set_custom_exc(*custom_exceptions)
1503 1503
1504 1504 # Set the exception mode
1505 1505 self.InteractiveTB.set_mode(mode=self.xmode)
1506 1506
1507 1507 def set_custom_exc(self, exc_tuple, handler):
1508 1508 """set_custom_exc(exc_tuple,handler)
1509 1509
1510 1510 Set a custom exception handler, which will be called if any of the
1511 1511 exceptions in exc_tuple occur in the mainloop (specifically, in the
1512 1512 run_code() method).
1513 1513
1514 1514 Parameters
1515 1515 ----------
1516 1516
1517 1517 exc_tuple : tuple of exception classes
1518 1518 A *tuple* of exception classes, for which to call the defined
1519 1519 handler. It is very important that you use a tuple, and NOT A
1520 1520 LIST here, because of the way Python's except statement works. If
1521 1521 you only want to trap a single exception, use a singleton tuple::
1522 1522
1523 1523 exc_tuple == (MyCustomException,)
1524 1524
1525 1525 handler : callable
1526 1526 handler must have the following signature::
1527 1527
1528 1528 def my_handler(self, etype, value, tb, tb_offset=None):
1529 1529 ...
1530 1530 return structured_traceback
1531 1531
1532 1532 Your handler must return a structured traceback (a list of strings),
1533 1533 or None.
1534 1534
1535 1535 This will be made into an instance method (via types.MethodType)
1536 1536 of IPython itself, and it will be called if any of the exceptions
1537 1537 listed in the exc_tuple are caught. If the handler is None, an
1538 1538 internal basic one is used, which just prints basic info.
1539 1539
1540 1540 To protect IPython from crashes, if your handler ever raises an
1541 1541 exception or returns an invalid result, it will be immediately
1542 1542 disabled.
1543 1543
1544 1544 WARNING: by putting in your own exception handler into IPython's main
1545 1545 execution loop, you run a very good chance of nasty crashes. This
1546 1546 facility should only be used if you really know what you are doing."""
1547 1547
1548 1548 assert type(exc_tuple)==type(()) , \
1549 1549 "The custom exceptions must be given AS A TUPLE."
1550 1550
1551 1551 def dummy_handler(self,etype,value,tb,tb_offset=None):
1552 1552 print '*** Simple custom exception handler ***'
1553 1553 print 'Exception type :',etype
1554 1554 print 'Exception value:',value
1555 1555 print 'Traceback :',tb
1556 1556 #print 'Source code :','\n'.join(self.buffer)
1557 1557
1558 1558 def validate_stb(stb):
1559 1559 """validate structured traceback return type
1560 1560
1561 1561 return type of CustomTB *should* be a list of strings, but allow
1562 1562 single strings or None, which are harmless.
1563 1563
1564 1564 This function will *always* return a list of strings,
1565 1565 and will raise a TypeError if stb is inappropriate.
1566 1566 """
1567 1567 msg = "CustomTB must return list of strings, not %r" % stb
1568 1568 if stb is None:
1569 1569 return []
1570 1570 elif isinstance(stb, basestring):
1571 1571 return [stb]
1572 1572 elif not isinstance(stb, list):
1573 1573 raise TypeError(msg)
1574 1574 # it's a list
1575 1575 for line in stb:
1576 1576 # check every element
1577 1577 if not isinstance(line, basestring):
1578 1578 raise TypeError(msg)
1579 1579 return stb
1580 1580
1581 1581 if handler is None:
1582 1582 wrapped = dummy_handler
1583 1583 else:
1584 1584 def wrapped(self,etype,value,tb,tb_offset=None):
1585 1585 """wrap CustomTB handler, to protect IPython from user code
1586 1586
1587 1587 This makes it harder (but not impossible) for custom exception
1588 1588 handlers to crash IPython.
1589 1589 """
1590 1590 try:
1591 1591 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1592 1592 return validate_stb(stb)
1593 1593 except:
1594 1594 # clear custom handler immediately
1595 1595 self.set_custom_exc((), None)
1596 1596 print >> io.stderr, "Custom TB Handler failed, unregistering"
1597 1597 # show the exception in handler first
1598 1598 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1599 1599 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1600 1600 print >> io.stdout, "The original exception:"
1601 1601 stb = self.InteractiveTB.structured_traceback(
1602 1602 (etype,value,tb), tb_offset=tb_offset
1603 1603 )
1604 1604 return stb
1605 1605
1606 1606 self.CustomTB = types.MethodType(wrapped,self)
1607 1607 self.custom_exceptions = exc_tuple
1608 1608
1609 1609 def excepthook(self, etype, value, tb):
1610 1610 """One more defense for GUI apps that call sys.excepthook.
1611 1611
1612 1612 GUI frameworks like wxPython trap exceptions and call
1613 1613 sys.excepthook themselves. I guess this is a feature that
1614 1614 enables them to keep running after exceptions that would
1615 1615 otherwise kill their mainloop. This is a bother for IPython
1616 1616 which excepts to catch all of the program exceptions with a try:
1617 1617 except: statement.
1618 1618
1619 1619 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1620 1620 any app directly invokes sys.excepthook, it will look to the user like
1621 1621 IPython crashed. In order to work around this, we can disable the
1622 1622 CrashHandler and replace it with this excepthook instead, which prints a
1623 1623 regular traceback using our InteractiveTB. In this fashion, apps which
1624 1624 call sys.excepthook will generate a regular-looking exception from
1625 1625 IPython, and the CrashHandler will only be triggered by real IPython
1626 1626 crashes.
1627 1627
1628 1628 This hook should be used sparingly, only in places which are not likely
1629 1629 to be true IPython errors.
1630 1630 """
1631 1631 self.showtraceback((etype,value,tb),tb_offset=0)
1632 1632
1633 1633 def _get_exc_info(self, exc_tuple=None):
1634 1634 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1635 1635
1636 1636 Ensures sys.last_type,value,traceback hold the exc_info we found,
1637 1637 from whichever source.
1638 1638
1639 1639 raises ValueError if none of these contain any information
1640 1640 """
1641 1641 if exc_tuple is None:
1642 1642 etype, value, tb = sys.exc_info()
1643 1643 else:
1644 1644 etype, value, tb = exc_tuple
1645 1645
1646 1646 if etype is None:
1647 1647 if hasattr(sys, 'last_type'):
1648 1648 etype, value, tb = sys.last_type, sys.last_value, \
1649 1649 sys.last_traceback
1650 1650
1651 1651 if etype is None:
1652 1652 raise ValueError("No exception to find")
1653 1653
1654 1654 # Now store the exception info in sys.last_type etc.
1655 1655 # WARNING: these variables are somewhat deprecated and not
1656 1656 # necessarily safe to use in a threaded environment, but tools
1657 1657 # like pdb depend on their existence, so let's set them. If we
1658 1658 # find problems in the field, we'll need to revisit their use.
1659 1659 sys.last_type = etype
1660 1660 sys.last_value = value
1661 1661 sys.last_traceback = tb
1662 1662
1663 1663 return etype, value, tb
1664 1664
1665 1665
1666 1666 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1667 1667 exception_only=False):
1668 1668 """Display the exception that just occurred.
1669 1669
1670 1670 If nothing is known about the exception, this is the method which
1671 1671 should be used throughout the code for presenting user tracebacks,
1672 1672 rather than directly invoking the InteractiveTB object.
1673 1673
1674 1674 A specific showsyntaxerror() also exists, but this method can take
1675 1675 care of calling it if needed, so unless you are explicitly catching a
1676 1676 SyntaxError exception, don't try to analyze the stack manually and
1677 1677 simply call this method."""
1678 1678
1679 1679 try:
1680 1680 try:
1681 1681 etype, value, tb = self._get_exc_info(exc_tuple)
1682 1682 except ValueError:
1683 1683 self.write_err('No traceback available to show.\n')
1684 1684 return
1685 1685
1686 1686 if etype is SyntaxError:
1687 1687 # Though this won't be called by syntax errors in the input
1688 1688 # line, there may be SyntaxError cases with imported code.
1689 1689 self.showsyntaxerror(filename)
1690 1690 elif etype is UsageError:
1691 1691 self.write_err("UsageError: %s" % value)
1692 1692 else:
1693 1693 if etype in self.custom_exceptions:
1694 1694 stb = self.CustomTB(etype, value, tb, tb_offset)
1695 1695 else:
1696 1696 if exception_only:
1697 1697 stb = ['An exception has occurred, use %tb to see '
1698 1698 'the full traceback.\n']
1699 1699 stb.extend(self.InteractiveTB.get_exception_only(etype,
1700 1700 value))
1701 1701 else:
1702 1702 stb = self.InteractiveTB.structured_traceback(etype,
1703 1703 value, tb, tb_offset=tb_offset)
1704 1704
1705 1705 self._showtraceback(etype, value, stb)
1706 1706 if self.call_pdb:
1707 1707 # drop into debugger
1708 1708 self.debugger(force=True)
1709 1709 return
1710 1710
1711 1711 # Actually show the traceback
1712 1712 self._showtraceback(etype, value, stb)
1713 1713
1714 1714 except KeyboardInterrupt:
1715 1715 self.write_err("\nKeyboardInterrupt\n")
1716 1716
1717 1717 def _showtraceback(self, etype, evalue, stb):
1718 1718 """Actually show a traceback.
1719 1719
1720 1720 Subclasses may override this method to put the traceback on a different
1721 1721 place, like a side channel.
1722 1722 """
1723 1723 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1724 1724
1725 1725 def showsyntaxerror(self, filename=None):
1726 1726 """Display the syntax error that just occurred.
1727 1727
1728 1728 This doesn't display a stack trace because there isn't one.
1729 1729
1730 1730 If a filename is given, it is stuffed in the exception instead
1731 1731 of what was there before (because Python's parser always uses
1732 1732 "<string>" when reading from a string).
1733 1733 """
1734 1734 etype, value, last_traceback = self._get_exc_info()
1735 1735
1736 1736 if filename and etype is SyntaxError:
1737 1737 try:
1738 1738 value.filename = filename
1739 1739 except:
1740 1740 # Not the format we expect; leave it alone
1741 1741 pass
1742 1742
1743 1743 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1744 1744 self._showtraceback(etype, value, stb)
1745 1745
1746 1746 # This is overridden in TerminalInteractiveShell to show a message about
1747 1747 # the %paste magic.
1748 1748 def showindentationerror(self):
1749 1749 """Called by run_cell when there's an IndentationError in code entered
1750 1750 at the prompt.
1751 1751
1752 1752 This is overridden in TerminalInteractiveShell to show a message about
1753 1753 the %paste magic."""
1754 1754 self.showsyntaxerror()
1755 1755
1756 1756 #-------------------------------------------------------------------------
1757 1757 # Things related to readline
1758 1758 #-------------------------------------------------------------------------
1759 1759
1760 1760 def init_readline(self):
1761 1761 """Command history completion/saving/reloading."""
1762 1762
1763 1763 if self.readline_use:
1764 1764 import IPython.utils.rlineimpl as readline
1765 1765
1766 1766 self.rl_next_input = None
1767 1767 self.rl_do_indent = False
1768 1768
1769 1769 if not self.readline_use or not readline.have_readline:
1770 1770 self.has_readline = False
1771 1771 self.readline = None
1772 1772 # Set a number of methods that depend on readline to be no-op
1773 1773 self.readline_no_record = no_op_context
1774 1774 self.set_readline_completer = no_op
1775 1775 self.set_custom_completer = no_op
1776 1776 self.set_completer_frame = no_op
1777 1777 if self.readline_use:
1778 1778 warn('Readline services not available or not loaded.')
1779 1779 else:
1780 1780 self.has_readline = True
1781 1781 self.readline = readline
1782 1782 sys.modules['readline'] = readline
1783 1783
1784 1784 # Platform-specific configuration
1785 1785 if os.name == 'nt':
1786 1786 # FIXME - check with Frederick to see if we can harmonize
1787 1787 # naming conventions with pyreadline to avoid this
1788 1788 # platform-dependent check
1789 1789 self.readline_startup_hook = readline.set_pre_input_hook
1790 1790 else:
1791 1791 self.readline_startup_hook = readline.set_startup_hook
1792 1792
1793 1793 # Load user's initrc file (readline config)
1794 1794 # Or if libedit is used, load editrc.
1795 1795 inputrc_name = os.environ.get('INPUTRC')
1796 1796 if inputrc_name is None:
1797 1797 inputrc_name = '.inputrc'
1798 1798 if readline.uses_libedit:
1799 1799 inputrc_name = '.editrc'
1800 1800 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1801 1801 if os.path.isfile(inputrc_name):
1802 1802 try:
1803 1803 readline.read_init_file(inputrc_name)
1804 1804 except:
1805 1805 warn('Problems reading readline initialization file <%s>'
1806 1806 % inputrc_name)
1807 1807
1808 1808 # Configure readline according to user's prefs
1809 1809 # This is only done if GNU readline is being used. If libedit
1810 1810 # is being used (as on Leopard) the readline config is
1811 1811 # not run as the syntax for libedit is different.
1812 1812 if not readline.uses_libedit:
1813 1813 for rlcommand in self.readline_parse_and_bind:
1814 1814 #print "loading rl:",rlcommand # dbg
1815 1815 readline.parse_and_bind(rlcommand)
1816 1816
1817 1817 # Remove some chars from the delimiters list. If we encounter
1818 1818 # unicode chars, discard them.
1819 1819 delims = readline.get_completer_delims()
1820 1820 if not py3compat.PY3:
1821 1821 delims = delims.encode("ascii", "ignore")
1822 1822 for d in self.readline_remove_delims:
1823 1823 delims = delims.replace(d, "")
1824 1824 delims = delims.replace(ESC_MAGIC, '')
1825 1825 readline.set_completer_delims(delims)
1826 1826 # otherwise we end up with a monster history after a while:
1827 1827 readline.set_history_length(self.history_length)
1828 1828
1829 1829 self.refill_readline_hist()
1830 1830 self.readline_no_record = ReadlineNoRecord(self)
1831 1831
1832 1832 # Configure auto-indent for all platforms
1833 1833 self.set_autoindent(self.autoindent)
1834 1834
1835 1835 def refill_readline_hist(self):
1836 1836 # Load the last 1000 lines from history
1837 1837 self.readline.clear_history()
1838 1838 stdin_encoding = sys.stdin.encoding or "utf-8"
1839 1839 last_cell = u""
1840 1840 for _, _, cell in self.history_manager.get_tail(1000,
1841 1841 include_latest=True):
1842 1842 # Ignore blank lines and consecutive duplicates
1843 1843 cell = cell.rstrip()
1844 1844 if cell and (cell != last_cell):
1845 1845 if self.multiline_history:
1846 1846 self.readline.add_history(py3compat.unicode_to_str(cell,
1847 1847 stdin_encoding))
1848 1848 else:
1849 1849 for line in cell.splitlines():
1850 1850 self.readline.add_history(py3compat.unicode_to_str(line,
1851 1851 stdin_encoding))
1852 1852 last_cell = cell
1853 1853
1854 1854 def set_next_input(self, s):
1855 1855 """ Sets the 'default' input string for the next command line.
1856 1856
1857 1857 Requires readline.
1858 1858
1859 1859 Example:
1860 1860
1861 1861 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1862 1862 [D:\ipython]|2> Hello Word_ # cursor is here
1863 1863 """
1864 1864 self.rl_next_input = py3compat.cast_bytes_py2(s)
1865 1865
1866 1866 # Maybe move this to the terminal subclass?
1867 1867 def pre_readline(self):
1868 1868 """readline hook to be used at the start of each line.
1869 1869
1870 1870 Currently it handles auto-indent only."""
1871 1871
1872 1872 if self.rl_do_indent:
1873 1873 self.readline.insert_text(self._indent_current_str())
1874 1874 if self.rl_next_input is not None:
1875 1875 self.readline.insert_text(self.rl_next_input)
1876 1876 self.rl_next_input = None
1877 1877
1878 1878 def _indent_current_str(self):
1879 1879 """return the current level of indentation as a string"""
1880 1880 return self.input_splitter.indent_spaces * ' '
1881 1881
1882 1882 #-------------------------------------------------------------------------
1883 1883 # Things related to text completion
1884 1884 #-------------------------------------------------------------------------
1885 1885
1886 1886 def init_completer(self):
1887 1887 """Initialize the completion machinery.
1888 1888
1889 1889 This creates completion machinery that can be used by client code,
1890 1890 either interactively in-process (typically triggered by the readline
1891 1891 library), programatically (such as in test suites) or out-of-prcess
1892 1892 (typically over the network by remote frontends).
1893 1893 """
1894 1894 from IPython.core.completer import IPCompleter
1895 1895 from IPython.core.completerlib import (module_completer,
1896 1896 magic_run_completer, cd_completer, reset_completer)
1897 1897
1898 1898 self.Completer = IPCompleter(shell=self,
1899 1899 namespace=self.user_ns,
1900 1900 global_namespace=self.user_global_ns,
1901 1901 alias_table=self.alias_manager.alias_table,
1902 1902 use_readline=self.has_readline,
1903 1903 config=self.config,
1904 1904 )
1905 1905 self.configurables.append(self.Completer)
1906 1906
1907 1907 # Add custom completers to the basic ones built into IPCompleter
1908 1908 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1909 1909 self.strdispatchers['complete_command'] = sdisp
1910 1910 self.Completer.custom_completers = sdisp
1911 1911
1912 1912 self.set_hook('complete_command', module_completer, str_key = 'import')
1913 1913 self.set_hook('complete_command', module_completer, str_key = 'from')
1914 1914 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1915 1915 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1916 1916 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1917 1917
1918 1918 # Only configure readline if we truly are using readline. IPython can
1919 1919 # do tab-completion over the network, in GUIs, etc, where readline
1920 1920 # itself may be absent
1921 1921 if self.has_readline:
1922 1922 self.set_readline_completer()
1923 1923
1924 1924 def complete(self, text, line=None, cursor_pos=None):
1925 1925 """Return the completed text and a list of completions.
1926 1926
1927 1927 Parameters
1928 1928 ----------
1929 1929
1930 1930 text : string
1931 1931 A string of text to be completed on. It can be given as empty and
1932 1932 instead a line/position pair are given. In this case, the
1933 1933 completer itself will split the line like readline does.
1934 1934
1935 1935 line : string, optional
1936 1936 The complete line that text is part of.
1937 1937
1938 1938 cursor_pos : int, optional
1939 1939 The position of the cursor on the input line.
1940 1940
1941 1941 Returns
1942 1942 -------
1943 1943 text : string
1944 1944 The actual text that was completed.
1945 1945
1946 1946 matches : list
1947 1947 A sorted list with all possible completions.
1948 1948
1949 1949 The optional arguments allow the completion to take more context into
1950 1950 account, and are part of the low-level completion API.
1951 1951
1952 1952 This is a wrapper around the completion mechanism, similar to what
1953 1953 readline does at the command line when the TAB key is hit. By
1954 1954 exposing it as a method, it can be used by other non-readline
1955 1955 environments (such as GUIs) for text completion.
1956 1956
1957 1957 Simple usage example:
1958 1958
1959 1959 In [1]: x = 'hello'
1960 1960
1961 1961 In [2]: _ip.complete('x.l')
1962 1962 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1963 1963 """
1964 1964
1965 1965 # Inject names into __builtin__ so we can complete on the added names.
1966 1966 with self.builtin_trap:
1967 1967 return self.Completer.complete(text, line, cursor_pos)
1968 1968
1969 1969 def set_custom_completer(self, completer, pos=0):
1970 1970 """Adds a new custom completer function.
1971 1971
1972 1972 The position argument (defaults to 0) is the index in the completers
1973 1973 list where you want the completer to be inserted."""
1974 1974
1975 1975 newcomp = types.MethodType(completer,self.Completer)
1976 1976 self.Completer.matchers.insert(pos,newcomp)
1977 1977
1978 1978 def set_readline_completer(self):
1979 1979 """Reset readline's completer to be our own."""
1980 1980 self.readline.set_completer(self.Completer.rlcomplete)
1981 1981
1982 1982 def set_completer_frame(self, frame=None):
1983 1983 """Set the frame of the completer."""
1984 1984 if frame:
1985 1985 self.Completer.namespace = frame.f_locals
1986 1986 self.Completer.global_namespace = frame.f_globals
1987 1987 else:
1988 1988 self.Completer.namespace = self.user_ns
1989 1989 self.Completer.global_namespace = self.user_global_ns
1990 1990
1991 1991 #-------------------------------------------------------------------------
1992 1992 # Things related to magics
1993 1993 #-------------------------------------------------------------------------
1994 1994
1995 1995 def init_magics(self):
1996 1996 from IPython.core import magics as m
1997 1997 self.magics_manager = magic.MagicsManager(shell=self,
1998 1998 confg=self.config,
1999 1999 user_magics=m.UserMagics(self))
2000 2000 self.configurables.append(self.magics_manager)
2001 2001
2002 2002 # Expose as public API from the magics manager
2003 2003 self.register_magics = self.magics_manager.register
2004 2004 self.register_magic_function = self.magics_manager.register_function
2005 2005 self.define_magic = self.magics_manager.define_magic
2006 2006
2007 2007 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2008 2008 m.ConfigMagics, m.DeprecatedMagics, m.ExecutionMagics,
2009 2009 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2010 2010 m.NamespaceMagics, m.OSMagics, m.PylabMagics )
2011 2011
2012 2012 # FIXME: Move the color initialization to the DisplayHook, which
2013 2013 # should be split into a prompt manager and displayhook. We probably
2014 2014 # even need a centralize colors management object.
2015 2015 self.magic('colors %s' % self.colors)
2016 2016
2017 def line_magic(self, magic_name, line, next_input=None):
2017 def line_magic(self, magic_name, line):
2018 2018 """Execute the given line magic.
2019 2019
2020 2020 Parameters
2021 2021 ----------
2022 2022 magic_name : str
2023 2023 Name of the desired magic function, without '%' prefix.
2024 2024
2025 2025 line : str
2026 2026 The rest of the input line as a single string.
2027
2028 next_input : str, optional
2029 Text to pre-load into the next input line.
2030 2027 """
2031 # Allow setting the next input - this is used if the user does `a=abs?`.
2032 # We do this first so that magic functions can override it.
2033 if next_input:
2034 self.set_next_input(next_input)
2035
2036 2028 fn = self.find_line_magic(magic_name)
2037 2029 if fn is None:
2038 2030 error("Magic function `%s` not found." % magic_name)
2039 2031 else:
2040 2032 # Note: this is the distance in the stack to the user's frame.
2041 2033 # This will need to be updated if the internal calling logic gets
2042 2034 # refactored, or else we'll be expanding the wrong variables.
2043 2035 stack_depth = 2
2044 2036 magic_arg_s = self.var_expand(line, stack_depth)
2045 2037 # Put magic args in a list so we can call with f(*a) syntax
2046 2038 args = [magic_arg_s]
2047 2039 # Grab local namespace if we need it:
2048 2040 if getattr(fn, "needs_local_scope", False):
2049 2041 args.append(sys._getframe(stack_depth).f_locals)
2050 2042 with self.builtin_trap:
2051 2043 result = fn(*args)
2052 2044 return result
2053 2045
2054 2046 def cell_magic(self, magic_name, line, cell):
2055 2047 """Execute the given cell magic.
2056 2048 """
2057 2049 fn = self.find_cell_magic(magic_name)
2058 2050 if fn is None:
2059 2051 error("Magic function `%s` not found." % magic_name)
2060 2052 else:
2061 2053 # Note: this is the distance in the stack to the user's frame.
2062 2054 # This will need to be updated if the internal calling logic gets
2063 2055 # refactored, or else we'll be expanding the wrong variables.
2064 2056 stack_depth = 2
2065 2057 magic_arg_s = self.var_expand(line, stack_depth)
2066 2058 with self.builtin_trap:
2067 2059 result = fn(line, cell)
2068 2060 return result
2069 2061
2070 2062 def find_line_magic(self, magic_name):
2071 2063 """Find and return a line magic by name.
2072 2064
2073 2065 Returns None if the magic isn't found."""
2074 2066 return self.magics_manager.magics['line'].get(magic_name)
2075 2067
2076 2068 def find_cell_magic(self, magic_name):
2077 2069 """Find and return a cell magic by name.
2078 2070
2079 2071 Returns None if the magic isn't found."""
2080 2072 return self.magics_manager.magics['cell'].get(magic_name)
2081 2073
2082 def find_magic(self, magic_name, magic_type='line'):
2074 def find_magic(self, magic_name, magic_kind='line'):
2083 2075 """Find and return a magic of the given type by name.
2084 2076
2085 2077 Returns None if the magic isn't found."""
2086 return self.magics_manager.magics[magic_type].get(magic_name)
2078 return self.magics_manager.magics[magic_kind].get(magic_name)
2087 2079
2088 def magic(self, arg_s, next_input=None):
2080 def magic(self, arg_s):
2089 2081 """DEPRECATED. Use line_magic() instead.
2090 2082
2091 2083 Call a magic function by name.
2092 2084
2093 2085 Input: a string containing the name of the magic function to call and
2094 2086 any additional arguments to be passed to the magic.
2095 2087
2096 2088 magic('name -opt foo bar') is equivalent to typing at the ipython
2097 2089 prompt:
2098 2090
2099 2091 In[1]: %name -opt foo bar
2100 2092
2101 2093 To call a magic without arguments, simply use magic('name').
2102 2094
2103 2095 This provides a proper Python function to call IPython's magics in any
2104 2096 valid Python code you can type at the interpreter, including loops and
2105 2097 compound statements.
2106 2098 """
2107 2099 # TODO: should we issue a loud deprecation warning here?
2108 2100 magic_name, _, magic_arg_s = arg_s.partition(' ')
2109 2101 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2110 return self.line_magic(magic_name, magic_arg_s, next_input)
2102 return self.line_magic(magic_name, magic_arg_s)
2111 2103
2112 2104 #-------------------------------------------------------------------------
2113 2105 # Things related to macros
2114 2106 #-------------------------------------------------------------------------
2115 2107
2116 2108 def define_macro(self, name, themacro):
2117 2109 """Define a new macro
2118 2110
2119 2111 Parameters
2120 2112 ----------
2121 2113 name : str
2122 2114 The name of the macro.
2123 2115 themacro : str or Macro
2124 2116 The action to do upon invoking the macro. If a string, a new
2125 2117 Macro object is created by passing the string to it.
2126 2118 """
2127 2119
2128 2120 from IPython.core import macro
2129 2121
2130 2122 if isinstance(themacro, basestring):
2131 2123 themacro = macro.Macro(themacro)
2132 2124 if not isinstance(themacro, macro.Macro):
2133 2125 raise ValueError('A macro must be a string or a Macro instance.')
2134 2126 self.user_ns[name] = themacro
2135 2127
2136 2128 #-------------------------------------------------------------------------
2137 2129 # Things related to the running of system commands
2138 2130 #-------------------------------------------------------------------------
2139 2131
2140 2132 def system_piped(self, cmd):
2141 2133 """Call the given cmd in a subprocess, piping stdout/err
2142 2134
2143 2135 Parameters
2144 2136 ----------
2145 2137 cmd : str
2146 2138 Command to execute (can not end in '&', as background processes are
2147 2139 not supported. Should not be a command that expects input
2148 2140 other than simple text.
2149 2141 """
2150 2142 if cmd.rstrip().endswith('&'):
2151 2143 # this is *far* from a rigorous test
2152 2144 # We do not support backgrounding processes because we either use
2153 2145 # pexpect or pipes to read from. Users can always just call
2154 2146 # os.system() or use ip.system=ip.system_raw
2155 2147 # if they really want a background process.
2156 2148 raise OSError("Background processes not supported.")
2157 2149
2158 2150 # we explicitly do NOT return the subprocess status code, because
2159 2151 # a non-None value would trigger :func:`sys.displayhook` calls.
2160 2152 # Instead, we store the exit_code in user_ns.
2161 2153 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
2162 2154
2163 2155 def system_raw(self, cmd):
2164 2156 """Call the given cmd in a subprocess using os.system
2165 2157
2166 2158 Parameters
2167 2159 ----------
2168 2160 cmd : str
2169 2161 Command to execute.
2170 2162 """
2171 2163 cmd = self.var_expand(cmd, depth=2)
2172 2164 # protect os.system from UNC paths on Windows, which it can't handle:
2173 2165 if sys.platform == 'win32':
2174 2166 from IPython.utils._process_win32 import AvoidUNCPath
2175 2167 with AvoidUNCPath() as path:
2176 2168 if path is not None:
2177 2169 cmd = '"pushd %s &&"%s' % (path, cmd)
2178 2170 cmd = py3compat.unicode_to_str(cmd)
2179 2171 ec = os.system(cmd)
2180 2172 else:
2181 2173 cmd = py3compat.unicode_to_str(cmd)
2182 2174 ec = os.system(cmd)
2183 2175
2184 2176 # We explicitly do NOT return the subprocess status code, because
2185 2177 # a non-None value would trigger :func:`sys.displayhook` calls.
2186 2178 # Instead, we store the exit_code in user_ns.
2187 2179 self.user_ns['_exit_code'] = ec
2188 2180
2189 2181 # use piped system by default, because it is better behaved
2190 2182 system = system_piped
2191 2183
2192 2184 def getoutput(self, cmd, split=True):
2193 2185 """Get output (possibly including stderr) from a subprocess.
2194 2186
2195 2187 Parameters
2196 2188 ----------
2197 2189 cmd : str
2198 2190 Command to execute (can not end in '&', as background processes are
2199 2191 not supported.
2200 2192 split : bool, optional
2201 2193
2202 2194 If True, split the output into an IPython SList. Otherwise, an
2203 2195 IPython LSString is returned. These are objects similar to normal
2204 2196 lists and strings, with a few convenience attributes for easier
2205 2197 manipulation of line-based output. You can use '?' on them for
2206 2198 details.
2207 2199 """
2208 2200 if cmd.rstrip().endswith('&'):
2209 2201 # this is *far* from a rigorous test
2210 2202 raise OSError("Background processes not supported.")
2211 2203 out = getoutput(self.var_expand(cmd, depth=2))
2212 2204 if split:
2213 2205 out = SList(out.splitlines())
2214 2206 else:
2215 2207 out = LSString(out)
2216 2208 return out
2217 2209
2218 2210 #-------------------------------------------------------------------------
2219 2211 # Things related to aliases
2220 2212 #-------------------------------------------------------------------------
2221 2213
2222 2214 def init_alias(self):
2223 2215 self.alias_manager = AliasManager(shell=self, config=self.config)
2224 2216 self.configurables.append(self.alias_manager)
2225 2217 self.ns_table['alias'] = self.alias_manager.alias_table,
2226 2218
2227 2219 #-------------------------------------------------------------------------
2228 2220 # Things related to extensions and plugins
2229 2221 #-------------------------------------------------------------------------
2230 2222
2231 2223 def init_extension_manager(self):
2232 2224 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2233 2225 self.configurables.append(self.extension_manager)
2234 2226
2235 2227 def init_plugin_manager(self):
2236 2228 self.plugin_manager = PluginManager(config=self.config)
2237 2229 self.configurables.append(self.plugin_manager)
2238 2230
2239 2231
2240 2232 #-------------------------------------------------------------------------
2241 2233 # Things related to payloads
2242 2234 #-------------------------------------------------------------------------
2243 2235
2244 2236 def init_payload(self):
2245 2237 self.payload_manager = PayloadManager(config=self.config)
2246 2238 self.configurables.append(self.payload_manager)
2247 2239
2248 2240 #-------------------------------------------------------------------------
2249 2241 # Things related to the prefilter
2250 2242 #-------------------------------------------------------------------------
2251 2243
2252 2244 def init_prefilter(self):
2253 2245 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2254 2246 self.configurables.append(self.prefilter_manager)
2255 2247 # Ultimately this will be refactored in the new interpreter code, but
2256 2248 # for now, we should expose the main prefilter method (there's legacy
2257 2249 # code out there that may rely on this).
2258 2250 self.prefilter = self.prefilter_manager.prefilter_lines
2259 2251
2260 2252 def auto_rewrite_input(self, cmd):
2261 2253 """Print to the screen the rewritten form of the user's command.
2262 2254
2263 2255 This shows visual feedback by rewriting input lines that cause
2264 2256 automatic calling to kick in, like::
2265 2257
2266 2258 /f x
2267 2259
2268 2260 into::
2269 2261
2270 2262 ------> f(x)
2271 2263
2272 2264 after the user's input prompt. This helps the user understand that the
2273 2265 input line was transformed automatically by IPython.
2274 2266 """
2275 2267 if not self.show_rewritten_input:
2276 2268 return
2277 2269
2278 2270 rw = self.prompt_manager.render('rewrite') + cmd
2279 2271
2280 2272 try:
2281 2273 # plain ascii works better w/ pyreadline, on some machines, so
2282 2274 # we use it and only print uncolored rewrite if we have unicode
2283 2275 rw = str(rw)
2284 2276 print >> io.stdout, rw
2285 2277 except UnicodeEncodeError:
2286 2278 print "------> " + cmd
2287 2279
2288 2280 #-------------------------------------------------------------------------
2289 2281 # Things related to extracting values/expressions from kernel and user_ns
2290 2282 #-------------------------------------------------------------------------
2291 2283
2292 2284 def _simple_error(self):
2293 2285 etype, value = sys.exc_info()[:2]
2294 2286 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2295 2287
2296 2288 def user_variables(self, names):
2297 2289 """Get a list of variable names from the user's namespace.
2298 2290
2299 2291 Parameters
2300 2292 ----------
2301 2293 names : list of strings
2302 2294 A list of names of variables to be read from the user namespace.
2303 2295
2304 2296 Returns
2305 2297 -------
2306 2298 A dict, keyed by the input names and with the repr() of each value.
2307 2299 """
2308 2300 out = {}
2309 2301 user_ns = self.user_ns
2310 2302 for varname in names:
2311 2303 try:
2312 2304 value = repr(user_ns[varname])
2313 2305 except:
2314 2306 value = self._simple_error()
2315 2307 out[varname] = value
2316 2308 return out
2317 2309
2318 2310 def user_expressions(self, expressions):
2319 2311 """Evaluate a dict of expressions in the user's namespace.
2320 2312
2321 2313 Parameters
2322 2314 ----------
2323 2315 expressions : dict
2324 2316 A dict with string keys and string values. The expression values
2325 2317 should be valid Python expressions, each of which will be evaluated
2326 2318 in the user namespace.
2327 2319
2328 2320 Returns
2329 2321 -------
2330 2322 A dict, keyed like the input expressions dict, with the repr() of each
2331 2323 value.
2332 2324 """
2333 2325 out = {}
2334 2326 user_ns = self.user_ns
2335 2327 global_ns = self.user_global_ns
2336 2328 for key, expr in expressions.iteritems():
2337 2329 try:
2338 2330 value = repr(eval(expr, global_ns, user_ns))
2339 2331 except:
2340 2332 value = self._simple_error()
2341 2333 out[key] = value
2342 2334 return out
2343 2335
2344 2336 #-------------------------------------------------------------------------
2345 2337 # Things related to the running of code
2346 2338 #-------------------------------------------------------------------------
2347 2339
2348 2340 def ex(self, cmd):
2349 2341 """Execute a normal python statement in user namespace."""
2350 2342 with self.builtin_trap:
2351 2343 exec cmd in self.user_global_ns, self.user_ns
2352 2344
2353 2345 def ev(self, expr):
2354 2346 """Evaluate python expression expr in user namespace.
2355 2347
2356 2348 Returns the result of evaluation
2357 2349 """
2358 2350 with self.builtin_trap:
2359 2351 return eval(expr, self.user_global_ns, self.user_ns)
2360 2352
2361 2353 def safe_execfile(self, fname, *where, **kw):
2362 2354 """A safe version of the builtin execfile().
2363 2355
2364 2356 This version will never throw an exception, but instead print
2365 2357 helpful error messages to the screen. This only works on pure
2366 2358 Python files with the .py extension.
2367 2359
2368 2360 Parameters
2369 2361 ----------
2370 2362 fname : string
2371 2363 The name of the file to be executed.
2372 2364 where : tuple
2373 2365 One or two namespaces, passed to execfile() as (globals,locals).
2374 2366 If only one is given, it is passed as both.
2375 2367 exit_ignore : bool (False)
2376 2368 If True, then silence SystemExit for non-zero status (it is always
2377 2369 silenced for zero status, as it is so common).
2378 2370 raise_exceptions : bool (False)
2379 2371 If True raise exceptions everywhere. Meant for testing.
2380 2372
2381 2373 """
2382 2374 kw.setdefault('exit_ignore', False)
2383 2375 kw.setdefault('raise_exceptions', False)
2384 2376
2385 2377 fname = os.path.abspath(os.path.expanduser(fname))
2386 2378
2387 2379 # Make sure we can open the file
2388 2380 try:
2389 2381 with open(fname) as thefile:
2390 2382 pass
2391 2383 except:
2392 2384 warn('Could not open file <%s> for safe execution.' % fname)
2393 2385 return
2394 2386
2395 2387 # Find things also in current directory. This is needed to mimic the
2396 2388 # behavior of running a script from the system command line, where
2397 2389 # Python inserts the script's directory into sys.path
2398 2390 dname = os.path.dirname(fname)
2399 2391
2400 2392 with prepended_to_syspath(dname):
2401 2393 try:
2402 2394 py3compat.execfile(fname,*where)
2403 2395 except SystemExit, status:
2404 2396 # If the call was made with 0 or None exit status (sys.exit(0)
2405 2397 # or sys.exit() ), don't bother showing a traceback, as both of
2406 2398 # these are considered normal by the OS:
2407 2399 # > python -c'import sys;sys.exit(0)'; echo $?
2408 2400 # 0
2409 2401 # > python -c'import sys;sys.exit()'; echo $?
2410 2402 # 0
2411 2403 # For other exit status, we show the exception unless
2412 2404 # explicitly silenced, but only in short form.
2413 2405 if kw['raise_exceptions']:
2414 2406 raise
2415 2407 if status.code not in (0, None) and not kw['exit_ignore']:
2416 2408 self.showtraceback(exception_only=True)
2417 2409 except:
2418 2410 if kw['raise_exceptions']:
2419 2411 raise
2420 2412 self.showtraceback()
2421 2413
2422 2414 def safe_execfile_ipy(self, fname):
2423 2415 """Like safe_execfile, but for .ipy files with IPython syntax.
2424 2416
2425 2417 Parameters
2426 2418 ----------
2427 2419 fname : str
2428 2420 The name of the file to execute. The filename must have a
2429 2421 .ipy extension.
2430 2422 """
2431 2423 fname = os.path.abspath(os.path.expanduser(fname))
2432 2424
2433 2425 # Make sure we can open the file
2434 2426 try:
2435 2427 with open(fname) as thefile:
2436 2428 pass
2437 2429 except:
2438 2430 warn('Could not open file <%s> for safe execution.' % fname)
2439 2431 return
2440 2432
2441 2433 # Find things also in current directory. This is needed to mimic the
2442 2434 # behavior of running a script from the system command line, where
2443 2435 # Python inserts the script's directory into sys.path
2444 2436 dname = os.path.dirname(fname)
2445 2437
2446 2438 with prepended_to_syspath(dname):
2447 2439 try:
2448 2440 with open(fname) as thefile:
2449 2441 # self.run_cell currently captures all exceptions
2450 2442 # raised in user code. It would be nice if there were
2451 2443 # versions of runlines, execfile that did raise, so
2452 2444 # we could catch the errors.
2453 2445 self.run_cell(thefile.read(), store_history=False)
2454 2446 except:
2455 2447 self.showtraceback()
2456 2448 warn('Unknown failure executing file: <%s>' % fname)
2457 2449
2458 2450 def safe_run_module(self, mod_name, where):
2459 2451 """A safe version of runpy.run_module().
2460 2452
2461 2453 This version will never throw an exception, but instead print
2462 2454 helpful error messages to the screen.
2463 2455
2464 2456 Parameters
2465 2457 ----------
2466 2458 mod_name : string
2467 2459 The name of the module to be executed.
2468 2460 where : dict
2469 2461 The globals namespace.
2470 2462 """
2471 2463 try:
2472 2464 where.update(
2473 2465 runpy.run_module(str(mod_name), run_name="__main__",
2474 2466 alter_sys=True)
2475 2467 )
2476 2468 except:
2477 2469 self.showtraceback()
2478 2470 warn('Unknown failure executing module: <%s>' % mod_name)
2479 2471
2480 2472 def call_cell_magic(self, raw_cell, store_history=False):
2481 2473 line, _, cell = raw_cell.partition(os.linesep)
2482 2474 magic_name, _, line = line.partition(' ')
2483 2475 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2484 2476 return self.cell_magic(magic_name, line, cell)
2485 2477
2486 2478 def run_cell(self, raw_cell, store_history=False, silent=False):
2487 2479 """Run a complete IPython cell.
2488 2480
2489 2481 Parameters
2490 2482 ----------
2491 2483 raw_cell : str
2492 2484 The code (including IPython code such as %magic functions) to run.
2493 2485 store_history : bool
2494 2486 If True, the raw and translated cell will be stored in IPython's
2495 2487 history. For user code calling back into IPython's machinery, this
2496 2488 should be set to False.
2497 2489 silent : bool
2498 2490 If True, avoid side-effets, such as implicit displayhooks, history,
2499 2491 and logging. silent=True forces store_history=False.
2500 2492 """
2501 2493 if (not raw_cell) or raw_cell.isspace():
2502 2494 return
2503 2495
2504 2496 if silent:
2505 2497 store_history = False
2506 2498
2507 2499 if raw_cell.startswith('%%'):
2508 2500 return self.call_cell_magic(raw_cell, store_history)
2509 2501
2510 2502 for line in raw_cell.splitlines():
2511 2503 self.input_splitter.push(line)
2512 2504 cell = self.input_splitter.source_reset()
2513 2505
2514 2506 with self.builtin_trap:
2515 2507 prefilter_failed = False
2516 2508 if len(cell.splitlines()) == 1:
2517 2509 try:
2518 2510 # use prefilter_lines to handle trailing newlines
2519 2511 # restore trailing newline for ast.parse
2520 2512 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2521 2513 except AliasError as e:
2522 2514 error(e)
2523 2515 prefilter_failed = True
2524 2516 except Exception:
2525 2517 # don't allow prefilter errors to crash IPython
2526 2518 self.showtraceback()
2527 2519 prefilter_failed = True
2528 2520
2529 2521 # Store raw and processed history
2530 2522 if store_history:
2531 2523 self.history_manager.store_inputs(self.execution_count,
2532 2524 cell, raw_cell)
2533 2525 if not silent:
2534 2526 self.logger.log(cell, raw_cell)
2535 2527
2536 2528 if not prefilter_failed:
2537 2529 # don't run if prefilter failed
2538 2530 cell_name = self.compile.cache(cell, self.execution_count)
2539 2531
2540 2532 with self.display_trap:
2541 2533 try:
2542 2534 code_ast = self.compile.ast_parse(cell,
2543 2535 filename=cell_name)
2544 2536 except IndentationError:
2545 2537 self.showindentationerror()
2546 2538 if store_history:
2547 2539 self.execution_count += 1
2548 2540 return None
2549 2541 except (OverflowError, SyntaxError, ValueError, TypeError,
2550 2542 MemoryError):
2551 2543 self.showsyntaxerror()
2552 2544 if store_history:
2553 2545 self.execution_count += 1
2554 2546 return None
2555 2547
2556 2548 interactivity = "none" if silent else "last_expr"
2557 2549 self.run_ast_nodes(code_ast.body, cell_name,
2558 2550 interactivity=interactivity)
2559 2551
2560 2552 # Execute any registered post-execution functions.
2561 2553 # unless we are silent
2562 2554 post_exec = [] if silent else self._post_execute.iteritems()
2563 2555
2564 2556 for func, status in post_exec:
2565 2557 if self.disable_failing_post_execute and not status:
2566 2558 continue
2567 2559 try:
2568 2560 func()
2569 2561 except KeyboardInterrupt:
2570 2562 print >> io.stderr, "\nKeyboardInterrupt"
2571 2563 except Exception:
2572 2564 # register as failing:
2573 2565 self._post_execute[func] = False
2574 2566 self.showtraceback()
2575 2567 print >> io.stderr, '\n'.join([
2576 2568 "post-execution function %r produced an error." % func,
2577 2569 "If this problem persists, you can disable failing post-exec functions with:",
2578 2570 "",
2579 2571 " get_ipython().disable_failing_post_execute = True"
2580 2572 ])
2581 2573
2582 2574 if store_history:
2583 2575 # Write output to the database. Does nothing unless
2584 2576 # history output logging is enabled.
2585 2577 self.history_manager.store_output(self.execution_count)
2586 2578 # Each cell is a *single* input, regardless of how many lines it has
2587 2579 self.execution_count += 1
2588 2580
2589 2581 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2590 2582 """Run a sequence of AST nodes. The execution mode depends on the
2591 2583 interactivity parameter.
2592 2584
2593 2585 Parameters
2594 2586 ----------
2595 2587 nodelist : list
2596 2588 A sequence of AST nodes to run.
2597 2589 cell_name : str
2598 2590 Will be passed to the compiler as the filename of the cell. Typically
2599 2591 the value returned by ip.compile.cache(cell).
2600 2592 interactivity : str
2601 2593 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2602 2594 run interactively (displaying output from expressions). 'last_expr'
2603 2595 will run the last node interactively only if it is an expression (i.e.
2604 2596 expressions in loops or other blocks are not displayed. Other values
2605 2597 for this parameter will raise a ValueError.
2606 2598 """
2607 2599 if not nodelist:
2608 2600 return
2609 2601
2610 2602 if interactivity == 'last_expr':
2611 2603 if isinstance(nodelist[-1], ast.Expr):
2612 2604 interactivity = "last"
2613 2605 else:
2614 2606 interactivity = "none"
2615 2607
2616 2608 if interactivity == 'none':
2617 2609 to_run_exec, to_run_interactive = nodelist, []
2618 2610 elif interactivity == 'last':
2619 2611 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2620 2612 elif interactivity == 'all':
2621 2613 to_run_exec, to_run_interactive = [], nodelist
2622 2614 else:
2623 2615 raise ValueError("Interactivity was %r" % interactivity)
2624 2616
2625 2617 exec_count = self.execution_count
2626 2618
2627 2619 try:
2628 2620 for i, node in enumerate(to_run_exec):
2629 2621 mod = ast.Module([node])
2630 2622 code = self.compile(mod, cell_name, "exec")
2631 2623 if self.run_code(code):
2632 2624 return True
2633 2625
2634 2626 for i, node in enumerate(to_run_interactive):
2635 2627 mod = ast.Interactive([node])
2636 2628 code = self.compile(mod, cell_name, "single")
2637 2629 if self.run_code(code):
2638 2630 return True
2639 2631
2640 2632 # Flush softspace
2641 2633 if softspace(sys.stdout, 0):
2642 2634 print
2643 2635
2644 2636 except:
2645 2637 # It's possible to have exceptions raised here, typically by
2646 2638 # compilation of odd code (such as a naked 'return' outside a
2647 2639 # function) that did parse but isn't valid. Typically the exception
2648 2640 # is a SyntaxError, but it's safest just to catch anything and show
2649 2641 # the user a traceback.
2650 2642
2651 2643 # We do only one try/except outside the loop to minimize the impact
2652 2644 # on runtime, and also because if any node in the node list is
2653 2645 # broken, we should stop execution completely.
2654 2646 self.showtraceback()
2655 2647
2656 2648 return False
2657 2649
2658 2650 def run_code(self, code_obj):
2659 2651 """Execute a code object.
2660 2652
2661 2653 When an exception occurs, self.showtraceback() is called to display a
2662 2654 traceback.
2663 2655
2664 2656 Parameters
2665 2657 ----------
2666 2658 code_obj : code object
2667 2659 A compiled code object, to be executed
2668 2660
2669 2661 Returns
2670 2662 -------
2671 2663 False : successful execution.
2672 2664 True : an error occurred.
2673 2665 """
2674 2666
2675 2667 # Set our own excepthook in case the user code tries to call it
2676 2668 # directly, so that the IPython crash handler doesn't get triggered
2677 2669 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2678 2670
2679 2671 # we save the original sys.excepthook in the instance, in case config
2680 2672 # code (such as magics) needs access to it.
2681 2673 self.sys_excepthook = old_excepthook
2682 2674 outflag = 1 # happens in more places, so it's easier as default
2683 2675 try:
2684 2676 try:
2685 2677 self.hooks.pre_run_code_hook()
2686 2678 #rprint('Running code', repr(code_obj)) # dbg
2687 2679 exec code_obj in self.user_global_ns, self.user_ns
2688 2680 finally:
2689 2681 # Reset our crash handler in place
2690 2682 sys.excepthook = old_excepthook
2691 2683 except SystemExit:
2692 2684 self.showtraceback(exception_only=True)
2693 2685 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2694 2686 except self.custom_exceptions:
2695 2687 etype,value,tb = sys.exc_info()
2696 2688 self.CustomTB(etype,value,tb)
2697 2689 except:
2698 2690 self.showtraceback()
2699 2691 else:
2700 2692 outflag = 0
2701 2693 return outflag
2702 2694
2703 2695 # For backwards compatibility
2704 2696 runcode = run_code
2705 2697
2706 2698 #-------------------------------------------------------------------------
2707 2699 # Things related to GUI support and pylab
2708 2700 #-------------------------------------------------------------------------
2709 2701
2710 2702 def enable_gui(self, gui=None):
2711 2703 raise NotImplementedError('Implement enable_gui in a subclass')
2712 2704
2713 2705 def enable_pylab(self, gui=None, import_all=True):
2714 2706 """Activate pylab support at runtime.
2715 2707
2716 2708 This turns on support for matplotlib, preloads into the interactive
2717 2709 namespace all of numpy and pylab, and configures IPython to correctly
2718 2710 interact with the GUI event loop. The GUI backend to be used can be
2719 2711 optionally selected with the optional :param:`gui` argument.
2720 2712
2721 2713 Parameters
2722 2714 ----------
2723 2715 gui : optional, string
2724 2716
2725 2717 If given, dictates the choice of matplotlib GUI backend to use
2726 2718 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2727 2719 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2728 2720 matplotlib (as dictated by the matplotlib build-time options plus the
2729 2721 user's matplotlibrc configuration file). Note that not all backends
2730 2722 make sense in all contexts, for example a terminal ipython can't
2731 2723 display figures inline.
2732 2724 """
2733 2725 from IPython.core.pylabtools import mpl_runner
2734 2726 # We want to prevent the loading of pylab to pollute the user's
2735 2727 # namespace as shown by the %who* magics, so we execute the activation
2736 2728 # code in an empty namespace, and we update *both* user_ns and
2737 2729 # user_ns_hidden with this information.
2738 2730 ns = {}
2739 2731 try:
2740 2732 gui = pylab_activate(ns, gui, import_all, self)
2741 2733 except KeyError:
2742 2734 error("Backend %r not supported" % gui)
2743 2735 return
2744 2736 self.user_ns.update(ns)
2745 2737 self.user_ns_hidden.update(ns)
2746 2738 # Now we must activate the gui pylab wants to use, and fix %run to take
2747 2739 # plot updates into account
2748 2740 self.enable_gui(gui)
2749 2741 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2750 2742 mpl_runner(self.safe_execfile)
2751 2743
2752 2744 #-------------------------------------------------------------------------
2753 2745 # Utilities
2754 2746 #-------------------------------------------------------------------------
2755 2747
2756 2748 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2757 2749 """Expand python variables in a string.
2758 2750
2759 2751 The depth argument indicates how many frames above the caller should
2760 2752 be walked to look for the local namespace where to expand variables.
2761 2753
2762 2754 The global namespace for expansion is always the user's interactive
2763 2755 namespace.
2764 2756 """
2765 2757 ns = self.user_ns.copy()
2766 2758 ns.update(sys._getframe(depth+1).f_locals)
2767 2759 ns.pop('self', None)
2768 2760 try:
2769 2761 cmd = formatter.format(cmd, **ns)
2770 2762 except Exception:
2771 2763 # if formatter couldn't format, just let it go untransformed
2772 2764 pass
2773 2765 return cmd
2774 2766
2775 2767 def mktempfile(self, data=None, prefix='ipython_edit_'):
2776 2768 """Make a new tempfile and return its filename.
2777 2769
2778 2770 This makes a call to tempfile.mktemp, but it registers the created
2779 2771 filename internally so ipython cleans it up at exit time.
2780 2772
2781 2773 Optional inputs:
2782 2774
2783 2775 - data(None): if data is given, it gets written out to the temp file
2784 2776 immediately, and the file is closed again."""
2785 2777
2786 2778 filename = tempfile.mktemp('.py', prefix)
2787 2779 self.tempfiles.append(filename)
2788 2780
2789 2781 if data:
2790 2782 tmp_file = open(filename,'w')
2791 2783 tmp_file.write(data)
2792 2784 tmp_file.close()
2793 2785 return filename
2794 2786
2795 2787 # TODO: This should be removed when Term is refactored.
2796 2788 def write(self,data):
2797 2789 """Write a string to the default output"""
2798 2790 io.stdout.write(data)
2799 2791
2800 2792 # TODO: This should be removed when Term is refactored.
2801 2793 def write_err(self,data):
2802 2794 """Write a string to the default error output"""
2803 2795 io.stderr.write(data)
2804 2796
2805 2797 def ask_yes_no(self, prompt, default=None):
2806 2798 if self.quiet:
2807 2799 return True
2808 2800 return ask_yes_no(prompt,default)
2809 2801
2810 2802 def show_usage(self):
2811 2803 """Show a usage message"""
2812 2804 page.page(IPython.core.usage.interactive_usage)
2813 2805
2814 2806 def extract_input_lines(self, range_str, raw=False):
2815 2807 """Return as a string a set of input history slices.
2816 2808
2817 2809 Parameters
2818 2810 ----------
2819 2811 range_str : string
2820 2812 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
2821 2813 since this function is for use by magic functions which get their
2822 2814 arguments as strings. The number before the / is the session
2823 2815 number: ~n goes n back from the current session.
2824 2816
2825 2817 Optional Parameters:
2826 2818 - raw(False): by default, the processed input is used. If this is
2827 2819 true, the raw input history is used instead.
2828 2820
2829 2821 Note that slices can be called with two notations:
2830 2822
2831 2823 N:M -> standard python form, means including items N...(M-1).
2832 2824
2833 2825 N-M -> include items N..M (closed endpoint)."""
2834 2826 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
2835 2827 return "\n".join(x for _, _, x in lines)
2836 2828
2837 2829 def find_user_code(self, target, raw=True, py_only=False):
2838 2830 """Get a code string from history, file, url, or a string or macro.
2839 2831
2840 2832 This is mainly used by magic functions.
2841 2833
2842 2834 Parameters
2843 2835 ----------
2844 2836
2845 2837 target : str
2846 2838
2847 2839 A string specifying code to retrieve. This will be tried respectively
2848 2840 as: ranges of input history (see %history for syntax), url,
2849 2841 correspnding .py file, filename, or an expression evaluating to a
2850 2842 string or Macro in the user namespace.
2851 2843
2852 2844 raw : bool
2853 2845 If true (default), retrieve raw history. Has no effect on the other
2854 2846 retrieval mechanisms.
2855 2847
2856 2848 py_only : bool (default False)
2857 2849 Only try to fetch python code, do not try alternative methods to decode file
2858 2850 if unicode fails.
2859 2851
2860 2852 Returns
2861 2853 -------
2862 2854 A string of code.
2863 2855
2864 2856 ValueError is raised if nothing is found, and TypeError if it evaluates
2865 2857 to an object of another type. In each case, .args[0] is a printable
2866 2858 message.
2867 2859 """
2868 2860 code = self.extract_input_lines(target, raw=raw) # Grab history
2869 2861 if code:
2870 2862 return code
2871 2863 utarget = unquote_filename(target)
2872 2864 try:
2873 2865 if utarget.startswith(('http://', 'https://')):
2874 2866 return openpy.read_py_url(utarget, skip_encoding_cookie=True)
2875 2867 except UnicodeDecodeError:
2876 2868 if not py_only :
2877 2869 response = urllib.urlopen(target)
2878 2870 return response.read().decode('latin1')
2879 2871 raise ValueError(("'%s' seem to be unreadable.") % utarget)
2880 2872
2881 2873 potential_target = [target]
2882 2874 try :
2883 2875 potential_target.insert(0,get_py_filename(target))
2884 2876 except IOError:
2885 2877 pass
2886 2878
2887 2879 for tgt in potential_target :
2888 2880 if os.path.isfile(tgt): # Read file
2889 2881 try :
2890 2882 return openpy.read_py_file(tgt, skip_encoding_cookie=True)
2891 2883 except UnicodeDecodeError :
2892 2884 if not py_only :
2893 2885 with io_open(tgt,'r', encoding='latin1') as f :
2894 2886 return f.read()
2895 2887 raise ValueError(("'%s' seem to be unreadable.") % target)
2896 2888
2897 2889 try: # User namespace
2898 2890 codeobj = eval(target, self.user_ns)
2899 2891 except Exception:
2900 2892 raise ValueError(("'%s' was not found in history, as a file, url, "
2901 2893 "nor in the user namespace.") % target)
2902 2894 if isinstance(codeobj, basestring):
2903 2895 return codeobj
2904 2896 elif isinstance(codeobj, Macro):
2905 2897 return codeobj.value
2906 2898
2907 2899 raise TypeError("%s is neither a string nor a macro." % target,
2908 2900 codeobj)
2909 2901
2910 2902 #-------------------------------------------------------------------------
2911 2903 # Things related to IPython exiting
2912 2904 #-------------------------------------------------------------------------
2913 2905 def atexit_operations(self):
2914 2906 """This will be executed at the time of exit.
2915 2907
2916 2908 Cleanup operations and saving of persistent data that is done
2917 2909 unconditionally by IPython should be performed here.
2918 2910
2919 2911 For things that may depend on startup flags or platform specifics (such
2920 2912 as having readline or not), register a separate atexit function in the
2921 2913 code that has the appropriate information, rather than trying to
2922 2914 clutter
2923 2915 """
2924 2916 # Close the history session (this stores the end time and line count)
2925 2917 # this must be *before* the tempfile cleanup, in case of temporary
2926 2918 # history db
2927 2919 self.history_manager.end_session()
2928 2920
2929 2921 # Cleanup all tempfiles left around
2930 2922 for tfile in self.tempfiles:
2931 2923 try:
2932 2924 os.unlink(tfile)
2933 2925 except OSError:
2934 2926 pass
2935 2927
2936 2928 # Clear all user namespaces to release all references cleanly.
2937 2929 self.reset(new_session=False)
2938 2930
2939 2931 # Run user hooks
2940 2932 self.hooks.shutdown_hook()
2941 2933
2942 2934 def cleanup(self):
2943 2935 self.restore_sys_module_state()
2944 2936
2945 2937
2946 2938 class InteractiveShellABC(object):
2947 2939 """An abstract base class for InteractiveShell."""
2948 2940 __metaclass__ = abc.ABCMeta
2949 2941
2950 2942 InteractiveShellABC.register(InteractiveShell)
@@ -1,437 +1,435 b''
1 1 # encoding: utf-8
2 2 """Magic functions for InteractiveShell.
3 3 """
4 4
5 5 #-----------------------------------------------------------------------------
6 6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
7 7 # Copyright (C) 2001 Fernando Perez <fperez@colorado.edu>
8 8 # Copyright (C) 2008 The IPython Development Team
9 9
10 10 # Distributed under the terms of the BSD License. The full license is in
11 11 # the file COPYING, distributed as part of this software.
12 12 #-----------------------------------------------------------------------------
13 13
14 14 #-----------------------------------------------------------------------------
15 15 # Imports
16 16 #-----------------------------------------------------------------------------
17 17 # Stdlib
18 18 import os
19 19 import re
20 20 import sys
21 21 import types
22 22 from getopt import getopt, GetoptError
23 23
24 24 # Our own
25 25 from IPython.config.configurable import Configurable
26 26 from IPython.core import oinspect
27 27 from IPython.core.error import UsageError
28 28 from IPython.core.prefilter import ESC_MAGIC
29 29 from IPython.external.decorator import decorator
30 30 from IPython.utils.ipstruct import Struct
31 31 from IPython.utils.process import arg_split
32 32 from IPython.utils.traitlets import Bool, Dict, Instance
33 33 from IPython.utils.warn import error, warn
34 34
35 35 #-----------------------------------------------------------------------------
36 36 # Globals
37 37 #-----------------------------------------------------------------------------
38 38
39 39 # A dict we'll use for each class that has magics, used as temporary storage to
40 40 # pass information between the @line/cell_magic method decorators and the
41 41 # @magics_class class decorator, because the method decorators have no
42 42 # access to the class when they run. See for more details:
43 43 # http://stackoverflow.com/questions/2366713/can-a-python-decorator-of-an-instance-method-access-the-class
44 44
45 45 magics = dict(line={}, cell={})
46 46
47 magic_types = ('line', 'cell')
47 magic_kinds = ('line', 'cell')
48 48 magic_spec = ('line', 'cell', 'line_cell')
49 49
50 50 #-----------------------------------------------------------------------------
51 51 # Utility classes and functions
52 52 #-----------------------------------------------------------------------------
53 53
54 54 class Bunch: pass
55 55
56 56
57 57 def on_off(tag):
58 58 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
59 59 return ['OFF','ON'][tag]
60 60
61 61
62 62 def compress_dhist(dh):
63 63 head, tail = dh[:-10], dh[-10:]
64 64
65 65 newhead = []
66 66 done = set()
67 67 for h in head:
68 68 if h in done:
69 69 continue
70 70 newhead.append(h)
71 71 done.add(h)
72 72
73 73 return newhead + tail
74 74
75 75
76 76 def needs_local_scope(func):
77 77 """Decorator to mark magic functions which need to local scope to run."""
78 78 func.needs_local_scope = True
79 79 return func
80 80
81 81 #-----------------------------------------------------------------------------
82 82 # Class and method decorators for registering magics
83 83 #-----------------------------------------------------------------------------
84 84
85 85 def magics_class(cls):
86 86 cls.registered = True
87 87 cls.magics = dict(line = magics['line'],
88 88 cell = magics['cell'])
89 89 magics['line'] = {}
90 90 magics['cell'] = {}
91 91 return cls
92 92
93 93
94 94 def record_magic(dct, mtype, mname, func):
95 95 if mtype == 'line_cell':
96 96 dct['line'][mname] = dct['cell'][mname] = func
97 97 else:
98 98 dct[mtype][mname] = func
99 99
100 100
101 def validate_type(magic_type):
102 if magic_type not in magic_spec:
103 raise ValueError('magic_type must be one of %s, %s given' %
104 magic_types, magic_type)
101 def validate_type(magic_kind):
102 if magic_kind not in magic_spec:
103 raise ValueError('magic_kind must be one of %s, %s given' %
104 magic_kinds, magic_kind)
105 105
106 106
107 def _magic_marker(magic_type):
108 validate_type(magic_type)
107 def _magic_marker(magic_kind):
108 validate_type(magic_kind)
109 109
110 # This is a closure to capture the magic_type. We could also use a class,
110 # This is a closure to capture the magic_kind. We could also use a class,
111 111 # but it's overkill for just that one bit of state.
112 112 def magic_deco(arg):
113 113 call = lambda f, *a, **k: f(*a, **k)
114 114
115 115 if callable(arg):
116 116 # "Naked" decorator call (just @foo, no args)
117 117 func = arg
118 118 name = func.func_name
119 119 func.magic_name = name
120 120 retval = decorator(call, func)
121 record_magic(magics, magic_type, name, name)
121 record_magic(magics, magic_kind, name, name)
122 122 elif isinstance(arg, basestring):
123 123 # Decorator called with arguments (@foo('bar'))
124 124 name = arg
125 125 def mark(func, *a, **kw):
126 126 func.magic_name = name
127 record_magic(magics, magic_type, name, func.func_name)
127 record_magic(magics, magic_kind, name, func.func_name)
128 128 return decorator(call, func)
129 129 retval = mark
130 130 else:
131 131 raise ValueError("Decorator can only be called with "
132 132 "string or function")
133 133 return retval
134 134
135 135 return magic_deco
136 136
137 137
138 def _function_magic_marker(magic_type):
139 validate_type(magic_type)
138 def _function_magic_marker(magic_kind):
139 validate_type(magic_kind)
140 140
141 # This is a closure to capture the magic_type. We could also use a class,
141 # This is a closure to capture the magic_kind. We could also use a class,
142 142 # but it's overkill for just that one bit of state.
143 143 def magic_deco(arg):
144 144 call = lambda f, *a, **k: f(*a, **k)
145 145
146 146 # Find get_ipython() in the caller's namespace
147 147 caller = sys._getframe(1)
148 148 for ns in ['f_locals', 'f_globals', 'f_builtins']:
149 149 get_ipython = getattr(caller, ns).get('get_ipython')
150 150 if get_ipython is not None:
151 151 break
152 152 else:
153 153 raise('Decorator can only run in context where `get_ipython` exists')
154 154
155 155 ip = get_ipython()
156 156
157 157 if callable(arg):
158 158 # "Naked" decorator call (just @foo, no args)
159 159 func = arg
160 #name = func.func_name
161 #func.magic_name = name
162 ip.register_magic_function(func)
160 name = func.func_name
161 ip.register_magic_function(func, magic_kind, name)
163 162 retval = decorator(call, func)
164 163 elif isinstance(arg, basestring):
165 164 # Decorator called with arguments (@foo('bar'))
166 165 name = arg
167 166 def mark(func, *a, **kw):
168 #func.magic_name = name
169 ip.register_magic_function(func)
167 ip.register_magic_function(func, magic_kind, name)
170 168 return decorator(call, func)
171 169 retval = mark
172 170 else:
173 171 raise ValueError("Decorator can only be called with "
174 172 "string or function")
175 173 return retval
176 174
177 175 return magic_deco
178 176
179 177
180 178 # Create the actual decorators for public use
181 179
182 180 # These three are used to decorate methods in class definitions
183 181 line_magic = _magic_marker('line')
184 182 cell_magic = _magic_marker('cell')
185 183 line_cell_magic = _magic_marker('line_cell')
186 184
187 185 # These three decorate standalone functions and perform the decoration
188 186 # immediately. They can only run where get_ipython() works
189 187 register_line_magic = _function_magic_marker('line')
190 188 register_cell_magic = _function_magic_marker('cell')
191 189 register_line_cell_magic = _function_magic_marker('line_cell')
192 190
193 191 #-----------------------------------------------------------------------------
194 192 # Core Magic classes
195 193 #-----------------------------------------------------------------------------
196 194
197 195 class MagicsManager(Configurable):
198 196 """Object that handles all magic-related functionality for IPython.
199 197 """
200 198 # Non-configurable class attributes
201 199
202 200 # A two-level dict, first keyed by magic type, then by magic function, and
203 201 # holding the actual callable object as value. This is the dict used for
204 202 # magic function dispatch
205 203 magics = Dict
206 204
207 205 # A registry of the original objects that we've been given holding magics.
208 206 registry = Dict
209 207
210 208 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
211 209
212 210 auto_magic = Bool
213 211
214 212 _auto_status = [
215 213 'Automagic is OFF, % prefix IS needed for magic functions.',
216 214 'Automagic is ON, % prefix IS NOT needed for magic functions.']
217 215
218 216 user_magics = Instance('IPython.core.magics.UserMagics')
219 217
220 218 def __init__(self, shell=None, config=None, user_magics=None, **traits):
221 219
222 220 super(MagicsManager, self).__init__(shell=shell, config=config,
223 221 user_magics=user_magics, **traits)
224 222 self.magics = dict(line={}, cell={})
225 223 # Let's add the user_magics to the registry for uniformity, so *all*
226 224 # registered magic containers can be found there.
227 225 self.registry[user_magics.__class__.__name__] = user_magics
228 226
229 227 def auto_status(self):
230 228 """Return descriptive string with automagic status."""
231 229 return self._auto_status[self.auto_magic]
232 230
233 231 def lsmagic(self):
234 232 """Return a dict of currently available magic functions.
235 233
236 234 The return dict has the keys 'line' and 'cell', corresponding to the
237 235 two types of magics we support. Each value is a list of names.
238 236 """
239 237 return self.magics
240 238
241 239 def register(self, *magic_objects):
242 240 """Register one or more instances of Magics.
243 241 """
244 242 # Start by validating them to ensure they have all had their magic
245 243 # methods registered at the instance level
246 244 for m in magic_objects:
247 245 if not m.registered:
248 246 raise ValueError("Class of magics %r was constructed without "
249 247 "the @register_macics class decorator")
250 248 if type(m) is type:
251 249 # If we're given an uninstantiated class
252 250 m = m(self.shell)
253 251
254 252 # Now that we have an instance, we can register it and update the
255 253 # table of callables
256 254 self.registry[m.__class__.__name__] = m
257 for mtype in magic_types:
255 for mtype in magic_kinds:
258 256 self.magics[mtype].update(m.magics[mtype])
259 257
260 def register_function(self, func, magic_type='line', magic_name=None):
258 def register_function(self, func, magic_kind='line', magic_name=None):
261 259 """Expose a standalone function as magic function for ipython.
262 260 """
263 261
264 262 # Create the new method in the user_magics and register it in the
265 263 # global table
266 validate_type(magic_type)
264 validate_type(magic_kind)
267 265 magic_name = func.func_name if magic_name is None else magic_name
268 266 setattr(self.user_magics, magic_name, func)
269 record_magic(self.magics, magic_type, magic_name, func)
267 record_magic(self.magics, magic_kind, magic_name, func)
270 268
271 269 def define_magic(self, name, func):
272 270 """Support for deprecated API.
273 271
274 272 This method exists only to support the old-style definition of magics.
275 273 It will eventually be removed. Deliberately not documented further.
276 274 """
277 275 meth = types.MethodType(func, self.user_magics)
278 276 setattr(self.user_magics, name, meth)
279 277 record_magic(self.magics, 'line', name, meth)
280 278
281 279 # Key base class that provides the central functionality for magics.
282 280
283 281 class Magics(object):
284 282 """Base class for implementing magic functions.
285 283
286 284 Shell functions which can be reached as %function_name. All magic
287 285 functions should accept a string, which they can parse for their own
288 286 needs. This can make some functions easier to type, eg `%cd ../`
289 287 vs. `%cd("../")`
290 288
291 289 Classes providing magic functions need to subclass this class, and they
292 290 MUST:
293 291
294 292 - Use the method decorators `@line_magic` and `@cell_magic` to decorate
295 293 individual methods as magic functions, AND
296 294
297 295 - Use the class decorator `@magics_class` to ensure that the magic
298 296 methods are properly registered at the instance level upon instance
299 297 initialization.
300 298
301 299 See :mod:`magic_functions` for examples of actual implementation classes.
302 300 """
303 301 # Dict holding all command-line options for each magic.
304 302 options_table = None
305 303 # Dict for the mapping of magic names to methods, set by class decorator
306 304 magics = None
307 305 # Flag to check that the class decorator was properly applied
308 306 registered = False
309 307 # Instance of IPython shell
310 308 shell = None
311 309
312 310 def __init__(self, shell):
313 311 if not(self.__class__.registered):
314 312 raise ValueError('Magics subclass without registration - '
315 313 'did you forget to apply @magics_class?')
316 314 self.shell = shell
317 315 self.options_table = {}
318 316 # The method decorators are run when the instance doesn't exist yet, so
319 317 # they can only record the names of the methods they are supposed to
320 318 # grab. Only now, that the instance exists, can we create the proper
321 319 # mapping to bound methods. So we read the info off the original names
322 320 # table and replace each method name by the actual bound method.
323 for mtype in magic_types:
321 for mtype in magic_kinds:
324 322 tab = self.magics[mtype]
325 323 # must explicitly use keys, as we're mutating this puppy
326 324 for magic_name in tab.keys():
327 325 meth_name = tab[magic_name]
328 326 if isinstance(meth_name, basestring):
329 327 tab[magic_name] = getattr(self, meth_name)
330 328
331 329 def arg_err(self,func):
332 330 """Print docstring if incorrect arguments were passed"""
333 331 print 'Error in arguments:'
334 332 print oinspect.getdoc(func)
335 333
336 334 def format_latex(self, strng):
337 335 """Format a string for latex inclusion."""
338 336
339 337 # Characters that need to be escaped for latex:
340 338 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
341 339 # Magic command names as headers:
342 340 cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
343 341 re.MULTILINE)
344 342 # Magic commands
345 343 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
346 344 re.MULTILINE)
347 345 # Paragraph continue
348 346 par_re = re.compile(r'\\$',re.MULTILINE)
349 347
350 348 # The "\n" symbol
351 349 newline_re = re.compile(r'\\n')
352 350
353 351 # Now build the string for output:
354 352 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
355 353 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
356 354 strng)
357 355 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
358 356 strng = par_re.sub(r'\\\\',strng)
359 357 strng = escape_re.sub(r'\\\1',strng)
360 358 strng = newline_re.sub(r'\\textbackslash{}n',strng)
361 359 return strng
362 360
363 361 def parse_options(self, arg_str, opt_str, *long_opts, **kw):
364 362 """Parse options passed to an argument string.
365 363
366 364 The interface is similar to that of getopt(), but it returns back a
367 365 Struct with the options as keys and the stripped argument string still
368 366 as a string.
369 367
370 368 arg_str is quoted as a true sys.argv vector by using shlex.split.
371 369 This allows us to easily expand variables, glob files, quote
372 370 arguments, etc.
373 371
374 372 Options:
375 373 -mode: default 'string'. If given as 'list', the argument string is
376 374 returned as a list (split on whitespace) instead of a string.
377 375
378 376 -list_all: put all option values in lists. Normally only options
379 377 appearing more than once are put in a list.
380 378
381 379 -posix (True): whether to split the input line in POSIX mode or not,
382 380 as per the conventions outlined in the shlex module from the
383 381 standard library."""
384 382
385 383 # inject default options at the beginning of the input line
386 384 caller = sys._getframe(1).f_code.co_name
387 385 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
388 386
389 387 mode = kw.get('mode','string')
390 388 if mode not in ['string','list']:
391 389 raise ValueError,'incorrect mode given: %s' % mode
392 390 # Get options
393 391 list_all = kw.get('list_all',0)
394 392 posix = kw.get('posix', os.name == 'posix')
395 393 strict = kw.get('strict', True)
396 394
397 395 # Check if we have more than one argument to warrant extra processing:
398 396 odict = {} # Dictionary with options
399 397 args = arg_str.split()
400 398 if len(args) >= 1:
401 399 # If the list of inputs only has 0 or 1 thing in it, there's no
402 400 # need to look for options
403 401 argv = arg_split(arg_str, posix, strict)
404 402 # Do regular option processing
405 403 try:
406 404 opts,args = getopt(argv,opt_str,*long_opts)
407 405 except GetoptError,e:
408 406 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
409 407 " ".join(long_opts)))
410 408 for o,a in opts:
411 409 if o.startswith('--'):
412 410 o = o[2:]
413 411 else:
414 412 o = o[1:]
415 413 try:
416 414 odict[o].append(a)
417 415 except AttributeError:
418 416 odict[o] = [odict[o],a]
419 417 except KeyError:
420 418 if list_all:
421 419 odict[o] = [a]
422 420 else:
423 421 odict[o] = a
424 422
425 423 # Prepare opts,args for return
426 424 opts = Struct(odict)
427 425 if mode == 'string':
428 426 args = ' '.join(args)
429 427
430 428 return opts,args
431 429
432 430 def default_option(self, fn, optstr):
433 431 """Make an entry in the options_table for fn, with value optstr"""
434 432
435 433 if fn not in self.lsmagic():
436 434 error("%s is not a magic function" % fn)
437 435 self.options_table[fn] = optstr
@@ -1,706 +1,710 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 #-----------------------------------------------------------------------------
10 10 # Copyright (C) 2010-2011 The IPython Development Team
11 11 #
12 12 # Distributed under the terms of the BSD License. The full license is in
13 13 # the file COPYING, distributed as part of this software.
14 14 #-----------------------------------------------------------------------------
15 15
16 16 #-----------------------------------------------------------------------------
17 17 # Imports
18 18 #-----------------------------------------------------------------------------
19 19 # stdlib
20 20 import unittest
21 21 import sys
22 22
23 23 # Third party
24 24 import nose.tools as nt
25 25
26 26 # Our own
27 27 from IPython.core import inputsplitter as isp
28 28 from IPython.testing import tools as tt
29 29 from IPython.utils import py3compat
30 30
31 31 #-----------------------------------------------------------------------------
32 32 # Semi-complete examples (also used as tests)
33 33 #-----------------------------------------------------------------------------
34 34
35 35 # Note: at the bottom, there's a slightly more complete version of this that
36 36 # can be useful during development of code here.
37 37
38 38 def mini_interactive_loop(input_func):
39 39 """Minimal example of the logic of an interactive interpreter loop.
40 40
41 41 This serves as an example, and it is used by the test system with a fake
42 42 raw_input that simulates interactive input."""
43 43
44 44 from IPython.core.inputsplitter import InputSplitter
45 45
46 46 isp = InputSplitter()
47 47 # In practice, this input loop would be wrapped in an outside loop to read
48 48 # input indefinitely, until some exit/quit command was issued. Here we
49 49 # only illustrate the basic inner loop.
50 50 while isp.push_accepts_more():
51 51 indent = ' '*isp.indent_spaces
52 52 prompt = '>>> ' + indent
53 53 line = indent + input_func(prompt)
54 54 isp.push(line)
55 55
56 56 # Here we just return input so we can use it in a test suite, but a real
57 57 # interpreter would instead send it for execution somewhere.
58 58 src = isp.source_reset()
59 59 #print 'Input source was:\n', src # dbg
60 60 return src
61 61
62 62 #-----------------------------------------------------------------------------
63 63 # Test utilities, just for local use
64 64 #-----------------------------------------------------------------------------
65 65
66 66 def assemble(block):
67 67 """Assemble a block into multi-line sub-blocks."""
68 68 return ['\n'.join(sub_block)+'\n' for sub_block in block]
69 69
70 70
71 71 def pseudo_input(lines):
72 72 """Return a function that acts like raw_input but feeds the input list."""
73 73 ilines = iter(lines)
74 74 def raw_in(prompt):
75 75 try:
76 76 return next(ilines)
77 77 except StopIteration:
78 78 return ''
79 79 return raw_in
80 80
81 81 #-----------------------------------------------------------------------------
82 82 # Tests
83 83 #-----------------------------------------------------------------------------
84 84 def test_spaces():
85 85 tests = [('', 0),
86 86 (' ', 1),
87 87 ('\n', 0),
88 88 (' \n', 1),
89 89 ('x', 0),
90 90 (' x', 1),
91 91 (' x',2),
92 92 (' x',4),
93 93 # Note: tabs are counted as a single whitespace!
94 94 ('\tx', 1),
95 95 ('\t x', 2),
96 96 ]
97 97 tt.check_pairs(isp.num_ini_spaces, tests)
98 98
99 99
100 100 def test_remove_comments():
101 101 tests = [('text', 'text'),
102 102 ('text # comment', 'text '),
103 103 ('text # comment\n', 'text \n'),
104 104 ('text # comment \n', 'text \n'),
105 105 ('line # c \nline\n','line \nline\n'),
106 106 ('line # c \nline#c2 \nline\nline #c\n\n',
107 107 'line \nline\nline\nline \n\n'),
108 108 ]
109 109 tt.check_pairs(isp.remove_comments, tests)
110 110
111 111 def test_has_comment():
112 112 tests = [('text', False),
113 113 ('text #comment', True),
114 114 ('text #comment\n', True),
115 115 ('#comment', True),
116 116 ('#comment\n', True),
117 117 ('a = "#string"', False),
118 118 ('a = "#string" # comment', True),
119 119 ('a #comment not "string"', True),
120 120 ]
121 121 tt.check_pairs(isp.has_comment, tests)
122 122
123 123
124 124 def test_get_input_encoding():
125 125 encoding = isp.get_input_encoding()
126 126 nt.assert_true(isinstance(encoding, basestring))
127 127 # simple-minded check that at least encoding a simple string works with the
128 128 # encoding we got.
129 129 nt.assert_equal(u'test'.encode(encoding), b'test')
130 130
131 131
132 132 class NoInputEncodingTestCase(unittest.TestCase):
133 133 def setUp(self):
134 134 self.old_stdin = sys.stdin
135 135 class X: pass
136 136 fake_stdin = X()
137 137 sys.stdin = fake_stdin
138 138
139 139 def test(self):
140 140 # Verify that if sys.stdin has no 'encoding' attribute we do the right
141 141 # thing
142 142 enc = isp.get_input_encoding()
143 143 self.assertEqual(enc, 'ascii')
144 144
145 145 def tearDown(self):
146 146 sys.stdin = self.old_stdin
147 147
148 148
149 149 class InputSplitterTestCase(unittest.TestCase):
150 150 def setUp(self):
151 151 self.isp = isp.InputSplitter()
152 152
153 153 def test_reset(self):
154 154 isp = self.isp
155 155 isp.push('x=1')
156 156 isp.reset()
157 157 self.assertEqual(isp._buffer, [])
158 158 self.assertEqual(isp.indent_spaces, 0)
159 159 self.assertEqual(isp.source, '')
160 160 self.assertEqual(isp.code, None)
161 161 self.assertEqual(isp._is_complete, False)
162 162
163 163 def test_source(self):
164 164 self.isp._store('1')
165 165 self.isp._store('2')
166 166 self.assertEqual(self.isp.source, '1\n2\n')
167 167 self.assertTrue(len(self.isp._buffer)>0)
168 168 self.assertEqual(self.isp.source_reset(), '1\n2\n')
169 169 self.assertEqual(self.isp._buffer, [])
170 170 self.assertEqual(self.isp.source, '')
171 171
172 172 def test_indent(self):
173 173 isp = self.isp # shorthand
174 174 isp.push('x=1')
175 175 self.assertEqual(isp.indent_spaces, 0)
176 176 isp.push('if 1:\n x=1')
177 177 self.assertEqual(isp.indent_spaces, 4)
178 178 isp.push('y=2\n')
179 179 self.assertEqual(isp.indent_spaces, 0)
180 180
181 181 def test_indent2(self):
182 182 # In cell mode, inputs must be fed in whole blocks, so skip this test
183 183 if self.isp.input_mode == 'cell': return
184 184
185 185 isp = self.isp
186 186 isp.push('if 1:')
187 187 self.assertEqual(isp.indent_spaces, 4)
188 188 isp.push(' x=1')
189 189 self.assertEqual(isp.indent_spaces, 4)
190 190 # Blank lines shouldn't change the indent level
191 191 isp.push(' '*2)
192 192 self.assertEqual(isp.indent_spaces, 4)
193 193
194 194 def test_indent3(self):
195 195 # In cell mode, inputs must be fed in whole blocks, so skip this test
196 196 if self.isp.input_mode == 'cell': return
197 197
198 198 isp = self.isp
199 199 # When a multiline statement contains parens or multiline strings, we
200 200 # shouldn't get confused.
201 201 isp.push("if 1:")
202 202 isp.push(" x = (1+\n 2)")
203 203 self.assertEqual(isp.indent_spaces, 4)
204 204
205 205 def test_indent4(self):
206 206 # In cell mode, inputs must be fed in whole blocks, so skip this test
207 207 if self.isp.input_mode == 'cell': return
208 208
209 209 isp = self.isp
210 210 # whitespace after ':' should not screw up indent level
211 211 isp.push('if 1: \n x=1')
212 212 self.assertEqual(isp.indent_spaces, 4)
213 213 isp.push('y=2\n')
214 214 self.assertEqual(isp.indent_spaces, 0)
215 215 isp.push('if 1:\t\n x=1')
216 216 self.assertEqual(isp.indent_spaces, 4)
217 217 isp.push('y=2\n')
218 218 self.assertEqual(isp.indent_spaces, 0)
219 219
220 220 def test_dedent_pass(self):
221 221 isp = self.isp # shorthand
222 222 # should NOT cause dedent
223 223 isp.push('if 1:\n passes = 5')
224 224 self.assertEqual(isp.indent_spaces, 4)
225 225 isp.push('if 1:\n pass')
226 226 self.assertEqual(isp.indent_spaces, 0)
227 227 isp.push('if 1:\n pass ')
228 228 self.assertEqual(isp.indent_spaces, 0)
229 229
230 230 def test_dedent_raise(self):
231 231 isp = self.isp # shorthand
232 232 # should NOT cause dedent
233 233 isp.push('if 1:\n raised = 4')
234 234 self.assertEqual(isp.indent_spaces, 4)
235 235 isp.push('if 1:\n raise TypeError()')
236 236 self.assertEqual(isp.indent_spaces, 0)
237 237 isp.push('if 1:\n raise')
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
242 242 def test_dedent_return(self):
243 243 isp = self.isp # shorthand
244 244 # should NOT cause dedent
245 245 isp.push('if 1:\n returning = 4')
246 246 self.assertEqual(isp.indent_spaces, 4)
247 247 isp.push('if 1:\n return 5 + 493')
248 248 self.assertEqual(isp.indent_spaces, 0)
249 249 isp.push('if 1:\n return')
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(0)')
254 254 self.assertEqual(isp.indent_spaces, 0)
255 255
256 256 def test_push(self):
257 257 isp = self.isp
258 258 self.assertTrue(isp.push('x=1'))
259 259
260 260 def test_push2(self):
261 261 isp = self.isp
262 262 self.assertFalse(isp.push('if 1:'))
263 263 for line in [' x=1', '# a comment', ' y=2']:
264 264 self.assertTrue(isp.push(line))
265 265
266 266 def test_push3(self):
267 267 isp = self.isp
268 268 isp.push('if True:')
269 269 isp.push(' a = 1')
270 270 self.assertFalse(isp.push('b = [1,'))
271 271
272 272 def test_replace_mode(self):
273 273 isp = self.isp
274 274 isp.input_mode = 'cell'
275 275 isp.push('x=1')
276 276 self.assertEqual(isp.source, 'x=1\n')
277 277 isp.push('x=2')
278 278 self.assertEqual(isp.source, 'x=2\n')
279 279
280 280 def test_push_accepts_more(self):
281 281 isp = self.isp
282 282 isp.push('x=1')
283 283 self.assertFalse(isp.push_accepts_more())
284 284
285 285 def test_push_accepts_more2(self):
286 286 # In cell mode, inputs must be fed in whole blocks, so skip this test
287 287 if self.isp.input_mode == 'cell': return
288 288
289 289 isp = self.isp
290 290 isp.push('if 1:')
291 291 self.assertTrue(isp.push_accepts_more())
292 292 isp.push(' x=1')
293 293 self.assertTrue(isp.push_accepts_more())
294 294 isp.push('')
295 295 self.assertFalse(isp.push_accepts_more())
296 296
297 297 def test_push_accepts_more3(self):
298 298 isp = self.isp
299 299 isp.push("x = (2+\n3)")
300 300 self.assertFalse(isp.push_accepts_more())
301 301
302 302 def test_push_accepts_more4(self):
303 303 # In cell mode, inputs must be fed in whole blocks, so skip this test
304 304 if self.isp.input_mode == 'cell': return
305 305
306 306 isp = self.isp
307 307 # When a multiline statement contains parens or multiline strings, we
308 308 # shouldn't get confused.
309 309 # FIXME: we should be able to better handle de-dents in statements like
310 310 # multiline strings and multiline expressions (continued with \ or
311 311 # parens). Right now we aren't handling the indentation tracking quite
312 312 # correctly with this, though in practice it may not be too much of a
313 313 # problem. We'll need to see.
314 314 isp.push("if 1:")
315 315 isp.push(" x = (2+")
316 316 isp.push(" 3)")
317 317 self.assertTrue(isp.push_accepts_more())
318 318 isp.push(" y = 3")
319 319 self.assertTrue(isp.push_accepts_more())
320 320 isp.push('')
321 321 self.assertFalse(isp.push_accepts_more())
322 322
323 323 def test_push_accepts_more5(self):
324 324 # In cell mode, inputs must be fed in whole blocks, so skip this test
325 325 if self.isp.input_mode == 'cell': return
326 326
327 327 isp = self.isp
328 328 isp.push('try:')
329 329 isp.push(' a = 5')
330 330 isp.push('except:')
331 331 isp.push(' raise')
332 332 self.assertTrue(isp.push_accepts_more())
333 333
334 334 def test_continuation(self):
335 335 isp = self.isp
336 336 isp.push("import os, \\")
337 337 self.assertTrue(isp.push_accepts_more())
338 338 isp.push("sys")
339 339 self.assertFalse(isp.push_accepts_more())
340 340
341 341 def test_syntax_error(self):
342 342 isp = self.isp
343 343 # Syntax errors immediately produce a 'ready' block, so the invalid
344 344 # Python can be sent to the kernel for evaluation with possible ipython
345 345 # special-syntax conversion.
346 346 isp.push('run foo')
347 347 self.assertFalse(isp.push_accepts_more())
348 348
349 349 def test_unicode(self):
350 350 self.isp.push(u"Pérez")
351 351 self.isp.push(u'\xc3\xa9')
352 352 self.isp.push(u"u'\xc3\xa9'")
353 353
354 354 class InteractiveLoopTestCase(unittest.TestCase):
355 355 """Tests for an interactive loop like a python shell.
356 356 """
357 357 def check_ns(self, lines, ns):
358 358 """Validate that the given input lines produce the resulting namespace.
359 359
360 360 Note: the input lines are given exactly as they would be typed in an
361 361 auto-indenting environment, as mini_interactive_loop above already does
362 362 auto-indenting and prepends spaces to the input.
363 363 """
364 364 src = mini_interactive_loop(pseudo_input(lines))
365 365 test_ns = {}
366 366 exec src in test_ns
367 367 # We can't check that the provided ns is identical to the test_ns,
368 368 # because Python fills test_ns with extra keys (copyright, etc). But
369 369 # we can check that the given dict is *contained* in test_ns
370 370 for k,v in ns.iteritems():
371 371 self.assertEqual(test_ns[k], v)
372 372
373 373 def test_simple(self):
374 374 self.check_ns(['x=1'], dict(x=1))
375 375
376 376 def test_simple2(self):
377 377 self.check_ns(['if 1:', 'x=2'], dict(x=2))
378 378
379 379 def test_xy(self):
380 380 self.check_ns(['x=1; y=2'], dict(x=1, y=2))
381 381
382 382 def test_abc(self):
383 383 self.check_ns(['if 1:','a=1','b=2','c=3'], dict(a=1, b=2, c=3))
384 384
385 385 def test_multi(self):
386 386 self.check_ns(['x =(1+','1+','2)'], dict(x=4))
387 387
388 388
389 389 def test_LineInfo():
390 390 """Simple test for LineInfo construction and str()"""
391 391 linfo = isp.LineInfo(' %cd /home')
392 392 nt.assert_equals(str(linfo), 'LineInfo [ |%|cd|/home]')
393 393
394 394 # Transformer tests
395 395 def transform_checker(tests, func):
396 396 """Utility to loop over test inputs"""
397 397 for inp, tr in tests:
398 398 nt.assert_equals(func(inp), tr)
399 399
400 400 # Data for all the syntax tests in the form of lists of pairs of
401 401 # raw/transformed input. We store it here as a global dict so that we can use
402 402 # it both within single-function tests and also to validate the behavior of the
403 403 # larger objects
404 404
405 405 syntax = \
406 406 dict(assign_system =
407 407 [(i,py3compat.u_format(o)) for i,o in \
408 408 [(u'a =! ls', "a = get_ipython().getoutput({u}'ls')"),
409 409 (u'b = !ls', "b = get_ipython().getoutput({u}'ls')"),
410 410 ('x=1', 'x=1'), # normal input is unmodified
411 411 (' ',' '), # blank lines are kept intact
412 412 ]],
413 413
414 414 assign_magic =
415 415 [(i,py3compat.u_format(o)) for i,o in \
416 416 [(u'a =% who', "a = get_ipython().magic({u}'who')"),
417 417 (u'b = %who', "b = get_ipython().magic({u}'who')"),
418 418 ('x=1', 'x=1'), # normal input is unmodified
419 419 (' ',' '), # blank lines are kept intact
420 420 ]],
421 421
422 422 classic_prompt =
423 423 [('>>> x=1', 'x=1'),
424 424 ('x=1', 'x=1'), # normal input is unmodified
425 425 (' ', ' '), # blank lines are kept intact
426 426 ('... ', ''), # continuation prompts
427 427 ],
428 428
429 429 ipy_prompt =
430 430 [('In [1]: x=1', 'x=1'),
431 431 ('x=1', 'x=1'), # normal input is unmodified
432 432 (' ',' '), # blank lines are kept intact
433 433 (' ....: ', ''), # continuation prompts
434 434 ],
435 435
436 436 # Tests for the escape transformer to leave normal code alone
437 437 escaped_noesc =
438 438 [ (' ', ' '),
439 439 ('x=1', 'x=1'),
440 440 ],
441 441
442 442 # System calls
443 443 escaped_shell =
444 444 [(i,py3compat.u_format(o)) for i,o in \
445 445 [ (u'!ls', "get_ipython().system({u}'ls')"),
446 446 # Double-escape shell, this means to capture the output of the
447 447 # subprocess and return it
448 448 (u'!!ls', "get_ipython().getoutput({u}'ls')"),
449 449 ]],
450 450
451 451 # Help/object info
452 452 escaped_help =
453 453 [(i,py3compat.u_format(o)) for i,o in \
454 454 [ (u'?', 'get_ipython().show_usage()'),
455 455 (u'?x1', "get_ipython().magic({u}'pinfo x1')"),
456 456 (u'??x2', "get_ipython().magic({u}'pinfo2 x2')"),
457 457 (u'?a.*s', "get_ipython().magic({u}'psearch a.*s')"),
458 458 (u'?%hist', "get_ipython().magic({u}'pinfo %hist')"),
459 459 (u'?abc = qwe', "get_ipython().magic({u}'pinfo abc')"),
460 460 ]],
461 461
462 462 end_help =
463 463 [(i,py3compat.u_format(o)) for i,o in \
464 464 [ (u'x3?', "get_ipython().magic({u}'pinfo x3')"),
465 465 (u'x4??', "get_ipython().magic({u}'pinfo2 x4')"),
466 466 (u'%hist?', "get_ipython().magic({u}'pinfo %hist')"),
467 467 (u'f*?', "get_ipython().magic({u}'psearch f*')"),
468 468 (u'ax.*aspe*?', "get_ipython().magic({u}'psearch ax.*aspe*')"),
469 (u'a = abc?', "get_ipython().magic({u}'pinfo abc', next_input={u}'a = abc')"),
470 (u'a = abc.qe??', "get_ipython().magic({u}'pinfo2 abc.qe', next_input={u}'a = abc.qe')"),
471 (u'a = *.items?', "get_ipython().magic({u}'psearch *.items', next_input={u}'a = *.items')"),
472 (u'plot(a?', "get_ipython().magic({u}'pinfo a', next_input={u}'plot(a')"),
469 (u'a = abc?', "get_ipython().set_next_input({u}'a = abc');"
470 "get_ipython().magic({u}'pinfo abc')"),
471 (u'a = abc.qe??', "get_ipython().set_next_input({u}'a = abc.qe');"
472 "get_ipython().magic({u}'pinfo2 abc.qe')"),
473 (u'a = *.items?', "get_ipython().set_next_input({u}'a = *.items');"
474 "get_ipython().magic({u}'psearch *.items')"),
475 (u'plot(a?', "get_ipython().set_next_input({u}'plot(a');"
476 "get_ipython().magic({u}'pinfo a')"),
473 477 (u'a*2 #comment?', 'a*2 #comment?'),
474 478 ]],
475 479
476 480 # Explicit magic calls
477 481 escaped_magic =
478 482 [(i,py3compat.u_format(o)) for i,o in \
479 483 [ (u'%cd', "get_ipython().magic({u}'cd')"),
480 484 (u'%cd /home', "get_ipython().magic({u}'cd /home')"),
481 485 # Backslashes need to be escaped.
482 486 (u'%cd C:\\User', "get_ipython().magic({u}'cd C:\\\\User')"),
483 487 (u' %magic', " get_ipython().magic({u}'magic')"),
484 488 ]],
485 489
486 490 # Quoting with separate arguments
487 491 escaped_quote =
488 492 [ (',f', 'f("")'),
489 493 (',f x', 'f("x")'),
490 494 (' ,f y', ' f("y")'),
491 495 (',f a b', 'f("a", "b")'),
492 496 ],
493 497
494 498 # Quoting with single argument
495 499 escaped_quote2 =
496 500 [ (';f', 'f("")'),
497 501 (';f x', 'f("x")'),
498 502 (' ;f y', ' f("y")'),
499 503 (';f a b', 'f("a b")'),
500 504 ],
501 505
502 506 # Simply apply parens
503 507 escaped_paren =
504 508 [ ('/f', 'f()'),
505 509 ('/f x', 'f(x)'),
506 510 (' /f y', ' f(y)'),
507 511 ('/f a b', 'f(a, b)'),
508 512 ],
509 513
510 514 # Check that we transform prompts before other transforms
511 515 mixed =
512 516 [(i,py3compat.u_format(o)) for i,o in \
513 517 [ (u'In [1]: %lsmagic', "get_ipython().magic({u}'lsmagic')"),
514 518 (u'>>> %lsmagic', "get_ipython().magic({u}'lsmagic')"),
515 519 (u'In [2]: !ls', "get_ipython().system({u}'ls')"),
516 520 (u'In [3]: abs?', "get_ipython().magic({u}'pinfo abs')"),
517 521 (u'In [4]: b = %who', "b = get_ipython().magic({u}'who')"),
518 522 ]],
519 523 )
520 524
521 525 # multiline syntax examples. Each of these should be a list of lists, with
522 526 # each entry itself having pairs of raw/transformed input. The union (with
523 527 # '\n'.join() of the transformed inputs is what the splitter should produce
524 528 # when fed the raw lines one at a time via push.
525 529 syntax_ml = \
526 530 dict(classic_prompt =
527 531 [ [('>>> for i in range(10):','for i in range(10):'),
528 532 ('... print i',' print i'),
529 533 ('... ', ''),
530 534 ],
531 535 ],
532 536
533 537 ipy_prompt =
534 538 [ [('In [24]: for i in range(10):','for i in range(10):'),
535 539 (' ....: print i',' print i'),
536 540 (' ....: ', ''),
537 541 ],
538 542 ],
539 543
540 544 multiline_datastructure =
541 545 [ [('>>> a = [1,','a = [1,'),
542 546 ('... 2]','2]'),
543 547 ],
544 548 ],
545 549 )
546 550
547 551
548 552 def test_assign_system():
549 553 tt.check_pairs(isp.transform_assign_system, syntax['assign_system'])
550 554
551 555
552 556 def test_assign_magic():
553 557 tt.check_pairs(isp.transform_assign_magic, syntax['assign_magic'])
554 558
555 559
556 560 def test_classic_prompt():
557 561 transform_checker(syntax['classic_prompt'], isp.transform_classic_prompt)
558 562 for example in syntax_ml['classic_prompt']:
559 563 transform_checker(example, isp.transform_classic_prompt)
560 564
561 565
562 566 def test_ipy_prompt():
563 567 transform_checker(syntax['ipy_prompt'], isp.transform_ipy_prompt)
564 568 for example in syntax_ml['ipy_prompt']:
565 569 transform_checker(example, isp.transform_ipy_prompt)
566 570
567 571 def test_end_help():
568 572 tt.check_pairs(isp.transform_help_end, syntax['end_help'])
569 573
570 574 def test_escaped_noesc():
571 575 tt.check_pairs(isp.transform_escaped, syntax['escaped_noesc'])
572 576
573 577
574 578 def test_escaped_shell():
575 579 tt.check_pairs(isp.transform_escaped, syntax['escaped_shell'])
576 580
577 581
578 582 def test_escaped_help():
579 583 tt.check_pairs(isp.transform_escaped, syntax['escaped_help'])
580 584
581 585
582 586 def test_escaped_magic():
583 587 tt.check_pairs(isp.transform_escaped, syntax['escaped_magic'])
584 588
585 589
586 590 def test_escaped_quote():
587 591 tt.check_pairs(isp.transform_escaped, syntax['escaped_quote'])
588 592
589 593
590 594 def test_escaped_quote2():
591 595 tt.check_pairs(isp.transform_escaped, syntax['escaped_quote2'])
592 596
593 597
594 598 def test_escaped_paren():
595 599 tt.check_pairs(isp.transform_escaped, syntax['escaped_paren'])
596 600
597 601
598 602 class IPythonInputTestCase(InputSplitterTestCase):
599 603 """By just creating a new class whose .isp is a different instance, we
600 604 re-run the same test battery on the new input splitter.
601 605
602 606 In addition, this runs the tests over the syntax and syntax_ml dicts that
603 607 were tested by individual functions, as part of the OO interface.
604 608
605 609 It also makes some checks on the raw buffer storage.
606 610 """
607 611
608 612 def setUp(self):
609 613 self.isp = isp.IPythonInputSplitter(input_mode='line')
610 614
611 615 def test_syntax(self):
612 616 """Call all single-line syntax tests from the main object"""
613 617 isp = self.isp
614 618 for example in syntax.itervalues():
615 619 for raw, out_t in example:
616 620 if raw.startswith(' '):
617 621 continue
618 622
619 623 isp.push(raw)
620 624 out, out_raw = isp.source_raw_reset()
621 625 self.assertEqual(out.rstrip(), out_t,
622 626 tt.pair_fail_msg.format("inputsplitter",raw, out_t, out))
623 627 self.assertEqual(out_raw.rstrip(), raw.rstrip())
624 628
625 629 def test_syntax_multiline(self):
626 630 isp = self.isp
627 631 for example in syntax_ml.itervalues():
628 632 out_t_parts = []
629 633 raw_parts = []
630 634 for line_pairs in example:
631 635 for lraw, out_t_part in line_pairs:
632 636 isp.push(lraw)
633 637 out_t_parts.append(out_t_part)
634 638 raw_parts.append(lraw)
635 639
636 640 out, out_raw = isp.source_raw_reset()
637 641 out_t = '\n'.join(out_t_parts).rstrip()
638 642 raw = '\n'.join(raw_parts).rstrip()
639 643 self.assertEqual(out.rstrip(), out_t)
640 644 self.assertEqual(out_raw.rstrip(), raw)
641 645
642 646
643 647 class BlockIPythonInputTestCase(IPythonInputTestCase):
644 648
645 649 # Deactivate tests that don't make sense for the block mode
646 650 test_push3 = test_split = lambda s: None
647 651
648 652 def setUp(self):
649 653 self.isp = isp.IPythonInputSplitter(input_mode='cell')
650 654
651 655 def test_syntax_multiline(self):
652 656 isp = self.isp
653 657 for example in syntax_ml.itervalues():
654 658 raw_parts = []
655 659 out_t_parts = []
656 660 for line_pairs in example:
657 661 for raw, out_t_part in line_pairs:
658 662 raw_parts.append(raw)
659 663 out_t_parts.append(out_t_part)
660 664
661 665 raw = '\n'.join(raw_parts)
662 666 out_t = '\n'.join(out_t_parts)
663 667
664 668 isp.push(raw)
665 669 out, out_raw = isp.source_raw_reset()
666 670 # Match ignoring trailing whitespace
667 671 self.assertEqual(out.rstrip(), out_t.rstrip())
668 672 self.assertEqual(out_raw.rstrip(), raw.rstrip())
669 673
670 674
671 675 #-----------------------------------------------------------------------------
672 676 # Main - use as a script, mostly for developer experiments
673 677 #-----------------------------------------------------------------------------
674 678
675 679 if __name__ == '__main__':
676 680 # A simple demo for interactive experimentation. This code will not get
677 681 # picked up by any test suite.
678 682 from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
679 683
680 684 # configure here the syntax to use, prompt and whether to autoindent
681 685 #isp, start_prompt = InputSplitter(), '>>> '
682 686 isp, start_prompt = IPythonInputSplitter(), 'In> '
683 687
684 688 autoindent = True
685 689 #autoindent = False
686 690
687 691 try:
688 692 while True:
689 693 prompt = start_prompt
690 694 while isp.push_accepts_more():
691 695 indent = ' '*isp.indent_spaces
692 696 if autoindent:
693 697 line = indent + raw_input(prompt+indent)
694 698 else:
695 699 line = raw_input(prompt)
696 700 isp.push(line)
697 701 prompt = '... '
698 702
699 703 # Here we just return input so we can use it in a test suite, but a
700 704 # real interpreter would instead send it for execution somewhere.
701 705 #src = isp.source; raise EOFError # dbg
702 706 src, raw = isp.source_raw_reset()
703 707 print 'Input source was:\n', src
704 708 print 'Raw source was:\n', raw
705 709 except EOFError:
706 710 print 'Bye'
@@ -1,487 +1,492 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Tests for various magic functions.
3 3
4 4 Needs to be run by nose (to make ipython session available).
5 5 """
6 6 from __future__ import absolute_import
7 7
8 8 #-----------------------------------------------------------------------------
9 9 # Imports
10 10 #-----------------------------------------------------------------------------
11 11
12 12 import io
13 13 import os
14 14 import sys
15 15 from StringIO import StringIO
16 from unittest import TestCase
16 17
17 18 import nose.tools as nt
18 19
19 20 from IPython.core import magic
21 from IPython.core.magic import (Magics, magics_class, line_magic,
22 cell_magic, line_cell_magic,
23 register_line_magic, register_cell_magic,
24 register_line_cell_magic)
20 25 from IPython.core.magics import execution
21 26 from IPython.nbformat.v3.tests.nbexamples import nb0
22 27 from IPython.nbformat import current
23 28 from IPython.testing import decorators as dec
24 29 from IPython.testing import tools as tt
25 30 from IPython.utils import py3compat
26 31 from IPython.utils.tempdir import TemporaryDirectory
27 32
28 33 #-----------------------------------------------------------------------------
29 34 # Test functions begin
30 35 #-----------------------------------------------------------------------------
31 36
32 37 @magic.magics_class
33 38 class DummyMagics(magic.Magics): pass
34 39
35 40 def test_rehashx():
36 41 # clear up everything
37 42 _ip = get_ipython()
38 43 _ip.alias_manager.alias_table.clear()
39 44 del _ip.db['syscmdlist']
40 45
41 46 _ip.magic('rehashx')
42 47 # Practically ALL ipython development systems will have more than 10 aliases
43 48
44 49 yield (nt.assert_true, len(_ip.alias_manager.alias_table) > 10)
45 50 for key, val in _ip.alias_manager.alias_table.iteritems():
46 51 # we must strip dots from alias names
47 52 nt.assert_true('.' not in key)
48 53
49 54 # rehashx must fill up syscmdlist
50 55 scoms = _ip.db['syscmdlist']
51 56 yield (nt.assert_true, len(scoms) > 10)
52 57
53 58
54 59 def test_magic_parse_options():
55 60 """Test that we don't mangle paths when parsing magic options."""
56 61 ip = get_ipython()
57 62 path = 'c:\\x'
58 63 m = DummyMagics(ip)
59 64 opts = m.parse_options('-f %s' % path,'f:')[0]
60 65 # argv splitting is os-dependent
61 66 if os.name == 'posix':
62 67 expected = 'c:x'
63 68 else:
64 69 expected = path
65 70 nt.assert_equals(opts['f'], expected)
66 71
67 72
68 73 @dec.skip_without('sqlite3')
69 74 def doctest_hist_f():
70 75 """Test %hist -f with temporary filename.
71 76
72 77 In [9]: import tempfile
73 78
74 79 In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
75 80
76 81 In [11]: %hist -nl -f $tfile 3
77 82
78 83 In [13]: import os; os.unlink(tfile)
79 84 """
80 85
81 86
82 87 @dec.skip_without('sqlite3')
83 88 def doctest_hist_r():
84 89 """Test %hist -r
85 90
86 91 XXX - This test is not recording the output correctly. For some reason, in
87 92 testing mode the raw history isn't getting populated. No idea why.
88 93 Disabling the output checking for now, though at least we do run it.
89 94
90 95 In [1]: 'hist' in _ip.lsmagic()
91 96 Out[1]: True
92 97
93 98 In [2]: x=1
94 99
95 100 In [3]: %hist -rl 2
96 101 x=1 # random
97 102 %hist -r 2
98 103 """
99 104
100 105
101 106 @dec.skip_without('sqlite3')
102 107 def doctest_hist_op():
103 108 """Test %hist -op
104 109
105 110 In [1]: class b(float):
106 111 ...: pass
107 112 ...:
108 113
109 114 In [2]: class s(object):
110 115 ...: def __str__(self):
111 116 ...: return 's'
112 117 ...:
113 118
114 119 In [3]:
115 120
116 121 In [4]: class r(b):
117 122 ...: def __repr__(self):
118 123 ...: return 'r'
119 124 ...:
120 125
121 126 In [5]: class sr(s,r): pass
122 127 ...:
123 128
124 129 In [6]:
125 130
126 131 In [7]: bb=b()
127 132
128 133 In [8]: ss=s()
129 134
130 135 In [9]: rr=r()
131 136
132 137 In [10]: ssrr=sr()
133 138
134 139 In [11]: 4.5
135 140 Out[11]: 4.5
136 141
137 142 In [12]: str(ss)
138 143 Out[12]: 's'
139 144
140 145 In [13]:
141 146
142 147 In [14]: %hist -op
143 148 >>> class b:
144 149 ... pass
145 150 ...
146 151 >>> class s(b):
147 152 ... def __str__(self):
148 153 ... return 's'
149 154 ...
150 155 >>>
151 156 >>> class r(b):
152 157 ... def __repr__(self):
153 158 ... return 'r'
154 159 ...
155 160 >>> class sr(s,r): pass
156 161 >>>
157 162 >>> bb=b()
158 163 >>> ss=s()
159 164 >>> rr=r()
160 165 >>> ssrr=sr()
161 166 >>> 4.5
162 167 4.5
163 168 >>> str(ss)
164 169 's'
165 170 >>>
166 171 """
167 172
168 173
169 174 @dec.skip_without('sqlite3')
170 175 def test_macro():
171 176 ip = get_ipython()
172 177 ip.history_manager.reset() # Clear any existing history.
173 178 cmds = ["a=1", "def b():\n return a**2", "print(a,b())"]
174 179 for i, cmd in enumerate(cmds, start=1):
175 180 ip.history_manager.store_inputs(i, cmd)
176 181 ip.magic("macro test 1-3")
177 182 nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n")
178 183
179 184 # List macros.
180 185 assert "test" in ip.magic("macro")
181 186
182 187
183 188 @dec.skip_without('sqlite3')
184 189 def test_macro_run():
185 190 """Test that we can run a multi-line macro successfully."""
186 191 ip = get_ipython()
187 192 ip.history_manager.reset()
188 193 cmds = ["a=10", "a+=1", py3compat.doctest_refactor_print("print a"),
189 194 "%macro test 2-3"]
190 195 for cmd in cmds:
191 196 ip.run_cell(cmd, store_history=True)
192 197 nt.assert_equal(ip.user_ns["test"].value,
193 198 py3compat.doctest_refactor_print("a+=1\nprint a\n"))
194 199 with tt.AssertPrints("12"):
195 200 ip.run_cell("test")
196 201 with tt.AssertPrints("13"):
197 202 ip.run_cell("test")
198 203
199 204
200 205 @dec.skipif_not_numpy
201 206 def test_numpy_reset_array_undec():
202 207 "Test '%reset array' functionality"
203 208 _ip.ex('import numpy as np')
204 209 _ip.ex('a = np.empty(2)')
205 210 yield (nt.assert_true, 'a' in _ip.user_ns)
206 211 _ip.magic('reset -f array')
207 212 yield (nt.assert_false, 'a' in _ip.user_ns)
208 213
209 214 def test_reset_out():
210 215 "Test '%reset out' magic"
211 216 _ip.run_cell("parrot = 'dead'", store_history=True)
212 217 # test '%reset -f out', make an Out prompt
213 218 _ip.run_cell("parrot", store_history=True)
214 219 nt.assert_true('dead' in [_ip.user_ns[x] for x in '_','__','___'])
215 220 _ip.magic('reset -f out')
216 221 nt.assert_false('dead' in [_ip.user_ns[x] for x in '_','__','___'])
217 222 nt.assert_true(len(_ip.user_ns['Out']) == 0)
218 223
219 224 def test_reset_in():
220 225 "Test '%reset in' magic"
221 226 # test '%reset -f in'
222 227 _ip.run_cell("parrot", store_history=True)
223 228 nt.assert_true('parrot' in [_ip.user_ns[x] for x in '_i','_ii','_iii'])
224 229 _ip.magic('%reset -f in')
225 230 nt.assert_false('parrot' in [_ip.user_ns[x] for x in '_i','_ii','_iii'])
226 231 nt.assert_true(len(set(_ip.user_ns['In'])) == 1)
227 232
228 233 def test_reset_dhist():
229 234 "Test '%reset dhist' magic"
230 235 _ip.run_cell("tmp = [d for d in _dh]") # copy before clearing
231 236 _ip.magic('cd ' + os.path.dirname(nt.__file__))
232 237 _ip.magic('cd -')
233 238 nt.assert_true(len(_ip.user_ns['_dh']) > 0)
234 239 _ip.magic('reset -f dhist')
235 240 nt.assert_true(len(_ip.user_ns['_dh']) == 0)
236 241 _ip.run_cell("_dh = [d for d in tmp]") #restore
237 242
238 243 def test_reset_in_length():
239 244 "Test that '%reset in' preserves In[] length"
240 245 _ip.run_cell("print 'foo'")
241 246 _ip.run_cell("reset -f in")
242 247 nt.assert_true(len(_ip.user_ns['In']) == _ip.displayhook.prompt_count+1)
243 248
244 249 def test_time():
245 250 _ip.magic('time None')
246 251
247 252 def test_tb_syntaxerror():
248 253 """test %tb after a SyntaxError"""
249 254 ip = get_ipython()
250 255 ip.run_cell("for")
251 256
252 257 # trap and validate stdout
253 258 save_stdout = sys.stdout
254 259 try:
255 260 sys.stdout = StringIO()
256 261 ip.run_cell("%tb")
257 262 out = sys.stdout.getvalue()
258 263 finally:
259 264 sys.stdout = save_stdout
260 265 # trim output, and only check the last line
261 266 last_line = out.rstrip().splitlines()[-1].strip()
262 267 nt.assert_equals(last_line, "SyntaxError: invalid syntax")
263 268
264 269
265 270 @py3compat.doctest_refactor_print
266 271 def doctest_time():
267 272 """
268 273 In [10]: %time None
269 274 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
270 275 Wall time: 0.00 s
271 276
272 277 In [11]: def f(kmjy):
273 278 ....: %time print 2*kmjy
274 279
275 280 In [12]: f(3)
276 281 6
277 282 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
278 283 Wall time: 0.00 s
279 284 """
280 285
281 286
282 287 def test_doctest_mode():
283 288 "Toggle doctest_mode twice, it should be a no-op and run without error"
284 289 _ip.magic('doctest_mode')
285 290 _ip.magic('doctest_mode')
286 291
287 292
288 293 def test_parse_options():
289 294 """Tests for basic options parsing in magics."""
290 295 # These are only the most minimal of tests, more should be added later. At
291 296 # the very least we check that basic text/unicode calls work OK.
292 297 m = DummyMagics(_ip)
293 298 nt.assert_equal(m.parse_options('foo', '')[1], 'foo')
294 299 nt.assert_equal(m.parse_options(u'foo', '')[1], u'foo')
295 300
296 301
297 302 def test_dirops():
298 303 """Test various directory handling operations."""
299 304 # curpath = lambda :os.path.splitdrive(os.getcwdu())[1].replace('\\','/')
300 305 curpath = os.getcwdu
301 306 startdir = os.getcwdu()
302 307 ipdir = os.path.realpath(_ip.ipython_dir)
303 308 try:
304 309 _ip.magic('cd "%s"' % ipdir)
305 310 nt.assert_equal(curpath(), ipdir)
306 311 _ip.magic('cd -')
307 312 nt.assert_equal(curpath(), startdir)
308 313 _ip.magic('pushd "%s"' % ipdir)
309 314 nt.assert_equal(curpath(), ipdir)
310 315 _ip.magic('popd')
311 316 nt.assert_equal(curpath(), startdir)
312 317 finally:
313 318 os.chdir(startdir)
314 319
315 320
316 321 def test_xmode():
317 322 # Calling xmode three times should be a no-op
318 323 xmode = _ip.InteractiveTB.mode
319 324 for i in range(3):
320 325 _ip.magic("xmode")
321 326 nt.assert_equal(_ip.InteractiveTB.mode, xmode)
322 327
323 328 def test_reset_hard():
324 329 monitor = []
325 330 class A(object):
326 331 def __del__(self):
327 332 monitor.append(1)
328 333 def __repr__(self):
329 334 return "<A instance>"
330 335
331 336 _ip.user_ns["a"] = A()
332 337 _ip.run_cell("a")
333 338
334 339 nt.assert_equal(monitor, [])
335 340 _ip.magic("reset -f")
336 341 nt.assert_equal(monitor, [1])
337 342
338 343 class TestXdel(tt.TempFileMixin):
339 344 def test_xdel(self):
340 345 """Test that references from %run are cleared by xdel."""
341 346 src = ("class A(object):\n"
342 347 " monitor = []\n"
343 348 " def __del__(self):\n"
344 349 " self.monitor.append(1)\n"
345 350 "a = A()\n")
346 351 self.mktmp(src)
347 352 # %run creates some hidden references...
348 353 _ip.magic("run %s" % self.fname)
349 354 # ... as does the displayhook.
350 355 _ip.run_cell("a")
351 356
352 357 monitor = _ip.user_ns["A"].monitor
353 358 nt.assert_equal(monitor, [])
354 359
355 360 _ip.magic("xdel a")
356 361
357 362 # Check that a's __del__ method has been called.
358 363 nt.assert_equal(monitor, [1])
359 364
360 365 def doctest_who():
361 366 """doctest for %who
362 367
363 368 In [1]: %reset -f
364 369
365 370 In [2]: alpha = 123
366 371
367 372 In [3]: beta = 'beta'
368 373
369 374 In [4]: %who int
370 375 alpha
371 376
372 377 In [5]: %who str
373 378 beta
374 379
375 380 In [6]: %whos
376 381 Variable Type Data/Info
377 382 ----------------------------
378 383 alpha int 123
379 384 beta str beta
380 385
381 386 In [7]: %who_ls
382 387 Out[7]: ['alpha', 'beta']
383 388 """
384 389
385 390 def test_whos():
386 391 """Check that whos is protected against objects where repr() fails."""
387 392 class A(object):
388 393 def __repr__(self):
389 394 raise Exception()
390 395 _ip.user_ns['a'] = A()
391 396 _ip.magic("whos")
392 397
393 398 @py3compat.u_format
394 399 def doctest_precision():
395 400 """doctest for %precision
396 401
397 402 In [1]: f = get_ipython().display_formatter.formatters['text/plain']
398 403
399 404 In [2]: %precision 5
400 405 Out[2]: {u}'%.5f'
401 406
402 407 In [3]: f.float_format
403 408 Out[3]: {u}'%.5f'
404 409
405 410 In [4]: %precision %e
406 411 Out[4]: {u}'%e'
407 412
408 413 In [5]: f(3.1415927)
409 414 Out[5]: {u}'3.141593e+00'
410 415 """
411 416
412 417 def test_psearch():
413 418 with tt.AssertPrints("dict.fromkeys"):
414 419 _ip.run_cell("dict.fr*?")
415 420
416 421 def test_timeit_shlex():
417 422 """test shlex issues with timeit (#1109)"""
418 423 _ip.ex("def f(*a,**kw): pass")
419 424 _ip.magic('timeit -n1 "this is a bug".count(" ")')
420 425 _ip.magic('timeit -r1 -n1 f(" ", 1)')
421 426 _ip.magic('timeit -r1 -n1 f(" ", 1, " ", 2, " ")')
422 427 _ip.magic('timeit -r1 -n1 ("a " + "b")')
423 428 _ip.magic('timeit -r1 -n1 f("a " + "b")')
424 429 _ip.magic('timeit -r1 -n1 f("a " + "b ")')
425 430
426 431
427 432 def test_timeit_arguments():
428 433 "Test valid timeit arguments, should not cause SyntaxError (GH #1269)"
429 434 _ip.magic("timeit ('#')")
430 435
431 436
432 437 @dec.skipif(execution.profile is None)
433 438 def test_prun_quotes():
434 439 "Test that prun does not clobber string escapes (GH #1302)"
435 440 _ip.magic("prun -q x = '\t'")
436 441 nt.assert_equal(_ip.user_ns['x'], '\t')
437 442
438 443 def test_extension():
439 444 tmpdir = TemporaryDirectory()
440 445 orig_ipython_dir = _ip.ipython_dir
441 446 try:
442 447 _ip.ipython_dir = tmpdir.name
443 448 nt.assert_raises(ImportError, _ip.magic, "load_ext daft_extension")
444 449 url = os.path.join(os.path.dirname(__file__), "daft_extension.py")
445 450 _ip.magic("install_ext %s" % url)
446 451 _ip.user_ns.pop('arq', None)
447 452 _ip.magic("load_ext daft_extension")
448 453 tt.assert_equal(_ip.user_ns['arq'], 185)
449 454 _ip.magic("unload_ext daft_extension")
450 455 assert 'arq' not in _ip.user_ns
451 456 finally:
452 457 _ip.ipython_dir = orig_ipython_dir
453 458
454 459 def test_notebook_export_json():
455 460 with TemporaryDirectory() as td:
456 461 outfile = os.path.join(td, "nb.ipynb")
457 462 _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
458 463 _ip.magic("notebook -e %s" % outfile)
459 464
460 465 def test_notebook_export_py():
461 466 with TemporaryDirectory() as td:
462 467 outfile = os.path.join(td, "nb.py")
463 468 _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
464 469 _ip.magic("notebook -e %s" % outfile)
465 470
466 471 def test_notebook_reformat_py():
467 472 with TemporaryDirectory() as td:
468 473 infile = os.path.join(td, "nb.ipynb")
469 474 with io.open(infile, 'w', encoding='utf-8') as f:
470 475 current.write(nb0, f, 'json')
471 476
472 477 _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
473 478 _ip.magic("notebook -f py %s" % infile)
474 479
475 480 def test_notebook_reformat_json():
476 481 with TemporaryDirectory() as td:
477 482 infile = os.path.join(td, "nb.py")
478 483 with io.open(infile, 'w', encoding='utf-8') as f:
479 484 current.write(nb0, f, 'py')
480 485
481 486 _ip.ex(py3compat.u_format(u"u = {u}'héllo'"))
482 487 _ip.magic("notebook -f ipynb %s" % infile)
483 488 _ip.magic("notebook -f json %s" % infile)
484 489
485 490 def test_env():
486 491 env = _ip.magic("env")
487 492 assert isinstance(env, dict), type(env)
General Comments 0
You need to be logged in to leave comments. Login now