##// END OF EJS Templates
Improved autosave code. Autosave thread termination is instantaneous.
Mani chandra -
Show More
@@ -1,544 +1,547 b''
1 1 """ History related magics and functionality """
2 2 #-----------------------------------------------------------------------------
3 3 # Copyright (C) 2010 The IPython Development Team.
4 4 #
5 5 # Distributed under the terms of the BSD License.
6 6 #
7 7 # The full license is in the file COPYING.txt, distributed with this software.
8 8 #-----------------------------------------------------------------------------
9 9
10 10 #-----------------------------------------------------------------------------
11 11 # Imports
12 12 #-----------------------------------------------------------------------------
13 13 from __future__ import print_function
14 14
15 15 # Stdlib imports
16 16 import fnmatch
17 17 import json
18 18 import os
19 19 import sys
20 20 import threading
21 21 import time
22 22
23 23 # Our own packages
24 24 import IPython.utils.io
25 25
26 26 from IPython.utils.pickleshare import PickleShareDB
27 27 from IPython.utils.io import ask_yes_no
28 28 from IPython.utils.warn import warn
29 29
30 30 #-----------------------------------------------------------------------------
31 31 # Classes and functions
32 32 #-----------------------------------------------------------------------------
33 33
34 34 class HistoryManager(object):
35 35 """A class to organize all history-related functionality in one place.
36 36 """
37 37 # Public interface
38 38
39 39 # An instance of the IPython shell we are attached to
40 40 shell = None
41 41 # A list to hold processed history
42 42 input_hist_parsed = None
43 43 # A list to hold raw history (as typed by user)
44 44 input_hist_raw = None
45 45 # A list of directories visited during session
46 46 dir_hist = None
47 47 # A dict of output history, keyed with ints from the shell's execution count
48 48 output_hist = None
49 49 # String with path to the history file
50 50 hist_file = None
51 51 # PickleShareDB instance holding the raw data for the shadow history
52 52 shadow_db = None
53 53 # ShadowHist instance with the actual shadow history
54 54 shadow_hist = None
55 55
56 56 # Private interface
57 57 # Variables used to store the three last inputs from the user. On each new
58 58 # history update, we populate the user's namespace with these, shifted as
59 59 # necessary.
60 60 _i00, _i, _ii, _iii = '','','',''
61 61
62 62 # A set with all forms of the exit command, so that we don't store them in
63 63 # the history (it's annoying to rewind the first entry and land on an exit
64 64 # call).
65 65 _exit_commands = None
66 66
67 67 def __init__(self, shell):
68 68 """Create a new history manager associated with a shell instance.
69 69 """
70 70 # We need a pointer back to the shell for various tasks.
71 71 self.shell = shell
72 72
73 73 # List of input with multi-line handling.
74 74 self.input_hist_parsed = []
75 75 # This one will hold the 'raw' input history, without any
76 76 # pre-processing. This will allow users to retrieve the input just as
77 77 # it was exactly typed in by the user, with %hist -r.
78 78 self.input_hist_raw = []
79 79
80 80 # list of visited directories
81 81 try:
82 82 self.dir_hist = [os.getcwd()]
83 83 except OSError:
84 84 self.dir_hist = []
85 85
86 86 # dict of output history
87 87 self.output_hist = {}
88 88
89 89 # Now the history file
90 90 if shell.profile:
91 91 histfname = 'history-%s' % shell.profile
92 92 else:
93 93 histfname = 'history'
94 94 self.hist_file = os.path.join(shell.ipython_dir, histfname + '.json')
95 95
96 96 # Objects related to shadow history management
97 97 self._init_shadow_hist()
98 98
99 99 self._i00, self._i, self._ii, self._iii = '','','',''
100 100
101 101 self._exit_commands = set(['Quit', 'quit', 'Exit', 'exit', '%Quit',
102 102 '%quit', '%Exit', '%exit'])
103 103
104 104 # Object is fully initialized, we can now call methods on it.
105 105
106 106 # Fill the history zero entry, user counter starts at 1
107 107 self.store_inputs('\n', '\n')
108 108
109 109 def _init_shadow_hist(self):
110 110 try:
111 111 self.shadow_db = PickleShareDB(os.path.join(
112 112 self.shell.ipython_dir, 'db'))
113 113 except UnicodeDecodeError:
114 114 print("Your ipython_dir can't be decoded to unicode!")
115 115 print("Please set HOME environment variable to something that")
116 116 print(r"only has ASCII characters, e.g. c:\home")
117 117 print("Now it is", self.ipython_dir)
118 118 sys.exit()
119 119 self.shadow_hist = ShadowHist(self.shadow_db, self.shell)
120 120
121 121 def populate_readline_history(self):
122 122 """Populate the readline history from the raw history.
123 123
124 124 We only store one copy of the raw history, which is persisted to a json
125 125 file on disk. The readline history is repopulated from the contents of
126 126 this file."""
127 127
128 128 try:
129 129 self.shell.readline.clear_history()
130 130 except AttributeError:
131 131 pass
132 132 else:
133 133 for h in self.input_hist_raw:
134 134 if not h.isspace():
135 135 for line in h.splitlines():
136 136 self.shell.readline.add_history(line)
137 137
138 138 def save_history(self):
139 139 """Save input history to a file (via readline library)."""
140 140 hist = dict(raw=self.input_hist_raw, #[-self.shell.history_length:],
141 141 parsed=self.input_hist_parsed) #[-self.shell.history_length:])
142 142 with open(self.hist_file,'wt') as hfile:
143 143 json.dump(hist, hfile,
144 144 sort_keys=True, indent=4)
145 145
146 146 def reload_history(self):
147 147 """Reload the input history from disk file."""
148 148
149 149 with open(self.hist_file,'rt') as hfile:
150 150 hist = json.load(hfile)
151 151 self.input_hist_parsed = hist['parsed']
152 152 self.input_hist_raw = hist['raw']
153 153 if self.shell.has_readline:
154 154 self.populate_readline_history()
155 155
156 156 def get_history(self, index=None, raw=False, output=True):
157 157 """Get the history list.
158 158
159 159 Get the input and output history.
160 160
161 161 Parameters
162 162 ----------
163 163 index : n or (n1, n2) or None
164 164 If n, then the last entries. If a tuple, then all in
165 165 range(n1, n2). If None, then all entries. Raises IndexError if
166 166 the format of index is incorrect.
167 167 raw : bool
168 168 If True, return the raw input.
169 169 output : bool
170 170 If True, then return the output as well.
171 171
172 172 Returns
173 173 -------
174 174 If output is True, then return a dict of tuples, keyed by the prompt
175 175 numbers and with values of (input, output). If output is False, then
176 176 a dict, keyed by the prompt number with the values of input. Raises
177 177 IndexError if no history is found.
178 178 """
179 179 if raw:
180 180 input_hist = self.input_hist_raw
181 181 else:
182 182 input_hist = self.input_hist_parsed
183 183 if output:
184 184 output_hist = self.output_hist
185 185 n = len(input_hist)
186 186 if index is None:
187 187 start=0; stop=n
188 188 elif isinstance(index, int):
189 189 start=n-index; stop=n
190 190 elif isinstance(index, tuple) and len(index) == 2:
191 191 start=index[0]; stop=index[1]
192 192 else:
193 193 raise IndexError('Not a valid index for the input history: %r'
194 194 % index)
195 195 hist = {}
196 196 for i in range(start, stop):
197 197 if output:
198 198 hist[i] = (input_hist[i], output_hist.get(i))
199 199 else:
200 200 hist[i] = input_hist[i]
201 201 if not hist:
202 202 raise IndexError('No history for range of indices: %r' % index)
203 203 return hist
204 204
205 205 def store_inputs(self, source, source_raw=None):
206 206 """Store source and raw input in history and create input cache
207 207 variables _i*.
208 208
209 209 Parameters
210 210 ----------
211 211 source : str
212 212 Python input.
213 213
214 214 source_raw : str, optional
215 215 If given, this is the raw input without any IPython transformations
216 216 applied to it. If not given, ``source`` is used.
217 217 """
218 218 if source_raw is None:
219 219 source_raw = source
220 220
221 221 # do not store exit/quit commands
222 222 if source_raw.strip() in self._exit_commands:
223 223 return
224 224
225 225 self.input_hist_parsed.append(source.rstrip())
226 226 self.input_hist_raw.append(source_raw.rstrip())
227 227 self.shadow_hist.add(source)
228 228
229 229 # update the auto _i variables
230 230 self._iii = self._ii
231 231 self._ii = self._i
232 232 self._i = self._i00
233 233 self._i00 = source_raw
234 234
235 235 # hackish access to user namespace to create _i1,_i2... dynamically
236 236 new_i = '_i%s' % self.shell.execution_count
237 237 to_main = {'_i': self._i,
238 238 '_ii': self._ii,
239 239 '_iii': self._iii,
240 240 new_i : self._i00 }
241 241 self.shell.user_ns.update(to_main)
242 242
243 243 def sync_inputs(self):
244 244 """Ensure raw and translated histories have same length."""
245 245 if len(self.input_hist_parsed) != len (self.input_hist_raw):
246 246 self.input_hist_raw[:] = self.input_hist_parsed
247 247
248 248 def reset(self):
249 249 """Clear all histories managed by this object."""
250 250 self.input_hist_parsed[:] = []
251 251 self.input_hist_raw[:] = []
252 252 self.output_hist.clear()
253 253 # The directory history can't be completely empty
254 254 self.dir_hist[:] = [os.getcwd()]
255 255
256 256 class HistorySaveThread(threading.Thread):
257 257 """Thread to save history periodically"""
258 258
259 259 def __init__(self, IPython_object, time_interval, exit_now):
260 260 threading.Thread.__init__(self)
261 261 self.IPython_object = IPython_object
262 262 self.time_interval = time_interval
263 263 self.exit_now = exit_now
264 self.cond = threading.Condition()
264 265
265 266 def run(self):
266 267 while 1:
268 self.cond.acquire()
269 self.cond.wait(self.time_interval)
270 self.cond.release()
267 271 if self.exit_now==True:
268 272 break
269 time.sleep(self.time_interval)
270 273 #printing for debug
271 #print("Saving...")
274 print("Saving...")
272 275 self.IPython_object.save_history()
273 276
274 277 def magic_history(self, parameter_s = ''):
275 278 """Print input history (_i<n> variables), with most recent last.
276 279
277 280 %history -> print at most 40 inputs (some may be multi-line)\\
278 281 %history n -> print at most n inputs\\
279 282 %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
280 283
281 284 By default, input history is printed without line numbers so it can be
282 285 directly pasted into an editor.
283 286
284 287 With -n, each input's number <n> is shown, and is accessible as the
285 288 automatically generated variable _i<n> as well as In[<n>]. Multi-line
286 289 statements are printed starting at a new line for easy copy/paste.
287 290
288 291 Options:
289 292
290 293 -n: print line numbers for each input.
291 294 This feature is only available if numbered prompts are in use.
292 295
293 296 -o: also print outputs for each input.
294 297
295 298 -p: print classic '>>>' python prompts before each input. This is useful
296 299 for making documentation, and in conjunction with -o, for producing
297 300 doctest-ready output.
298 301
299 302 -r: (default) print the 'raw' history, i.e. the actual commands you typed.
300 303
301 304 -t: print the 'translated' history, as IPython understands it. IPython
302 305 filters your input and converts it all into valid Python source before
303 306 executing it (things like magics or aliases are turned into function
304 307 calls, for example). With this option, you'll see the native history
305 308 instead of the user-entered version: '%cd /' will be seen as
306 309 'get_ipython().magic("%cd /")' instead of '%cd /'.
307 310
308 311 -g: treat the arg as a pattern to grep for in (full) history.
309 312 This includes the "shadow history" (almost all commands ever written).
310 313 Use '%hist -g' to show full shadow history (may be very long).
311 314 In shadow history, every index nuwber starts with 0.
312 315
313 316 -f FILENAME: instead of printing the output to the screen, redirect it to
314 317 the given file. The file is always overwritten, though IPython asks for
315 318 confirmation first if it already exists.
316 319 """
317 320
318 321 if not self.shell.displayhook.do_full_cache:
319 322 print('This feature is only available if numbered prompts are in use.')
320 323 return
321 324 opts,args = self.parse_options(parameter_s,'gnoptsrf:',mode='list')
322 325
323 326 # Check if output to specific file was requested.
324 327 try:
325 328 outfname = opts['f']
326 329 except KeyError:
327 330 outfile = IPython.utils.io.Term.cout # default
328 331 # We don't want to close stdout at the end!
329 332 close_at_end = False
330 333 else:
331 334 if os.path.exists(outfname):
332 335 if not ask_yes_no("File %r exists. Overwrite?" % outfname):
333 336 print('Aborting.')
334 337 return
335 338
336 339 outfile = open(outfname,'w')
337 340 close_at_end = True
338 341
339 342 if 't' in opts:
340 343 input_hist = self.shell.history_manager.input_hist_parsed
341 344 elif 'r' in opts:
342 345 input_hist = self.shell.history_manager.input_hist_raw
343 346 else:
344 347 # Raw history is the default
345 348 input_hist = self.shell.history_manager.input_hist_raw
346 349
347 350 default_length = 40
348 351 pattern = None
349 352 if 'g' in opts:
350 353 init = 1
351 354 final = len(input_hist)
352 355 parts = parameter_s.split(None, 1)
353 356 if len(parts) == 1:
354 357 parts += '*'
355 358 head, pattern = parts
356 359 pattern = "*" + pattern + "*"
357 360 elif len(args) == 0:
358 361 final = len(input_hist)-1
359 362 init = max(1,final-default_length)
360 363 elif len(args) == 1:
361 364 final = len(input_hist)
362 365 init = max(1, final-int(args[0]))
363 366 elif len(args) == 2:
364 367 init, final = map(int, args)
365 368 else:
366 369 warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
367 370 print(self.magic_hist.__doc__, file=IPython.utils.io.Term.cout)
368 371 return
369 372
370 373 width = len(str(final))
371 374 line_sep = ['','\n']
372 375 print_nums = 'n' in opts
373 376 print_outputs = 'o' in opts
374 377 pyprompts = 'p' in opts
375 378
376 379 found = False
377 380 if pattern is not None:
378 381 sh = self.shell.history_manager.shadowhist.all()
379 382 for idx, s in sh:
380 383 if fnmatch.fnmatch(s, pattern):
381 384 print("0%d: %s" %(idx, s.expandtabs(4)), file=outfile)
382 385 found = True
383 386
384 387 if found:
385 388 print("===", file=outfile)
386 389 print("shadow history ends, fetch by %rep <number> (must start with 0)",
387 390 file=outfile)
388 391 print("=== start of normal history ===", file=outfile)
389 392
390 393 for in_num in range(init, final):
391 394 # Print user history with tabs expanded to 4 spaces. The GUI clients
392 395 # use hard tabs for easier usability in auto-indented code, but we want
393 396 # to produce PEP-8 compliant history for safe pasting into an editor.
394 397 inline = input_hist[in_num].expandtabs(4).rstrip()+'\n'
395 398
396 399 if pattern is not None and not fnmatch.fnmatch(inline, pattern):
397 400 continue
398 401
399 402 multiline = int(inline.count('\n') > 1)
400 403 if print_nums:
401 404 print('%s:%s' % (str(in_num).ljust(width), line_sep[multiline]),
402 405 file=outfile)
403 406 if pyprompts:
404 407 print('>>>', file=outfile)
405 408 if multiline:
406 409 lines = inline.splitlines()
407 410 print('\n... '.join(lines), file=outfile)
408 411 print('... ', file=outfile)
409 412 else:
410 413 print(inline, end='', file=outfile)
411 414 else:
412 415 print(inline, end='', file=outfile)
413 416 if print_outputs:
414 417 output = self.shell.history_manager.output_hist.get(in_num)
415 418 if output is not None:
416 419 print(repr(output), file=outfile)
417 420
418 421 if close_at_end:
419 422 outfile.close()
420 423
421 424
422 425 def magic_hist(self, parameter_s=''):
423 426 """Alternate name for %history."""
424 427 return self.magic_history(parameter_s)
425 428
426 429
427 430 def rep_f(self, arg):
428 431 r""" Repeat a command, or get command to input line for editing
429 432
430 433 - %rep (no arguments):
431 434
432 435 Place a string version of last computation result (stored in the special '_'
433 436 variable) to the next input prompt. Allows you to create elaborate command
434 437 lines without using copy-paste::
435 438
436 439 $ l = ["hei", "vaan"]
437 440 $ "".join(l)
438 441 ==> heivaan
439 442 $ %rep
440 443 $ heivaan_ <== cursor blinking
441 444
442 445 %rep 45
443 446
444 447 Place history line 45 to next input prompt. Use %hist to find out the
445 448 number.
446 449
447 450 %rep 1-4 6-7 3
448 451
449 452 Repeat the specified lines immediately. Input slice syntax is the same as
450 453 in %macro and %save.
451 454
452 455 %rep foo
453 456
454 457 Place the most recent line that has the substring "foo" to next input.
455 458 (e.g. 'svn ci -m foobar').
456 459 """
457 460
458 461 opts,args = self.parse_options(arg,'',mode='list')
459 462 if not args:
460 463 self.set_next_input(str(self.shell.user_ns["_"]))
461 464 return
462 465
463 466 if len(args) == 1 and not '-' in args[0]:
464 467 arg = args[0]
465 468 if len(arg) > 1 and arg.startswith('0'):
466 469 # get from shadow hist
467 470 num = int(arg[1:])
468 471 line = self.shell.shadowhist.get(num)
469 472 self.set_next_input(str(line))
470 473 return
471 474 try:
472 475 num = int(args[0])
473 476 self.set_next_input(str(self.shell.input_hist_raw[num]).rstrip())
474 477 return
475 478 except ValueError:
476 479 pass
477 480
478 481 for h in reversed(self.shell.input_hist_raw):
479 482 if 'rep' in h:
480 483 continue
481 484 if fnmatch.fnmatch(h,'*' + arg + '*'):
482 485 self.set_next_input(str(h).rstrip())
483 486 return
484 487
485 488 try:
486 489 lines = self.extract_input_slices(args, True)
487 490 print("lines", lines)
488 491 self.run_cell(lines)
489 492 except ValueError:
490 493 print("Not found in recent history:", args)
491 494
492 495
493 496 _sentinel = object()
494 497
495 498 class ShadowHist(object):
496 499 def __init__(self, db, shell):
497 500 # cmd => idx mapping
498 501 self.curidx = 0
499 502 self.db = db
500 503 self.disabled = False
501 504 self.shell = shell
502 505
503 506 def inc_idx(self):
504 507 idx = self.db.get('shadowhist_idx', 1)
505 508 self.db['shadowhist_idx'] = idx + 1
506 509 return idx
507 510
508 511 def add(self, ent):
509 512 if self.disabled:
510 513 return
511 514 try:
512 515 old = self.db.hget('shadowhist', ent, _sentinel)
513 516 if old is not _sentinel:
514 517 return
515 518 newidx = self.inc_idx()
516 519 #print("new", newidx) # dbg
517 520 self.db.hset('shadowhist',ent, newidx)
518 521 except:
519 522 self.shell.showtraceback()
520 523 print("WARNING: disabling shadow history")
521 524 self.disabled = True
522 525
523 526 def all(self):
524 527 d = self.db.hdict('shadowhist')
525 528 items = [(i,s) for (s,i) in d.iteritems()]
526 529 items.sort()
527 530 return items
528 531
529 532 def get(self, idx):
530 533 all = self.all()
531 534
532 535 for k, v in all:
533 536 if k == idx:
534 537 return v
535 538
536 539
537 540 def init_ipython(ip):
538 541 ip.define_magic("rep",rep_f)
539 542 ip.define_magic("hist",magic_hist)
540 543 ip.define_magic("history",magic_history)
541 544
542 545 # XXX - ipy_completers are in quarantine, need to be updated to new apis
543 546 #import ipy_completers
544 547 #ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
@@ -1,2545 +1,2545 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-2010 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__
21 21 import __future__
22 22 import abc
23 23 import atexit
24 24 import codeop
25 25 import os
26 26 import re
27 27 import sys
28 28 import tempfile
29 29 import types
30 30 from contextlib import nested
31 31
32 32 from IPython.config.configurable import Configurable
33 33 from IPython.core import debugger, oinspect
34 34 from IPython.core import history as ipcorehist
35 35 from IPython.core import page
36 36 from IPython.core import prefilter
37 37 from IPython.core import shadowns
38 38 from IPython.core import ultratb
39 39 from IPython.core.alias import AliasManager
40 40 from IPython.core.builtin_trap import BuiltinTrap
41 41 from IPython.core.compilerop import CachingCompiler
42 42 from IPython.core.display_trap import DisplayTrap
43 43 from IPython.core.displayhook import DisplayHook
44 44 from IPython.core.error import TryNext, UsageError
45 45 from IPython.core.extensions import ExtensionManager
46 46 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
47 47 from IPython.core.history import HistoryManager
48 48 from IPython.core.history import HistorySaveThread
49 49 from IPython.core.inputsplitter import IPythonInputSplitter
50 50 from IPython.core.logger import Logger
51 51 from IPython.core.magic import Magic
52 52 from IPython.core.payload import PayloadManager
53 53 from IPython.core.plugin import PluginManager
54 54 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
55 55 from IPython.external.Itpl import ItplNS
56 56 from IPython.utils import PyColorize
57 57 from IPython.utils import io
58 58 from IPython.utils import pickleshare
59 59 from IPython.utils.doctestreload import doctest_reload
60 60 from IPython.utils.io import ask_yes_no, rprint
61 61 from IPython.utils.ipstruct import Struct
62 62 from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
63 63 from IPython.utils.process import system, getoutput
64 64 from IPython.utils.strdispatch import StrDispatch
65 65 from IPython.utils.syspathcontext import prepended_to_syspath
66 66 from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
67 67 from IPython.utils.traitlets import (Int, Str, CBool, CaselessStrEnum, Enum,
68 68 List, Unicode, Instance, Type)
69 69 from IPython.utils.warn import warn, error, fatal
70 70 import IPython.core.hooks
71 71
72 72 #-----------------------------------------------------------------------------
73 73 # Globals
74 74 #-----------------------------------------------------------------------------
75 75
76 76 # compiled regexps for autoindent management
77 77 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
78 78
79 79 #-----------------------------------------------------------------------------
80 80 # Utilities
81 81 #-----------------------------------------------------------------------------
82 82
83 83 # store the builtin raw_input globally, and use this always, in case user code
84 84 # overwrites it (like wx.py.PyShell does)
85 85 raw_input_original = raw_input
86 86
87 87 def softspace(file, newvalue):
88 88 """Copied from code.py, to remove the dependency"""
89 89
90 90 oldvalue = 0
91 91 try:
92 92 oldvalue = file.softspace
93 93 except AttributeError:
94 94 pass
95 95 try:
96 96 file.softspace = newvalue
97 97 except (AttributeError, TypeError):
98 98 # "attribute-less object" or "read-only attributes"
99 99 pass
100 100 return oldvalue
101 101
102 102
103 103 def no_op(*a, **kw): pass
104 104
105 105 class SpaceInInput(Exception): pass
106 106
107 107 class Bunch: pass
108 108
109 109
110 110 def get_default_colors():
111 111 if sys.platform=='darwin':
112 112 return "LightBG"
113 113 elif os.name=='nt':
114 114 return 'Linux'
115 115 else:
116 116 return 'Linux'
117 117
118 118
119 119 class SeparateStr(Str):
120 120 """A Str subclass to validate separate_in, separate_out, etc.
121 121
122 122 This is a Str based trait that converts '0'->'' and '\\n'->'\n'.
123 123 """
124 124
125 125 def validate(self, obj, value):
126 126 if value == '0': value = ''
127 127 value = value.replace('\\n','\n')
128 128 return super(SeparateStr, self).validate(obj, value)
129 129
130 130 class MultipleInstanceError(Exception):
131 131 pass
132 132
133 133
134 134 #-----------------------------------------------------------------------------
135 135 # Main IPython class
136 136 #-----------------------------------------------------------------------------
137 137
138 138 class InteractiveShell(Configurable, Magic):
139 139 """An enhanced, interactive shell for Python."""
140 140
141 141 _instance = None
142 142 autocall = Enum((0,1,2), default_value=1, config=True)
143 143 # TODO: remove all autoindent logic and put into frontends.
144 144 # We can't do this yet because even runlines uses the autoindent.
145 145 autoindent = CBool(True, config=True)
146 146 automagic = CBool(True, config=True)
147 147 cache_size = Int(1000, config=True)
148 148 color_info = CBool(True, config=True)
149 149 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
150 150 default_value=get_default_colors(), config=True)
151 151 debug = CBool(False, config=True)
152 152 deep_reload = CBool(False, config=True)
153 153 displayhook_class = Type(DisplayHook)
154 154 exit_now = CBool(False)
155 155 # Monotonically increasing execution counter
156 156 execution_count = Int(1)
157 157 filename = Str("<ipython console>")
158 158 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
159 159
160 160 # Input splitter, to split entire cells of input into either individual
161 161 # interactive statements or whole blocks.
162 162 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
163 163 (), {})
164 164 logstart = CBool(False, config=True)
165 165 logfile = Str('', config=True)
166 166 logappend = Str('', config=True)
167 167 object_info_string_level = Enum((0,1,2), default_value=0,
168 168 config=True)
169 169 pdb = CBool(False, config=True)
170 170
171 171 pprint = CBool(True, config=True)
172 172 profile = Str('', config=True)
173 173 prompt_in1 = Str('In [\\#]: ', config=True)
174 174 prompt_in2 = Str(' .\\D.: ', config=True)
175 175 prompt_out = Str('Out[\\#]: ', config=True)
176 176 prompts_pad_left = CBool(True, config=True)
177 177 quiet = CBool(False, config=True)
178 178
179 179 history_length = Int(10000, config=True)
180 180
181 181 # The readline stuff will eventually be moved to the terminal subclass
182 182 # but for now, we can't do that as readline is welded in everywhere.
183 183 readline_use = CBool(True, config=True)
184 184 readline_merge_completions = CBool(True, config=True)
185 185 readline_omit__names = Enum((0,1,2), default_value=2, config=True)
186 186 readline_remove_delims = Str('-/~', config=True)
187 187 readline_parse_and_bind = List([
188 188 'tab: complete',
189 189 '"\C-l": clear-screen',
190 190 'set show-all-if-ambiguous on',
191 191 '"\C-o": tab-insert',
192 192 '"\M-i": " "',
193 193 '"\M-o": "\d\d\d\d"',
194 194 '"\M-I": "\d\d\d\d"',
195 195 '"\C-r": reverse-search-history',
196 196 '"\C-s": forward-search-history',
197 197 '"\C-p": history-search-backward',
198 198 '"\C-n": history-search-forward',
199 199 '"\e[A": history-search-backward',
200 200 '"\e[B": history-search-forward',
201 201 '"\C-k": kill-line',
202 202 '"\C-u": unix-line-discard',
203 203 ], allow_none=False, config=True)
204 204
205 205 # TODO: this part of prompt management should be moved to the frontends.
206 206 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
207 207 separate_in = SeparateStr('\n', config=True)
208 208 separate_out = SeparateStr('', config=True)
209 209 separate_out2 = SeparateStr('', config=True)
210 210 wildcards_case_sensitive = CBool(True, config=True)
211 211 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
212 212 default_value='Context', config=True)
213 213
214 214 # Subcomponents of InteractiveShell
215 215 alias_manager = Instance('IPython.core.alias.AliasManager')
216 216 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
217 217 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
218 218 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
219 219 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
220 220 plugin_manager = Instance('IPython.core.plugin.PluginManager')
221 221 payload_manager = Instance('IPython.core.payload.PayloadManager')
222 222 history_manager = Instance('IPython.core.history.HistoryManager')
223 223
224 224 # Private interface
225 225 _post_execute = set()
226 226
227 227 def __init__(self, config=None, ipython_dir=None,
228 228 user_ns=None, user_global_ns=None,
229 229 custom_exceptions=((), None)):
230 230
231 231 # This is where traits with a config_key argument are updated
232 232 # from the values on config.
233 233 super(InteractiveShell, self).__init__(config=config)
234 234
235 235 # These are relatively independent and stateless
236 236 self.init_ipython_dir(ipython_dir)
237 237 self.init_instance_attrs()
238 238 self.init_environment()
239 239
240 240 # Create namespaces (user_ns, user_global_ns, etc.)
241 241 self.init_create_namespaces(user_ns, user_global_ns)
242 242 # This has to be done after init_create_namespaces because it uses
243 243 # something in self.user_ns, but before init_sys_modules, which
244 244 # is the first thing to modify sys.
245 245 # TODO: When we override sys.stdout and sys.stderr before this class
246 246 # is created, we are saving the overridden ones here. Not sure if this
247 247 # is what we want to do.
248 248 self.save_sys_module_state()
249 249 self.init_sys_modules()
250 250
251 251 self.init_history()
252 252 self.init_encoding()
253 253 self.init_prefilter()
254 254
255 255 Magic.__init__(self, self)
256 256
257 257 self.init_syntax_highlighting()
258 258 self.init_hooks()
259 259 self.init_pushd_popd_magic()
260 260 # self.init_traceback_handlers use to be here, but we moved it below
261 261 # because it and init_io have to come after init_readline.
262 262 self.init_user_ns()
263 263 self.init_logger()
264 264 self.init_alias()
265 265 self.init_builtins()
266 266
267 267 # pre_config_initialization
268 268
269 269 # The next section should contain everything that was in ipmaker.
270 270 self.init_logstart()
271 271
272 272 # The following was in post_config_initialization
273 273 self.init_inspector()
274 274 # init_readline() must come before init_io(), because init_io uses
275 275 # readline related things.
276 276 self.init_readline()
277 277 # init_completer must come after init_readline, because it needs to
278 278 # know whether readline is present or not system-wide to configure the
279 279 # completers, since the completion machinery can now operate
280 280 # independently of readline (e.g. over the network)
281 281 self.init_completer()
282 282 # TODO: init_io() needs to happen before init_traceback handlers
283 283 # because the traceback handlers hardcode the stdout/stderr streams.
284 284 # This logic in in debugger.Pdb and should eventually be changed.
285 285 self.init_io()
286 286 self.init_traceback_handlers(custom_exceptions)
287 287 self.init_prompts()
288 288 self.init_displayhook()
289 289 self.init_reload_doctest()
290 290 self.init_magics()
291 291 self.init_pdb()
292 292 self.init_extension_manager()
293 293 self.init_plugin_manager()
294 294 self.init_payload()
295 295 self.hooks.late_startup_hook()
296 296 atexit.register(self.atexit_operations)
297 self.history_thread = HistorySaveThread(self, 10, False)
297 self.history_thread = HistorySaveThread(self, 60, False)
298 298 self.history_thread.start()
299 299
300 300 # While we're trying to have each part of the code directly access what it
301 301 # needs without keeping redundant references to objects, we have too much
302 302 # legacy code that expects ip.db to exist, so let's make it a property that
303 303 # retrieves the underlying object from our new history manager.
304 304 @property
305 305 def db(self):
306 306 return self.history_manager.shadow_db
307 307
308 308 @classmethod
309 309 def instance(cls, *args, **kwargs):
310 310 """Returns a global InteractiveShell instance."""
311 311 if cls._instance is None:
312 312 inst = cls(*args, **kwargs)
313 313 # Now make sure that the instance will also be returned by
314 314 # the subclasses instance attribute.
315 315 for subclass in cls.mro():
316 316 if issubclass(cls, subclass) and \
317 317 issubclass(subclass, InteractiveShell):
318 318 subclass._instance = inst
319 319 else:
320 320 break
321 321 if isinstance(cls._instance, cls):
322 322 return cls._instance
323 323 else:
324 324 raise MultipleInstanceError(
325 325 'Multiple incompatible subclass instances of '
326 326 'InteractiveShell are being created.'
327 327 )
328 328
329 329 @classmethod
330 330 def initialized(cls):
331 331 return hasattr(cls, "_instance")
332 332
333 333 def get_ipython(self):
334 334 """Return the currently running IPython instance."""
335 335 return self
336 336
337 337 #-------------------------------------------------------------------------
338 338 # Trait changed handlers
339 339 #-------------------------------------------------------------------------
340 340
341 341 def _ipython_dir_changed(self, name, new):
342 342 if not os.path.isdir(new):
343 343 os.makedirs(new, mode = 0777)
344 344
345 345 def set_autoindent(self,value=None):
346 346 """Set the autoindent flag, checking for readline support.
347 347
348 348 If called with no arguments, it acts as a toggle."""
349 349
350 350 if not self.has_readline:
351 351 if os.name == 'posix':
352 352 warn("The auto-indent feature requires the readline library")
353 353 self.autoindent = 0
354 354 return
355 355 if value is None:
356 356 self.autoindent = not self.autoindent
357 357 else:
358 358 self.autoindent = value
359 359
360 360 #-------------------------------------------------------------------------
361 361 # init_* methods called by __init__
362 362 #-------------------------------------------------------------------------
363 363
364 364 def init_ipython_dir(self, ipython_dir):
365 365 if ipython_dir is not None:
366 366 self.ipython_dir = ipython_dir
367 367 self.config.Global.ipython_dir = self.ipython_dir
368 368 return
369 369
370 370 if hasattr(self.config.Global, 'ipython_dir'):
371 371 self.ipython_dir = self.config.Global.ipython_dir
372 372 else:
373 373 self.ipython_dir = get_ipython_dir()
374 374
375 375 # All children can just read this
376 376 self.config.Global.ipython_dir = self.ipython_dir
377 377
378 378 def init_instance_attrs(self):
379 379 self.more = False
380 380
381 381 # command compiler
382 382 self.compile = CachingCompiler()
383 383
384 384 # User input buffers
385 385 # NOTE: these variables are slated for full removal, once we are 100%
386 386 # sure that the new execution logic is solid. We will delte runlines,
387 387 # push_line and these buffers, as all input will be managed by the
388 388 # frontends via an inputsplitter instance.
389 389 self.buffer = []
390 390 self.buffer_raw = []
391 391
392 392 # Make an empty namespace, which extension writers can rely on both
393 393 # existing and NEVER being used by ipython itself. This gives them a
394 394 # convenient location for storing additional information and state
395 395 # their extensions may require, without fear of collisions with other
396 396 # ipython names that may develop later.
397 397 self.meta = Struct()
398 398
399 399 # Object variable to store code object waiting execution. This is
400 400 # used mainly by the multithreaded shells, but it can come in handy in
401 401 # other situations. No need to use a Queue here, since it's a single
402 402 # item which gets cleared once run.
403 403 self.code_to_run = None
404 404
405 405 # Temporary files used for various purposes. Deleted at exit.
406 406 self.tempfiles = []
407 407
408 408 # Keep track of readline usage (later set by init_readline)
409 409 self.has_readline = False
410 410
411 411 # keep track of where we started running (mainly for crash post-mortem)
412 412 # This is not being used anywhere currently.
413 413 self.starting_dir = os.getcwd()
414 414
415 415 # Indentation management
416 416 self.indent_current_nsp = 0
417 417
418 418 def init_environment(self):
419 419 """Any changes we need to make to the user's environment."""
420 420 pass
421 421
422 422 def init_encoding(self):
423 423 # Get system encoding at startup time. Certain terminals (like Emacs
424 424 # under Win32 have it set to None, and we need to have a known valid
425 425 # encoding to use in the raw_input() method
426 426 try:
427 427 self.stdin_encoding = sys.stdin.encoding or 'ascii'
428 428 except AttributeError:
429 429 self.stdin_encoding = 'ascii'
430 430
431 431 def init_syntax_highlighting(self):
432 432 # Python source parser/formatter for syntax highlighting
433 433 pyformat = PyColorize.Parser().format
434 434 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
435 435
436 436 def init_pushd_popd_magic(self):
437 437 # for pushd/popd management
438 438 try:
439 439 self.home_dir = get_home_dir()
440 440 except HomeDirError, msg:
441 441 fatal(msg)
442 442
443 443 self.dir_stack = []
444 444
445 445 def init_logger(self):
446 446 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
447 447 logmode='rotate')
448 448
449 449 def init_logstart(self):
450 450 """Initialize logging in case it was requested at the command line.
451 451 """
452 452 if self.logappend:
453 453 self.magic_logstart(self.logappend + ' append')
454 454 elif self.logfile:
455 455 self.magic_logstart(self.logfile)
456 456 elif self.logstart:
457 457 self.magic_logstart()
458 458
459 459 def init_builtins(self):
460 460 self.builtin_trap = BuiltinTrap(shell=self)
461 461
462 462 def init_inspector(self):
463 463 # Object inspector
464 464 self.inspector = oinspect.Inspector(oinspect.InspectColors,
465 465 PyColorize.ANSICodeColors,
466 466 'NoColor',
467 467 self.object_info_string_level)
468 468
469 469 def init_io(self):
470 470 # This will just use sys.stdout and sys.stderr. If you want to
471 471 # override sys.stdout and sys.stderr themselves, you need to do that
472 472 # *before* instantiating this class, because Term holds onto
473 473 # references to the underlying streams.
474 474 if sys.platform == 'win32' and self.has_readline:
475 475 Term = io.IOTerm(cout=self.readline._outputfile,
476 476 cerr=self.readline._outputfile)
477 477 else:
478 478 Term = io.IOTerm()
479 479 io.Term = Term
480 480
481 481 def init_prompts(self):
482 482 # TODO: This is a pass for now because the prompts are managed inside
483 483 # the DisplayHook. Once there is a separate prompt manager, this
484 484 # will initialize that object and all prompt related information.
485 485 pass
486 486
487 487 def init_displayhook(self):
488 488 # Initialize displayhook, set in/out prompts and printing system
489 489 self.displayhook = self.displayhook_class(
490 490 config=self.config,
491 491 shell=self,
492 492 cache_size=self.cache_size,
493 493 input_sep = self.separate_in,
494 494 output_sep = self.separate_out,
495 495 output_sep2 = self.separate_out2,
496 496 ps1 = self.prompt_in1,
497 497 ps2 = self.prompt_in2,
498 498 ps_out = self.prompt_out,
499 499 pad_left = self.prompts_pad_left
500 500 )
501 501 # This is a context manager that installs/revmoes the displayhook at
502 502 # the appropriate time.
503 503 self.display_trap = DisplayTrap(hook=self.displayhook)
504 504
505 505 def init_reload_doctest(self):
506 506 # Do a proper resetting of doctest, including the necessary displayhook
507 507 # monkeypatching
508 508 try:
509 509 doctest_reload()
510 510 except ImportError:
511 511 warn("doctest module does not exist.")
512 512
513 513 #-------------------------------------------------------------------------
514 514 # Things related to injections into the sys module
515 515 #-------------------------------------------------------------------------
516 516
517 517 def save_sys_module_state(self):
518 518 """Save the state of hooks in the sys module.
519 519
520 520 This has to be called after self.user_ns is created.
521 521 """
522 522 self._orig_sys_module_state = {}
523 523 self._orig_sys_module_state['stdin'] = sys.stdin
524 524 self._orig_sys_module_state['stdout'] = sys.stdout
525 525 self._orig_sys_module_state['stderr'] = sys.stderr
526 526 self._orig_sys_module_state['excepthook'] = sys.excepthook
527 527 try:
528 528 self._orig_sys_modules_main_name = self.user_ns['__name__']
529 529 except KeyError:
530 530 pass
531 531
532 532 def restore_sys_module_state(self):
533 533 """Restore the state of the sys module."""
534 534 try:
535 535 for k, v in self._orig_sys_module_state.iteritems():
536 536 setattr(sys, k, v)
537 537 except AttributeError:
538 538 pass
539 539 # Reset what what done in self.init_sys_modules
540 540 try:
541 541 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
542 542 except (AttributeError, KeyError):
543 543 pass
544 544
545 545 #-------------------------------------------------------------------------
546 546 # Things related to hooks
547 547 #-------------------------------------------------------------------------
548 548
549 549 def init_hooks(self):
550 550 # hooks holds pointers used for user-side customizations
551 551 self.hooks = Struct()
552 552
553 553 self.strdispatchers = {}
554 554
555 555 # Set all default hooks, defined in the IPython.hooks module.
556 556 hooks = IPython.core.hooks
557 557 for hook_name in hooks.__all__:
558 558 # default hooks have priority 100, i.e. low; user hooks should have
559 559 # 0-100 priority
560 560 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
561 561
562 562 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
563 563 """set_hook(name,hook) -> sets an internal IPython hook.
564 564
565 565 IPython exposes some of its internal API as user-modifiable hooks. By
566 566 adding your function to one of these hooks, you can modify IPython's
567 567 behavior to call at runtime your own routines."""
568 568
569 569 # At some point in the future, this should validate the hook before it
570 570 # accepts it. Probably at least check that the hook takes the number
571 571 # of args it's supposed to.
572 572
573 573 f = types.MethodType(hook,self)
574 574
575 575 # check if the hook is for strdispatcher first
576 576 if str_key is not None:
577 577 sdp = self.strdispatchers.get(name, StrDispatch())
578 578 sdp.add_s(str_key, f, priority )
579 579 self.strdispatchers[name] = sdp
580 580 return
581 581 if re_key is not None:
582 582 sdp = self.strdispatchers.get(name, StrDispatch())
583 583 sdp.add_re(re.compile(re_key), f, priority )
584 584 self.strdispatchers[name] = sdp
585 585 return
586 586
587 587 dp = getattr(self.hooks, name, None)
588 588 if name not in IPython.core.hooks.__all__:
589 589 print "Warning! Hook '%s' is not one of %s" % \
590 590 (name, IPython.core.hooks.__all__ )
591 591 if not dp:
592 592 dp = IPython.core.hooks.CommandChainDispatcher()
593 593
594 594 try:
595 595 dp.add(f,priority)
596 596 except AttributeError:
597 597 # it was not commandchain, plain old func - replace
598 598 dp = f
599 599
600 600 setattr(self.hooks,name, dp)
601 601
602 602 def register_post_execute(self, func):
603 603 """Register a function for calling after code execution.
604 604 """
605 605 if not callable(func):
606 606 raise ValueError('argument %s must be callable' % func)
607 607 self._post_execute.add(func)
608 608
609 609 #-------------------------------------------------------------------------
610 610 # Things related to the "main" module
611 611 #-------------------------------------------------------------------------
612 612
613 613 def new_main_mod(self,ns=None):
614 614 """Return a new 'main' module object for user code execution.
615 615 """
616 616 main_mod = self._user_main_module
617 617 init_fakemod_dict(main_mod,ns)
618 618 return main_mod
619 619
620 620 def cache_main_mod(self,ns,fname):
621 621 """Cache a main module's namespace.
622 622
623 623 When scripts are executed via %run, we must keep a reference to the
624 624 namespace of their __main__ module (a FakeModule instance) around so
625 625 that Python doesn't clear it, rendering objects defined therein
626 626 useless.
627 627
628 628 This method keeps said reference in a private dict, keyed by the
629 629 absolute path of the module object (which corresponds to the script
630 630 path). This way, for multiple executions of the same script we only
631 631 keep one copy of the namespace (the last one), thus preventing memory
632 632 leaks from old references while allowing the objects from the last
633 633 execution to be accessible.
634 634
635 635 Note: we can not allow the actual FakeModule instances to be deleted,
636 636 because of how Python tears down modules (it hard-sets all their
637 637 references to None without regard for reference counts). This method
638 638 must therefore make a *copy* of the given namespace, to allow the
639 639 original module's __dict__ to be cleared and reused.
640 640
641 641
642 642 Parameters
643 643 ----------
644 644 ns : a namespace (a dict, typically)
645 645
646 646 fname : str
647 647 Filename associated with the namespace.
648 648
649 649 Examples
650 650 --------
651 651
652 652 In [10]: import IPython
653 653
654 654 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
655 655
656 656 In [12]: IPython.__file__ in _ip._main_ns_cache
657 657 Out[12]: True
658 658 """
659 659 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
660 660
661 661 def clear_main_mod_cache(self):
662 662 """Clear the cache of main modules.
663 663
664 664 Mainly for use by utilities like %reset.
665 665
666 666 Examples
667 667 --------
668 668
669 669 In [15]: import IPython
670 670
671 671 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
672 672
673 673 In [17]: len(_ip._main_ns_cache) > 0
674 674 Out[17]: True
675 675
676 676 In [18]: _ip.clear_main_mod_cache()
677 677
678 678 In [19]: len(_ip._main_ns_cache) == 0
679 679 Out[19]: True
680 680 """
681 681 self._main_ns_cache.clear()
682 682
683 683 #-------------------------------------------------------------------------
684 684 # Things related to debugging
685 685 #-------------------------------------------------------------------------
686 686
687 687 def init_pdb(self):
688 688 # Set calling of pdb on exceptions
689 689 # self.call_pdb is a property
690 690 self.call_pdb = self.pdb
691 691
692 692 def _get_call_pdb(self):
693 693 return self._call_pdb
694 694
695 695 def _set_call_pdb(self,val):
696 696
697 697 if val not in (0,1,False,True):
698 698 raise ValueError,'new call_pdb value must be boolean'
699 699
700 700 # store value in instance
701 701 self._call_pdb = val
702 702
703 703 # notify the actual exception handlers
704 704 self.InteractiveTB.call_pdb = val
705 705
706 706 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
707 707 'Control auto-activation of pdb at exceptions')
708 708
709 709 def debugger(self,force=False):
710 710 """Call the pydb/pdb debugger.
711 711
712 712 Keywords:
713 713
714 714 - force(False): by default, this routine checks the instance call_pdb
715 715 flag and does not actually invoke the debugger if the flag is false.
716 716 The 'force' option forces the debugger to activate even if the flag
717 717 is false.
718 718 """
719 719
720 720 if not (force or self.call_pdb):
721 721 return
722 722
723 723 if not hasattr(sys,'last_traceback'):
724 724 error('No traceback has been produced, nothing to debug.')
725 725 return
726 726
727 727 # use pydb if available
728 728 if debugger.has_pydb:
729 729 from pydb import pm
730 730 else:
731 731 # fallback to our internal debugger
732 732 pm = lambda : self.InteractiveTB.debugger(force=True)
733 733 self.history_saving_wrapper(pm)()
734 734
735 735 #-------------------------------------------------------------------------
736 736 # Things related to IPython's various namespaces
737 737 #-------------------------------------------------------------------------
738 738
739 739 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
740 740 # Create the namespace where the user will operate. user_ns is
741 741 # normally the only one used, and it is passed to the exec calls as
742 742 # the locals argument. But we do carry a user_global_ns namespace
743 743 # given as the exec 'globals' argument, This is useful in embedding
744 744 # situations where the ipython shell opens in a context where the
745 745 # distinction between locals and globals is meaningful. For
746 746 # non-embedded contexts, it is just the same object as the user_ns dict.
747 747
748 748 # FIXME. For some strange reason, __builtins__ is showing up at user
749 749 # level as a dict instead of a module. This is a manual fix, but I
750 750 # should really track down where the problem is coming from. Alex
751 751 # Schmolck reported this problem first.
752 752
753 753 # A useful post by Alex Martelli on this topic:
754 754 # Re: inconsistent value from __builtins__
755 755 # Von: Alex Martelli <aleaxit@yahoo.com>
756 756 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
757 757 # Gruppen: comp.lang.python
758 758
759 759 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
760 760 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
761 761 # > <type 'dict'>
762 762 # > >>> print type(__builtins__)
763 763 # > <type 'module'>
764 764 # > Is this difference in return value intentional?
765 765
766 766 # Well, it's documented that '__builtins__' can be either a dictionary
767 767 # or a module, and it's been that way for a long time. Whether it's
768 768 # intentional (or sensible), I don't know. In any case, the idea is
769 769 # that if you need to access the built-in namespace directly, you
770 770 # should start with "import __builtin__" (note, no 's') which will
771 771 # definitely give you a module. Yeah, it's somewhat confusing:-(.
772 772
773 773 # These routines return properly built dicts as needed by the rest of
774 774 # the code, and can also be used by extension writers to generate
775 775 # properly initialized namespaces.
776 776 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
777 777 user_global_ns)
778 778
779 779 # Assign namespaces
780 780 # This is the namespace where all normal user variables live
781 781 self.user_ns = user_ns
782 782 self.user_global_ns = user_global_ns
783 783
784 784 # An auxiliary namespace that checks what parts of the user_ns were
785 785 # loaded at startup, so we can list later only variables defined in
786 786 # actual interactive use. Since it is always a subset of user_ns, it
787 787 # doesn't need to be separately tracked in the ns_table.
788 788 self.user_ns_hidden = {}
789 789
790 790 # A namespace to keep track of internal data structures to prevent
791 791 # them from cluttering user-visible stuff. Will be updated later
792 792 self.internal_ns = {}
793 793
794 794 # Now that FakeModule produces a real module, we've run into a nasty
795 795 # problem: after script execution (via %run), the module where the user
796 796 # code ran is deleted. Now that this object is a true module (needed
797 797 # so docetst and other tools work correctly), the Python module
798 798 # teardown mechanism runs over it, and sets to None every variable
799 799 # present in that module. Top-level references to objects from the
800 800 # script survive, because the user_ns is updated with them. However,
801 801 # calling functions defined in the script that use other things from
802 802 # the script will fail, because the function's closure had references
803 803 # to the original objects, which are now all None. So we must protect
804 804 # these modules from deletion by keeping a cache.
805 805 #
806 806 # To avoid keeping stale modules around (we only need the one from the
807 807 # last run), we use a dict keyed with the full path to the script, so
808 808 # only the last version of the module is held in the cache. Note,
809 809 # however, that we must cache the module *namespace contents* (their
810 810 # __dict__). Because if we try to cache the actual modules, old ones
811 811 # (uncached) could be destroyed while still holding references (such as
812 812 # those held by GUI objects that tend to be long-lived)>
813 813 #
814 814 # The %reset command will flush this cache. See the cache_main_mod()
815 815 # and clear_main_mod_cache() methods for details on use.
816 816
817 817 # This is the cache used for 'main' namespaces
818 818 self._main_ns_cache = {}
819 819 # And this is the single instance of FakeModule whose __dict__ we keep
820 820 # copying and clearing for reuse on each %run
821 821 self._user_main_module = FakeModule()
822 822
823 823 # A table holding all the namespaces IPython deals with, so that
824 824 # introspection facilities can search easily.
825 825 self.ns_table = {'user':user_ns,
826 826 'user_global':user_global_ns,
827 827 'internal':self.internal_ns,
828 828 'builtin':__builtin__.__dict__
829 829 }
830 830
831 831 # Similarly, track all namespaces where references can be held and that
832 832 # we can safely clear (so it can NOT include builtin). This one can be
833 833 # a simple list. Note that the main execution namespaces, user_ns and
834 834 # user_global_ns, can NOT be listed here, as clearing them blindly
835 835 # causes errors in object __del__ methods. Instead, the reset() method
836 836 # clears them manually and carefully.
837 837 self.ns_refs_table = [ self.user_ns_hidden,
838 838 self.internal_ns, self._main_ns_cache ]
839 839
840 840 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
841 841 """Return a valid local and global user interactive namespaces.
842 842
843 843 This builds a dict with the minimal information needed to operate as a
844 844 valid IPython user namespace, which you can pass to the various
845 845 embedding classes in ipython. The default implementation returns the
846 846 same dict for both the locals and the globals to allow functions to
847 847 refer to variables in the namespace. Customized implementations can
848 848 return different dicts. The locals dictionary can actually be anything
849 849 following the basic mapping protocol of a dict, but the globals dict
850 850 must be a true dict, not even a subclass. It is recommended that any
851 851 custom object for the locals namespace synchronize with the globals
852 852 dict somehow.
853 853
854 854 Raises TypeError if the provided globals namespace is not a true dict.
855 855
856 856 Parameters
857 857 ----------
858 858 user_ns : dict-like, optional
859 859 The current user namespace. The items in this namespace should
860 860 be included in the output. If None, an appropriate blank
861 861 namespace should be created.
862 862 user_global_ns : dict, optional
863 863 The current user global namespace. The items in this namespace
864 864 should be included in the output. If None, an appropriate
865 865 blank namespace should be created.
866 866
867 867 Returns
868 868 -------
869 869 A pair of dictionary-like object to be used as the local namespace
870 870 of the interpreter and a dict to be used as the global namespace.
871 871 """
872 872
873 873
874 874 # We must ensure that __builtin__ (without the final 's') is always
875 875 # available and pointing to the __builtin__ *module*. For more details:
876 876 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
877 877
878 878 if user_ns is None:
879 879 # Set __name__ to __main__ to better match the behavior of the
880 880 # normal interpreter.
881 881 user_ns = {'__name__' :'__main__',
882 882 '__builtin__' : __builtin__,
883 883 '__builtins__' : __builtin__,
884 884 }
885 885 else:
886 886 user_ns.setdefault('__name__','__main__')
887 887 user_ns.setdefault('__builtin__',__builtin__)
888 888 user_ns.setdefault('__builtins__',__builtin__)
889 889
890 890 if user_global_ns is None:
891 891 user_global_ns = user_ns
892 892 if type(user_global_ns) is not dict:
893 893 raise TypeError("user_global_ns must be a true dict; got %r"
894 894 % type(user_global_ns))
895 895
896 896 return user_ns, user_global_ns
897 897
898 898 def init_sys_modules(self):
899 899 # We need to insert into sys.modules something that looks like a
900 900 # module but which accesses the IPython namespace, for shelve and
901 901 # pickle to work interactively. Normally they rely on getting
902 902 # everything out of __main__, but for embedding purposes each IPython
903 903 # instance has its own private namespace, so we can't go shoving
904 904 # everything into __main__.
905 905
906 906 # note, however, that we should only do this for non-embedded
907 907 # ipythons, which really mimic the __main__.__dict__ with their own
908 908 # namespace. Embedded instances, on the other hand, should not do
909 909 # this because they need to manage the user local/global namespaces
910 910 # only, but they live within a 'normal' __main__ (meaning, they
911 911 # shouldn't overtake the execution environment of the script they're
912 912 # embedded in).
913 913
914 914 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
915 915
916 916 try:
917 917 main_name = self.user_ns['__name__']
918 918 except KeyError:
919 919 raise KeyError('user_ns dictionary MUST have a "__name__" key')
920 920 else:
921 921 sys.modules[main_name] = FakeModule(self.user_ns)
922 922
923 923 def init_user_ns(self):
924 924 """Initialize all user-visible namespaces to their minimum defaults.
925 925
926 926 Certain history lists are also initialized here, as they effectively
927 927 act as user namespaces.
928 928
929 929 Notes
930 930 -----
931 931 All data structures here are only filled in, they are NOT reset by this
932 932 method. If they were not empty before, data will simply be added to
933 933 therm.
934 934 """
935 935 # This function works in two parts: first we put a few things in
936 936 # user_ns, and we sync that contents into user_ns_hidden so that these
937 937 # initial variables aren't shown by %who. After the sync, we add the
938 938 # rest of what we *do* want the user to see with %who even on a new
939 939 # session (probably nothing, so theye really only see their own stuff)
940 940
941 941 # The user dict must *always* have a __builtin__ reference to the
942 942 # Python standard __builtin__ namespace, which must be imported.
943 943 # This is so that certain operations in prompt evaluation can be
944 944 # reliably executed with builtins. Note that we can NOT use
945 945 # __builtins__ (note the 's'), because that can either be a dict or a
946 946 # module, and can even mutate at runtime, depending on the context
947 947 # (Python makes no guarantees on it). In contrast, __builtin__ is
948 948 # always a module object, though it must be explicitly imported.
949 949
950 950 # For more details:
951 951 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
952 952 ns = dict(__builtin__ = __builtin__)
953 953
954 954 # Put 'help' in the user namespace
955 955 try:
956 956 from site import _Helper
957 957 ns['help'] = _Helper()
958 958 except ImportError:
959 959 warn('help() not available - check site.py')
960 960
961 961 # make global variables for user access to the histories
962 962 ns['_ih'] = self.history_manager.input_hist_parsed
963 963 ns['_oh'] = self.history_manager.output_hist
964 964 ns['_dh'] = self.history_manager.dir_hist
965 965
966 966 ns['_sh'] = shadowns
967 967
968 968 # user aliases to input and output histories. These shouldn't show up
969 969 # in %who, as they can have very large reprs.
970 970 ns['In'] = self.history_manager.input_hist_parsed
971 971 ns['Out'] = self.history_manager.output_hist
972 972
973 973 # Store myself as the public api!!!
974 974 ns['get_ipython'] = self.get_ipython
975 975
976 976 # Sync what we've added so far to user_ns_hidden so these aren't seen
977 977 # by %who
978 978 self.user_ns_hidden.update(ns)
979 979
980 980 # Anything put into ns now would show up in %who. Think twice before
981 981 # putting anything here, as we really want %who to show the user their
982 982 # stuff, not our variables.
983 983
984 984 # Finally, update the real user's namespace
985 985 self.user_ns.update(ns)
986 986
987 987 def reset(self):
988 988 """Clear all internal namespaces.
989 989
990 990 Note that this is much more aggressive than %reset, since it clears
991 991 fully all namespaces, as well as all input/output lists.
992 992 """
993 993 # Clear histories
994 994 self.history_manager.reset()
995 995
996 996 # Reset counter used to index all histories
997 997 self.execution_count = 0
998 998
999 999 # Restore the user namespaces to minimal usability
1000 1000 for ns in self.ns_refs_table:
1001 1001 ns.clear()
1002 1002
1003 1003 # The main execution namespaces must be cleared very carefully,
1004 1004 # skipping the deletion of the builtin-related keys, because doing so
1005 1005 # would cause errors in many object's __del__ methods.
1006 1006 for ns in [self.user_ns, self.user_global_ns]:
1007 1007 drop_keys = set(ns.keys())
1008 1008 drop_keys.discard('__builtin__')
1009 1009 drop_keys.discard('__builtins__')
1010 1010 for k in drop_keys:
1011 1011 del ns[k]
1012 1012
1013 1013 # Restore the user namespaces to minimal usability
1014 1014 self.init_user_ns()
1015 1015
1016 1016 # Restore the default and user aliases
1017 1017 self.alias_manager.clear_aliases()
1018 1018 self.alias_manager.init_aliases()
1019 1019
1020 1020 def reset_selective(self, regex=None):
1021 1021 """Clear selective variables from internal namespaces based on a
1022 1022 specified regular expression.
1023 1023
1024 1024 Parameters
1025 1025 ----------
1026 1026 regex : string or compiled pattern, optional
1027 1027 A regular expression pattern that will be used in searching
1028 1028 variable names in the users namespaces.
1029 1029 """
1030 1030 if regex is not None:
1031 1031 try:
1032 1032 m = re.compile(regex)
1033 1033 except TypeError:
1034 1034 raise TypeError('regex must be a string or compiled pattern')
1035 1035 # Search for keys in each namespace that match the given regex
1036 1036 # If a match is found, delete the key/value pair.
1037 1037 for ns in self.ns_refs_table:
1038 1038 for var in ns:
1039 1039 if m.search(var):
1040 1040 del ns[var]
1041 1041
1042 1042 def push(self, variables, interactive=True):
1043 1043 """Inject a group of variables into the IPython user namespace.
1044 1044
1045 1045 Parameters
1046 1046 ----------
1047 1047 variables : dict, str or list/tuple of str
1048 1048 The variables to inject into the user's namespace. If a dict, a
1049 1049 simple update is done. If a str, the string is assumed to have
1050 1050 variable names separated by spaces. A list/tuple of str can also
1051 1051 be used to give the variable names. If just the variable names are
1052 1052 give (list/tuple/str) then the variable values looked up in the
1053 1053 callers frame.
1054 1054 interactive : bool
1055 1055 If True (default), the variables will be listed with the ``who``
1056 1056 magic.
1057 1057 """
1058 1058 vdict = None
1059 1059
1060 1060 # We need a dict of name/value pairs to do namespace updates.
1061 1061 if isinstance(variables, dict):
1062 1062 vdict = variables
1063 1063 elif isinstance(variables, (basestring, list, tuple)):
1064 1064 if isinstance(variables, basestring):
1065 1065 vlist = variables.split()
1066 1066 else:
1067 1067 vlist = variables
1068 1068 vdict = {}
1069 1069 cf = sys._getframe(1)
1070 1070 for name in vlist:
1071 1071 try:
1072 1072 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1073 1073 except:
1074 1074 print ('Could not get variable %s from %s' %
1075 1075 (name,cf.f_code.co_name))
1076 1076 else:
1077 1077 raise ValueError('variables must be a dict/str/list/tuple')
1078 1078
1079 1079 # Propagate variables to user namespace
1080 1080 self.user_ns.update(vdict)
1081 1081
1082 1082 # And configure interactive visibility
1083 1083 config_ns = self.user_ns_hidden
1084 1084 if interactive:
1085 1085 for name, val in vdict.iteritems():
1086 1086 config_ns.pop(name, None)
1087 1087 else:
1088 1088 for name,val in vdict.iteritems():
1089 1089 config_ns[name] = val
1090 1090
1091 1091 #-------------------------------------------------------------------------
1092 1092 # Things related to object introspection
1093 1093 #-------------------------------------------------------------------------
1094 1094
1095 1095 def _ofind(self, oname, namespaces=None):
1096 1096 """Find an object in the available namespaces.
1097 1097
1098 1098 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1099 1099
1100 1100 Has special code to detect magic functions.
1101 1101 """
1102 1102 #oname = oname.strip()
1103 1103 #print '1- oname: <%r>' % oname # dbg
1104 1104 try:
1105 1105 oname = oname.strip().encode('ascii')
1106 1106 #print '2- oname: <%r>' % oname # dbg
1107 1107 except UnicodeEncodeError:
1108 1108 print 'Python identifiers can only contain ascii characters.'
1109 1109 return dict(found=False)
1110 1110
1111 1111 alias_ns = None
1112 1112 if namespaces is None:
1113 1113 # Namespaces to search in:
1114 1114 # Put them in a list. The order is important so that we
1115 1115 # find things in the same order that Python finds them.
1116 1116 namespaces = [ ('Interactive', self.user_ns),
1117 1117 ('IPython internal', self.internal_ns),
1118 1118 ('Python builtin', __builtin__.__dict__),
1119 1119 ('Alias', self.alias_manager.alias_table),
1120 1120 ]
1121 1121 alias_ns = self.alias_manager.alias_table
1122 1122
1123 1123 # initialize results to 'null'
1124 1124 found = False; obj = None; ospace = None; ds = None;
1125 1125 ismagic = False; isalias = False; parent = None
1126 1126
1127 1127 # We need to special-case 'print', which as of python2.6 registers as a
1128 1128 # function but should only be treated as one if print_function was
1129 1129 # loaded with a future import. In this case, just bail.
1130 1130 if (oname == 'print' and not (self.compile.compiler_flags &
1131 1131 __future__.CO_FUTURE_PRINT_FUNCTION)):
1132 1132 return {'found':found, 'obj':obj, 'namespace':ospace,
1133 1133 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1134 1134
1135 1135 # Look for the given name by splitting it in parts. If the head is
1136 1136 # found, then we look for all the remaining parts as members, and only
1137 1137 # declare success if we can find them all.
1138 1138 oname_parts = oname.split('.')
1139 1139 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1140 1140 for nsname,ns in namespaces:
1141 1141 try:
1142 1142 obj = ns[oname_head]
1143 1143 except KeyError:
1144 1144 continue
1145 1145 else:
1146 1146 #print 'oname_rest:', oname_rest # dbg
1147 1147 for part in oname_rest:
1148 1148 try:
1149 1149 parent = obj
1150 1150 obj = getattr(obj,part)
1151 1151 except:
1152 1152 # Blanket except b/c some badly implemented objects
1153 1153 # allow __getattr__ to raise exceptions other than
1154 1154 # AttributeError, which then crashes IPython.
1155 1155 break
1156 1156 else:
1157 1157 # If we finish the for loop (no break), we got all members
1158 1158 found = True
1159 1159 ospace = nsname
1160 1160 if ns == alias_ns:
1161 1161 isalias = True
1162 1162 break # namespace loop
1163 1163
1164 1164 # Try to see if it's magic
1165 1165 if not found:
1166 1166 if oname.startswith(ESC_MAGIC):
1167 1167 oname = oname[1:]
1168 1168 obj = getattr(self,'magic_'+oname,None)
1169 1169 if obj is not None:
1170 1170 found = True
1171 1171 ospace = 'IPython internal'
1172 1172 ismagic = True
1173 1173
1174 1174 # Last try: special-case some literals like '', [], {}, etc:
1175 1175 if not found and oname_head in ["''",'""','[]','{}','()']:
1176 1176 obj = eval(oname_head)
1177 1177 found = True
1178 1178 ospace = 'Interactive'
1179 1179
1180 1180 return {'found':found, 'obj':obj, 'namespace':ospace,
1181 1181 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1182 1182
1183 1183 def _ofind_property(self, oname, info):
1184 1184 """Second part of object finding, to look for property details."""
1185 1185 if info.found:
1186 1186 # Get the docstring of the class property if it exists.
1187 1187 path = oname.split('.')
1188 1188 root = '.'.join(path[:-1])
1189 1189 if info.parent is not None:
1190 1190 try:
1191 1191 target = getattr(info.parent, '__class__')
1192 1192 # The object belongs to a class instance.
1193 1193 try:
1194 1194 target = getattr(target, path[-1])
1195 1195 # The class defines the object.
1196 1196 if isinstance(target, property):
1197 1197 oname = root + '.__class__.' + path[-1]
1198 1198 info = Struct(self._ofind(oname))
1199 1199 except AttributeError: pass
1200 1200 except AttributeError: pass
1201 1201
1202 1202 # We return either the new info or the unmodified input if the object
1203 1203 # hadn't been found
1204 1204 return info
1205 1205
1206 1206 def _object_find(self, oname, namespaces=None):
1207 1207 """Find an object and return a struct with info about it."""
1208 1208 inf = Struct(self._ofind(oname, namespaces))
1209 1209 return Struct(self._ofind_property(oname, inf))
1210 1210
1211 1211 def _inspect(self, meth, oname, namespaces=None, **kw):
1212 1212 """Generic interface to the inspector system.
1213 1213
1214 1214 This function is meant to be called by pdef, pdoc & friends."""
1215 1215 info = self._object_find(oname)
1216 1216 if info.found:
1217 1217 pmethod = getattr(self.inspector, meth)
1218 1218 formatter = format_screen if info.ismagic else None
1219 1219 if meth == 'pdoc':
1220 1220 pmethod(info.obj, oname, formatter)
1221 1221 elif meth == 'pinfo':
1222 1222 pmethod(info.obj, oname, formatter, info, **kw)
1223 1223 else:
1224 1224 pmethod(info.obj, oname)
1225 1225 else:
1226 1226 print 'Object `%s` not found.' % oname
1227 1227 return 'not found' # so callers can take other action
1228 1228
1229 1229 def object_inspect(self, oname):
1230 1230 info = self._object_find(oname)
1231 1231 if info.found:
1232 1232 return self.inspector.info(info.obj, oname, info=info)
1233 1233 else:
1234 1234 return oinspect.object_info(name=oname, found=False)
1235 1235
1236 1236 #-------------------------------------------------------------------------
1237 1237 # Things related to history management
1238 1238 #-------------------------------------------------------------------------
1239 1239
1240 1240 def init_history(self):
1241 1241 self.history_manager = HistoryManager(shell=self)
1242 1242
1243 1243 def save_history(self):
1244 1244 """Save input history to a file (via readline library)."""
1245 1245 self.history_manager.save_history()
1246 1246
1247 1247 def reload_history(self):
1248 1248 """Reload the input history from disk file."""
1249 1249 self.history_manager.reload_history()
1250 1250
1251 1251 def history_saving_wrapper(self, func):
1252 1252 """ Wrap func for readline history saving
1253 1253
1254 1254 Convert func into callable that saves & restores
1255 1255 history around the call """
1256 1256
1257 1257 if self.has_readline:
1258 1258 from IPython.utils import rlineimpl as readline
1259 1259 else:
1260 1260 return func
1261 1261
1262 1262 def wrapper():
1263 1263 self.save_history()
1264 1264 try:
1265 1265 func()
1266 1266 finally:
1267 1267 self.reload_history()
1268 1268 return wrapper
1269 1269
1270 1270 def get_history(self, index=None, raw=False, output=True):
1271 1271 return self.history_manager.get_history(index, raw, output)
1272 1272
1273 1273
1274 1274 #-------------------------------------------------------------------------
1275 1275 # Things related to exception handling and tracebacks (not debugging)
1276 1276 #-------------------------------------------------------------------------
1277 1277
1278 1278 def init_traceback_handlers(self, custom_exceptions):
1279 1279 # Syntax error handler.
1280 1280 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1281 1281
1282 1282 # The interactive one is initialized with an offset, meaning we always
1283 1283 # want to remove the topmost item in the traceback, which is our own
1284 1284 # internal code. Valid modes: ['Plain','Context','Verbose']
1285 1285 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1286 1286 color_scheme='NoColor',
1287 1287 tb_offset = 1,
1288 1288 check_cache=self.compile.check_cache)
1289 1289
1290 1290 # The instance will store a pointer to the system-wide exception hook,
1291 1291 # so that runtime code (such as magics) can access it. This is because
1292 1292 # during the read-eval loop, it may get temporarily overwritten.
1293 1293 self.sys_excepthook = sys.excepthook
1294 1294
1295 1295 # and add any custom exception handlers the user may have specified
1296 1296 self.set_custom_exc(*custom_exceptions)
1297 1297
1298 1298 # Set the exception mode
1299 1299 self.InteractiveTB.set_mode(mode=self.xmode)
1300 1300
1301 1301 def set_custom_exc(self, exc_tuple, handler):
1302 1302 """set_custom_exc(exc_tuple,handler)
1303 1303
1304 1304 Set a custom exception handler, which will be called if any of the
1305 1305 exceptions in exc_tuple occur in the mainloop (specifically, in the
1306 1306 run_code() method.
1307 1307
1308 1308 Inputs:
1309 1309
1310 1310 - exc_tuple: a *tuple* of valid exceptions to call the defined
1311 1311 handler for. It is very important that you use a tuple, and NOT A
1312 1312 LIST here, because of the way Python's except statement works. If
1313 1313 you only want to trap a single exception, use a singleton tuple:
1314 1314
1315 1315 exc_tuple == (MyCustomException,)
1316 1316
1317 1317 - handler: this must be defined as a function with the following
1318 1318 basic interface::
1319 1319
1320 1320 def my_handler(self, etype, value, tb, tb_offset=None)
1321 1321 ...
1322 1322 # The return value must be
1323 1323 return structured_traceback
1324 1324
1325 1325 This will be made into an instance method (via types.MethodType)
1326 1326 of IPython itself, and it will be called if any of the exceptions
1327 1327 listed in the exc_tuple are caught. If the handler is None, an
1328 1328 internal basic one is used, which just prints basic info.
1329 1329
1330 1330 WARNING: by putting in your own exception handler into IPython's main
1331 1331 execution loop, you run a very good chance of nasty crashes. This
1332 1332 facility should only be used if you really know what you are doing."""
1333 1333
1334 1334 assert type(exc_tuple)==type(()) , \
1335 1335 "The custom exceptions must be given AS A TUPLE."
1336 1336
1337 1337 def dummy_handler(self,etype,value,tb):
1338 1338 print '*** Simple custom exception handler ***'
1339 1339 print 'Exception type :',etype
1340 1340 print 'Exception value:',value
1341 1341 print 'Traceback :',tb
1342 1342 print 'Source code :','\n'.join(self.buffer)
1343 1343
1344 1344 if handler is None: handler = dummy_handler
1345 1345
1346 1346 self.CustomTB = types.MethodType(handler,self)
1347 1347 self.custom_exceptions = exc_tuple
1348 1348
1349 1349 def excepthook(self, etype, value, tb):
1350 1350 """One more defense for GUI apps that call sys.excepthook.
1351 1351
1352 1352 GUI frameworks like wxPython trap exceptions and call
1353 1353 sys.excepthook themselves. I guess this is a feature that
1354 1354 enables them to keep running after exceptions that would
1355 1355 otherwise kill their mainloop. This is a bother for IPython
1356 1356 which excepts to catch all of the program exceptions with a try:
1357 1357 except: statement.
1358 1358
1359 1359 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1360 1360 any app directly invokes sys.excepthook, it will look to the user like
1361 1361 IPython crashed. In order to work around this, we can disable the
1362 1362 CrashHandler and replace it with this excepthook instead, which prints a
1363 1363 regular traceback using our InteractiveTB. In this fashion, apps which
1364 1364 call sys.excepthook will generate a regular-looking exception from
1365 1365 IPython, and the CrashHandler will only be triggered by real IPython
1366 1366 crashes.
1367 1367
1368 1368 This hook should be used sparingly, only in places which are not likely
1369 1369 to be true IPython errors.
1370 1370 """
1371 1371 self.showtraceback((etype,value,tb),tb_offset=0)
1372 1372
1373 1373 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1374 1374 exception_only=False):
1375 1375 """Display the exception that just occurred.
1376 1376
1377 1377 If nothing is known about the exception, this is the method which
1378 1378 should be used throughout the code for presenting user tracebacks,
1379 1379 rather than directly invoking the InteractiveTB object.
1380 1380
1381 1381 A specific showsyntaxerror() also exists, but this method can take
1382 1382 care of calling it if needed, so unless you are explicitly catching a
1383 1383 SyntaxError exception, don't try to analyze the stack manually and
1384 1384 simply call this method."""
1385 1385
1386 1386 try:
1387 1387 if exc_tuple is None:
1388 1388 etype, value, tb = sys.exc_info()
1389 1389 else:
1390 1390 etype, value, tb = exc_tuple
1391 1391
1392 1392 if etype is None:
1393 1393 if hasattr(sys, 'last_type'):
1394 1394 etype, value, tb = sys.last_type, sys.last_value, \
1395 1395 sys.last_traceback
1396 1396 else:
1397 1397 self.write_err('No traceback available to show.\n')
1398 1398 return
1399 1399
1400 1400 if etype is SyntaxError:
1401 1401 # Though this won't be called by syntax errors in the input
1402 1402 # line, there may be SyntaxError cases whith imported code.
1403 1403 self.showsyntaxerror(filename)
1404 1404 elif etype is UsageError:
1405 1405 print "UsageError:", value
1406 1406 else:
1407 1407 # WARNING: these variables are somewhat deprecated and not
1408 1408 # necessarily safe to use in a threaded environment, but tools
1409 1409 # like pdb depend on their existence, so let's set them. If we
1410 1410 # find problems in the field, we'll need to revisit their use.
1411 1411 sys.last_type = etype
1412 1412 sys.last_value = value
1413 1413 sys.last_traceback = tb
1414 1414
1415 1415 if etype in self.custom_exceptions:
1416 1416 # FIXME: Old custom traceback objects may just return a
1417 1417 # string, in that case we just put it into a list
1418 1418 stb = self.CustomTB(etype, value, tb, tb_offset)
1419 1419 if isinstance(ctb, basestring):
1420 1420 stb = [stb]
1421 1421 else:
1422 1422 if exception_only:
1423 1423 stb = ['An exception has occurred, use %tb to see '
1424 1424 'the full traceback.\n']
1425 1425 stb.extend(self.InteractiveTB.get_exception_only(etype,
1426 1426 value))
1427 1427 else:
1428 1428 stb = self.InteractiveTB.structured_traceback(etype,
1429 1429 value, tb, tb_offset=tb_offset)
1430 1430 # FIXME: the pdb calling should be done by us, not by
1431 1431 # the code computing the traceback.
1432 1432 if self.InteractiveTB.call_pdb:
1433 1433 # pdb mucks up readline, fix it back
1434 1434 self.set_readline_completer()
1435 1435
1436 1436 # Actually show the traceback
1437 1437 self._showtraceback(etype, value, stb)
1438 1438
1439 1439 except KeyboardInterrupt:
1440 1440 self.write_err("\nKeyboardInterrupt\n")
1441 1441
1442 1442 def _showtraceback(self, etype, evalue, stb):
1443 1443 """Actually show a traceback.
1444 1444
1445 1445 Subclasses may override this method to put the traceback on a different
1446 1446 place, like a side channel.
1447 1447 """
1448 1448 print >> io.Term.cout, self.InteractiveTB.stb2text(stb)
1449 1449
1450 1450 def showsyntaxerror(self, filename=None):
1451 1451 """Display the syntax error that just occurred.
1452 1452
1453 1453 This doesn't display a stack trace because there isn't one.
1454 1454
1455 1455 If a filename is given, it is stuffed in the exception instead
1456 1456 of what was there before (because Python's parser always uses
1457 1457 "<string>" when reading from a string).
1458 1458 """
1459 1459 etype, value, last_traceback = sys.exc_info()
1460 1460
1461 1461 # See note about these variables in showtraceback() above
1462 1462 sys.last_type = etype
1463 1463 sys.last_value = value
1464 1464 sys.last_traceback = last_traceback
1465 1465
1466 1466 if filename and etype is SyntaxError:
1467 1467 # Work hard to stuff the correct filename in the exception
1468 1468 try:
1469 1469 msg, (dummy_filename, lineno, offset, line) = value
1470 1470 except:
1471 1471 # Not the format we expect; leave it alone
1472 1472 pass
1473 1473 else:
1474 1474 # Stuff in the right filename
1475 1475 try:
1476 1476 # Assume SyntaxError is a class exception
1477 1477 value = SyntaxError(msg, (filename, lineno, offset, line))
1478 1478 except:
1479 1479 # If that failed, assume SyntaxError is a string
1480 1480 value = msg, (filename, lineno, offset, line)
1481 1481 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1482 1482 self._showtraceback(etype, value, stb)
1483 1483
1484 1484 #-------------------------------------------------------------------------
1485 1485 # Things related to readline
1486 1486 #-------------------------------------------------------------------------
1487 1487
1488 1488 def init_readline(self):
1489 1489 """Command history completion/saving/reloading."""
1490 1490
1491 1491 if self.readline_use:
1492 1492 import IPython.utils.rlineimpl as readline
1493 1493
1494 1494 self.rl_next_input = None
1495 1495 self.rl_do_indent = False
1496 1496
1497 1497 if not self.readline_use or not readline.have_readline:
1498 1498 self.has_readline = False
1499 1499 self.readline = None
1500 1500 # Set a number of methods that depend on readline to be no-op
1501 1501 self.set_readline_completer = no_op
1502 1502 self.set_custom_completer = no_op
1503 1503 self.set_completer_frame = no_op
1504 1504 warn('Readline services not available or not loaded.')
1505 1505 else:
1506 1506 self.has_readline = True
1507 1507 self.readline = readline
1508 1508 sys.modules['readline'] = readline
1509 1509
1510 1510 # Platform-specific configuration
1511 1511 if os.name == 'nt':
1512 1512 # FIXME - check with Frederick to see if we can harmonize
1513 1513 # naming conventions with pyreadline to avoid this
1514 1514 # platform-dependent check
1515 1515 self.readline_startup_hook = readline.set_pre_input_hook
1516 1516 else:
1517 1517 self.readline_startup_hook = readline.set_startup_hook
1518 1518
1519 1519 # Load user's initrc file (readline config)
1520 1520 # Or if libedit is used, load editrc.
1521 1521 inputrc_name = os.environ.get('INPUTRC')
1522 1522 if inputrc_name is None:
1523 1523 home_dir = get_home_dir()
1524 1524 if home_dir is not None:
1525 1525 inputrc_name = '.inputrc'
1526 1526 if readline.uses_libedit:
1527 1527 inputrc_name = '.editrc'
1528 1528 inputrc_name = os.path.join(home_dir, inputrc_name)
1529 1529 if os.path.isfile(inputrc_name):
1530 1530 try:
1531 1531 readline.read_init_file(inputrc_name)
1532 1532 except:
1533 1533 warn('Problems reading readline initialization file <%s>'
1534 1534 % inputrc_name)
1535 1535
1536 1536 # Configure readline according to user's prefs
1537 1537 # This is only done if GNU readline is being used. If libedit
1538 1538 # is being used (as on Leopard) the readline config is
1539 1539 # not run as the syntax for libedit is different.
1540 1540 if not readline.uses_libedit:
1541 1541 for rlcommand in self.readline_parse_and_bind:
1542 1542 #print "loading rl:",rlcommand # dbg
1543 1543 readline.parse_and_bind(rlcommand)
1544 1544
1545 1545 # Remove some chars from the delimiters list. If we encounter
1546 1546 # unicode chars, discard them.
1547 1547 delims = readline.get_completer_delims().encode("ascii", "ignore")
1548 1548 delims = delims.translate(None, self.readline_remove_delims)
1549 1549 delims = delims.replace(ESC_MAGIC, '')
1550 1550 readline.set_completer_delims(delims)
1551 1551 # otherwise we end up with a monster history after a while:
1552 1552 readline.set_history_length(self.history_length)
1553 1553 try:
1554 1554 #print '*** Reading readline history' # dbg
1555 1555 self.reload_history()
1556 1556 except IOError:
1557 1557 pass # It doesn't exist yet.
1558 1558
1559 1559 # Configure auto-indent for all platforms
1560 1560 self.set_autoindent(self.autoindent)
1561 1561
1562 1562 def set_next_input(self, s):
1563 1563 """ Sets the 'default' input string for the next command line.
1564 1564
1565 1565 Requires readline.
1566 1566
1567 1567 Example:
1568 1568
1569 1569 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1570 1570 [D:\ipython]|2> Hello Word_ # cursor is here
1571 1571 """
1572 1572
1573 1573 self.rl_next_input = s
1574 1574
1575 1575 # Maybe move this to the terminal subclass?
1576 1576 def pre_readline(self):
1577 1577 """readline hook to be used at the start of each line.
1578 1578
1579 1579 Currently it handles auto-indent only."""
1580 1580
1581 1581 if self.rl_do_indent:
1582 1582 self.readline.insert_text(self._indent_current_str())
1583 1583 if self.rl_next_input is not None:
1584 1584 self.readline.insert_text(self.rl_next_input)
1585 1585 self.rl_next_input = None
1586 1586
1587 1587 def _indent_current_str(self):
1588 1588 """return the current level of indentation as a string"""
1589 1589 return self.input_splitter.indent_spaces * ' '
1590 1590
1591 1591 #-------------------------------------------------------------------------
1592 1592 # Things related to text completion
1593 1593 #-------------------------------------------------------------------------
1594 1594
1595 1595 def init_completer(self):
1596 1596 """Initialize the completion machinery.
1597 1597
1598 1598 This creates completion machinery that can be used by client code,
1599 1599 either interactively in-process (typically triggered by the readline
1600 1600 library), programatically (such as in test suites) or out-of-prcess
1601 1601 (typically over the network by remote frontends).
1602 1602 """
1603 1603 from IPython.core.completer import IPCompleter
1604 1604 from IPython.core.completerlib import (module_completer,
1605 1605 magic_run_completer, cd_completer)
1606 1606
1607 1607 self.Completer = IPCompleter(self,
1608 1608 self.user_ns,
1609 1609 self.user_global_ns,
1610 1610 self.readline_omit__names,
1611 1611 self.alias_manager.alias_table,
1612 1612 self.has_readline)
1613 1613
1614 1614 # Add custom completers to the basic ones built into IPCompleter
1615 1615 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1616 1616 self.strdispatchers['complete_command'] = sdisp
1617 1617 self.Completer.custom_completers = sdisp
1618 1618
1619 1619 self.set_hook('complete_command', module_completer, str_key = 'import')
1620 1620 self.set_hook('complete_command', module_completer, str_key = 'from')
1621 1621 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1622 1622 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1623 1623
1624 1624 # Only configure readline if we truly are using readline. IPython can
1625 1625 # do tab-completion over the network, in GUIs, etc, where readline
1626 1626 # itself may be absent
1627 1627 if self.has_readline:
1628 1628 self.set_readline_completer()
1629 1629
1630 1630 def complete(self, text, line=None, cursor_pos=None):
1631 1631 """Return the completed text and a list of completions.
1632 1632
1633 1633 Parameters
1634 1634 ----------
1635 1635
1636 1636 text : string
1637 1637 A string of text to be completed on. It can be given as empty and
1638 1638 instead a line/position pair are given. In this case, the
1639 1639 completer itself will split the line like readline does.
1640 1640
1641 1641 line : string, optional
1642 1642 The complete line that text is part of.
1643 1643
1644 1644 cursor_pos : int, optional
1645 1645 The position of the cursor on the input line.
1646 1646
1647 1647 Returns
1648 1648 -------
1649 1649 text : string
1650 1650 The actual text that was completed.
1651 1651
1652 1652 matches : list
1653 1653 A sorted list with all possible completions.
1654 1654
1655 1655 The optional arguments allow the completion to take more context into
1656 1656 account, and are part of the low-level completion API.
1657 1657
1658 1658 This is a wrapper around the completion mechanism, similar to what
1659 1659 readline does at the command line when the TAB key is hit. By
1660 1660 exposing it as a method, it can be used by other non-readline
1661 1661 environments (such as GUIs) for text completion.
1662 1662
1663 1663 Simple usage example:
1664 1664
1665 1665 In [1]: x = 'hello'
1666 1666
1667 1667 In [2]: _ip.complete('x.l')
1668 1668 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1669 1669 """
1670 1670
1671 1671 # Inject names into __builtin__ so we can complete on the added names.
1672 1672 with self.builtin_trap:
1673 1673 return self.Completer.complete(text, line, cursor_pos)
1674 1674
1675 1675 def set_custom_completer(self, completer, pos=0):
1676 1676 """Adds a new custom completer function.
1677 1677
1678 1678 The position argument (defaults to 0) is the index in the completers
1679 1679 list where you want the completer to be inserted."""
1680 1680
1681 1681 newcomp = types.MethodType(completer,self.Completer)
1682 1682 self.Completer.matchers.insert(pos,newcomp)
1683 1683
1684 1684 def set_readline_completer(self):
1685 1685 """Reset readline's completer to be our own."""
1686 1686 self.readline.set_completer(self.Completer.rlcomplete)
1687 1687
1688 1688 def set_completer_frame(self, frame=None):
1689 1689 """Set the frame of the completer."""
1690 1690 if frame:
1691 1691 self.Completer.namespace = frame.f_locals
1692 1692 self.Completer.global_namespace = frame.f_globals
1693 1693 else:
1694 1694 self.Completer.namespace = self.user_ns
1695 1695 self.Completer.global_namespace = self.user_global_ns
1696 1696
1697 1697 #-------------------------------------------------------------------------
1698 1698 # Things related to magics
1699 1699 #-------------------------------------------------------------------------
1700 1700
1701 1701 def init_magics(self):
1702 1702 # FIXME: Move the color initialization to the DisplayHook, which
1703 1703 # should be split into a prompt manager and displayhook. We probably
1704 1704 # even need a centralize colors management object.
1705 1705 self.magic_colors(self.colors)
1706 1706 # History was moved to a separate module
1707 1707 from . import history
1708 1708 history.init_ipython(self)
1709 1709
1710 1710 def magic(self,arg_s):
1711 1711 """Call a magic function by name.
1712 1712
1713 1713 Input: a string containing the name of the magic function to call and
1714 1714 any additional arguments to be passed to the magic.
1715 1715
1716 1716 magic('name -opt foo bar') is equivalent to typing at the ipython
1717 1717 prompt:
1718 1718
1719 1719 In[1]: %name -opt foo bar
1720 1720
1721 1721 To call a magic without arguments, simply use magic('name').
1722 1722
1723 1723 This provides a proper Python function to call IPython's magics in any
1724 1724 valid Python code you can type at the interpreter, including loops and
1725 1725 compound statements.
1726 1726 """
1727 1727 args = arg_s.split(' ',1)
1728 1728 magic_name = args[0]
1729 1729 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1730 1730
1731 1731 try:
1732 1732 magic_args = args[1]
1733 1733 except IndexError:
1734 1734 magic_args = ''
1735 1735 fn = getattr(self,'magic_'+magic_name,None)
1736 1736 if fn is None:
1737 1737 error("Magic function `%s` not found." % magic_name)
1738 1738 else:
1739 1739 magic_args = self.var_expand(magic_args,1)
1740 1740 with nested(self.builtin_trap,):
1741 1741 result = fn(magic_args)
1742 1742 return result
1743 1743
1744 1744 def define_magic(self, magicname, func):
1745 1745 """Expose own function as magic function for ipython
1746 1746
1747 1747 def foo_impl(self,parameter_s=''):
1748 1748 'My very own magic!. (Use docstrings, IPython reads them).'
1749 1749 print 'Magic function. Passed parameter is between < >:'
1750 1750 print '<%s>' % parameter_s
1751 1751 print 'The self object is:',self
1752 1752
1753 1753 self.define_magic('foo',foo_impl)
1754 1754 """
1755 1755
1756 1756 import new
1757 1757 im = types.MethodType(func,self)
1758 1758 old = getattr(self, "magic_" + magicname, None)
1759 1759 setattr(self, "magic_" + magicname, im)
1760 1760 return old
1761 1761
1762 1762 #-------------------------------------------------------------------------
1763 1763 # Things related to macros
1764 1764 #-------------------------------------------------------------------------
1765 1765
1766 1766 def define_macro(self, name, themacro):
1767 1767 """Define a new macro
1768 1768
1769 1769 Parameters
1770 1770 ----------
1771 1771 name : str
1772 1772 The name of the macro.
1773 1773 themacro : str or Macro
1774 1774 The action to do upon invoking the macro. If a string, a new
1775 1775 Macro object is created by passing the string to it.
1776 1776 """
1777 1777
1778 1778 from IPython.core import macro
1779 1779
1780 1780 if isinstance(themacro, basestring):
1781 1781 themacro = macro.Macro(themacro)
1782 1782 if not isinstance(themacro, macro.Macro):
1783 1783 raise ValueError('A macro must be a string or a Macro instance.')
1784 1784 self.user_ns[name] = themacro
1785 1785
1786 1786 #-------------------------------------------------------------------------
1787 1787 # Things related to the running of system commands
1788 1788 #-------------------------------------------------------------------------
1789 1789
1790 1790 def system(self, cmd):
1791 1791 """Call the given cmd in a subprocess.
1792 1792
1793 1793 Parameters
1794 1794 ----------
1795 1795 cmd : str
1796 1796 Command to execute (can not end in '&', as bacground processes are
1797 1797 not supported.
1798 1798 """
1799 1799 # We do not support backgrounding processes because we either use
1800 1800 # pexpect or pipes to read from. Users can always just call
1801 1801 # os.system() if they really want a background process.
1802 1802 if cmd.endswith('&'):
1803 1803 raise OSError("Background processes not supported.")
1804 1804
1805 1805 return system(self.var_expand(cmd, depth=2))
1806 1806
1807 1807 def getoutput(self, cmd, split=True):
1808 1808 """Get output (possibly including stderr) from a subprocess.
1809 1809
1810 1810 Parameters
1811 1811 ----------
1812 1812 cmd : str
1813 1813 Command to execute (can not end in '&', as background processes are
1814 1814 not supported.
1815 1815 split : bool, optional
1816 1816
1817 1817 If True, split the output into an IPython SList. Otherwise, an
1818 1818 IPython LSString is returned. These are objects similar to normal
1819 1819 lists and strings, with a few convenience attributes for easier
1820 1820 manipulation of line-based output. You can use '?' on them for
1821 1821 details.
1822 1822 """
1823 1823 if cmd.endswith('&'):
1824 1824 raise OSError("Background processes not supported.")
1825 1825 out = getoutput(self.var_expand(cmd, depth=2))
1826 1826 if split:
1827 1827 out = SList(out.splitlines())
1828 1828 else:
1829 1829 out = LSString(out)
1830 1830 return out
1831 1831
1832 1832 #-------------------------------------------------------------------------
1833 1833 # Things related to aliases
1834 1834 #-------------------------------------------------------------------------
1835 1835
1836 1836 def init_alias(self):
1837 1837 self.alias_manager = AliasManager(shell=self, config=self.config)
1838 1838 self.ns_table['alias'] = self.alias_manager.alias_table,
1839 1839
1840 1840 #-------------------------------------------------------------------------
1841 1841 # Things related to extensions and plugins
1842 1842 #-------------------------------------------------------------------------
1843 1843
1844 1844 def init_extension_manager(self):
1845 1845 self.extension_manager = ExtensionManager(shell=self, config=self.config)
1846 1846
1847 1847 def init_plugin_manager(self):
1848 1848 self.plugin_manager = PluginManager(config=self.config)
1849 1849
1850 1850 #-------------------------------------------------------------------------
1851 1851 # Things related to payloads
1852 1852 #-------------------------------------------------------------------------
1853 1853
1854 1854 def init_payload(self):
1855 1855 self.payload_manager = PayloadManager(config=self.config)
1856 1856
1857 1857 #-------------------------------------------------------------------------
1858 1858 # Things related to the prefilter
1859 1859 #-------------------------------------------------------------------------
1860 1860
1861 1861 def init_prefilter(self):
1862 1862 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
1863 1863 # Ultimately this will be refactored in the new interpreter code, but
1864 1864 # for now, we should expose the main prefilter method (there's legacy
1865 1865 # code out there that may rely on this).
1866 1866 self.prefilter = self.prefilter_manager.prefilter_lines
1867 1867
1868 1868 def auto_rewrite_input(self, cmd):
1869 1869 """Print to the screen the rewritten form of the user's command.
1870 1870
1871 1871 This shows visual feedback by rewriting input lines that cause
1872 1872 automatic calling to kick in, like::
1873 1873
1874 1874 /f x
1875 1875
1876 1876 into::
1877 1877
1878 1878 ------> f(x)
1879 1879
1880 1880 after the user's input prompt. This helps the user understand that the
1881 1881 input line was transformed automatically by IPython.
1882 1882 """
1883 1883 rw = self.displayhook.prompt1.auto_rewrite() + cmd
1884 1884
1885 1885 try:
1886 1886 # plain ascii works better w/ pyreadline, on some machines, so
1887 1887 # we use it and only print uncolored rewrite if we have unicode
1888 1888 rw = str(rw)
1889 1889 print >> IPython.utils.io.Term.cout, rw
1890 1890 except UnicodeEncodeError:
1891 1891 print "------> " + cmd
1892 1892
1893 1893 #-------------------------------------------------------------------------
1894 1894 # Things related to extracting values/expressions from kernel and user_ns
1895 1895 #-------------------------------------------------------------------------
1896 1896
1897 1897 def _simple_error(self):
1898 1898 etype, value = sys.exc_info()[:2]
1899 1899 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
1900 1900
1901 1901 def user_variables(self, names):
1902 1902 """Get a list of variable names from the user's namespace.
1903 1903
1904 1904 Parameters
1905 1905 ----------
1906 1906 names : list of strings
1907 1907 A list of names of variables to be read from the user namespace.
1908 1908
1909 1909 Returns
1910 1910 -------
1911 1911 A dict, keyed by the input names and with the repr() of each value.
1912 1912 """
1913 1913 out = {}
1914 1914 user_ns = self.user_ns
1915 1915 for varname in names:
1916 1916 try:
1917 1917 value = repr(user_ns[varname])
1918 1918 except:
1919 1919 value = self._simple_error()
1920 1920 out[varname] = value
1921 1921 return out
1922 1922
1923 1923 def user_expressions(self, expressions):
1924 1924 """Evaluate a dict of expressions in the user's namespace.
1925 1925
1926 1926 Parameters
1927 1927 ----------
1928 1928 expressions : dict
1929 1929 A dict with string keys and string values. The expression values
1930 1930 should be valid Python expressions, each of which will be evaluated
1931 1931 in the user namespace.
1932 1932
1933 1933 Returns
1934 1934 -------
1935 1935 A dict, keyed like the input expressions dict, with the repr() of each
1936 1936 value.
1937 1937 """
1938 1938 out = {}
1939 1939 user_ns = self.user_ns
1940 1940 global_ns = self.user_global_ns
1941 1941 for key, expr in expressions.iteritems():
1942 1942 try:
1943 1943 value = repr(eval(expr, global_ns, user_ns))
1944 1944 except:
1945 1945 value = self._simple_error()
1946 1946 out[key] = value
1947 1947 return out
1948 1948
1949 1949 #-------------------------------------------------------------------------
1950 1950 # Things related to the running of code
1951 1951 #-------------------------------------------------------------------------
1952 1952
1953 1953 def ex(self, cmd):
1954 1954 """Execute a normal python statement in user namespace."""
1955 1955 with nested(self.builtin_trap,):
1956 1956 exec cmd in self.user_global_ns, self.user_ns
1957 1957
1958 1958 def ev(self, expr):
1959 1959 """Evaluate python expression expr in user namespace.
1960 1960
1961 1961 Returns the result of evaluation
1962 1962 """
1963 1963 with nested(self.builtin_trap,):
1964 1964 return eval(expr, self.user_global_ns, self.user_ns)
1965 1965
1966 1966 def safe_execfile(self, fname, *where, **kw):
1967 1967 """A safe version of the builtin execfile().
1968 1968
1969 1969 This version will never throw an exception, but instead print
1970 1970 helpful error messages to the screen. This only works on pure
1971 1971 Python files with the .py extension.
1972 1972
1973 1973 Parameters
1974 1974 ----------
1975 1975 fname : string
1976 1976 The name of the file to be executed.
1977 1977 where : tuple
1978 1978 One or two namespaces, passed to execfile() as (globals,locals).
1979 1979 If only one is given, it is passed as both.
1980 1980 exit_ignore : bool (False)
1981 1981 If True, then silence SystemExit for non-zero status (it is always
1982 1982 silenced for zero status, as it is so common).
1983 1983 """
1984 1984 kw.setdefault('exit_ignore', False)
1985 1985
1986 1986 fname = os.path.abspath(os.path.expanduser(fname))
1987 1987
1988 1988 # Make sure we have a .py file
1989 1989 if not fname.endswith('.py'):
1990 1990 warn('File must end with .py to be run using execfile: <%s>' % fname)
1991 1991
1992 1992 # Make sure we can open the file
1993 1993 try:
1994 1994 with open(fname) as thefile:
1995 1995 pass
1996 1996 except:
1997 1997 warn('Could not open file <%s> for safe execution.' % fname)
1998 1998 return
1999 1999
2000 2000 # Find things also in current directory. This is needed to mimic the
2001 2001 # behavior of running a script from the system command line, where
2002 2002 # Python inserts the script's directory into sys.path
2003 2003 dname = os.path.dirname(fname)
2004 2004
2005 2005 with prepended_to_syspath(dname):
2006 2006 try:
2007 2007 execfile(fname,*where)
2008 2008 except SystemExit, status:
2009 2009 # If the call was made with 0 or None exit status (sys.exit(0)
2010 2010 # or sys.exit() ), don't bother showing a traceback, as both of
2011 2011 # these are considered normal by the OS:
2012 2012 # > python -c'import sys;sys.exit(0)'; echo $?
2013 2013 # 0
2014 2014 # > python -c'import sys;sys.exit()'; echo $?
2015 2015 # 0
2016 2016 # For other exit status, we show the exception unless
2017 2017 # explicitly silenced, but only in short form.
2018 2018 if status.code not in (0, None) and not kw['exit_ignore']:
2019 2019 self.showtraceback(exception_only=True)
2020 2020 except:
2021 2021 self.showtraceback()
2022 2022
2023 2023 def safe_execfile_ipy(self, fname):
2024 2024 """Like safe_execfile, but for .ipy files with IPython syntax.
2025 2025
2026 2026 Parameters
2027 2027 ----------
2028 2028 fname : str
2029 2029 The name of the file to execute. The filename must have a
2030 2030 .ipy extension.
2031 2031 """
2032 2032 fname = os.path.abspath(os.path.expanduser(fname))
2033 2033
2034 2034 # Make sure we have a .py file
2035 2035 if not fname.endswith('.ipy'):
2036 2036 warn('File must end with .py to be run using execfile: <%s>' % fname)
2037 2037
2038 2038 # Make sure we can open the file
2039 2039 try:
2040 2040 with open(fname) as thefile:
2041 2041 pass
2042 2042 except:
2043 2043 warn('Could not open file <%s> for safe execution.' % fname)
2044 2044 return
2045 2045
2046 2046 # Find things also in current directory. This is needed to mimic the
2047 2047 # behavior of running a script from the system command line, where
2048 2048 # Python inserts the script's directory into sys.path
2049 2049 dname = os.path.dirname(fname)
2050 2050
2051 2051 with prepended_to_syspath(dname):
2052 2052 try:
2053 2053 with open(fname) as thefile:
2054 2054 # self.run_cell currently captures all exceptions
2055 2055 # raised in user code. It would be nice if there were
2056 2056 # versions of runlines, execfile that did raise, so
2057 2057 # we could catch the errors.
2058 2058 self.run_cell(thefile.read())
2059 2059 except:
2060 2060 self.showtraceback()
2061 2061 warn('Unknown failure executing file: <%s>' % fname)
2062 2062
2063 2063 def run_cell(self, cell):
2064 2064 """Run the contents of an entire multiline 'cell' of code.
2065 2065
2066 2066 The cell is split into separate blocks which can be executed
2067 2067 individually. Then, based on how many blocks there are, they are
2068 2068 executed as follows:
2069 2069
2070 2070 - A single block: 'single' mode.
2071 2071
2072 2072 If there's more than one block, it depends:
2073 2073
2074 2074 - if the last one is no more than two lines long, run all but the last
2075 2075 in 'exec' mode and the very last one in 'single' mode. This makes it
2076 2076 easy to type simple expressions at the end to see computed values. -
2077 2077 otherwise (last one is also multiline), run all in 'exec' mode
2078 2078
2079 2079 When code is executed in 'single' mode, :func:`sys.displayhook` fires,
2080 2080 results are displayed and output prompts are computed. In 'exec' mode,
2081 2081 no results are displayed unless :func:`print` is called explicitly;
2082 2082 this mode is more akin to running a script.
2083 2083
2084 2084 Parameters
2085 2085 ----------
2086 2086 cell : str
2087 2087 A single or multiline string.
2088 2088 """
2089 2089
2090 2090 # We need to break up the input into executable blocks that can be run
2091 2091 # in 'single' mode, to provide comfortable user behavior.
2092 2092 blocks = self.input_splitter.split_blocks(cell)
2093 2093
2094 2094 if not blocks:
2095 2095 return
2096 2096
2097 2097 # Store the 'ipython' version of the cell as well, since that's what
2098 2098 # needs to go into the translated history and get executed (the
2099 2099 # original cell may contain non-python syntax).
2100 2100 ipy_cell = ''.join(blocks)
2101 2101
2102 2102 # Store raw and processed history
2103 2103 self.history_manager.store_inputs(ipy_cell, cell)
2104 2104
2105 2105 self.logger.log(ipy_cell, cell)
2106 2106 # dbg code!!!
2107 2107 if 0:
2108 2108 def myapp(self, val): # dbg
2109 2109 import traceback as tb
2110 2110 stack = ''.join(tb.format_stack())
2111 2111 print 'Value:', val
2112 2112 print 'Stack:\n', stack
2113 2113 list.append(self, val)
2114 2114
2115 2115 import new
2116 2116 self.history_manager.input_hist_parsed.append = types.MethodType(myapp,
2117 2117 self.history_manager.input_hist_parsed)
2118 2118 # End dbg
2119 2119
2120 2120 # All user code execution must happen with our context managers active
2121 2121 with nested(self.builtin_trap, self.display_trap):
2122 2122
2123 2123 # Single-block input should behave like an interactive prompt
2124 2124 if len(blocks) == 1:
2125 2125 # since we return here, we need to update the execution count
2126 2126 out = self.run_one_block(blocks[0])
2127 2127 self.execution_count += 1
2128 2128 return out
2129 2129
2130 2130 # In multi-block input, if the last block is a simple (one-two
2131 2131 # lines) expression, run it in single mode so it produces output.
2132 2132 # Otherwise just feed the whole thing to run_code. This seems like
2133 2133 # a reasonable usability design.
2134 2134 last = blocks[-1]
2135 2135 last_nlines = len(last.splitlines())
2136 2136
2137 2137 # Note: below, whenever we call run_code, we must sync history
2138 2138 # ourselves, because run_code is NOT meant to manage history at all.
2139 2139 if last_nlines < 2:
2140 2140 # Here we consider the cell split between 'body' and 'last',
2141 2141 # store all history and execute 'body', and if successful, then
2142 2142 # proceed to execute 'last'.
2143 2143
2144 2144 # Get the main body to run as a cell
2145 2145 ipy_body = ''.join(blocks[:-1])
2146 2146 retcode = self.run_source(ipy_body, symbol='exec',
2147 2147 post_execute=False)
2148 2148 if retcode==0:
2149 2149 # And the last expression via runlines so it produces output
2150 2150 self.run_one_block(last)
2151 2151 else:
2152 2152 # Run the whole cell as one entity, storing both raw and
2153 2153 # processed input in history
2154 2154 self.run_source(ipy_cell, symbol='exec')
2155 2155
2156 2156 # Each cell is a *single* input, regardless of how many lines it has
2157 2157 self.execution_count += 1
2158 2158
2159 2159 def run_one_block(self, block):
2160 2160 """Run a single interactive block.
2161 2161
2162 2162 If the block is single-line, dynamic transformations are applied to it
2163 2163 (like automagics, autocall and alias recognition).
2164 2164 """
2165 2165 if len(block.splitlines()) <= 1:
2166 2166 out = self.run_single_line(block)
2167 2167 else:
2168 2168 out = self.run_code(block)
2169 2169 return out
2170 2170
2171 2171 def run_single_line(self, line):
2172 2172 """Run a single-line interactive statement.
2173 2173
2174 2174 This assumes the input has been transformed to IPython syntax by
2175 2175 applying all static transformations (those with an explicit prefix like
2176 2176 % or !), but it will further try to apply the dynamic ones.
2177 2177
2178 2178 It does not update history.
2179 2179 """
2180 2180 tline = self.prefilter_manager.prefilter_line(line)
2181 2181 return self.run_source(tline)
2182 2182
2183 2183 # PENDING REMOVAL: this method is slated for deletion, once our new
2184 2184 # input logic has been 100% moved to frontends and is stable.
2185 2185 def runlines(self, lines, clean=False):
2186 2186 """Run a string of one or more lines of source.
2187 2187
2188 2188 This method is capable of running a string containing multiple source
2189 2189 lines, as if they had been entered at the IPython prompt. Since it
2190 2190 exposes IPython's processing machinery, the given strings can contain
2191 2191 magic calls (%magic), special shell access (!cmd), etc.
2192 2192 """
2193 2193
2194 2194 if isinstance(lines, (list, tuple)):
2195 2195 lines = '\n'.join(lines)
2196 2196
2197 2197 if clean:
2198 2198 lines = self._cleanup_ipy_script(lines)
2199 2199
2200 2200 # We must start with a clean buffer, in case this is run from an
2201 2201 # interactive IPython session (via a magic, for example).
2202 2202 self.reset_buffer()
2203 2203 lines = lines.splitlines()
2204 2204
2205 2205 # Since we will prefilter all lines, store the user's raw input too
2206 2206 # before we apply any transformations
2207 2207 self.buffer_raw[:] = [ l+'\n' for l in lines]
2208 2208
2209 2209 more = False
2210 2210 prefilter_lines = self.prefilter_manager.prefilter_lines
2211 2211 with nested(self.builtin_trap, self.display_trap):
2212 2212 for line in lines:
2213 2213 # skip blank lines so we don't mess up the prompt counter, but
2214 2214 # do NOT skip even a blank line if we are in a code block (more
2215 2215 # is true)
2216 2216
2217 2217 if line or more:
2218 2218 more = self.push_line(prefilter_lines(line, more))
2219 2219 # IPython's run_source returns None if there was an error
2220 2220 # compiling the code. This allows us to stop processing
2221 2221 # right away, so the user gets the error message at the
2222 2222 # right place.
2223 2223 if more is None:
2224 2224 break
2225 2225 # final newline in case the input didn't have it, so that the code
2226 2226 # actually does get executed
2227 2227 if more:
2228 2228 self.push_line('\n')
2229 2229
2230 2230 def run_source(self, source, filename=None,
2231 2231 symbol='single', post_execute=True):
2232 2232 """Compile and run some source in the interpreter.
2233 2233
2234 2234 Arguments are as for compile_command().
2235 2235
2236 2236 One several things can happen:
2237 2237
2238 2238 1) The input is incorrect; compile_command() raised an
2239 2239 exception (SyntaxError or OverflowError). A syntax traceback
2240 2240 will be printed by calling the showsyntaxerror() method.
2241 2241
2242 2242 2) The input is incomplete, and more input is required;
2243 2243 compile_command() returned None. Nothing happens.
2244 2244
2245 2245 3) The input is complete; compile_command() returned a code
2246 2246 object. The code is executed by calling self.run_code() (which
2247 2247 also handles run-time exceptions, except for SystemExit).
2248 2248
2249 2249 The return value is:
2250 2250
2251 2251 - True in case 2
2252 2252
2253 2253 - False in the other cases, unless an exception is raised, where
2254 2254 None is returned instead. This can be used by external callers to
2255 2255 know whether to continue feeding input or not.
2256 2256
2257 2257 The return value can be used to decide whether to use sys.ps1 or
2258 2258 sys.ps2 to prompt the next line."""
2259 2259
2260 2260 # We need to ensure that the source is unicode from here on.
2261 2261 if type(source)==str:
2262 2262 usource = source.decode(self.stdin_encoding)
2263 2263 else:
2264 2264 usource = source
2265 2265
2266 2266 if 0: # dbg
2267 2267 print 'Source:', repr(source) # dbg
2268 2268 print 'USource:', repr(usource) # dbg
2269 2269 print 'type:', type(source) # dbg
2270 2270 print 'encoding', self.stdin_encoding # dbg
2271 2271
2272 2272 try:
2273 2273 code = self.compile(usource, symbol, self.execution_count)
2274 2274 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2275 2275 # Case 1
2276 2276 self.showsyntaxerror(filename)
2277 2277 return None
2278 2278
2279 2279 if code is None:
2280 2280 # Case 2
2281 2281 return True
2282 2282
2283 2283 # Case 3
2284 2284 # We store the code object so that threaded shells and
2285 2285 # custom exception handlers can access all this info if needed.
2286 2286 # The source corresponding to this can be obtained from the
2287 2287 # buffer attribute as '\n'.join(self.buffer).
2288 2288 self.code_to_run = code
2289 2289 # now actually execute the code object
2290 2290 if self.run_code(code, post_execute) == 0:
2291 2291 return False
2292 2292 else:
2293 2293 return None
2294 2294
2295 2295 # For backwards compatibility
2296 2296 runsource = run_source
2297 2297
2298 2298 def run_code(self, code_obj, post_execute=True):
2299 2299 """Execute a code object.
2300 2300
2301 2301 When an exception occurs, self.showtraceback() is called to display a
2302 2302 traceback.
2303 2303
2304 2304 Return value: a flag indicating whether the code to be run completed
2305 2305 successfully:
2306 2306
2307 2307 - 0: successful execution.
2308 2308 - 1: an error occurred.
2309 2309 """
2310 2310
2311 2311 # Set our own excepthook in case the user code tries to call it
2312 2312 # directly, so that the IPython crash handler doesn't get triggered
2313 2313 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2314 2314
2315 2315 # we save the original sys.excepthook in the instance, in case config
2316 2316 # code (such as magics) needs access to it.
2317 2317 self.sys_excepthook = old_excepthook
2318 2318 outflag = 1 # happens in more places, so it's easier as default
2319 2319 try:
2320 2320 try:
2321 2321 self.hooks.pre_run_code_hook()
2322 2322 #rprint('Running code') # dbg
2323 2323 exec code_obj in self.user_global_ns, self.user_ns
2324 2324 finally:
2325 2325 # Reset our crash handler in place
2326 2326 sys.excepthook = old_excepthook
2327 2327 except SystemExit:
2328 2328 self.reset_buffer()
2329 2329 self.showtraceback(exception_only=True)
2330 2330 warn("To exit: use any of 'exit', 'quit', %Exit or Ctrl-D.", level=1)
2331 2331 except self.custom_exceptions:
2332 2332 etype,value,tb = sys.exc_info()
2333 2333 self.CustomTB(etype,value,tb)
2334 2334 except:
2335 2335 self.showtraceback()
2336 2336 else:
2337 2337 outflag = 0
2338 2338 if softspace(sys.stdout, 0):
2339 2339 print
2340 2340
2341 2341 # Execute any registered post-execution functions. Here, any errors
2342 2342 # are reported only minimally and just on the terminal, because the
2343 2343 # main exception channel may be occupied with a user traceback.
2344 2344 # FIXME: we need to think this mechanism a little more carefully.
2345 2345 if post_execute:
2346 2346 for func in self._post_execute:
2347 2347 try:
2348 2348 func()
2349 2349 except:
2350 2350 head = '[ ERROR ] Evaluating post_execute function: %s' % \
2351 2351 func
2352 2352 print >> io.Term.cout, head
2353 2353 print >> io.Term.cout, self._simple_error()
2354 2354 print >> io.Term.cout, 'Removing from post_execute'
2355 2355 self._post_execute.remove(func)
2356 2356
2357 2357 # Flush out code object which has been run (and source)
2358 2358 self.code_to_run = None
2359 2359 return outflag
2360 2360
2361 2361 # For backwards compatibility
2362 2362 runcode = run_code
2363 2363
2364 2364 # PENDING REMOVAL: this method is slated for deletion, once our new
2365 2365 # input logic has been 100% moved to frontends and is stable.
2366 2366 def push_line(self, line):
2367 2367 """Push a line to the interpreter.
2368 2368
2369 2369 The line should not have a trailing newline; it may have
2370 2370 internal newlines. The line is appended to a buffer and the
2371 2371 interpreter's run_source() method is called with the
2372 2372 concatenated contents of the buffer as source. If this
2373 2373 indicates that the command was executed or invalid, the buffer
2374 2374 is reset; otherwise, the command is incomplete, and the buffer
2375 2375 is left as it was after the line was appended. The return
2376 2376 value is 1 if more input is required, 0 if the line was dealt
2377 2377 with in some way (this is the same as run_source()).
2378 2378 """
2379 2379
2380 2380 # autoindent management should be done here, and not in the
2381 2381 # interactive loop, since that one is only seen by keyboard input. We
2382 2382 # need this done correctly even for code run via runlines (which uses
2383 2383 # push).
2384 2384
2385 2385 #print 'push line: <%s>' % line # dbg
2386 2386 self.buffer.append(line)
2387 2387 full_source = '\n'.join(self.buffer)
2388 2388 more = self.run_source(full_source, self.filename)
2389 2389 if not more:
2390 2390 self.history_manager.store_inputs('\n'.join(self.buffer_raw),
2391 2391 full_source)
2392 2392 self.reset_buffer()
2393 2393 self.execution_count += 1
2394 2394 return more
2395 2395
2396 2396 def reset_buffer(self):
2397 2397 """Reset the input buffer."""
2398 2398 self.buffer[:] = []
2399 2399 self.buffer_raw[:] = []
2400 2400 self.input_splitter.reset()
2401 2401
2402 2402 # For backwards compatibility
2403 2403 resetbuffer = reset_buffer
2404 2404
2405 2405 def _is_secondary_block_start(self, s):
2406 2406 if not s.endswith(':'):
2407 2407 return False
2408 2408 if (s.startswith('elif') or
2409 2409 s.startswith('else') or
2410 2410 s.startswith('except') or
2411 2411 s.startswith('finally')):
2412 2412 return True
2413 2413
2414 2414 def _cleanup_ipy_script(self, script):
2415 2415 """Make a script safe for self.runlines()
2416 2416
2417 2417 Currently, IPython is lines based, with blocks being detected by
2418 2418 empty lines. This is a problem for block based scripts that may
2419 2419 not have empty lines after blocks. This script adds those empty
2420 2420 lines to make scripts safe for running in the current line based
2421 2421 IPython.
2422 2422 """
2423 2423 res = []
2424 2424 lines = script.splitlines()
2425 2425 level = 0
2426 2426
2427 2427 for l in lines:
2428 2428 lstripped = l.lstrip()
2429 2429 stripped = l.strip()
2430 2430 if not stripped:
2431 2431 continue
2432 2432 newlevel = len(l) - len(lstripped)
2433 2433 if level > 0 and newlevel == 0 and \
2434 2434 not self._is_secondary_block_start(stripped):
2435 2435 # add empty line
2436 2436 res.append('')
2437 2437 res.append(l)
2438 2438 level = newlevel
2439 2439
2440 2440 return '\n'.join(res) + '\n'
2441 2441
2442 2442 #-------------------------------------------------------------------------
2443 2443 # Things related to GUI support and pylab
2444 2444 #-------------------------------------------------------------------------
2445 2445
2446 2446 def enable_pylab(self, gui=None):
2447 2447 raise NotImplementedError('Implement enable_pylab in a subclass')
2448 2448
2449 2449 #-------------------------------------------------------------------------
2450 2450 # Utilities
2451 2451 #-------------------------------------------------------------------------
2452 2452
2453 2453 def var_expand(self,cmd,depth=0):
2454 2454 """Expand python variables in a string.
2455 2455
2456 2456 The depth argument indicates how many frames above the caller should
2457 2457 be walked to look for the local namespace where to expand variables.
2458 2458
2459 2459 The global namespace for expansion is always the user's interactive
2460 2460 namespace.
2461 2461 """
2462 2462
2463 2463 return str(ItplNS(cmd,
2464 2464 self.user_ns, # globals
2465 2465 # Skip our own frame in searching for locals:
2466 2466 sys._getframe(depth+1).f_locals # locals
2467 2467 ))
2468 2468
2469 2469 def mktempfile(self, data=None, prefix='ipython_edit_'):
2470 2470 """Make a new tempfile and return its filename.
2471 2471
2472 2472 This makes a call to tempfile.mktemp, but it registers the created
2473 2473 filename internally so ipython cleans it up at exit time.
2474 2474
2475 2475 Optional inputs:
2476 2476
2477 2477 - data(None): if data is given, it gets written out to the temp file
2478 2478 immediately, and the file is closed again."""
2479 2479
2480 2480 filename = tempfile.mktemp('.py', prefix)
2481 2481 self.tempfiles.append(filename)
2482 2482
2483 2483 if data:
2484 2484 tmp_file = open(filename,'w')
2485 2485 tmp_file.write(data)
2486 2486 tmp_file.close()
2487 2487 return filename
2488 2488
2489 2489 # TODO: This should be removed when Term is refactored.
2490 2490 def write(self,data):
2491 2491 """Write a string to the default output"""
2492 2492 io.Term.cout.write(data)
2493 2493
2494 2494 # TODO: This should be removed when Term is refactored.
2495 2495 def write_err(self,data):
2496 2496 """Write a string to the default error output"""
2497 2497 io.Term.cerr.write(data)
2498 2498
2499 2499 def ask_yes_no(self,prompt,default=True):
2500 2500 if self.quiet:
2501 2501 return True
2502 2502 return ask_yes_no(prompt,default)
2503 2503
2504 2504 def show_usage(self):
2505 2505 """Show a usage message"""
2506 2506 page.page(IPython.core.usage.interactive_usage)
2507 2507
2508 2508 #-------------------------------------------------------------------------
2509 2509 # Things related to IPython exiting
2510 2510 #-------------------------------------------------------------------------
2511 2511 def atexit_operations(self):
2512 2512 """This will be executed at the time of exit.
2513 2513
2514 2514 Cleanup operations and saving of persistent data that is done
2515 2515 unconditionally by IPython should be performed here.
2516 2516
2517 2517 For things that may depend on startup flags or platform specifics (such
2518 2518 as having readline or not), register a separate atexit function in the
2519 2519 code that has the appropriate information, rather than trying to
2520 2520 clutter
2521 2521 """
2522 2522 # Cleanup all tempfiles left around
2523 2523 for tfile in self.tempfiles:
2524 2524 try:
2525 2525 os.unlink(tfile)
2526 2526 except OSError:
2527 2527 pass
2528 2528
2529 2529 self.save_history()
2530 2530
2531 2531 # Clear all user namespaces to release all references cleanly.
2532 2532 self.reset()
2533 2533
2534 2534 # Run user hooks
2535 2535 self.hooks.shutdown_hook()
2536 2536
2537 2537 def cleanup(self):
2538 2538 self.restore_sys_module_state()
2539 2539
2540 2540
2541 2541 class InteractiveShellABC(object):
2542 2542 """An abstract base class for InteractiveShell."""
2543 2543 __metaclass__ = abc.ABCMeta
2544 2544
2545 2545 InteractiveShellABC.register(InteractiveShell)
@@ -1,618 +1,621 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Subclass of InteractiveShell for terminal based frontends."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2010 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 import __builtin__
18 18 import bdb
19 19 from contextlib import nested
20 20 import os
21 21 import re
22 22 import sys
23 23
24 24 from IPython.core.error import TryNext
25 25 from IPython.core.usage import interactive_usage, default_banner
26 26 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
27 27 from IPython.core.history import HistorySaveThread
28 28 from IPython.lib.inputhook import enable_gui
29 29 from IPython.lib.pylabtools import pylab_activate
30 30 from IPython.utils.terminal import toggle_set_term_title, set_term_title
31 31 from IPython.utils.process import abbrev_cwd
32 32 from IPython.utils.warn import warn
33 33 from IPython.utils.text import num_ini_spaces
34 34 from IPython.utils.traitlets import Int, Str, CBool
35 35
36 36
37 37 #-----------------------------------------------------------------------------
38 38 # Utilities
39 39 #-----------------------------------------------------------------------------
40 40
41 41
42 42 def get_default_editor():
43 43 try:
44 44 ed = os.environ['EDITOR']
45 45 except KeyError:
46 46 if os.name == 'posix':
47 47 ed = 'vi' # the only one guaranteed to be there!
48 48 else:
49 49 ed = 'notepad' # same in Windows!
50 50 return ed
51 51
52 52
53 53 # store the builtin raw_input globally, and use this always, in case user code
54 54 # overwrites it (like wx.py.PyShell does)
55 55 raw_input_original = raw_input
56 56
57 57
58 58 #-----------------------------------------------------------------------------
59 59 # Main class
60 60 #-----------------------------------------------------------------------------
61 61
62 62
63 63 class TerminalInteractiveShell(InteractiveShell):
64 64
65 65 autoedit_syntax = CBool(False, config=True)
66 66 banner = Str('')
67 67 banner1 = Str(default_banner, config=True)
68 68 banner2 = Str('', config=True)
69 69 confirm_exit = CBool(True, config=True)
70 70 # This display_banner only controls whether or not self.show_banner()
71 71 # is called when mainloop/interact are called. The default is False
72 72 # because for the terminal based application, the banner behavior
73 73 # is controlled by Global.display_banner, which IPythonApp looks at
74 74 # to determine if *it* should call show_banner() by hand or not.
75 75 display_banner = CBool(False) # This isn't configurable!
76 76 embedded = CBool(False)
77 77 embedded_active = CBool(False)
78 78 editor = Str(get_default_editor(), config=True)
79 79 pager = Str('less', config=True)
80 80
81 81 screen_length = Int(0, config=True)
82 82 term_title = CBool(False, config=True)
83 83
84 84 def __init__(self, config=None, ipython_dir=None, user_ns=None,
85 85 user_global_ns=None, custom_exceptions=((),None),
86 86 usage=None, banner1=None, banner2=None,
87 87 display_banner=None):
88 88
89 89 super(TerminalInteractiveShell, self).__init__(
90 90 config=config, ipython_dir=ipython_dir, user_ns=user_ns,
91 91 user_global_ns=user_global_ns, custom_exceptions=custom_exceptions
92 92 )
93 93 self.init_term_title()
94 94 self.init_usage(usage)
95 95 self.init_banner(banner1, banner2, display_banner)
96 96
97 97 #-------------------------------------------------------------------------
98 98 # Things related to the terminal
99 99 #-------------------------------------------------------------------------
100 100
101 101 @property
102 102 def usable_screen_length(self):
103 103 if self.screen_length == 0:
104 104 return 0
105 105 else:
106 106 num_lines_bot = self.separate_in.count('\n')+1
107 107 return self.screen_length - num_lines_bot
108 108
109 109 def init_term_title(self):
110 110 # Enable or disable the terminal title.
111 111 if self.term_title:
112 112 toggle_set_term_title(True)
113 113 set_term_title('IPython: ' + abbrev_cwd())
114 114 else:
115 115 toggle_set_term_title(False)
116 116
117 117 #-------------------------------------------------------------------------
118 118 # Things related to aliases
119 119 #-------------------------------------------------------------------------
120 120
121 121 def init_alias(self):
122 122 # The parent class defines aliases that can be safely used with any
123 123 # frontend.
124 124 super(TerminalInteractiveShell, self).init_alias()
125 125
126 126 # Now define aliases that only make sense on the terminal, because they
127 127 # need direct access to the console in a way that we can't emulate in
128 128 # GUI or web frontend
129 129 if os.name == 'posix':
130 130 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
131 131 ('man', 'man')]
132 132 elif os.name == 'nt':
133 133 aliases = [('cls', 'cls')]
134 134
135 135
136 136 for name, cmd in aliases:
137 137 self.alias_manager.define_alias(name, cmd)
138 138
139 139 #-------------------------------------------------------------------------
140 140 # Things related to the banner and usage
141 141 #-------------------------------------------------------------------------
142 142
143 143 def _banner1_changed(self):
144 144 self.compute_banner()
145 145
146 146 def _banner2_changed(self):
147 147 self.compute_banner()
148 148
149 149 def _term_title_changed(self, name, new_value):
150 150 self.init_term_title()
151 151
152 152 def init_banner(self, banner1, banner2, display_banner):
153 153 if banner1 is not None:
154 154 self.banner1 = banner1
155 155 if banner2 is not None:
156 156 self.banner2 = banner2
157 157 if display_banner is not None:
158 158 self.display_banner = display_banner
159 159 self.compute_banner()
160 160
161 161 def show_banner(self, banner=None):
162 162 if banner is None:
163 163 banner = self.banner
164 164 self.write(banner)
165 165
166 166 def compute_banner(self):
167 167 self.banner = self.banner1
168 168 if self.profile:
169 169 self.banner += '\nIPython profile: %s\n' % self.profile
170 170 if self.banner2:
171 171 self.banner += '\n' + self.banner2
172 172
173 173 def init_usage(self, usage=None):
174 174 if usage is None:
175 175 self.usage = interactive_usage
176 176 else:
177 177 self.usage = usage
178 178
179 179 #-------------------------------------------------------------------------
180 180 # Mainloop and code execution logic
181 181 #-------------------------------------------------------------------------
182 182
183 183 def mainloop(self, display_banner=None):
184 184 """Start the mainloop.
185 185
186 186 If an optional banner argument is given, it will override the
187 187 internally created default banner.
188 188 """
189 189
190 190 with nested(self.builtin_trap, self.display_trap):
191 191
192 192 # if you run stuff with -c <cmd>, raw hist is not updated
193 193 # ensure that it's in sync
194 194 self.history_manager.sync_inputs()
195 195
196 196 while 1:
197 197 try:
198 198 self.interact(display_banner=display_banner)
199 199 #self.interact_with_readline()
200 200 # XXX for testing of a readline-decoupled repl loop, call
201 201 # interact_with_readline above
202 202 break
203 203 except KeyboardInterrupt:
204 204 # this should not be necessary, but KeyboardInterrupt
205 205 # handling seems rather unpredictable...
206 206 self.write("\nKeyboardInterrupt in interact()\n")
207 207
208 208 def interact(self, display_banner=None):
209 209 """Closely emulate the interactive Python console."""
210 210
211 211 # batch run -> do not interact
212 212 if self.exit_now:
213 213 return
214 214
215 215 if display_banner is None:
216 216 display_banner = self.display_banner
217 217 if display_banner:
218 218 self.show_banner()
219 219
220 220 more = False
221 221
222 222 # Mark activity in the builtins
223 223 __builtin__.__dict__['__IPYTHON__active'] += 1
224 224
225 225 if self.has_readline:
226 226 self.readline_startup_hook(self.pre_readline)
227 227 # exit_now is set by a call to %Exit or %Quit, through the
228 228 # ask_exit callback.
229 229
230 230 while not self.exit_now:
231 231 self.hooks.pre_prompt_hook()
232 232 if more:
233 233 try:
234 234 prompt = self.hooks.generate_prompt(True)
235 235 except:
236 236 self.showtraceback()
237 237 if self.autoindent:
238 238 self.rl_do_indent = True
239 239
240 240 else:
241 241 try:
242 242 prompt = self.hooks.generate_prompt(False)
243 243 except:
244 244 self.showtraceback()
245 245 try:
246 246 line = self.raw_input(prompt)
247 247 if self.exit_now:
248 248 # quick exit on sys.std[in|out] close
249 249 break
250 250 if self.autoindent:
251 251 self.rl_do_indent = False
252 252
253 253 except KeyboardInterrupt:
254 254 #double-guard against keyboardinterrupts during kbdint handling
255 255 try:
256 256 self.write('\nKeyboardInterrupt\n')
257 257 self.resetbuffer()
258 258 more = False
259 259 except KeyboardInterrupt:
260 260 pass
261 261 except EOFError:
262 262 if self.autoindent:
263 263 self.rl_do_indent = False
264 264 if self.has_readline:
265 265 self.readline_startup_hook(None)
266 266 self.write('\n')
267 267 self.exit()
268 268 except bdb.BdbQuit:
269 269 warn('The Python debugger has exited with a BdbQuit exception.\n'
270 270 'Because of how pdb handles the stack, it is impossible\n'
271 271 'for IPython to properly format this particular exception.\n'
272 272 'IPython will resume normal operation.')
273 273 except:
274 274 # exceptions here are VERY RARE, but they can be triggered
275 275 # asynchronously by signal handlers, for example.
276 276 self.showtraceback()
277 277 else:
278 278 self.input_splitter.push(line)
279 279 more = self.input_splitter.push_accepts_more()
280 280 if (self.SyntaxTB.last_syntax_error and
281 281 self.autoedit_syntax):
282 282 self.edit_syntax_error()
283 283 if not more:
284 284 source_raw = self.input_splitter.source_raw_reset()[1]
285 285 self.run_cell(source_raw)
286 286
287 287 # We are off again...
288 288 __builtin__.__dict__['__IPYTHON__active'] -= 1
289 289
290 290 # Turn off the exit flag, so the mainloop can be restarted if desired
291 291 self.exit_now = False
292 292
293 293 def raw_input(self, prompt='', continue_prompt=False):
294 294 """Write a prompt and read a line.
295 295
296 296 The returned line does not include the trailing newline.
297 297 When the user enters the EOF key sequence, EOFError is raised.
298 298
299 299 Optional inputs:
300 300
301 301 - prompt(''): a string to be printed to prompt the user.
302 302
303 303 - continue_prompt(False): whether this line is the first one or a
304 304 continuation in a sequence of inputs.
305 305 """
306 306 # Code run by the user may have modified the readline completer state.
307 307 # We must ensure that our completer is back in place.
308 308
309 309 if self.has_readline:
310 310 self.set_readline_completer()
311 311
312 312 try:
313 313 line = raw_input_original(prompt).decode(self.stdin_encoding)
314 314 except ValueError:
315 315 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
316 316 " or sys.stdout.close()!\nExiting IPython!")
317 317 self.ask_exit()
318 318 return ""
319 319
320 320 # Try to be reasonably smart about not re-indenting pasted input more
321 321 # than necessary. We do this by trimming out the auto-indent initial
322 322 # spaces, if the user's actual input started itself with whitespace.
323 323 if self.autoindent:
324 324 if num_ini_spaces(line) > self.indent_current_nsp:
325 325 line = line[self.indent_current_nsp:]
326 326 self.indent_current_nsp = 0
327 327
328 328 # store the unfiltered input before the user has any chance to modify
329 329 # it.
330 330 if line.strip():
331 331 if continue_prompt:
332 332 if self.has_readline and self.readline_use:
333 333 histlen = self.readline.get_current_history_length()
334 334 if histlen > 1:
335 335 newhist = self.history_manager.input_hist_raw[-1].rstrip()
336 336 self.readline.remove_history_item(histlen-1)
337 337 self.readline.replace_history_item(histlen-2,
338 338 newhist.encode(self.stdin_encoding))
339 339 else:
340 340 self.history_manager.input_hist_raw.append('%s\n' % line)
341 341 elif not continue_prompt:
342 342 self.history_manager.input_hist_raw.append('\n')
343 343 try:
344 344 lineout = self.prefilter_manager.prefilter_lines(line,continue_prompt)
345 345 except:
346 346 # blanket except, in case a user-defined prefilter crashes, so it
347 347 # can't take all of ipython with it.
348 348 self.showtraceback()
349 349 return ''
350 350 else:
351 351 return lineout
352 352
353 353
354 354 def raw_input(self, prompt=''):
355 355 """Write a prompt and read a line.
356 356
357 357 The returned line does not include the trailing newline.
358 358 When the user enters the EOF key sequence, EOFError is raised.
359 359
360 360 Optional inputs:
361 361
362 362 - prompt(''): a string to be printed to prompt the user.
363 363
364 364 - continue_prompt(False): whether this line is the first one or a
365 365 continuation in a sequence of inputs.
366 366 """
367 367 # Code run by the user may have modified the readline completer state.
368 368 # We must ensure that our completer is back in place.
369 369
370 370 if self.has_readline:
371 371 self.set_readline_completer()
372 372
373 373 try:
374 374 line = raw_input_original(prompt).decode(self.stdin_encoding)
375 375 except ValueError:
376 376 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
377 377 " or sys.stdout.close()!\nExiting IPython!")
378 378 self.ask_exit()
379 379 return ""
380 380
381 381 # Try to be reasonably smart about not re-indenting pasted input more
382 382 # than necessary. We do this by trimming out the auto-indent initial
383 383 # spaces, if the user's actual input started itself with whitespace.
384 384 if self.autoindent:
385 385 if num_ini_spaces(line) > self.indent_current_nsp:
386 386 line = line[self.indent_current_nsp:]
387 387 self.indent_current_nsp = 0
388 388
389 389 return line
390 390
391 391 #-------------------------------------------------------------------------
392 392 # Methods to support auto-editing of SyntaxErrors.
393 393 #-------------------------------------------------------------------------
394 394
395 395 def edit_syntax_error(self):
396 396 """The bottom half of the syntax error handler called in the main loop.
397 397
398 398 Loop until syntax error is fixed or user cancels.
399 399 """
400 400
401 401 while self.SyntaxTB.last_syntax_error:
402 402 # copy and clear last_syntax_error
403 403 err = self.SyntaxTB.clear_err_state()
404 404 if not self._should_recompile(err):
405 405 return
406 406 try:
407 407 # may set last_syntax_error again if a SyntaxError is raised
408 408 self.safe_execfile(err.filename,self.user_ns)
409 409 except:
410 410 self.showtraceback()
411 411 else:
412 412 try:
413 413 f = file(err.filename)
414 414 try:
415 415 # This should be inside a display_trap block and I
416 416 # think it is.
417 417 sys.displayhook(f.read())
418 418 finally:
419 419 f.close()
420 420 except:
421 421 self.showtraceback()
422 422
423 423 def _should_recompile(self,e):
424 424 """Utility routine for edit_syntax_error"""
425 425
426 426 if e.filename in ('<ipython console>','<input>','<string>',
427 427 '<console>','<BackgroundJob compilation>',
428 428 None):
429 429
430 430 return False
431 431 try:
432 432 if (self.autoedit_syntax and
433 433 not self.ask_yes_no('Return to editor to correct syntax error? '
434 434 '[Y/n] ','y')):
435 435 return False
436 436 except EOFError:
437 437 return False
438 438
439 439 def int0(x):
440 440 try:
441 441 return int(x)
442 442 except TypeError:
443 443 return 0
444 444 # always pass integer line and offset values to editor hook
445 445 try:
446 446 self.hooks.fix_error_editor(e.filename,
447 447 int0(e.lineno),int0(e.offset),e.msg)
448 448 except TryNext:
449 449 warn('Could not open editor')
450 450 return False
451 451 return True
452 452
453 453 #-------------------------------------------------------------------------
454 454 # Things related to GUI support and pylab
455 455 #-------------------------------------------------------------------------
456 456
457 457 def enable_pylab(self, gui=None):
458 458 """Activate pylab support at runtime.
459 459
460 460 This turns on support for matplotlib, preloads into the interactive
461 461 namespace all of numpy and pylab, and configures IPython to correcdtly
462 462 interact with the GUI event loop. The GUI backend to be used can be
463 463 optionally selected with the optional :param:`gui` argument.
464 464
465 465 Parameters
466 466 ----------
467 467 gui : optional, string
468 468
469 469 If given, dictates the choice of matplotlib GUI backend to use
470 470 (should be one of IPython's supported backends, 'tk', 'qt', 'wx' or
471 471 'gtk'), otherwise we use the default chosen by matplotlib (as
472 472 dictated by the matplotlib build-time options plus the user's
473 473 matplotlibrc configuration file).
474 474 """
475 475 # We want to prevent the loading of pylab to pollute the user's
476 476 # namespace as shown by the %who* magics, so we execute the activation
477 477 # code in an empty namespace, and we update *both* user_ns and
478 478 # user_ns_hidden with this information.
479 479 ns = {}
480 480 gui = pylab_activate(ns, gui)
481 481 self.user_ns.update(ns)
482 482 self.user_ns_hidden.update(ns)
483 483 # Now we must activate the gui pylab wants to use, and fix %run to take
484 484 # plot updates into account
485 485 enable_gui(gui)
486 486 self.magic_run = self._pylab_magic_run
487 487
488 488 #-------------------------------------------------------------------------
489 489 # Things related to exiting
490 490 #-------------------------------------------------------------------------
491 491
492 492 def ask_exit(self):
493 493 """ Ask the shell to exit. Can be overiden and used as a callback. """
494 494 self.exit_now = True
495 495
496 496 def exit(self):
497 497 """Handle interactive exit.
498 498
499 499 This method calls the ask_exit callback."""
500 500 if self.confirm_exit:
501 501 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
502 502 self.shell.history_thread.exit_now=True
503 self.shell.history_thread.cond.acquire()
504 self.shell.history_thread.cond.notify()
505 self.shell.history_thread.cond.release()
503 506 self.ask_exit()
504 507 else:
505 self.shell.history_thread = HistorySaveThread(self.shell, 10, False)
508 self.shell.history_thread = HistorySaveThread(self.shell, 60, False)
506 509 self.shell.history_thread.start()
507 510 self.ask_exit()
508 511
509 512 #------------------------------------------------------------------------
510 513 # Magic overrides
511 514 #------------------------------------------------------------------------
512 515 # Once the base class stops inheriting from magic, this code needs to be
513 516 # moved into a separate machinery as well. For now, at least isolate here
514 517 # the magics which this class needs to implement differently from the base
515 518 # class, or that are unique to it.
516 519
517 520 def magic_autoindent(self, parameter_s = ''):
518 521 """Toggle autoindent on/off (if available)."""
519 522
520 523 self.shell.set_autoindent()
521 524 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
522 525
523 526 def magic_cpaste(self, parameter_s=''):
524 527 """Paste & execute a pre-formatted code block from clipboard.
525 528
526 529 You must terminate the block with '--' (two minus-signs) alone on the
527 530 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
528 531 is the new sentinel for this operation)
529 532
530 533 The block is dedented prior to execution to enable execution of method
531 534 definitions. '>' and '+' characters at the beginning of a line are
532 535 ignored, to allow pasting directly from e-mails, diff files and
533 536 doctests (the '...' continuation prompt is also stripped). The
534 537 executed block is also assigned to variable named 'pasted_block' for
535 538 later editing with '%edit pasted_block'.
536 539
537 540 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
538 541 This assigns the pasted block to variable 'foo' as string, without
539 542 dedenting or executing it (preceding >>> and + is still stripped)
540 543
541 544 '%cpaste -r' re-executes the block previously entered by cpaste.
542 545
543 546 Do not be alarmed by garbled output on Windows (it's a readline bug).
544 547 Just press enter and type -- (and press enter again) and the block
545 548 will be what was just pasted.
546 549
547 550 IPython statements (magics, shell escapes) are not supported (yet).
548 551
549 552 See also
550 553 --------
551 554 paste: automatically pull code from clipboard.
552 555 """
553 556
554 557 opts,args = self.parse_options(parameter_s,'rs:',mode='string')
555 558 par = args.strip()
556 559 if opts.has_key('r'):
557 560 self._rerun_pasted()
558 561 return
559 562
560 563 sentinel = opts.get('s','--')
561 564
562 565 block = self._strip_pasted_lines_for_code(
563 566 self._get_pasted_lines(sentinel))
564 567
565 568 self._execute_block(block, par)
566 569
567 570 def magic_paste(self, parameter_s=''):
568 571 """Paste & execute a pre-formatted code block from clipboard.
569 572
570 573 The text is pulled directly from the clipboard without user
571 574 intervention and printed back on the screen before execution (unless
572 575 the -q flag is given to force quiet mode).
573 576
574 577 The block is dedented prior to execution to enable execution of method
575 578 definitions. '>' and '+' characters at the beginning of a line are
576 579 ignored, to allow pasting directly from e-mails, diff files and
577 580 doctests (the '...' continuation prompt is also stripped). The
578 581 executed block is also assigned to variable named 'pasted_block' for
579 582 later editing with '%edit pasted_block'.
580 583
581 584 You can also pass a variable name as an argument, e.g. '%paste foo'.
582 585 This assigns the pasted block to variable 'foo' as string, without
583 586 dedenting or executing it (preceding >>> and + is still stripped)
584 587
585 588 Options
586 589 -------
587 590
588 591 -r: re-executes the block previously entered by cpaste.
589 592
590 593 -q: quiet mode: do not echo the pasted text back to the terminal.
591 594
592 595 IPython statements (magics, shell escapes) are not supported (yet).
593 596
594 597 See also
595 598 --------
596 599 cpaste: manually paste code into terminal until you mark its end.
597 600 """
598 601 opts,args = self.parse_options(parameter_s,'rq',mode='string')
599 602 par = args.strip()
600 603 if opts.has_key('r'):
601 604 self._rerun_pasted()
602 605 return
603 606
604 607 text = self.shell.hooks.clipboard_get()
605 608 block = self._strip_pasted_lines_for_code(text.splitlines())
606 609
607 610 # By default, echo back to terminal unless quiet mode is requested
608 611 if not opts.has_key('q'):
609 612 write = self.shell.write
610 613 write(self.shell.pycolorize(block))
611 614 if not block.endswith('\n'):
612 615 write('\n')
613 616 write("## -- End pasted text --\n")
614 617
615 618 self._execute_block(block, par)
616 619
617 620
618 621 InteractiveShellABC.register(TerminalInteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now